@llui/compiler 0.3.0

package/dist/modules/spread-in-children.js

@@ -0,0 +1,144 @@
+// `spread-in-children` — errors when an element-helper's children array
+// contains a spread of a dynamic source (`div([...someList()])`).
+// Disables the compiler's template-clone optimization. Locally-bounded
+// spreads (`const xs = [a, b]; div([...xs])`) are exempt. Migrated from
+// `@llui/eslint-plugin/src/rules/spread-in-children.ts`.
+import ts from 'typescript';
+import { rangeFromOffsets } from '../diagnostic.js';
+import { ELEMENT_HELPERS } from './_element-helpers.js';
+const ARRAY_ITERATION_METHODS = new Set([
+    'map',
+    'filter',
+    'flatMap',
+    'slice',
+    'concat',
+    'reverse',
+    'sort',
+]);
+/** Walk top-level statements and resolve `const NAME = init` to the init expression. */
+function resolveTopLevelConstInit(sf, name) {
+    for (const stmt of sf.statements) {
+        if (!ts.isVariableStatement(stmt))
+            continue;
+        if (!(stmt.declarationList.flags & ts.NodeFlags.Const))
+            continue;
+        for (const d of stmt.declarationList.declarations) {
+            if (ts.isIdentifier(d.name) && d.name.text === name)
+                return d.initializer ?? null;
+        }
+    }
+    return null;
+}
+function isBoundedArrayReceiver(sf, recv) {
+    if (!ts.isIdentifier(recv))
+        return false;
+    const init = resolveTopLevelConstInit(sf, recv.text);
+    if (!init)
+        return false;
+    if (ts.isArrayLiteralExpression(init))
+        return true;
+    if (ts.isAsExpression(init)) {
+        return ts.isArrayLiteralExpression(init.expression);
+    }
+    return false;
+}
+function isBoundedInitializer(sf, init) {
+    if (ts.isArrayLiteralExpression(init))
+        return true;
+    if (ts.isAsExpression(init))
+        return isBoundedInitializer(sf, init.expression);
+    if (ts.isCallExpression(init)) {
+        if (ts.isIdentifier(init.expression))
+            return true;
+        if (ts.isPropertyAccessExpression(init.expression) && ts.isIdentifier(init.expression.name)) {
+            const method = init.expression.name.text;
+            if (!ARRAY_ITERATION_METHODS.has(method))
+                return true;
+            return isBoundedArrayReceiver(sf, init.expression.expression);
+        }
+    }
+    return false;
+}
+function isBoundedSpreadSource(sf, expr) {
+    // Strip parens + `as` casts before classifying — `...(cond ? a : b)`
+    // wraps the conditional in a ParenthesizedExpression; `...x as never`
+    // wraps in an AsExpression.
+    let e = expr;
+    while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e))
+        e = e.expression;
+    if (ts.isIdentifier(e)) {
+        const init = resolveTopLevelConstInit(sf, e.text);
+        if (!init)
+            return false;
+        return isBoundedInitializer(sf, init);
+    }
+    // Inline array literal — `[...[a, b]]` is degenerate but bounded.
+    if (ts.isArrayLiteralExpression(e))
+        return true;
+    // Ternary `cond ? [literal] : []` is a conditional-render pattern;
+    // both branches must be bounded for the whole spread to be bounded.
+    if (ts.isConditionalExpression(e)) {
+        return isBoundedSpreadSource(sf, e.whenTrue) && isBoundedSpreadSource(sf, e.whenFalse);
+    }
+    if (ts.isCallExpression(e)) {
+        if (ts.isPropertyAccessExpression(e.expression) && ts.isIdentifier(e.expression.name)) {
+            const method = e.expression.name.text;
+            if (!ARRAY_ITERATION_METHODS.has(method))
+                return true;
+            return isBoundedArrayReceiver(sf, e.expression.expression);
+        }
+        return true;
+    }
+    return false;
+}
+export function spreadInChildrenModule() {
+    return {
+        name: 'spread-in-children',
+        compilerVersion: '^0.3.0',
+        diagnostics: [
+            {
+                id: 'llui/spread-in-children',
+                description: 'Spread of a dynamic array into element children — disables template-clone optimization.',
+            },
+        ],
+        visitors: {
+            [ts.SyntaxKind.SourceFile]: (ctx, node) => {
+                const visited = node;
+                const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true);
+                const walk = (n) => {
+                    if (ts.isCallExpression(n) &&
+                        ts.isIdentifier(n.expression) &&
+                        ELEMENT_HELPERS.has(n.expression.text)) {
+                        for (const arg of n.arguments) {
+                            if (!ts.isArrayLiteralExpression(arg))
+                                continue;
+                            for (const el of arg.elements) {
+                                if (!ts.isSpreadElement(el))
+                                    continue;
+                                if (isBoundedSpreadSource(sf, el.expression))
+                                    continue;
+                                ctx.reportDiagnostic({
+                                    id: 'llui/spread-in-children',
+                                    severity: 'error',
+                                    category: 'perf',
+                                    message: `Spread of a dynamic array in children of \`${n.expression.text}()\` disables ` +
+                                        `the compiler's template-clone optimization (the child count is no longer ` +
+                                        `statically known). For dynamic child counts, use \`each({ items, key, render })\` ` +
+                                        `instead — it gets per-row scope, key-based reconciliation, and reactive bindings.`,
+                                    location: {
+                                        file: sf.fileName,
+                                        range: rangeFromOffsets(sf.text, el.getStart(sf), el.getEnd()),
+                                    },
+                                });
+                                break;
+                            }
+                        }
+                    }
+                    ts.forEachChild(n, walk);
+                };
+                walk(sf);
+            },
+        },
+    };
+}
+//# sourceMappingURL=spread-in-children.js.map

