@animus-ui/next-plugin 0.1.0-next.30

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type { AnimusNextOptions } from './types';
+export { withAnimus } from './with-animus';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AACjD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC"}

package/dist/index.mjs

@@ -0,0 +1,386 @@
+import { a as setManifestJson, i as setAnalysisPromise, o as __require, r as resetAnalysisPromise, t as getAnalysisPromise } from "./singleton-BZ7W87Ir.mjs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "fs";
+import { extname, join, relative, resolve } from "path";
+import { createHash } from "crypto";
+import { tmpdir } from "os";
+import { applyPrefix, applyUnitFallback, detectRuntime, execSubprocess, extractSystemFilePackages, resolveGlobalStyles } from "@animus-ui/extract/pipeline";
+//#region src/plugin.ts
+const PLUGIN_NAME = "AnimusWebpackPlugin";
+var AnimusWebpackPlugin = class {
+	options;
+	rootDir = null;
+	configJson = "";
+	groupRegistryJson = "";
+	themeJson = "";
+	variableMapJson = "";
+	variableCss = "";
+	contextualVarsJson = null;
+	globalCss = "";
+	systemResolveScript = null;
+	fileCache = /* @__PURE__ */ new Map();
+	lastCssHash = null;
+	constructor(options) {
+		this.options = options;
+	}
+	initialized = false;
+	apply(compiler) {
+		compiler.hooks.run.tapPromise(PLUGIN_NAME, async (_compiler) => {
+			this.rootDir = _compiler.context;
+			const existing = getAnalysisPromise();
+			if (existing) {
+				await existing;
+				return;
+			}
+			const promise = this.runFullPipeline();
+			setAnalysisPromise(promise);
+			await promise;
+		});
+		compiler.hooks.watchRun.tapPromise(PLUGIN_NAME, async (_compiler) => {
+			this.rootDir = _compiler.context;
+			if (!this.initialized) {
+				const existing = getAnalysisPromise();
+				if (existing) {
+					await existing;
+					this.initialized = true;
+					return;
+				}
+				const promise = this.runFullPipeline();
+				setAnalysisPromise(promise);
+				await promise;
+				this.initialized = true;
+				return;
+			}
+			await this.handleWatchUpdate();
+		});
+	}
+	async handleWatchUpdate() {
+		const rootDir = this.rootDir;
+		const resolvedSystemPath = resolve(rootDir, this.options.system);
+		try {
+			const systemSource = readFileSync(resolvedSystemPath, "utf-8");
+			const systemRelPath = relative(rootDir, resolvedSystemPath);
+			const cached = this.fileCache.get(systemRelPath);
+			const currentHash = createHash("md5").update(systemSource).digest("hex");
+			if (cached && cached.hash !== currentHash) {
+				this.resetForHmr();
+				this.initialized = false;
+				const promise = this.runFullPipeline();
+				setAnalysisPromise(promise);
+				await promise;
+				this.initialized = true;
+				return;
+			}
+		} catch {}
+		const excludePatterns = this.options.exclude ?? [
+			"node_modules",
+			"dist",
+			".test.",
+			".spec.",
+			".next",
+			".animus"
+		];
+		const files = this.discoverFiles(rootDir, rootDir, excludePatterns);
+		let hasChanges = false;
+		for (const filePath of files) {
+			const relPath = relative(rootDir, filePath);
+			const cached = this.fileCache.get(relPath);
+			const source = readFileSync(filePath, "utf-8");
+			const hash = createHash("md5").update(source).digest("hex");
+			if (!cached || cached.hash !== hash) {
+				hasChanges = true;
+				this.fileCache.set(relPath, {
+					hash,
+					source
+				});
+			}
+		}
+		if (hasChanges) {
+			resetAnalysisPromise();
+			const promise = this.runFullPipeline();
+			setAnalysisPromise(promise);
+			await promise;
+		}
+	}
+	async runFullPipeline() {
+		const rootDir = this.rootDir;
+		const resolvedSystemPath = resolve(rootDir, this.options.system);
+		this.loadSystem(rootDir, resolvedSystemPath);
+		const excludePatterns = this.options.exclude ?? [
+			"node_modules",
+			"dist",
+			".test.",
+			".spec.",
+			".next",
+			".animus"
+		];
+		const files = this.discoverFiles(rootDir, rootDir, excludePatterns);
+		const fileEntries = [];
+		for (const filePath of files) {
+			const source = readFileSync(filePath, "utf-8");
+			const relPath = relative(rootDir, filePath);
+			const hash = createHash("md5").update(source).digest("hex");
+			this.fileCache.set(relPath, {
+				hash,
+				source
+			});
+			fileEntries.push({
+				path: relPath,
+				source,
+				hash
+			});
+		}
+		const packageNames = extractSystemFilePackages(resolvedSystemPath);
+		const packageMap = this.resolvePackagesByName(rootDir, packageNames);
+		const { analyzeProject } = __require("@animus-ui/extract");
+		const animusDirPath = join(rootDir, ".animus");
+		const emitterConfig = JSON.stringify({
+			runtime_import: "@animus-ui/system/runtime",
+			css_module_id: ".animus/styles.css",
+			system_props_module_id: join(animusDirPath, "system-props.js")
+		});
+		const manifestJson = analyzeProject(JSON.stringify(fileEntries), this.themeJson, this.variableMapJson, this.contextualVarsJson || null, this.configJson, this.groupRegistryJson, JSON.stringify(packageMap), false, this.options.prefix || null, emitterConfig);
+		const manifest = JSON.parse(manifestJson);
+		let componentCss = manifest?.css || "";
+		if (this.systemResolveScript && componentCss.includes("__TRANSFORM__")) componentCss = this.resolveTransforms(rootDir, componentCss);
+		componentCss = applyUnitFallback(componentCss);
+		const parts = [];
+		if (this.variableCss) parts.push(this.variableCss);
+		if (this.globalCss) parts.push(this.globalCss);
+		if (componentCss) parts.push(componentCss);
+		const fullCss = parts.join("\n\n");
+		const cssHash = createHash("md5").update(fullCss).digest("hex");
+		if (cssHash !== this.lastCssHash) {
+			const animusDir = join(rootDir, ".animus");
+			if (!existsSync(animusDir)) mkdirSync(animusDir, { recursive: true });
+			writeFileSync(join(animusDir, "styles.css"), fullCss);
+			this.lastCssHash = cssHash;
+		}
+		const systemPropMap = JSON.stringify(manifest?.system_prop_map ?? {});
+		const dynamicProps = manifest?.dynamic_props ?? {};
+		const dynamicPropConfig = {};
+		for (const [propName, meta] of Object.entries(dynamicProps)) dynamicPropConfig[propName] = {
+			varName: meta.var_name,
+			slotClass: meta.slot_class,
+			...meta.transform_name ? { transformName: meta.transform_name } : {},
+			...meta.scale_values && Object.keys(meta.scale_values).length > 0 ? { scaleValues: meta.scale_values } : {}
+		};
+		let transformsSource = "{}";
+		if (this.systemResolveScript) try {
+			const resolvedSystemPath = resolve(rootDir, this.options.system);
+			const tmpOut = join(tmpdir(), `animus-transforms-${Date.now()}.json`);
+			execSubprocess(`const m = require(${JSON.stringify(resolvedSystemPath)});\nconst ds = m.ds || m.default || m.system;\nconst cfg = ds.toConfig();\nconst out = {};\nfor (const [name, fn] of Object.entries(cfg.transforms || {})) {\n  out[name] = fn.toString();\n}\nrequire('fs').writeFileSync(${JSON.stringify(tmpOut)}, JSON.stringify(out));\n`, rootDir);
+			const fnStrings = JSON.parse(readFileSync(tmpOut, "utf-8"));
+			try {
+				__require("fs").unlinkSync(tmpOut);
+			} catch {}
+			transformsSource = `{\n${Object.entries(fnStrings).map(([name, src]) => `  ${JSON.stringify(name)}: ${src}`).join(",\n")}\n}`;
+		} catch {}
+		const animusDir = join(rootDir, ".animus");
+		if (!existsSync(animusDir)) mkdirSync(animusDir, { recursive: true });
+		writeFileSync(join(animusDir, "system-props.js"), `export const systemPropMap = ${systemPropMap};\nexport const systemPropGroups = ${this.groupRegistryJson};\nexport const dynamicPropConfig = ${JSON.stringify(dynamicPropConfig)};\nexport const transforms = ${transformsSource};\n`);
+		setManifestJson(manifestJson);
+	}
+	loadSystem(rootDir, systemPath) {
+		const tmpOut = join(tmpdir(), `animus-system-${Date.now()}.json`);
+		execSubprocess(`const m = require(${JSON.stringify(systemPath)});\nconst ds = m.ds || m.default || m.system;\nif (!ds || !ds.toConfig) { throw new Error('Module does not export a SystemInstance with .serialize()'); }\nconst cfg = ds.toConfig();\nconst tokens = m.tokens || m.theme || null;\nconst serialized = tokens && typeof tokens.serialize === 'function' ? tokens.serialize() : null;\nconst globalStyleBlocks = {};\nfor (const [key, val] of Object.entries(m)) {\n  if (val && typeof val === 'object' && val.__brand === 'GlobalStyleBlock') {\n    globalStyleBlocks[key] = val.styles;\n  }\n}\nrequire('fs').writeFileSync(${JSON.stringify(tmpOut)}, JSON.stringify({\n  propConfig: cfg.propConfig,\n  groupRegistry: cfg.groupRegistry,\n  serialized: serialized,\n  transformNames: Object.keys(cfg.transforms || {}),\n  globalStyleBlocks: Object.keys(globalStyleBlocks).length > 0 ? globalStyleBlocks : null\n}));\n`, rootDir);
+		const result = readFileSync(tmpOut, "utf-8");
+		try {
+			__require("fs").unlinkSync(tmpOut);
+		} catch {}
+		const parsed = JSON.parse(result);
+		this.configJson = parsed.propConfig;
+		this.groupRegistryJson = parsed.groupRegistry;
+		if (parsed.serialized) {
+			this.themeJson = parsed.serialized.scalesJson;
+			this.variableMapJson = parsed.serialized.variableMapJson;
+			this.variableCss = parsed.serialized.variableCss;
+			this.contextualVarsJson = parsed.serialized.contextualVarsJson;
+			if (this.options.prefix) {
+				const prefixed = applyPrefix(this.options.prefix, this.variableMapJson, this.variableCss);
+				this.variableMapJson = prefixed.variableMapJson;
+				this.variableCss = prefixed.variableCss;
+			}
+		} else throw new Error("[animus-extract] Theme must be built with createTheme().build(). No .serialize() method found on tokens export.");
+		if (parsed.globalStyleBlocks) {
+			if (Object.keys(parsed.globalStyleBlocks).length > 0) try {
+				const flat = JSON.parse(this.themeJson);
+				const propConfig = JSON.parse(this.configJson);
+				const variableMap = {};
+				for (const [tokenPath, value] of Object.entries(flat)) if (typeof value === "string" && value.startsWith("var(") && value.endsWith(")")) variableMap[tokenPath] = value.slice(4, -1);
+				const gsResult = resolveGlobalStyles(parsed.globalStyleBlocks, propConfig, flat, variableMap, {});
+				const parts = Object.values(gsResult).filter(Boolean);
+				if (parts.length > 0) this.globalCss = `@layer global {\n${parts.join("\n\n")}\n}`;
+			} catch (e) {
+				const msg = e instanceof Error ? e.message : String(e);
+				if (this.options.strict) throw new Error(`[animus-extract] Global styles resolution failed: ${msg}`);
+				console.warn("[animus-extract] Global styles resolution failed:", msg);
+			}
+		}
+		if (parsed.transformNames && parsed.transformNames.length > 0) {
+			const tmpResolve = join(tmpdir(), `animus-transforms-resolve-${Date.now()}.js`);
+			writeFileSync(tmpResolve, `const m = require(${JSON.stringify(systemPath)});\nconst ds = m.ds || m.default || m.system;\nconst cfg = ds.toConfig();\nconst css = require('fs').readFileSync(process.argv[2], 'utf-8');\nconst resolved = css.replace(/__TRANSFORM__(\\w+)__(.+?)__/g, (_, name, rawValue) => {\n  const fn = cfg.transforms[name];\n  if (!fn) return rawValue;\n  const value = rawValue !== '' && !isNaN(Number(rawValue)) ? Number(rawValue) : rawValue;\n  const result = fn(value);\n  return typeof result === 'object' ? JSON.stringify(result) : String(result);\n});\nrequire('fs').writeFileSync(process.argv[3], resolved);\n`);
+			this.systemResolveScript = tmpResolve;
+		}
+	}
+	resolveTransforms(rootDir, css) {
+		const { execSync } = __require("child_process");
+		const ts = Date.now();
+		const tmpIn = join(tmpdir(), `animus-css-${ts}.css`);
+		const tmpOut = join(tmpdir(), `animus-css-${ts}.out.css`);
+		writeFileSync(tmpIn, css);
+		execSync(`${detectRuntime()} run "${this.systemResolveScript}" "${tmpIn}" "${tmpOut}"`, {
+			cwd: rootDir,
+			encoding: "utf-8"
+		});
+		const resolved = readFileSync(tmpOut, "utf-8");
+		try {
+			__require("fs").unlinkSync(tmpIn);
+			__require("fs").unlinkSync(tmpOut);
+		} catch {}
+		return resolved;
+	}
+	discoverFiles(dir, rootDir, excludePatterns) {
+		const results = [];
+		const extensions = new Set([
+			".ts",
+			".tsx",
+			".js",
+			".jsx"
+		]);
+		const walk = (currentDir) => {
+			let entries;
+			try {
+				entries = readdirSync(currentDir);
+			} catch {
+				return;
+			}
+			for (const entry of entries) {
+				const fullPath = join(currentDir, entry);
+				const relPath = relative(rootDir, fullPath);
+				if (excludePatterns.some((p) => relPath.includes(p))) continue;
+				let stat;
+				try {
+					stat = statSync(fullPath);
+				} catch {
+					continue;
+				}
+				if (stat.isDirectory()) walk(fullPath);
+				else if (extensions.has(extname(entry))) results.push(fullPath);
+			}
+		};
+		walk(dir);
+		return results;
+	}
+	resolvePackagesByName(rootDir, names) {
+		if (names.length === 0) return {};
+		const nameSet = new Set(names);
+		const packageMap = {};
+		try {
+			const workspaces = JSON.parse(readFileSync(join(rootDir, "package.json"), "utf-8")).workspaces || [];
+			for (const ws of workspaces) {
+				const wsDir = resolve(rootDir, ws);
+				if (!existsSync(wsDir)) continue;
+				try {
+					const pkg = JSON.parse(readFileSync(join(wsDir, "package.json"), "utf-8"));
+					const name = pkg.name || "";
+					if (nameSet.has(name)) {
+						const entryPath = resolve(wsDir, pkg.main || pkg.module || "index.ts");
+						if (existsSync(entryPath)) packageMap[name] = relative(rootDir, entryPath);
+					}
+				} catch {}
+			}
+		} catch {}
+		return packageMap;
+	}
+	/**
+	* Reset analysis state for HMR geological reset.
+	*/
+	resetForHmr() {
+		resetAnalysisPromise();
+		this.lastCssHash = null;
+		try {
+			const { clearAnalysisCache } = __require("@animus-ui/extract");
+			clearAnalysisCache();
+		} catch {}
+	}
+	/** Expose file cache for HMR change detection */
+	getFileCache() {
+		return this.fileCache;
+	}
+	/** Expose options for the loader */
+	getOptions() {
+		return this.options;
+	}
+};
+//#endregion
+//#region src/with-animus.ts
+let warnedGitignore = false;
+/**
+* Wrap a Next.js config to enable Animus static CSS extraction.
+*
+* ```ts
+* // next.config.ts
+* import { withAnimus } from '@animus-ui/next-plugin';
+* export default withAnimus({ system: './src/ds.ts' })({});
+* ```
+*/
+function withAnimus(options) {
+	if (!options.system) throw new Error("[animus-extract] Missing required option `system`. Provide the path to your SystemInstance module: withAnimus({ system: \"./src/ds.ts\" })");
+	return (nextConfig) => {
+		const existingWebpack = nextConfig.webpack;
+		return {
+			...nextConfig,
+			webpack(config, context) {
+				const rootDir = process.cwd();
+				const animusDir = join(rootDir, ".animus");
+				if (!existsSync(animusDir)) mkdirSync(animusDir, { recursive: true });
+				if (!warnedGitignore) {
+					warnedGitignore = true;
+					try {
+						const gitignorePath = join(rootDir, ".gitignore");
+						if (existsSync(gitignorePath)) {
+							if (!readFileSync(gitignorePath, "utf-8").includes(".animus")) console.warn("[animus-extract] Add `.animus/` to your .gitignore — it contains generated build artifacts.");
+						}
+					} catch {}
+				}
+				const plugin = new AnimusWebpackPlugin({
+					system: options.system,
+					exclude: options.exclude,
+					strict: options.strict,
+					verbose: options.verbose,
+					prefix: options.prefix
+				});
+				config.plugins = config.plugins || [];
+				config.plugins.push(plugin);
+				config.resolve = config.resolve || {};
+				config.resolve.alias = config.resolve.alias || {};
+				config.resolve.alias[".animus/styles.css"] = join(rootDir, ".animus", "styles.css");
+				const systemPropsPath = join(rootDir, ".animus", "system-props.js");
+				config.plugins.push({ apply(compiler) {
+					compiler.hooks.normalModuleFactory.tap("AnimusVirtualResolve", (nmf) => {
+						nmf.hooks.beforeResolve.tap("AnimusVirtualResolve", (resolveData) => {
+							if (resolveData.request === "virtual:animus/system-props") resolveData.request = systemPropsPath;
+						});
+					});
+				} });
+				const loaderPath = resolve(__dirname, "loader.mjs");
+				const actualLoaderPath = existsSync(loaderPath) ? loaderPath : resolve(__dirname, "loader.ts");
+				config.module = config.module || {};
+				config.module.rules = config.module.rules || [];
+				config.module.rules.push({
+					test: /\.(ts|tsx|js|jsx)$/,
+					exclude: /node_modules/,
+					enforce: "pre",
+					use: [{
+						loader: actualLoaderPath,
+						options: { strict: options.strict }
+					}]
+				});
+				if (typeof existingWebpack === "function") return existingWebpack(config, context);
+				return config;
+			}
+		};
+	};
+}
+//#endregion
+export { withAnimus };

