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

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?`//
+// 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.mjs

@@ -1 +1,59 @@
-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};
+// 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
+  };
+}
+export {
+  createComponentResolver
+};

package/dist/resolve/load-directive.cjs

@@ -1 +1,93 @@
-"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}}
+"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/load-directive.ts
+var load_directive_exports = {};
+__export(load_directive_exports, {
+  DEFAULT_INTERACTION_EVENTS: () => DEFAULT_INTERACTION_EVENTS,
+  EAGER: () => EAGER,
+  LoadDirectiveError: () => LoadDirectiveError,
+  isDeferred: () => isDeferred,
+  isLoadDirective: () => isLoadDirective,
+  parseLoadDirective: () => parseLoadDirective,
+  strategyKey: () => strategyKey
+});
+module.exports = __toCommonJS(load_directive_exports);
+var EAGER = { kind: "eager" };
+var DEFAULT_INTERACTION_EVENTS = ["pointerdown", "focusin", "keydown"];
+var STRATEGIES = /* @__PURE__ */ new Set(["eager", "idle", "visible", "interaction", "media", "never"]);
+var LoadDirectiveError = class extends Error {
+};
+function isLoadDirective(name) {
+  return name.startsWith("load:");
+}
+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":
+      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:
+      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;
+}
+function isDeferred(strategy) {
+  return strategy.kind !== "eager" && strategy.kind !== "never";
+}
+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.d.cts

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