@dotit/core 1.0.0

package/dist/merge.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeData = mergeData;
+exports.parseAndMerge = parseAndMerge;
+const parser_1 = require("./parser");
+const RUNTIME_VARIABLES = new Set(["page", "pages"]);
+const SYSTEM_VARIABLES = new Set(["timestamp", "date", "year"]);
+const DANGEROUS_PATH_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+const MAX_PATH_DEPTH = 20;
+function getByPath(obj, path) {
+    const keys = path.split(".");
+    if (keys.length > MAX_PATH_DEPTH)
+        return undefined;
+    return keys.reduce((current, key) => {
+        if (current === null || current === undefined)
+            return undefined;
+        if (DANGEROUS_PATH_KEYS.has(key))
+            return undefined;
+        if (Array.isArray(current)) {
+            const idx = Number(key);
+            if (!isNaN(idx) && idx >= 0 && idx < current.length)
+                return current[idx];
+            return undefined;
+        }
+        if (typeof current === "object") {
+            return Object.prototype.hasOwnProperty.call(current, key)
+                ? current[key]
+                : undefined;
+        }
+        return undefined;
+    }, obj);
+}
+function getSystemVariable(key) {
+    switch (key) {
+        case "timestamp":
+            return new Date().toISOString();
+        case "date":
+            return new Date().toLocaleDateString();
+        case "year":
+            return String(new Date().getFullYear());
+        default:
+            return undefined;
+    }
+}
+function resolveString(str, data, agentName) {
+    if (!str.includes("{{"))
+        return { resolved: str, hasUnresolved: false };
+    let hasUnresolved = false;
+    const resolved = str.replace(/\{\{([^}]+)\}\}/g, (match, rawPath) => {
+        const path = rawPath.trim();
+        if (path.length > 200) {
+            hasUnresolved = true;
+            return match;
+        }
+        if (RUNTIME_VARIABLES.has(path))
+            return match;
+        if (SYSTEM_VARIABLES.has(path)) {
+            const sysVal = getSystemVariable(path);
+            if (sysVal !== undefined)
+                return sysVal;
+        }
+        if (path === "agent") {
+            if (agentName)
+                return agentName;
+            hasUnresolved = true;
+            return match;
+        }
+        const value = getByPath(data, path);
+        if (value !== undefined && value !== null)
+            return String(value);
+        hasUnresolved = true;
+        return MISSING_MODE === "blank" ? "" : match;
+    });
+    return { resolved, hasUnresolved };
+}
+let MISSING_MODE = "keep";
+function resolveBlock(block, data, agentName) {
+    const newBlock = { ...block };
+    let blockHasUnresolved = false;
+    if (newBlock.content) {
+        const { resolved, hasUnresolved } = resolveString(newBlock.content, data, agentName);
+        newBlock.content = resolved;
+        if (hasUnresolved)
+            blockHasUnresolved = true;
+    }
+    if (newBlock.originalContent) {
+        const { resolved } = resolveString(newBlock.originalContent, data, agentName);
+        newBlock.originalContent = resolved;
+    }
+    if (newBlock.properties) {
+        const newProps = {};
+        for (const [key, val] of Object.entries(newBlock.properties)) {
+            if (typeof val === "string") {
+                const { resolved, hasUnresolved } = resolveString(val, data, agentName);
+                newProps[key] = resolved;
+                if (hasUnresolved)
+                    blockHasUnresolved = true;
+            }
+            else {
+                newProps[key] = val;
+            }
+        }
+        newBlock.properties = newProps;
+    }
+    if (blockHasUnresolved) {
+        if (!newBlock.properties)
+            newBlock.properties = {};
+        newBlock.properties.unresolved = 1;
+    }
+    if (newBlock.children) {
+        newBlock.children = newBlock.children.map((child) => resolveBlock(child, data, agentName));
+    }
+    if (newBlock.table) {
+        newBlock.table = {
+            headers: newBlock.table.headers?.map((h) => {
+                const { resolved } = resolveString(h, data, agentName);
+                return resolved;
+            }),
+            rows: newBlock.table.rows.map((row) => row.map((cell) => {
+                const { resolved } = resolveString(cell, data, agentName);
+                return resolved;
+            })),
+        };
+    }
+    if (newBlock.inline) {
+        newBlock.inline = newBlock.inline.map((node) => {
+            const newNode = { ...node };
+            if ("value" in newNode && typeof newNode.value === "string") {
+                const { resolved } = resolveString(newNode.value, data, agentName);
+                newNode.value = resolved;
+            }
+            if ("href" in newNode && typeof newNode.href === "string") {
+                const { resolved } = resolveString(newNode.href, data, agentName);
+                newNode.href = resolved;
+            }
+            return newNode;
+        });
+    }
+    return newBlock;
+}
+function singularize(name) {
+    if (name.endsWith("ies"))
+        return name.slice(0, -3) + "y";
+    if (name.endsWith("s"))
+        return name.slice(0, -1);
+    return name;
+}
+function expandEachRows(blocks, data, agentName) {
+    const result = [];
+    for (const block of blocks) {
+        if (block.type !== "table" ||
+            !block.table?.headers ||
+            block.table.headers.length === 0) {
+            if (block.children && block.children.length > 0) {
+                result.push({
+                    ...block,
+                    children: expandEachRows(block.children, data, agentName),
+                });
+            }
+            else {
+                result.push(block);
+            }
+            continue;
+        }
+        const headers = block.table.headers;
+        const lastHeader = headers[headers.length - 1].trim();
+        const eachMatch = lastHeader.match(/^each:\s*(.+)$/i);
+        if (!eachMatch) {
+            result.push(block);
+            continue;
+        }
+        const eachDirective = eachMatch[1].trim();
+        let arrayName;
+        let loopVar;
+        if (eachDirective.includes(" as ")) {
+            const parts = eachDirective.split(" as ");
+            arrayName = parts[0].trim();
+            loopVar = parts[1].trim();
+        }
+        else {
+            arrayName = eachDirective;
+            loopVar = singularize(arrayName);
+        }
+        const items = getByPath(data, arrayName);
+        const cleanHeaders = headers.slice(0, -1);
+        if (!Array.isArray(items) || items.length === 0) {
+            result.push({
+                ...block,
+                table: {
+                    headers: cleanHeaders,
+                    rows: [],
+                },
+            });
+            continue;
+        }
+        const templateRow = block.table.rows[0];
+        if (!templateRow) {
+            result.push({
+                ...block,
+                table: {
+                    headers: cleanHeaders,
+                    rows: [],
+                },
+            });
+            continue;
+        }
+        const expandedRows = [];
+        for (const item of items) {
+            const itemData = { ...data, [loopVar]: item };
+            const expandedRow = templateRow.map((cell) => {
+                const { resolved } = resolveString(cell, itemData, agentName);
+                return resolved;
+            });
+            expandedRows.push(expandedRow);
+        }
+        result.push({
+            ...block,
+            table: {
+                headers: cleanHeaders,
+                rows: expandedRows,
+            },
+        });
+    }
+    return result;
+}
+function mergeData(template, data, options) {
+    if (!template || !template.blocks)
+        return template;
+    if (!data || typeof data !== "object")
+        return template;
+    MISSING_MODE = options?.missing ?? "keep";
+    const agentName = template.metadata?.agent;
+    const expandedBlocks = expandEachRows(template.blocks, data, agentName);
+    const newBlocks = expandedBlocks.map((block) => resolveBlock(block, data, agentName));
+    let newMetadata = template.metadata ? { ...template.metadata } : undefined;
+    if (newMetadata) {
+        if (newMetadata.title) {
+            const { resolved } = resolveString(newMetadata.title, data, agentName);
+            newMetadata.title = resolved;
+        }
+        if (newMetadata.summary) {
+            const { resolved } = resolveString(newMetadata.summary, data, agentName);
+            newMetadata.summary = resolved;
+        }
+    }
+    return {
+        ...template,
+        blocks: newBlocks,
+        metadata: newMetadata,
+    };
+}
+function parseAndMerge(source, data, options) {
+    const template = (0, parser_1.parseIntentText)(source);
+    return mergeData(template, data, options);
+}

package/dist/parser.d.ts

@@ -0,0 +1,29 @@
+import { IntentDocument, ParseOptions } from "./types";
+export declare function _resetIdCounter(): void;
+export declare function detectHistoryBoundary(lines: string[]): number;
+export declare function parseIntentText(fileContent: string, options?: ParseOptions): IntentDocument;
+export interface SafeParseOptions {
+    unknownKeyword: "note" | "skip" | "throw";
+    maxBlocks: number;
+    maxLineLength: number;
+    strict: boolean;
+}
+export declare const DEFAULT_SAFE_PARSE_OPTIONS: SafeParseOptions;
+export interface ParseWarning {
+    line: number;
+    message: string;
+    code: string;
+    original: string;
+}
+export interface ParseError {
+    line: number;
+    message: string;
+    code: string;
+    original: string;
+}
+export interface SafeParseResult {
+    document: IntentDocument;
+    warnings: ParseWarning[];
+    errors: ParseError[];
+}
+export declare function parseIntentTextSafe(source: string, options?: Partial<SafeParseOptions>): SafeParseResult;