@podlite/schema 0.0.41 → 0.0.43

package/lib/selectors.js

@@ -2,36 +2,327 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSelector = exports.parseSelector = void 0;
 const index_1 = require("./index");
+// --- predicate parser ---------------------------------------------------
+const isIdentStart = (c) => /[a-zA-Z_]/.test(c);
+const isIdentCont = (c) => /[a-zA-Z0-9_-]/.test(c);
+// Read an angle-bracketed value starting at `<`. Returns the inner content
+// (without delimiters) and the index right after the closing `>`.
+// Nested `<>` pairs are matched recursively.
+const readAngleValue = (s, start) => {
+    if (s[start] !== '<')
+        return undefined;
+    let depth = 1;
+    let i = start + 1;
+    while (i < s.length && depth > 0) {
+        if (s[i] === '<')
+            depth++;
+        else if (s[i] === '>') {
+            depth--;
+            if (depth === 0)
+                return { value: s.slice(start + 1, i), end: i + 1 };
+        }
+        i++;
+    }
+    return undefined;
+};
+const parseCondition = (raw) => {
+    const s = raw.trim();
+    if (!s.startsWith(':'))
+        return undefined;
+    let i = 1;
+    let modifier;
+    if (s.startsWith('!?', i)) {
+        modifier = '!?';
+        i += 2;
+    }
+    else if (s[i] === '!') {
+        modifier = '!';
+        i += 1;
+    }
+    else if (s[i] === '?') {
+        modifier = '?';
+        i += 1;
+    }
+    if (i >= s.length || !isIdentStart(s[i]))
+        return undefined;
+    const nameStart = i;
+    while (i < s.length && isIdentCont(s[i]))
+        i++;
+    const attrName = s.slice(nameStart, i);
+    if (i >= s.length)
+        return { modifier, attrName };
+    if (s[i] === '~' && s[i + 1] === '<') {
+        const read = readAngleValue(s, i + 1);
+        if (!read || read.end !== s.length)
+            return undefined;
+        return { modifier, attrName, valueSpec: { kind: 'contains', value: read.value } };
+    }
+    if (s[i] === '<') {
+        const read = readAngleValue(s, i);
+        if (!read || read.end !== s.length)
+            return undefined;
+        return { modifier, attrName, valueSpec: { kind: 'angle', value: read.value } };
+    }
+    return undefined;
+};
+// Split predicate body by whitespace at top level, respecting <...> nesting.
+const splitConditions = (body) => {
+    const chunks = [];
+    let depth = 0;
+    let buf = '';
+    for (let i = 0; i < body.length; i++) {
+        const c = body[i];
+        if (c === '<')
+            depth++;
+        else if (c === '>') {
+            if (depth === 0)
+                return undefined;
+            depth--;
+        }
+        if (depth === 0 && /\s/.test(c)) {
+            if (buf) {
+                chunks.push(buf);
+                buf = '';
+            }
+            continue;
+        }
+        buf += c;
+    }
+    if (depth !== 0)
+        return undefined;
+    if (buf)
+        chunks.push(buf);
+    return chunks;
+};
+const parsePredicate = (body) => {
+    const chunks = splitConditions(body);
+    if (!chunks)
+        return undefined;
+    const conditions = [];
+    for (const chunk of chunks) {
+        const cond = parseCondition(chunk);
+        if (!cond)
+            return undefined;
+        conditions.push(cond);
+    }
+    return conditions;
+};
+const parsePattern = (raw) => {
+    const s = raw.trim();
+    if (!s)
+        return undefined;
+    let blockType;
+    let i = 0;
+    if (s[0] === '*') {
+        blockType = '*';
+        i = 1;
+    }
+    else if (isIdentStart(s[0])) {
+        let j = 1;
+        while (j < s.length && isIdentCont(s[j]))
+            j++;
+        blockType = s.slice(0, j);
+        i = j;
+    }
+    else {
+        return undefined;
+    }
+    // skip optional whitespace between block-type and predicate
+    while (i < s.length && /\s/.test(s[i]))
+        i++;
+    if (i >= s.length)
+        return { blockType };
+    if (s[i] !== '[' || s[s.length - 1] !== ']')
+        return undefined;
+    const body = s.slice(i + 1, s.length - 1).trim();
+    if (!body)
+        return undefined;
+    const predicate = parsePredicate(body);
+    if (!predicate)
+        return undefined;
+    return { blockType, predicate };
+};
+// Split pattern-list by comma at top level, respecting [...] and <...> nesting.
+const splitPatterns = (s) => {
+    const chunks = [];
+    let bracketDepth = 0;
+    let angleDepth = 0;
+    let buf = '';
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === '[')
+            bracketDepth++;
+        else if (c === ']') {
+            if (bracketDepth === 0)
+                return undefined;
+            bracketDepth--;
+        }
+        else if (c === '<')
+            angleDepth++;
+        else if (c === '>') {
+            if (angleDepth === 0)
+                return undefined;
+            angleDepth--;
+        }
+        if (c === ',' && bracketDepth === 0 && angleDepth === 0) {
+            chunks.push(buf);
+            buf = '';
+            continue;
+        }
+        buf += c;
+    }
+    if (bracketDepth !== 0 || angleDepth !== 0)
+        return undefined;
+    chunks.push(buf);
+    return chunks;
+};
+const parsePatternList = (filterPart) => {
+    if (!filterPart)
+        return [];
+    const chunks = splitPatterns(filterPart);
+    if (!chunks)
+        return undefined;
+    const patterns = [];
+    for (const chunk of chunks) {
+        const trimmed = chunk.trim();
+        if (!trimmed)
+            continue;
+        const p = parsePattern(trimmed);
+        if (!p)
+            return undefined;
+        patterns.push(p);
+    }
+    return patterns;
+};
 const parseSelector = (selector) => {
     const trimmed = selector.trim();
     if (!trimmed)
         return undefined;
-    // Split on the first '|' — left is source, right is blocks selector
+    // Split on the first '|' — left is source, right is pattern-list
     const pipeIdx = trimmed.indexOf('|');
     const sourcePart = (pipeIdx === -1 ? trimmed : trimmed.slice(0, pipeIdx)).trim();
     const filterPart = pipeIdx === -1 ? '' : trimmed.slice(pipeIdx + 1).trim();
-    const blockFilters = filterPart
-        ? filterPart
-            .split(',')
-            .map(s => s.trim())
-            .filter(Boolean)
-        : [];
-    // Source: scheme:path or scheme:path#anchor
-    const sourceMatch = sourcePart.match(/^([^:]+):([^#]+)(?:#(.+))?$/);
+    const patterns = parsePatternList(filterPart);
+    if (patterns === undefined)
+        return undefined;
+    // Source: scheme:path or scheme:path#anchor. Scheme is identifier-shaped
+    // so that bare predicates like `*[:attr<v>]` don't get consumed as scheme.
+    const sourceMatch = sourcePart.match(/^([a-zA-Z][a-zA-Z0-9-]*):([^#]+)(?:#(.+))?$/);
     if (sourceMatch) {
         return {
             scheme: sourceMatch[1],
             document: sourceMatch[2].trim(),
             anchor: sourceMatch[3],
-            blockFilters,
+            patterns,
         };
     }
-    if (blockFilters.length > 0) {
-        return { blockFilters };
+    if (patterns.length > 0) {
+        return { patterns };
+    }
+    // No pipe — treat the whole input as a pattern-list (CLI-friendly shorthand
+    // for filter-only selectors, e.g. `head1, code[:lang<python>]`).
+    if (pipeIdx === -1) {
+        const fallback = parsePatternList(sourcePart);
+        if (fallback && fallback.length > 0)
+            return { patterns: fallback };
     }
     return undefined;
 };
 exports.parseSelector = parseSelector;
+const matchCondition = (node, cond, ctx) => {
+    const attrs = (0, index_1.makeAttrs)(node, ctx);
+    const exists = attrs.exists(cond.attrName);
+    if (!cond.valueSpec) {
+        switch (cond.modifier) {
+            case undefined:
+                return exists && Boolean(attrs.getFirstValue(cond.attrName));
+            case '!':
+                return exists && attrs.getFirstValue(cond.attrName) === false;
+            case '?':
+                return exists;
+            case '!?':
+                return !exists;
+        }
+    }
+    if (cond.valueSpec.kind === 'angle') {
+        if (!exists)
+            return false;
+        const equal = String(attrs.getFirstValue(cond.attrName)) === cond.valueSpec.value;
+        return cond.modifier === '!' ? !equal : equal;
+    }
+    if (cond.valueSpec.kind === 'contains') {
+        if (!exists)
+            return false;
+        // Author-facing semantics: `:tags<a b c>` is a list of three elements.
+        // Grammar parses unquoted identifier sequences as a single string, so
+        // split string values on whitespace/comma to recover list shape.
+        const tokens = [];
+        for (const v of attrs.getAllValues(cond.attrName)) {
+            if (typeof v === 'string') {
+                for (const t of v.split(/[\s,]+/))
+                    if (t)
+                        tokens.push(t);
+            }
+            else {
+                tokens.push(String(v));
+            }
+        }
+        const present = tokens.includes(cond.valueSpec.value);
+        return cond.modifier === '!' ? !present : present;
+    }
+    return false;
+};
+// Replicate name/level handling from getFromTree for backward compat with
+// 'head1' / 'item' style block-types.
+const blockTypeMatches = (node, blockType) => {
+    if (blockType === '*')
+        return true;
+    const anyNode = node;
+    if (anyNode.name === blockType)
+        return true;
+    const m = blockType.match(/^(head|item)(\d+)?$/);
+    if (m) {
+        const [, baseName, levelStr] = m;
+        if (anyNode.name !== baseName)
+            return false;
+        const expectedLevel = levelStr ? parseInt(levelStr, 10) : baseName === 'item' ? 1 : undefined;
+        if (expectedLevel === undefined)
+            return true;
+        // Heading plugin stores level as the regex capture string; coerce.
+        return Number(anyNode.level) === expectedLevel;
+    }
+    return false;
+};
+const matchesPattern = (node, pattern, ctx) => {
+    if (!blockTypeMatches(node, pattern.blockType))
+        return false;
+    if (!pattern.predicate)
+        return true;
+    return pattern.predicate.every(c => matchCondition(node, c, ctx));
+};
+// Walk one document in source order, accumulating =config defaults forward
+// (last-wins, shared across the subtree) so a block matches against the same
+// effective attributes the renderer would apply.
+const collectMatches = (node, patterns, config, seen, out) => {
+    if (Array.isArray(node)) {
+        for (const child of node)
+            collectMatches(child, patterns, config, seen, out);
+        return;
+    }
+    if (!node || typeof node !== 'object')
+        return;
+    const anyNode = node;
+    if (anyNode.type === 'config' && typeof anyNode.name === 'string' && anyNode.config) {
+        config[anyNode.name] = anyNode.config;
+    }
+    else if (anyNode.type === 'block' && !seen.has(node) && patterns.some(p => matchesPattern(node, p, { config }))) {
+        out.push(node);
+        seen.add(node);
+    }
+    if (anyNode.content !== undefined) {
+        collectMatches(anyNode.content, patterns, config, seen, out);
+    }
+};
 // Normalize a path for loose suffix comparison:
 //   'src/foo.podlite'      ~= 'foo.podlite'
 //   './includes/x.podlite' ~= 'includes/x.podlite'
@@ -124,7 +415,7 @@ const runSelector = (selector, docs) => {
     const parsed = (0, exports.parseSelector)(selector);
     if (!parsed)
         return [];
-    const { scheme, document, anchor, blockFilters } = parsed;
+    const { scheme, document, anchor, patterns } = parsed;
     let matchedDocs = docs;
     if (scheme === 'doc' && document) {
         matchedDocs = docs.filter(doc => getDocIDs(doc).includes(document));
@@ -146,17 +437,16 @@ const runSelector = (selector, docs) => {
         }
         return collectedBlocks;
     }
-    // Block filters — extract blocks by name across matched docs
-    if (blockFilters.length > 0) {
+    // Patterns — source-order traversal, apply each pattern, dedupe across patterns
+    if (patterns.length > 0) {
         const collectedBlocks = [];
+        const seen = new Set();
         for (const d of matchedDocs) {
-            for (const name of blockFilters) {
-                collectedBlocks.push(...(0, index_1.getFromTree)(d.node, name));
-            }
+            collectMatches(d.node, patterns, {}, seen, collectedBlocks);
         }
         return collectedBlocks;
     }
-    // No anchor, no filter — return whole docs
+    // No anchor, no patterns — return whole docs
     return matchedDocs.map(d => d.node);
 };
 exports.runSelector = runSelector;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@podlite/schema",
-  "version": "0.0.41",
+  "version": "0.0.43",
   "description": "AST tools and schema for Podlite markup language — validate, traverse, and transform document trees",
   "main": "lib/index.js",
   "homepage": "https://podlite.org",