@vibes.diy/api-svc 14.3.91 → 14.3.93

package/intern/opens-check.js

@@ -4,6 +4,11 @@ import acornJsx from "acorn-jsx";
 import { transform } from "sucrase";
 import { POUF_ENTRY_EXPORTS } from "@vibes.diy/pouf/exports";
 import { lockedGroupsVersions } from "./grouped-vibe-import-map.js";
+import { asNode, childNodes, columnAt, field, lineAt, nodeAt, nodesAt, stringAt } from "./opens-ast.js";
+import { GENERATED_BROWSER_GLOBALS } from "./opens-browser-globals.js";
+import { checkHooks } from "./opens-hooks.js";
+import { checkInert } from "./opens-inert.js";
+import { hookCallStarts, resolveName, scanScopes } from "./opens-scope.js";
 export const OPENS_ADVISORY_CLASSES = new Set(["unknown-package"]);
 const LOOK_EXPORTS = [
     "Avatar",
@@ -351,6 +356,85 @@ export const OPENS_MODULE_EXPORTS = {
     "@vibes.diy/vibe-runtime": RUNTIME_EXPORTS,
     ...Object.fromEntries(importMapEntries().flatMap(([spec, target]) => target === RUNTIME_ALIAS ? [[spec, RUNTIME_EXPORTS]] : [])),
 };
+const OBJECT_MEMBERS = [
+    "constructor",
+    "hasOwnProperty",
+    "isPrototypeOf",
+    "propertyIsEnumerable",
+    "toLocaleString",
+    "toString",
+    "valueOf",
+];
+const FUNCTION_MEMBERS = [...OBJECT_MEMBERS, "apply", "bind", "call", "length", "name"];
+const TOAST_MEMBERS = ["error", "info", "success", "warning"];
+const USE_FIREPROOF_RESULT_KEYS = [
+    "access",
+    "addInterest",
+    "attach",
+    "clearWriteRejection",
+    "database",
+    "fromCache",
+    "getFromCache",
+    "removeInterest",
+    "useAllDocs",
+    "useChanges",
+    "useDocument",
+    "useLiveQuery",
+    "writeRejection",
+];
+const DATABASE_MEMBERS = [
+    "allDocs",
+    "applyEphemeral",
+    "applyRemote",
+    "applySnapshot",
+    "broadcastEphemeral",
+    "bulk",
+    "changes",
+    "close",
+    "compact",
+    "del",
+    "dequeuePush",
+    "destroy",
+    "dropCursor",
+    "dropEphemeralPeer",
+    "enableEphemeral",
+    "evictChannel",
+    "foldSeedDocs",
+    "get",
+    "getCursors",
+    "getSyncMeta",
+    "initialSyncConfirmed",
+    "initialSyncSettled",
+    "materializeAllDocs",
+    "materializeLive",
+    "name",
+    "onSettledChange",
+    "overwriteFromServer",
+    "peekPushQueue",
+    "put",
+    "query",
+    "queryLive",
+    "ready",
+    "recordAccepted",
+    "remove",
+    "resubscribe",
+    "revertDoc",
+    "seedDocs",
+    "setCursors",
+    "setReadObserver",
+    "size",
+    "snapshot",
+    "subscribe",
+];
+export const OPENS_MEMBER_SHAPES = {
+    toast: TOAST_MEMBERS,
+    useFireproofResult: USE_FIREPROOF_RESULT_KEYS,
+    database: DATABASE_MEMBERS,
+};
+const TOAST_HOMES = new Set(["@vibes.diy/pouf/interactive", "@vibes.diy/pouf"]);
+function isRuntimeSpecifier(spec) {
+    return OPENS_MODULE_EXPORTS[spec] === RUNTIME_EXPORTS;
+}
 function isMappedSpecifier(spec) {
     return importMapEntries().some(([key]) => key === spec || (key.endsWith("/") && spec.startsWith(key)));
 }
@@ -585,268 +669,12 @@ const BROWSER_GLOBALS = new Set([
     "webkitSpeechRecognition",
     "Geolocation",
 ]);
-function isGlobalName(name) {
-    return BROWSER_GLOBALS.has(name);
-}
-function asNode(value) {
-    if (typeof value !== "object" || value === null)
-        return undefined;
-    if ("type" in value && typeof value.type === "string" && "start" in value && typeof value.start === "number") {
-        return { ...value, type: value.type, start: value.start };
-    }
-    return undefined;
-}
-function field(node, key) {
-    return Reflect.get(node, key);
-}
-function nodeAt(node, key) {
-    return asNode(field(node, key));
+const ALL_BROWSER_GLOBALS = new Set([...BROWSER_GLOBALS, ...GENERATED_BROWSER_GLOBALS]);
+export function isOpensGlobalName(name) {
+    return ALL_BROWSER_GLOBALS.has(name);
 }
-function nodesAt(node, key) {
-    const value = field(node, key);
-    if (Array.isArray(value) === false)
-        return [];
-    return value.flatMap((item) => {
-        const n = asNode(item);
-        return n === undefined ? [] : [n];
-    });
-}
-function stringAt(node, key) {
-    const value = field(node, key);
-    return typeof value === "string" ? value : undefined;
-}
-function isComputed(node) {
-    return field(node, "computed") === true;
-}
-const SKIP_KEYS = new Set(["type", "start", "end", "loc", "range", "raw"]);
-function childNodes(node) {
-    return Object.keys(node)
-        .filter((key) => SKIP_KEYS.has(key) === false)
-        .flatMap((key) => {
-        const value = field(node, key);
-        const items = Array.isArray(value) ? value : [value];
-        return items.flatMap((item) => {
-            const child = asNode(item);
-            return child === undefined ? [] : [{ key, child }];
-        });
-    });
-}
-const HOOK_NAME = /^use[A-Z0-9]/;
-function declarePattern(pattern, visit, scan) {
-    switch (pattern.type) {
-        case "Identifier": {
-            const name = stringAt(pattern, "name");
-            if (name !== undefined)
-                scan.declared.add(name);
-            return;
-        }
-        case "ObjectPattern":
-            for (const prop of nodesAt(pattern, "properties")) {
-                if (prop.type === "RestElement") {
-                    const arg = nodeAt(prop, "argument");
-                    if (arg !== undefined)
-                        declarePattern(arg, visit, scan);
-                    continue;
-                }
-                const key = nodeAt(prop, "key");
-                if (key !== undefined && isComputed(prop))
-                    walk({ node: key, parent: prop, key: "key", depth: visit.depth }, scan);
-                const value = nodeAt(prop, "value");
-                if (value !== undefined)
-                    declarePattern(value, visit, scan);
-            }
-            return;
-        case "ArrayPattern":
-            for (const element of nodesAt(pattern, "elements"))
-                declarePattern(element, visit, scan);
-            return;
-        case "RestElement": {
-            const arg = nodeAt(pattern, "argument");
-            if (arg !== undefined)
-                declarePattern(arg, visit, scan);
-            return;
-        }
-        case "AssignmentPattern": {
-            const left = nodeAt(pattern, "left");
-            const right = nodeAt(pattern, "right");
-            if (left !== undefined)
-                declarePattern(left, visit, scan);
-            if (right !== undefined)
-                walk({ node: right, parent: pattern, key: "right", depth: visit.depth }, scan);
-            return;
-        }
-        default:
-            walk({ node: pattern, parent: undefined, key: "", depth: visit.depth }, scan);
-    }
-}
-function declareId(node, scan) {
-    const id = nodeAt(node, "id");
-    const name = id === undefined ? undefined : stringAt(id, "name");
-    if (name !== undefined)
-        scan.declared.add(name);
-}
-function walkFunction(v, scan) {
-    declareId(v.node, scan);
-    const inner = { depth: v.depth + 1 };
-    for (const param of nodesAt(v.node, "params"))
-        declarePattern(param, inner, scan);
-    const body = nodeAt(v.node, "body");
-    if (body !== undefined)
-        walk({ node: body, parent: v.node, key: "body", depth: inner.depth }, scan);
-}
-function jsxReference(name) {
-    switch (name.type) {
-        case "JSXIdentifier": {
-            const id = stringAt(name, "name");
-            if (id === undefined || /^[a-z]/.test(id) || id.includes("-"))
-                return undefined;
-            return { name: id, start: name.start };
-        }
-        case "JSXMemberExpression": {
-            let object = nodeAt(name, "object");
-            while (object !== undefined && object.type === "JSXMemberExpression")
-                object = nodeAt(object, "object");
-            const root = object === undefined ? undefined : stringAt(object, "name");
-            return object === undefined || root === undefined || root === "this" ? undefined : { name: root, start: object.start };
-        }
-        default:
-            return undefined;
-    }
-}
-function isNonReferenceIdentifier(v) {
-    const parent = v.parent;
-    if (parent === undefined)
-        return false;
-    switch (true) {
-        case parent.type === "MemberExpression" && v.key === "property" && isComputed(parent) === false:
-        case (parent.type === "Property" || parent.type === "MethodDefinition" || parent.type === "PropertyDefinition") &&
-            v.key === "key" &&
-            isComputed(parent) === false:
-        case parent.type === "LabeledStatement" || parent.type === "BreakStatement" || parent.type === "ContinueStatement":
-        case parent.type === "ExportSpecifier" && v.key === "exported":
-        case parent.type === "MetaProperty":
-            return true;
-        default:
-            return false;
-    }
-}
-function walk(v, scan) {
-    const node = v.node;
-    switch (node.type) {
-        case "Identifier": {
-            const name = stringAt(node, "name");
-            if (name !== undefined && isNonReferenceIdentifier(v) === false)
-                scan.refs.push({ name, start: node.start });
-            return;
-        }
-        case "ImportDeclaration":
-        case "ImportExpression":
-        case "ExportAllDeclaration":
-            return;
-        case "ExportNamedDeclaration":
-            if (nodeAt(node, "source") !== undefined)
-                return;
-            break;
-        case "VariableDeclarator": {
-            const id = nodeAt(node, "id");
-            if (id !== undefined)
-                declarePattern(id, v, scan);
-            const init = nodeAt(node, "init");
-            if (init !== undefined)
-                walk({ node: init, parent: node, key: "init", depth: v.depth }, scan);
-            return;
-        }
-        case "FunctionDeclaration":
-        case "FunctionExpression":
-        case "ArrowFunctionExpression":
-            walkFunction(v, scan);
-            return;
-        case "ClassDeclaration":
-        case "ClassExpression": {
-            declareId(node, scan);
-            const superClass = nodeAt(node, "superClass");
-            if (superClass !== undefined)
-                walk({ node: superClass, parent: node, key: "superClass", depth: v.depth }, scan);
-            const body = nodeAt(node, "body");
-            if (body !== undefined)
-                walk({ node: body, parent: node, key: "body", depth: v.depth + 1 }, scan);
-            return;
-        }
-        case "CatchClause": {
-            const param = nodeAt(node, "param");
-            if (param !== undefined)
-                declarePattern(param, v, scan);
-            const body = nodeAt(node, "body");
-            if (body !== undefined)
-                walk({ node: body, parent: node, key: "body", depth: v.depth }, scan);
-            return;
-        }
-        case "UnaryExpression": {
-            const arg = nodeAt(node, "argument");
-            if (stringAt(node, "operator") === "typeof" && arg !== undefined && arg.type === "Identifier")
-                return;
-            break;
-        }
-        case "CallExpression": {
-            const callee = nodeAt(node, "callee");
-            const hook = callee === undefined ? undefined : hookName(callee);
-            if (hook !== undefined && v.depth === 0)
-                scan.hookCalls.push({ name: hook, start: node.start });
-            break;
-        }
-        case "JSXElement": {
-            const opening = nodeAt(node, "openingElement");
-            if (opening !== undefined)
-                walk({ node: opening, parent: node, key: "openingElement", depth: v.depth }, scan);
-            for (const child of nodesAt(node, "children"))
-                walk({ node: child, parent: node, key: "children", depth: v.depth }, scan);
-            return;
-        }
-        case "JSXOpeningElement": {
-            const name = nodeAt(node, "name");
-            const ref = name === undefined ? undefined : jsxReference(name);
-            if (ref !== undefined)
-                scan.refs.push(ref);
-            for (const attr of nodesAt(node, "attributes"))
-                walk({ node: attr, parent: node, key: "attributes", depth: v.depth }, scan);
-            return;
-        }
-        case "JSXAttribute": {
-            const value = nodeAt(node, "value");
-            if (value !== undefined)
-                walk({ node: value, parent: node, key: "value", depth: v.depth }, scan);
-            return;
-        }
-        case "JSXText":
-        case "JSXIdentifier":
-        case "JSXNamespacedName":
-        case "JSXMemberExpression":
-        case "JSXClosingElement":
-        case "JSXClosingFragment":
-        case "JSXOpeningFragment":
-        case "Literal":
-        case "TemplateElement":
-            return;
-        default:
-            break;
-    }
-    for (const { key, child } of childNodes(node))
-        walk({ node: child, parent: node, key, depth: v.depth }, scan);
-}
-function hookName(callee) {
-    switch (callee.type) {
-        case "Identifier": {
-            const name = stringAt(callee, "name");
-            return name !== undefined && HOOK_NAME.test(name) ? name : undefined;
-        }
-        case "MemberExpression": {
-            const property = nodeAt(callee, "property");
-            const name = property === undefined || isComputed(callee) ? undefined : stringAt(property, "name");
-            return name !== undefined && HOOK_NAME.test(name) ? name : undefined;
-        }
-        default:
-            return undefined;
-    }
+function isGlobalName(name) {
+    return isOpensGlobalName(name);
 }
 function collectImports(program, scan) {
     for (const statement of nodesAt(program, "body")) {
@@ -858,10 +686,6 @@ function collectImports(program, scan) {
             case "ImportDeclaration": {
                 const names = [];
                 for (const specifier of nodesAt(statement, "specifiers")) {
-                    const local = nodeAt(specifier, "local");
-                    const localName = local === undefined ? undefined : stringAt(local, "name");
-                    if (localName !== undefined)
-                        scan.declared.add(localName);
                     const imported = nodeAt(specifier, "imported");
                     const importedName = imported === undefined ? undefined : (stringAt(imported, "name") ?? stringAt(imported, "value"));
                     if (specifier.type === "ImportSpecifier" && importedName !== undefined)
@@ -899,9 +723,6 @@ function collectDynamicImports(node, scan) {
     for (const { child } of childNodes(node))
         collectDynamicImports(child, scan);
 }
-function lineAt(source, offset) {
-    return source.slice(0, offset).split("\n").length;
-}
 function resolveRelative(from, spec) {
     const base = spec.startsWith("/") ? [] : from.split("/").slice(1, -1);
     const parts = [...base];
@@ -963,10 +784,10 @@ function checkFile(args) {
     const program = asNode(parsed.Ok());
     if (program === undefined)
         return NOTHING;
-    const scan = { declared: new Set(), refs: [], hookCalls: [], imports: [] };
+    const scan = { imports: [] };
     collectImports(program, scan);
     collectDynamicImports(program, scan);
-    walk({ node: program, parent: undefined, key: "", depth: 0 }, scan);
+    const scopes = scanScopes(program);
     const findings = [];
     const deps = [];
     for (const imp of scan.imports) {
@@ -1012,27 +833,147 @@ function checkFile(args) {
         }
     }
     const reported = new Set();
-    for (const ref of scan.refs) {
-        if (scan.declared.has(ref.name) || isGlobalName(ref.name) || reported.has(ref.name))
+    for (const ref of scopes.refs) {
+        if (isGlobalName(ref.name) || resolveName(ref.name, ref.scope) !== undefined)
+            continue;
+        const declaredAt = scopes.declaredAnywhere.get(ref.name);
+        const where = { file: path, line: lineAt(source, ref.start), column: columnAt(source, ref.start), name: ref.name };
+        if (declaredAt === undefined) {
+            if (reported.has(ref.name))
+                continue;
+            reported.add(ref.name);
+            findings.push({ class: "undefined-identifier", message: `${ref.name} is used but never imported or declared`, ...where });
             continue;
-        reported.add(ref.name);
+        }
         findings.push({
-            class: "undefined-identifier",
-            message: `${ref.name} is used but never imported or declared`,
-            file: path,
-            line: lineAt(source, ref.start),
+            class: "out-of-scope-identifier",
+            message: `${ref.name} is used here but declared only inside another function or block (line ${lineAt(source, declaredAt)}), so it is not defined at this line; declare it where every use can see it`,
+            ...where,
         });
     }
-    for (const hook of scan.hookCalls) {
+    const hookCalls = hookCallStarts(scopes);
+    for (const call of scopes.calls) {
+        if (call.atModule === false || hookCalls.has(call.start) === false)
+            continue;
+        const name = call.callee.kind === "id" ? call.callee.name : call.callee.property;
         findings.push({
             class: "hook-at-module-scope",
-            message: `${hook.name}(…) is called at module scope; hooks run inside a component or another hook`,
+            message: `${name}(…) is called at module scope; hooks run inside a component or another hook`,
+            file: path,
+            line: lineAt(source, call.start),
+        });
+    }
+    for (const hook of checkHooks(program, (start) => hookCalls.has(start))) {
+        findings.push({
+            class: hook.class,
+            message: hook.message,
             file: path,
             line: lineAt(source, hook.start),
+            column: columnAt(source, hook.start),
+        });
+    }
+    for (const member of memberFindings(scopes)) {
+        findings.push({
+            class: "unknown-member",
+            message: member.message,
+            file: path,
+            line: lineAt(source, member.nameStart),
+            column: columnAt(source, member.nameStart),
+            name: member.name,
+        });
+    }
+    for (const inert of checkInert(program, (offset) => lineAt(source, offset))) {
+        findings.push({
+            class: inert.class,
+            message: inert.message,
+            file: path,
+            line: lineAt(source, inert.start),
+            column: columnAt(source, inert.start),
+            ...(inert.anchorStart === undefined ? {} : { anchorLine: lineAt(source, inert.anchorStart) }),
         });
     }
     return { findings: findings.sort((a, b) => a.line - b.line), deps };
 }
+function importedFrom(binding, spec, name) {
+    return binding?.origin?.kind === "import" && binding.origin.imported === name && spec(binding.origin.spec);
+}
+function shapeOf(binding) {
+    const origin = binding?.origin;
+    if (origin === undefined)
+        return undefined;
+    if (importedFrom(binding, (s) => TOAST_HOMES.has(s), "toast"))
+        return "toast";
+    if (origin.kind !== "call")
+        return undefined;
+    if (importedFrom(resolveName(origin.callee, origin.scope), isRuntimeSpecifier, "useFireproof") === false)
+        return undefined;
+    if (origin.key === undefined)
+        return "useFireproofResult";
+    return origin.key === "database" ? "database" : undefined;
+}
+const SHAPE_ALLOWED = {
+    toast: new Set([...TOAST_MEMBERS, ...FUNCTION_MEMBERS]),
+    useFireproofResult: new Set([...USE_FIREPROOF_RESULT_KEYS, ...OBJECT_MEMBERS]),
+    database: new Set([...DATABASE_MEMBERS, ...OBJECT_MEMBERS]),
+};
+function shapeMessage(shape, read, member) {
+    switch (shape) {
+        case "toast":
+            return `${read}.${member} is not a function: toast has ${TOAST_MEMBERS.join(", ")} (or call ${read}("…") itself)`;
+        case "useFireproofResult":
+            return `useFireproof(…) returns no ${member}; it returns ${USE_FIREPROOF_RESULT_KEYS.join(", ")}`;
+        case "database":
+            return `${read}.${member} does not exist on the database; use useLiveQuery for lists, or database.put, get, del, query, allDocs, subscribe`;
+    }
+}
+function memberFindings(scopes) {
+    const out = [];
+    const reported = new Set();
+    function report(finding) {
+        if (reported.has(finding.start))
+            return;
+        reported.add(finding.start);
+        out.push(finding);
+    }
+    for (const use of scopes.members) {
+        if (use.called === false)
+            continue;
+        const shape = shapeOf(resolveName(use.root, use.scope));
+        if (shape === undefined)
+            continue;
+        const [first, second] = use.path;
+        if (use.path.length === 1 && SHAPE_ALLOWED[shape].has(first) === false) {
+            report({ message: shapeMessage(shape, use.root, first), start: use.start, name: first, nameStart: use.propStart });
+        }
+        if (use.path.length === 2 &&
+            shape === "useFireproofResult" &&
+            first === "database" &&
+            SHAPE_ALLOWED.database.has(second) === false) {
+            report({
+                message: shapeMessage("database", `${use.root}.database`, second),
+                start: use.start,
+                name: second,
+                nameStart: use.propStart,
+            });
+        }
+    }
+    for (const call of scopes.calls) {
+        if (call.callee.kind !== "id")
+            continue;
+        const origin = resolveName(call.callee.name, call.scope)?.origin;
+        if (origin?.kind !== "call" || origin.key === undefined || SHAPE_ALLOWED.useFireproofResult.has(origin.key))
+            continue;
+        if (importedFrom(resolveName(origin.callee, origin.scope), isRuntimeSpecifier, "useFireproof") === false)
+            continue;
+        report({
+            message: shapeMessage("useFireproofResult", "useFireproof", origin.key),
+            start: call.start,
+            name: call.callee.name,
+            nameStart: call.start,
+        });
+    }
+    return out;
+}
 function isBrowserModule(path) {
     return /\.(jsx?|tsx?)$/.test(path) && path.startsWith("/~~") === false && path !== "/access.js" && path !== "/backend.js";
 }
@@ -1052,4 +993,41 @@ export function checkOpens(vfs) {
     }
     return { opens: findings.every((finding) => OPENS_ADVISORY_CLASSES.has(finding.class)), findings };
 }
+export function collapseOpensFindings(findings) {
+    const counts = new Map();
+    const keyOf = (f) => (f.name === undefined ? undefined : `${f.class}|${f.file}|${f.name}`);
+    for (const f of findings) {
+        const key = keyOf(f);
+        if (key !== undefined)
+            counts.set(key, (counts.get(key) ?? 0) + 1);
+    }
+    const seen = new Set();
+    const out = [];
+    for (const f of findings) {
+        const key = keyOf(f);
+        if (key === undefined) {
+            out.push(f);
+            continue;
+        }
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const n = counts.get(key) ?? 1;
+        out.push(n > 1 ? { ...f, message: `${f.message} (${n} uses)` } : f);
+    }
+    return out;
+}
+export function opensFindingKey(finding) {
+    return `${finding.class}|${finding.file}|${finding.message.replace(/\(line \d+\)/g, "(line)").replace(/ \(\d+ uses\)$/, "")}`;
+}
+export function opensBaseline(vfs) {
+    if (vfs.size === 0)
+        return new Set();
+    return new Set(checkOpens(vfs)
+        .findings.filter((finding) => OPENS_ADVISORY_CLASSES.has(finding.class) === false)
+        .map(opensFindingKey));
+}
+export function newOpensFindings(verdict, baseline) {
+    return verdict.findings.filter((finding) => OPENS_ADVISORY_CLASSES.has(finding.class) === false && baseline.has(opensFindingKey(finding)) === false);
+}
 //# sourceMappingURL=opens-check.js.map