package/dist/modules/spread-in-children.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spread-in-children.js","sourceRoot":"","sources":["../../src/modules/spread-in-children.ts"],"names":[],"mappings":"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","sourcesContent":["// `spread-in-children` — errors when an element-helper's children array\n// contains a spread of a dynamic source (`div([...someList()])`).\n// Disables the compiler's template-clone optimization. Locally-bounded\n// spreads (`const xs = [a, b]; div([...xs])`) are exempt. Migrated from\n// `@llui/eslint-plugin/src/rules/spread-in-children.ts`.\n\nimport ts from 'typescript'\nimport { rangeFromOffsets } from '../diagnostic.js'\nimport type { CompilerModule } from '../module.js'\nimport { ELEMENT_HELPERS } from './_element-helpers.js'\n\nconst ARRAY_ITERATION_METHODS = new Set([\n  'map',\n  'filter',\n  'flatMap',\n  'slice',\n  'concat',\n  'reverse',\n  'sort',\n])\n\n/** Walk top-level statements and resolve `const NAME = init` to the init expression. */\nfunction resolveTopLevelConstInit(sf: ts.SourceFile, name: string): ts.Expression | null {\n  for (const stmt of sf.statements) {\n    if (!ts.isVariableStatement(stmt)) continue\n    if (!(stmt.declarationList.flags & ts.NodeFlags.Const)) continue\n    for (const d of stmt.declarationList.declarations) {\n      if (ts.isIdentifier(d.name) && d.name.text === name) return d.initializer ?? null\n    }\n  }\n  return null\n}\n\nfunction isBoundedArrayReceiver(sf: ts.SourceFile, recv: ts.Expression): boolean {\n  if (!ts.isIdentifier(recv)) return false\n  const init = resolveTopLevelConstInit(sf, recv.text)\n  if (!init) return false\n  if (ts.isArrayLiteralExpression(init)) return true\n  if (ts.isAsExpression(init)) {\n    return ts.isArrayLiteralExpression(init.expression)\n  }\n  return false\n}\n\nfunction isBoundedInitializer(sf: ts.SourceFile, init: ts.Expression): boolean {\n  if (ts.isArrayLiteralExpression(init)) return true\n  if (ts.isAsExpression(init)) return isBoundedInitializer(sf, init.expression)\n  if (ts.isCallExpression(init)) {\n    if (ts.isIdentifier(init.expression)) return true\n    if (ts.isPropertyAccessExpression(init.expression) && ts.isIdentifier(init.expression.name)) {\n      const method = init.expression.name.text\n      if (!ARRAY_ITERATION_METHODS.has(method)) return true\n      return isBoundedArrayReceiver(sf, init.expression.expression)\n    }\n  }\n  return false\n}\n\nfunction isBoundedSpreadSource(sf: ts.SourceFile, expr: ts.Expression): boolean {\n  // Strip parens + `as` casts before classifying — `...(cond ? a : b)`\n  // wraps the conditional in a ParenthesizedExpression; `...x as never`\n  // wraps in an AsExpression.\n  let e: ts.Expression = expr\n  while (ts.isParenthesizedExpression(e) || ts.isAsExpression(e)) e = e.expression\n  if (ts.isIdentifier(e)) {\n    const init = resolveTopLevelConstInit(sf, e.text)\n    if (!init) return false\n    return isBoundedInitializer(sf, init)\n  }\n  // Inline array literal — `[...[a, b]]` is degenerate but bounded.\n  if (ts.isArrayLiteralExpression(e)) return true\n  // Ternary `cond ? [literal] : []` is a conditional-render pattern;\n  // both branches must be bounded for the whole spread to be bounded.\n  if (ts.isConditionalExpression(e)) {\n    return isBoundedSpreadSource(sf, e.whenTrue) && isBoundedSpreadSource(sf, e.whenFalse)\n  }\n  if (ts.isCallExpression(e)) {\n    if (ts.isPropertyAccessExpression(e.expression) && ts.isIdentifier(e.expression.name)) {\n      const method = e.expression.name.text\n      if (!ARRAY_ITERATION_METHODS.has(method)) return true\n      return isBoundedArrayReceiver(sf, e.expression.expression)\n    }\n    return true\n  }\n  return false\n}\n\nexport function spreadInChildrenModule(): CompilerModule {\n  return {\n    name: 'spread-in-children',\n    compilerVersion: '^0.3.0',\n    diagnostics: [\n      {\n        id: 'llui/spread-in-children',\n        description:\n          'Spread of a dynamic array into element children — disables template-clone optimization.',\n      },\n    ],\n    visitors: {\n      [ts.SyntaxKind.SourceFile]: (ctx, node) => {\n        const visited = node as ts.SourceFile\n        const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true)\n        const walk = (n: ts.Node): void => {\n          if (\n            ts.isCallExpression(n) &&\n            ts.isIdentifier(n.expression) &&\n            ELEMENT_HELPERS.has(n.expression.text)\n          ) {\n            for (const arg of n.arguments) {\n              if (!ts.isArrayLiteralExpression(arg)) continue\n              for (const el of arg.elements) {\n                if (!ts.isSpreadElement(el)) continue\n                if (isBoundedSpreadSource(sf, el.expression)) continue\n                ctx.reportDiagnostic({\n                  id: 'llui/spread-in-children',\n                  severity: 'error',\n                  category: 'perf',\n                  message:\n                    `Spread of a dynamic array in children of \\`${n.expression.text}()\\` disables ` +\n                    `the compiler's template-clone optimization (the child count is no longer ` +\n                    `statically known). For dynamic child counts, use \\`each({ items, key, render })\\` ` +\n                    `instead — it gets per-row scope, key-based reconciliation, and reactive bindings.`,\n                  location: {\n                    file: sf.fileName,\n                    range: rangeFromOffsets(sf.text, el.getStart(sf), el.getEnd()),\n                  },\n                })\n                break\n              }\n            }\n          }\n          ts.forEachChild(n, walk)\n        }\n        walk(sf)\n      },\n    },\n  }\n}\n"]}

