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

package/dist/resolve/write-globals.cjs

@@ -1,22 +1,327 @@
-"use strict";var y=Object.defineProperty;var W=Object.getOwnPropertyDescriptor;var B=Object.getOwnPropertyNames;var F=Object.prototype.hasOwnProperty;var U=(e,t)=>{for(var o in t)y(e,o,{get:t[o],enumerable:!0})},H=(e,t,o,s)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of B(t))!F.call(e,n)&&n!==o&&y(e,n,{get:()=>t[n],enumerable:!(s=W(t,n))||s.enumerable});return e};var K=e=>H(y({},"__esModule",{value:!0}),e);var te={};U(te,{DEFAULT_GLOBALS_PATH:()=>k,writeComponentGlobals:()=>ee});module.exports=K(te);var f=require("node:fs"),c=require("node:path");var V=e=>"components"in e;function M(e,t){return e.replace(/\$(\d+)/g,(o,s)=>t[Number(s)]??o)}function J(e,t){return typeof t=="string"?{module:t,export:e}:t}function w(e=[]){let t=new Map,o=[],s=[];for(let i of e){if(!V(i)){s.push(i);continue}for(let[l,p]of Object.entries(i.components)){let d=J(l,p),m=t.get(l);if(m&&m.module!==d.module){let g=o.find(v=>v.name===l);g?g.modules.push(d.module):o.push({name:l,modules:[m.module,d.module]});continue}t.set(l,d)}}let n=new Map;return{resolve:i=>{if(n.has(i))return n.get(i);let l=t.get(i);if(!l)for(let p of s){let d=i.match(new RegExp(p.match.source,p.match.flags.replace("g","")));if(d){l={module:M(p.module,d),export:p.export?M(p.export,d):i};break}}return n.set(i,l),l},names:()=>[...t.keys()],conflicts:()=>o}}var O=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],S=["Suspense","SuspenseList","Await"],I=["Router","Outlet","Redirect","Link"],ie=[...O,...S,...I],le=new Set([...O,...S]);function j(e={}){let{controlFlowModule:t="@fluixi/dom",coreModule:o="@fluixi/core",routerModule:s="@fluixi/core/router"}=e,n={};for(let a of O)n[a]=t;for(let a of S)n[a]=o;for(let a of I)n[a]=s;return n}var R="@fluixi/reactive/signal",b={$signal:{export:"signal",module:R,returns:"signal-handle"},$memo:{export:"memo",module:R,returns:"memo-handle"},$effect:{export:"effect",module:R,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:R,returns:"resource-handle"},$selector:{export:"createSelector",module:R,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:R,returns:"memo-accessor"},$untrack:{export:"untrack",module:R,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}};var ae=new RegExp(`\\$(?:${Object.keys(b).map(e=>e.slice(1)).join("|")})\\s*\\(`);var q=new Set(["Text","Image","Option","Audio","Comment","Range","Selection","Notification","Event","Document","Element","Node","Screen","Window","Location","History","Storage","Response","Request","Headers"]);function z(e){if(e.startsWith(".")||e.startsWith("/")||/^[~@]\//.test(e))return;let t=e.split("/");return e.startsWith("@")?t.slice(0,2).join("/"):t[0]}function $(e){return`_${e.replace(/[^A-Za-z0-9]/g,"_")}`}function N(e,t={}){let{available:o,builtins:s=!0,intrinsics:n=!0,generator:a="@fluixi/compiler",specifier:i=r=>r}=t,l=[...e];s&&l.push({components:j()});let p=w(l),d=o?new Set(o):void 0,m=[],g=[],v=[],C=new Map;for(let r of[...p.names()].sort()){let u=p.resolve(r);if(!u)continue;let x=z(u.module);q.has(r)?g.push(r):d&&x&&!d.has(x)?v.push(r):(m.push(r),C.set(r,u))}let A=n?[...new Set(Object.values(b).map(r=>r.module))]:[],E=[...new Set([...m.map(r=>C.get(r).module),...A])].sort().map(r=>`import * as ${$(r)} from '${i(r)}';`),D=m.map(r=>{let u=C.get(r),x=$(u.module);return u.export==="default"?`  const ${r}: typeof ${x}.default;`:`  export import ${r} = ${x}.${u.export};`}),_=g.length>0?`//
+"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/write-globals.ts
+var write_globals_exports = {};
+__export(write_globals_exports, {
+  DEFAULT_GLOBALS_PATH: () => DEFAULT_GLOBALS_PATH,
+  writeComponentGlobals: () => writeComponentGlobals
+});
+module.exports = __toCommonJS(write_globals_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
+
+// 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(module2) {
+  return `_${module2.replace(/[^A-Za-z0-9]/g, "_")}`;
+}
+function componentGlobals(rules, options = {}) {
+  const {
+    available: availableList,
+    builtins = true,
+    intrinsics = true,
+    generator = "@fluixi/compiler",
+    specifier = (module2) => module2
+  } = 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:
-`+g.map(r=>{let u=p.resolve(r)?.module;return`//   import { ${r} } from '${u?i(u):""}';
-`}).join(""):"",G=n?Object.entries(b).map(([r,u])=>`  const ${r}: typeof ${$(u.module)}.${u.export};`):[],h=e.filter(r=>"match"in r).length,P=h>0?`//
-// ${h} pattern rule${h===1?"":"s"} cannot be declared:
+` + shadowedByDom.map((n) => {
+    const module2 = resolver.resolve(n)?.module;
+    return `//   import { ${n} } from '${module2 ? specifier(module2) : ""}';
+`;
+  }).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 ${a} — 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.
-`+_+P+(E.length>0?`
-${E.join(`
-`)}
-`:`
-`)+`
+` + note + patternNote + (imports.length > 0 ? `
+${imports.join("\n")}
+` : "\n") + `
 declare global {
-${[...D,...G].join(`
-`)}
+${[...lines, ...intrinsicLines].join("\n")}
+}
+`;
+  return { source, declared, shadowedByDom, unavailable, patternRules };
+}
+
+// src/resolve/write-globals.ts
+var GENERATED_MARKER = "GENERATED by @fluixi/compiler";
+var DEFAULT_GLOBALS_PATH = "fluixi.d.ts";
+function coveredByInclude(root, target) {
+  let config;
+  try {
+    const raw = (0, import_node_fs.readFileSync)((0, import_node_path.resolve)(root, "tsconfig.json"), "utf8");
+    config = JSON.parse(raw.replace(/^\s*\/\/.*$/gm, ""));
+  } catch {
+    return void 0;
+  }
+  if (config.extends !== void 0) return void 0;
+  if (!Array.isArray(config.include)) return true;
+  const relative2 = relativePosix(root, target);
+  return config.include.some((entry) => {
+    if (typeof entry !== "string") return false;
+    const pattern = entry.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "(?:.*/)?").replace(/\*/g, "[^/]*");
+    return new RegExp(`^${pattern}(?:/.*)?$`).test(relative2);
+  });
+}
+function relativePosix(from, to) {
+  return (0, import_node_path.relative)(from, to).split(import_node_path.sep).join("/");
+}
+function forTypeScript(module2, outDir, root) {
+  if (!module2.startsWith("/")) return module2;
+  const absolute = (0, import_node_path.resolve)(root, module2.slice(1));
+  let rel = (0, import_node_path.relative)(outDir, absolute).split(import_node_path.sep).join("/");
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  return rel.replace(/\.(tsx|ts|jsx|mts|cts)$/, ".js");
+}
+function projectDependencies(root) {
+  try {
+    const manifest = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.resolve)(root, "package.json"), "utf8"));
+    return [
+      ...Object.keys(manifest.dependencies ?? {}),
+      ...Object.keys(manifest.devDependencies ?? {}),
+      ...Object.keys(manifest.peerDependencies ?? {})
+    ];
+  } catch {
+    return void 0;
+  }
+}
+function writeComponentGlobals(options, root) {
+  if (options.globals === false) return { status: "skipped", reason: "disabled" };
+  const rules = options.resolve ?? [];
+  const target = (0, import_node_path.resolve)(root, options.globals ?? DEFAULT_GLOBALS_PATH);
+  let existing;
+  try {
+    existing = (0, import_node_fs.readFileSync)(target, "utf8");
+  } catch {
+    existing = void 0;
+  }
+  if (existing !== void 0 && !existing.includes(GENERATED_MARKER)) {
+    return { status: "skipped", reason: "foreign-file", path: target };
+  }
+  const { source, declared } = componentGlobals(rules, {
+    available: projectDependencies(root),
+    specifier: (module2) => forTypeScript(module2, (0, import_node_path.dirname)(target), root)
+  });
+  if (existing === source) {
+    return {
+      status: "unchanged",
+      path: target,
+      declared: declared.length,
+      warning: warnIfUnreachable(root, target)
+    };
+  }
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(target), { recursive: true });
+  (0, import_node_fs.writeFileSync)(target, source);
+  return {
+    status: "written",
+    path: target,
+    declared: declared.length,
+    warning: warnIfUnreachable(root, target)
+  };
+}
+function warnIfUnreachable(root, target) {
+  if (coveredByInclude(root, target) !== false) return void 0;
+  const relative2 = relativePosix(root, target);
+  return `[fluixi] ${relative2} is not covered by "include" in tsconfig.json, so TypeScript will ignore it and every resolved component stays "Cannot find name". Add "${relative2}" to "include".`;
 }
