@fluixi/compiler 1.0.0-alpha.68 → 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 l=Object.defineProperty;var n=Object.getOwnPropertyDescriptor;var d=Object.getOwnPropertyNames;var s=Object.prototype.hasOwnProperty;var i=(a,e)=>{for(var t in e)l(a,t,{get:e[t],enumerable:!0})},m=(a,e,t,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of d(e))!s.call(a,o)&&o!==t&&l(a,o,{get:()=>e[o],enumerable:!(r=n(e,o))||r.enumerable});return a};var p=a=>m(l({},"__esModule",{value:!0}),a);var u={};i(u,{defaultOptions:()=>b});module.exports=p(u);var b={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

@@ -1,8 +1,27 @@
+import type { ComponentResolverRule } from './resolve/component-resolver.js';
 /**
  * Public compiler options. This schema is the stable public API — it stays put
  * 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 */
@@ -13,6 +32,11 @@ export interface CompilerOptions {
     hydratable?: boolean;
     sourceMaps?: boolean;
     dev?: boolean;
+    /**
+     * Rules that resolve an unbound capitalised tag to a module, so a component can be
+     * used in a template without an import. See `createComponentResolver`.
+     */
+    resolve?: readonly ComponentResolverRule[];
 }
 export declare const defaultOptions: CompilerOptions;
 //# sourceMappingURL=options.d.ts.map

package/dist/options.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"options.d.ts","sourceRoot":"","sources":["../src/options.ts"],"names":[],"mappings":"AAAA;;;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;CACf;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/component-resolver.cjs

@@ -0,0 +1 @@
+"use strict";var u=Object.defineProperty;var d=Object.getOwnPropertyDescriptor;var g=Object.getOwnPropertyNames;var R=Object.prototype.hasOwnProperty;var C=(o,e)=>{for(var n in e)u(o,n,{get:e[n],enumerable:!0})},v=(o,e,n,i)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of g(e))!R.call(o,t)&&t!==n&&u(o,t,{get:()=>e[t],enumerable:!(i=d(e,t))||i.enumerable});return o};var x=o=>v(u({},"__esModule",{value:!0}),o);var y={};C(y,{createComponentResolver:()=>b});module.exports=x(y);var h=o=>"components"in o;function a(o,e){return o.replace(/\$(\d+)/g,(n,i)=>e[Number(i)]??n)}function M(o,e){return typeof e=="string"?{module:e,export:o}:e}function b(o=[]){let e=new Map,n=[],i=[];for(let r of o){if(!h(r)){i.push(r);continue}for(let[s,p]of Object.entries(r.components)){let l=M(s,p),c=e.get(s);if(c&&c.module!==l.module){let m=n.find(f=>f.name===s);m?m.modules.push(l.module):n.push({name:s,modules:[c.module,l.module]});continue}e.set(s,l)}}let t=new Map;return{resolve:r=>{if(t.has(r))return t.get(r);let s=e.get(r);if(!s)for(let p of i){let l=r.match(new RegExp(p.match.source,p.match.flags.replace("g","")));if(l){s={module:a(p.module,l),export:p.export?a(p.export,l):r};break}}return t.set(r,s),s},names:()=>[...e.keys()],conflicts:()=>n}}