package/dist/modules/state-mutation.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerModule } from '../module.js';
+export declare function stateMutationModule(): CompilerModule;
+//# sourceMappingURL=state-mutation.d.ts.map

package/dist/modules/state-mutation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-mutation.d.ts","sourceRoot":"","sources":["../../src/modules/state-mutation.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAqClD,wBAAgB,mBAAmB,IAAI,cAAc,CA8GpD"}

package/dist/modules/state-mutation.js

@@ -0,0 +1,138 @@
+// `state-mutation` — errors on direct mutation of the state parameter
+// inside a component's update function. State is immutable; the
+// runtime compares old/new state by reference to compute the dirty
+// mask. Direct mutation breaks that invariant and silently disables
+// bitmask gating. Migrated from
+// `@llui/eslint-plugin/src/rules/state-mutation.ts`.
+import ts from 'typescript';
+import { rangeFromOffsets } from '../diagnostic.js';
+import { findComponentCalls } from './_shared.js';
+const MUTATING_METHODS = new Set([
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+    'fill',
+]);
+function findUpdateProperty(call) {
+    const arg = call.arguments[0];
+    if (!arg || !ts.isObjectLiteralExpression(arg))
+        return undefined;
+    for (const prop of arg.properties) {
+        if (ts.isPropertyAssignment(prop) &&
+            ts.isIdentifier(prop.name) &&
+            prop.name.text === 'update') {
+            return prop;
+        }
+    }
+    return undefined;
+}
+/** True when `expr` is a member access rooted at the state binding name. */
+function isStateMemberAccess(expr, stateName) {
+    if (!ts.isPropertyAccessExpression(expr) && !ts.isElementAccessExpression(expr))
+        return false;
+    const root = expr.expression;
+    if (ts.isIdentifier(root) && root.text === stateName)
+        return true;
+    return isStateMemberAccess(root, stateName);
+}
+export function stateMutationModule() {
+    return {
+        name: 'state-mutation',
+        compilerVersion: '^0.3.0',
+        diagnostics: [
+            {
+                id: 'llui/state-mutation',
+                description: 'Direct mutation of state in update() — state is immutable, return `{ ...state, field: value }`.',
+            },
+        ],
+        visitors: {
+            [ts.SyntaxKind.SourceFile]: (ctx, node) => {
+                const visited = node;
+                const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true);
+                for (const call of findComponentCalls(sf)) {
+                    const updateProp = findUpdateProperty(call);
+                    if (!updateProp)
+                        continue;
+                    const fn = updateProp.initializer;
+                    if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn))
+                        continue;
+                    const stateParam = fn.parameters[0];
+                    if (!stateParam || !ts.isIdentifier(stateParam.name))
+                        continue;
+                    const stateName = stateParam.name.text;
+                    const report = (n, msg) => {
+                        ctx.reportDiagnostic({
+                            id: 'llui/state-mutation',
+                            severity: 'error',
+                            category: 'reactivity',
+                            message: msg,
+                            location: {
+                                file: sf.fileName,
+                                range: rangeFromOffsets(sf.text, n.getStart(sf), n.getEnd()),
+                            },
+                        });
+                    };
+                    const walk = (n) => {
+                        // Don't descend into nested function expressions — those are
+                        // deferred callbacks, not the synchronous update body.
+                        if ((ts.isArrowFunction(n) ||
+                            ts.isFunctionExpression(n) ||
+                            ts.isFunctionDeclaration(n)) &&
+                            n !== fn) {
+                            return;
+                        }
+                        // Assignment: state.x = ... / state.x += ...
+                        if (ts.isBinaryExpression(n)) {
+                            const op = n.operatorToken.kind;
+                            const isAssign = op === ts.SyntaxKind.EqualsToken ||
+                                op === ts.SyntaxKind.PlusEqualsToken ||
+                                op === ts.SyntaxKind.MinusEqualsToken ||
+                                op === ts.SyntaxKind.AsteriskEqualsToken ||
+                                op === ts.SyntaxKind.SlashEqualsToken ||
+                                op === ts.SyntaxKind.PercentEqualsToken ||
+                                op === ts.SyntaxKind.AmpersandEqualsToken ||
+                                op === ts.SyntaxKind.BarEqualsToken ||
+                                op === ts.SyntaxKind.CaretEqualsToken ||
+                                op === ts.SyntaxKind.LessThanLessThanEqualsToken ||
+                                op === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken ||
+                                op === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken;
+                            if (isAssign && isStateMemberAccess(n.left, stateName)) {
+                                if (op === ts.SyntaxKind.EqualsToken) {
+                                    report(n, `Direct mutation of \`${stateName}\` in update() — state is immutable. Return a new state object: \`{ ...${stateName}, field: newValue }\`.`);
+                                }
+                                else {
+                                    report(n, `Compound assignment on \`${stateName}\` in update() — state is immutable. Compute the new value and return it via spread.`);
+                                }
+                            }
+                        }
+                        // ++state.x / --state.x / state.x++
+                        if (ts.isPostfixUnaryExpression(n) || ts.isPrefixUnaryExpression(n)) {
+                            const op = n.operator;
+                            if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {
+                                if (isStateMemberAccess(n.operand, stateName)) {
+                                    report(n, `Increment/decrement on \`${stateName}\` in update() — state is immutable. Compute the new value and return it via spread.`);
+                                }
+                            }
+                        }
+                        // state.arr.push(…) etc.
+                        if (ts.isCallExpression(n) &&
+                            ts.isPropertyAccessExpression(n.expression) &&
+                            ts.isIdentifier(n.expression.name) &&
+                            MUTATING_METHODS.has(n.expression.name.text) &&
+                            isStateMemberAccess(n.expression.expression, stateName)) {
+                            report(n, `Mutating method \`.${n.expression.name.text}()\` on a state property in update() — use the immutable form (e.g. \`[...arr, x]\` instead of \`arr.push(x)\`).`);
+                        }
+                        ts.forEachChild(n, walk);
+                    };
+                    if (fn.body)
+                        walk(fn.body);
+                }
+            },
+        },
+    };
+}
+//# sourceMappingURL=state-mutation.js.map

