@fluixi/compiler 1.0.0-alpha.75 → 1.0.0-alpha.77

package/README.md

@@ -38,6 +38,42 @@ gets an RPC stub, the server build keeps and registers the body.
 Most apps don't use this package directly — [`@fluixi/vite-plugin`](../vite-plugin) (and
 [`@fluixi/start`](../start)) wrap it.
 
+## What it does to your code
+
+Beyond turning markup into DOM calls:
+
+**Props you destructured stay reactive.** `function Card({ title })` compiles to
+`props.title` at each use, so the binding keeps updating, and `...rest` becomes the
+`splitProps` call you would have written. Anything it can't prove safe — a reassigned
+binding, a computed key, a default it would have to re-run per read — is left exactly as
+written and reported. On by default; set `propsDestructure: false` for a package that ships
+its **source** for consumers to compile, since the rewrite belongs to whoever compiles.
+
+**`$` intrinsics resolve without an import.** `$signal`, `$memo`, `$effect`, `$store`,
+`$resource`, `$selector`, `$deferred`, `$untrack`, `$untrackStore` compile to the runtime
+calls they stand for, and the import is added for what a module actually used. A primitive
+is recognised by the binding it came from, never by name: `import { signal as state }` is
+recognised, a local `function signal()` is not. A module that binds a `$` name keeps its
+own meaning and gets a diagnostic.
+
+**Unimported tags resolve through rules.** `resolve` says where a capitalised tag comes
+from — an entry per component, or one pattern for a family:
+
+```ts
+createVitePlugin({ resolve: [{ match: /^([A-Z]\w+)$/, module: '/src/components/$1.tsx' }] })
+```
+
+**`load:` splits a component into its own chunk.** `load:visible`, `load:idle`,
+`load:interaction`, `load:media` decide when its module is fetched. It works on a component
+a rule supplies and on one you imported yourself — in the second case the static import is
+removed, which only happens when the name is used nowhere but as a tag.
+
+**It says when it couldn't do these things.** A tag nothing supplies and a `load:` that
+can't apply both build cleanly and fail at runtime, so they're reported at build time with
+the reason. The bundler adapters print them; `TransformResult` carries them as
+`propsDiagnostics`, `intrinsicDiagnostics`, `loadDiagnostics` and `unresolvedDiagnostics`
+if you're driving the transform yourself.
+
 ## 📦 Installation
 
 ```sh
@@ -68,8 +104,8 @@ import { transformTemplates } from '@fluixi/compiler/transform';
 const { code, map } = transformTemplates(source, 'App.tsx', {})!;
 ```
 
-`transformTemplates` returns `null` when a module has no JSX and no templates, so a
-bundler can leave the file untouched.
+`transformTemplates` returns `null` when there is nothing to do — no JSX, no templates, no
+`$` intrinsics and nothing to report — so a bundler can leave the file untouched.
 
 ### Compiling through Babel
 

package/dist/analyze/intrinsics.cjs

@@ -0,0 +1 @@
+"use strict";var c=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var u=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var d=(e,r)=>{for(var n in r)c(e,n,{get:r[n],enumerable:!0})},f=(e,r,n,i)=>{if(r&&typeof r=="object"||typeof r=="function")for(let o of u(r))!m.call(e,o)&&o!==n&&c(e,o,{get:()=>r[o],enumerable:!(i=l(r,o))||i.enumerable});return e};var x=e=>f(c({},"__esModule",{value:!0}),e);var h={};d(h,{INTRINSICS:()=>s,PRIMITIVE_MODULES:()=>a,REACTIVE_MODULE:()=>t,RUNTIME_PRIMITIVES:()=>p,isIntrinsicName:()=>R,isPrimitiveModule:()=>v,mayHaveIntrinsic:()=>I});module.exports=x(h);var t="@fluixi/reactive/signal",s={$signal:{export:"signal",module:t,returns:"signal-handle"},$memo:{export:"memo",module:t,returns:"memo-handle"},$effect:{export:"effect",module:t,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:t,returns:"resource-handle"},$selector:{export:"createSelector",module:t,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:t,returns:"memo-accessor"},$untrack:{export:"untrack",module:t,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}},p={signal:"signal-handle",memo:"memo-handle",effect:"effect",store:"store-handle",createSignal:["signal-accessor","signal-setter"],createMemo:"memo-accessor",createEffect:"effect",createRenderEffect:"effect",createStore:"reactive-object",resource:"resource-handle",createResource:"reactive-object",createSelector:"memo-accessor",createDeferred:"memo-accessor"},a=["@fluixi/reactive","@fluixi/reactive/signal","@fluixi/reactive/signal-next","@fluixi/reactive/store","@fluixi/core","@fluixi/core/rx"],g=new RegExp(`\\$(?:${Object.keys(s).map(e=>e.slice(1)).join("|")})\\s*\\(`);function I(e){return g.test(e)}function R(e){return Object.prototype.hasOwnProperty.call(s,e)}function v(e){return a.includes(e)}

package/dist/analyze/intrinsics.d.ts