package/dist/resolve/component-resolver.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Compile-time component resolution.
+ *
+ * An unbound capitalised tag in a template is a name the compiler can resolve to a
+ * module, instead of an import the author has to write. The framework already does
+ * this for `Suspense`/`Portal`/`Router`, but through a hardcoded name set inside the
+ * Babel plugin — which cannot be extended by a UI library or an app, and cannot be
+ * configured per project.
+ *
+ * This is the configurable version of the same idea. It is deliberately a pure
+ * `name -> { module, export }` function with no filesystem access and no Babel
+ * dependency, because three separate consumers need exactly the same answer:
+ *
+ *   - the compiler, to inject the import;
+ *   - the TS plugin, to synthesise the import so hover/go-to-definition/rename work;
+ *   - a codemod, to materialise imports back into source.
+ *
+ * Keeping resolution pure is what lets those three agree. Anything requiring the
+ * filesystem (directory conventions) belongs in a rule *builder* that produces a map,
+ * not in the resolver itself.
+ */
+/** Where a resolved component comes from. */
+export interface ResolvedComponent {
+    module: string;
+    /** The export name, or `default`. */
+    export: string;
+}
+/**
+ * An explicit name -> module map. This is what a component library ships
+ * (`Button -> @fluixi-ui/button`), generated from its own package list rather than
+ * hand-maintained.
+ */
+export interface ComponentMapRule {
+    components: Record<string, string | ResolvedComponent>;
+}
+/**
+ * A pattern rule. `$1`-style references in `module`/`export` are substituted from the
+ * match groups, so one rule can cover a family (`Icon(.+) -> @/icons/$1`).
+ */
+export interface ComponentPatternRule {
+    match: RegExp;
+    module: string;
+    /** Defaults to the tag name; use `'default'` for file-per-component layouts. */
+    export?: string;
+}
+export type ComponentResolverRule = ComponentMapRule | ComponentPatternRule;
+/** Two rules claiming the same name — reported rather than silently first-wins. */
+export interface ResolverConflict {
+    name: string;
+    modules: string[];
+}
+export interface ComponentResolver {
+    /** `undefined` when no rule claims the name. */
+    resolve: (name: string) => ResolvedComponent | undefined;
+    /** Every name the resolver can answer, for editor completion. */
+    names: () => string[];
+    /** Names claimed by more than one rule with different targets. */
+    conflicts: () => ResolverConflict[];
+}
+/**
+ * Build a resolver from rules, in order.
+ *
+ * Map rules are flattened up front so lookup is a plain object read — resolution runs
+ * once per component reference per compile, so it sits on the hot path of every build.
+ * Pattern rules are tried afterwards, in declaration order, and only when no map rule
+ * matched: an explicit entry should always beat a pattern.
+ */
+export declare function createComponentResolver(rules?: readonly ComponentResolverRule[]): ComponentResolver;
+//# sourceMappingURL=component-resolver.d.ts.map

package/dist/resolve/component-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"component-resolver.d.ts","sourceRoot":"","sources":["../../src/resolve/component-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,6CAA6C;AAC7C,MAAM,WAAW,iBAAiB;IAChC,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CAAC,CAAC;CACxD;AAED;;;GAGG;AACH,MAAM,WAAW,oBAAoB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,qBAAqB,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;AAE5E,mFAAmF;AACnF,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB;AAED,MAAM,WAAW,iBAAiB;IAChC,gDAAgD;IAChD,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,iBAAiB,GAAG,SAAS,CAAC;IACzD,iEAAiE;IACjE,KAAK,EAAE,MAAM,MAAM,EAAE,CAAC;IACtB,kEAAkE;IAClE,SAAS,EAAE,MAAM,gBAAgB,EAAE,CAAC;CACrC;AAiBD;;;;;;;GAOG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,GAAE,SAAS,qBAAqB,EAAO,GAC3C,iBAAiB,CAwDnB"}

package/dist/resolve/component-resolver.js