package/dist/modules/state-mutation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-mutation.js","sourceRoot":"","sources":["../../src/modules/state-mutation.ts"],"names":[],"mappings":"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","sourcesContent":["// `state-mutation` — errors on direct mutation of the state parameter\n// inside a component's update function. State is immutable; the\n// runtime compares old/new state by reference to compute the dirty\n// mask. Direct mutation breaks that invariant and silently disables\n// bitmask gating. Migrated from\n// `@llui/eslint-plugin/src/rules/state-mutation.ts`.\n\nimport ts from 'typescript'\nimport { rangeFromOffsets } from '../diagnostic.js'\nimport type { CompilerModule } from '../module.js'\nimport { findComponentCalls } from './_shared.js'\n\nconst MUTATING_METHODS = new Set([\n  'push',\n  'pop',\n  'shift',\n  'unshift',\n  'splice',\n  'sort',\n  'reverse',\n  'fill',\n])\n\nfunction findUpdateProperty(call: ts.CallExpression): ts.PropertyAssignment | undefined {\n  const arg = call.arguments[0]\n  if (!arg || !ts.isObjectLiteralExpression(arg)) return undefined\n  for (const prop of arg.properties) {\n    if (\n      ts.isPropertyAssignment(prop) &&\n      ts.isIdentifier(prop.name) &&\n      prop.name.text === 'update'\n    ) {\n      return prop\n    }\n  }\n  return undefined\n}\n\n/** True when `expr` is a member access rooted at the state binding name. */\nfunction isStateMemberAccess(expr: ts.Node, stateName: string): boolean {\n  if (!ts.isPropertyAccessExpression(expr) && !ts.isElementAccessExpression(expr)) return false\n  const root = expr.expression\n  if (ts.isIdentifier(root) && root.text === stateName) return true\n  return isStateMemberAccess(root, stateName)\n}\n\nexport function stateMutationModule(): CompilerModule {\n  return {\n    name: 'state-mutation',\n    compilerVersion: '^0.3.0',\n    diagnostics: [\n      {\n        id: 'llui/state-mutation',\n        description:\n          'Direct mutation of state in update() — state is immutable, return `{ ...state, field: value }`.',\n      },\n    ],\n    visitors: {\n      [ts.SyntaxKind.SourceFile]: (ctx, node) => {\n        const visited = node as ts.SourceFile\n        const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true)\n        for (const call of findComponentCalls(sf)) {\n          const updateProp = findUpdateProperty(call)\n          if (!updateProp) continue\n          const fn = updateProp.initializer\n          if (!ts.isArrowFunction(fn) && !ts.isFunctionExpression(fn)) continue\n          const stateParam = fn.parameters[0]\n          if (!stateParam || !ts.isIdentifier(stateParam.name)) continue\n          const stateName = stateParam.name.text\n\n          const report = (n: ts.Node, msg: string): void => {\n            ctx.reportDiagnostic({\n              id: 'llui/state-mutation',\n              severity: 'error',\n              category: 'reactivity',\n              message: msg,\n              location: {\n                file: sf.fileName,\n                range: rangeFromOffsets(sf.text, n.getStart(sf), n.getEnd()),\n              },\n            })\n          }\n\n          const walk = (n: ts.Node): void => {\n            // Don't descend into nested function expressions — those are\n            // deferred callbacks, not the synchronous update body.\n            if (\n              (ts.isArrowFunction(n) ||\n                ts.isFunctionExpression(n) ||\n                ts.isFunctionDeclaration(n)) &&\n              n !== fn\n            ) {\n              return\n            }\n            // Assignment: state.x = ... / state.x += ...\n            if (ts.isBinaryExpression(n)) {\n              const op = n.operatorToken.kind\n              const isAssign =\n                op === ts.SyntaxKind.EqualsToken ||\n                op === ts.SyntaxKind.PlusEqualsToken ||\n                op === ts.SyntaxKind.MinusEqualsToken ||\n                op === ts.SyntaxKind.AsteriskEqualsToken ||\n                op === ts.SyntaxKind.SlashEqualsToken ||\n                op === ts.SyntaxKind.PercentEqualsToken ||\n                op === ts.SyntaxKind.AmpersandEqualsToken ||\n                op === ts.SyntaxKind.BarEqualsToken ||\n                op === ts.SyntaxKind.CaretEqualsToken ||\n                op === ts.SyntaxKind.LessThanLessThanEqualsToken ||\n                op === ts.SyntaxKind.GreaterThanGreaterThanEqualsToken ||\n                op === ts.SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken\n              if (isAssign && isStateMemberAccess(n.left, stateName)) {\n                if (op === ts.SyntaxKind.EqualsToken) {\n                  report(\n                    n,\n                    `Direct mutation of \\`${stateName}\\` in update() — state is immutable. Return a new state object: \\`{ ...${stateName}, field: newValue }\\`.`,\n                  )\n                } else {\n                  report(\n                    n,\n                    `Compound assignment on \\`${stateName}\\` in update() — state is immutable. Compute the new value and return it via spread.`,\n                  )\n                }\n              }\n            }\n            // ++state.x / --state.x / state.x++\n            if (ts.isPostfixUnaryExpression(n) || ts.isPrefixUnaryExpression(n)) {\n              const op = n.operator\n              if (op === ts.SyntaxKind.PlusPlusToken || op === ts.SyntaxKind.MinusMinusToken) {\n                if (isStateMemberAccess(n.operand, stateName)) {\n                  report(\n                    n,\n                    `Increment/decrement on \\`${stateName}\\` in update() — state is immutable. Compute the new value and return it via spread.`,\n                  )\n                }\n              }\n            }\n            // state.arr.push(…) etc.\n            if (\n              ts.isCallExpression(n) &&\n              ts.isPropertyAccessExpression(n.expression) &&\n              ts.isIdentifier(n.expression.name) &&\n              MUTATING_METHODS.has(n.expression.name.text) &&\n              isStateMemberAccess(n.expression.expression, stateName)\n            ) {\n              report(\n                n,\n                `Mutating method \\`.${n.expression.name.text}()\\` on a state property in update() — use the immutable form (e.g. \\`[...arr, x]\\` instead of \\`arr.push(x)\\`).`,\n              )\n            }\n            ts.forEachChild(n, walk)\n          }\n          if (fn.body) walk(fn.body)\n        }\n      },\n    },\n  }\n}\n"]}

