@fluixi/compiler 1.0.0-alpha.100

package/dist/analyze/reactive-bindings.js

@@ -0,0 +1,191 @@
+/**
+ * Which names in a module hold reactive values, and what kind.
+ *
+ * Resolved from where a name came from, never from how it reads. This has to hold:
+ *
+ *   import { createSignal as useState } from '@fluixi/reactive/signal';
+ *   const count = useState(0);          // a signal
+ *
+ *   function createSignal() { return 42; }
+ *   const value = createSignal();       // not a signal
+ *
+ * A name tells you nothing; the binding it resolves to tells you everything. So this
+ * walks the imports first, then the declarations that call them, and a local
+ * declaration always wins over anything the compiler would otherwise assume.
+ *
+ * Babel-free by the rule in no-babel-in-core: nodes are read structurally.
+ */
+import { INTRINSICS, RUNTIME_PRIMITIVES, isPrimitiveModule, } from './intrinsics.js';
+/** Every name a binding pattern introduces. */
+function patternNames(node, out) {
+    if (!node)
+        return;
+    switch (node.type) {
+        case 'Identifier':
+            out.add(node.name);
+            return;
+        case 'ObjectPattern':
+            for (const p of node.properties ?? []) {
+                if (p.type === 'RestElement')
+                    patternNames(p.argument, out);
+                else
+                    patternNames(p.value, out);
+            }
+            return;
+        case 'ArrayPattern':
+            for (const e of node.elements ?? [])
+                patternNames(e, out);
+            return;
+        case 'AssignmentPattern':
+            patternNames(node.left, out);
+            return;
+        case 'RestElement':
+            patternNames(node.argument, out);
+            return;
+    }
+}
+/** Walk everything under a node. */
+function walk(root, visit) {
+    if (!root || typeof root !== 'object' || typeof root.type !== 'string')
+        return;
+    visit(root);
+    for (const key of Object.keys(root)) {
+        if (key === 'loc' || key === 'leadingComments' || key === 'trailingComments')
+            continue;
+        const value = root[key];
+        if (Array.isArray(value))
+            for (const item of value)
+                walk(item, visit);
+        else if (value && typeof value === 'object')
+            walk(value, visit);
+    }
+}
+/** The primitive a call expression resolves to, if it resolves to one at all. */
+function calledPrimitive(node, bindings) {
+    if (node.type !== 'CallExpression')
+        return undefined;
+    const callee = node.callee;
+    if (callee?.type !== 'Identifier')
+        return undefined;
+    const name = callee.name;
+    const imported = bindings.primitives.get(name);
+    if (imported)
+        return imported;
+    // `$signal(…)`, unless the module bound that name itself.
+    const intrinsic = INTRINSICS[name];
+    if (intrinsic && !bindings.shadowed.has(name))
+        return intrinsic.returns;
+    return undefined;
+}
+/** Record what a declaration's pattern holds, given what the call returns. */
+function classify(id, returns, kinds) {
+    if (Array.isArray(returns)) {
+        // `const [count, setCount] = $signal(0)`: position decides which is which.
+        if (id.type === 'ArrayPattern') {
+            id.elements.forEach((element, index) => {
+                const kind = returns[index];
+                if (element?.type === 'Identifier' && kind)
+                    kinds.set(element.name, kind);
+            });
+        }
+        return;
+    }
+    if (id.type === 'Identifier')
+        kinds.set(id.name, returns);
+}
+/**
+ * Every name the module binds, in any scope.
+ *
+ * Deliberately scope-blind: it answers "does this file declare this name anywhere", which
+ * is the question a diagnostic needs. A component declared inside a function
+ * (`const Row = () => …`) is bound just as much as an import, and warning about it would
+ * be noise. Over-permissive on purpose: missing a warning beats inventing one.
+ */
+export function declaredNames(program) {
+    const names = new Set();
+    walk(program, (node) => {
+        switch (node.type) {
+            case 'VariableDeclarator':
+                patternNames(node.id, names);
+                return;
+            case 'FunctionDeclaration':
+            case 'FunctionExpression':
+            case 'ArrowFunctionExpression':
+                patternNames(node.id, names);
+                for (const p of node.params ?? [])
+                    patternNames(p, names);
+                return;
+            case 'ClassDeclaration':
+            case 'ClassExpression':
+                patternNames(node.id, names);
+                return;
+            case 'ImportSpecifier':
+            case 'ImportDefaultSpecifier':
+            case 'ImportNamespaceSpecifier':
+                patternNames(node.local, names);
+                return;
+            case 'CatchClause':
+                patternNames(node.param, names);
+                return;
+        }
+    });
+    return names;
+}
+/**
+ * Read a module's reactive bindings.
+ *
+ * Two passes, because a call can only be classified once its callee is known: imports
+ * and local declarations first, then the declarations that call them.
+ */
+export function resolveReactiveBindings(program) {
+    const bindings = { kinds: new Map(), primitives: new Map(), shadowed: new Set() };
+    const root = program;
+    // Anything the module declares under a `$` name shadows the intrinsic. Checked across
+    // the whole module, not just the top level: a nested `const $signal = …` still means
+    // the call at that point isn't ours, and refusing the rewrite there is the safe answer.
+    walk(root, (node) => {
+        const names = new Set();
+        if (node.type === 'VariableDeclarator')
+            patternNames(node.id, names);
+        else if (node.type === 'FunctionDeclaration' || node.type === 'ClassDeclaration')
+            patternNames(node.id, names);
+        else if (node.type === 'ImportDefaultSpecifier' || node.type === 'ImportNamespaceSpecifier')
+            patternNames(node.local, names);
+        else if (node.type === 'ImportSpecifier')
+            patternNames(node.local, names);
+        else if (node.type === 'FunctionExpression' ||
+            node.type === 'ArrowFunctionExpression' ||
+            node.type === 'FunctionDeclaration') {
+            for (const p of node.params ?? [])
+                patternNames(p, names);
+        }
+        for (const name of names)
+            if (INTRINSICS[name])
+                bindings.shadowed.add(name);
+    });
+    // Imported primitives, under whatever local name they were given.
+    for (const statement of root.body ?? []) {
+        if (statement.type !== 'ImportDeclaration')
+            continue;
+        if (!isPrimitiveModule(statement.source?.value))
+            continue;
+        for (const specifier of statement.specifiers ?? []) {
+            if (specifier.type !== 'ImportSpecifier')
+                continue;
+            const importedNode = specifier.imported;
+            const imported = (importedNode.type === 'Identifier' ? importedNode.name : importedNode.value);
+            const returns = RUNTIME_PRIMITIVES[imported];
+            if (returns)
+                bindings.primitives.set(specifier.local.name, returns);
+        }
+    }
+    // What the declarations that call them hold.
+    walk(root, (node) => {
+        if (node.type !== 'VariableDeclarator' || !node.init)
+            return;
+        const returns = calledPrimitive(node.init, bindings);
+        if (returns)
+            classify(node.id, returns, bindings.kinds);
+    });
+    return bindings;
+}

