@dotit/core 1.0.0

package/dist/query.d.ts

@@ -0,0 +1,32 @@
+import { IntentDocument, IntentBlock } from "./types";
+export interface QueryClause {
+    field: string;
+    operator: "=" | "!=" | "<" | ">" | "<=" | ">=" | "contains" | "startsWith" | "exists";
+    value?: string | number | boolean;
+}
+export interface QuerySort {
+    field: string;
+    direction: "asc" | "desc";
+}
+export interface QueryOptions {
+    where?: QueryClause[];
+    sort?: QuerySort[];
+    limit?: number;
+    offset?: number;
+}
+export interface QueryResult {
+    blocks: IntentBlock[];
+    total: number;
+    matched: number;
+}
+export declare function parseQuery(queryString: string): QueryOptions;
+export declare function queryBlocks(document: IntentDocument, options: QueryOptions | string): QueryResult;
+export declare function formatQueryResult(result: QueryResult, format?: "json" | "table" | "simple"): string;
+export interface SimpleQueryOptions {
+    type?: string | string[];
+    content?: string | RegExp;
+    properties?: Record<string, string | RegExp>;
+    section?: string | RegExp;
+    limit?: number;
+}
+export declare function queryDocument(doc: IntentDocument, query?: SimpleQueryOptions): IntentBlock[];