package/dist/modules/state-schema.d.ts

@@ -0,0 +1,8 @@
+import type { CompilerModule } from '../module.js';
+import { type StateSchema } from '../state-schema.js';
+export interface StateSchemaModuleOptions {
+    /** Pre-computed schema (cross-file aware) — null when extraction failed. */
+    stateSchema: StateSchema | null;
+}
+export declare function stateSchemaModule(opts: StateSchemaModuleOptions): CompilerModule;
+//# sourceMappingURL=state-schema.d.ts.map

package/dist/modules/state-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-schema.d.ts","sourceRoot":"","sources":["../../src/modules/state-schema.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,cAAc,EAAwB,MAAM,cAAc,CAAA;AACxE,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAIzE,MAAM,WAAW,wBAAwB;IACvC,4EAA4E;IAC5E,WAAW,EAAE,WAAW,GAAG,IAAI,CAAA;CAChC;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,wBAAwB,GAAG,cAAc,CA0ChF"}

package/dist/modules/state-schema.js

@@ -0,0 +1,55 @@
+// `state-schema` — emits `__stateSchema` per `component()` call and
+// populates the schema-hash inputs slot. Factory module: takes the
+// pre-computed StateSchema (from `extractStateSchema` upstream, with
+// cross-file resolution if available) and emits its literal form
+// targeted at each component() call site.
+//
+// Migrated from the inline `injectStateSchema` in transform.ts. The
+// monolith's `extractStateSchema(...)` call lives in transformLlui's
+// setup section and gets passed into the factory; the module consumes
+// it without re-running the extractor. This keeps the extraction
+// authoritative at the umbrella level (where pre-extracted cross-file
+// data + type-source overrides are already wired) and frees the module
+// from re-implementing input resolution.
+import { stateTypeToLiteral } from '../state-schema.js';
+import { SCHEMA_HASH_INPUTS_SLOT } from './schema-hash.js';
+import { findComponentCalls } from './_shared.js';
+export function stateSchemaModule(opts) {
+    return {
+        name: 'state-schema',
+        compilerVersion: '^0.3.0',
+        diagnostics: [],
+        // Targets captured in `emit` — see `_shared.ts`.
+        visitors: {},
+        emit(ctx, analysis) {
+            if (!opts.stateSchema)
+                return [];
+            const calls = findComponentCalls(analysis.sourceFile);
+            if (calls.length === 0)
+                return [];
+            // Populate the schema-hash inputs slot. The schema-hash module
+            // reads this on its own emit pass and computes the hash. Module
+            // ordering is observable per v2c §2.1: when `stateSchemaModule`
+            // appears in the active module list before `schemaHashModule`,
+            // the inputs slot is populated when schema-hash's emit runs.
+            const hashInputs = analysis.perModule.get(SCHEMA_HASH_INPUTS_SLOT);
+            if (hashInputs) {
+                hashInputs.stateSchema = opts.stateSchema;
+            }
+            else {
+                analysis.perModule.set(SCHEMA_HASH_INPUTS_SLOT, {
+                    msgSchema: null,
+                    stateSchema: opts.stateSchema,
+                    msgAnnotations: null,
+                });
+            }
+            return calls.map((call) => ({
+                module: 'state-schema',
+                field: '__stateSchema',
+                value: stateTypeToLiteral({ kind: 'object', fields: opts.stateSchema.fields }, ctx.factory),
+                target: call,
+            }));
+        },
+    };
+}
+//# sourceMappingURL=state-schema.js.map

