@omnicajs/icons 0.3.0 → 0.3.1

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.3.1
+
+### Features
+
+* Added import-driven Vue icon components ([5fed0d0](https://github.com/omnicajs/icons/commit/5fed0d0724bafc5d60ba43ab4510c3f1856e944c))
+
 ## 0.3.0
 
 ### ⚠ BREAKING CHANGE* **icons:** Added missing icons and standardized clear circle

package/README.md

@@ -119,6 +119,119 @@ const brainKeywords = manifest.variants.filled.groups.ai.icons['brain-circuit'].
 // ['ai/brain-ai']
 ```
 
+## Import-driven Vue icons
+
+The opt-in Vue adapter complements the existing full, group, and configured subset APIs. It supports Vue 3 and transforms only unqualified `filled` and `outlined` package assets.
+
+### Vite
+
+Add the adapter before the regular Vue plugin:
+
+```ts
+import vue from '@vitejs/plugin-vue'
+import { defineConfig } from 'vite'
+import { omnicaIconComponents } from '@omnicajs/icons/vite'
+
+export default defineConfig({
+    plugins: [
+        omnicaIconComponents(),
+        vue(),
+    ],
+})
+```
+
+### Webpack
+
+Add the icon plugin before `VueLoaderPlugin`. The adapter injects its package-scoped SVG rule and reuses the application's `vue-loader`:
+
+```js
+const { VueLoaderPlugin } = require('vue-loader')
+const { OmnicaIconComponentsPlugin } = require('@omnicajs/icons/webpack')
+
+module.exports = {
+    output: {
+        publicPath: '/',
+    },
+    module: {
+        rules: [
+            { test: /\.vue$/, loader: 'vue-loader' },
+            { test: /\.svg$/, type: 'asset/resource' },
+        ],
+    },
+    plugins: [
+        new OmnicaIconComponentsPlugin(),
+        new VueLoaderPlugin(),
+    ],
+}
+```
+
+### Rspack
+
+Rspack uses the same contract and its own typed entrypoint:
+
+```js
+const { VueLoaderPlugin } = require('vue-loader')
+const { OmnicaIconComponentsPlugin } = require('@omnicajs/icons/rspack')
+
+module.exports = {
+    output: {
+        publicPath: '/',
+    },
+    module: {
+        rules: [
+            { test: /\.vue$/, loader: 'vue-loader' },
+            { test: /\.svg$/, type: 'asset/resource' },
+        ],
+    },
+    plugins: [
+        new OmnicaIconComponentsPlugin(),
+        new VueLoaderPlugin(),
+    ],
+}
+```
+
+Both configurations require the normal Vue 3 SFC toolchain (`vue`, `vue-loader`, and `@vue/compiler-sfc`) in the application. The package does not declare a root Vue peer because the adapter is opt-in and the sprite/URL APIs remain compatible with non-Vue and Vue 2 consumers. If an application already has another SVG loader, constrain that rule with a query or exclude `@omnicajs/icons/assets/icons` so one unqualified import is not processed by two component loaders.
+
+An unqualified monochrome SVG import then resolves to a Vue component:
+
+```vue
+<script setup lang="ts">
+import IconClearCircle from '@omnicajs/icons/assets/icons/filled/actions/clear-circle.svg'
+</script>
+
+<template>
+    <IconClearCircle width="24" height="24" aria-hidden="true" />
+</template>
+```
+
+Load the opt-in declarations from a project declaration file included by the consumer `tsconfig`, for example `src/omnica-icons.d.ts`:
+
+```ts
+import '@omnicajs/icons/vue'
+```
+
+The `/vue` entrypoint exports `OmnicaIconProps` as Vue's `SVGAttributes` plus typed `data-*` attributes, and `OmnicaIconComponent` as `DefineComponent<OmnicaIconProps>`. Every transformed asset uses that component type, so TypeScript checks standard SVG presentation, sizing, accessibility, data, and event attributes instead of exposing an unqualified generic Vue component.
+
+Production builds emit one content-hashed sprite containing the imported `filled` and `outlined` symbols. Generated components preserve the source `viewBox`, forward attributes to their root `svg`, and inherit `currentColor`. The symbol fragment includes the variant, for example `#filled/actions/clear-circle`, so filled and outlined names cannot collide. Vite honours its configured root-relative `base`; Webpack and Rspack use their root-relative `output.publicPath`.
+
+For SSR, run the client build first. It emits `.omnica/omnica-icons-imported.json`; the Vite, Webpack, and Rspack SSR adapters read that manifest and reference the exact client sprite instead of hashing the server graph independently. Server-rendered icons must be a subset of the client graph, otherwise the SSR build fails with the missing symbol names instead of producing a URL that would return 404.
+
+The default client output is `<root>/dist` for Vite and `<context>/dist` for Webpack/Rspack. When the client uses another output directory, pass it to both configurations:
+
+```ts
+omnicaIconComponents({ clientOutputDirectory: 'dist/client' })
+```
+
+```js
+new OmnicaIconComponentsPlugin({ clientOutputDirectory: 'dist/client' })
+```
+
+All production builds require a root-relative public path such as `/app/`: configure it through Vite `base` or Webpack/Rspack `output.publicPath`. Absolute HTTP(S), protocol-relative, automatic, empty, and relative paths are rejected. The generated components use external SVG `<use>` references, which browsers restrict to the page origin, so CDN sprite URLs are not supported. SSR builds reuse the public sprite URL recorded by the client manifest even when the server bundler has another root-relative public path.
+
+Vite development serves content-addressed one-symbol sprites so HMR can add or remove imports without stale combined-sprite state. Vite watch builds and Webpack/Rspack watch compilations recalculate the production sprite from the current module graph.
+
+Imports with `?url` keep the bundler's standard string URL behavior. Static asset URLs in Vue templates, CSS `url()` references, and JavaScript `new URL(..., import.meta.url)` dependencies also remain in the normal asset pipeline; only module imports become components. Flags and logos are not transformed by this adapter and remain available through their existing URL and sprite APIs.
+
 ## Custom subsets with the CLI
 
 The package can generate one sprite per selected variant. Create `omnica-icons.config.mjs`:

package/dist/_virtual/_rolldown/runtime.cjs

@@ -0,0 +1,23 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+exports.__toESM = __toESM;

package/dist/build.js

@@ -1,3 +1,4 @@
+import { extractSymbol, serializeSprite } from "./shared/sprite.js";
 import fs from "node:fs/promises";
 import path from "node:path";
 //#region tooling/build.ts
@@ -10,13 +11,6 @@ var hasOwn = (object, key) => Object.prototype.hasOwnProperty.call(object, key);
 var assertObject = (value, label) => {
 	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`${label} must be an object`);
 };
-var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-var serializeSprite = (symbols) => [
-	"<svg xmlns=\"http://www.w3.org/2000/svg\">",
-	symbols.join("\n"),
-	"</svg>",
-	""
-].join("\n");
 var selectionNames = (selection, group) => selection === "*" ? Object.keys(group.icons) : selection;
 var runtimeModule = ({ variant, groups }, spriteImport) => {
 	return `const hasOwn = (object: object, key: PropertyKey): key is keyof typeof object => Object.prototype.hasOwnProperty.call(object, key)
@@ -92,12 +86,6 @@ var resolveSelection = (config, manifest) => {
 		})
 	}));
 };
-var extractSymbol = (sprite, symbolId, filename) => {
-	const expression = new RegExp(`<symbol\\b[^>]*\\bid=(["'])${escapeRegExp(symbolId)}\\1[\\s\\S]*?<\\/symbol>`);
-	const match = sprite.match(expression);
-	if (!match) throw new Error(`Unable to find symbol ${symbolId} in ${filename}`);
-	return match[0];
-};
 var loadIconSymbols = (resolvedVariants) => Promise.all(resolvedVariants.map(async (variant) => ({
 	...variant,
 	groups: await Promise.all(variant.groups.map(async (group) => {

package/dist/extracted/bundler/component-loader.cjs

@@ -0,0 +1,26 @@
+const require_extracted_bundler_plugin = require("./plugin.cjs");
+let node_path = require("node:path");
+let node_url = require("node:url");
+//#region tooling/extracted/bundler/component-loader.ts
+var omnicaIconComponentsLoader = function() {
+	const callback = this.async();
+	const { ssr = false } = this.getOptions();
+	const assetsPath = (0, node_path.resolve)(__dirname, "../../../assets/icons");
+	const assetPath = (0, node_path.relative)(assetsPath, this.resourcePath).split(node_path.sep).join("/");
+	this.cacheable(true);
+	if (assetPath.startsWith("../") || assetPath === "..") {
+		callback(/* @__PURE__ */ new Error(`Imported icon is outside ${assetsPath}: ${this.resourcePath}`));
+		return;
+	}
+	const source = `@omnicajs/icons/assets/icons/${assetPath}`;
+	import((0, node_url.pathToFileURL)((0, node_path.join)(__dirname, "../core.js")).href).then(async ({ createVueIconSfc, loadImportedIcon, loadManifest }) => {
+		const icon = await loadImportedIcon(source, await loadManifest());
+		if (!icon) throw new Error(`Unable to resolve imported icon ${source}`);
+		this.emitFile(require_extracted_bundler_plugin.importedSymbolAssetFilename(icon), require_extracted_bundler_plugin.createImportedSymbolAsset(icon));
+		callback(null, createVueIconSfc(icon, ssr ? JSON.stringify(require_extracted_bundler_plugin.importedSpriteMarker) : `__webpack_public_path__ + ${JSON.stringify(require_extracted_bundler_plugin.importedSpriteMarker)}`));
+	}).catch((error) => {
+		callback(error instanceof Error ? error : new Error(String(error)));
+	});
+};
+//#endregion
+module.exports = omnicaIconComponentsLoader;

package/dist/extracted/bundler/component-loader.d.ts

@@ -0,0 +1,3 @@
+import type { LoaderDefinitionFunction } from 'webpack';
+declare const omnicaIconComponentsLoader: LoaderDefinitionFunction;
+export default omnicaIconComponentsLoader;

package/dist/extracted/bundler/plugin.cjs

@@ -0,0 +1,125 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_runtime = require("../../_virtual/_rolldown/runtime.cjs");
+const require_manifest = require("../manifest.cjs");
+let node_path = require("node:path");
+let node_url = require("node:url");
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
+node_fs_promises = require_runtime.__toESM(node_fs_promises, 1);
+//#region tooling/extracted/bundler/plugin.ts
+var pluginName = "OmnicaIconComponentsPlugin";
+var temporaryAssetPrefix = "__omnica_icons_imported__/";
+var importedSpriteMarker = "__OMNICA_IMPORTED_SPRITE_URL__";
+var targetsNode = (compiler) => {
+	const target = compiler.options.target;
+	return (Array.isArray(target) ? target : [target]).some((candidate) => typeof candidate === "string" && candidate.startsWith("node")) || compiler.options.externalsPresets?.node === true;
+};
+var assertRootRelativePublicPath = (publicPath) => {
+	if (typeof publicPath !== "string" || !publicPath.startsWith("/") || publicPath.startsWith("//") || !publicPath.endsWith("/")) throw new Error(`Import-driven icon builds require output.publicPath to be root-relative and end in "/". Absolute, protocol-relative, automatic, and relative public paths are not supported. Received ${typeof publicPath === "string" ? JSON.stringify(publicPath) : typeof publicPath}.`);
+	return publicPath;
+};
+var renderContentHashFilename = (template, source) => {
+	const hash = (0, node_crypto.createHash)("sha256").update(source).digest("hex");
+	return template.replace(/\[contenthash(?::(\d+))?\]/g, (_match, length) => length ? hash.slice(0, Number(length)) : hash);
+};
+var createImportedSymbolAsset = (symbol) => JSON.stringify({
+	schemaVersion: 1,
+	importedSymbol: symbol.importedSymbol,
+	symbolSource: symbol.symbolSource
+});
+var importedSymbolAssetFilename = (symbol) => {
+	return `${temporaryAssetPrefix}${(0, node_crypto.createHash)("sha256").update(symbol.importedSymbol).digest("hex")}.json`;
+};
+var parseImportedSymbolAsset = (source, filename) => {
+	const parsed = JSON.parse(source);
+	if (parsed.schemaVersion !== 1 || typeof parsed.importedSymbol !== "string" || typeof parsed.symbolSource !== "string") throw new Error(`Invalid imported icon metadata in ${filename}`);
+	return parsed;
+};
+var replaceSpriteMarker = (compiler, compilation, filename) => {
+	const { ReplaceSource } = compiler.webpack.sources;
+	for (const asset of compilation.getAssets()) {
+		const source = asset.source.source().toString();
+		if (!source.includes("__OMNICA_IMPORTED_SPRITE_URL__")) continue;
+		const replaced = new ReplaceSource(asset.source, asset.name);
+		let position = source.indexOf(importedSpriteMarker);
+		while (position !== -1) {
+			replaced.replace(position, position + 30 - 1, filename);
+			position = source.indexOf(importedSpriteMarker, position + 30);
+		}
+		compilation.updateAsset(asset.name, replaced);
+	}
+};
+var BundlerIconComponentsPlugin = class {
+	#options;
+	constructor(options = {}) {
+		this.#options = options;
+	}
+	apply(compiler) {
+		const loaderPath = (0, node_path.join)(__dirname, "component-loader.cjs");
+		const templateAssetsLoaderPath = (0, node_path.join)(__dirname, "template-assets-loader.cjs");
+		const assetsPath = (0, node_path.resolve)(__dirname, "../../../assets/icons");
+		const clientOutputDirectory = (0, node_path.resolve)(compiler.context, this.#options.clientOutputDirectory ?? "dist");
+		const ssr = this.#options.ssr ?? targetsNode(compiler);
+		const publicPath = assertRootRelativePublicPath(compiler.options.output.publicPath);
+		const vueLoader = {
+			loader: this.#options.vueLoader ?? "vue-loader",
+			options: { experimentalInlineMatchResource: true }
+		};
+		compiler.options.module.rules.push({
+			dependency: { not: ["url"] },
+			include: assetsPath,
+			issuer: /\.(?:[cm]?[jt]sx?|vue)$/,
+			resourceQuery: /^(?:$|\?vue&type=(?:script|template)\b)/,
+			test: /\.svg$/,
+			type: "javascript/auto",
+			use: [vueLoader, {
+				loader: loaderPath,
+				options: { ssr }
+			}]
+		});
+		compiler.options.module.rules.push({
+			enforce: "post",
+			resourceQuery: /\bvue&type=(?:script|template)\b/,
+			test: /\.vue$/,
+			use: [{ loader: templateAssetsLoaderPath }]
+		});
+		compiler.hooks.thisCompilation.tap(pluginName, (compilation) => {
+			compilation.hooks.processAssets.tapPromise({
+				name: pluginName,
+				stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_OPTIMIZE_INLINE
+			}, async () => {
+				const temporaryAssets = compilation.getAssets().filter((asset) => asset.name.startsWith(temporaryAssetPrefix));
+				if (temporaryAssets.length === 0) return;
+				const symbols = temporaryAssets.map((asset) => parseImportedSymbolAsset(asset.source.source().toString(), asset.name));
+				for (const asset of temporaryAssets) compilation.deleteAsset(asset.name);
+				let filename;
+				if (ssr) {
+					const manifestPath = (0, node_path.join)(clientOutputDirectory, require_manifest.importedSpriteManifestFilename);
+					let clientManifest;
+					try {
+						clientManifest = require_manifest.parseImportedSpriteManifest(await node_fs_promises.default.readFile(manifestPath, "utf8"), manifestPath);
+					} catch (error) {
+						const detail = error instanceof Error ? ` ${error.message}` : "";
+						throw new Error(`Unable to load the import-driven icon client manifest at ${manifestPath}. Build the client before SSR or configure clientOutputDirectory.${detail}`);
+					}
+					require_manifest.assertImportedSymbolsAvailable(clientManifest, symbols);
+					filename = clientManifest.spriteUrl;
+				} else {
+					const { createImportedSprite } = await import((0, node_url.pathToFileURL)((0, node_path.join)(__dirname, "../core.js")).href);
+					const spriteSource = createImportedSprite(symbols);
+					const filenameTemplate = this.#options.filename ?? "assets/omnica-icons-imported.[contenthash:8].svg";
+					filename = renderContentHashFilename(filenameTemplate, spriteSource);
+					compilation.emitAsset(filename, new compiler.webpack.sources.RawSource(spriteSource), { immutable: /\[contenthash(?::\d+)?\]/.test(filenameTemplate) });
+					compilation.emitAsset(require_manifest.importedSpriteManifestFilename, new compiler.webpack.sources.RawSource(require_manifest.createImportedSpriteManifest(filename, `${publicPath}${filename}`, symbols)));
+				}
+				replaceSpriteMarker(compiler, compilation, filename);
+			});
+		});
+	}
+};
+//#endregion
+exports.BundlerIconComponentsPlugin = BundlerIconComponentsPlugin;
+exports.createImportedSymbolAsset = createImportedSymbolAsset;
+exports.importedSpriteMarker = importedSpriteMarker;
+exports.importedSymbolAssetFilename = importedSymbolAssetFilename;
+exports.renderContentHashFilename = renderContentHashFilename;

package/dist/extracted/bundler/plugin.d.ts

@@ -0,0 +1,21 @@
+import type { Compiler } from 'webpack';
+import type { ImportedSymbol } from '../core.js';
+export interface BundlerIconComponentsOptions {
+    /** Supports `[contenthash]` and `[contenthash:N]`. */
+    readonly filename?: string;
+    /** Overrides the loader used to compile the generated Vue SFC. */
+    readonly vueLoader?: string;
+    /** Client build output read by a later SSR build. Defaults to `<context>/dist`. */
+    readonly clientOutputDirectory?: string;
+    /** Overrides automatic Node-target SSR detection. */
+    readonly ssr?: boolean;
+}
+export declare const importedSpriteMarker = "__OMNICA_IMPORTED_SPRITE_URL__";
+export declare const renderContentHashFilename: (template: string, source: string) => string;
+export declare const createImportedSymbolAsset: (symbol: ImportedSymbol) => string;
+export declare const importedSymbolAssetFilename: (symbol: ImportedSymbol) => string;
+export declare class BundlerIconComponentsPlugin {
+    #private;
+    constructor(options?: BundlerIconComponentsOptions);
+    apply(compiler: Compiler): void;
+}

package/dist/extracted/bundler/template-assets-loader.cjs

@@ -0,0 +1,8 @@
+//#region tooling/extracted/bundler/template-assets-loader.ts
+var vueTemplateAssetImport = /(\bimport\s+_imports_\d+\s+from\s+)(["'])(@omnicajs\/icons\/assets\/icons\/(?:filled|outlined)\/[^"'?#]+\.svg)\2/g;
+var bundlerTemplateAssetsLoader = function(source, sourceMap) {
+	const transformed = source.replace(vueTemplateAssetImport, (_match, prefix, quote, request) => `${prefix}${quote}${request}?url${quote}`);
+	this.callback(null, transformed, sourceMap);
+};
+//#endregion
+module.exports = bundlerTemplateAssetsLoader;

package/dist/extracted/bundler/template-assets-loader.d.ts

@@ -0,0 +1,3 @@
+import type { LoaderDefinitionFunction } from 'webpack';
+declare const bundlerTemplateAssetsLoader: LoaderDefinitionFunction;
+export default bundlerTemplateAssetsLoader;

package/dist/extracted/core.d.ts

@@ -0,0 +1,14 @@
+import type { IconManifest, ManifestIcon } from '../build.js';
+export { loadManifest } from '../build.js';
+export interface ImportedIcon extends ManifestIcon {
+    readonly variant: 'filled' | 'outlined';
+    readonly group: string;
+    readonly name: string;
+    readonly importedSymbol: string;
+    readonly symbolSource: string;
+}
+export type ImportedSymbol = Pick<ImportedIcon, 'importedSymbol' | 'symbolSource'>;
+export declare const resolveImportedIcon: (source: string, manifest: IconManifest) => Omit<ImportedIcon, "symbolSource"> | null;
+export declare const loadImportedIcon: (source: string, manifest: IconManifest) => Promise<ImportedIcon | null>;
+export declare const createImportedSprite: (icons: readonly ImportedSymbol[]) => string;
+export declare const createVueIconSfc: (icon: ImportedIcon, spriteExpression: string) => string;

package/dist/extracted/core.js

@@ -0,0 +1,64 @@
+import { serializeSprite } from "../shared/sprite.js";
+import { loadIconSymbols, loadManifest } from "../build.js";
+//#region tooling/extracted/core.ts
+var importedAssetExpression = /^@omnicajs\/icons\/(assets\/icons\/(filled|outlined)\/([^/]+)\/([^/]+)\.svg)$/;
+var importedSymbolId = (variant, group, name) => `${variant}/${group}/${name}`;
+var resolveImportedIcon = (source, manifest) => {
+	if (source.includes("?") || source.includes("#")) return null;
+	const match = source.match(importedAssetExpression);
+	if (!match) return null;
+	const [, assetPath, variant, group, name] = match;
+	const icon = manifest.variants[variant]?.groups[group]?.icons[name];
+	if (!icon || icon.source !== assetPath) throw new Error(`Unknown imported icon ${variant}/${group}/${name}`);
+	return {
+		...icon,
+		variant,
+		group,
+		name,
+		importedSymbol: importedSymbolId(variant, group, name)
+	};
+};
+var loadImportedIcon = async (source, manifest) => {
+	const icon = resolveImportedIcon(source, manifest);
+	if (!icon) return null;
+	const symbolSource = (await loadIconSymbols([{
+		variant: icon.variant,
+		groups: [{
+			name: icon.group,
+			sprite: manifest.variants[icon.variant].groups[icon.group].sprite,
+			icons: [{
+				name: icon.name,
+				source: icon.source,
+				symbol: icon.symbol,
+				viewBox: icon.viewBox,
+				keywords: icon.keywords
+			}]
+		}]
+	}]))[0]?.groups[0]?.icons[0]?.symbolSource;
+	if (!symbolSource) throw new Error(`Missing symbol source for ${icon.importedSymbol}`);
+	return {
+		...icon,
+		symbolSource
+	};
+};
+var createImportedSprite = (icons) => {
+	return serializeSprite([...new Map(icons.map((icon) => [icon.importedSymbol, icon])).values()].sort((left, right) => left.importedSymbol.localeCompare(right.importedSymbol)).map((icon) => icon.symbolSource.replace(/(<symbol\b[^>]*\bid=)(["'])([^"']+)\2/, (_match, prefix, quote) => `${prefix}${quote}${icon.importedSymbol}${quote}`)));
+};
+var componentName = (icon) => `Omnica-${icon.variant}-${icon.group}-${icon.name}-icon`.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => `${part[0].toUpperCase()}${part.slice(1)}`).join("");
+var createVueIconSfc = (icon, spriteExpression) => `<template>
+    <svg viewBox="${icon.viewBox}">
+        <use :href="href" />
+    </svg>
+</template>
+
+<script>
+const href = ${spriteExpression} + ${JSON.stringify(`#${icon.importedSymbol}`)}
+
+export default {
+    name: ${JSON.stringify(componentName(icon))},
+    data: () => ({ href }),
+}
+<\/script>
+`;
+//#endregion
+export { createImportedSprite, createVueIconSfc, loadImportedIcon, loadManifest, resolveImportedIcon };

package/dist/extracted/manifest.cjs

@@ -0,0 +1,23 @@
+//#region tooling/extracted/manifest.ts
+var importedSpriteManifestFilename = ".omnica/omnica-icons-imported.json";
+var createImportedSpriteManifest = (spriteFilename, spriteUrl, icons) => `${JSON.stringify({
+	schemaVersion: 1,
+	spriteFilename,
+	spriteUrl,
+	symbols: [...new Set(icons.map((icon) => icon.importedSymbol))].sort()
+}, null, 2)}\n`;
+var parseImportedSpriteManifest = (source, filename) => {
+	const parsed = JSON.parse(source);
+	if (parsed.schemaVersion !== 1 || typeof parsed.spriteFilename !== "string" || parsed.spriteFilename.length === 0 || typeof parsed.spriteUrl !== "string" || !parsed.spriteUrl.startsWith("/") || parsed.spriteUrl.startsWith("//") || !Array.isArray(parsed.symbols) || parsed.symbols.some((symbol) => typeof symbol !== "string") || new Set(parsed.symbols).size !== parsed.symbols.length) throw new Error(`Invalid import-driven icon manifest in ${filename}`);
+	return parsed;
+};
+var assertImportedSymbolsAvailable = (manifest, icons) => {
+	const clientSymbols = new Set(manifest.symbols);
+	const missing = [...new Set(icons.map((icon) => icon.importedSymbol).filter((symbol) => !clientSymbols.has(symbol)))].sort();
+	if (missing.length > 0) throw new Error(`SSR imports icons missing from the client sprite: ${missing.join(", ")}. Build the client first and ensure its icon graph contains every server-rendered icon.`);
+};
+//#endregion
+exports.assertImportedSymbolsAvailable = assertImportedSymbolsAvailable;
+exports.createImportedSpriteManifest = createImportedSpriteManifest;
+exports.importedSpriteManifestFilename = importedSpriteManifestFilename;
+exports.parseImportedSpriteManifest = parseImportedSpriteManifest;

package/dist/extracted/manifest.d.ts

@@ -0,0 +1,11 @@
+import type { ImportedSymbol } from './core.js';
+export interface ImportedSpriteManifest {
+    readonly schemaVersion: 1;
+    readonly spriteFilename: string;
+    readonly spriteUrl: string;
+    readonly symbols: readonly string[];
+}
+export declare const importedSpriteManifestFilename = ".omnica/omnica-icons-imported.json";
+export declare const createImportedSpriteManifest: (spriteFilename: string, spriteUrl: string, icons: readonly ImportedSymbol[]) => string;
+export declare const parseImportedSpriteManifest: (source: string, filename: string) => ImportedSpriteManifest;
+export declare const assertImportedSymbolsAvailable: (manifest: ImportedSpriteManifest, icons: readonly ImportedSymbol[]) => void;

package/dist/extracted/manifest.js

@@ -0,0 +1,20 @@
+//#region tooling/extracted/manifest.ts
+var importedSpriteManifestFilename = ".omnica/omnica-icons-imported.json";
+var createImportedSpriteManifest = (spriteFilename, spriteUrl, icons) => `${JSON.stringify({
+	schemaVersion: 1,
+	spriteFilename,
+	spriteUrl,
+	symbols: [...new Set(icons.map((icon) => icon.importedSymbol))].sort()
+}, null, 2)}\n`;
+var parseImportedSpriteManifest = (source, filename) => {
+	const parsed = JSON.parse(source);
+	if (parsed.schemaVersion !== 1 || typeof parsed.spriteFilename !== "string" || parsed.spriteFilename.length === 0 || typeof parsed.spriteUrl !== "string" || !parsed.spriteUrl.startsWith("/") || parsed.spriteUrl.startsWith("//") || !Array.isArray(parsed.symbols) || parsed.symbols.some((symbol) => typeof symbol !== "string") || new Set(parsed.symbols).size !== parsed.symbols.length) throw new Error(`Invalid import-driven icon manifest in ${filename}`);
+	return parsed;
+};
+var assertImportedSymbolsAvailable = (manifest, icons) => {
+	const clientSymbols = new Set(manifest.symbols);
+	const missing = [...new Set(icons.map((icon) => icon.importedSymbol).filter((symbol) => !clientSymbols.has(symbol)))].sort();
+	if (missing.length > 0) throw new Error(`SSR imports icons missing from the client sprite: ${missing.join(", ")}. Build the client first and ensure its icon graph contains every server-rendered icon.`);
+};
+//#endregion
+export { assertImportedSymbolsAvailable, createImportedSpriteManifest, importedSpriteManifestFilename, parseImportedSpriteManifest };

package/dist/extracted/vite.d.ts

@@ -0,0 +1,8 @@
+import type { Plugin } from 'vite';
+export interface OmnicaIconComponentsOptions {
+    /** Asset name before Vite adds its content hash. */
+    readonly spriteName?: string;
+    /** Client build output read by a later SSR build. Defaults to `<root>/dist`. */
+    readonly clientOutputDirectory?: string;
+}
+export declare const omnicaIconComponents: (options?: OmnicaIconComponentsOptions) => Plugin;