@fluixi/compiler 1.0.0-alpha.83 → 1.0.0-alpha.85

package/dist/resolve/component-globals.d.cts

@@ -0,0 +1,80 @@
+/**
+ * Ambient declarations for the components `resolve` supplies without an import.
+ *
+ * The compiler injects the import, so nothing in the source imports these, which leaves
+ * TypeScript reporting `TS2304: Cannot find name`. The code compiles and runs; the editor
+ * is unusable and `tsc` fails. These declarations describe what the compiler already
+ * does. They do not enable it.
+ *
+ * This lives next to the resolver, and takes rules rather than a flat map, because the
+ * resolver is the only thing that knows the whole picture: a UI library's components, the
+ * project's own, and the framework builtins all arrive through the same config. A
+ * component library cannot generate this on its own, it does not know what else the
+ * project resolves: which is why the generator belongs here and the library-specific CLI
+ * that predates it does not.
+ *
+ * Pure, like the resolver: rules in, source out, no filesystem. Writing the file is the
+ * caller's job (the Vite plugin does it on config resolve; a CLI can do it in CI).
+ */
+import { type ComponentResolverRule } from './component-resolver.cjs';
+export interface ComponentGlobalsOptions {
+    /**
+     * Packages the project can actually resolve: normally its declared dependencies.
+     *
+     * Declaring a component from a package the project does not depend on produces an
+     * unresolvable `import(...)`, and under the usual `skipLibCheck: true` that failure is
+     * silent: the component degrades to `any` and every prop typo type-checks, which is
+     * worse than the error it replaced. Omit to declare everything, which is only correct
+     * when every package is present.
+     *
+     * Relative and alias specifiers are never filtered, there is no package to check.
+     */
+    available?: Iterable<string>;
+    /**
+     * Declare the framework builtins (`Show`, `For`, `Portal`, `Router`, …) too.
+     *
+     * On by default because the compiler resolves them whether or not a rule mentions
+     * them, so declaring them is what matches reality. A real import shadows the ambient
+     * declaration, so this stays safe for code that imports them explicitly.
+     */
+    builtins?: boolean;
+    /**
+     * Declare the `$` reactive intrinsics (`$signal`, `$memo`, …).
+     *
+     * On by default, matching the compiler: it rewrites those calls whether or not
+     * anything declares them, and without the declaration the editor reports
+     * "Cannot find name '$signal'" for code that builds correctly.
+     */
+    intrinsics?: boolean;
+    /** Attribution written into the header. */
+    generator?: string;
+    /**
+     * Rewrite a module specifier for the file being generated.
+     *
+     * A bundler and TypeScript do not agree on every specifier: Vite resolves a
+     * root-absolute `/src/x.tsx` that TypeScript cannot see at all. The caller knows where
+     * the file will land and so is the only one able to fix that up; the generator stays
+     * pure and just asks.
+     */
+    specifier?: (module: string) => string;
+}
+export interface ComponentGlobalsResult {
+    /** The `.d.ts` source to write. */
+    source: string;
+    /** Components declared. */
+    declared: string[];
+    /** Left out because `lib.dom` already claims the name. */
+    shadowedByDom: string[];
+    /** Left out because the project does not depend on their package. */
+    unavailable: string[];
+    /**
+     * Pattern rules, which have no finite name list and so cannot be declared.
+     *
+     * `Icon(.+) -> @/icons/$1` matches unboundedly many names; the resolver answers them on
+     * demand but cannot enumerate them. Those tags stay manual, and the caller is told how
+     * many rules are in that position rather than left to wonder why nothing appeared.
+     */
+    patternRules: number;
+}
+/** Build the ambient `.d.ts` for the components a project's `resolve` config supplies. */
+export declare function componentGlobals(rules: readonly ComponentResolverRule[], options?: ComponentGlobalsOptions): ComponentGlobalsResult;

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

