@fluixi/compiler 1.0.0-alpha.69 → 1.0.0-alpha.70

package/dist/optimize/analyze-static.js

@@ -0,0 +1,131 @@
+/**
+ * A prop is inert only when it is a plain attribute or property with a literal value.
+ *
+ * `expr` means arbitrary JS, which may read a signal or allocate, so it is dynamic even
+ * when `reactive` is false — a non-reactive expression still has to run per instance.
+ */
+function propReason(prop) {
+    switch (prop.kind) {
+        case 'event':
+            return 'event';
+        case 'ref':
+            return 'ref';
+        case 'spread':
+            return 'spread';
+        case 'class':
+        case 'style':
+            // classList/style objects are built from expressions even when they look literal.
+            return 'class-or-style-directive';
+        case 'attr':
+        case 'prop':
+            if (prop.reactive)
+                return 'reactive-prop';
+            if (prop.expr !== undefined)
+                return 'expression-prop';
+            return undefined;
+        /* c8 ignore next 2 */
+        default:
+            return 'expression-prop';
+    }
+}
+/**
+ * Mark every static element in the tree, returning what was decided.
+ *
+ * Mutates `IRElement.static` in place, since that field is the contract codegen reads.
+ */
+export function analyzeStatic(root) {
+    const staticElements = [];
+    const reasons = new Map();
+    /** Returns whether `node` is static, marking elements bottom-up. */
+    const visit = (node) => {
+        switch (node.kind) {
+            case 'text':
+                return true;
+            case 'expr':
+                // A hole is dynamic even when it is not reactive: its value is computed.
+                return false;
+            case 'component':
+            case 'control':
+                // Both produce their own subtree at runtime, so an ancestor cannot be cloned
+                // wholesale. Still walk in, so nested elements are marked for their own sake.
+                for (const child of node.children)
+                    visit(child);
+                return false;
+            case 'fragment':
+                // A fragment is not an element and cannot itself be cloned, but its children
+                // can be considered independently.
+                for (const child of node.children)
+                    visit(child);
+                return false;
+            case 'element': {
+                // Children are visited first and unconditionally, so a static subtree nested
+                // under a dynamic parent is still marked and can be cloned on its own.
+                let childrenStatic = true;
+                for (const child of node.children) {
+                    if (!visit(child))
+                        childrenStatic = false;
+                }
+                let reason;
+                for (const prop of node.props) {
+                    reason = propReason(prop);
+                    if (reason)
+                        break;
+                }
+                if (!reason && !childrenStatic) {
+                    reason = childReason(node);
+                }
+                node.static = !reason;
+                if (reason)
+                    reasons.set(node, reason);
+                else
+                    staticElements.push(node);
+                return node.static;
+            }
+            /* c8 ignore next 2 */
+            default:
+                return false;
+        }
+    };
+    for (const node of Array.isArray(root) ? root : [root])
+        visit(node);
+    return { staticElements, reasons };
+}
+/** The most specific reason a child made its parent dynamic. */
+function childReason(node) {
+    for (const child of node.children) {
+        if (child.kind === 'expr')
+            return 'expression-child';
+        if (child.kind === 'component')
+            return 'component-child';
+        if (child.kind === 'control')
+            return 'control-child';
+        if (child.kind === 'element' && !child.static)
+            return 'expression-child';
+        if (child.kind === 'fragment')
+            return 'expression-child';
+    }
+    /* c8 ignore next */
+    return 'expression-child';
+}
+/**
+ * The outermost static elements — the roots worth turning into templates.
+ *
+ * Cloning a static child of a static parent is wasted: the parent's template already
+ * contains it.
+ */
+export function staticRoots(root) {
+    const roots = [];
+    const visit = (node) => {
+        if (node.kind === 'element' && node.static) {
+            roots.push(node);
+            return; // its subtree is inside this template
+        }
+        const children = node.children;
+        if (children)
+            for (const child of children)
+                visit(child);
+    };
+    for (const node of Array.isArray(root) ? root : [root])
+        visit(node);
+    return roots;
+}

package/dist/optimize/analyze-static.mjs

@@ -0,0 +1 @@
+function a(r){switch(r.kind){case"event":return"event";case"ref":return"ref";case"spread":return"spread";case"class":case"style":return"class-or-style-directive";case"attr":case"prop":return r.reactive?"reactive-prop":r.expr!==void 0?"expression-prop":void 0;default:return"expression-prop"}}function f(r){let t=[],c=new Map,n=e=>{switch(e.kind){case"text":return!0;case"expr":return!1;case"component":case"control":for(let s of e.children)n(s);return!1;case"fragment":for(let s of e.children)n(s);return!1;case"element":{let s=!0;for(let o of e.children)n(o)||(s=!1);let i;for(let o of e.props)if(i=a(o),i)break;return!i&&!s&&(i=l(e)),e.static=!i,i?c.set(e,i):t.push(e),e.static}default:return!1}};for(let e of Array.isArray(r)?r:[r])n(e);return{staticElements:t,reasons:c}}function l(r){for(let t of r.children){if(t.kind==="expr")return"expression-child";if(t.kind==="component")return"component-child";if(t.kind==="control")return"control-child";if(t.kind==="element"&&!t.static||t.kind==="fragment")return"expression-child"}return"expression-child"}function p(r){let t=[],c=n=>{if(n.kind==="element"&&n.static){t.push(n);return}let e=n.children;if(e)for(let s of e)c(s)};for(let n of Array.isArray(r)?r:[r])c(n);return t}export{f as analyzeStatic,p as staticRoots};