@@ -0,0 +1,67 @@
+/**
+ * The reactive primitives the compiler knows by name, in one place.
+ *
+ * Two ways to write the same thing. The runtime call, which needs an import and works
+ * without us:
+ *
+ *   import { createSignal } from '@fluixi/reactive/signal';
+ *   const count = createSignal(0);
+ *
+ * And the intrinsic, which the compiler resolves and imports for you:
+ *
+ *   const count = $signal(0);
+ *
+ * They are not two reactive systems. `$signal` compiles to the same `createSignal` call,
+ * so there's one graph, one lifecycle, one SSR story. The `$` form is authoring sugar
+ * the compiler understands; the runtime form stays public, because a library that never
+ * runs this compiler still has to be able to write reactive code.
+ *
+ * Everything the compiler needs to know about a primitive lives in this table rather
+ * than spread across passes, so adding one is an entry, not a new code path.
+ */
+/** What a binding holds, once we know where it came from. */
+export type ReactiveKind = 'plain'
+/** `signal(0)` — one object, read with `.get()` and written with `.set()`. */
+ | 'signal-handle'
+/** `memo(fn)` — read-only, so `.get()` only. */
+ | 'memo-handle'
+/** `store(obj)` — read properties directly, `.set()` writes. */
+ | 'store-handle'
+/** `resource(fn)` — `.get()` reads, with `.loading`/`.latest`/`.refetch()` on it. */
+ | 'resource-handle'
+/** The accessor half of the tuple form, `const [count] = createSignal(0)`. */
+ | 'signal-accessor' | 'signal-setter' | 'memo-accessor' | 'effect' | 'reactive-object';
+export interface Intrinsic {
+    /** Runtime export this compiles to. */
+    export: string;
+    /** Module it comes from. */
+    module: string;
+    /**
+     * What the call yields. A tuple means the call is destructured into that many
+     * bindings — `createSignal` gives an accessor and a setter, in that order.
+     */
+    returns: ReactiveKind | readonly ReactiveKind[];
+}
+/** Module the reactive primitives are imported from when the compiler adds the import. */
+export declare const REACTIVE_MODULE = "@fluixi/reactive/signal";
+/**
+ * `$name` → the runtime it stands for.
+ *
+ * The `$` prefix is reserved. A local binding of the same name wins — it has to, or the
+ * compiler would rewrite code that means something else — and that's reported rather
+ * than done quietly.
+ */
+export declare const INTRINSICS: Readonly<Record<string, Intrinsic>>;
+/**
+ * The runtime names, for the other direction: source that imports `createSignal` gets
+ * classified the same way as source that writes `$signal`, so later passes see one
+ * vocabulary whichever form the author used.
+ */
+export declare const RUNTIME_PRIMITIVES: Readonly<Record<string, Intrinsic['returns']>>;
+/** Modules whose exports count as reactive primitives. */
+export declare const PRIMITIVE_MODULES: readonly string[];
+export declare function mayHaveIntrinsic(code: string): boolean;
+export declare function isIntrinsicName(name: string): boolean;
+/** Whether a module path exports the reactive primitives. */
+export declare function isPrimitiveModule(source: string): boolean;
+//# sourceMappingURL=intrinsics.d.ts.map

package/dist/analyze/intrinsics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intrinsics.d.ts","sourceRoot":"","sources":["../../src/analyze/intrinsics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,6DAA6D;AAC7D,MAAM,MAAM,YAAY,GACpB,OAAO;AACT,8EAA8E;GAC5E,eAAe;AACjB,gDAAgD;GAC9C,aAAa;AACf,gEAAgE;GAC9D,cAAc;AAChB,qFAAqF;GACnF,iBAAiB;AACnB,8EAA8E;GAC5E,iBAAiB,GACjB,eAAe,GACf,eAAe,GACf,QAAQ,GACR,iBAAiB,CAAC;AAEtB,MAAM,WAAW,SAAS;IACxB,uCAAuC;IACvC,MAAM,EAAE,MAAM,CAAC;IACf,4BAA4B;IAC5B,MAAM,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,OAAO,EAAE,YAAY,GAAG,SAAS,YAAY,EAAE,CAAC;CACjD;AAED,0FAA0F;AAC1F,eAAO,MAAM,eAAe,4BAA4B,CAAC;AAEzD;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,CAmB1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC,CAc7E,CAAC;AAEF,0DAA0D;AAC1D,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAO9C,CAAC;AAQF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEtD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED,6DAA6D;AAC7D,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAEzD"}

package/dist/analyze/intrinsics.js