package/dist/loader.d.ts

@@ -0,0 +1,20 @@
+type LoaderContext = {
+    resourcePath: string;
+    rootContext: string;
+    getOptions: () => {
+        strict?: boolean;
+    };
+};
+/**
+ * Webpack loader for Animus source transformation.
+ * Runs with enforce: 'pre' to see original source before Babel/SWC.
+ * Replaces builder chains with createComponent() calls using the pre-built manifest.
+ *
+ * CSS handling: the Rust emitter injects `import '.animus/styles.css'` into every
+ * file with extracted components. Without intervention, webpack duplicates the full
+ * stylesheet into every route chunk. This loader strips those imports and re-injects
+ * a single CSS import in the root layout/app file, ensuring one copy for the whole app.
+ */
+export default function animusLoader(this: LoaderContext, source: string): string;
+export {};
+//# sourceMappingURL=loader.d.ts.map

package/dist/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../src/loader.ts"],"names":[],"mappings":"AAIA,KAAK,aAAa,GAAG;IACnB,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM;QAAE,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACxC,CAAC;AAoBF;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,YAAY,CAClC,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,MAAM,GACb,MAAM,CAwCR"}

package/dist/loader.mjs

@@ -0,0 +1,53 @@
+import { n as getManifestJson, o as __require } from "./singleton-BZ7W87Ir.mjs";
+import { relative } from "path";
+//#region src/loader.ts
+/**
+* Regex matching CSS import lines injected by the Rust emitter.
+* Catches both the alias form (`import '.animus/styles.css'`) and
+* relative forms (`import '../.animus/styles.css'`).
+*/
+const CSS_IMPORT_RE = /import\s+['"][^'"]*\.animus\/styles\.css['"];\n?/g;
+/**
+* Root entry file patterns. CSS is imported ONLY here to prevent
+* per-chunk duplication in Next.js builds.
+*
+* - App Router: `app/layout.tsx` (root layout wraps all routes)
+* - Pages Router: `pages/_app.tsx` (custom App wraps all pages)
+*
+* The `(src\/)?` prefix handles projects that use a `src/` directory.
+*/
+const ROOT_ENTRY_RE = /^(src\/)?(?:app\/layout|pages\/_app)\.[tj]sx?$/;
+/**
+* Webpack loader for Animus source transformation.
+* Runs with enforce: 'pre' to see original source before Babel/SWC.
+* Replaces builder chains with createComponent() calls using the pre-built manifest.
+*
+* CSS handling: the Rust emitter injects `import '.animus/styles.css'` into every
+* file with extracted components. Without intervention, webpack duplicates the full
+* stylesheet into every route chunk. This loader strips those imports and re-injects
+* a single CSS import in the root layout/app file, ensuring one copy for the whole app.
+*/
+function animusLoader(source) {
+	const manifestJson = getManifestJson();
+	if (!manifestJson) return source;
+	const filename = relative(this.rootContext, this.resourcePath);
+	const isRootEntry = ROOT_ENTRY_RE.test(filename);
+	try {
+		const { transformFile } = __require("@animus-ui/extract");
+		const result = transformFile(source, filename, manifestJson);
+		let code = result.hasComponents ? result.code : source;
+		code = code.replace(CSS_IMPORT_RE, "");
+		if (isRootEntry && !code.includes(".animus/styles.css")) if (code.startsWith("'use client'") || code.startsWith("\"use client\"")) {
+			const nl = code.indexOf("\n");
+			code = `${code.slice(0, nl + 1)}import '.animus/styles.css';\n${code.slice(nl + 1)}`;
+		} else code = `import '.animus/styles.css';\n${code}`;
+		return code;
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : String(e);
+		if ((this.getOptions?.() ?? {}).strict) throw new Error(`[animus-extract] Transform failed for ${filename}: ${msg}`);
+		console.warn(`[animus-extract] Transform failed for ${filename}:`, msg);
+		return source;
+	}
+}
+//#endregion
+export { animusLoader as default };

