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

package/dist/resolve/load-directive.mjs

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

package/dist/resolve/resolve-ir.cjs

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

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

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

package/dist/resolve/resolve-ir.mjs

@@ -1 +1,85 @@
-var c=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],l=["Suspense","SuspenseList","Await"],a=["Router","Outlet","Redirect","Link"],C=[...c,...l,...a],p=new Set([...c,...l]);function v(t={}){let{controlFlowModule:i="@fluixi/dom",coreModule:d="@fluixi/core",routerModule:s="@fluixi/core/router"}=t,o={};for(let r of c)o[r]=i;for(let r of l)o[r]=d;for(let r of a)o[r]=s;return o}var m={kind:"eager"};function N(t,i={}){let{resolver:d,isBound:s,modules:o,strategyFor:r}=i,R=v(o),f=new Map,g=new Set,S=e=>{let{name:n}=e;if(!n||n.includes(".")||s?.(n))return;let u=E(n);if(!u){g.add(n);return}let O=u.origin==="builtin"&&p.has(n)?m:r?.(e)??m;e.source={...u,loading:O},f.set(n,e.source)},E=e=>{if(p.has(e))return{module:R[e],export:e,origin:"builtin"};let n=d?.resolve(e);if(n)return{module:n.module,export:n.export,origin:"rule"};if(a.includes(e))return{module:R[e],export:e,origin:"builtin"}};return x(t,e=>{e.kind==="component"&&S(e)}),{resolved:f,unresolved:[...g]}}function x(t,i){let d=Array.isArray(t)?t:[t];for(let s of d){i(s);let o=s.children;o&&x(o,i)}}export{N as resolveComponentSources,x as walk};
+// 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/resolve/load-directive.ts
+var EAGER = { kind: "eager" };
+
+// src/resolve/resolve-ir.ts
+function resolveComponentSources(root, options = {}) {
+  const { resolver, isBound, modules, strategyFor } = options;
+  const builtins = builtinComponentMap(modules);
+  const resolved = /* @__PURE__ */ new Map();
+  const unresolved = /* @__PURE__ */ new Set();
+  const annotate = (node) => {
+    const { name } = node;
+    if (!name || name.includes(".")) return;
+    if (isBound?.(name)) return;
+    const source = sourceFor(name);
+    if (!source) {
+      unresolved.add(name);
+      return;
+    }
+    const loading = source.origin === "builtin" && RESERVED_COMPONENTS.has(name) ? EAGER : strategyFor?.(node) ?? EAGER;
+    node.source = { ...source, loading };
+    resolved.set(name, node.source);
+  };
+  const sourceFor = (name) => {
+    if (RESERVED_COMPONENTS.has(name)) {
+      return { module: builtins[name], export: name, origin: "builtin" };
+    }
+    const rule = resolver?.resolve(name);
+    if (rule) return { module: rule.module, export: rule.export, origin: "rule" };
+    if (ROUTER_COMPONENTS.includes(name)) {
+      return { module: builtins[name], export: name, origin: "builtin" };
+    }
+    return void 0;
+  };
+  walk(root, (node) => {
+    if (node.kind === "component") annotate(node);
+  });
+  return { resolved, unresolved: [...unresolved] };
+}
+function walk(root, visit) {
+  const nodes = Array.isArray(root) ? root : [root];
+  for (const node of nodes) {
+    visit(node);
+    const children = node.children;
+    if (children) walk(children, visit);
+  }
+}
+export {
+  resolveComponentSources,
+  walk
+};