@@ -1,7 +1,7 @@
 /**
  * Ambient declarations for the components `resolve` supplies without an import.
  *
- * The compiler injects the import, so nothing in the source imports these — which leaves
+ * The compiler injects the import, so nothing in the source imports these, which leaves
  * TypeScript reporting `TS2304: Cannot find name`. The code compiles and runs; the editor
  * is unusable and `tsc` fails. These declarations describe what the compiler already
  * does. They do not enable it.
@@ -9,8 +9,8 @@
  * This lives next to the resolver, and takes rules rather than a flat map, because the
  * resolver is the only thing that knows the whole picture: a UI library's components, the
  * project's own, and the framework builtins all arrive through the same config. A
- * component library cannot generate this on its own — it does not know what else the
- * project resolves — which is why the generator belongs here and the library-specific CLI
+ * component library cannot generate this on its own, it does not know what else the
+ * project resolves: which is why the generator belongs here and the library-specific CLI
  * that predates it does not.
  *
  * Pure, like the resolver: rules in, source out, no filesystem. Writing the file is the
@@ -19,7 +19,7 @@
 import { type ComponentResolverRule } from './component-resolver.js';
 export interface ComponentGlobalsOptions {
     /**
-     * Packages the project can actually resolve — normally its declared dependencies.
+     * Packages the project can actually resolve: normally its declared dependencies.
      *
      * Declaring a component from a package the project does not depend on produces an
      * unresolvable `import(...)`, and under the usual `skipLibCheck: true` that failure is
@@ -27,7 +27,7 @@ export interface ComponentGlobalsOptions {
      * worse than the error it replaced. Omit to declare everything, which is only correct
      * when every package is present.
      *
-     * Relative and alias specifiers are never filtered — there is no package to check.
+     * Relative and alias specifiers are never filtered, there is no package to check.
      */
     available?: Iterable<string>;
     /**

package/dist/resolve/component-globals.js

@@ -1,7 +1,7 @@
 /**
  * Ambient declarations for the components `resolve` supplies without an import.
  *
- * The compiler injects the import, so nothing in the source imports these — which leaves
+ * The compiler injects the import, so nothing in the source imports these, which leaves
  * TypeScript reporting `TS2304: Cannot find name`. The code compiles and runs; the editor
  * is unusable and `tsc` fails. These declarations describe what the compiler already
  * does. They do not enable it.
@@ -9,8 +9,8 @@
  * This lives next to the resolver, and takes rules rather than a flat map, because the
  * resolver is the only thing that knows the whole picture: a UI library's components, the
  * project's own, and the framework builtins all arrive through the same config. A
- * component library cannot generate this on its own — it does not know what else the
- * project resolves — which is why the generator belongs here and the library-specific CLI
+ * component library cannot generate this on its own, it does not know what else the
+ * project resolves: which is why the generator belongs here and the library-specific CLI
  * that predates it does not.
  *
  * Pure, like the resolver: rules in, source out, no filesystem. Writing the file is the
@@ -23,7 +23,7 @@ import { INTRINSICS } from '../analyze/intrinsics.js';
  * Names `lib.dom` already declares as globals.
  *
  * An ambient `const Text` cannot beat `lib.dom`'s `var Text`, so for these the editor
- * would disagree with the compiler — resolution still works at runtime, but the type
+ * would disagree with the compiler: resolution still works at runtime, but the type
  * shown would be the DOM node's. They are left out and reported instead, since importing
  * them explicitly makes both agree.
  */