-`,declared:m,shadowedByDom:g,unavailable:v,patternRules:h}}var Z="GENERATED by @fluixi/compiler",k="fluixi.d.ts";function Q(e,t){let o;try{let n=(0,f.readFileSync)((0,c.resolve)(e,"tsconfig.json"),"utf8");o=JSON.parse(n.replace(/^\s*\/\/.*$/gm,""))}catch{return}if(o.extends!==void 0)return;if(!Array.isArray(o.include))return!0;let s=L(e,t);return o.include.some(n=>{if(typeof n!="string")return!1;let a=n.replace(/[.+^${}()|[\]\\]/g,"\\$&").replace(/\*\*\//g,"(?:.*/)?").replace(/\*/g,"[^/]*");return new RegExp(`^${a}(?:/.*)?$`).test(s)})}function L(e,t){return(0,c.relative)(e,t).split(c.sep).join("/")}function X(e,t,o){if(!e.startsWith("/"))return e;let s=(0,c.resolve)(o,e.slice(1)),n=(0,c.relative)(t,s).split(c.sep).join("/");return n.startsWith(".")||(n=`./${n}`),n.replace(/\.(tsx|ts|jsx|mts|cts)$/,".js")}function Y(e){try{let t=JSON.parse((0,f.readFileSync)((0,c.resolve)(e,"package.json"),"utf8"));return[...Object.keys(t.dependencies??{}),...Object.keys(t.devDependencies??{}),...Object.keys(t.peerDependencies??{})]}catch{return}}function ee(e,t){if(e.globals===!1)return{status:"skipped",reason:"disabled"};let o=e.resolve??[],s=(0,c.resolve)(t,e.globals??k),n;try{n=(0,f.readFileSync)(s,"utf8")}catch{n=void 0}if(n!==void 0&&!n.includes(Z))return{status:"skipped",reason:"foreign-file",path:s};let{source:a,declared:i}=N(o,{available:Y(t),specifier:l=>X(l,(0,c.dirname)(s),t)});return n===a?{status:"unchanged",path:s,declared:i.length,warning:T(t,s)}:((0,f.mkdirSync)((0,c.dirname)(s),{recursive:!0}),(0,f.writeFileSync)(s,a),{status:"written",path:s,declared:i.length,warning:T(t,s)})}function T(e,t){if(Q(e,t)!==!1)return;let o=L(e,t);return`[fluixi] ${o} is not covered by "include" in tsconfig.json, so TypeScript will ignore it and every resolved component stays "Cannot find name". Add "${o}" to "include".`}

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

@@ -0,0 +1,30 @@
+import type { ComponentResolverRule } from './component-resolver.cjs';
+export declare const DEFAULT_GLOBALS_PATH = "fluixi.d.ts";
+export interface WriteGlobalsOptions {
+    resolve?: readonly ComponentResolverRule[];
+    globals?: string | false;
+}
+export type WriteGlobalsOutcome = ({
+    status: 'written';
+    path: string;
+    declared: number;
+} | {
+    status: 'unchanged';
+    path: string;
+    declared: number;
+} | {
+    status: 'skipped';
+    reason: 'disabled' | 'foreign-file';
+    path?: string;
+}) & {
+    /**
+     * Set when the file was written somewhere TypeScript will not read it.
+     *
+     * Worth surfacing because the symptom is indistinguishable from the generator never
+     * having run: every resolved tag is still `Cannot find name`, and the file sitting
+     * right there makes it look like it should have worked.
+     */
+    warning?: string;
+};
+/** Generate and write the declarations for `root`, returning what was done. */
+export declare function writeComponentGlobals(options: WriteGlobalsOptions, root: string): WriteGlobalsOutcome;