@@ -0,0 +1,95 @@
+/**
+ * Compile-time component resolution.
+ *
+ * An unbound capitalised tag in a template is a name the compiler can resolve to a
+ * module, instead of an import the author has to write. The framework already does
+ * this for `Suspense`/`Portal`/`Router`, but through a hardcoded name set inside the
+ * Babel plugin — which cannot be extended by a UI library or an app, and cannot be
+ * configured per project.
+ *
+ * This is the configurable version of the same idea. It is deliberately a pure
+ * `name -> { module, export }` function with no filesystem access and no Babel
+ * dependency, because three separate consumers need exactly the same answer:
+ *
+ *   - the compiler, to inject the import;
+ *   - the TS plugin, to synthesise the import so hover/go-to-definition/rename work;
+ *   - a codemod, to materialise imports back into source.
+ *
+ * Keeping resolution pure is what lets those three agree. Anything requiring the
+ * filesystem (directory conventions) belongs in a rule *builder* that produces a map,
+ * not in the resolver itself.
+ */
+const isMapRule = (rule) => 'components' in rule;
+/** Expand `$1`/`$2` against a regex match. */
+function substitute(template, match) {
+    return template.replace(/\$(\d+)/g, (whole, index) => {
+        const group = match[Number(index)];
+        return group ?? whole;
+    });
+}
+function normalise(name, entry) {
+    return typeof entry === 'string' ? { module: entry, export: name } : entry;
+}
+/**
+ * Build a resolver from rules, in order.
+ *
+ * Map rules are flattened up front so lookup is a plain object read — resolution runs
+ * once per component reference per compile, so it sits on the hot path of every build.
+ * Pattern rules are tried afterwards, in declaration order, and only when no map rule
+ * matched: an explicit entry should always beat a pattern.
+ */
+export function createComponentResolver(rules = []) {
+    const exact = new Map();
+    const conflicts = [];
+    const patterns = [];
+    for (const rule of rules) {
+        if (!isMapRule(rule)) {
+            patterns.push(rule);
+            continue;
+        }
+        for (const [name, entry] of Object.entries(rule.components)) {
+            const resolved = normalise(name, entry);
+            const existing = exact.get(name);
+            if (existing && existing.module !== resolved.module) {
+                // Ambiguity is the failure mode that actually happens once a map holds
+                // ~80 common words (Card, Table, Text, Link). Silently taking the first
+                // rule would compile a working import of the wrong component, which is
+                // far worse to debug than a build error — so it is recorded and reported.
+                const conflict = conflicts.find((c) => c.name === name);
+                if (conflict)
+                    conflict.modules.push(resolved.module);
+                else
+                    conflicts.push({ name, modules: [existing.module, resolved.module] });
+                continue;
+            }
+            exact.set(name, resolved);
+        }
+    }
+    const cache = new Map();
+    const resolve = (name) => {
+        if (cache.has(name))
+            return cache.get(name);
+        let result = exact.get(name);
+        if (!result) {
+            for (const rule of patterns) {
+                // A fresh regex per test: a caller's `/g` pattern carries lastIndex between
+                // calls, which would make resolution depend on how many names came before it.
+                const match = name.match(new RegExp(rule.match.source, rule.match.flags.replace('g', '')));
+                if (!match)
+                    continue;
+                result = {
+                    module: substitute(rule.module, match),
+                    export: rule.export ? substitute(rule.export, match) : name,
+                };
+                break;
+            }
+        }
+        cache.set(name, result);
+        return result;
+    };
+    return {
+        resolve,
+        names: () => [...exact.keys()],
+        conflicts: () => conflicts,
+    };
+}

package/dist/resolve/component-resolver.mjs

@@ -0,0 +1 @@
+var f=r=>"components"in r;function m(r,e){return r.replace(/\$(\d+)/g,(l,i)=>e[Number(i)]??l)}function d(r,e){return typeof e=="string"?{module:e,export:r}:e}function R(r=[]){let e=new Map,l=[],i=[];for(let o of r){if(!f(o)){i.push(o);continue}for(let[n,s]of Object.entries(o.components)){let t=d(n,s),c=e.get(n);if(c&&c.module!==t.module){let u=l.find(a=>a.name===n);u?u.modules.push(t.module):l.push({name:n,modules:[c.module,t.module]});continue}e.set(n,t)}}let p=new Map;return{resolve:o=>{if(p.has(o))return p.get(o);let n=e.get(o);if(!n)for(let s of i){let t=o.match(new RegExp(s.match.source,s.match.flags.replace("g","")));if(t){n={module:m(s.module,t),export:s.export?m(s.export,t):o};break}}return p.set(o,n),n},names:()=>[...e.keys()],conflicts:()=>l}}export{R as createComponentResolver};

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}}