package/dist/optimize/collapse-strategies.cjs

@@ -0,0 +1 @@
+"use strict";var d=Object.defineProperty;var f=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var R=Object.prototype.hasOwnProperty;var x=(e,o)=>{for(var t in o)d(e,t,{get:o[t],enumerable:!0})},v=(e,o,t,i)=>{if(o&&typeof o=="object"||typeof o=="function")for(let n of g(o))!R.call(e,n)&&n!==t&&d(e,n,{get:()=>o[n],enumerable:!(i=f(o,n))||i.enumerable});return e};var S=e=>v(d({},"__esModule",{value:!0}),e);var E={};x(E,{collapseStrategies:()=>I});module.exports=S(E);function l(e){return e.kind!=="eager"&&e.kind!=="never"}var u=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],p=["Suspense","SuspenseList","Await"],m=["Router","Outlet","Redirect","Link"],O=[...u,...p,...m],C=new Set([...u,...p]);function c(e,o){let t=Array.isArray(e)?e:[e];for(let i of t){o(i);let n=i.children;n&&c(n,o)}}function I(e){let o=[];c(e,r=>{r.kind==="component"&&r.source&&o.push(r)});let t=new Set,i=new Set;for(let r of o){let{module:s,loading:a}=r.source;a.kind==="eager"&&t.add(s),a.kind==="never"&&i.add(s)}let n=new Map;for(let r of o){let s=r.source;l(s.loading)&&t.has(s.module)&&(s.loading={kind:"eager"},n.set(s.module,(n.get(s.module)??0)+1))}return{collapsed:n,conflicted:[...i].filter(r=>t.has(r))}}

package/dist/optimize/collapse-strategies.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Strategy collapsing — demote a deferred reference whose module is already present.
+ *
+ * This is not a nice-to-have. Without it the naive feature is a regression: if a module
+ * is referenced eagerly anywhere in the compilation unit, it is in the parent chunk
+ * already, so a `load:visible` boundary elsewhere adds a wrapper, a promise and a
+ * re-render in order to fetch nothing. The bytes are paid twice — once in the chunk,
+ * once in the deferral machinery — and the component renders later than it needs to.
+ *
+ * Collapsing runs per module, not per component name, because a chunk is a module:
+ * `<Button>` eager and `<ButtonGroup load:visible>` from the same package means the
+ * package is already loaded, so deferring the second buys nothing.
+ *
+ * `never` is not collapsed. It means "no client code at all", which is a statement about
+ * what should exist rather than about when to fetch it; an eager sibling does not make a
+ * server-only component suddenly belong in the client bundle. That combination is
+ * contradictory and reported instead.
+ */
+import type { IRNode } from '../ir/nodes.js';
+export interface CollapseReport {
+    /** Modules demoted to eager, with the reference count that was demoted. */
+    collapsed: Map<string, number>;
+    /**
+     * Modules referenced both as `load:never` and in a way that needs client code.
+     * Contradictory rather than optimisable, so it is reported and left alone.
+     */
+    conflicted: string[];
+}
+/** Demote deferred references to modules that are already in the chunk. */
+export declare function collapseStrategies(root: IRNode | IRNode[]): CollapseReport;
+//# sourceMappingURL=collapse-strategies.d.ts.map

package/dist/optimize/collapse-strategies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collapse-strategies.d.ts","sourceRoot":"","sources":["../../src/optimize/collapse-strategies.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAe,MAAM,gBAAgB,CAAC;AAI1D,MAAM,WAAW,cAAc;IAC7B,2EAA2E;IAC3E,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/B;;;OAGG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,2EAA2E;AAC3E,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,cAAc,CA2B1E"}

package/dist/optimize/collapse-strategies.js

@@ -0,0 +1,33 @@
+import { isDeferred } from '../resolve/load-directive.js';
+import { walk } from '../resolve/resolve-ir.js';
+/** Demote deferred references to modules that are already in the chunk. */
+export function collapseStrategies(root) {
+    const components = [];
+    walk(root, (node) => {
+        if (node.kind === 'component' && node.source)
+            components.push(node);
+    });
+    const eager = new Set();
+    const never = new Set();
+    for (const node of components) {
+        const { module, loading } = node.source;
+        if (loading.kind === 'eager')
+            eager.add(module);
+        if (loading.kind === 'never')
+            never.add(module);
+    }
+    const collapsed = new Map();
+    for (const node of components) {
+        const source = node.source;
+        if (!isDeferred(source.loading))
+            continue;
+        if (!eager.has(source.module))
+            continue;
+        source.loading = { kind: 'eager' };
+        collapsed.set(source.module, (collapsed.get(source.module) ?? 0) + 1);
+    }
+    return {
+        collapsed,
+        conflicted: [...never].filter((m) => eager.has(m)),
+    };
+}

package/dist/optimize/collapse-strategies.mjs

