@fluixi/compiler 1.0.0-alpha.70 → 1.0.0-alpha.72

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

@@ -0,0 +1,73 @@
+/**
+ * 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.js';
+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;
+    /** 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;
+//# sourceMappingURL=component-globals.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"component-globals.d.ts","sourceRoot":"","sources":["../../src/resolve/component-globals.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,OAAO,EAEL,KAAK,qBAAqB,EAE3B,MAAM,yBAAyB,CAAC;AAkCjC,MAAM,WAAW,uBAAuB;IACtC;;;;;;;;;;OAUG;IACH,SAAS,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC7B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,CAAC;CACxC;AAED,MAAM,WAAW,sBAAsB;IACrC,mCAAmC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,2BAA2B;IAC3B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,0DAA0D;IAC1D,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,qEAAqE;IACrE,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB;;;;;;OAMG;IACH,YAAY,EAAE,MAAM,CAAC;CACtB;AAgBD,0FAA0F;AAC1F,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,SAAS,qBAAqB,EAAE,EACvC,OAAO,GAAE,uBAA4B,GACpC,sBAAsB,CAyFxB"}

package/dist/resolve/component-globals.js

@@ -0,0 +1,137 @@
+/**
+ * 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 { createComponentResolver, } from './component-resolver.js';
+import { builtinComponentMap } from './builtins.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
+ * shown would be the DOM node's. They are left out and reported instead, since importing
+ * them explicitly makes both agree.
+ */
+const DOM_GLOBALS = new Set([
+    'Text',
+    'Image',
+    'Option',
+    'Audio',
+    'Comment',
+    'Range',
+    'Selection',
+    'Notification',
+    'Event',
+    'Document',
+    'Element',
+    'Node',
+    'Screen',
+    'Window',
+    'Location',
+    'History',
+    'Storage',
+    'Response',
+    'Request',
+    'Headers',
+]);
+/** The package a specifier belongs to, or undefined when it is not a package import. */
+function packageOf(specifier) {
+    if (specifier.startsWith('.') || specifier.startsWith('/'))
+        return undefined;
+    // Alias specifiers (`@/x`, `~/x`) are project-local and resolve through tsconfig paths.
+    if (/^[~@]\//.test(specifier))
+        return undefined;
+    const parts = specifier.split('/');
+    return specifier.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+}
+/** A valid identifier for the namespace import of `module`. */
+function namespaceAlias(module) {
+    return `_${module.replace(/[^A-Za-z0-9]/g, '_')}`;
+}
+/** Build the ambient `.d.ts` for the components a project's `resolve` config supplies. */
+export function componentGlobals(rules, options = {}) {
+    const { available: availableList, builtins = 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
+        // first-match, and a project retargeting `Router` should keep its own answer.
+        all.push({ components: builtinComponentMap() });
+    }
+    const resolver = createComponentResolver(all);
+    const available = availableList ? new Set(availableList) : undefined;
+    const declared = [];
+    const shadowedByDom = [];
+    const unavailable = [];
+    const resolved = new Map();
+    for (const name of [...resolver.names()].sort()) {
+        const target = resolver.resolve(name);
+        /* c8 ignore next */
+        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 modules = [...new Set(declared.map((name) => resolved.get(name).module))].sort();
+    const imports = modules.map((m) => `import * as ${namespaceAlias(m)} from '${specifier(m)}';`);
+    // `export import X = ns.X` rather than `const X: typeof import('…').X`: an alias
+    // resolves to the original symbol, so hover shows the real declaration
+    // (`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`
+    // form, which types and documents correctly but renders as an anonymous arrow.
+    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
+        ? `//\n// Import these explicitly — lib.dom already declares the name, so an ambient\n` +
+            `// declaration cannot win:\n` +
+            shadowedByDom
+                .map((n) => {
+                const module = resolver.resolve(n)?.module;
+                return `//   import { ${n} } from '${module ? specifier(module) : ''}';\n`;
+            })
+                .join('')
+        : '';
+    const patternRules = rules.filter((rule) => 'match' in rule).length;
+    const patternNote = patternRules > 0
+        ? `//\n// ${patternRules} pattern rule${patternRules === 1 ? '' : 's'} cannot be declared:\n` +
+            `// 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` +
+        `//\n` +
+        `// The components \`resolve\` supplies without an import. This describes what the\n` +
+        `// compiler already does; it does not enable it.\n` +
+        note +
+        patternNote +
+        (imports.length > 0 ? `\n${imports.join('\n')}\n` : '\n') +
+        `\ndeclare global {\n${lines.join('\n')}\n}\n`;
+    return { source, declared, shadowedByDom, unavailable, patternRules };
+}

package/dist/resolve/component-globals.mjs

@@ -0,0 +1,22 @@
+var $=t=>"components"in t;function v(t,o){return t.replace(/\$(\d+)/g,(l,p)=>o[Number(p)]??l)}function N(t,o){return typeof o=="string"?{module:o,export:t}:o}function b(t=[]){let o=new Map,l=[],p=[];for(let r of t){if(!$(r)){p.push(r);continue}for(let[n,a]of Object.entries(r.components)){let s=N(n,a),m=o.get(n);if(m&&m.module!==s.module){let d=l.find(f=>f.name===n);d?d.modules.push(s.module):l.push({name:n,modules:[m.module,s.module]});continue}o.set(n,s)}}let i=new Map;return{resolve:r=>{if(i.has(r))return i.get(r);let n=o.get(r);if(!n)for(let a of p){let s=r.match(new RegExp(a.match.source,a.match.flags.replace("g","")));if(s){n={module:v(a.module,s),export:a.export?v(a.export,s):r};break}}return i.set(r,n),n},names:()=>[...o.keys()],conflicts:()=>l}}var C=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],h=["Suspense","SuspenseList","Await"],M=["Router","Outlet","Redirect","Link"],j=[...C,...h,...M],A=new Set([...C,...h]);function O(t={}){let{controlFlowModule:o="@fluixi/dom",coreModule:l="@fluixi/core",routerModule:p="@fluixi/core/router-next"}=t,i={};for(let u of C)i[u]=o;for(let u of h)i[u]=l;for(let u of M)i[u]=p;return i}var T=new Set(["Text","Image","Option","Audio","Comment","Range","Selection","Notification","Event","Document","Element","Node","Screen","Window","Location","History","Storage","Response","Request","Headers"]);function L(t){if(t.startsWith(".")||t.startsWith("/")||/^[~@]\//.test(t))return;let o=t.split("/");return t.startsWith("@")?o.slice(0,2).join("/"):o[0]}function y(t){return`_${t.replace(/[^A-Za-z0-9]/g,"_")}`}function W(t,o={}){let{available:l,builtins:p=!0,generator:i="@fluixi/compiler",specifier:u=e=>e}=o,r=[...t];p&&r.push({components:O()});let n=b(r),a=l?new Set(l):void 0,s=[],m=[],d=[],f=new Map;for(let e of[...n.names()].sort()){let c=n.resolve(e);if(!c)continue;let g=L(c.module);T.has(e)?m.push(e):a&&g&&!a.has(g)?d.push(e):(s.push(e),f.set(e,c))}let x=[...new Set(s.map(e=>f.get(e).module))].sort().map(e=>`import * as ${y(e)} from '${u(e)}';`),w=s.map(e=>{let c=f.get(e),g=y(c.module);return c.export==="default"?`  const ${e}: typeof ${g}.default;`:`  export import ${e} = ${g}.${c.export};`}),E=m.length>0?`//
+// Import these explicitly — lib.dom already declares the name, so an ambient
+// declaration cannot win:
+`+m.map(e=>{let c=n.resolve(e)?.module;return`//   import { ${e} } from '${c?u(c):""}';
+`}).join(""):"",R=t.filter(e=>"match"in e).length,S=R>0?`//
+// ${R} pattern rule${R===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 ${i} — do not edit.
+//
+// The components \`resolve\` supplies without an import. This describes what the
+// compiler already does; it does not enable it.
+`+E+S+(x.length>0?`
+${x.join(`
+`)}
+`:`
+`)+`
+declare global {
+${w.join(`
+`)}
+}
+`,declared:s,shadowedByDom:m,unavailable:d,patternRules:R}}export{W as componentGlobals};

package/dist/resolve/write-globals.cjs

@@ -0,0 +1,22 @@
+"use strict";var x=Object.defineProperty;var D=Object.getOwnPropertyDescriptor;var L=Object.getOwnPropertyNames;var _=Object.prototype.hasOwnProperty;var W=(e,n)=>{for(var o in n)x(e,o,{get:n[o],enumerable:!0})},B=(e,n,o,r)=>{if(n&&typeof n=="object"||typeof n=="function")for(let t of L(n))!_.call(e,t)&&t!==o&&x(e,t,{get:()=>n[t],enumerable:!(r=D(n,t))||r.enumerable});return e};var P=e=>B(x({},"__esModule",{value:!0}),e);var Z={};W(Z,{DEFAULT_GLOBALS_PATH:()=>N,writeComponentGlobals:()=>V});module.exports=P(Z);var f=require("node:fs"),c=require("node:path");var F=e=>"components"in e;function O(e,n){return e.replace(/\$(\d+)/g,(o,r)=>n[Number(r)]??o)}function I(e,n){return typeof n=="string"?{module:n,export:e}:n}function w(e=[]){let n=new Map,o=[],r=[];for(let i of e){if(!F(i)){r.push(i);continue}for(let[l,p]of Object.entries(i.components)){let u=I(l,p),m=n.get(l);if(m&&m.module!==u.module){let g=o.find(R=>R.name===l);g?g.modules.push(u.module):o.push({name:l,modules:[m.module,u.module]});continue}n.set(l,u)}}let t=new Map;return{resolve:i=>{if(t.has(i))return t.get(i);let l=n.get(i);if(!l)for(let p of r){let u=i.match(new RegExp(p.match.source,p.match.flags.replace("g","")));if(u){l={module:O(p.module,u),export:p.export?O(p.export,u):i};break}}return t.set(i,l),l},names:()=>[...n.keys()],conflicts:()=>o}}var b=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],C=["Suspense","SuspenseList","Await"],M=["Router","Outlet","Redirect","Link"],ne=[...b,...C,...M],te=new Set([...b,...C]);function E(e={}){let{controlFlowModule:n="@fluixi/dom",coreModule:o="@fluixi/core",routerModule:r="@fluixi/core/router-next"}=e,t={};for(let a of b)t[a]=n;for(let a of C)t[a]=o;for(let a of M)t[a]=r;return t}var U=new Set(["Text","Image","Option","Audio","Comment","Range","Selection","Notification","Event","Document","Element","Node","Screen","Window","Location","History","Storage","Response","Request","Headers"]);function H(e){if(e.startsWith(".")||e.startsWith("/")||/^[~@]\//.test(e))return;let n=e.split("/");return e.startsWith("@")?n.slice(0,2).join("/"):n[0]}function S(e){return`_${e.replace(/[^A-Za-z0-9]/g,"_")}`}function $(e,n={}){let{available:o,builtins:r=!0,generator:t="@fluixi/compiler",specifier:a=s=>s}=n,i=[...e];r&&i.push({components:E()});let l=w(i),p=o?new Set(o):void 0,u=[],m=[],g=[],R=new Map;for(let s of[...l.names()].sort()){let d=l.resolve(s);if(!d)continue;let h=H(d.module);U.has(s)?m.push(s):p&&h&&!p.has(h)?g.push(s):(u.push(s),R.set(s,d))}let y=[...new Set(u.map(s=>R.get(s).module))].sort().map(s=>`import * as ${S(s)} from '${a(s)}';`),A=u.map(s=>{let d=R.get(s),h=S(d.module);return d.export==="default"?`  const ${s}: typeof ${h}.default;`:`  export import ${s} = ${h}.${d.export};`}),G=m.length>0?`//
+// Import these explicitly — lib.dom already declares the name, so an ambient
+// declaration cannot win:
+`+m.map(s=>{let d=l.resolve(s)?.module;return`//   import { ${s} } from '${d?a(d):""}';
+`}).join(""):"",v=e.filter(s=>"match"in s).length,k=v>0?`//
+// ${v} pattern rule${v===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 ${t} — do not edit.
+//
+// The components \`resolve\` supplies without an import. This describes what the
+// compiler already does; it does not enable it.
+`+G+k+(y.length>0?`
+${y.join(`
+`)}
+`:`
+`)+`
+declare global {
+${A.join(`
+`)}
+}
+`,declared:u,shadowedByDom:m,unavailable:g,patternRules:v}}var J="GENERATED by @fluixi/compiler",N="fluixi.d.ts";function q(e,n){let o;try{let t=(0,f.readFileSync)((0,c.resolve)(e,"tsconfig.json"),"utf8");o=JSON.parse(t.replace(/^\s*\/\/.*$/gm,""))}catch{return}if(o.extends!==void 0)return;if(!Array.isArray(o.include))return!0;let r=T(e,n);return o.include.some(t=>{if(typeof t!="string")return!1;let a=t.replace(/[.+^${}()|[\]\\]/g,"\\$&").replace(/\*\*\//g,"(?:.*/)?").replace(/\*/g,"[^/]*");return new RegExp(`^${a}(?:/.*)?$`).test(r)})}function T(e,n){return(0,c.relative)(e,n).split(c.sep).join("/")}function z(e,n,o){if(!e.startsWith("/"))return e;let r=(0,c.resolve)(o,e.slice(1)),t=(0,c.relative)(n,r).split(c.sep).join("/");return t.startsWith(".")||(t=`./${t}`),t.replace(/\.(tsx|ts|jsx|mts|cts)$/,".js")}function K(e){try{let n=JSON.parse((0,f.readFileSync)((0,c.resolve)(e,"package.json"),"utf8"));return[...Object.keys(n.dependencies??{}),...Object.keys(n.devDependencies??{}),...Object.keys(n.peerDependencies??{})]}catch{return}}function V(e,n){if(e.globals===!1)return{status:"skipped",reason:"disabled"};let o=e.resolve??[],r=(0,c.resolve)(n,e.globals??N),t;try{t=(0,f.readFileSync)(r,"utf8")}catch{t=void 0}if(t!==void 0&&!t.includes(J))return{status:"skipped",reason:"foreign-file",path:r};let{source:a,declared:i}=$(o,{available:K(n),specifier:l=>z(l,(0,c.dirname)(r),n)});return t===a?{status:"unchanged",path:r,declared:i.length,warning:j(n,r)}:((0,f.mkdirSync)((0,c.dirname)(r),{recursive:!0}),(0,f.writeFileSync)(r,a),{status:"written",path:r,declared:i.length,warning:j(n,r)})}function j(e,n){if(q(e,n)!==!1)return;let o=T(e,n);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.ts

@@ -0,0 +1,31 @@
+import type { ComponentResolverRule } from './component-resolver.js';
+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;
+//# sourceMappingURL=write-globals.d.ts.map

package/dist/resolve/write-globals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-globals.d.ts","sourceRoot":"","sources":["../../src/resolve/write-globals.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAKrE,eAAO,MAAM,oBAAoB,gBAAgB,CAAC;AAElD,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAC3C,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAAC;CAC1B;AAED,MAAM,MAAM,mBAAmB,GAAG,CAC9B;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,MAAM,EAAE,SAAS,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,cAAc,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,CAC5E,GAAG;IACF;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AA2EF,+EAA+E;AAC/E,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,mBAAmB,EAC5B,IAAI,EAAE,MAAM,GACX,mBAAmB,CAwCrB"}

package/dist/resolve/write-globals.js

@@ -0,0 +1,136 @@
+/**
+ * Write the generated component declarations into a project.
+ *
+ * Split from the generator so the generator stays pure and testable; this half owns the
+ * three things that only matter once a real file is involved:
+ *
+ *  - **Never clobber someone's file.** A path like `src/fluixi.d.ts` is plausible enough
+ *    that a project may already have one. Anything without our header is left alone and
+ *    reported, because silently overwriting hand-written declarations is unrecoverable.
+ *  - **Do not rewrite unchanged content.** The dev server watches this directory; an
+ *    identical write still bumps mtime and can cost a reload every restart.
+ *  - **Only declare what the project can resolve.** Dependencies come from its manifest,
+ *    so a component from an uninstalled package is skipped rather than degraded to `any`.
+ */
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, relative, sep, resolve as resolvePath } from 'node:path';
+import { componentGlobals } from './component-globals.js';
+/** The marker every generated file carries, used to tell ours from a hand-written one. */
+const GENERATED_MARKER = 'GENERATED by @fluixi/compiler';
+export const DEFAULT_GLOBALS_PATH = 'fluixi.d.ts';
+/**
+ * Whether `target` looks covered by the project's `include`, as best we can tell.
+ *
+ * `undefined` when there is nothing to judge from — no tsconfig, unreadable, or an
+ * `extends` we would have to resolve to answer honestly. Best-effort by design: this
+ * drives a warning, never a failure, so a wrong guess must not be able to break a build.
+ */
+function coveredByInclude(root, target) {
+    let config;
+    try {
+        const raw = readFileSync(resolvePath(root, 'tsconfig.json'), 'utf8');
+        // Comments are legal in tsconfig and would break JSON.parse.
+        config = JSON.parse(raw.replace(/^\s*\/\/.*$/gm, ''));
+    }
+    catch {
+        return undefined;
+    }
+    if (config.extends !== undefined)
+        return undefined;
+    // No `include` means the whole directory tree, which covers anything we write.
+    if (!Array.isArray(config.include))
+        return true;
+    const relative = relativePosix(root, target);
+    return config.include.some((entry) => {
+        if (typeof entry !== 'string')
+            return false;
+        const pattern = entry
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*\*\//g, '(?:.*/)?')
+            .replace(/\*/g, '[^/]*');
+        // A bare directory entry (`src`) covers everything beneath it.
+        return new RegExp(`^${pattern}(?:/.*)?$`).test(relative);
+    });
+}
+/** `from` -> `to` as a posix-style relative path. */
+function relativePosix(from, to) {
+    return relative(from, to).split(sep).join('/');
+}
+/**
+ * Make a specifier resolvable from the generated file.
+ *
+ * A bundler-root-absolute `/src/components/Card.tsx` is what Vite wants and what
+ * TypeScript cannot resolve at all, so it becomes a path relative to the generated file.
+ * The extension goes to `.js` because that is what TypeScript expects to be written for
+ * a `.ts`/`.tsx` source under every module resolution mode that accepts an extension.
+ */
+function forTypeScript(module, outDir, root) {
+    if (!module.startsWith('/'))
+        return module;
+    const absolute = resolvePath(root, module.slice(1));
+    let rel = relative(outDir, absolute).split(sep).join('/');
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    return rel.replace(/\.(tsx|ts|jsx|mts|cts)$/, '.js');
+}
+/** The project's declared dependencies, or undefined when there is no readable manifest. */
+function projectDependencies(root) {
+    try {
+        const manifest = JSON.parse(readFileSync(resolvePath(root, 'package.json'), 'utf8'));
+        return [
+            ...Object.keys(manifest.dependencies ?? {}),
+            ...Object.keys(manifest.devDependencies ?? {}),
+            ...Object.keys(manifest.peerDependencies ?? {}),
+        ];
+    }
+    catch {
+        // No manifest to read — declare everything and let TypeScript report what is missing.
+        return undefined;
+    }
+}
+/** Generate and write the declarations for `root`, returning what was done. */
+export function writeComponentGlobals(options, root) {
+    if (options.globals === false)
+        return { status: 'skipped', reason: 'disabled' };
+    const rules = options.resolve ?? [];
+    const target = resolvePath(root, options.globals ?? DEFAULT_GLOBALS_PATH);
+    let existing;
+    try {
+        existing = readFileSync(target, 'utf8');
+    }
+    catch {
+        existing = undefined;
+    }
+    if (existing !== undefined && !existing.includes(GENERATED_MARKER)) {
+        return { status: 'skipped', reason: 'foreign-file', path: target };
+    }
+    const { source, declared } = componentGlobals(rules, {
+        available: projectDependencies(root),
+        specifier: (module) => forTypeScript(module, dirname(target), root),
+    });
+    if (existing === source) {
+        return {
+            status: 'unchanged',
+            path: target,
+            declared: declared.length,
+            warning: warnIfUnreachable(root, target),
+        };
+    }
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, source);
+    return {
+        status: 'written',
+        path: target,
+        declared: declared.length,
+        warning: warnIfUnreachable(root, target),
+    };
+}
+/** The message to show when the generated file is outside the project's `include`. */
+function warnIfUnreachable(root, target) {
+    if (coveredByInclude(root, target) !== false)
+        return undefined;
+    const relative = relativePosix(root, target);
+    return (`[fluixi] ${relative} is not covered by "include" in tsconfig.json, so TypeScript ` +
+        `will ignore it and every resolved component stays "Cannot find name". Add ` +
+        `"${relative}" to "include".`);
+}

package/dist/resolve/write-globals.mjs

@@ -0,0 +1,22 @@
+import{mkdirSync as P,readFileSync as b,writeFileSync as F}from"node:fs";import{dirname as $,relative as N,sep as T,resolve as h}from"node:path";var L=e=>"components"in e;function y(e,n){return e.replace(/\$(\d+)/g,(o,r)=>n[Number(r)]??o)}function _(e,n){return typeof n=="string"?{module:n,export:e}:n}function O(e=[]){let n=new Map,o=[],r=[];for(let i of e){if(!L(i)){r.push(i);continue}for(let[l,u]of Object.entries(i.components)){let c=_(l,u),d=n.get(l);if(d&&d.module!==c.module){let m=o.find(f=>f.name===l);m?m.modules.push(c.module):o.push({name:l,modules:[d.module,c.module]});continue}n.set(l,c)}}let t=new Map;return{resolve:i=>{if(t.has(i))return t.get(i);let l=n.get(i);if(!l)for(let u of r){let c=i.match(new RegExp(u.match.source,u.match.flags.replace("g","")));if(c){l={module:y(u.module,c),export:u.export?y(u.export,c):i};break}}return t.set(i,l),l},names:()=>[...n.keys()],conflicts:()=>o}}var v=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],x=["Suspense","SuspenseList","Await"],w=["Router","Outlet","Redirect","Link"],Z=[...v,...x,...w],Q=new Set([...v,...x]);function M(e={}){let{controlFlowModule:n="@fluixi/dom",coreModule:o="@fluixi/core",routerModule:r="@fluixi/core/router-next"}=e,t={};for(let a of v)t[a]=n;for(let a of x)t[a]=o;for(let a of w)t[a]=r;return t}var W=new Set(["Text","Image","Option","Audio","Comment","Range","Selection","Notification","Event","Document","Element","Node","Screen","Window","Location","History","Storage","Response","Request","Headers"]);function B(e){if(e.startsWith(".")||e.startsWith("/")||/^[~@]\//.test(e))return;let n=e.split("/");return e.startsWith("@")?n.slice(0,2).join("/"):n[0]}function E(e){return`_${e.replace(/[^A-Za-z0-9]/g,"_")}`}function S(e,n={}){let{available:o,builtins:r=!0,generator:t="@fluixi/compiler",specifier:a=s=>s}=n,i=[...e];r&&i.push({components:M()});let l=O(i),u=o?new Set(o):void 0,c=[],d=[],m=[],f=new Map;for(let s of[...l.names()].sort()){let p=l.resolve(s);if(!p)continue;let g=B(p.module);W.has(s)?d.push(s):u&&g&&!u.has(g)?m.push(s):(c.push(s),f.set(s,p))}let C=[...new Set(c.map(s=>f.get(s).module))].sort().map(s=>`import * as ${E(s)} from '${a(s)}';`),G=c.map(s=>{let p=f.get(s),g=E(p.module);return p.export==="default"?`  const ${s}: typeof ${g}.default;`:`  export import ${s} = ${g}.${p.export};`}),k=d.length>0?`//
+// Import these explicitly — lib.dom already declares the name, so an ambient
+// declaration cannot win:
+`+d.map(s=>{let p=l.resolve(s)?.module;return`//   import { ${s} } from '${p?a(p):""}';
+`}).join(""):"",R=e.filter(s=>"match"in s).length,D=R>0?`//
+// ${R} pattern rule${R===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 ${t} — do not edit.
+//
+// The components \`resolve\` supplies without an import. This describes what the
+// compiler already does; it does not enable it.
+`+k+D+(C.length>0?`
+${C.join(`
+`)}
+`:`
+`)+`
+declare global {
+${G.join(`
+`)}
+}
+`,declared:c,shadowedByDom:d,unavailable:m,patternRules:R}}var I="GENERATED by @fluixi/compiler",U="fluixi.d.ts";function H(e,n){let o;try{let t=b(h(e,"tsconfig.json"),"utf8");o=JSON.parse(t.replace(/^\s*\/\/.*$/gm,""))}catch{return}if(o.extends!==void 0)return;if(!Array.isArray(o.include))return!0;let r=A(e,n);return o.include.some(t=>{if(typeof t!="string")return!1;let a=t.replace(/[.+^${}()|[\]\\]/g,"\\$&").replace(/\*\*\//g,"(?:.*/)?").replace(/\*/g,"[^/]*");return new RegExp(`^${a}(?:/.*)?$`).test(r)})}function A(e,n){return N(e,n).split(T).join("/")}function J(e,n,o){if(!e.startsWith("/"))return e;let r=h(o,e.slice(1)),t=N(n,r).split(T).join("/");return t.startsWith(".")||(t=`./${t}`),t.replace(/\.(tsx|ts|jsx|mts|cts)$/,".js")}function q(e){try{let n=JSON.parse(b(h(e,"package.json"),"utf8"));return[...Object.keys(n.dependencies??{}),...Object.keys(n.devDependencies??{}),...Object.keys(n.peerDependencies??{})]}catch{return}}function se(e,n){if(e.globals===!1)return{status:"skipped",reason:"disabled"};let o=e.resolve??[],r=h(n,e.globals??U),t;try{t=b(r,"utf8")}catch{t=void 0}if(t!==void 0&&!t.includes(I))return{status:"skipped",reason:"foreign-file",path:r};let{source:a,declared:i}=S(o,{available:q(n),specifier:l=>J(l,$(r),n)});return t===a?{status:"unchanged",path:r,declared:i.length,warning:j(n,r)}:(P($(r),{recursive:!0}),F(r,a),{status:"written",path:r,declared:i.length,warning:j(n,r)})}function j(e,n){if(H(e,n)!==!1)return;let o=A(e,n);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".`}export{U as DEFAULT_GLOBALS_PATH,se as writeComponentGlobals};