package/dist/analyze/reactive-bindings.mjs

@@ -0,0 +1,187 @@
+// src/analyze/intrinsics.ts
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
+  $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
+  $cachedResource: { export: "cachedResource", module: "@fluixi/reactive/cached-resource", returns: "resource-handle" },
+  // No short runtime form for these yet, so the intrinsic stands for the `create*`
+  // name. Still worth having: no import to write, and when a shorter form is
+  // designed, the change is this line rather than a compiler pass.
+  $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  // Not value constructors, but the compiler has to know them: they change what a read
+  // does. `untrack` suppresses dependency collection, which is exactly the kind of thing
+  // dependency analysis must not guess at.
+  $untrack: { export: "untrack", module: REACTIVE_MODULE, returns: "plain" },
+  $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" },
+  // Scopes, scheduling and lifecycle: no value to classify, but the same authoring promise,
+  // no import to write. `$cleanup` registers a callback on the current owner (`onCleanup`).
+  $batch: { export: "batch", module: REACTIVE_MODULE, returns: "plain" },
+  $cleanup: { export: "onCleanup", module: REACTIVE_MODULE, returns: "plain" },
+  $root: { export: "root", module: REACTIVE_MODULE, returns: "plain" },
+  $context: { export: "context", module: REACTIVE_MODULE, returns: "plain" },
+  $renderEffect: { export: "renderEffect", module: REACTIVE_MODULE, returns: "effect" },
+  $computed: { export: "computed", module: REACTIVE_MODULE, returns: "effect" },
+  // Storage for where the code runs, and a signal kept in it. `$persisted` is a signal
+  // handle as far as reads go: the same accessor with `set` on it.
+  $storage: { export: "useStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $asyncStorage: { export: "useAsyncStorage", module: "@fluixi/core/storage", returns: "plain" },
+  $persisted: { export: "persisted", module: "@fluixi/core/storage", returns: "signal-handle" },
+  // An environment variable, public or server-only; the browser build refuses a secret.
+  $env: { export: "env", module: "@fluixi/start/env", returns: "plain" }
+};
+var RUNTIME_PRIMITIVES = {
+  signal: "signal-handle",
+  memo: "memo-handle",
+  effect: "effect",
+  store: "store-handle",
+  createSignal: ["signal-accessor", "signal-setter"],
+  createMemo: "memo-accessor",
+  createEffect: "effect",
+  createRenderEffect: "effect",
+  renderEffect: "effect",
+  computed: "effect",
+  createStore: "reactive-object",
+  resource: "resource-handle",
+  cachedResource: "resource-handle",
+  createResource: "reactive-object",
+  createSelector: "memo-accessor",
+  createDeferred: "memo-accessor"
+};
+var PRIMITIVE_MODULES = [
+  "@fluixi/reactive",
+  "@fluixi/reactive/signal",
+  "@fluixi/reactive/store",
+  "@fluixi/reactive/cached-resource",
+  "@fluixi/core"
+];
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+function isPrimitiveModule(source) {
+  return PRIMITIVE_MODULES.includes(source);
+}
+
+// src/analyze/reactive-bindings.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties ?? []) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements ?? []) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function walk(root, visit) {
+  if (!root || typeof root !== "object" || typeof root.type !== "string") return;
+  visit(root);
+  for (const key of Object.keys(root)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    const value = root[key];
+    if (Array.isArray(value)) for (const item of value) walk(item, visit);
+    else if (value && typeof value === "object") walk(value, visit);
+  }
+}
+function calledPrimitive(node, bindings) {
+  if (node.type !== "CallExpression") return void 0;
+  const callee = node.callee;
+  if (callee?.type !== "Identifier") return void 0;
+  const name = callee.name;
+  const imported = bindings.primitives.get(name);
+  if (imported) return imported;
+  const intrinsic = INTRINSICS[name];
+  if (intrinsic && !bindings.shadowed.has(name)) return intrinsic.returns;
+  return void 0;
+}
+function classify(id, returns, kinds) {
+  if (Array.isArray(returns)) {
+    if (id.type === "ArrayPattern") {
+      id.elements.forEach((element, index) => {
+        const kind = returns[index];
+        if (element?.type === "Identifier" && kind) kinds.set(element.name, kind);
+      });
+    }
+    return;
+  }
+  if (id.type === "Identifier") kinds.set(id.name, returns);
+}
+function declaredNames(program) {
+  const names = /* @__PURE__ */ new Set();
+  walk(program, (node) => {
+    switch (node.type) {
+      case "VariableDeclarator":
+        patternNames(node.id, names);
+        return;
+      case "FunctionDeclaration":
+      case "FunctionExpression":
+      case "ArrowFunctionExpression":
+        patternNames(node.id, names);
+        for (const p of node.params ?? []) patternNames(p, names);
+        return;
+      case "ClassDeclaration":
+      case "ClassExpression":
+        patternNames(node.id, names);
+        return;
+      case "ImportSpecifier":
+      case "ImportDefaultSpecifier":
+      case "ImportNamespaceSpecifier":
+        patternNames(node.local, names);
+        return;
+      case "CatchClause":
+        patternNames(node.param, names);
+        return;
+    }
+  });
+  return names;
+}
+function resolveReactiveBindings(program) {
+  const bindings = { kinds: /* @__PURE__ */ new Map(), primitives: /* @__PURE__ */ new Map(), shadowed: /* @__PURE__ */ new Set() };
+  const root = program;
+  walk(root, (node) => {
+    const names = /* @__PURE__ */ new Set();
+    if (node.type === "VariableDeclarator") patternNames(node.id, names);
+    else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") patternNames(node.id, names);
+    else if (node.type === "ImportDefaultSpecifier" || node.type === "ImportNamespaceSpecifier") patternNames(node.local, names);
+    else if (node.type === "ImportSpecifier") patternNames(node.local, names);
+    else if (node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration") {
+      for (const p of node.params ?? []) patternNames(p, names);
+    }
+    for (const name of names) if (INTRINSICS[name]) bindings.shadowed.add(name);
+  });
+  for (const statement of root.body ?? []) {
+    if (statement.type !== "ImportDeclaration") continue;
+    if (!isPrimitiveModule(statement.source?.value)) continue;
+    for (const specifier of statement.specifiers ?? []) {
+      if (specifier.type !== "ImportSpecifier") continue;
+      const importedNode = specifier.imported;
+      const imported = importedNode.type === "Identifier" ? importedNode.name : importedNode.value;
+      const returns = RUNTIME_PRIMITIVES[imported];
+      if (returns) bindings.primitives.set(specifier.local.name, returns);
+    }
+  }
+  walk(root, (node) => {
+    if (node.type !== "VariableDeclarator" || !node.init) return;
+    const returns = calledPrimitive(node.init, bindings);
+    if (returns) classify(node.id, returns, bindings.kinds);
+  });
+  return bindings;
+}
+export {
+  declaredNames,
+  resolveReactiveBindings
+};