package/dist/modules/state-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"state-schema.js","sourceRoot":"","sources":["../../src/modules/state-schema.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,mEAAmE;AACnE,qEAAqE;AACrE,iEAAiE;AACjE,0CAA0C;AAC1C,EAAE;AACF,oEAAoE;AACpE,qEAAqE;AACrE,sEAAsE;AACtE,iEAAiE;AACjE,sEAAsE;AACtE,uEAAuE;AACvE,yCAAyC;AAGzC,OAAO,EAAE,kBAAkB,EAAoB,MAAM,oBAAoB,CAAA;AACzE,OAAO,EAAE,uBAAuB,EAAyB,MAAM,kBAAkB,CAAA;AACjF,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAOjD,MAAM,UAAU,iBAAiB,CAAC,IAA8B;IAC9D,OAAO;QACL,IAAI,EAAE,cAAc;QACpB,eAAe,EAAE,QAAQ;QACzB,WAAW,EAAE,EAAE;QACf,iDAAiD;QACjD,QAAQ,EAAE,EAAE;QAEZ,IAAI,CAAC,GAAG,EAAE,QAAQ;YAChB,IAAI,CAAC,IAAI,CAAC,WAAW;gBAAE,OAAO,EAAE,CAAA;YAChC,MAAM,KAAK,GAAG,kBAAkB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAA;YACrD,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO,EAAE,CAAA;YAEjC,+DAA+D;YAC/D,gEAAgE;YAChE,gEAAgE;YAChE,+DAA+D;YAC/D,6DAA6D;YAC7D,MAAM,UAAU,GAAG,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,uBAAuB,CAEpD,CAAA;YACb,IAAI,UAAU,EAAE,CAAC;gBACf,UAAU,CAAC,WAAW,GAAG,IAAI,CAAC,WAAW,CAAA;YAC3C,CAAC;iBAAM,CAAC;gBACN,QAAQ,CAAC,SAAS,CAAC,GAAG,CAAC,uBAAuB,EAAE;oBAC9C,SAAS,EAAE,IAAI;oBACf,WAAW,EAAE,IAAI,CAAC,WAAW;oBAC7B,cAAc,EAAE,IAAI;iBACD,CAAC,CAAA;YACxB,CAAC;YAED,OAAO,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBAC1B,MAAM,EAAE,cAAc;gBACtB,KAAK,EAAE,eAAe;gBACtB,KAAK,EAAE,kBAAkB,CACvB,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,WAAY,CAAC,MAAM,EAAE,EACpD,GAAG,CAAC,OAAO,CACZ;gBACD,MAAM,EAAE,IAAI;aACb,CAAC,CAAC,CAAA;QACL,CAAC;KACF,CAAA;AACH,CAAC","sourcesContent":["// `state-schema` — emits `__stateSchema` per `component()` call and\n// populates the schema-hash inputs slot. Factory module: takes the\n// pre-computed StateSchema (from `extractStateSchema` upstream, with\n// cross-file resolution if available) and emits its literal form\n// targeted at each component() call site.\n//\n// Migrated from the inline `injectStateSchema` in transform.ts. The\n// monolith's `extractStateSchema(...)` call lives in transformLlui's\n// setup section and gets passed into the factory; the module consumes\n// it without re-running the extractor. This keeps the extraction\n// authoritative at the umbrella level (where pre-extracted cross-file\n// data + type-source overrides are already wired) and frees the module\n// from re-implementing input resolution.\n\nimport type { CompilerModule, EmissionContribution } from '../module.js'\nimport { stateTypeToLiteral, type StateSchema } from '../state-schema.js'\nimport { SCHEMA_HASH_INPUTS_SLOT, type SchemaHashInputs } from './schema-hash.js'\nimport { findComponentCalls } from './_shared.js'\n\nexport interface StateSchemaModuleOptions {\n  /** Pre-computed schema (cross-file aware) — null when extraction failed. */\n  stateSchema: StateSchema | null\n}\n\nexport function stateSchemaModule(opts: StateSchemaModuleOptions): CompilerModule {\n  return {\n    name: 'state-schema',\n    compilerVersion: '^0.3.0',\n    diagnostics: [],\n    // Targets captured in `emit` — see `_shared.ts`.\n    visitors: {},\n\n    emit(ctx, analysis): EmissionContribution[] {\n      if (!opts.stateSchema) return []\n      const calls = findComponentCalls(analysis.sourceFile)\n      if (calls.length === 0) return []\n\n      // Populate the schema-hash inputs slot. The schema-hash module\n      // reads this on its own emit pass and computes the hash. Module\n      // ordering is observable per v2c §2.1: when `stateSchemaModule`\n      // appears in the active module list before `schemaHashModule`,\n      // the inputs slot is populated when schema-hash's emit runs.\n      const hashInputs = analysis.perModule.get(SCHEMA_HASH_INPUTS_SLOT) as\n        | SchemaHashInputs\n        | undefined\n      if (hashInputs) {\n        hashInputs.stateSchema = opts.stateSchema\n      } else {\n        analysis.perModule.set(SCHEMA_HASH_INPUTS_SLOT, {\n          msgSchema: null,\n          stateSchema: opts.stateSchema,\n          msgAnnotations: null,\n        } as SchemaHashInputs)\n      }\n\n      return calls.map((call) => ({\n        module: 'state-schema',\n        field: '__stateSchema',\n        value: stateTypeToLiteral(\n          { kind: 'object', fields: opts.stateSchema!.fields },\n          ctx.factory,\n        ),\n        target: call,\n      }))\n    },\n  }\n}\n"]}

