@tixxin/nuxt-theme-engine 0.0.1

package/dist/module.mjs

@@ -0,0 +1,897 @@
+import { promises } from 'node:fs';
+import { createRequire } from 'node:module';
+import { useNuxt, defineNuxtModule, createResolver, addImportsDir, addPlugin, addComponent, addTemplate, addTypeTemplate, extendPages, logger } from '@nuxt/kit';
+import 'node:child_process';
+import 'node:path';
+import 'node:process';
+import 'node:stream';
+import 'node:readline';
+import { resolve, relative, extname, dirname, join } from 'pathe';
+import fg from 'fast-glob';
+import { z } from 'zod';
+
+//#region \0rolldown/runtime.js
+var l = (e, t) => () => (t || e((t = { exports: {} }).exports, t), t.exports);
+var u = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region node_modules/isexe/windows.js
+var _ = /* @__PURE__ */ l(((e, t) => {
+	t.exports = a;
+	a.sync = o;
+	var n = u("fs");
+	function r(e, t) {
+		var n = t.pathExt !== void 0 ? t.pathExt : process.env.PATHEXT;
+		if (!n) return true;
+		n = n.split(";");
+		if (n.indexOf("") !== -1) return true;
+		for (var r = 0; r < n.length; r++) {
+			var i = n[r].toLowerCase();
+			if (i && e.substr(-i.length).toLowerCase() === i) return true;
+		}
+		return false;
+	}
+	function i(e, t, n) {
+		if (!e.isSymbolicLink() && !e.isFile()) return false;
+		return r(t, n);
+	}
+	function a(e, t, r) {
+		n.stat(e, function(n, a) {
+			r(n, n ? false : i(a, e, t));
+		});
+	}
+	function o(e, t) {
+		return i(n.statSync(e), e, t);
+	}
+}));
+//#endregion
+//#region node_modules/isexe/mode.js
+var v = /* @__PURE__ */ l(((e, t) => {
+	t.exports = r;
+	r.sync = i;
+	var n = u("fs");
+	function r(e, t, r) {
+		n.stat(e, function(e, n) {
+			r(e, e ? false : a(n, t));
+		});
+	}
+	function i(e, t) {
+		return a(n.statSync(e), t);
+	}
+	function a(e, t) {
+		return e.isFile() && o(e, t);
+	}
+	function o(e, t) {
+		var n = e.mode;
+		var r = e.uid;
+		var i = e.gid;
+		var a = t.uid !== void 0 ? t.uid : process.getuid && process.getuid();
+		var o = t.gid !== void 0 ? t.gid : process.getgid && process.getgid();
+		var s = parseInt("100", 8);
+		var c = parseInt("010", 8);
+		var l = parseInt("001", 8);
+		var u = s | c;
+		return n & l || n & c && i === o || n & s && r === a || n & u && a === 0;
+	}
+}));
+//#endregion
+//#region node_modules/isexe/index.js
+var y = /* @__PURE__ */ l(((e, t) => {
+	u("fs");
+	var n;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) n = _();
+	else n = v();
+	t.exports = r;
+	r.sync = i;
+	function r(e, t, i) {
+		if (typeof t === "function") {
+			i = t;
+			t = {};
+		}
+		if (!i) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(n, i) {
+				r(e, t || {}, function(e, t) {
+					if (e) i(e);
+					else n(t);
+				});
+			});
+		}
+		n(e, t || {}, function(e, n) {
+			if (e) {
+				if (e.code === "EACCES" || t && t.ignoreErrors) {
+					e = null;
+					n = false;
+				}
+			}
+			i(e, n);
+		});
+	}
+	function i(e, t) {
+		try {
+			return n.sync(e, t || {});
+		} catch (e) {
+			if (t && t.ignoreErrors || e.code === "EACCES") return false;
+			else throw e;
+		}
+	}
+}));
+//#endregion
+//#region node_modules/which/which.js
+var b = /* @__PURE__ */ l(((e, t) => {
+	const n = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const r = u("path");
+	const i = n ? ";" : ":";
+	const a = y();
+	const o = (e) => Object.assign(/* @__PURE__ */ new Error(`not found: ${e}`), { code: "ENOENT" });
+	const s = (e, t) => {
+		const r = t.colon || i;
+		const a = e.match(/\//) || n && e.match(/\\/) ? [""] : [...n ? [process.cwd()] : [], ...(t.path || process.env.PATH || "").split(r)];
+		const o = n ? t.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const s = n ? o.split(r) : [""];
+		if (n) {
+			if (e.indexOf(".") !== -1 && s[0] !== "") s.unshift("");
+		}
+		return {
+			pathEnv: a,
+			pathExt: s,
+			pathExtExe: o
+		};
+	};
+	const c = (e, t, n) => {
+		if (typeof t === "function") {
+			n = t;
+			t = {};
+		}
+		if (!t) t = {};
+		const { pathEnv: i, pathExt: c, pathExtExe: l } = s(e, t);
+		const u = [];
+		const d = (n) => new Promise((a, s) => {
+			if (n === i.length) return t.all && u.length ? a(u) : s(o(e));
+			const c = i[n];
+			const l = /^".*"$/.test(c) ? c.slice(1, -1) : c;
+			const d = r.join(l, e);
+			a(f(!l && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d, n, 0));
+		});
+		const f = (e, n, r) => new Promise((i, o) => {
+			if (r === c.length) return i(d(n + 1));
+			const s = c[r];
+			a(e + s, { pathExt: l }, (a, o) => {
+				if (!a && o) if (t.all) u.push(e + s);
+				else return i(e + s);
+				return i(f(e, n, r + 1));
+			});
+		});
+		return n ? d(0).then((e) => n(null, e), n) : d(0);
+	};
+	const l = (e, t) => {
+		t = t || {};
+		const { pathEnv: n, pathExt: i, pathExtExe: c } = s(e, t);
+		const l = [];
+		for (let o = 0; o < n.length; o++) {
+			const s = n[o];
+			const u = /^".*"$/.test(s) ? s.slice(1, -1) : s;
+			const d = r.join(u, e);
+			const f = !u && /^\.[\\\/]/.test(e) ? e.slice(0, 2) + d : d;
+			for (let e = 0; e < i.length; e++) {
+				const n = f + i[e];
+				try {
+					if (a.sync(n, { pathExt: c })) if (t.all) l.push(n);
+					else return n;
+				} catch (e) {}
+			}
+		}
+		if (t.all && l.length) return l;
+		if (t.nothrow) return null;
+		throw o(e);
+	};
+	t.exports = c;
+	c.sync = l;
+}));
+//#endregion
+//#region node_modules/path-key/index.js
+var x = /* @__PURE__ */ l(((e, t) => {
+	const n = (e = {}) => {
+		const t = e.env || process.env;
+		if ((e.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(t).reverse().find((e) => e.toUpperCase() === "PATH") || "Path";
+	};
+	t.exports = n;
+	t.exports.default = n;
+}));
+//#endregion
+//#region node_modules/cross-spawn/lib/util/resolveCommand.js
+var S = /* @__PURE__ */ l(((e, t) => {
+	const n = u("path");
+	const r = b();
+	const i = x();
+	function a(e, t) {
+		const a = e.options.env || process.env;
+		const o = process.cwd();
+		const s = e.options.cwd != null;
+		const c = s && process.chdir !== void 0 && !process.chdir.disabled;
+		if (c) try {
+			process.chdir(e.options.cwd);
+		} catch (e) {}
+		let l;
+		try {
+			l = r.sync(e.command, {
+				path: a[i({ env: a })],
+				pathExt: t ? n.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (c) process.chdir(o);
+		}
+		if (l) l = n.resolve(s ? e.options.cwd : "", l);
+		return l;
+	}
+	function o(e) {
+		return a(e) || a(e, true);
+	}
+	t.exports = o;
+}));
+//#endregion
+//#region node_modules/cross-spawn/lib/util/escape.js
+var C = /* @__PURE__ */ l(((e, t) => {
+	const n = /([()\][%!^"`<>&|;, *?])/g;
+	function r(e) {
+		e = e.replace(n, "^$1");
+		return e;
+	}
+	function i(e, t) {
+		e = `${e}`;
+		e = e.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		e = e.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		e = `"${e}"`;
+		e = e.replace(n, "^$1");
+		if (t) e = e.replace(n, "^$1");
+		return e;
+	}
+	t.exports.command = r;
+	t.exports.argument = i;
+}));
+//#endregion
+//#region node_modules/shebang-regex/index.js
+var w = /* @__PURE__ */ l(((e, t) => {
+	t.exports = /^#!(.*)/;
+}));
+//#endregion
+//#region node_modules/shebang-command/index.js
+var T = /* @__PURE__ */ l(((e, t) => {
+	const n = w();
+	t.exports = (e = "") => {
+		const t = e.match(n);
+		if (!t) return null;
+		const [r, i] = t[0].replace(/#! ?/, "").split(" ");
+		const a = r.split("/").pop();
+		if (a === "env") return i;
+		return i ? `${a} ${i}` : a;
+	};
+}));
+//#endregion
+//#region node_modules/cross-spawn/lib/util/readShebang.js
+var E = /* @__PURE__ */ l(((e, t) => {
+	const n = u("fs");
+	const r = T();
+	function i(e) {
+		const t = 150;
+		const i = Buffer.alloc(t);
+		let a;
+		try {
+			a = n.openSync(e, "r");
+			n.readSync(a, i, 0, t, 0);
+			n.closeSync(a);
+		} catch (e) {}
+		return r(i.toString());
+	}
+	t.exports = i;
+}));
+//#endregion
+//#region node_modules/cross-spawn/lib/parse.js
+var D = /* @__PURE__ */ l(((e, t) => {
+	const n = u("path");
+	const r = S();
+	const i = C();
+	const a = E();
+	const o = process.platform === "win32";
+	const s = /\.(?:com|exe)$/i;
+	const c = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function l(e) {
+		e.file = r(e);
+		const t = e.file && a(e.file);
+		if (t) {
+			e.args.unshift(e.file);
+			e.command = t;
+			return r(e);
+		}
+		return e.file;
+	}
+	function d(e) {
+		if (!o) return e;
+		const t = l(e);
+		const r = !s.test(t);
+		if (e.options.forceShell || r) {
+			const r = c.test(t);
+			e.command = n.normalize(e.command);
+			e.command = i.command(e.command);
+			e.args = e.args.map((e) => i.argument(e, r));
+			e.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[e.command].concat(e.args).join(" ")}"`
+			];
+			e.command = process.env.comspec || "cmd.exe";
+			e.options.windowsVerbatimArguments = true;
+		}
+		return e;
+	}
+	function f(e, t, n) {
+		if (t && !Array.isArray(t)) {
+			n = t;
+			t = null;
+		}
+		t = t ? t.slice(0) : [];
+		n = Object.assign({}, n);
+		const r = {
+			command: e,
+			args: t,
+			options: n,
+			file: void 0,
+			original: {
+				command: e,
+				args: t
+			}
+		};
+		return n.shell ? r : d(r);
+	}
+	t.exports = f;
+}));
+//#endregion
+//#region node_modules/cross-spawn/lib/enoent.js
+var O = /* @__PURE__ */ l(((e, t) => {
+	const n = process.platform === "win32";
+	function r(e, t) {
+		return Object.assign(/* @__PURE__ */ new Error(`${t} ${e.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${t} ${e.command}`,
+			path: e.command,
+			spawnargs: e.args
+		});
+	}
+	function i(e, t) {
+		if (!n) return;
+		const r = e.emit;
+		e.emit = function(n, i) {
+			if (n === "exit") {
+				const n = a(i, t);
+				if (n) return r.call(e, "error", n);
+			}
+			return r.apply(e, arguments);
+		};
+	}
+	function a(e, t) {
+		if (n && e === 1 && !t.file) return r(t.original, "spawn");
+		return null;
+	}
+	function o(e, t) {
+		if (n && e === 1 && !t.file) return r(t.original, "spawnSync");
+		return null;
+	}
+	t.exports = {
+		hookChildProcess: i,
+		verifyENOENT: a,
+		verifyENOENTSync: o,
+		notFoundError: r
+	};
+}));
+//#endregion
+//#region node_modules/cross-spawn/index.js
+var k = /* @__PURE__ */ l(((e, t) => {
+	const n = u("child_process");
+	const r = D();
+	const i = O();
+	function a(e, t, a) {
+		const o = r(e, t, a);
+		const s = n.spawn(o.command, o.args, o.options);
+		i.hookChildProcess(s, o);
+		return s;
+	}
+	function o(e, t, a) {
+		const o = r(e, t, a);
+		const s = n.spawnSync(o.command, o.args, o.options);
+		s.error = s.error || i.verifyENOENTSync(s.status, o);
+		return s;
+	}
+	t.exports = a;
+	t.exports.spawn = a;
+	t.exports.sync = o;
+	t.exports._parse = r;
+	t.exports._enoent = i;
+}));
+//#endregion
+//#region src/non-zero-exit-error.ts
+k();
+
+function addCustomTab(tab, nuxt = useNuxt()) {
+  nuxt.hook("devtools:customTabs", async (tabs) => {
+    if (typeof tab === "function")
+      tab = await tab();
+    tabs.push(tab);
+  });
+}
+
+function extractThemeScopedCss(css, themeName) {
+  const selectors = [
+    new RegExp(`\\[data-theme=["']${themeName}["']\\][^{]*\\{([\\s\\S]*?)\\}`, "g"),
+    new RegExp(`\\.dark\\s+\\[data-theme=["']${themeName}["']\\][^{]*\\{([\\s\\S]*?)\\}`, "g")
+  ];
+  return selectors.flatMap((pattern) => {
+    return Array.from(css.matchAll(pattern)).map((match) => match[1] ?? "");
+  });
+}
+function extractCssVars(css) {
+  return Array.from(css.matchAll(/(--theme-[a-zA-Z0-9-_]+)\s*:/g)).map((match) => match[1]).filter((value) => Boolean(value));
+}
+async function checkCssVars(rootDir, themes, requiredCssVars) {
+  if (requiredCssVars.length === 0) {
+    return [];
+  }
+  const cssFiles = await fg([
+    ".nuxt/dist/client/**/*.css",
+    ".output/public/_nuxt/**/*.css"
+  ], {
+    cwd: rootDir,
+    absolute: true,
+    onlyFiles: true
+  });
+  if (cssFiles.length === 0) {
+    return Promise.all(themes.map(async (theme) => {
+      const sourceCss = await Promise.all(theme.cssFiles.map((file) => promises.readFile(resolve(file), "utf8")));
+      const provided = Array.from(new Set(extractCssVars(sourceCss.join("\n")))).sort();
+      return {
+        theme: theme.name,
+        provided,
+        missing: requiredCssVars.filter((variable) => !provided.includes(variable))
+      };
+    }));
+  }
+  const cssChunks = await Promise.all(cssFiles.map((file) => promises.readFile(resolve(file), "utf8")));
+  const joinedCss = cssChunks.join("\n");
+  return themes.map((theme) => {
+    const scopedBlocks = extractThemeScopedCss(joinedCss, theme.name).join("\n");
+    const provided = Array.from(new Set(extractCssVars(scopedBlocks))).sort();
+    const missing = requiredCssVars.filter((variable) => !provided.includes(variable));
+    return {
+      theme: theme.name,
+      provided,
+      missing
+    };
+  });
+}
+
+function parseContractNames(source) {
+  const match = source.match(/themeContractNames\s*=\s*\[([\s\S]*?)\]\s*as const/);
+  if (!match) {
+    return [];
+  }
+  const contractListSource = match[1] ?? "";
+  return Array.from(contractListSource.matchAll(/['"`]([^'"`]+)['"`]/g)).map((result) => result[1]).filter((name) => Boolean(name));
+}
+async function generateThemeComponentDts(contractsSourcePath, contractsImportId) {
+  const source = await promises.readFile(contractsSourcePath, "utf8");
+  const names = parseContractNames(source);
+  const union = names.length > 0 ? names.map((name) => `'${name}'`).join(" | ") : "never";
+  return `import type { DefineComponent } from 'vue'
+import type { ThemeComponentContracts } from ${JSON.stringify(contractsImportId)}
+
+declare module '#build/theme-engine.contracts.mjs' {
+  export const themeEngineContracts: {
+    entry: string
+    importId: string
+  }
+
+  export type GeneratedThemeComponentName = ${union}
+  export type GeneratedThemeComponentContracts = ThemeComponentContracts
+  export type ThemeComponentDiscriminatedProps = {
+    [K in keyof ThemeComponentContracts]: { name: K } & ThemeComponentContracts[K]
+  }[keyof ThemeComponentContracts]
+}
+
+type ThemeComponentDiscriminatedProps = import('#build/theme-engine.contracts.mjs').ThemeComponentDiscriminatedProps
+declare const ThemeComponent: DefineComponent<ThemeComponentDiscriminatedProps>
+
+declare module 'vue' {
+  export interface GlobalComponents {
+    ThemeComponent: typeof ThemeComponent
+  }
+}
+
+export {}
+`;
+}
+
+const COMPONENT_GLOB = "**/*.{vue,js,ts,tsx}";
+function toPascalCase(segment) {
+  return segment.replace(/\.[^.]+$/, "").split(/[^a-zA-Z0-9]+/).filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function toComponentName(relativePath) {
+  return relativePath.split(/[\\/]/).map((segment) => toPascalCase(segment.replace(extname(segment), ""))).join("");
+}
+function toThemePrefix(themeName) {
+  return themeName.split(/[^a-zA-Z0-9]+/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1)).join("");
+}
+function toImportPath(buildDir, filePath) {
+  const relativePath = relative(buildDir, filePath).replace(/\\/g, "/");
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+async function scanThemeComponentSources(theme) {
+  try {
+    await promises.access(theme.componentsDir);
+  } catch {
+    return [];
+  }
+  const files = await fg(COMPONENT_GLOB, {
+    cwd: theme.componentsDir,
+    absolute: true,
+    onlyFiles: true
+  });
+  return files.map((filePath) => {
+    const relativePath = relative(theme.componentsDir, filePath);
+    return {
+      logicalName: toComponentName(relativePath),
+      filePath,
+      relativePath,
+      ownerTheme: theme.name
+    };
+  });
+}
+async function generateThemeRegistry(themes, buildDir) {
+  new Map(themes.map((theme) => [theme.name, theme]));
+  const componentSourcesByTheme = /* @__PURE__ */ new Map();
+  for (const theme of themes) {
+    const sources = await scanThemeComponentSources(theme);
+    componentSourcesByTheme.set(
+      theme.name,
+      new Map(sources.map((source) => [source.logicalName, source]))
+    );
+  }
+  const registry = {
+    themes: {},
+    uniqueAliases: []
+  };
+  const seenAliases = /* @__PURE__ */ new Set();
+  for (const theme of themes) {
+    const entries = {};
+    for (const themeName of theme.inheritanceChain) {
+      const sourceMap = componentSourcesByTheme.get(themeName);
+      if (!sourceMap) {
+        continue;
+      }
+      for (const [logicalName, source] of sourceMap.entries()) {
+        if (entries[logicalName]) {
+          continue;
+        }
+        const entry = {
+          logicalName,
+          alias: `${toThemePrefix(theme.name)}${logicalName}`,
+          theme: theme.name,
+          sourceTheme: source.ownerTheme,
+          filePath: source.filePath,
+          importPath: toImportPath(buildDir, source.filePath)
+        };
+        entries[logicalName] = entry;
+        if (!seenAliases.has(entry.alias)) {
+          seenAliases.add(entry.alias);
+          registry.uniqueAliases.push(entry);
+        }
+      }
+    }
+    registry.themes[theme.name] = entries;
+  }
+  registry.uniqueAliases.sort((left, right) => left.alias.localeCompare(right.alias));
+  return registry;
+}
+
+const themeJsonSchema = z.object({
+  name: z.string().min(1).regex(/^[a-z0-9-]+$/),
+  extends: z.string().min(1).regex(/^[a-z0-9-]+$/).optional(),
+  label: z.string().min(1).optional(),
+  description: z.string().min(1).optional()
+});
+async function fileExists(path) {
+  try {
+    await promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function detectCycles(themesByName) {
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  const visit = (themeName) => {
+    if (visited.has(themeName)) {
+      return;
+    }
+    if (visiting.has(themeName)) {
+      throw new Error(`Detected circular theme inheritance involving "${themeName}".`);
+    }
+    visiting.add(themeName);
+    const theme = themesByName.get(themeName);
+    if (!theme) {
+      throw new Error(`Theme "${themeName}" is missing from the resolved theme map.`);
+    }
+    if (theme.extends) {
+      if (!themesByName.has(theme.extends)) {
+        throw new Error(`Theme "${themeName}" extends missing parent theme "${theme.extends}".`);
+      }
+      visit(theme.extends);
+    }
+    visiting.delete(themeName);
+    visited.add(themeName);
+  };
+  for (const themeName of themesByName.keys()) {
+    visit(themeName);
+  }
+}
+function resolveInheritanceChain(themeName, themesByName) {
+  const chain = [];
+  let cursor = themesByName.get(themeName);
+  while (cursor) {
+    chain.push(cursor.name);
+    cursor = cursor.extends ? themesByName.get(cursor.extends) : void 0;
+  }
+  return chain;
+}
+async function loadThemeDefinitions(themesDir) {
+  const themeJsonFiles = await fg("*/theme.json", {
+    cwd: themesDir,
+    absolute: true,
+    onlyFiles: true
+  });
+  const themes = await Promise.all(themeJsonFiles.map(async (themeJsonPath) => {
+    const raw = await promises.readFile(themeJsonPath, "utf8");
+    const json = themeJsonSchema.parse(JSON.parse(raw));
+    const themePath = dirname(themeJsonPath);
+    const componentsDir = join(themePath, "app/components");
+    const assetsDir = join(themePath, "app/assets");
+    const cssFiles = await fileExists(assetsDir) ? await fg("**/*.{css,scss,sass,less,pcss}", {
+      cwd: assetsDir,
+      absolute: true,
+      onlyFiles: true
+    }) : [];
+    return {
+      name: json.name,
+      label: json.label ?? json.name,
+      description: json.description,
+      extends: json.extends,
+      path: themePath,
+      themeJsonPath,
+      componentsDir,
+      assetsDir,
+      cssFiles,
+      inheritanceChain: []
+    };
+  }));
+  const themesByName = new Map(themes.map((theme) => [theme.name, theme]));
+  detectCycles(themesByName);
+  const resolvedThemes = await Promise.all(themes.map(async (theme) => {
+    if (!await fileExists(theme.componentsDir)) {
+      return {
+        ...theme,
+        inheritanceChain: resolveInheritanceChain(theme.name, themesByName)
+      };
+    }
+    return {
+      ...theme,
+      inheritanceChain: resolveInheritanceChain(theme.name, themesByName)
+    };
+  }));
+  return resolvedThemes.sort((left, right) => left.name.localeCompare(right.name));
+}
+
+const DEFAULTS = {
+  themesDir: "themes",
+  defaultTheme: "base",
+  cookieKey: "theme-pref",
+  lazyLoadThemes: false,
+  requiredCssVars: [],
+  contractsEntry: "@tixxin/theme-contracts",
+  contractsImportId: "@tixxin/theme-contracts"
+};
+const require$1 = createRequire(import.meta.url);
+async function pathExists(path) {
+  try {
+    await promises.access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function isLocalSpecifier(specifier) {
+  return specifier.startsWith(".") || specifier.startsWith("/") || specifier.startsWith("~") || /^[A-Za-z]:[\\/]/.test(specifier);
+}
+async function resolveContractsEntry(entry, importId, rootDir, moduleRoot, aliases) {
+  const internalDefaultEntry = resolve(moduleRoot, "packages/theme-contracts/src/index.ts");
+  if ((entry === "@tixxin/theme-contracts" || entry === "packages/theme-contracts/src/index.ts") && await pathExists(internalDefaultEntry)) {
+    return internalDefaultEntry;
+  }
+  const aliasTarget = aliases[entry] ?? aliases[importId];
+  if (typeof aliasTarget === "string") {
+    return isLocalSpecifier(aliasTarget) ? resolve(rootDir, aliasTarget) : aliasTarget;
+  }
+  if (isLocalSpecifier(entry)) {
+    return resolve(rootDir, entry);
+  }
+  return require$1.resolve(entry, {
+    paths: [rootDir, moduleRoot]
+  });
+}
+function serializeRegistry(registry) {
+  const registryShape = Object.fromEntries(
+    Object.entries(registry.themes).map(([themeName, entries]) => {
+      return [themeName, Object.fromEntries(
+        Object.entries(entries).map(([logicalName, entry]) => {
+          return [logicalName, {
+            alias: entry.alias,
+            sourceTheme: entry.sourceTheme
+          }];
+        })
+      )];
+    })
+  );
+  const loaderEntries = registry.uniqueAliases.map((entry, index) => ({
+    constName: `loader_${index}`,
+    entry
+  }));
+  const loaderDefinitions = loaderEntries.map((item) => `const ${item.constName} = () => import(${JSON.stringify(item.entry.importPath)})`).join("\n");
+  const loaderLookup = new Map(loaderEntries.map((item) => [`${item.entry.theme}:${item.entry.logicalName}`, item.constName]));
+  const loaderObject = Object.entries(registry.themes).map(([themeName, entries]) => {
+    const entrySource = Object.keys(entries).map((logicalName) => {
+      const loaderName = loaderLookup.get(`${themeName}:${logicalName}`);
+      return `${JSON.stringify(logicalName)}: ${loaderName}`;
+    }).join(",\n      ");
+    return `${JSON.stringify(themeName)}: {
+      ${entrySource}
+    }`;
+  }).join(",\n  ");
+  return `${loaderDefinitions}
+
+export const themeComponentRegistry = ${JSON.stringify(registryShape, null, 2)}
+
+export const themeComponentLoaders = {
+  ${loaderObject}
+}
+`;
+}
+function serializeOptions(options, themes) {
+  const serializedThemes = themes.map((theme) => ({
+    name: theme.name,
+    label: theme.label,
+    extends: theme.extends ?? null,
+    inheritanceChain: theme.inheritanceChain
+  }));
+  return `export const themeEngineOptions = ${JSON.stringify(options, null, 2)}
+export const themeEngineThemeNames = ${JSON.stringify(themes.map((theme) => theme.name), null, 2)}
+export const themeEngineThemes = ${JSON.stringify(serializedThemes, null, 2)}
+`;
+}
+function serializeCssReport(report) {
+  return `export const themeCssVariableReport = ${JSON.stringify(report, null, 2)}
+`;
+}
+function serializeContracts(entry, importId) {
+  return `export const themeEngineContracts = ${JSON.stringify({
+    entry,
+    importId
+  }, null, 2)}
+`;
+}
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "@tixxin/nuxt-theme-engine",
+    configKey: "themeEngine",
+    compatibility: {
+      nuxt: ">=4.0.0"
+    }
+  },
+  defaults: DEFAULTS,
+  async setup(moduleOptions, nuxt) {
+    const resolver = createResolver(import.meta.url);
+    const moduleRoot = resolver.resolve("..");
+    const options = {
+      ...DEFAULTS,
+      ...moduleOptions
+    };
+    const themesDir = resolve(nuxt.options.rootDir, options.themesDir);
+    const contractsImportId = options.contractsImportId;
+    const contractsEntry = await resolveContractsEntry(
+      options.contractsEntry,
+      contractsImportId,
+      nuxt.options.rootDir,
+      moduleRoot,
+      nuxt.options.alias
+    );
+    const themes = await loadThemeDefinitions(themesDir);
+    const defaultTheme = themes.some((theme) => theme.name === options.defaultTheme) ? options.defaultTheme : themes[0]?.name ?? options.defaultTheme;
+    const resolvedOptions = {
+      ...options,
+      contractsEntry,
+      contractsImportId,
+      defaultTheme,
+      lazyLoadThemes: options.lazyLoadThemes && !nuxt.options.dev
+    };
+    const registry = await generateThemeRegistry(themes, nuxt.options.buildDir);
+    if (!nuxt.options.alias[contractsImportId]) {
+      nuxt.options.alias[contractsImportId] = contractsEntry;
+    }
+    addImportsDir(resolver.resolve("./runtime/composables"));
+    addPlugin(resolver.resolve("./runtime/plugins/theme-sync.client"));
+    addComponent({
+      name: "ThemeComponent",
+      filePath: resolver.resolve("./runtime/components/ThemeComponent.vue")
+    });
+    if (!resolvedOptions.lazyLoadThemes) {
+      for (const entry of registry.uniqueAliases) {
+        addComponent({
+          name: entry.alias,
+          filePath: entry.filePath
+        });
+      }
+    }
+    for (const theme of themes) {
+      for (const cssFile of theme.cssFiles) {
+        if (!nuxt.options.css.includes(cssFile)) {
+          nuxt.options.css.push(cssFile);
+        }
+      }
+    }
+    addTemplate({
+      filename: "theme-engine.options.mjs",
+      getContents: () => serializeOptions(resolvedOptions, themes)
+    });
+    addTemplate({
+      filename: "theme-engine.registry.mjs",
+      getContents: () => serializeRegistry(registry)
+    });
+    addTemplate({
+      filename: "theme-engine.contracts.mjs",
+      getContents: () => serializeContracts(contractsEntry, contractsImportId)
+    });
+    const cssReportTemplate = addTemplate({
+      filename: "theme-engine.css-report.mjs",
+      getContents: () => serializeCssReport([])
+    });
+    addTypeTemplate({
+      filename: "types/theme-components.d.ts",
+      getContents: () => generateThemeComponentDts(contractsEntry, contractsImportId)
+    });
+    extendPages((pages) => {
+      pages.push({
+        name: "theme-engine-devtools",
+        path: "/_theme-engine-devtools",
+        file: resolver.resolve("./runtime/devtools/page.vue")
+      });
+    });
+    addCustomTab({
+      name: "theme-engine",
+      title: "Theme Engine",
+      icon: "carbon:paint-brush",
+      category: "modules",
+      view: {
+        type: "iframe",
+        src: "/_theme-engine-devtools"
+      }
+    }, nuxt);
+    nuxt.hook("close", async () => {
+      const report = await checkCssVars(nuxt.options.rootDir, themes, resolvedOptions.requiredCssVars);
+      await promises.writeFile(cssReportTemplate.dst, serializeCssReport(report), "utf8");
+      for (const item of report.filter((entry) => entry.missing.length > 0)) {
+        logger.warn(`Theme "${item.theme}" is missing required CSS variables: ${item.missing.join(", ")}`);
+      }
+    });
+  }
+});
+
+export { module$1 as default };