@@ -0,0 +1,91 @@
+/**
+ * The reactive primitives the compiler knows by name, in one place.
+ *
+ * Two ways to write the same thing. The runtime call, which needs an import and works
+ * without us:
+ *
+ *   import { createSignal } from '@fluixi/reactive/signal';
+ *   const count = createSignal(0);
+ *
+ * And the intrinsic, which the compiler resolves and imports for you:
+ *
+ *   const count = $signal(0);
+ *
+ * They are not two reactive systems. `$signal` compiles to the same `createSignal` call,
+ * so there's one graph, one lifecycle, one SSR story. The `$` form is authoring sugar
+ * the compiler understands; the runtime form stays public, because a library that never
+ * runs this compiler still has to be able to write reactive code.
+ *
+ * Everything the compiler needs to know about a primitive lives in this table rather
+ * than spread across passes, so adding one is an entry, not a new code path.
+ */
+/** Module the reactive primitives are imported from when the compiler adds the import. */
+export const REACTIVE_MODULE = '@fluixi/reactive/signal';
+/**
+ * `$name` → the runtime it stands for.
+ *
+ * The `$` prefix is reserved. A local binding of the same name wins — it has to, or the
+ * compiler would rewrite code that means something else — and that's reported rather
+ * than done quietly.
+ */
+export const 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' },
+    // 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' },
+};
+/**
+ * The runtime names, for the other direction: source that imports `createSignal` gets
+ * classified the same way as source that writes `$signal`, so later passes see one
+ * vocabulary whichever form the author used.
+ */
+export const 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',
+    createStore: 'reactive-object',
+    resource: 'resource-handle',
+    createResource: 'reactive-object',
+    createSelector: 'memo-accessor',
+    createDeferred: 'memo-accessor',
+};
+/** Modules whose exports count as reactive primitives. */
+export const PRIMITIVE_MODULES = [
+    '@fluixi/reactive',
+    '@fluixi/reactive/signal',
+    '@fluixi/reactive/signal-next',
+    '@fluixi/reactive/store',
+    '@fluixi/core',
+    '@fluixi/core/rx',
+];
+/**
+ * Cheap text check for the file-skipping fast path: a module with no `$` call never
+ * needs parsing. Non-global, so it has no lastIndex to carry between calls.
+ */
+const INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join('|')})\\s*\\(`);
+export function mayHaveIntrinsic(code) {
+    return INTRINSIC_CALL.test(code);
+}
+export function isIntrinsicName(name) {
+    return Object.prototype.hasOwnProperty.call(INTRINSICS, name);
+}
+/** Whether a module path exports the reactive primitives. */
+export function isPrimitiveModule(source) {
+    return PRIMITIVE_MODULES.includes(source);
+}

package/dist/analyze/intrinsics.mjs

@@ -0,0 +1 @@
+var r="@fluixi/reactive/signal",t={$signal:{export:"signal",module:r,returns:"signal-handle"},$memo:{export:"memo",module:r,returns:"memo-handle"},$effect:{export:"effect",module:r,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:r,returns:"resource-handle"},$selector:{export:"createSelector",module:r,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:r,returns:"memo-accessor"},$untrack:{export:"untrack",module:r,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}},c={signal:"signal-handle",memo:"memo-handle",effect:"effect",store:"store-handle",createSignal:["signal-accessor","signal-setter"],createMemo:"memo-accessor",createEffect:"effect",createRenderEffect:"effect",createStore:"reactive-object",resource:"resource-handle",createResource:"reactive-object",createSelector:"memo-accessor",createDeferred:"memo-accessor"},o=["@fluixi/reactive","@fluixi/reactive/signal","@fluixi/reactive/signal-next","@fluixi/reactive/store","@fluixi/core","@fluixi/core/rx"],n=new RegExp(`\\$(?:${Object.keys(t).map(e=>e.slice(1)).join("|")})\\s*\\(`);function s(e){return n.test(e)}function i(e){return Object.prototype.hasOwnProperty.call(t,e)}function a(e){return o.includes(e)}export{t as INTRINSICS,o as PRIMITIVE_MODULES,r as REACTIVE_MODULE,c as RUNTIME_PRIMITIVES,i as isIntrinsicName,a as isPrimitiveModule,s as mayHaveIntrinsic};

package/dist/analyze/props-destructure.cjs

@@ -0,0 +1 @@
+"use strict";var p=Object.defineProperty;var h=Object.getOwnPropertyDescriptor;var w=Object.getOwnPropertyNames;var b=Object.prototype.hasOwnProperty;var k=(s,t)=>{for(var e in t)p(s,e,{get:t[e],enumerable:!0})},v=(s,t,e,n)=>{if(t&&typeof t=="object"||typeof t=="function")for(let a of w(t))!b.call(s,a)&&a!==e&&p(s,a,{get:()=>t[a],enumerable:!(n=h(t,a))||n.enumerable});return s};var x=s=>v(p({},"__esModule",{value:!0}),s);var R={};k(R,{explainBail:()=>E,planPropsDestructure:()=>D});module.exports=x(R);function u(s,t){if(s)switch(s.type){case"Identifier":t.add(s.name);return;case"ObjectPattern":for(let e of s.properties)e.type==="RestElement"?u(e.argument,t):u(e.value,t);return;case"ArrayPattern":for(let e of s.elements)u(e,t);return;case"AssignmentPattern":u(s.left,t);return;case"RestElement":u(s.argument,t);return}}function m(s){switch(s.type){case"StringLiteral":case"NumericLiteral":case"BooleanLiteral":case"NullLiteral":case"BigIntLiteral":case"RegExpLiteral":case"Identifier":return!0;case"Literal":return!0;case"TemplateLiteral":return s.expressions.every(m);case"UnaryExpression":return m(s.argument);case"MemberExpression":return!1;default:return!1}}function f(s,t){if(!(!s||typeof s!="object")){t(s);for(let e of Object.keys(s)){if(e==="loc"||e==="range"||e==="leadingComments"||e==="trailingComments")continue;let n=s[e];if(Array.isArray(n))for(let a of n)a&&typeof a=="object"&&f(a,t);else n&&typeof n=="object"&&typeof n.type=="string"&&f(n,t)}}}function P(s){let t=new Set;return f(s,e=>{if(e.type==="AssignmentExpression")u(e.left,t);else if(e.type==="UpdateExpression"){let n=e.argument;n?.type==="Identifier"&&t.add(n.name)}}),t}function S(s,t){let e=new Set,n=a=>{let c=new Set;u(a,c);for(let i of c)t.has(i)&&e.add(i)};return f(s,a=>{switch(a.type){case"VariableDeclarator":n(a.id);return;case"FunctionDeclaration":case"FunctionExpression":case"ArrowFunctionExpression":n(a.id);for(let c of a.params??[])n(c);return;case"CatchClause":n(a.param);return;case"ClassDeclaration":case"ClassExpression":n(a.id);return}}),e}function N(s,t,e){for(let n of s.properties??[]){if(n.type==="RestElement"){let o=n.argument;if(o?.type!=="Identifier"||t.length>0){let l=new Set;u(o,l);for(let y of l)e.bails.push({name:y,reason:"rest"});continue}e.rest={name:o.name,keys:[]};continue}if(n.computed){let o=new Set;u(n.value,o);for(let l of o)e.bails.push({name:l,reason:"computed"});continue}let a=n.key,c=a.type==="Identifier"?a.name:a.value,i=n.value,r;i.type==="AssignmentPattern"&&(r=i.right,i=i.left);let d=[...t,c];if(i.type==="Identifier"){if(r&&!m(r)){e.bails.push({name:i.name,reason:"unsafe-default"});continue}e.reads.push({name:i.name,path:d,...r?{fallback:r}:{}});continue}if(i.type==="ObjectPattern"){if(r){let o=new Set;u(i,o);for(let l of o)e.bails.push({name:l,reason:"unsafe-default"});continue}N(i,d,e);continue}let g=new Set;u(i,g);for(let o of g)e.bails.push({name:o,reason:"computed"})}}function D(s,t){let e={reads:[],bails:[]};if(s?.type!=="ObjectPattern"||(N(s,[],e),e.rest&&(t?.type!=="BlockStatement"?(e.bails.push({name:e.rest.name,reason:"rest"}),delete e.rest):e.rest.keys=(s.properties??[]).filter(r=>r.type!=="RestElement"&&!r.computed).map(r=>{let d=r.key;return d.type==="Identifier"?d.name:d.value})),e.reads.length===0&&!e.rest))return e;let n=new Set(e.reads.map(r=>r.name));e.rest&&n.add(e.rest.name);let a=P(t),c=S(t,n),i=[];for(let r of e.reads)a.has(r.name)?e.bails.push({name:r.name,reason:"reassigned"}):c.has(r.name)?e.bails.push({name:r.name,reason:"shadowed"}):i.push(r);return e.reads=i,e.rest&&a.has(e.rest.name)?(e.bails.push({name:e.rest.name,reason:"reassigned"}),delete e.rest):e.rest&&c.has(e.rest.name)&&(e.bails.push({name:e.rest.name,reason:"shadowed"}),delete e.rest),e}function E(s){switch(s){case"rest":return"this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";case"computed":return"the property is not known until it runs";case"reassigned":return"the binding is assigned to, and props are read-only";case"shadowed":return"an inner scope binds the same name";case"unsafe-default":return"the default would have to run again on every read"}}

package/dist/analyze/props-destructure.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Props destructuring, without losing reactivity.
+ *
+ * Props come in as an object of getters, so `props.name` re-reads every time and that
+ * keeps a binding current. `const { name } = props` copies the value out once, which is
+ * why we call splitProps in about 84 components.
+ *
+ * The plan here rewrites `name` to `props.name` at each use rather than making it an
+ * accessor. `() => props.name` would change the binding's type, and then every use has
+ * to change with it: passed to a plain function, stored in an array, compared with
+ * `===`. That's a whole-program job. Substitution is one function body and a rename.
+ *
+ * It does change one thing. A read that happens later sees the current value instead of
+ * the value at destructure time, which is the reason to do this at all. Anything past
+ * that I leave as written and report, so splitProps stays correct where it's still the
+ * right answer.
+ *
+ * No babel in here (see no-babel-in-core.spec.ts) — nodes are read structurally, the way
+ * transform/bindings.ts does, so either front-end can drive it.
+ */
+interface Node {
+    type: string;
+    [key: string]: unknown;
+}
+/** Why a binding was left alone. All of these change more than when the read happens. */
+export type DestructureBail = 
+/**
+ * A rest we can't serve: destructured further (`...{ a }`), or in a function with no
+ * block to put the splitProps call in (`({ a, ...rest }) => …`).
+ */
+'rest'
+/** `const { [key]: a } = props` — we don't know the property until it runs. */
+ | 'computed'
+/** The binding gets assigned to, and props are read-only, so it can't become a member. */
+ | 'reassigned'
+/** An inner scope binds the same name, so a use site could mean either one. */
+ | 'shadowed'
+/**
+ * A default we can't re-run on every read: a function hands out a new identity each
+ * time, a call runs its side effect each time.
+ */
+ | 'unsafe-default';
+export interface PropsRead {
+    /** The local name the pattern introduced. */
+    name: string;
+    /** Property path to read through instead — `['user', 'name']` for `{ user: { name } }`. */
+    path: string[];
+    /**
+     * Default from the pattern. JS only applies one for `undefined`, not for null, so
+     * codegen has to test `=== undefined` rather than reach for `??`, and re-run it on
+     * every read.
+     */
+    fallback?: Node;
+}
+export interface DestructurePlan {
+    /** Bindings we can rewrite to a property read. */
+    reads: PropsRead[];
+    /** Bindings we left alone, with the reason to report. */
+    bails: {
+        name: string;
+        reason: DestructureBail;
+    }[];
+    /**
+     * A `...rest`, and the keys it has to exclude.
+     *
+     * This is what splitProps is for: it copies the getters across rather than reading
+     * them, which is the reason a plain `...rest` can't be rewritten. So instead of
+     * refusing the pattern, we write the splitProps call the author would have written.
+     */
+    rest?: {
+        name: string;
+        keys: string[];
+    };
+}
+/**
+ * Plan one props pattern. `pattern` is the ObjectPattern, `body` the function body its
+ * bindings live in. Every binding ends up in `reads` (rewrite it) or `bails` (leave it
+ * and say why).
+ */
+export declare function planPropsDestructure(pattern: Node, body: Node | null | undefined): DestructurePlan;
+/** Reason text for the diagnostic. */
+export declare function explainBail(reason: DestructureBail): string;
+export {};
+//# sourceMappingURL=props-destructure.d.ts.map

package/dist/analyze/props-destructure.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"props-destructure.d.ts","sourceRoot":"","sources":["../../src/analyze/props-destructure.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,UAAU,IAAI;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED,yFAAyF;AACzF,MAAM,MAAM,eAAe;AACzB;;;GAGG;AACD,MAAM;AACR,+EAA+E;GAC7E,UAAU;AACZ,0FAA0F;GACxF,YAAY;AACd,+EAA+E;GAC7E,UAAU;AACZ;;;GAGG;GACD,gBAAgB,CAAC;AAErB,MAAM,WAAW,SAAS;IACxB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAC;IACb,2FAA2F;IAC3F,IAAI,EAAE,MAAM,EAAE,CAAC;IACf;;;;OAIG;IACH,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,eAAe;IAC9B,kDAAkD;IAClD,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,yDAAyD;IACzD,KAAK,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,eAAe,CAAA;KAAE,EAAE,CAAC;IACnD;;;;;;OAMG;IACH,IAAI,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CACzC;AAoLD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS,GAAG,eAAe,CAgDlG;AAED,sCAAsC;AACtC,wBAAgB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAa3D"}

package/dist/analyze/props-destructure.js

@@ -0,0 +1,272 @@
+/**
+ * Props destructuring, without losing reactivity.
+ *
+ * Props come in as an object of getters, so `props.name` re-reads every time and that
+ * keeps a binding current. `const { name } = props` copies the value out once, which is
+ * why we call splitProps in about 84 components.
+ *
+ * The plan here rewrites `name` to `props.name` at each use rather than making it an
+ * accessor. `() => props.name` would change the binding's type, and then every use has
+ * to change with it: passed to a plain function, stored in an array, compared with
+ * `===`. That's a whole-program job. Substitution is one function body and a rename.
+ *
+ * It does change one thing. A read that happens later sees the current value instead of
+ * the value at destructure time, which is the reason to do this at all. Anything past
+ * that I leave as written and report, so splitProps stays correct where it's still the
+ * right answer.
+ *
+ * No babel in here (see no-babel-in-core.spec.ts) — nodes are read structurally, the way
+ * transform/bindings.ts does, so either front-end can drive it.
+ */
+/** Every name a pattern introduces, so we can check each one for shadowing and writes. */
+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;
+    }
+}
+/**
+ * Defaults get re-run on every read now, so they have to be cheap and stable. Literals
+ * and identifiers are. A function isn't — it hands out a new identity each read, which
+ * breaks anything comparing props — and neither is a call.
+ */
+function isSafeDefault(node) {
+    switch (node.type) {
+        case 'StringLiteral':
+        case 'NumericLiteral':
+        case 'BooleanLiteral':
+        case 'NullLiteral':
+        case 'BigIntLiteral':
+        case 'RegExpLiteral':
+        case 'Identifier':
+            return true;
+        // ESTree spells every literal as `Literal`; both shapes reach this analysis.
+        case 'Literal':
+            return true;
+        case 'TemplateLiteral':
+            return node.expressions.every(isSafeDefault);
+        case 'UnaryExpression':
+            return isSafeDefault(node.argument);
+        case 'MemberExpression':
+            // Could be a getter, and we'd be running it on every read.
+            return false;
+        default:
+            return false;
+    }
+}
+/** Walk everything under `root`. No visitor API here, so it's hand-rolled. */
+function walk(root, visit) {
+    if (!root || typeof root !== 'object')
+        return;
+    visit(root);
+    for (const key of Object.keys(root)) {
+        if (key === 'loc' || key === 'range' || key === 'leadingComments' || key === 'trailingComments')
+            continue;
+        const value = root[key];
+        if (Array.isArray(value)) {
+            for (const item of value)
+                if (item && typeof item === 'object')
+                    walk(item, visit);
+        }
+        else if (value && typeof value === 'object' && typeof value.type === 'string') {
+            walk(value, visit);
+        }
+    }
+}
+/** Anything written to in the body — `name = x`, `name++`, `[name] = …`. */
+function reassignedNames(body) {
+    const written = new Set();
+    walk(body, (node) => {
+        if (node.type === 'AssignmentExpression')
+            patternNames(node.left, written);
+        else if (node.type === 'UpdateExpression') {
+            const arg = node.argument;
+            if (arg?.type === 'Identifier')
+                written.add(arg.name);
+        }
+    });
+    return written;
+}
+/** Names an inner scope re-binds, where a use site would mean something else. */
+function shadowedNames(body, candidates) {
+    const shadowed = new Set();
+    const note = (node) => {
+        const names = new Set();
+        patternNames(node, names);
+        for (const n of names)
+            if (candidates.has(n))
+                shadowed.add(n);
+    };
+    walk(body, (node) => {
+        switch (node.type) {
+            case 'VariableDeclarator':
+                note(node.id);
+                return;
+            case 'FunctionDeclaration':
+            case 'FunctionExpression':
+            case 'ArrowFunctionExpression':
+                note(node.id);
+                for (const p of node.params ?? [])
+                    note(p);
+                return;
+            case 'CatchClause':
+                note(node.param);
+                return;
+            case 'ClassDeclaration':
+            case 'ClassExpression':
+                note(node.id);
+                return;
+        }
+    });
+    return shadowed;
+}
+/** One level of an object pattern, recursing into nested ones. */
+function collect(pattern, path, plan) {
+    for (const property of pattern.properties ?? []) {
+        if (property.type === 'RestElement') {
+            const argument = property.argument;
+            // Only a plain name. `...{ a }` would need its own splitProps and its own rules.
+            if (argument?.type !== 'Identifier' || path.length > 0) {
+                const names = new Set();
+                patternNames(argument, names);
+                for (const name of names)
+                    plan.bails.push({ name, reason: 'rest' });
+                continue;
+            }
+            plan.rest = { name: argument.name, keys: [] };
+            continue;
+        }
+        if (property.computed) {
+            const names = new Set();
+            patternNames(property.value, names);
+            for (const name of names)
+                plan.bails.push({ name, reason: 'computed' });
+            continue;
+        }
+        const key = property.key;
+        const propertyName = (key.type === 'Identifier' ? key.name : key.value);
+        let value = property.value;
+        let fallback;
+        if (value.type === 'AssignmentPattern') {
+            fallback = value.right;
+            value = value.left;
+        }
+        const here = [...path, propertyName];
+        if (value.type === 'Identifier') {
+            if (fallback && !isSafeDefault(fallback)) {
+                plan.bails.push({ name: value.name, reason: 'unsafe-default' });
+                continue;
+            }
+            plan.reads.push({ name: value.name, path: here, ...(fallback ? { fallback } : {}) });
+            continue;
+        }
+        if (value.type === 'ObjectPattern') {
+            // `{ user: { name } = {} }` would have to build the default object on every read.
+            if (fallback) {
+                const names = new Set();
+                patternNames(value, names);
+                for (const name of names)
+                    plan.bails.push({ name, reason: 'unsafe-default' });
+                continue;
+            }
+            collect(value, here, plan);
+            continue;
+        }
+        // An array pattern indexes into a value we can't prove is stable, so leave it.
+        const names = new Set();
+        patternNames(value, names);
+        for (const name of names)
+            plan.bails.push({ name, reason: 'computed' });
+    }
+}
+/**
+ * Plan one props pattern. `pattern` is the ObjectPattern, `body` the function body its
+ * bindings live in. Every binding ends up in `reads` (rewrite it) or `bails` (leave it
+ * and say why).
+ */
+export function planPropsDestructure(pattern, body) {
+    const plan = { reads: [], bails: [] };
+    if (pattern?.type !== 'ObjectPattern')
+        return plan;
+    collect(pattern, [], plan);
+    if (plan.rest) {
+        // The splitProps call is a statement, so there has to be somewhere to put it.
+        if (body?.type !== 'BlockStatement') {
+            plan.bails.push({ name: plan.rest.name, reason: 'rest' });
+            delete plan.rest;
+        }
+        else {
+            // Keys the rest has to exclude: every top-level property the pattern names.
+            plan.rest.keys = (pattern.properties ?? [])
+                .filter((p) => p.type !== 'RestElement' && !p.computed)
+                .map((p) => {
+                const key = p.key;
+                return (key.type === 'Identifier' ? key.name : key.value);
+            });
+        }
+    }
+    if (plan.reads.length === 0 && !plan.rest)
+        return plan;
+    const candidates = new Set(plan.reads.map((r) => r.name));
+    if (plan.rest)
+        candidates.add(plan.rest.name);
+    const written = reassignedNames(body);
+    const shadowed = shadowedNames(body, candidates);
+    const kept = [];
+    for (const read of plan.reads) {
+        if (written.has(read.name))
+            plan.bails.push({ name: read.name, reason: 'reassigned' });
+        else if (shadowed.has(read.name))
+            plan.bails.push({ name: read.name, reason: 'shadowed' });
+        else
+            kept.push(read);
+    }
+    plan.reads = kept;
+    // The rest binding is declared by the code we emit, so it has to survive the same
+    // checks: reassigning it or shadowing the name would break what we wrote.
+    if (plan.rest && written.has(plan.rest.name)) {
+        plan.bails.push({ name: plan.rest.name, reason: 'reassigned' });
+        delete plan.rest;
+    }
+    else if (plan.rest && shadowed.has(plan.rest.name)) {
+        plan.bails.push({ name: plan.rest.name, reason: 'shadowed' });
+        delete plan.rest;
+    }
+    return plan;
+}
+/** Reason text for the diagnostic. */
+export function explainBail(reason) {
+    switch (reason) {
+        case 'rest':
+            return 'this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters';
+        case 'computed':
+            return 'the property is not known until it runs';
+        case 'reassigned':
+            return 'the binding is assigned to, and props are read-only';
+        case 'shadowed':
+            return 'an inner scope binds the same name';
+        case 'unsafe-default':
+            return 'the default would have to run again on every read';
+    }
+}

package/dist/analyze/props-destructure.mjs

@@ -0,0 +1 @@
+function u(s,n){if(s)switch(s.type){case"Identifier":n.add(s.name);return;case"ObjectPattern":for(let e of s.properties)e.type==="RestElement"?u(e.argument,n):u(e.value,n);return;case"ArrayPattern":for(let e of s.elements)u(e,n);return;case"AssignmentPattern":u(s.left,n);return;case"RestElement":u(s.argument,n);return}}function p(s){switch(s.type){case"StringLiteral":case"NumericLiteral":case"BooleanLiteral":case"NullLiteral":case"BigIntLiteral":case"RegExpLiteral":case"Identifier":return!0;case"Literal":return!0;case"TemplateLiteral":return s.expressions.every(p);case"UnaryExpression":return p(s.argument);case"MemberExpression":return!1;default:return!1}}function f(s,n){if(!(!s||typeof s!="object")){n(s);for(let e of Object.keys(s)){if(e==="loc"||e==="range"||e==="leadingComments"||e==="trailingComments")continue;let t=s[e];if(Array.isArray(t))for(let a of t)a&&typeof a=="object"&&f(a,n);else t&&typeof t=="object"&&typeof t.type=="string"&&f(t,n)}}}function y(s){let n=new Set;return f(s,e=>{if(e.type==="AssignmentExpression")u(e.left,n);else if(e.type==="UpdateExpression"){let t=e.argument;t?.type==="Identifier"&&n.add(t.name)}}),n}function h(s,n){let e=new Set,t=a=>{let c=new Set;u(a,c);for(let i of c)n.has(i)&&e.add(i)};return f(s,a=>{switch(a.type){case"VariableDeclarator":t(a.id);return;case"FunctionDeclaration":case"FunctionExpression":case"ArrowFunctionExpression":t(a.id);for(let c of a.params??[])t(c);return;case"CatchClause":t(a.param);return;case"ClassDeclaration":case"ClassExpression":t(a.id);return}}),e}function g(s,n,e){for(let t of s.properties??[]){if(t.type==="RestElement"){let o=t.argument;if(o?.type!=="Identifier"||n.length>0){let l=new Set;u(o,l);for(let N of l)e.bails.push({name:N,reason:"rest"});continue}e.rest={name:o.name,keys:[]};continue}if(t.computed){let o=new Set;u(t.value,o);for(let l of o)e.bails.push({name:l,reason:"computed"});continue}let a=t.key,c=a.type==="Identifier"?a.name:a.value,i=t.value,r;i.type==="AssignmentPattern"&&(r=i.right,i=i.left);let d=[...n,c];if(i.type==="Identifier"){if(r&&!p(r)){e.bails.push({name:i.name,reason:"unsafe-default"});continue}e.reads.push({name:i.name,path:d,...r?{fallback:r}:{}});continue}if(i.type==="ObjectPattern"){if(r){let o=new Set;u(i,o);for(let l of o)e.bails.push({name:l,reason:"unsafe-default"});continue}g(i,d,e);continue}let m=new Set;u(i,m);for(let o of m)e.bails.push({name:o,reason:"computed"})}}function w(s,n){let e={reads:[],bails:[]};if(s?.type!=="ObjectPattern"||(g(s,[],e),e.rest&&(n?.type!=="BlockStatement"?(e.bails.push({name:e.rest.name,reason:"rest"}),delete e.rest):e.rest.keys=(s.properties??[]).filter(r=>r.type!=="RestElement"&&!r.computed).map(r=>{let d=r.key;return d.type==="Identifier"?d.name:d.value})),e.reads.length===0&&!e.rest))return e;let t=new Set(e.reads.map(r=>r.name));e.rest&&t.add(e.rest.name);let a=y(n),c=h(n,t),i=[];for(let r of e.reads)a.has(r.name)?e.bails.push({name:r.name,reason:"reassigned"}):c.has(r.name)?e.bails.push({name:r.name,reason:"shadowed"}):i.push(r);return e.reads=i,e.rest&&a.has(e.rest.name)?(e.bails.push({name:e.rest.name,reason:"reassigned"}),delete e.rest):e.rest&&c.has(e.rest.name)&&(e.bails.push({name:e.rest.name,reason:"shadowed"}),delete e.rest),e}function b(s){switch(s){case"rest":return"this rest element cannot be served by splitProps, and copying the props into a plain object would lose the getters";case"computed":return"the property is not known until it runs";case"reassigned":return"the binding is assigned to, and props are read-only";case"shadowed":return"an inner scope binds the same name";case"unsafe-default":return"the default would have to run again on every read"}}export{b as explainBail,w as planPropsDestructure};

package/dist/analyze/reactive-bindings.cjs

@@ -0,0 +1 @@
+"use strict";var f=Object.defineProperty;var g=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var N=Object.prototype.hasOwnProperty;var I=(r,e)=>{for(var i in e)f(r,i,{get:e[i],enumerable:!0})},x=(r,e,i,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let n of y(e))!N.call(r,n)&&n!==i&&f(r,n,{get:()=>e[n],enumerable:!(t=g(e,n))||t.enumerable});return r};var v=r=>x(f({},"__esModule",{value:!0}),r);var b={};I(b,{declaredNames:()=>E,resolveReactiveBindings:()=>w});module.exports=v(b);var o="@fluixi/reactive/signal",l={$signal:{export:"signal",module:o,returns:"signal-handle"},$memo:{export:"memo",module:o,returns:"memo-handle"},$effect:{export:"effect",module:o,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:o,returns:"resource-handle"},$selector:{export:"createSelector",module:o,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:o,returns:"memo-accessor"},$untrack:{export:"untrack",module:o,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}},p={signal:"signal-handle",memo:"memo-handle",effect:"effect",store:"store-handle",createSignal:["signal-accessor","signal-setter"],createMemo:"memo-accessor",createEffect:"effect",createRenderEffect:"effect",createStore:"reactive-object",resource:"resource-handle",createResource:"reactive-object",createSelector:"memo-accessor",createDeferred:"memo-accessor"},R=["@fluixi/reactive","@fluixi/reactive/signal","@fluixi/reactive/signal-next","@fluixi/reactive/store","@fluixi/core","@fluixi/core/rx"],D=new RegExp(`\\$(?:${Object.keys(l).map(r=>r.slice(1)).join("|")})\\s*\\(`);function d(r){return R.includes(r)}function s(r,e){if(r)switch(r.type){case"Identifier":e.add(r.name);return;case"ObjectPattern":for(let i of r.properties??[])i.type==="RestElement"?s(i.argument,e):s(i.value,e);return;case"ArrayPattern":for(let i of r.elements??[])s(i,e);return;case"AssignmentPattern":s(r.left,e);return;case"RestElement":s(r.argument,e);return}}function c(r,e){if(!(!r||typeof r!="object"||typeof r.type!="string")){e(r);for(let i of Object.keys(r)){if(i==="loc"||i==="leadingComments"||i==="trailingComments")continue;let t=r[i];if(Array.isArray(t))for(let n of t)c(n,e);else t&&typeof t=="object"&&c(t,e)}}}function S(r,e){if(r.type!=="CallExpression")return;let i=r.callee;if(i?.type!=="Identifier")return;let t=i.name,n=e.primitives.get(t);if(n)return n;let a=l[t];if(a&&!e.shadowed.has(t))return a.returns}function h(r,e,i){if(Array.isArray(e)){r.type==="ArrayPattern"&&r.elements.forEach((t,n)=>{let a=e[n];t?.type==="Identifier"&&a&&i.set(t.name,a)});return}r.type==="Identifier"&&i.set(r.name,e)}function E(r){let e=new Set;return c(r,i=>{switch(i.type){case"VariableDeclarator":s(i.id,e);return;case"FunctionDeclaration":case"FunctionExpression":case"ArrowFunctionExpression":s(i.id,e);for(let t of i.params??[])s(t,e);return;case"ClassDeclaration":case"ClassExpression":s(i.id,e);return;case"ImportSpecifier":case"ImportDefaultSpecifier":case"ImportNamespaceSpecifier":s(i.local,e);return;case"CatchClause":s(i.param,e);return}}),e}function w(r){let e={kinds:new Map,primitives:new Map,shadowed:new Set},i=r;c(i,t=>{let n=new Set;if(t.type==="VariableDeclarator")s(t.id,n);else if(t.type==="FunctionDeclaration"||t.type==="ClassDeclaration")s(t.id,n);else if(t.type==="ImportDefaultSpecifier"||t.type==="ImportNamespaceSpecifier")s(t.local,n);else if(t.type==="ImportSpecifier")s(t.local,n);else if(t.type==="FunctionExpression"||t.type==="ArrowFunctionExpression"||t.type==="FunctionDeclaration")for(let a of t.params??[])s(a,n);for(let a of n)l[a]&&e.shadowed.add(a)});for(let t of i.body??[])if(t.type==="ImportDeclaration"&&d(t.source?.value))for(let n of t.specifiers??[]){if(n.type!=="ImportSpecifier")continue;let a=n.imported,m=a.type==="Identifier"?a.name:a.value,u=p[m];u&&e.primitives.set(n.local.name,u)}return c(i,t=>{if(t.type!=="VariableDeclarator"||!t.init)return;let n=S(t.init,e);n&&h(t.id,n,e.kinds)}),e}