@prestack/thread 0.1.3 → 0.1.5

package/dist/integrity/slopnators/sl_undeclared_destination.ts

@@ -1,5 +1,8 @@
 import type { Slopnator } from '../slopnator.ts'
 
+import { descend, read, reached } from '../../core/descend.ts'
+import { rowsIn } from './sl_unthreaded.ts'
+
 interface Held {
   readonly type?: string
   readonly name?: unknown
@@ -11,9 +14,6 @@ interface Held {
 }
 
 const HREF = 'href'
-const GLOBALS = new Set(['window', 'globalThis', 'self'])
-const HISTORIES = new Set(['router', 'navigation', 'history'])
-const MOVES = new Set(['push', 'replace', 'prefetch'])
 
 const named = (held: Held | undefined): string | undefined => {
   if (held?.type === 'Identifier' || held?.type === 'JSXIdentifier') return typeof held.name === 'string' ? held.name : undefined
@@ -27,39 +27,87 @@ const spoken = (held: Held): string | undefined => {
   return undefined
 }
 
-function moving(held: Held): string | undefined {
-  if (held.type !== 'MemberExpression' || held.computed === true) return undefined
-  const on = named(held.object)
-  const reached = named(held.property)
-  if (on === undefined || reached === undefined) return undefined
-  if (GLOBALS.has(on) && reached === 'location') return `${on}.location`
-  if (HISTORIES.has(on) && MOVES.has(reached)) return `${on}.${reached}()`
-  return undefined
+const SCREEN = 'screen'
+
+const PASCAL = (id: string): string =>
+  id
+    .split(/[-_]/)
+    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
+    .join('')
+
+const nameOf = (at: string): string =>
+  PASCAL((at.split('\\').join('/').split('/').at(-1) ?? at).replace(/^scr_/, '').replace(/\.[^.]+$/, ''))
+
+const routeFor = (id: string): string => `/${id}`
+
+function addressed(): ReadonlyMap<string, string> {
+  const found = new Map<string, string>()
+
+  descend()
+
+  for (const at of reached()) {
+    const text = read(at)
+    if (text === undefined) continue
+
+    let waiting: { readonly id: string; readonly at: string }[] = []
+    for (const one of rowsIn(text)) {
+      if (one.id === undefined) continue
+      if (one.list === 'declares') {
+        if (one.at !== undefined) waiting.push({ id: one.id, at: one.at })
+        continue
+      }
+      if (one.list !== undefined) continue
+      if (one.id === SCREEN) for (const row of waiting) found.set(routeFor(row.id), nameOf(row.at))
+      waiting = []
+    }
+  }
+
+  return found
 }
 
 export const slopnator: Slopnator = {
-  on: ['JSXAttribute', 'Property', 'MemberExpression'],
+  on: ['JSXAttribute', 'Property', 'Literal'],
   holds: (node) => {
     const held = node as Held
-    const written = spoken(held) === HREF ? '`href`' : moving(held)
-    if (written === undefined) return false
+
+    if (spoken(held) === HREF) {
+      return (
+        '`href` moves somebody without naming a screen, so the map holds no link for it — ' +
+        'the destination reads as unreachable to the orphan pass, the app reads as having no path to it, and it navigates correctly'
+      )
+    }
+
+    if (held.type !== 'Literal' || typeof held.value !== 'string') return false
+
+    const screen = addressed().get(held.value)
+    if (screen === undefined) return false
+
     return (
-      `${written} moves somebody without naming a screen, so the map holds no link for it — ` +
-      'the destination reads as unreachable to the orphan pass, the app reads as having no path to it, and it navigates correctly'
+      'this writes the address of ' + screen + ' rather than naming it, so the map holds no link for it — ' +
+      'the destination reads as unreachable to the orphan pass and the app navigates there anyway. Name the screen: navigateTo="' + screen + '"'
     )
   },
   proves: {
     wrong: [
       "const link = { href: '/orders/42' }",
-      "window.location = '/orders/42'",
-      "router.push('/orders/42')",
-      'history.replace(next)',
-      'navigation.prefetch(next)',
+      '<a href="/orders/42">{label}</a>',
+      {
+        files: [
+          { at: 'thread/core/thread.ts', source: "export interface Threaded {\n  readonly id?: string\n  readonly at?: string\n  readonly describes?: string\n  readonly declares?: readonly Threaded[]\n  readonly derives?: readonly Threaded[]\n  readonly seeds?: readonly Threaded[]\n}\n" },
+          { at: 'threads/thread.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const THREAD: Threaded = {\n  declares: [\n    {\n      at: 'threads/_probe_screens.ts',\n    },\n  ],\n}\n" },
+          { at: 'threads/_probe_screens.ts', source: "import type { Threaded } from '../thread/core/thread.ts'\n\nexport const SCREENS: Threaded = {\n  id: 'screen',\n  declares: [\n    {\n      id: 'orders',\n      at: 'screens/scr_orders.tsx',\n    },\n  ],\n}\n" },
+          { at: 'app/_probe_address.tsx', source: "export const HELD = router.push('/orders')\n" },
+        ],
+        at: 'app/_probe_address.tsx',
+      },
     ],
     right: [
-      '<Link.label navigateTo="Home" labelKey="home.title" />',
+      'const path = router.pathname',
+      '<Link.linkInline navigateTo="Home" labelKey="home.title" />',
       "const to = { navigateTo: 'Order', labelKey: 'order.title' }",
       'const rows = orders.push(one)',
+      "const parts = one.split('/')",
+      "const at = '/api/webhook'",
     ],
   },
 }

package/dist/integrity/slopnators/sl_undeclared_list.d.ts

@@ -0,0 +1,2 @@
+import type { Slopnator } from '../slopnator.ts';
+export declare const slopnator: Slopnator;

package/dist/integrity/slopnators/sl_undeclared_list.js

@@ -0,0 +1,363 @@
+import { dirname, resolve } from 'node:path';
+import ts from 'typescript';
+import { readFileSync } from '../../integrations/disk.js';
+const LIST = 2;
+const WIDENED = 'TSAsExpression';
+function bare(held) {
+    let one = held ?? undefined;
+    while (one?.type === WIDENED)
+        one = one.expression;
+    return one;
+}
+const spoken = (held) => {
+    const one = bare(held);
+    return one?.type === 'Literal' && typeof one.value === 'string';
+};
+const strings = (held) => {
+    const one = bare(held);
+    if (one?.type !== 'ArrayExpression')
+        return false;
+    const all = one.elements ?? [];
+    return all.length >= LIST && all.every((each) => spoken(each) || woven(each));
+};
+const SPREAD = 'SpreadElement';
+function woven(held) {
+    const one = bare(held);
+    if (one?.type !== SPREAD)
+        return false;
+    let words = 0;
+    let other = false;
+    const walk = (node, seen) => {
+        if (node === null || typeof node !== 'object' || seen.has(node))
+            return;
+        seen.add(node);
+        if (Array.isArray(node)) {
+            for (const each of node)
+                walk(each, seen);
+            return;
+        }
+        const held = node;
+        if (held.type === 'Literal') {
+            if (typeof held.value === 'string')
+                words += 1;
+            else
+                other = true;
+            return;
+        }
+        for (const [key, each] of Object.entries(node)) {
+            if (key !== BACK)
+                walk(each, seen);
+        }
+    };
+    walk(one.argument, new Set());
+    return words > 0 && !other;
+}
+function valued(held) {
+    const found = [];
+    for (const one of held.properties ?? []) {
+        if (one?.type === 'Property')
+            found.push(one.value);
+    }
+    return found;
+}
+function tabled(held, seen) {
+    const one = bare(held);
+    if (one === undefined || one.type !== 'ObjectExpression' || seen.has(one))
+        return false;
+    seen.add(one);
+    const all = valued(one);
+    if (all.filter((each) => spoken(each)).length >= LIST)
+        return true;
+    return all.some((each) => strings(each) || tabled(each, seen));
+}
+function drawn(held) {
+    if (held.type !== 'NewExpression' || held.callee?.type !== 'Identifier' || held.callee.name !== 'Set')
+        return undefined;
+    const only = held.arguments ?? [];
+    if (only.length !== 1)
+        return undefined;
+    const call = bare(only[0]);
+    const callee = call?.callee;
+    if (call?.type !== 'CallExpression' || callee?.type !== 'MemberExpression')
+        return undefined;
+    if (callee.object?.type !== 'Identifier' || callee.object.name !== 'Object')
+        return undefined;
+    const asked = callee.property?.name;
+    if (asked !== 'keys' && asked !== 'values')
+        return undefined;
+    const from = bare((call.arguments ?? [])[0]);
+    return from?.type === 'Identifier' ? from.name : undefined;
+}
+function adapted(node) {
+    if (ts.isAsExpression(node) || ts.isParenthesizedExpression(node)) {
+        const inner = adapted(node.expression);
+        return inner === undefined ? undefined : { type: WIDENED, expression: inner };
+    }
+    if (ts.isStringLiteral(node))
+        return { type: 'Literal', value: node.text };
+    if (ts.isSpreadElement(node))
+        return { type: SPREAD, argument: adapted(node.expression) ?? null };
+    if (ts.isCallExpression(node)) {
+        return { type: 'CallExpression', arguments: node.arguments.map((one) => adapted(one)).filter((one) => one !== undefined) };
+    }
+    if (ts.isArrayLiteralExpression(node)) {
+        return { type: 'ArrayExpression', elements: node.elements.map((one) => adapted(one) ?? null) };
+    }
+    if (ts.isObjectLiteralExpression(node)) {
+        const properties = [];
+        for (const one of node.properties) {
+            if (!ts.isPropertyAssignment(one))
+                continue;
+            const value = adapted(one.initializer);
+            if (value !== undefined)
+                properties.push({ type: 'Property', value });
+        }
+        return { type: 'ObjectExpression', properties };
+    }
+    return undefined;
+}
+function parsed(at, text) {
+    return ts.createSourceFile(at, text, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+}
+function brought(source, name) {
+    for (const statement of source.statements) {
+        if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier))
+            continue;
+        const bindings = statement.importClause?.namedBindings;
+        if (bindings === undefined || !ts.isNamedImports(bindings))
+            continue;
+        if (!bindings.elements.some((one) => one.name.text === name))
+            continue;
+        return statement.moduleSpecifier.text;
+    }
+    return undefined;
+}
+function elsewhere(at, name) {
+    const specifier = brought(parsed(at.filename, at.text), name);
+    if (specifier === undefined || !specifier.startsWith('.'))
+        return undefined;
+    const path = resolve(dirname(at.filename), specifier);
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    for (const statement of parsed(path, text).statements) {
+        if (!ts.isVariableStatement(statement))
+            continue;
+        for (const one of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(one.name) || one.name.text !== name || one.initializer === undefined)
+                continue;
+            return adapted(one.initializer);
+        }
+    }
+    return undefined;
+}
+function initOf(held, name, seen) {
+    if (held === null || typeof held !== 'object' || seen.has(held))
+        return undefined;
+    seen.add(held);
+    if (Array.isArray(held)) {
+        for (const one of held) {
+            const found = initOf(one, name, seen);
+            if (found !== undefined)
+                return found;
+        }
+        return undefined;
+    }
+    const node = held;
+    const init = node.init ?? undefined;
+    if (node.type === 'VariableDeclarator' && node.id?.type === 'Identifier' && node.id.name === name && init !== undefined)
+        return init;
+    for (const [key, one] of Object.entries(held)) {
+        if (key === BACK)
+            continue;
+        const found = initOf(one, name, seen);
+        if (found !== undefined)
+            return found;
+    }
+    return undefined;
+}
+function listed(init, program, at, through) {
+    const one = bare(init);
+    if (one === undefined)
+        return false;
+    if (strings(one))
+        return true;
+    if (tabled(one, new Set()))
+        return true;
+    if (one.type === 'NewExpression' || one.type === 'CallExpression') {
+        const only = one.arguments ?? [];
+        if (only.length === 1 && strings(only[0]))
+            return true;
+    }
+    const from = drawn(one);
+    if (from === undefined || through.has(from))
+        return false;
+    const followed = new Set(through);
+    followed.add(from);
+    const here = initOf(program, from, new Set());
+    return listed(here ?? elsewhere(at, from), program, at, followed);
+}
+const asks = (held, name) => {
+    const callee = held?.callee;
+    if (held?.type !== 'CallExpression' || callee?.type !== 'MemberExpression')
+        return false;
+    const on = bare(callee.object);
+    if (on?.type !== 'Identifier' || on.name !== name)
+        return false;
+    const said = callee.property?.name;
+    return said === 'has' || said === 'includes';
+};
+const BACK = 'parent';
+function asking(held, name, seen) {
+    if (held === null || typeof held !== 'object' || seen.has(held))
+        return false;
+    seen.add(held);
+    if (Array.isArray(held))
+        return held.some((one) => asking(one, name, seen));
+    if (asks(held, name))
+        return true;
+    return Object.entries(held).some(([key, one]) => key !== BACK && asking(one, name, seen));
+}
+function consults(node, name) {
+    if (node.type === 'MemberExpression') {
+        const on = bare(node.object);
+        if (on?.type === 'Identifier' && on.name === name)
+            return true;
+    }
+    const callee = node.callee;
+    if (node.type !== 'CallExpression' || callee?.type !== 'MemberExpression')
+        return false;
+    if (callee.object?.type !== 'Identifier' || callee.object.name !== 'Object')
+        return false;
+    const only = node.arguments ?? [];
+    const from = bare(only[0]);
+    return only.length === 1 && from?.type === 'Identifier' && from.name === name;
+}
+function consulted(held, name, seen) {
+    if (held === null || typeof held !== 'object' || seen.has(held))
+        return false;
+    seen.add(held);
+    if (Array.isArray(held))
+        return held.some((one) => consulted(one, name, seen));
+    if (consults(held, name))
+        return true;
+    return Object.entries(held).some(([key, one]) => key !== BACK && consulted(one, name, seen));
+}
+function continues(held) {
+    if (held === null || held === undefined)
+        return false;
+    if (held.type === 'ContinueStatement')
+        return true;
+    if (held.type !== 'BlockStatement')
+        return false;
+    return (held.body ?? []).some((one) => one?.type === 'ContinueStatement');
+}
+const LEAVES = 'ReturnStatement';
+const THROWN = 'ThrowStatement';
+const leaving = (one) => one?.type === LEAVES || one?.type === THROWN;
+function exits(held) {
+    if (held === null || held === undefined)
+        return false;
+    if (leaving(held))
+        return true;
+    if (held.type !== 'BlockStatement')
+        return false;
+    return (held.body ?? []).some((one) => leaving(one));
+}
+function look(held, name, found, seen) {
+    if (held === null || typeof held !== 'object' || seen.has(held))
+        return;
+    seen.add(held);
+    if (Array.isArray(held)) {
+        for (const one of held)
+            look(one, name, found, seen);
+        return;
+    }
+    const node = held;
+    if (node.type === 'UnaryExpression' && node.operator === '!' && asks(node.argument ?? undefined, name)) {
+        found.skips = true;
+        return;
+    }
+    if (node.type === 'IfStatement' && continues(node.consequent) && asking(node.test, name, new Set())) {
+        found.skips = true;
+        look(node.consequent, name, found, seen);
+        look(node.alternate, name, found, seen);
+        return;
+    }
+    if (node.type === 'IfStatement' && exits(node.consequent) && asking(node.test, name, new Set())) {
+        found.gates = true;
+        return;
+    }
+    if (asks(node, name)) {
+        found.gates = true;
+        return;
+    }
+    for (const [key, one] of Object.entries(node)) {
+        if (key !== BACK)
+            look(one, name, found, seen);
+    }
+}
+export const slopnator = {
+    on: ['VariableDeclarator'],
+    holds: (node, at) => {
+        const held = node;
+        const program = at.ancestors().find((one) => one?.type === 'Program');
+        if (!listed(held.init, program, at, new Set()))
+            return false;
+        const named = held.id?.type === 'Identifier' ? held.id.name : undefined;
+        const table = bare(held.init)?.type === 'ObjectExpression';
+        if (table && (named === undefined || !consulted(program, named, new Set())))
+            return false;
+        if (named !== undefined) {
+            const found = { gates: false, skips: false };
+            look(program, named, found, new Set());
+            if (!found.gates && found.skips)
+                return false;
+        }
+        return (`\`${named ?? 'this'}\` is ${table ? 'a table' : 'a list'} of words written out here and this check refuses what is IN it, so ` +
+            'whatever breaks the rule under a name nobody typed walks straight past. Wrapping them in `as const`, nesting them under a key, ' +
+            'or building a set out of the keys leaves the same list one step further out of sight. A list that decides what a check CATCHES ' +
+            'has to come from the tree: `thread inspect <word>` names the row that coins any word you need, and a check that reads those ' +
+            'rows widens when the tree does. A list a check only SKIPS is left alone, because adding a word to one of those makes it ' +
+            'stricter and it can never go blind.');
+    },
+    proves: {
+        wrong: [
+            "const CROSSINGS = ['fetch', 'setTimeout', 'setInterval']",
+            "const STARTS = new Set(['node:child_process', 'child_process'])\nexport const opens = (from: string): boolean => {\n  if (!STARTS.has(from)) return false\n  return true\n}",
+            "const GLOBALS = new Set(['Date', 'performance', 'Math'])",
+            "const MOVES = new Set(['push', 'replace'])\nexport const moved = (one: string): boolean => MOVES.has(one)",
+            "const SURFACES = ['cli', 'api', 'mcp'] as const\nexport const surfaced = (one: string): boolean => (SURFACES as readonly string[]).includes(one)",
+            "const MOVING = { globals: ['window', 'globalThis'], histories: ['router', 'history'] }\nexport const moves = (one: string): boolean => MOVING.globals.includes(one)",
+            "const HANDED_BY = { postgres: 'store', pglite: 'store', https: 'http' }\nexport const handedBy = (reach: string): string => HANDED_BY[reach] ?? reach",
+            "const HANDS = { postgres: 'store', pglite: 'store' }\nconst PINS = new Set(Object.keys(HANDS))\nexport const pinned = (one: string): boolean => PINS.has(one)",
+            {
+                files: [
+                    { at: 'threads/held.ts', source: "export const PINNED = { clock: ['Date.now', 'setTimeout'] }\n" },
+                    { at: 'threads/slopnators/sl_probe_followed.ts', source: "import { PINNED } from '../held.ts'\n\nconst PINS = new Set(Object.keys(PINNED))\nexport const pinned = (one: string): boolean => PINS.has(one)\n" },
+                ],
+                at: 'threads/slopnators/sl_probe_followed.ts',
+            },
+        ],
+        right: [
+            'const CROSSINGS = declared()',
+            "const UNDER = 'operations/'",
+            "const COMMON = new Set(['a', 'the'])\nexport const words = (all: readonly string[]): readonly string[] => all.filter((one) => !COMMON.has(one))",
+            "const SKIP = new Set(['dist', 'node_modules'])\nexport function walk(names: readonly string[]): number {\n  let seen = 0\n  for (const name of names) {\n    if (SKIP.has(name)) continue\n    seen += 1\n  }\n  return seen\n}",
+            "const LEFT = ['dist', 'node_modules'] as const\nexport function walked(names: readonly string[]): number {\n  let seen = 0\n  for (const name of names) {\n    if ((LEFT as readonly string[]).includes(name)) continue\n    seen += 1\n  }\n  return seen\n}",
+            "export const SAYS = { cli: 'runs at a terminal', api: 'answers a request' }",
+            {
+                files: [
+                    { at: 'threads/made.ts', source: "export const MADE = declared()\n" },
+                    { at: 'threads/slopnators/sl_probe_derived.ts', source: "import { MADE } from '../made.ts'\n\nconst PICKED = new Set(Object.keys(MADE))\nexport const picked = (one: string): boolean => PICKED.has(one)\n" },
+                ],
+                at: 'threads/slopnators/sl_probe_derived.ts',
+            },
+            "export const slopnator = { on: ['CallExpression', 'NewExpression'], holds: () => false, proves: { wrong: ['new Date()'], right: ['const at = 1'] } }",
+        ],
+    },
+};