@invariant-ui/cli 0.0.0-stage → 0.1.0

package/dist/validation/scan.js

@@ -0,0 +1,295 @@
+import ts from "typescript";
+const dyn = (text) => ({ expression: text.replace(/\s+/g, " ").trim().slice(0, 80) });
+function jsxValue(init, sf) {
+    if (!init)
+        return true;
+    if (ts.isStringLiteral(init))
+        return init.text;
+    if (ts.isJsxExpression(init) && init.expression) {
+        const e = init.expression;
+        if (ts.isStringLiteralLike(e))
+            return e.text;
+        if (ts.isNumericLiteral(e))
+            return Number(e.text);
+        if (e.kind === ts.SyntaxKind.TrueKeyword)
+            return true;
+        if (e.kind === ts.SyntaxKind.FalseKeyword)
+            return false;
+        if (e.kind === ts.SyntaxKind.NullKeyword)
+            return null;
+        return dyn(e.getText(sf));
+    }
+    return dyn(init.getText(sf));
+}
+/** JSX elements and import bindings in a TypeScript/JavaScript snippet, by syntax only. Nothing is evaluated. */
+export function scanJsx(code, filename = "snippet.tsx") {
+    const kind = /\.jsx?$/i.test(filename) ? ts.ScriptKind.JSX : ts.ScriptKind.TSX;
+    const sf = ts.createSourceFile(filename, code, ts.ScriptTarget.Latest, true, kind);
+    const uses = [];
+    const imports = new Map();
+    for (const stmt of sf.statements) {
+        if (!ts.isImportDeclaration(stmt) || !ts.isStringLiteral(stmt.moduleSpecifier))
+            continue;
+        const module = stmt.moduleSpecifier.text;
+        const clause = stmt.importClause;
+        if (!clause)
+            continue;
+        if (clause.name)
+            imports.set(clause.name.text, { module, imported: "default" });
+        const bindings = clause.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings))
+            imports.set(bindings.name.text, { module, imported: "*" });
+        else if (bindings)
+            for (const el of bindings.elements)
+                imports.set(el.name.text, { module, imported: (el.propertyName ?? el.name).text });
+    }
+    const unwrap = (node) => {
+        let n = node;
+        while (ts.isParenthesizedExpression(n) || ts.isAsExpression(n) || ts.isNonNullExpression(n))
+            n = n.expression;
+        return n;
+    };
+    const isJsx = (n) => ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n);
+    const containsJsx = (n) => {
+        let found = false;
+        const look = (c) => {
+            if (found)
+                return;
+            if (isJsx(c))
+                found = true;
+            else
+                ts.forEachChild(c, look);
+        };
+        look(n);
+        return found;
+    };
+    /** True when this element is what a component returns (directly or through a conditional), not a value stored elsewhere. */
+    const isRendered = (node) => {
+        let child = node;
+        for (let p = node.parent; p; child = p, p = p.parent) {
+            if (ts.isParenthesizedExpression(p) || ts.isAsExpression(p) || ts.isNonNullExpression(p))
+                continue;
+            if (ts.isReturnStatement(p))
+                return true;
+            if (ts.isArrowFunction(p))
+                return p.body === child;
+            if (ts.isConditionalExpression(p)) {
+                if (p.condition === child)
+                    return false;
+                continue;
+            }
+            if (ts.isBinaryExpression(p) &&
+                [
+                    ts.SyntaxKind.AmpersandAmpersandToken,
+                    ts.SyntaxKind.BarBarToken,
+                    ts.SyntaxKind.QuestionQuestionToken
+                ].includes(p.operatorToken.kind))
+                continue;
+            return false;
+        }
+        return false;
+    };
+    const isOpaqueChild = (child) => {
+        if (!ts.isJsxExpression(child) || !child.expression)
+            return false;
+        const e = unwrap(child.expression);
+        if (ts.isStringLiteralLike(e) || ts.isNumericLiteral(e))
+            return false;
+        return !containsJsx(e);
+    };
+    const visit = (node, parent, depth, loop) => {
+        let next = parent;
+        let nextDepth = depth;
+        let nextLoop = loop;
+        if (ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node)) {
+            const opening = ts.isJsxElement(node) ? node.openingElement : node;
+            const attrs = {};
+            let spread = false;
+            for (const a of opening.attributes.properties) {
+                if (ts.isJsxSpreadAttribute(a))
+                    spread = true;
+                else
+                    attrs[a.name.getText(sf)] = jsxValue(a.initializer, sf);
+            }
+            const hasChildren = ts.isJsxElement(node)
+                ? node.children.some((c) => !(ts.isJsxText(c) && c.containsOnlyTriviaWhiteSpaces))
+                : false;
+            const opaque = spread ||
+                "children" in attrs ||
+                "dangerouslySetInnerHTML" in attrs ||
+                (ts.isJsxElement(node) && node.children.some(isOpaqueChild));
+            const pos = sf.getLineAndCharacterOfPosition(node.getStart(sf));
+            // A root element that is not returned (a variable, an argument) is not placed in the tree here.
+            const level = parent === undefined && !isRendered(node) ? depth + 1 : depth;
+            uses.push({
+                tag: opening.tagName.getText(sf),
+                line: pos.line + 1,
+                column: pos.character + 1,
+                attrs,
+                hasChildren,
+                hasSpread: spread,
+                parent,
+                exprDepth: level,
+                loopDepth: loop,
+                opaque
+            });
+            next = uses.length - 1;
+            nextDepth = level;
+        }
+        else if (ts.isJsxExpression(node)) {
+            // `icon={<Icon />}` is an element handed to its parent as a prop, not a condition or a loop.
+            const direct = ts.isJsxAttribute(node.parent) && node.expression !== undefined && isJsx(unwrap(node.expression));
+            if (!direct)
+                nextDepth = depth + 1;
+        }
+        else if ((ts.isArrowFunction(node) || ts.isFunctionExpression(node)) && depth > 0) {
+            nextLoop = loop + 1;
+        }
+        ts.forEachChild(node, (child) => visit(child, next, nextDepth, nextLoop));
+    };
+    visit(sf, undefined, 0, 0);
+    return { uses, imports };
+}
+const RAW_TEXT = new Set(["script", "style"]);
+const VOID = new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "source",
+    "track",
+    "wbr"
+]);
+const camel = (n) => /^(data|aria)-/.test(n) ? n : n.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+/**
+ * Element start tags in an HTML-like template (Vue, Angular, HTML), with their nesting. A single linear pass:
+ * no DOM, no expression evaluation. Event handlers, structural directives and references are skipped;
+ * bindings are kept as dynamic values.
+ */
+export function scanMarkup(code) {
+    const uses = [];
+    const stack = [];
+    let i = 0;
+    let line = 1;
+    let lineStart = 0;
+    const n = code.length;
+    const advance = (to) => {
+        for (; i < to && i < n; i++)
+            if (code[i] === "\n") {
+                line++;
+                lineStart = i + 1;
+            }
+    };
+    while (i < n) {
+        const lt = code.indexOf("<", i);
+        if (lt < 0)
+            break;
+        advance(lt);
+        if (code.startsWith("<!--", i)) {
+            const end = code.indexOf("-->", i + 4);
+            advance(end < 0 ? n : end + 3);
+            continue;
+        }
+        if (code.startsWith("</", i)) {
+            const close = /^<\/([A-Za-z][A-Za-z0-9_.:-]*)/.exec(code.slice(i, i + 130));
+            if (close) {
+                const at = stack.map((s) => s.tag).lastIndexOf(close[1]);
+                if (at >= 0)
+                    stack.length = at;
+            }
+            advance(i + 2);
+            continue;
+        }
+        const m = /^<([A-Za-z][A-Za-z0-9_.:-]*)/.exec(code.slice(i, i + 130));
+        if (!m) {
+            advance(i + 1);
+            continue;
+        }
+        const tag = m[1];
+        const startLine = line;
+        const startColumn = i - lineStart + 1;
+        let j = i + m[0].length;
+        const attrs = {};
+        let spread = false;
+        let selfClosing = false;
+        while (j < n) {
+            while (j < n && /\s/.test(code[j]))
+                j++;
+            const c = code[j];
+            if (c === undefined)
+                break;
+            if (c === ">") {
+                j++;
+                break;
+            }
+            if (c === "/" && code[j + 1] === ">") {
+                selfClosing = true;
+                j += 2;
+                break;
+            }
+            const nm = /^[^\s=>/"']+/.exec(code.slice(j, j + 200));
+            if (!nm) {
+                j++;
+                continue;
+            }
+            const raw = nm[0];
+            j += raw.length;
+            let value;
+            let k = j;
+            while (k < n && /\s/.test(code[k]))
+                k++;
+            if (code[k] === "=") {
+                k++;
+                while (k < n && /\s/.test(code[k]))
+                    k++;
+                const q = code[k];
+                if (q === '"' || q === "'") {
+                    const end = code.indexOf(q, k + 1);
+                    value = code.slice(k + 1, end < 0 ? n : end);
+                    j = end < 0 ? n : end + 1;
+                }
+                else {
+                    const um = /^[^\s>]+/.exec(code.slice(k, k + 200));
+                    value = um?.[0] ?? "";
+                    j = k + value.length;
+                }
+            }
+            if (/^(@|\(|v-on:|v-on$|#|\*|v-if|v-else|v-for|v-show|v-model|v-slot|ng)/.test(raw) &&
+                !/^\[/.test(raw)) {
+                if (raw === "v-bind" || raw.startsWith("v-bind="))
+                    spread = true;
+                continue;
+            }
+            const bound = /^(:|v-bind:|\[)/.test(raw);
+            const name = camel(raw
+                .replace(/^(:|v-bind:)/, "")
+                .replace(/^\[|\]$/g, "")
+                .replace(/^attr\./, ""));
+            attrs[name] = bound ? dyn(value ?? "") : value === undefined ? true : value;
+        }
+        uses.push({
+            tag,
+            line: startLine,
+            column: startColumn,
+            attrs,
+            hasChildren: selfClosing ? false : undefined,
+            hasSpread: spread,
+            parent: stack[stack.length - 1]?.index
+        });
+        if (!selfClosing && !VOID.has(tag.toLowerCase()) && !RAW_TEXT.has(tag.toLowerCase()))
+            stack.push({ tag, index: uses.length - 1 });
+        advance(j);
+        if (RAW_TEXT.has(tag.toLowerCase()) && !selfClosing) {
+            const close = code.toLowerCase().indexOf(`</${tag.toLowerCase()}`, i);
+            advance(close < 0 ? n : close);
+        }
+    }
+    return uses;
+}
+//# sourceMappingURL=scan.js.map

package/dist/validation/text.js

@@ -0,0 +1,34 @@
+/** Edit distance, capped: returns `limit + 1` as soon as the distance must exceed `limit`. */
+export function distance(a, b, limit) {
+    if (Math.abs(a.length - b.length) > limit)
+        return limit + 1;
+    let prev = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        const cur = [i];
+        let best = i;
+        for (let j = 1; j <= b.length; j++) {
+            const v = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+            cur.push(v);
+            if (v < best)
+                best = v;
+        }
+        if (best > limit)
+            return limit + 1;
+        prev = cur;
+    }
+    return prev[b.length];
+}
+/** Up to `max` candidates close to `name`, nearest first. Case-insensitive; never suggests the name itself. */
+export function nearest(name, candidates, max = 3) {
+    const n = name.toLowerCase();
+    const limit = Math.max(2, Math.floor(n.length / 3));
+    return [...new Set(candidates)]
+        .filter((c) => c.toLowerCase() !== n)
+        .map((c) => ({ c, d: distance(n, c.toLowerCase(), limit) }))
+        .filter((x) => x.d <= limit)
+        .sort((a, b) => a.d - b.d || (a.c < b.c ? -1 : 1))
+        .slice(0, max)
+        .map((x) => x.c);
+}
+export const quoteList = (values) => values.map((v) => JSON.stringify(v)).join(", ");
+//# sourceMappingURL=text.js.map