package/dist/plugin.d.ts

@@ -0,0 +1,48 @@
+import type { AnimusNextOptions } from './types';
+type Compiler = {
+    hooks: {
+        run: {
+            tapPromise: (name: string, fn: (c: Compiler) => Promise<void>) => void;
+        };
+        watchRun: {
+            tapPromise: (name: string, fn: (c: Compiler) => Promise<void>) => void;
+        };
+    };
+    context: string;
+};
+export declare class AnimusWebpackPlugin {
+    private options;
+    private rootDir;
+    private configJson;
+    private groupRegistryJson;
+    private themeJson;
+    private variableMapJson;
+    private variableCss;
+    private contextualVarsJson;
+    private globalCss;
+    private systemResolveScript;
+    private fileCache;
+    private lastCssHash;
+    constructor(options: AnimusNextOptions);
+    private initialized;
+    apply(compiler: Compiler): void;
+    private handleWatchUpdate;
+    private runFullPipeline;
+    private loadSystem;
+    private resolveTransforms;
+    private discoverFiles;
+    private resolvePackagesByName;
+    /**
+     * Reset analysis state for HMR geological reset.
+     */
+    resetForHmr(): void;
+    /** Expose file cache for HMR change detection */
+    getFileCache(): Map<string, {
+        hash: string;
+        source: string;
+    }>;
+    /** Expose options for the loader */
+    getOptions(): AnimusNextOptions;
+}
+export {};
+//# sourceMappingURL=plugin.d.ts.map

