@podlite/schema 0.0.38 → 0.0.40

package/lib/selectors.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSelector = exports.parseSelector = void 0;
+const index_1 = require("./index");
+const parseSelector = (selector) => {
+    const trimmed = selector.trim();
+    if (!trimmed)
+        return undefined;
+    // Split on the first '|' — left is source, right is blocks selector
+    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(/^([^:]+):([^#]+)(?:#(.+))?$/);
+    if (sourceMatch) {
+        return {
+            scheme: sourceMatch[1],
+            document: sourceMatch[2].trim(),
+            anchor: sourceMatch[3],
+            blockFilters,
+        };
+    }
+    if (blockFilters.length > 0) {
+        return { blockFilters };
+    }
+    return undefined;
+};
+exports.parseSelector = parseSelector;
+// Normalize a path for loose suffix comparison:
+//   'src/foo.podlite'      ~= 'foo.podlite'
+//   './includes/x.podlite' ~= 'includes/x.podlite'
+const normalizePath = (p) => p.replace(/\\/g, '/').replace(/^\.\//, '');
+const isGlobPattern = (s) => /[*?[]/.test(s);
+// Convert a glob pattern to an anchored RegExp.
+//   **/   →  (?:.*/)?   zero or more directory segments (lets **/foo match root-level foo)
+//   **    →  .*         any characters, crosses /
+//   *     →  [^/]*      any characters within a single segment
+//   ?     →  [^/]       single character within a segment
+// Other regex meta characters are escaped.
+const globRegexCache = new Map();
+const globToRegex = (glob) => {
+    const cached = globRegexCache.get(glob);
+    if (cached)
+        return cached;
+    let re = '';
+    let i = 0;
+    while (i < glob.length) {
+        const c = glob[i];
+        const next = glob[i + 1];
+        if (c === '*' && next === '*' && glob[i + 2] === '/') {
+            re += '(?:.*/)?';
+            i += 3;
+        }
+        else if (c === '*' && next === '*') {
+            re += '.*';
+            i += 2;
+        }
+        else if (c === '*') {
+            re += '[^/]*';
+            i += 1;
+        }
+        else if (c === '?') {
+            re += '[^/]';
+            i += 1;
+        }
+        else if (/[\\^$.()+|{}[\]]/.test(c)) {
+            re += '\\' + c;
+            i += 1;
+        }
+        else {
+            re += c;
+            i += 1;
+        }
+    }
+    const compiled = new RegExp(`^${re}$`);
+    globRegexCache.set(glob, compiled);
+    return compiled;
+};
+const filePathMatches = (docFile, target) => {
+    const a = normalizePath(docFile);
+    const b = normalizePath(target);
+    if (isGlobPattern(b)) {
+        const rx = globToRegex(b);
+        if (rx.test(a))
+            return true;
+        // Suffix-tolerant match: allow any parent prefix (consistent with
+        // non-glob suffix matching, so 'src/00-foo/x.pod' matches '00-foo/x.pod').
+        const body = rx.source.slice(1, -1);
+        const rxSuffix = new RegExp(`^(?:.*/)${body}$`);
+        return rxSuffix.test(a);
+    }
+    return a === b || a.endsWith('/' + b) || b.endsWith('/' + a);
+};
+const getDocIDs = (doc) => {
+    const ids = [];
+    (0, index_1.getFromTree)(doc.node, 'NAME', 'TITLE').forEach(block => {
+        const conf = (0, index_1.makeAttrs)(block, {});
+        const title = (0, index_1.getTextContentFromNode)(block).trim();
+        if (conf.exists('id')) {
+            const id = conf.getFirstValue('id');
+            if (id)
+                ids.push(id);
+        }
+        ids.push(title);
+    });
+    return ids;
+};
+function getMapIDsBlocks(srcNode) {
+    const idsMap = new Map();
+    (0, index_1.getFromTree)(srcNode, { type: 'block' }).forEach(i => {
+        const id = (0, index_1.getNodeId)(i, {});
+        if (id)
+            idsMap.set(id, i);
+    });
+    return idsMap;
+}
+const runSelector = (selector, docs) => {
+    const parsed = (0, exports.parseSelector)(selector);
+    if (!parsed)
+        return [];
+    const { scheme, document, anchor, blockFilters } = parsed;
+    let matchedDocs = docs;
+    if (scheme === 'doc' && document) {
+        matchedDocs = docs.filter(doc => getDocIDs(doc).includes(document));
+    }
+    else if (scheme === 'file' && document) {
+        matchedDocs = docs.filter(doc => filePathMatches(doc.file, document));
+    }
+    else if (scheme && scheme !== 'doc' && scheme !== 'file') {
+        return [];
+    }
+    // Anchor takes precedence — single-block-by-id lookup
+    if (anchor) {
+        const collectedBlocks = [];
+        for (const d of matchedDocs) {
+            const idsMap = getMapIDsBlocks(d.node);
+            const block = idsMap.get(anchor);
+            if (block)
+                collectedBlocks.push(block);
+        }
+        return collectedBlocks;
+    }
+    // Block filters — extract blocks by name across matched docs
+    if (blockFilters.length > 0) {
+        const collectedBlocks = [];
+        for (const d of matchedDocs) {
+            for (const name of blockFilters) {
+                collectedBlocks.push(...(0, index_1.getFromTree)(d.node, name));
+            }
+        }
+        return collectedBlocks;
+    }
+    // No anchor, no filter — return whole docs
+    return matchedDocs.map(d => d.node);
+};
+exports.runSelector = runSelector;
+//# sourceMappingURL=selectors.js.map

package/package.json

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