package/dist/analyze/reactive-expr.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/analyze/reactive-expr.ts
+var reactive_expr_exports = {};
+__export(reactive_expr_exports, {
+  isReactiveShape: () => isReactiveShape
+});
+module.exports = __toCommonJS(reactive_expr_exports);
+var STABLE_MEMBER = "children";
+function isReactiveShape(shape) {
+  switch (shape.kind) {
+    case "call":
+      return true;
+    case "member":
+      return shape.property !== STABLE_MEMBER;
+    case "compound":
+      return shape.parts.some(isReactiveShape);
+    case "opaque":
+      return false;
+  }
+}

package/dist/analyze/reactive-expr.d.cts

@@ -0,0 +1,38 @@
+/**
+ * Which expressions get wired reactively: `count()` re-runs on change, `count`
+ * does not, `props.children` is a subtree reference rather than a value.
+ *
+ * `ExprShape` is four cases and must not grow into a JavaScript AST, a front-end
+ * reports what the rule branches on, everything else collapses to `compound` or
+ * `opaque`. One rule, one place, whatever the parser.
+ */
+export type ExprShape = 
+/** A call: `count()`, `t('key')`, `mergeRefs(a, b)`. Always reactive. */
+{
+    kind: 'call';
+}
+/**
+ * A property access. `property` is the static name, or `null` when the access is
+ * computed or otherwise not a plain identifier (`obj[key]`, `obj[fn()]`).
+ */
+ | {
+    kind: 'member';
+    property: string | null;
+}
+/**
+ * Anything built out of sub-expressions: conditionals, logical and binary
+ * operators, template literals, object and array literals. Reactive when any
+ * part is, so `class={{ active: active() }}` reacts and `class={{ a: true }}`
+ * does not. The front-end decides which children count: a spread element or a
+ * computed key contributes nothing, because the compiler cannot see through it.
+ */
+ | {
+    kind: 'compound';
+    parts: ExprShape[];
+}
+/** Identifiers, literals, functions, JSX: passed through untouched. */
+ | {
+    kind: 'opaque';
+};
+/** Whether an expression of this shape must be wired reactively. */
+export declare function isReactiveShape(shape: ExprShape): boolean;