package/dist/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../src/plugin.ts"],"names":[],"mappings":"AA2BA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE;QACL,GAAG,EAAE;YACH,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;SACxE,CAAC;QACF,QAAQ,EAAE;YACR,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,QAAQ,KAAK,OAAO,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;SACxE,CAAC;KACH,CAAC;IACF,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAIF,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,OAAO,CAAuB;IAGtC,OAAO,CAAC,UAAU,CAAM;IACxB,OAAO,CAAC,iBAAiB,CAAM;IAC/B,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,eAAe,CAAM;IAC7B,OAAO,CAAC,WAAW,CAAM;IACzB,OAAO,CAAC,kBAAkB,CAAuB;IACjD,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,mBAAmB,CAAuB;IAGlD,OAAO,CAAC,SAAS,CAAuD;IACxE,OAAO,CAAC,WAAW,CAAuB;gBAE9B,OAAO,EAAE,iBAAiB;IAItC,OAAO,CAAC,WAAW,CAAS;IAE5B,KAAK,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;YA2CjB,iBAAiB;YAwDjB,eAAe;IAiJ7B,OAAO,CAAC,UAAU;IAiIlB,OAAO,CAAC,iBAAiB;IAqBzB,OAAO,CAAC,aAAa;IAyCrB,OAAO,CAAC,qBAAqB;IAuC7B;;OAEG;IACH,WAAW,IAAI,IAAI;IASnB,iDAAiD;IACjD,YAAY,IAAI,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC;IAI7D,oCAAoC;IACpC,UAAU,IAAI,iBAAiB;CAGhC"}