@@ -0,0 +1 @@
+function a(o){return o.kind!=="eager"&&o.kind!=="never"}var l=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],u=["Suspense","SuspenseList","Await"],p=["Router","Outlet","Redirect","Link"],g=[...l,...u,...p],m=new Set([...l,...u]);function d(o,t){let i=Array.isArray(o)?o:[o];for(let s of i){t(s);let r=s.children;r&&d(r,t)}}function w(o){let t=[];d(o,e=>{e.kind==="component"&&e.source&&t.push(e)});let i=new Set,s=new Set;for(let e of t){let{module:n,loading:c}=e.source;c.kind==="eager"&&i.add(n),c.kind==="never"&&s.add(n)}let r=new Map;for(let e of t){let n=e.source;a(n.loading)&&i.has(n.module)&&(n.loading={kind:"eager"},r.set(n.module,(r.get(n.module)??0)+1))}return{collapsed:r,conflicted:[...s].filter(e=>i.has(e))}}export{w as collapseStrategies};

package/dist/options.cjs

@@ -1 +1 @@
-"use strict";var r=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var m=Object.prototype.hasOwnProperty;var p=(o,e)=>{for(var a in e)r(o,a,{get:e[a],enumerable:!0})},d=(o,e,a,l)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of s(e))!m.call(o,t)&&t!==a&&r(o,t,{get:()=>e[t],enumerable:!(l=n(e,t))||l.enumerable});return o};var i=o=>d(r({},"__esModule",{value:!0}),o);var u={};p(u,{defaultOptions:()=>v});module.exports=i(u);var v={backend:"imperative",generate:"dom",moduleName:"@fluixi/dom",delegateEvents:!0,hydratable:!1,sourceMaps:!0,dev:!1};
+"use strict";var l=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var s=Object.getOwnPropertyNames;var p=Object.prototype.hasOwnProperty;var m=(o,e)=>{for(var t in e)l(o,t,{get:e[t],enumerable:!0})},d=(o,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let a of s(e))!p.call(o,a)&&a!==t&&l(o,a,{get:()=>e[a],enumerable:!(r=n(e,a))||r.enumerable});return o};var i=o=>d(l({},"__esModule",{value:!0}),o);var b={};m(b,{defaultOptions:()=>v});module.exports=i(b);var v={backend:"imperative",generate:"dom",moduleName:"@fluixi/dom",delegateEvents:!0,hydratable:!1,sourceMaps:!0,dev:!1};

package/dist/options.d.ts

@@ -4,6 +4,24 @@ import type { ComponentResolverRule } from './resolve/component-resolver.js';
  * as backends change. Switching DOM strategy is `backend`, not a rewrite.
  */
 export interface CompilerOptions {
+    /**
+     * Clone static subtrees from a `<template>` instead of building them element by
+     * element. Roughly 2x faster to instantiate, but **client-only**: `createTemplate`
+     * produces real DOM nodes, which the SSR renderer's ServerElement tree rejects, and a
+     * clone creates a fresh node where hydration must adopt the existing one. Opt in for
+     * a client-rendered app; leave off wherever SSR or hydration is involved.
+     */
+    templateClone?: boolean;
+    /**
+     * Also clone subtrees whose *structure* is static but which contain dynamic holes —
+     * the common shape. Roughly halves the emitted code for such a subtree and replaces
+     * per-element construction with one clone.
+     *
+     * Works under SSR and hydration: each hole is bracketed by `<!--fx-->` markers, so its
+     * content is exactly the nodes between them and the server's markup has the same shape
+     * as the client's template. Hydration adopts those nodes rather than rebuilding them.
+     */
+    partialTemplates?: boolean;
     /** which codegen backend to use */
     backend?: 'imperative' | 'template-clone';
     /** output target */

package/dist/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,mCAAmC;IACnC,OAAO,CAAC,EAAE,YAAY,GAAG,gBAAgB,CAAC;IAC1C,oBAAoB;IACpB,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;IACrC,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC5C;AAED,eAAO,MAAM,cAAc,EAAE,eAQ5B,CAAC"}
+{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAE7E;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;;;OAMG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;;;;;;;;OAQG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,mCAAmC;IACnC,OAAO,CAAC,EAAE,YAAY,GAAG,gBAAgB,CAAC;IAC1C,oBAAoB;IACpB,QAAQ,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,SAAS,CAAC;IACrC,uDAAuD;IACvD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;OAGG;IACH,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;CAC5C;AAED,eAAO,MAAM,cAAc,EAAE,eAQ5B,CAAC"}

package/dist/resolve/builtins.cjs

@@ -0,0 +1 @@
+"use strict";var l=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var m=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var M=(o,t)=>{for(var e in t)l(o,e,{get:t[e],enumerable:!0})},O=(o,t,e,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of m(t))!d.call(o,n)&&n!==e&&l(o,n,{get:()=>t[n],enumerable:!(s=a(t,n))||s.enumerable});return o};var f=o=>O(l({},"__esModule",{value:!0}),o);var E={};M(E,{BUILTIN_COMPONENTS:()=>x,CORE_CONTROL_FLOW:()=>u,DOM_CONTROL_FLOW:()=>i,RESERVED_COMPONENTS:()=>R,ROUTER_COMPONENTS:()=>c,builtinComponentMap:()=>p,builtinComponents:()=>C,routerComponents:()=>g});module.exports=f(E);var i=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],u=["Suspense","SuspenseList","Await"],c=["Router","Outlet","Redirect","Link"],x=[...i,...u,...c],R=new Set([...i,...u]);function p(o={}){let{controlFlowModule:t="@fluixi/dom",coreModule:e="@fluixi/core",routerModule:s="@fluixi/core/router-next"}=o,n={};for(let r of i)n[r]=t;for(let r of u)n[r]=e;for(let r of c)n[r]=s;return n}function C(o={}){return{components:p(o)}}function g(o){let t=o??"@fluixi/core/router-next";return{components:Object.fromEntries(c.map(e=>[e,t]))}}