package/dist/analyze/reactive-expr.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Which expressions get wired reactively: `count()` re-runs on change, `count`
+ * does not, `props.children` is a subtree reference rather than a value.
+ *
+ * `ExprShape` is four cases and must not grow into a JavaScript AST, a front-end
+ * reports what the rule branches on, everything else collapses to `compound` or
+ * `opaque`. One rule, one place, whatever the parser.
+ */
+export type ExprShape = 
+/** A call: `count()`, `t('key')`, `mergeRefs(a, b)`. Always reactive. */
+{
+    kind: 'call';
+}
+/**
+ * A property access. `property` is the static name, or `null` when the access is
+ * computed or otherwise not a plain identifier (`obj[key]`, `obj[fn()]`).
+ */
+ | {
+    kind: 'member';
+    property: string | null;
+}
+/**
+ * Anything built out of sub-expressions: conditionals, logical and binary
+ * operators, template literals, object and array literals. Reactive when any
+ * part is, so `class={{ active: active() }}` reacts and `class={{ a: true }}`
+ * does not. The front-end decides which children count: a spread element or a
+ * computed key contributes nothing, because the compiler cannot see through it.
+ */
+ | {
+    kind: 'compound';
+    parts: ExprShape[];
+}
+/** Identifiers, literals, functions, JSX: passed through untouched. */
+ | {
+    kind: 'opaque';
+};
+/** Whether an expression of this shape must be wired reactively. */
+export declare function isReactiveShape(shape: ExprShape): boolean;
+//# sourceMappingURL=reactive-expr.d.ts.map