package/dist/modules/static-items.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerModule } from '../module.js';
+export declare function staticItemsModule(): CompilerModule;
+//# sourceMappingURL=static-items.d.ts.map

package/dist/modules/static-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-items.d.ts","sourceRoot":"","sources":["../../src/modules/static-items.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAuClD,wBAAgB,iBAAiB,IAAI,cAAc,CAoFlD"}

package/dist/modules/static-items.js

@@ -0,0 +1,125 @@
+// `static-items` — errors when `each({ items })` receives a factory that
+// doesn't read state. Without state reads, the items list is computed
+// once at mount and `each` never reconciles — adds/removes/updates are
+// invisible. Migrated from
+// `@llui/eslint-plugin/src/rules/static-items.ts`.
+import ts from 'typescript';
+import { rangeFromOffsets } from '../diagnostic.js';
+function bodyMayRead(body) {
+    let found = false;
+    const walk = (n) => {
+        if (found)
+            return;
+        if (ts.isCallExpression(n) ||
+            ts.isPropertyAccessExpression(n) ||
+            ts.isElementAccessExpression(n)) {
+            found = true;
+            return;
+        }
+        ts.forEachChild(n, walk);
+    };
+    walk(body);
+    return found;
+}
+function readsParam(body, paramName) {
+    let found = false;
+    const walk = (n) => {
+        if (found)
+            return;
+        if (ts.isIdentifier(n) && n.text === paramName) {
+            const parent = n.parent;
+            // Don't count the parameter declaration itself.
+            if (parent && ts.isParameter(parent) && parent.name === n) {
+                return;
+            }
+            found = true;
+            return;
+        }
+        ts.forEachChild(n, walk);
+    };
+    walk(body);
+    return found;
+}
+export function staticItemsModule() {
+    return {
+        name: 'static-items',
+        compilerVersion: '^0.3.0',
+        diagnostics: [
+            {
+                id: 'llui/static-items',
+                description: '`each({ items })` factory reads no state — list never reconciles.',
+            },
+        ],
+        visitors: {
+            [ts.SyntaxKind.SourceFile]: (ctx, node) => {
+                const visited = node;
+                const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true);
+                const walk = (n) => {
+                    if (ts.isCallExpression(n)) {
+                        let isEach = false;
+                        if (ts.isIdentifier(n.expression) && n.expression.text === 'each')
+                            isEach = true;
+                        else if (ts.isPropertyAccessExpression(n.expression) &&
+                            ts.isIdentifier(n.expression.name) &&
+                            n.expression.name.text === 'each')
+                            isEach = true;
+                        if (isEach) {
+                            const opts = n.arguments[0];
+                            if (opts && ts.isObjectLiteralExpression(opts)) {
+                                const itemsProp = opts.properties.find((p) => ts.isPropertyAssignment(p) &&
+                                    ts.isIdentifier(p.name) &&
+                                    p.name.text === 'items');
+                                if (itemsProp) {
+                                    const v = itemsProp.initializer;
+                                    if (ts.isArrowFunction(v) || ts.isFunctionExpression(v)) {
+                                        let isStatic = false;
+                                        if (v.parameters.length === 0) {
+                                            // Zero-param zero-arg `() => Foo` where Foo is a
+                                            // bare identifier is an explicit opt-in to a
+                                            // known-static list (the author named a const
+                                            // and pointed `items` at it). The footgun pattern
+                                            // is `() => [1,2,3]` / `() => {…}` (anonymous
+                                            // literal); the named-const case is a legitimate
+                                            // pattern and shouldn't fire.
+                                            const body = v.body;
+                                            if (body && ts.isIdentifier(body)) {
+                                                isStatic = false;
+                                            }
+                                            else {
+                                                isStatic = body ? !bodyMayRead(body) : true;
+                                            }
+                                        }
+                                        else if (v.parameters.length === 1) {
+                                            const param = v.parameters[0];
+                                            if (ts.isIdentifier(param.name)) {
+                                                isStatic = v.body ? !readsParam(v.body, param.name.text) : true;
+                                            }
+                                        }
+                                        if (isStatic) {
+                                            ctx.reportDiagnostic({
+                                                id: 'llui/static-items',
+                                                severity: 'error',
+                                                category: 'reactivity',
+                                                message: `\`each()\`'s \`items\` factory reads no state — the list is computed ` +
+                                                    `once at mount and \`each\` never reconciles. Adds, removes, and updates ` +
+                                                    `to items will never appear in the DOM. Reference the state field that ` +
+                                                    `holds the list, e.g. \`items: (s) => s.list.items\`.`,
+                                                location: {
+                                                    file: sf.fileName,
+                                                    range: rangeFromOffsets(sf.text, n.getStart(sf), n.getEnd()),
+                                                },
+                                            });
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    ts.forEachChild(n, walk);
+                };
+                walk(sf);
+            },
+        },
+    };
+}
+//# sourceMappingURL=static-items.js.map

package/dist/modules/static-items.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-items.js","sourceRoot":"","sources":["../../src/modules/static-items.ts"],"names":[],"mappings":"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","sourcesContent":["// `static-items` — errors when `each({ items })` receives a factory that\n// doesn't read state. Without state reads, the items list is computed\n// once at mount and `each` never reconciles — adds/removes/updates are\n// invisible. Migrated from\n// `@llui/eslint-plugin/src/rules/static-items.ts`.\n\nimport ts from 'typescript'\nimport { rangeFromOffsets } from '../diagnostic.js'\nimport type { CompilerModule } from '../module.js'\n\nfunction bodyMayRead(body: ts.Node): boolean {\n  let found = false\n  const walk = (n: ts.Node): void => {\n    if (found) return\n    if (\n      ts.isCallExpression(n) ||\n      ts.isPropertyAccessExpression(n) ||\n      ts.isElementAccessExpression(n)\n    ) {\n      found = true\n      return\n    }\n    ts.forEachChild(n, walk)\n  }\n  walk(body)\n  return found\n}\n\nfunction readsParam(body: ts.Node, paramName: string): boolean {\n  let found = false\n  const walk = (n: ts.Node): void => {\n    if (found) return\n    if (ts.isIdentifier(n) && n.text === paramName) {\n      const parent = n.parent\n      // Don't count the parameter declaration itself.\n      if (parent && ts.isParameter(parent) && parent.name === n) {\n        return\n      }\n      found = true\n      return\n    }\n    ts.forEachChild(n, walk)\n  }\n  walk(body)\n  return found\n}\n\nexport function staticItemsModule(): CompilerModule {\n  return {\n    name: 'static-items',\n    compilerVersion: '^0.3.0',\n    diagnostics: [\n      {\n        id: 'llui/static-items',\n        description: '`each({ items })` factory reads no state — list never reconciles.',\n      },\n    ],\n    visitors: {\n      [ts.SyntaxKind.SourceFile]: (ctx, node) => {\n        const visited = node as ts.SourceFile\n        const sf = ts.createSourceFile(visited.fileName, visited.text, ts.ScriptTarget.Latest, true)\n        const walk = (n: ts.Node): void => {\n          if (ts.isCallExpression(n)) {\n            let isEach = false\n            if (ts.isIdentifier(n.expression) && n.expression.text === 'each') isEach = true\n            else if (\n              ts.isPropertyAccessExpression(n.expression) &&\n              ts.isIdentifier(n.expression.name) &&\n              n.expression.name.text === 'each'\n            )\n              isEach = true\n            if (isEach) {\n              const opts = n.arguments[0]\n              if (opts && ts.isObjectLiteralExpression(opts)) {\n                const itemsProp = opts.properties.find(\n                  (p): p is ts.PropertyAssignment =>\n                    ts.isPropertyAssignment(p) &&\n                    ts.isIdentifier(p.name) &&\n                    p.name.text === 'items',\n                )\n                if (itemsProp) {\n                  const v = itemsProp.initializer\n                  if (ts.isArrowFunction(v) || ts.isFunctionExpression(v)) {\n                    let isStatic = false\n                    if (v.parameters.length === 0) {\n                      // Zero-param zero-arg `() => Foo` where Foo is a\n                      // bare identifier is an explicit opt-in to a\n                      // known-static list (the author named a const\n                      // and pointed `items` at it). The footgun pattern\n                      // is `() => [1,2,3]` / `() => {…}` (anonymous\n                      // literal); the named-const case is a legitimate\n                      // pattern and shouldn't fire.\n                      const body = v.body\n                      if (body && ts.isIdentifier(body)) {\n                        isStatic = false\n                      } else {\n                        isStatic = body ? !bodyMayRead(body) : true\n                      }\n                    } else if (v.parameters.length === 1) {\n                      const param = v.parameters[0]!\n                      if (ts.isIdentifier(param.name)) {\n                        isStatic = v.body ? !readsParam(v.body, param.name.text) : true\n                      }\n                    }\n                    if (isStatic) {\n                      ctx.reportDiagnostic({\n                        id: 'llui/static-items',\n                        severity: 'error',\n                        category: 'reactivity',\n                        message:\n                          `\\`each()\\`'s \\`items\\` factory reads no state — the list is computed ` +\n                          `once at mount and \\`each\\` never reconciles. Adds, removes, and updates ` +\n                          `to items will never appear in the DOM. Reference the state field that ` +\n                          `holds the list, e.g. \\`items: (s) => s.list.items\\`.`,\n                        location: {\n                          file: sf.fileName,\n                          range: rangeFromOffsets(sf.text, n.getStart(sf), n.getEnd()),\n                        },\n                      })\n                    }\n                  }\n                }\n              }\n            }\n          }\n          ts.forEachChild(n, walk)\n        }\n        walk(sf)\n      },\n    },\n  }\n}\n"]}

package/dist/modules/static-on.d.ts

@@ -0,0 +1,3 @@
+import type { CompilerModule } from '../module.js';
+export declare function staticOnModule(): CompilerModule;
+//# sourceMappingURL=static-on.d.ts.map

package/dist/modules/static-on.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"static-on.d.ts","sourceRoot":"","sources":["../../src/modules/static-on.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAoClD,wBAAgB,cAAc,IAAI,cAAc,CAgE/C"}