package/dist/resolve/builtins.d.ts

@@ -0,0 +1,69 @@
+/**
+ * The components the compiler supplies without an import, as data.
+ *
+ * Two different things have always been bundled into one hardcoded `Set` per group:
+ * *which module a name comes from*, and *whether the name has special lowering*. Only
+ * the first is interesting outside the compiler, and every tool needs it — the TS
+ * plugin, to resolve `<Show>` for hover and go-to-definition; the language server, to
+ * complete and validate tags inside `` html`…` ``; a codemod, to materialise imports.
+ * Having no published source, `@fluixi/ts-plugin` duplicated the list and pinned it
+ * with a test that fails when the two drift.
+ *
+ * So the names live here, shaped as {@link ComponentMapRule} so they compose with
+ * user-configured `resolve` rules, and the compiler keeps its own sets for the parts
+ * that are genuinely about codegen.
+ *
+ * The split matters: control-flow names cannot become ordinary rules. `Show`, `For`,
+ * `Index` and `Match` read a reactive *value* prop inside their own tracking scope, so
+ * the compiler emits that prop as a getter — without it `each={items()}` snapshots once
+ * and never updates. They are also exempted from `createMemo` wrapping and may be
+ * replaced outright by `optimizeControlFlowComponent`. A rule only injects an import,
+ * so converting them would keep the import and silently drop the reactivity.
+ *
+ * Router components have no such behaviour — every reference to them in the plugin is
+ * import plumbing — so they are a plain rule.
+ */
+import type { ComponentMapRule } from './component-resolver.js';
+/** Where the built-in groups come from when the host does not override the module. */
+export interface BuiltinModules {
+    /** Control flow that lives in the DOM package. Default `@fluixi/dom`. */
+    controlFlowModule?: string;
+    /** Control flow that only exists in core. Default `@fluixi/core`. */
+    coreModule?: string;
+    /** Router components. Default `@fluixi/core/router-next`. */
+    routerModule?: string;
+}
+/** Control flow lowered against the DOM runtime. */
+export declare const DOM_CONTROL_FLOW: readonly ["Show", "For", "Index", "Switch", "Match", "Portal", "Dynamic", "ErrorBoundary"];
+/** Control flow that only `@fluixi/core` exports — importing it from dom resolves to nothing. */
+export declare const CORE_CONTROL_FLOW: readonly ["Suspense", "SuspenseList", "Await"];
+/**
+ * Router components.
+ *
+ * `Routes` is not a component (routing is `<Router routes={…}>`) and `lazy` is a call
+ * rather than a tag, so neither can be supplied this way.
+ */
+export declare const ROUTER_COMPONENTS: readonly ["Router", "Outlet", "Redirect", "Link"];
+/** Every name the compiler supplies without an import. */
+export declare const BUILTIN_COMPONENTS: readonly string[];
+/**
+ * Names whose meaning is fixed by the compiler and cannot be reassigned by a rule.
+ *
+ * A rule naming one of these is a silent no-op — the compiler matches the built-in
+ * first and the tag renders control flow instead of the intended component, with no
+ * error. Rule authors should check against this set and report rather than emit.
+ */
+export declare const RESERVED_COMPONENTS: ReadonlySet<string>;
+/** Name → module for every built-in, honouring host module overrides. */
+export declare function builtinComponentMap(modules?: BuiltinModules): Record<string, string>;
+/**
+ * The built-ins as a resolver rule, for tools that want one uniform lookup.
+ *
+ * Note this is the *naming* half only. Feeding it to the compiler would not make
+ * control flow work through resolution — the compiler still recognises those names
+ * itself, for the codegen reasons above.
+ */
+export declare function builtinComponents(modules?: BuiltinModules): ComponentMapRule;
+/** Just the router group as a rule — the one group that is purely an import. */
+export declare function routerComponents(routerModule?: string): ComponentMapRule;
+//# sourceMappingURL=builtins.d.ts.map

package/dist/resolve/builtins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtins.d.ts","sourceRoot":"","sources":["../../src/resolve/builtins.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAEhE,sFAAsF;AACtF,MAAM,WAAW,cAAc;IAC7B,yEAAyE;IACzE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,qEAAqE;IACrE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,6DAA6D;IAC7D,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,oDAAoD;AACpD,eAAO,MAAM,gBAAgB,4FASnB,CAAC;AAEX,iGAAiG;AACjG,eAAO,MAAM,iBAAiB,gDAAiD,CAAC;AAEhF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,mDAAoD,CAAC;AAEnF,0DAA0D;AAC1D,eAAO,MAAM,kBAAkB,EAAE,SAAS,MAAM,EAI/C,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAGlD,CAAC;AAEH,yEAAyE;AACzE,wBAAgB,mBAAmB,CAAC,OAAO,GAAE,cAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAYxF;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,OAAO,GAAE,cAAmB,GAAG,gBAAgB,CAEhF;AAED,gFAAgF;AAChF,wBAAgB,gBAAgB,CAAC,YAAY,CAAC,EAAE,MAAM,GAAG,gBAAgB,CAGxE"}