package/dist/analyze/reactive-expr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reactive-expr.d.ts","sourceRoot":"","sources":["../../src/analyze/reactive-expr.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,MAAM,SAAS;AACnB,yEAAyE;AACvE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE;AAClB;;;GAGG;GACD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE;AAC7C;;;;;;GAMG;GACD;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,SAAS,EAAE,CAAA;CAAE;AAC1C,uEAAuE;GACrE;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC;AAavB,oEAAoE;AACpE,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAWzD"}

package/dist/analyze/reactive-expr.js

@@ -0,0 +1,31 @@
+/**
+ * Which expressions get wired reactively: `count()` re-runs on change, `count`
+ * does not, `props.children` is a subtree reference rather than a value.
+ *
+ * `ExprShape` is four cases and must not grow into a JavaScript AST, a front-end
+ * reports what the rule branches on, everything else collapses to `compound` or
+ * `opaque`. One rule, one place, whatever the parser.
+ */
+/**
+ * `props.children`: and any `.children` access: is a stable subtree reference,
+ * not a reactive value. Compiling it to a `() => props.children` thunk adds an
+ * insert layer that fully unwraps the children's Suspense/memo into a static node,
+ * severing the reactive binding: a nested lazy/Suspense that resolves later never
+ * propagates up through the component-children hop. Passing it through
+ * non-reactively (`insert(el, props.children)`) keeps the child's memo intact so
+ * `insert` binds to it, which is what a direct `<Outlet/>` does.
+ */
+const STABLE_MEMBER = 'children';
+/** Whether an expression of this shape must be wired reactively. */
+export function isReactiveShape(shape) {
+    switch (shape.kind) {
+        case 'call':
+            return true;
+        case 'member':
+            return shape.property !== STABLE_MEMBER;
+        case 'compound':
+            return shape.parts.some(isReactiveShape);
+        case 'opaque':
+            return false;
+    }
+}

package/dist/analyze/reactive-expr.mjs

@@ -0,0 +1,17 @@
+// src/analyze/reactive-expr.ts
+var STABLE_MEMBER = "children";
+function isReactiveShape(shape) {
+  switch (shape.kind) {
+    case "call":
+      return true;
+    case "member":
+      return shape.property !== STABLE_MEMBER;
+    case "compound":
+      return shape.parts.some(isReactiveShape);
+    case "opaque":
+      return false;
+  }
+}
+export {
+  isReactiveShape
+};