@podlite/schema 0.0.41 → 0.0.43

package/lib/helpers/handlers.d.ts

@@ -7,6 +7,17 @@ export declare const wrapContent: (pre: any, post: any) => RuleHandler;
  * emptyContent - skip any child node
  */
 export declare const emptyContent: () => RuleHandler;
+/**
+ * Replace each non-whitespace character with the mask character.
+ * Whitespace (spaces, tabs, newlines) is preserved.
+ */
+export declare const maskText: (s: string) => string;
+/**
+ * Walk a content array (strings or fcode/text nodes) and return concatenated
+ * text content for masking. Nested formatting codes are flattened — masked
+ * output drops formatting structure by design.
+ */
+export declare const collectText: (content: unknown) => string;
 /**
  * content - process childs as regular content
  */

package/lib/helpers/handlers.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.handleNested = exports.subUse = exports.setContext = exports.setFn = exports.content = exports.emptyContent = exports.wrapContent = void 0;
+exports.handleNested = exports.subUse = exports.setContext = exports.setFn = exports.content = exports.collectText = exports.maskText = exports.emptyContent = exports.wrapContent = void 0;
 const makeQuery_1 = require("./makeQuery");
 const makeInterator_1 = __importDefault(require("./makeInterator"));
 const config_1 = __importDefault(require("./config"));
@@ -22,6 +22,33 @@ exports.wrapContent = wrapContent;
  */
 const emptyContent = () => () => () => { };
 exports.emptyContent = emptyContent;
+const MASK_CHAR = '█';
+/**
+ * Replace each non-whitespace character with the mask character.
+ * Whitespace (spaces, tabs, newlines) is preserved.
+ */
+const maskText = (s) => s.replace(/\S/g, MASK_CHAR);
+exports.maskText = maskText;
+/**
+ * Walk a content array (strings or fcode/text nodes) and return concatenated
+ * text content for masking. Nested formatting codes are flattened — masked
+ * output drops formatting structure by design.
+ */
+const collectText = (content) => {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content)) {
+        if (content && typeof content === 'object') {
+            const node = content;
+            if (node.type === 'text' || node.type === 'verbatim')
+                return node.value || '';
+            return (0, exports.collectText)(node.content);
+        }
+        return '';
+    }
+    return content.map(exports.collectText).join('');
+};
+exports.collectText = collectText;
 /**
  * content - process childs as regular content
  */

package/lib/helpers/makeInterator.js