package/dist/resolve/builtins.js

@@ -0,0 +1,64 @@
+/** Control flow lowered against the DOM runtime. */
+export const DOM_CONTROL_FLOW = [
+    'Show',
+    'For',
+    'Index',
+    'Switch',
+    'Match',
+    'Portal',
+    'Dynamic',
+    'ErrorBoundary',
+];
+/** Control flow that only `@fluixi/core` exports — importing it from dom resolves to nothing. */
+export const CORE_CONTROL_FLOW = ['Suspense', 'SuspenseList', 'Await'];
+/**
+ * Router components.
+ *
+ * `Routes` is not a component (routing is `<Router routes={…}>`) and `lazy` is a call
+ * rather than a tag, so neither can be supplied this way.
+ */
+export const ROUTER_COMPONENTS = ['Router', 'Outlet', 'Redirect', 'Link'];
+/** Every name the compiler supplies without an import. */
+export const BUILTIN_COMPONENTS = [
+    ...DOM_CONTROL_FLOW,
+    ...CORE_CONTROL_FLOW,
+    ...ROUTER_COMPONENTS,
+];
+/**
+ * Names whose meaning is fixed by the compiler and cannot be reassigned by a rule.
+ *
+ * A rule naming one of these is a silent no-op — the compiler matches the built-in
+ * first and the tag renders control flow instead of the intended component, with no
+ * error. Rule authors should check against this set and report rather than emit.
+ */
+export const RESERVED_COMPONENTS = new Set([
+    ...DOM_CONTROL_FLOW,
+    ...CORE_CONTROL_FLOW,
+]);
+/** Name → module for every built-in, honouring host module overrides. */
+export function builtinComponentMap(modules = {}) {
+    const { controlFlowModule = '@fluixi/dom', coreModule = '@fluixi/core', routerModule = '@fluixi/core/router-next', } = modules;
+    const map = {};
+    for (const name of DOM_CONTROL_FLOW)
+        map[name] = controlFlowModule;
+    for (const name of CORE_CONTROL_FLOW)
+        map[name] = coreModule;
+    for (const name of ROUTER_COMPONENTS)
+        map[name] = routerModule;
+    return map;
+}
+/**
+ * The built-ins as a resolver rule, for tools that want one uniform lookup.
+ *
+ * Note this is the *naming* half only. Feeding it to the compiler would not make
+ * control flow work through resolution — the compiler still recognises those names
+ * itself, for the codegen reasons above.
+ */
+export function builtinComponents(modules = {}) {
+    return { components: builtinComponentMap(modules) };
+}
+/** Just the router group as a rule — the one group that is purely an import. */
+export function routerComponents(routerModule) {
+    const module = routerModule ?? '@fluixi/core/router-next';
+    return { components: Object.fromEntries(ROUTER_COMPONENTS.map((n) => [n, module])) };
+}

package/dist/resolve/builtins.mjs

@@ -0,0 +1 @@
+var s=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],i=["Suspense","SuspenseList","Await"],u=["Router","Outlet","Redirect","Link"],p=[...s,...i,...u],a=new Set([...s,...i]);function l(o={}){let{controlFlowModule:e="@fluixi/dom",coreModule:r="@fluixi/core",routerModule:c="@fluixi/core/router-next"}=o,n={};for(let t of s)n[t]=e;for(let t of i)n[t]=r;for(let t of u)n[t]=c;return n}function m(o={}){return{components:l(o)}}function d(o){let e=o??"@fluixi/core/router-next";return{components:Object.fromEntries(u.map(r=>[r,e]))}}export{p as BUILTIN_COMPONENTS,i as CORE_CONTROL_FLOW,s as DOM_CONTROL_FLOW,a as RESERVED_COMPONENTS,u as ROUTER_COMPONENTS,l as builtinComponentMap,m as builtinComponents,d as routerComponents};

package/dist/resolve/load-directive.cjs

@@ -0,0 +1 @@
+"use strict";var o=Object.defineProperty;var l=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var u=Object.prototype.hasOwnProperty;var k=(e,n)=>{for(var t in n)o(e,t,{get:n[t],enumerable:!0})},p=(e,n,t,a)=>{if(n&&typeof n=="object"||typeof n=="function")for(let r of g(n))!u.call(e,r)&&r!==t&&o(e,r,{get:()=>n[r],enumerable:!(a=l(n,r))||a.enumerable});return e};var w=e=>p(o({},"__esModule",{value:!0}),e);var y={};k(y,{DEFAULT_INTERACTION_EVENTS:()=>c,EAGER:()=>d,LoadDirectiveError:()=>i,isDeferred:()=>m,isLoadDirective:()=>v,parseLoadDirective:()=>f,strategyKey:()=>x});module.exports=w(y);var d={kind:"eager"},c=["pointerdown","focusin","keydown"],s=new Set(["eager","idle","visible","interaction","media","never"]),i=class extends Error{};function v(e){return e.startsWith("load:")}function f(e,n){let t=e.slice(5);if(!s.has(t))throw new i(`Unknown load strategy 'load:${t}'. Expected one of ${[...s].join(", ")}.`);switch(t){case"eager":return d;case"idle":return{kind:"idle"};case"never":return{kind:"never"};case"visible":return n?{kind:"visible",rootMargin:n}:{kind:"visible"};case"interaction":return{kind:"interaction",events:n?h(n):[...c]};case"media":if(!n)throw new i(`'load:media' needs a query, e.g. load:media="(min-width: 1024px)".`);return{kind:"media",query:n};default:throw new i(`Unhandled load strategy '${t}'.`)}}function h(e){let n=e.split(/[\s,]+/).map(t=>t.trim()).filter(Boolean);if(n.length===0)throw new i("'load:interaction' was given no event names.");return n}function m(e){return e.kind!=="eager"&&e.kind!=="never"}function x(e){switch(e.kind){case"visible":return`visible:${e.rootMargin??""}`;case"interaction":return`interaction:${[...e.events].sort().join(",")}`;case"media":return`media:${e.query}`;default:return e.kind}}