package/dist/singleton-BZ7W87Ir.mjs

@@ -0,0 +1,31 @@
+import { createRequire } from "node:module";
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/singleton.ts
+/**
+* Module-scope singleton for sharing analysis state between the webpack plugin and loader.
+*
+* Uses globalThis to survive the ESM/CJS module boundary: the plugin is loaded via ESM
+* (next.config.ts import) while the loader is loaded by webpack via require(). Without
+* globalThis, each module system gets its own singleton instance.
+*/
+const MANIFEST_KEY = "__animus_manifest_json__";
+const PROMISE_KEY = "__animus_analysis_promise__";
+function getManifestJson() {
+	return globalThis[MANIFEST_KEY];
+}
+function setManifestJson(json) {
+	globalThis[MANIFEST_KEY] = json;
+}
+function getAnalysisPromise() {
+	return globalThis[PROMISE_KEY];
+}
+function setAnalysisPromise(promise) {
+	globalThis[PROMISE_KEY] = promise;
+}
+function resetAnalysisPromise() {
+	globalThis[PROMISE_KEY] = null;
+}
+//#endregion
+export { setManifestJson as a, setAnalysisPromise as i, getManifestJson as n, __require as o, resetAnalysisPromise as r, getAnalysisPromise as t };

package/dist/singleton.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Module-scope singleton for sharing analysis state between the webpack plugin and loader.
+ *
+ * Uses globalThis to survive the ESM/CJS module boundary: the plugin is loaded via ESM
+ * (next.config.ts import) while the loader is loaded by webpack via require(). Without
+ * globalThis, each module system gets its own singleton instance.
+ */
+export declare function getManifestJson(): string | null;
+export declare function setManifestJson(json: string): void;
+export declare function getAnalysisPromise(): Promise<void> | null;
+export declare function setAnalysisPromise(promise: Promise<void>): void;
+export declare function resetAnalysisPromise(): void;
+//# sourceMappingURL=singleton.d.ts.map