@@ -29,13 +29,11 @@ function thisFunc(rules) {
             const nextRuleIndex = nextRuleSet.findIndex(rule => rule.isFor(node));
             const defaultFn = (n = node, ctx = context, localInterator = interator) => {
                 if (nextRuleIndex !== -1) {
-                    nextRuleSet[nextRuleIndex].fn(n, ctx, localInterator, () => {
+                    return nextRuleSet[nextRuleIndex].fn(n, ctx, localInterator, () => {
                         /* empty default action */
                     });
                 }
-                else {
-                    return;
-                }
+                return;
             };
             if (typeof reversed[ruleIndex].fn !== 'function') {
                 console.warn('[podlite] bad fn for ' + JSON.stringify(node, null, 2));

package/lib/index.js

@@ -64,6 +64,7 @@ const plugin_group_defn_1 = __importDefault(require("./plugin-group-defn"));
 const plugin_group_items_1 = __importDefault(require("./plugin-group-items"));
 const plugin_defn_fill_term_1 = __importDefault(require("./plugin-defn-fill-term"));
 const plugin_tables_1 = __importDefault(require("./plugin-tables"));
+const plugin_data_table_1 = __importDefault(require("./plugin-data-table"));
 function toAst() {
     return {};
 }
@@ -152,6 +153,7 @@ function makeTree() {
     chain.use(plugin_heading_1.default);
     chain.use(plugin_defn_fill_term_1.default);
     chain.use(plugin_tables_1.default);
+    chain.use(plugin_data_table_1.default);
     chain.use(plugin_formatting_codes_1.default);
     // save order for the next two plugins
     chain.use(plugin_group_items_1.default);

package/lib/plugin-data-table.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => (tree: any) => any;
+export default _default;

package/lib/plugin-data-table.js

@@ -0,0 +1,157 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const makeTransformer_1 = __importDefault(require("./helpers/makeTransformer"));
+const config_1 = __importDefault(require("./helpers/config"));
+const plugin_tables_1 = require("./plugin-tables");
+const extensionMimeMap = {
+    csv: 'text/csv; header=present',
+    tsv: 'text/tab-separated-values; header=present',
+    tab: 'text/tab-separated-values; header=present',
+};
+function inferMimeFromExtension(path) {
+    const m = path.match(/\.([a-z0-9]+)$/i);
+    if (!m)
+        return undefined;
+    return extensionMimeMap[m[1].toLowerCase()];
+}
+function parseColumnsList(values) {
+    if (!Array.isArray(values) || values.length === 0)
+        return [];
+    if (values.length === 1 && typeof values[0] === 'string' && values[0].includes(',')) {
+        return values[0]
+            .split(',')
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+    }
+    return values.map(v => String(v).trim()).filter(s => s.length > 0);
+}
+function resolveColumnIndex(col, headerRow, maxCols) {
+    const trimmed = col.trim();
+    if (/^\d+$/.test(trimmed)) {
+        const n = parseInt(trimmed, 10);
+        const idx = n - 1;
+        if (idx < 0 || idx >= maxCols) {
+            throw new Error(`column index ${n} out of range (1..${maxCols})`);
+        }
+        return idx;
+    }
+    if (!headerRow) {
+        throw new Error(`column name "${col}" requires header=present`);
+    }
+    const idx = headerRow.indexOf(col);
+    if (idx === -1) {
+        throw new Error(`column name "${col}" not found in header`);
+    }
+    return idx;
+}
+function projectColumns(rows, columns, hasHeader) {
+    if (rows.length === 0)
+        return rows;
+    const maxCols = rows[0].length;
+    const headerRow = hasHeader ? rows[0] : null;
+    const indices = columns.map(col => resolveColumnIndex(col, headerRow, maxCols));
+    return rows.map(row => indices.map(i => row[i] ?? ''));
+}
+function applyRename(rows, rename, hasHeader) {
+    if (!hasHeader || rows.length === 0)
+        return rows;
+    const headerRow = [...rows[0]];
+    for (const [key, newName] of Object.entries(rename)) {
+        const idx = resolveColumnIndex(key, headerRow, headerRow.length);
+        headerRow[idx] = String(newName);
+    }
+    return [headerRow, ...rows.slice(1)];
+}
+function processDataTable(node, tree) {
+    const attrs = (0, config_1.default)(node, {});
+    const srcRaw = attrs.getFirstValue('src');
+    const mimeAttr = attrs.getFirstValue('mime-type');
+    const renameMap = attrs.getMapValue('rename');
+    const columnsPresent = attrs.exists('columns');
+    const columns = columnsPresent ? parseColumnsList(attrs.getAllValues('columns')) : null;
+    const bodyText = (0, plugin_tables_1.extractDataText)(node);
+    const hasInlineBody = bodyText.trim().length > 0;
+    if (srcRaw && hasInlineBody) {
+        throw new Error(':src and inline body are mutually exclusive');
+    }
+    if (columnsPresent && (!columns || columns.length === 0)) {
+        throw new Error(':columns must have at least one entry; omit the attribute to render all columns');
+    }
+    let csvText;
+    let mimeType;
+    let hasHeader;
+    if (srcRaw) {
+        const srcStr = String(srcRaw);
+        const m = srcStr.match(/^(file|data|http|https|doc):(.+)$/);
+        const scheme = m ? m[1] : 'file';
+        const target = m ? m[2] : srcStr;
+        if (scheme === 'data') {
+            const dataBlock = (0, plugin_tables_1.findDataBlockByKey)(tree, target);
+            if (!dataBlock) {
+                console.warn(`[data-table] no =data block found for data:${target} — rendered as empty`);
+                return { ...node, name: 'table', content: [] };
+            }
+            if (mimeAttr) {
+                throw new Error(`:mime-type cannot be declared with :src<data:${target}> (inherited from referenced block)`);
+            }
+            const dataMime = (0, config_1.default)(dataBlock, {}).getFirstValue('mime-type');
+            if (!dataMime) {
+                console.warn(`[data-table] =data block ${target} has no :mime-type — rendered as empty`);
+                return { ...node, name: 'table', content: [] };
+            }
+            const parsed = (0, plugin_tables_1.parseMimeType)(dataMime);
+            mimeType = parsed.type;
+            hasHeader = parsed.params.header === 'present';
+            csvText = (0, plugin_tables_1.extractDataText)(dataBlock);
+        }
+        else {
+            return node;
+        }
+    }
+    else {
+        if (!mimeAttr) {
+            throw new Error('inline body requires :mime-type');
+        }
+        const parsed = (0, plugin_tables_1.parseMimeType)(mimeAttr);
+        mimeType = parsed.type;
+        hasHeader = parsed.params.header === 'present';
+        csvText = bodyText;
+    }
+    const isCsv = mimeType === 'text/csv';
+    const isTsv = mimeType === 'text/tab-separated-values';
+    if (!isCsv && !isTsv) {
+        console.warn(`[data-table] unsupported mime-type ${mimeType} — rendered as empty`);
+        return { ...node, name: 'table', content: [] };
+    }
+    let rows = isCsv ? (0, plugin_tables_1.parseCsv)(csvText) : (0, plugin_tables_1.parseTsv)(csvText);
+    if (rows.length === 0) {
+        console.warn(`[data-table] ${isCsv ? 'CSV' : 'TSV'} parse produced no rows — rendered as empty`);
+        return { ...node, name: 'table', content: [] };
+    }
+    if (columns) {
+        rows = projectColumns(rows, columns, hasHeader);
+    }
+    if (renameMap) {
+        rows = applyRename(rows, renameMap, hasHeader);
+    }
+    const filledNode = { ...node, name: 'table', content: (0, plugin_tables_1.csvToTableContent)(rows, hasHeader) };
+    return (0, plugin_tables_1.normalizeCellCounts)(filledNode, 'data-table');
+}
+exports.default = () => tree => {
+    const transformer = (0, makeTransformer_1.default)({
+        'data-table': node => {
+            try {
+                return processDataTable(node, tree);
+            }
+            catch (err) {
+                console.warn(`[data-table] ${err.message}`);
+                return { ...node, name: 'table', content: [] };
+            }
+        },
+    });
+    return transformer(tree);
+};
+//# sourceMappingURL=plugin-data-table.js.map

package/lib/plugin-tables.d.ts

@@ -1,2 +1,12 @@
+export declare function parseCsv(text: any): any[];
+export declare function parseTsv(text: any): any;
+export declare function parseMimeType(raw: any): {
+    type: string;
+    params: Record<string, string>;
+};
+export declare function findDataBlockByKey(tree: any, key: any): any;
+export declare function extractDataText(dataNode: any): any;
+export declare function csvToTableContent(csvRows: any, hasHeader?: boolean): any;
+export declare function normalizeCellCounts(tableNode: any, source?: string): any;
 declare const _default: () => (tree: any) => any;
 export default _default;

package/lib/plugin-tables.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeCellCounts = exports.csvToTableContent = exports.extractDataText = exports.findDataBlockByKey = exports.parseMimeType = exports.parseTsv = exports.parseCsv = void 0;
 /**
  * Plugin for fill term's for defn. From S26:
  * The first non-blank line of content is treated as a term being defined,
@@ -73,6 +74,7 @@ function parseCsv(text) {
     // Drop rows that are entirely blank (empty content after trim).
     return rows.filter(r => !(r.length === 1 && r[0].trim() === ''));
 }
+exports.parseCsv = parseCsv;
 // Parse a TSV (tab-separated values) blob. Unlike CSV, TSV has no quoting
 // mechanism — fields are split strictly on tabs and `"` is a literal
 // character. Tabs and newlines inside fields are not representable in TSV.
@@ -81,6 +83,7 @@ function parseTsv(text) {
     const rows = lines.map(line => line.split('\t'));
     return rows.filter(r => !(r.length === 1 && r[0].trim() === ''));
 }
+exports.parseTsv = parseTsv;
 // Parse a MIME type value into the bare type and a map of parameters
 // (RFC 6838 / RFC 7231 §3.1.1.1). Used to recognise the `header` parameter
 // (RFC 4180 §3) on `:mime-type` of CSV/TSV =data blocks.
@@ -111,6 +114,7 @@ function parseMimeType(raw) {
     }
     return { type, params };
 }
+exports.parseMimeType = parseMimeType;
 // Locate the first `=data` block with a matching `:key` attribute anywhere
 // in the document tree.
 function findDataBlockByKey(tree, key) {
@@ -137,12 +141,14 @@ function findDataBlockByKey(tree, key) {
     walk(tree);
     return found;
 }
+exports.findDataBlockByKey = findDataBlockByKey;
 function extractDataText(dataNode) {
     if (!dataNode || !Array.isArray(dataNode.content))
         return '';
     const verbatim = dataNode.content.find(c => c && c.type === 'verbatim');
     return verbatim && typeof verbatim.value === 'string' ? verbatim.value : '';
 }
+exports.extractDataText = extractDataText;
 // Detect whether the =table body is a single-line source reference like
 // `data:key` or `file:path` (spec §1672). Returns the parsed reference or
 // null if the body is ordinary table content.
@@ -203,6 +209,7 @@ function csvToTableContent(csvRows, hasHeader = false) {
         return buildRowBlock(cells, hasHeader && i === 0);
     });
 }
+exports.csvToTableContent = csvToTableContent;
 // ─── Error recovery (design notes Rules 2-4) ───────────────────────────────
 // Rule 2 — table-level cell count validation. Pad short rows with empty
 // cells; truncate long rows. Emit a warning whenever a row is changed.
@@ -265,6 +272,7 @@ function normalizeCellCounts(tableNode, source = 'table') {
     });
     return mutated ? { ...tableNode, content: newContent } : tableNode;
 }
+exports.normalizeCellCounts = normalizeCellCounts;
 // Rule 3 — mixed separator detection (text-mode only). Inspects each line
 // for visible separators (`|` / `+`) surrounded by whitespace; lines without
 // any visible separator fall back to whitespace separation. Warns when more

package/lib/selectors.d.ts

@@ -8,11 +8,27 @@ export declare type SelectorDoc = {
     file: string;
     node: PodNode | PodliteDocument;
 };
+export declare type ValueSpec = {
+    kind: 'angle';
+    value: string;
+} | {
+    kind: 'contains';
+    value: string;
+};
+export declare type Condition = {
+    modifier?: '!' | '?' | '!?';
+    attrName: string;
+    valueSpec?: ValueSpec;
+};
+export declare type Pattern = {
+    blockType: string;
+    predicate?: Condition[];
+};
 export declare type ParsedSelector = {
     scheme?: string;
     document?: string;
     anchor?: string;
-    blockFilters: string[];
+    patterns: Pattern[];
 };
 export declare const parseSelector: (selector: string) => ParsedSelector | undefined;
 export declare const runSelector: <T extends SelectorDoc>(selector: string, docs: T[]) => PodNode[] | T[];