@fluixi/compiler 1.0.0-alpha.92 → 1.0.0-alpha.93

package/dist/transform/source-locations.d.ts

@@ -12,6 +12,11 @@ export interface SourceLocationsResult {
 export declare const SOURCE_MARKER = "__fx_source";
 /** Where a component was declared. Keyed by name, since that is all the runtime carries. */
 export declare const COMPONENT_MARKER = "__fx_component";
+/**
+ * Where a class that extends another was declared, keyed by the class itself: a custom
+ * element's definition, which the runtime can only reach through `element.constructor`.
+ */
+export declare const CLASS_MARKER = "__fx_class";
 /**
  * Where one reactive hole was written. This one wraps: the position has to travel with the
  * accessor to wherever the dom wires it up. A template is emitted as one overwrite, so the
@@ -38,7 +43,7 @@ export declare const markHole: (accessor: string, line: number, column: number,
 export declare const PROPS_MARKER = "__fx_props";
 /** `_({ get a() {…} }, {"a":[9,25]})`, or the object untouched when nothing is watching. */
 export declare const markProps: (object: string, at: Record<string, [number, number]>) => string;
-/** Cheap enough to run before parsing. */
-export declare function mayHaveReactiveCall(code: string): boolean;
+/** Whether a module has anything to mark: a primitive call or a subclass. Cheap enough to run before parsing. */
+export declare function mayHaveSourceMarks(code: string): boolean;
 export declare function collectSourceEdits(program: unknown, filename: string): SourceLocationsResult;
 //# sourceMappingURL=source-locations.d.ts.map

package/dist/transform/source-locations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"source-locations.d.ts","sourceRoot":"","sources":["../../src/transform/source-locations.ts"],"names":[],"mappings":"AA6BA,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,gEAAgE;AAChE,eAAO,MAAM,aAAa,gBAAgB,CAAC;AAE3C,4FAA4F;AAC5F,eAAO,MAAM,gBAAgB,mBAAmB,CAAC;AAEjD;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,cAAc,CAAC;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GACnB,UAAU,MAAM,EAChB,MAAM,MAAM,EACZ,QAAQ,MAAM,EACd,OAAO,MAAM,KACZ,MAGE,CAAC;AAEN;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,eAAe,CAAC;AAEzC,4FAA4F;AAC5F,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,EAAE,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAG,MACF,CAAC;AAQhF,0CAA0C;AAC1C,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAKzD;AAuED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,qBAAqB,CA+G5F"}
+{"version":3,"file":"source-locations.d.ts","sourceRoot":"","sources":["../../src/transform/source-locations.ts"],"names":[],"mappings":"AA6BA,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,UAAU,EAAE,CAAC;IACpB,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,gEAAgE;AAChE,eAAO,MAAM,aAAa,gBAAgB,CAAC;AAE3C,4FAA4F;AAC5F,eAAO,MAAM,gBAAgB,mBAAmB,CAAC;AAEjD;;;GAGG;AACH,eAAO,MAAM,YAAY,eAAe,CAAC;AAEzC;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,cAAc,CAAC;AAEvC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GACnB,UAAU,MAAM,EAChB,MAAM,MAAM,EACZ,QAAQ,MAAM,EACd,OAAO,MAAM,KACZ,MAGE,CAAC;AAEN;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,eAAe,CAAC;AAEzC,4FAA4F;AAC5F,eAAO,MAAM,SAAS,GAAI,QAAQ,MAAM,EAAE,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,KAAG,MACF,CAAC;AAQhF,iHAAiH;AACjH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAOxD;AAmFD,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,qBAAqB,CA6J5F"}

package/dist/transform/source-locations.js

@@ -22,6 +22,11 @@ import { resolveReactiveBindings } from '../analyze/reactive-bindings.js';
 export const SOURCE_MARKER = '__fx_source';
 /** Where a component was declared. Keyed by name, since that is all the runtime carries. */
 export const COMPONENT_MARKER = '__fx_component';