package/dist/resolve/load-directive.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The `load:` directive — when a component's code is fetched.
+ *
+ * Resolution decides *where* a component comes from; this decides *when*. They are
+ * separate because they vary independently: the location of `<RevenueChart>` is the
+ * same everywhere and belongs in config, while whether this particular usage should
+ * wait for the viewport is a property of the usage. Fusing them — `<Chart lazy="./Chart">`
+ * — was rejected for exactly that reason.
+ *
+ * `load:` joins the existing `use:`/`prop:`/`attr:`/`bool:` namespace, so it cannot
+ * collide with a real prop and the parser already has a directive taxonomy to hang it on.
+ *
+ * One parser for both frontends. `load:visible` is already a valid `JSXNamespacedName`,
+ * so JSX needs no parser change, and the html`` path produces a `LoadDirective` node —
+ * but both funnel through {@link parseLoadDirective}, so the two syntaxes cannot drift.
+ */
+/** When a component's module is fetched. */
+export type IRLoadStrategy = {
+    kind: 'eager';
+} | {
+    kind: 'idle';
+} | {
+    kind: 'visible';
+    rootMargin?: string;
+} | {
+    kind: 'interaction';
+    events: string[];
+} | {
+    kind: 'media';
+    query: string;
+} | {
+    kind: 'never';
+};
+/** Everything is eager unless a directive says otherwise. */
+export declare const EAGER: IRLoadStrategy;
+/** Events that trigger an `interaction` load when none are named. */
+export declare const DEFAULT_INTERACTION_EVENTS: readonly ["pointerdown", "focusin", "keydown"];
+export declare class LoadDirectiveError extends Error {
+}
+/** True for an attribute name in the `load:` namespace. */
+export declare function isLoadDirective(name: string): boolean;
+/**
+ * Parse `load:<strategy>` plus its optional value into a strategy.
+ *
+ * `value` is the attribute's literal text — `load:visible="200px"` — or null for a bare
+ * directive. A `${…}` hole is rejected: the strategy has to be known at compile time
+ * because it decides how the module is emitted, and a runtime value cannot.
+ */
+export declare function parseLoadDirective(name: string, value: string | null): IRLoadStrategy;
+/** True when the strategy means "not in the parent chunk". */
+export declare function isDeferred(strategy: IRLoadStrategy): boolean;
+/** A stable key for grouping references that share a strategy. */
+export declare function strategyKey(strategy: IRLoadStrategy): string;
+//# sourceMappingURL=load-directive.d.ts.map

package/dist/resolve/load-directive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-directive.d.ts","sourceRoot":"","sources":["../../src/resolve/load-directive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,4CAA4C;AAC5C,MAAM,MAAM,cAAc,GACtB;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,GACjB;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,GAChB;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GACxC;IAAE,IAAI,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GACzC;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAChC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAAC;AAEtB,6DAA6D;AAC7D,eAAO,MAAM,KAAK,EAAE,cAAkC,CAAC;AAEvD,qEAAqE;AACrE,eAAO,MAAM,0BAA0B,gDAAiD,CAAC;AAIzF,qBAAa,kBAAmB,SAAQ,KAAK;CAAG;AAEhD,2DAA2D;AAC3D,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,cAAc,CAqCrF;AAaD,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAE5D;AAED,kEAAkE;AAClE,wBAAgB,WAAW,CAAC,QAAQ,EAAE,cAAc,GAAG,MAAM,CAW5D"}

package/dist/resolve/load-directive.js