package/dist/singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"singleton.d.ts","sourceRoot":"","sources":["../src/singleton.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,wBAAgB,eAAe,IAAI,MAAM,GAAG,IAAI,CAE/C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAElD;AAED,wBAAgB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAIzD;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAE/D;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C"}

package/dist/types.d.ts

@@ -0,0 +1,13 @@
+export interface AnimusNextOptions {
+    /** Path to a module exporting a SystemInstance from `@animus-ui/system`. */
+    system: string;
+    /** Glob patterns to exclude from analysis. */
+    exclude?: string[];
+    /** When true, extraction failures throw instead of warning. */
+    strict?: boolean;
+    /** Enable verbose logging. */
+    verbose?: boolean;
+    /** Namespace prefix for CSS variables and class names. */
+    prefix?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,MAAM,EAAE,MAAM,CAAC;IACf,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,+DAA+D;IAC/D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,8BAA8B;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,0DAA0D;IAC1D,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/with-animus.d.ts

@@ -0,0 +1,33 @@
+import type { AnimusNextOptions } from './types';
+type WebpackConfig = {
+    plugins?: unknown[];
+    resolve?: {
+        alias?: Record<string, string>;
+    };
+    module?: {
+        rules?: Array<{
+            test?: RegExp;
+            exclude?: RegExp;
+            enforce?: string;
+            use?: Array<{
+                loader: string;
+                options?: Record<string, unknown>;
+            }>;
+        }>;
+    };
+};
+type NextConfig = Record<string, unknown> & {
+    webpack?: (config: WebpackConfig, context: Record<string, unknown>) => WebpackConfig;
+};
+/**
+ * Wrap a Next.js config to enable Animus static CSS extraction.
+ *
+ * ```ts
+ * // next.config.ts
+ * import { withAnimus } from '@animus-ui/next-plugin';
+ * export default withAnimus({ system: './src/ds.ts' })({});
+ * ```
+ */
+export declare function withAnimus(options: AnimusNextOptions): (nextConfig: NextConfig) => NextConfig;
+export {};
+//# sourceMappingURL=with-animus.d.ts.map

package/dist/with-animus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-animus.d.ts","sourceRoot":"","sources":["../src/with-animus.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD,KAAK,aAAa,GAAG;IACnB,OAAO,CAAC,EAAE,OAAO,EAAE,CAAC;IACpB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;KAChC,CAAC;IACF,MAAM,CAAC,EAAE;QACP,KAAK,CAAC,EAAE,KAAK,CAAC;YACZ,IAAI,CAAC,EAAE,MAAM,CAAC;YACd,OAAO,CAAC,EAAE,MAAM,CAAC;YACjB,OAAO,CAAC,EAAE,MAAM,CAAC;YACjB,GAAG,CAAC,EAAE,KAAK,CAAC;gBAAE,MAAM,EAAE,MAAM,CAAC;gBAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;aAAE,CAAC,CAAC;SACpE,CAAC,CAAC;KACJ,CAAC;CACH,CAAC;AAEF,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;IAC1C,OAAO,CAAC,EAAE,CACR,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAC7B,aAAa,CAAC;CACpB,CAAC;AAIF;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CACxB,OAAO,EAAE,iBAAiB,GACzB,CAAC,UAAU,EAAE,UAAU,KAAK,UAAU,CAkIxC"}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@animus-ui/next-plugin",
+  "version": "0.1.0-next.30",
+  "description": "Animus static CSS extraction for Next.js (webpack)",
+  "author": "codecaaron <airrobb@gmail.com>",
+  "license": "MIT",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./loader": {
+      "types": "./dist/loader.d.ts",
+      "import": "./dist/loader.mjs",
+      "default": "./dist/loader.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/codecaaron/animus"
+  },
+  "scripts": {
+    "build": "tsdown && tsc -p tsconfig.build.json",
+    "compile": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "next": ">=14.0.0",
+    "webpack": ">=5.0.0"
+  },
+  "dependencies": {
+    "@animus-ui/extract": "0.1.0-next.30"
+  }
+}