@@ -68,7 +68,7 @@ export function componentGlobals(rules, options = {}) {
     const { available: availableList, builtins = true, intrinsics = true, generator = '@fluixi/compiler', specifier = (module) => module, } = options;
     const all = [...rules];
     if (builtins) {
-        // Appended, so an explicit rule for the same name still wins — the resolver is
+        // Appended, so an explicit rule for the same name still wins, the resolver is
         // first-match, and a project retargeting `Router` should keep its own answer.
         all.push({ components: builtinComponentMap() });
     }
@@ -107,8 +107,8 @@ export function componentGlobals(rules, options = {}) {
     // (`Button(props: ButtonProps): ComponentChild`) and go-to-definition lands on the
     // source. Both forms keep the JSDoc; the alias also keeps the shape.
     //
-    // A default export cannot use it — `import X = ns.default` is a syntax error, since
-    // `default` is a reserved word in that position — so those fall back to the `const`
+    // A default export cannot use it: `import X = ns.default` is a syntax error, since
+    // `default` is a reserved word in that position, so those fall back to the `const`
     // form, which types and documents correctly but renders as an anonymous arrow.
     const lines = declared.map((name) => {
         const target = resolved.get(name);
@@ -118,7 +118,7 @@ export function componentGlobals(rules, options = {}) {
             : `  export import ${name} = ${ns}.${target.export};`;
     });
     const note = shadowedByDom.length > 0
-        ? `//\n// Import these explicitly — lib.dom already declares the name, so an ambient\n` +
+        ? `//\n// Import these explicitly: lib.dom already declares the name, so an ambient\n` +
             `// declaration cannot win:\n` +
             shadowedByDom
                 .map((n) => {
@@ -129,7 +129,7 @@ export function componentGlobals(rules, options = {}) {
         : '';
     // `typeof ns.signal` rather than an alias: the intrinsic is a global that stands for
     // the runtime call, so it takes the runtime's signature without claiming to be that
-    // symbol — go-to-definition on `$signal` should land on what it compiles to.
+    // symbol: go-to-definition on `$signal` should land on what it compiles to.
     const intrinsicLines = intrinsics
         ? Object.entries(INTRINSICS).map(([name, intrinsic]) => `  const ${name}: typeof ${namespaceAlias(intrinsic.module)}.${intrinsic.export};`)
         : [];
@@ -139,7 +139,7 @@ export function componentGlobals(rules, options = {}) {
             `// a pattern matches unboundedly many names, so there is no list to emit. Those\n` +
             `// tags still resolve at build time; declare them by hand if the editor needs them.\n`
         : '';
-    const source = `// GENERATED by ${generator} — do not edit.\n` +
+    const source = `// GENERATED by ${generator}, do not edit.\n` +
         `//\n` +
         `// The components \`resolve\` supplies without an import. This describes what the\n` +
         `// compiler already does; it does not enable it.\n` +

package/dist/resolve/component-globals.mjs

@@ -1,22 +1,219 @@
-var j=t=>"components"in t;function O(t,o){return t.replace(/\$(\d+)/g,(a,u)=>o[Number(u)]??a)}function _(t,o){return typeof o=="string"?{module:o,export:t}:o}function S(t=[]){let o=new Map,a=[],u=[];for(let n of t){if(!j(n)){u.push(n);continue}for(let[r,l]of Object.entries(n.components)){let c=_(r,l),m=o.get(r);if(m&&m.module!==c.module){let d=a.find(R=>R.name===r);d?d.modules.push(c.module):a.push({name:r,modules:[m.module,c.module]});continue}o.set(r,c)}}let i=new Map;return{resolve:n=>{if(i.has(n))return i.get(n);let r=o.get(n);if(!r)for(let l of u){let c=n.match(new RegExp(l.match.source,l.match.flags.replace("g","")));if(c){r={module:O(l.module,c),export:l.export?O(l.export,c):n};break}}return i.set(n,r),r},names:()=>[...o.keys()],conflicts:()=>a}}var C=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],b=["Suspense","SuspenseList","Await"],$=["Router","Outlet","Redirect","Link"],G=[...C,...b,...$],W=new Set([...C,...b]);function E(t={}){let{controlFlowModule:o="@fluixi/dom",coreModule:a="@fluixi/core",routerModule:u="@fluixi/core/router"}=t,i={};for(let p of C)i[p]=o;for(let p of b)i[p]=a;for(let p of $)i[p]=u;return i}var f="@fluixi/reactive/signal",h={$signal:{export:"signal",module:f,returns:"signal-handle"},$memo:{export:"memo",module:f,returns:"memo-handle"},$effect:{export:"effect",module:f,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:f,returns:"resource-handle"},$selector:{export:"createSelector",module:f,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:f,returns:"memo-accessor"},$untrack:{export:"untrack",module:f,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}};var U=new RegExp(`\\$(?:${Object.keys(h).map(t=>t.slice(1)).join("|")})\\s*\\(`);var D=new Set(["Text","Image","Option","Audio","Comment","Range","Selection","Notification","Event","Document","Element","Node","Screen","Window","Location","History","Storage","Response","Request","Headers"]);function P(t){if(t.startsWith(".")||t.startsWith("/")||/^[~@]\//.test(t))return;let o=t.split("/");return t.startsWith("@")?o.slice(0,2).join("/"):o[0]}function M(t){return`_${t.replace(/[^A-Za-z0-9]/g,"_")}`}function z(t,o={}){let{available:a,builtins:u=!0,intrinsics:i=!0,generator:p="@fluixi/compiler",specifier:n=e=>e}=o,r=[...t];u&&r.push({components:E()});let l=S(r),c=a?new Set(a):void 0,m=[],d=[],R=[],v=new Map;for(let e of[...l.names()].sort()){let s=l.resolve(e);if(!s)continue;let g=P(s.module);D.has(e)?d.push(e):c&&g&&!c.has(g)?R.push(e):(m.push(e),v.set(e,s))}let I=i?[...new Set(Object.values(h).map(e=>e.module))]:[],y=[...new Set([...m.map(e=>v.get(e).module),...I])].sort().map(e=>`import * as ${M(e)} from '${n(e)}';`),w=m.map(e=>{let s=v.get(e),g=M(s.module);return s.export==="default"?`  const ${e}: typeof ${g}.default;`:`  export import ${e} = ${g}.${s.export};`}),N=d.length>0?`//
-// Import these explicitly — lib.dom already declares the name, so an ambient
+// src/resolve/component-resolver.ts
+var isMapRule = (rule) => "components" in rule;
+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;
+}
+function createComponentResolver(rules = []) {
+  const exact = /* @__PURE__ */ 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) {
+        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 = /* @__PURE__ */ 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) {
+        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
+  };
+}
+
+// src/resolve/builtins.ts
+var DOM_CONTROL_FLOW = [
+  "Show",
+  "For",
+  "Index",
+  "Switch",
+  "Match",
+  "Portal",
+  "Dynamic",
+  "ErrorBoundary"
+];
+var CORE_CONTROL_FLOW = ["Suspense", "SuspenseList", "Await"];
+var ROUTER_COMPONENTS = ["Router", "Outlet", "Redirect", "Link"];
+var BUILTIN_COMPONENTS = [
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW,
+  ...ROUTER_COMPONENTS
+];
+var RESERVED_COMPONENTS = /* @__PURE__ */ new Set([
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW
+]);
+function builtinComponentMap(modules = {}) {
+  const {
+    controlFlowModule = "@fluixi/dom",
+    coreModule = "@fluixi/core",
+    routerModule = "@fluixi/core/router"
+  } = 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;
+}
+
+// src/analyze/intrinsics.ts
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
+  $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
+  // 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" }
+};
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+
+// src/resolve/component-globals.ts
+var DOM_GLOBALS = /* @__PURE__ */ new Set([
+  "Text",
+  "Image",
+  "Option",
+  "Audio",
+  "Comment",
+  "Range",
+  "Selection",
+  "Notification",
+  "Event",
+  "Document",
+  "Element",
+  "Node",
+  "Screen",
+  "Window",
+  "Location",
+  "History",
+  "Storage",
+  "Response",
+  "Request",
+  "Headers"
+]);
+function packageOf(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) return void 0;
+  if (/^[~@]\//.test(specifier)) return void 0;
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function namespaceAlias(module) {
+  return `_${module.replace(/[^A-Za-z0-9]/g, "_")}`;
+}
+function componentGlobals(rules, options = {}) {
+  const {
+    available: availableList,
+    builtins = true,
+    intrinsics = true,
+    generator = "@fluixi/compiler",
+    specifier = (module) => module
+  } = options;
+  const all = [...rules];
+  if (builtins) {
+    all.push({ components: builtinComponentMap() });
+  }
+  const resolver = createComponentResolver(all);
+  const available = availableList ? new Set(availableList) : void 0;
+  const declared = [];
+  const shadowedByDom = [];
+  const unavailable = [];
+  const resolved = /* @__PURE__ */ new Map();
+  for (const name of [...resolver.names()].sort()) {
+    const target = resolver.resolve(name);
+    if (!target) continue;
+    const pkg = packageOf(target.module);
+    if (DOM_GLOBALS.has(name)) shadowedByDom.push(name);
+    else if (available && pkg && !available.has(pkg)) unavailable.push(name);
+    else {
+      declared.push(name);
+      resolved.set(name, target);
+    }
+  }
+  const intrinsicModules = intrinsics ? [...new Set(Object.values(INTRINSICS).map((i) => i.module))] : [];
+  const modules = [
+    .../* @__PURE__ */ new Set([...declared.map((name) => resolved.get(name).module), ...intrinsicModules])
+  ].sort();
+  const imports = modules.map(
+    (m) => `import * as ${namespaceAlias(m)} from '${specifier(m)}';`
+  );
+  const lines = declared.map((name) => {
+    const target = resolved.get(name);
+    const ns = namespaceAlias(target.module);
+    return target.export === "default" ? `  const ${name}: typeof ${ns}.default;` : `  export import ${name} = ${ns}.${target.export};`;
+  });
+  const note = shadowedByDom.length > 0 ? `//
+// Import these explicitly: lib.dom already declares the name, so an ambient
 // declaration cannot win:
-`+d.map(e=>{let s=l.resolve(e)?.module;return`//   import { ${e} } from '${s?n(s):""}';
-`}).join(""):"",T=i?Object.entries(h).map(([e,s])=>`  const ${e}: typeof ${M(s.module)}.${s.export};`):[],x=t.filter(e=>"match"in e).length,L=x>0?`//
-// ${x} pattern rule${x===1?"":"s"} cannot be declared:
+` + shadowedByDom.map((n) => {
+    const module = resolver.resolve(n)?.module;
+    return `//   import { ${n} } from '${module ? specifier(module) : ""}';
+`;
+  }).join("") : "";
+  const intrinsicLines = intrinsics ? Object.entries(INTRINSICS).map(
+    ([name, intrinsic]) => `  const ${name}: typeof ${namespaceAlias(intrinsic.module)}.${intrinsic.export};`
+  ) : [];
+  const patternRules = rules.filter((rule) => "match" in rule).length;
+  const patternNote = patternRules > 0 ? `//
+// ${patternRules} pattern rule${patternRules === 1 ? "" : "s"} cannot be declared:
 // a pattern matches unboundedly many names, so there is no list to emit. Those
 // tags still resolve at build time; declare them by hand if the editor needs them.
-`:"";return{source:`// GENERATED by ${p} — do not edit.
+` : "";
+  const source = `// GENERATED by ${generator}, do not edit.
 //
 // The components \`resolve\` supplies without an import. This describes what the
 // compiler already does; it does not enable it.
-`+N+L+(y.length>0?`
-${y.join(`
-`)}
-`:`
-`)+`
+` + note + patternNote + (imports.length > 0 ? `
+${imports.join("\n")}
+` : "\n") + `
 declare global {
-${[...w,...T].join(`
-`)}
+${[...lines, ...intrinsicLines].join("\n")}
+}
+`;
+  return { source, declared, shadowedByDom, unavailable, patternRules };
 }
-`,declared:m,shadowedByDom:d,unavailable:R,patternRules:x}}export{z as componentGlobals};
+export {
+  componentGlobals
+};

package/dist/resolve/component-resolver.cjs

@@ -1 +1,80 @@
-"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}}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/resolve/component-resolver.ts
+var component_resolver_exports = {};
+__export(component_resolver_exports, {
+  createComponentResolver: () => createComponentResolver
+});
+module.exports = __toCommonJS(component_resolver_exports);
+var isMapRule = (rule) => "components" in rule;
+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;
+}
+function createComponentResolver(rules = []) {
+  const exact = /* @__PURE__ */ 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) {
+        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 = /* @__PURE__ */ 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) {
+        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.d.cts

@@ -0,0 +1,68 @@
+/**
+ * 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;

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

@@ -4,7 +4,7 @@
  * 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
+ * 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
@@ -44,7 +44,7 @@ export interface ComponentPatternRule {
     export?: string;
 }
 export type ComponentResolverRule = ComponentMapRule | ComponentPatternRule;
-/** Two rules claiming the same name — reported rather than silently first-wins. */
+/** Two rules claiming the same name: reported rather than silently first-wins. */
 export interface ResolverConflict {
     name: string;
     modules: string[];
@@ -60,7 +60,7 @@ export interface ComponentResolver {
 /**
  * Build a resolver from rules, in order.
  *
- * Map rules are flattened up front so lookup is a plain object read — resolution runs
+ * 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.

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

@@ -1 +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"}
+{"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,kFAAkF;AAClF,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

@@ -4,7 +4,7 @@
  * 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
+ * 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
@@ -33,7 +33,7 @@ function normalise(name, entry) {
 /**
  * Build a resolver from rules, in order.
  *
- * Map rules are flattened up front so lookup is a plain object read — resolution runs
+ * 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.
@@ -54,7 +54,7 @@ export function createComponentResolver(rules = []) {
                 // 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.
+                // 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);