package/dist/query.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuery = parseQuery;
+exports.queryBlocks = queryBlocks;
+exports.formatQueryResult = formatQueryResult;
+exports.queryDocument = queryDocument;
+const utils_1 = require("./utils");
+function parseQuery(queryString) {
+    const options = { where: [], sort: [] };
+    if (typeof queryString !== "string" || queryString.length === 0)
+        return options;
+    const capped = queryString.length > 10000 ? queryString.slice(0, 10000) : queryString;
+    const parts = capped.trim().split(/\s+/);
+    for (const part of parts) {
+        if (part.startsWith("sort:")) {
+            const sortMatch = part.match(/^sort:([^:]+)(?::(asc|desc))?$/i);
+            if (sortMatch) {
+                options.sort.push({
+                    field: sortMatch[1],
+                    direction: sortMatch[2] || "asc",
+                });
+            }
+            continue;
+        }
+        if (part.startsWith("limit:")) {
+            const limitMatch = part.match(/^limit:(\d+)$/i);
+            if (limitMatch) {
+                options.limit = parseInt(limitMatch[1], 10);
+            }
+            continue;
+        }
+        if (part.startsWith("offset:")) {
+            const offsetMatch = part.match(/^offset:(\d+)$/i);
+            if (offsetMatch) {
+                options.offset = parseInt(offsetMatch[1], 10);
+            }
+            continue;
+        }
+        const clauseMatch = part.match(/^([^:=<>!?]+)(=|!=|<=|>=|<|>|:contains|:startsWith|\?)(.*)$/);
+        if (clauseMatch) {
+            const field = clauseMatch[1];
+            const op = clauseMatch[2];
+            const val = clauseMatch[3];
+            let operator;
+            switch (op) {
+                case "=":
+                    operator = "=";
+                    break;
+                case "!=":
+                    operator = "!=";
+                    break;
+                case "<":
+                    operator = "<";
+                    break;
+                case ">":
+                    operator = ">";
+                    break;
+                case "<=":
+                    operator = "<=";
+                    break;
+                case ">=":
+                    operator = ">=";
+                    break;
+                case ":contains":
+                    operator = "contains";
+                    break;
+                case ":startsWith":
+                    operator = "startsWith";
+                    break;
+                case "?":
+                    operator = "exists";
+                    break;
+                default:
+                    operator = "=";
+            }
+            options.where.push({
+                field,
+                operator,
+                value: operator === "exists"
+                    ? undefined
+                    : parseValue((op === ":contains" || op === ":startsWith") &&
+                        val.startsWith("=")
+                        ? val.slice(1)
+                        : val),
+            });
+        }
+    }
+    return options;
+}
+function parseValue(val) {
+    const trimmed = val.trim();
+    if (trimmed === "true")
+        return true;
+    if (trimmed === "false")
+        return false;
+    if (/^-?\d+$/.test(trimmed))
+        return parseInt(trimmed, 10);
+    if (/^-?\d+\.\d+$/.test(trimmed))
+        return parseFloat(trimmed);
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) ||
+        (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function getFieldValue(block, field) {
+    if (field === "type")
+        return block.type;
+    if (field === "content")
+        return block.content;
+    if (field === "id")
+        return block.id;
+    if (block.properties && field in block.properties) {
+        return block.properties[field];
+    }
+    if (field === "hasHeaders" && block.table) {
+        return !!block.table.headers;
+    }
+    if (field === "rowCount" && block.table) {
+        return block.table.rows.length;
+    }
+    return undefined;
+}
+function evaluateClause(block, clause) {
+    const value = getFieldValue(block, clause.field);
+    switch (clause.operator) {
+        case "exists":
+            return value !== undefined;
+        case "=":
+            return String(value).toLowerCase() === String(clause.value).toLowerCase();
+        case "!=":
+            return String(value).toLowerCase() !== String(clause.value).toLowerCase();
+        case "<":
+            return compareValues(value, clause.value) < 0;
+        case ">":
+            return compareValues(value, clause.value) > 0;
+        case "<=":
+            return compareValues(value, clause.value) <= 0;
+        case ">=":
+            return compareValues(value, clause.value) >= 0;
+        case "contains":
+            return String(value)
+                .toLowerCase()
+                .includes(String(clause.value).toLowerCase());
+        case "startsWith":
+            return String(value)
+                .toLowerCase()
+                .startsWith(String(clause.value).toLowerCase());
+        default:
+            return false;
+    }
+}
+function compareValues(a, b) {
+    if (typeof a === "number" && typeof b === "number") {
+        return a - b;
+    }
+    const dateA = new Date(String(a));
+    const dateB = new Date(String(b));
+    if (!isNaN(dateA.getTime()) && !isNaN(dateB.getTime())) {
+        return dateA.getTime() - dateB.getTime();
+    }
+    return String(a).localeCompare(String(b));
+}
+function queryBlocks(document, options) {
+    if (!document || !document.blocks) {
+        return { blocks: [], total: 0, matched: 0 };
+    }
+    const opts = typeof options === "string" ? parseQuery(options) : options;
+    let blocks = (0, utils_1.flattenBlocks)(document.blocks);
+    if (opts.where && opts.where.length > 0) {
+        blocks = blocks.filter((block) => opts.where.every((clause) => evaluateClause(block, clause)));
+    }
+    if (opts.sort && opts.sort.length > 0) {
+        blocks.sort((a, b) => {
+            for (const sort of opts.sort) {
+                const valA = getFieldValue(a, sort.field);
+                const valB = getFieldValue(b, sort.field);
+                const cmp = compareValues(valA, valB);
+                if (cmp !== 0) {
+                    return sort.direction === "desc" ? -cmp : cmp;
+                }
+            }
+            return 0;
+        });
+    }
+    const matched = blocks.length;
+    if (opts.offset && opts.offset > 0) {
+        blocks = blocks.slice(opts.offset);
+    }
+    if (opts.limit !== undefined && opts.limit >= 0) {
+        blocks = blocks.slice(0, opts.limit);
+    }
+    return {
+        blocks,
+        total: (0, utils_1.flattenBlocks)(document.blocks).length,
+        matched,
+    };
+}
+function formatQueryResult(result, format = "simple") {
+    switch (format) {
+        case "json":
+            return JSON.stringify(result, null, 2);
+        case "table":
+            return formatAsTable(result.blocks);
+        case "simple":
+        default:
+            return result.blocks
+                .map((b) => `[${b.type}] ${b.content}${b.properties
+                ? " | " +
+                    Object.entries(b.properties)
+                        .map(([k, v]) => `${k}:${v}`)
+                        .join(" | ")
+                : ""}`)
+                .join("\n");
+    }
+}
+function formatAsTable(blocks) {
+    if (blocks.length === 0)
+        return "No results";
+    const headers = ["ID", "Type", "Content", "Properties"];
+    const rows = blocks.map((b) => [
+        b.id.slice(0, 8),
+        b.type,
+        b.content.slice(0, 40),
+        Object.entries(b.properties || {})
+            .map(([k, v]) => `${k}:${String(v).slice(0, 15)}`)
+            .join(", ") || "-",
+    ]);
+    const colWidths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => String(r[i]).length)));
+    const separator = "+" + colWidths.map((w) => "-".repeat(w + 2)).join("+") + "+";
+    const headerRow = "| " + headers.map((h, i) => h.padEnd(colWidths[i])).join(" | ") + " |";
+    const dataRows = rows.map((row) => "| " +
+        row.map((cell, i) => String(cell).padEnd(colWidths[i])).join(" | ") +
+        " |");
+    return [separator, headerRow, separator, ...dataRows, separator].join("\n");
+}
+function queryDocument(doc, query = {}) {
+    if (!doc || !Array.isArray(doc.blocks))
+        return [];
+    const allBlocks = (0, utils_1.flattenBlocks)(doc.blocks);
+    if (Object.keys(query).length === 0)
+        return [...allBlocks];
+    let sectionBlocks = null;
+    if (query.section !== undefined) {
+        sectionBlocks = new Set();
+        let inMatchingSection = false;
+        for (const block of allBlocks) {
+            if (block.type === "section") {
+                inMatchingSection = matchValue(block.content, query.section);
+            }
+            else if (inMatchingSection) {
+                sectionBlocks.add(block.id);
+            }
+        }
+    }
+    let results = [];
+    for (const block of allBlocks) {
+        if (sectionBlocks !== null && !sectionBlocks.has(block.id))
+            continue;
+        if (query.type !== undefined) {
+            const types = Array.isArray(query.type) ? query.type : [query.type];
+            if (!types.includes(block.type))
+                continue;
+        }
+        if (query.content !== undefined) {
+            if (!matchValue(block.content || "", query.content))
+                continue;
+        }
+        if (query.properties !== undefined) {
+            let allMatch = true;
+            for (const [key, expected] of Object.entries(query.properties)) {
+                const actual = block.properties?.[key];
+                if (actual === undefined || !matchValue(String(actual), expected)) {
+                    allMatch = false;
+                    break;
+                }
+            }
+            if (!allMatch)
+                continue;
+        }
+        results.push(block);
+    }
+    if (query.limit !== undefined && query.limit >= 0) {
+        results = results.slice(0, query.limit);
+    }
+    return results;
+}
+function matchValue(text, pattern) {
+    if (typeof pattern === "string") {
+        return text.toLowerCase().includes(pattern.toLowerCase());
+    }
+    return pattern.test(text);
+}

package/dist/renderer.d.ts

@@ -0,0 +1,16 @@
+import { IntentDocument, PrintLayout } from "./types";
+import { IntentTheme } from "./theme";
+export interface RenderOptions {
+    theme?: string | IntentTheme;
+}
+export declare function collectPrintLayout(doc: IntentDocument): PrintLayout;
+export declare function cssContentValue(text: string): string;
+export declare const DOC_STYLE_TARGETS: Record<string, string[]>;
+export interface DocumentStyleRule {
+    target: string;
+    declarations: string;
+}
+export declare function collectDocumentStyles(doc: IntentDocument): DocumentStyleRule[];
+export declare function documentStyleCSS(doc: IntentDocument, selectorMap?: Record<string, string[]>, selectorPrefix?: string): string;
+export declare function renderHTML(document: IntentDocument, options?: RenderOptions): string;
+export declare function renderPrint(doc: IntentDocument, options?: RenderOptions): string;