@@ -0,0 +1,93 @@
+/**
+ * The `load:` directive — when a component's code is fetched.
+ *
+ * Resolution decides *where* a component comes from; this decides *when*. They are
+ * separate because they vary independently: the location of `<RevenueChart>` is the
+ * same everywhere and belongs in config, while whether this particular usage should
+ * wait for the viewport is a property of the usage. Fusing them — `<Chart lazy="./Chart">`
+ * — was rejected for exactly that reason.
+ *
+ * `load:` joins the existing `use:`/`prop:`/`attr:`/`bool:` namespace, so it cannot
+ * collide with a real prop and the parser already has a directive taxonomy to hang it on.
+ *
+ * One parser for both frontends. `load:visible` is already a valid `JSXNamespacedName`,
+ * so JSX needs no parser change, and the html`` path produces a `LoadDirective` node —
+ * but both funnel through {@link parseLoadDirective}, so the two syntaxes cannot drift.
+ */
+/** Everything is eager unless a directive says otherwise. */
+export const EAGER = { kind: 'eager' };
+/** Events that trigger an `interaction` load when none are named. */
+export const DEFAULT_INTERACTION_EVENTS = ['pointerdown', 'focusin', 'keydown'];
+const STRATEGIES = new Set(['eager', 'idle', 'visible', 'interaction', 'media', 'never']);
+export class LoadDirectiveError extends Error {
+}
+/** True for an attribute name in the `load:` namespace. */
+export function isLoadDirective(name) {
+    return name.startsWith('load:');
+}
+/**
+ * Parse `load:<strategy>` plus its optional value into a strategy.
+ *
+ * `value` is the attribute's literal text — `load:visible="200px"` — or null for a bare
+ * directive. A `${…}` hole is rejected: the strategy has to be known at compile time
+ * because it decides how the module is emitted, and a runtime value cannot.
+ */
+export function parseLoadDirective(name, value) {
+    const strategy = name.slice('load:'.length);
+    if (!STRATEGIES.has(strategy)) {
+        throw new LoadDirectiveError(`Unknown load strategy 'load:${strategy}'. Expected one of ${[...STRATEGIES].join(', ')}.`);
+    }
+    switch (strategy) {
+        case 'eager':
+            return EAGER;
+        case 'idle':
+            return { kind: 'idle' };
+        case 'never':
+            return { kind: 'never' };
+        case 'visible':
+            // `load:visible="200px"` starts the fetch before the element reaches the
+            // viewport, which is usually what you want — arriving exactly on intersection
+            // means the user waits for the network.
+            return value ? { kind: 'visible', rootMargin: value } : { kind: 'visible' };
+        case 'interaction':
+            return {
+                kind: 'interaction',
+                events: value ? splitEvents(value) : [...DEFAULT_INTERACTION_EVENTS],
+            };
+        case 'media':
+            if (!value) {
+                throw new LoadDirectiveError(`'load:media' needs a query, e.g. load:media="(min-width: 1024px)".`);
+            }
+            return { kind: 'media', query: value };
+        default:
+            /* c8 ignore next */
+            throw new LoadDirectiveError(`Unhandled load strategy '${strategy}'.`);
+    }
+}
+function splitEvents(value) {
+    const events = value
+        .split(/[\s,]+/)
+        .map((e) => e.trim())
+        .filter(Boolean);
+    if (events.length === 0) {
+        throw new LoadDirectiveError(`'load:interaction' was given no event names.`);
+    }
+    return events;
+}
+/** True when the strategy means "not in the parent chunk". */
+export function isDeferred(strategy) {
+    return strategy.kind !== 'eager' && strategy.kind !== 'never';
+}
+/** A stable key for grouping references that share a strategy. */
+export function strategyKey(strategy) {
+    switch (strategy.kind) {
+        case 'visible':
+            return `visible:${strategy.rootMargin ?? ''}`;
+        case 'interaction':
+            return `interaction:${[...strategy.events].sort().join(',')}`;
+        case 'media':
+            return `media:${strategy.query}`;
+        default:
+            return strategy.kind;
+    }
+}

package/dist/resolve/load-directive.mjs

@@ -0,0 +1 @@
+var o={kind:"eager"},a=["pointerdown","focusin","keydown"],r=new Set(["eager","idle","visible","interaction","media","never"]),i=class extends Error{};function d(e){return e.startsWith("load:")}function c(e,n){let t=e.slice(5);if(!r.has(t))throw new i(`Unknown load strategy 'load:${t}'. Expected one of ${[...r].join(", ")}.`);switch(t){case"eager":return o;case"idle":return{kind:"idle"};case"never":return{kind:"never"};case"visible":return n?{kind:"visible",rootMargin:n}:{kind:"visible"};case"interaction":return{kind:"interaction",events:n?s(n):[...a]};case"media":if(!n)throw new i(`'load:media' needs a query, e.g. load:media="(min-width: 1024px)".`);return{kind:"media",query:n};default:throw new i(`Unhandled load strategy '${t}'.`)}}function s(e){let n=e.split(/[\s,]+/).map(t=>t.trim()).filter(Boolean);if(n.length===0)throw new i("'load:interaction' was given no event names.");return n}function l(e){return e.kind!=="eager"&&e.kind!=="never"}function g(e){switch(e.kind){case"visible":return`visible:${e.rootMargin??""}`;case"interaction":return`interaction:${[...e.events].sort().join(",")}`;case"media":return`media:${e.query}`;default:return e.kind}}export{a as DEFAULT_INTERACTION_EVENTS,o as EAGER,i as LoadDirectiveError,l as isDeferred,d as isLoadDirective,c as parseLoadDirective,g as strategyKey};

package/dist/resolve/resolve-ir.cjs