+/**
+ * Where a class that extends another was declared, keyed by the class itself: a custom
+ * element's definition, which the runtime can only reach through `element.constructor`.
+ */
+export const CLASS_MARKER = '__fx_class';
 /**
  * Where one reactive hole was written. This one wraps: the position has to travel with the
  * accessor to wherever the dom wires it up. A template is emitted as one overwrite, so the
@@ -53,13 +58,16 @@ const RUNTIME_PRIMITIVES = new Set([
     'signal', 'memo', 'effect', 'store', 'resource', 'watch',
     'createSignal', 'createMemo', 'createEffect', 'createStore', 'createResource',
 ]);
-/** Cheap enough to run before parsing. */
-export function mayHaveReactiveCall(code) {
+/** Whether a module has anything to mark: a primitive call or a subclass. Cheap enough to run before parsing. */
+export function mayHaveSourceMarks(code) {
     for (const name of RUNTIME_PRIMITIVES) {
         if (code.includes(name))
             return true;
     }
-    return code.includes('$signal') || code.includes('$memo') || code.includes('$effect') || code.includes('$store');
+    if (code.includes('$signal') || code.includes('$memo') || code.includes('$effect') || code.includes('$store'))
+        return true;
+    // A subclass gets a declaration mark, so an element with no signal of its own is still found.
+    return /\bclass\b[^{;]*\bextends\b/.test(code);
 }
 /** Positions where the grammar allows exactly one statement, so a second one changes it. */
 const SINGLE_STATEMENT_PARENTS = new Set([
@@ -74,6 +82,8 @@ function isLoneBranch(statement, parent) {
 function isExport(node) {
     return node.type === 'ExportNamedDeclaration' || node.type === 'ExportDefaultDeclaration';
 }
+/** Where a class holds a per-instance initializer: the value of a field. */
+const CLASS_FIELDS = new Set(['PropertyDefinition', 'ClassProperty', 'ClassPrivateProperty', 'AccessorProperty']);
 function isStatement(node) {
     return node.type.endsWith('Statement') || node.type === 'VariableDeclaration';
 }
@@ -103,6 +113,15 @@ function walk(node, visit, stack = []) {
  */
 function nameFor(stack) {
     const declarator = stack[stack.length - 1];
+    // `#count = signal(0)` and `count = signal(0)`: the field's name, without the `#`.
+    if (declarator && CLASS_FIELDS.has(declarator.type)) {
+        const key = declarator.key;
+        if (key?.type === 'Identifier' || key?.type === 'PrivateIdentifier' || key?.type === 'PrivateName') {
+            const name = (key.name ?? key.id?.name);
+            return name;
+        }
+        return undefined;
+    }
     if (declarator?.type !== 'VariableDeclarator')
         return undefined;
     const id = declarator.id;
@@ -170,6 +189,20 @@ export function collectSourceEdits(program, filename) {
                 });
             }
         }
+        // A static block at the top of the body runs once, when the class is defined, with `this`
+        // bound to the class. Only a subclass: that covers every custom element and keeps the mark
+        // off plain classes. An ambient `declare class` has no body to run.
+        if ((node.type === 'ClassDeclaration' || node.type === 'ClassExpression') && node.superClass && !node.declare) {
+            const at = node.loc?.start;
+            const body = node.body;
+            if (at && body) {
+                edits.push({
+                    start: body.start + 1,
+                    end: body.start + 1,
+                    code: `static{globalThis.${CLASS_MARKER}?.(this,${JSON.stringify(filename)},${at.line},${at.column});}`,
+                });
+            }
+        }
         if (node.type !== 'CallExpression')
             return;
         const callee = node.callee;
@@ -186,6 +219,38 @@ export function collectSourceEdits(program, filename) {
         const position = node.loc?.start;
         if (!position)
             return;
+        // A class field (`#count = signal(0)`) runs once per instance, and the class body has no
+        // statement to put the mark in front of. Hoisting it before the class runs it once, at
+        // definition, and the next node created anywhere took its name and line; inside a function
+        // (a mixin) the nearest statement was the function's body block, and the mark landed in
+        // front of the `{`. The call itself carries the mark instead, so it runs right before the
+        // node it describes.
+        for (let i = stack.length - 1; i >= 0; i--) {
+            const up = stack[i];
+            if (isStatement(up))
+                break;
+            if (CLASS_FIELDS.has(up.type)) {
+                if (claimed.has(node.start))
+                    return;
+                claimed.add(node.start);
+                const label = nameFor(stack);
+                // An instance field also hands over `this`: the constructor runs before a custom
+                // element opens its scope, and the instance is what ties the node to it later.
+                const own = !up.static;
+                const args = [
+                    JSON.stringify(filename),
+                    String(position.line),
+                    String(position.column),
+                    label ? JSON.stringify(label) : own ? 'undefined' : undefined,
+                    own ? 'this' : undefined,
+                ]
+                    .filter((a) => a !== undefined)
+                    .join(',');
+                edits.push({ start: node.start, end: node.start, code: `(globalThis.${SOURCE_MARKER}?.(${args}),` });
+                edits.push({ start: node.end, end: node.end, code: ')' });
+                return;
+            }
+        }
         // The mark goes in front of the statement, clear of any span another pass rewrites.
         let statement;
         let parent;

package/dist/transform/source-locations.mjs

@@ -6,6 +6,7 @@ var INTRINSICS = {
   $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.
@@ -16,6 +17,19 @@ var INTRINSICS = {
   // 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" }
 };
@@ -28,8 +42,11 @@ var RUNTIME_PRIMITIVES = {
   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"
@@ -38,6 +55,7 @@ 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*\\(`);
@@ -141,6 +159,7 @@ function resolveReactiveBindings(program) {
 // src/transform/source-locations.ts
 var SOURCE_MARKER = "__fx_source";
 var COMPONENT_MARKER = "__fx_component";
+var CLASS_MARKER = "__fx_class";
 var HOLE_MARKER = "__fx_hole";
 var markHole = (accessor, line, column, name) => `(globalThis.${HOLE_MARKER} ?? ((f) => f))(${accessor},${line},${column}${name === void 0 ? "" : `,${JSON.stringify(name)}`})`;
 var PROPS_MARKER = "__fx_props";
@@ -158,11 +177,12 @@ var RUNTIME_PRIMITIVES2 = /* @__PURE__ */ new Set([
   "createStore",
   "createResource"
 ]);
-function mayHaveReactiveCall(code) {
+function mayHaveSourceMarks(code) {
   for (const name of RUNTIME_PRIMITIVES2) {
     if (code.includes(name)) return true;
   }
-  return code.includes("$signal") || code.includes("$memo") || code.includes("$effect") || code.includes("$store");
+  if (code.includes("$signal") || code.includes("$memo") || code.includes("$effect") || code.includes("$store")) return true;
+  return /\bclass\b[^{;]*\bextends\b/.test(code);
 }
 var SINGLE_STATEMENT_PARENTS = /* @__PURE__ */ new Set([
   "IfStatement",
@@ -181,6 +201,7 @@ function isLoneBranch(statement, parent) {
 function isExport(node) {
   return node.type === "ExportNamedDeclaration" || node.type === "ExportDefaultDeclaration";
 }
+var CLASS_FIELDS = /* @__PURE__ */ new Set(["PropertyDefinition", "ClassProperty", "ClassPrivateProperty", "AccessorProperty"]);
 function isStatement(node) {
   return node.type.endsWith("Statement") || node.type === "VariableDeclaration";
 }
@@ -201,6 +222,14 @@ function walk2(node, visit, stack = []) {
 }
 function nameFor(stack) {
   const declarator = stack[stack.length - 1];
+  if (declarator && CLASS_FIELDS.has(declarator.type)) {
+    const key = declarator.key;
+    if (key?.type === "Identifier" || key?.type === "PrivateIdentifier" || key?.type === "PrivateName") {
+      const name = key.name ?? key.id?.name;
+      return name;
+    }
+    return void 0;
+  }
   if (declarator?.type !== "VariableDeclarator") return void 0;
   const id = declarator.id;
   if (id?.type === "Identifier") return id.name;
@@ -249,6 +278,17 @@ function collectSourceEdits(program, filename) {
         });
       }
     }
+    if ((node.type === "ClassDeclaration" || node.type === "ClassExpression") && node.superClass && !node.declare) {
+      const at = node.loc?.start;
+      const body = node.body;
+      if (at && body) {
+        edits.push({
+          start: body.start + 1,
+          end: body.start + 1,
+          code: `static{globalThis.${CLASS_MARKER}?.(this,${JSON.stringify(filename)},${at.line},${at.column});}`
+        });
+      }
+    }
     if (node.type !== "CallExpression") return;
     const callee = node.callee;
     if (callee?.type !== "Identifier") return;
@@ -258,6 +298,26 @@ function collectSourceEdits(program, filename) {
     if (!intrinsic && !imported) return;
     const position = node.loc?.start;
     if (!position) return;
+    for (let i = stack.length - 1; i >= 0; i--) {
+      const up = stack[i];
+      if (isStatement(up)) break;
+      if (CLASS_FIELDS.has(up.type)) {
+        if (claimed.has(node.start)) return;
+        claimed.add(node.start);
+        const label2 = nameFor(stack);
+        const own = !up.static;
+        const args2 = [
+          JSON.stringify(filename),
+          String(position.line),
+          String(position.column),
+          label2 ? JSON.stringify(label2) : own ? "undefined" : void 0,
+          own ? "this" : void 0
+        ].filter((a) => a !== void 0).join(",");
+        edits.push({ start: node.start, end: node.start, code: `(globalThis.${SOURCE_MARKER}?.(${args2}),` });
+        edits.push({ start: node.end, end: node.end, code: ")" });
+        return;
+      }
+    }
     let statement;
     let parent;
     let index = -1;
@@ -298,6 +358,7 @@ function collectSourceEdits(program, filename) {
   return { edits, marked: edits.length };
 }
 export {
+  CLASS_MARKER,
   COMPONENT_MARKER,
   HOLE_MARKER,
   PROPS_MARKER,
@@ -305,5 +366,5 @@ export {
   collectSourceEdits,
   markHole,
   markProps,
-  mayHaveReactiveCall
+  mayHaveSourceMarks
 };