@@ -0,0 +1 @@
+"use strict";var c=Object.defineProperty;var M=Object.getOwnPropertyDescriptor;var y=Object.getOwnPropertyNames;var I=Object.prototype.hasOwnProperty;var w=(n,e)=>{for(var i in e)c(n,i,{get:e[i],enumerable:!0})},N=(n,e,i,s)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of y(e))!I.call(n,o)&&o!==i&&c(n,o,{get:()=>e[o],enumerable:!(s=M(e,o))||s.enumerable});return n};var k=n=>N(c({},"__esModule",{value:!0}),n);var h={};w(h,{resolveComponentSources:()=>b,walk:()=>f});module.exports=k(h);var l=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],p=["Suspense","SuspenseList","Await"],a=["Router","Outlet","Redirect","Link"],L=[...l,...p,...a],m=new Set([...l,...p]);function S(n={}){let{controlFlowModule:e="@fluixi/dom",coreModule:i="@fluixi/core",routerModule:s="@fluixi/core/router-next"}=n,o={};for(let d of l)o[d]=e;for(let d of p)o[d]=i;for(let d of a)o[d]=s;return o}var R={kind:"eager"};function b(n,e={}){let{resolver:i,isBound:s,modules:o,strategyFor:d}=e,g=S(o),x=new Map,v=new Set,E=t=>{let{name:r}=t;if(!r||r.includes(".")||s?.(r))return;let u=O(r);if(!u){v.add(r);return}let C=u.origin==="builtin"&&m.has(r)?R:d?.(t)??R;t.source={...u,loading:C},x.set(r,t.source)},O=t=>{if(m.has(t))return{module:g[t],export:t,origin:"builtin"};let r=i?.resolve(t);if(r)return{module:r.module,export:r.export,origin:"rule"};if(a.includes(t))return{module:g[t],export:t,origin:"builtin"}};return f(n,t=>{t.kind==="component"&&E(t)}),{resolved:x,unresolved:[...v]}}function f(n,e){let i=Array.isArray(n)?n:[n];for(let s of i){e(s);let o=s.children;o&&f(o,e)}}

package/dist/resolve/resolve-ir.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The resolve pass: annotate component references in the IR with where they come from.
+ *
+ * Runs between the frontends and the optimizer, so every later pass reads provenance off
+ * the node instead of re-deriving it. Nothing here emits code — the pass only records a
+ * decision, which is what lets the same answer drive import injection, chunk grouping,
+ * hint planning and diagnostics without any of them agreeing by coincidence.
+ *
+ * Two suppliers, in precedence order:
+ *
+ *  1. **Control flow** (`Show`, `For`, `Switch`, …) — the name selects a lowering, so a
+ *     rule cannot re-point it. Recorded as `builtin` so a later pass can tell the
+ *     difference between "configured here" and "fixed by the compiler".
+ *  2. **Configured rules**, then the **router built-ins**. Router components are only an
+ *     import, so a project's own `Link` wins; see `builtins.ts`.
+ *
+ * A name bound in the file is not resolved at all: the author's import always wins, and
+ * the caller supplies those bindings via `isBound`.
+ */
+import type { IRNode, IRComponent, IRComponentSource } from '../ir/nodes.js';
+import type { ComponentResolver } from './component-resolver.js';
+import { builtinComponentMap } from './builtins.js';
+import { type IRLoadStrategy } from './load-directive.js';
+export interface ResolveOptions {
+    /** Rules configured for the project. Omit when the project configures none. */
+    resolver?: ComponentResolver;
+    /** True when the name already has a binding in the file — an import the author wrote. */
+    isBound?: (name: string) => boolean;
+    /** Module overrides, so `routerModule` and friends are honoured. */
+    modules?: Parameters<typeof builtinComponentMap>[0];
+    /**
+     * The `load:` strategy for a reference, when the frontend found one on the tag.
+     * Keyed by node so two usages of the same component can load differently — the
+     * whole reason timing lives at the usage site and location does not.
+     */
+    strategyFor?: (node: IRComponent) => IRLoadStrategy | undefined;
+}
+export interface ResolveReport {
+    /** Every reference the pass annotated, by name. */
+    resolved: Map<string, IRComponentSource>;
+    /**
+     * Capitalised tags nothing supplies and nothing binds.
+     *
+     * These compile to a reference to an identifier that does not exist — the build
+     * succeeds and the page throws at runtime — so they are the pass's most useful
+     * output for diagnostics.
+     */
+    unresolved: string[];
+}
+/** Annotate every component reference in `root`, returning what was decided. */
+export declare function resolveComponentSources(root: IRNode | IRNode[], options?: ResolveOptions): ResolveReport;
+/** Depth-first walk over every node that can contain children. */
+export declare function walk(root: IRNode | IRNode[], visit: (node: IRNode) => void): void;
+//# sourceMappingURL=resolve-ir.d.ts.map

package/dist/resolve/resolve-ir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-ir.d.ts","sourceRoot":"","sources":["../../src/resolve/resolve-ir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AAC7E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AACjE,OAAO,EAA0C,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAC5F,OAAO,EAAS,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAEjE,MAAM,WAAW,cAAc;IAC7B,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,iBAAiB,CAAC;IAC7B,yFAAyF;IACzF,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC;IACpC,oEAAoE;IACpE,OAAO,CAAC,EAAE,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;IACpD;;;;OAIG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,WAAW,KAAK,cAAc,GAAG,SAAS,CAAC;CACjE;AAED,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAC;IACzC;;;;;;OAMG;IACH,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB;AAED,gFAAgF;AAChF,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EACvB,OAAO,GAAE,cAAmB,GAC3B,aAAa,CA8Cf;AAED,kEAAkE;AAClE,wBAAgB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAOjF"}