@omnicajs/icons 0.2.0

package/dist/vite.d.ts

@@ -0,0 +1,7 @@
+import type { IconBuildConfig } from './build.js';
+import type { Plugin } from 'vite';
+export interface OmnicaIconsOptions extends IconBuildConfig {
+    /** Writes exact declarations for `virtual:omnicajs-icons`. The file must be included by consumer TypeScript. */
+    readonly declarationFile?: string;
+}
+export declare const omnicaIcons: (options: OmnicaIconsOptions) => Plugin;

package/dist/vite.js

@@ -0,0 +1,61 @@
+import { createAdapterDeclarations, createAdapterRuntime } from "./adapter-output.js";
+import { buildIconSet } from "./build.js";
+import fs from "node:fs/promises";
+import path from "node:path";
+import crypto from "node:crypto";
+//#region tooling/vite.ts
+var virtualModuleId = "virtual:omnicajs-icons";
+var resolvedVirtualModuleId = `\0${virtualModuleId}`;
+var omnicaIcons = (options) => {
+	let artifacts = [];
+	let command = "build";
+	const references = {};
+	return {
+		name: "omnicajs-icons",
+		enforce: "pre",
+		configResolved(config) {
+			command = config.command;
+		},
+		async buildStart() {
+			artifacts = await buildIconSet(options);
+			if (options.declarationFile) {
+				const declarationFile = path.resolve(options.declarationFile);
+				await fs.mkdir(path.dirname(declarationFile), { recursive: true });
+				await fs.writeFile(declarationFile, createAdapterDeclarations(artifacts));
+			}
+			if (command === "build") for (const artifact of artifacts) references[artifact.variant] = this.emitFile({
+				type: "asset",
+				name: `omnica-icons-${artifact.variant}.svg`,
+				source: artifact.spriteSource
+			});
+		},
+		configureServer(server) {
+			server.middlewares.use("/@omnicajs/icons/", (request, response, next) => {
+				const variant = request.url?.split(/[?#]/, 1)[0]?.replace(/\.svg$/, "");
+				const artifact = artifacts.find((candidate) => candidate.variant === variant);
+				if (!artifact) {
+					next();
+					return;
+				}
+				response.statusCode = 200;
+				response.setHeader("Content-Type", "image/svg+xml");
+				response.setHeader("Cache-Control", "no-cache");
+				response.end(artifact.spriteSource);
+			});
+		},
+		resolveId(id) {
+			return id === virtualModuleId ? resolvedVirtualModuleId : null;
+		},
+		load(id) {
+			if (id !== resolvedVirtualModuleId) return null;
+			const spriteExpressions = Object.fromEntries(artifacts.map((artifact) => {
+				if (command === "build") return [artifact.variant, `import.meta.ROLLUP_FILE_URL_${references[artifact.variant]}`];
+				const hash = crypto.createHash("sha256").update(artifact.spriteSource).digest("hex").slice(0, 8);
+				return [artifact.variant, JSON.stringify(`/@omnicajs/icons/${artifact.variant}.svg?v=${hash}`)];
+			}));
+			return createAdapterRuntime(artifacts, spriteExpressions);
+		}
+	};
+};
+//#endregion
+export { omnicaIcons };

package/dist/webpack-loader.cjs

@@ -0,0 +1,33 @@
+let node_path = require("node:path");
+let node_crypto = require("node:crypto");
+let node_fs_promises = require("node:fs/promises");
+let node_url = require("node:url");
+//#region tooling/webpack-loader.ts
+var renderFilename = (template, variant, source) => {
+	const hash = (0, node_crypto.createHash)("sha256").update(source).digest("hex");
+	return template.replaceAll("[variant]", variant).replace(/\[contenthash(?::(\d+))?\]/g, (_match, length) => length ? hash.slice(0, Number(length)) : hash);
+};
+var omnicaIconsLoader = function() {
+	const callback = this.async();
+	const options = this.getOptions();
+	this.cacheable(true);
+	Promise.all([import((0, node_url.pathToFileURL)((0, node_path.join)(__dirname, "build.js")).href), import((0, node_url.pathToFileURL)((0, node_path.join)(__dirname, "adapter-output.js")).href)]).then(async ([{ buildIconSet }, { createAdapterDeclarations, createAdapterRuntime }]) => {
+		const artifacts = await buildIconSet(options.config);
+		const spriteExpressions = {};
+		for (const artifact of artifacts) {
+			const filename = renderFilename(options.filename, artifact.variant, artifact.spriteSource);
+			this.emitFile(filename, artifact.spriteSource);
+			spriteExpressions[artifact.variant] = `(__webpack_public_path__ + ${JSON.stringify(filename)})`;
+		}
+		if (options.declarationFile) {
+			const declarationFile = (0, node_path.resolve)(options.declarationFile);
+			await (0, node_fs_promises.mkdir)((0, node_path.dirname)(declarationFile), { recursive: true });
+			await (0, node_fs_promises.writeFile)(declarationFile, createAdapterDeclarations(artifacts));
+		}
+		callback(null, createAdapterRuntime(artifacts, spriteExpressions, "cjs"));
+	}).catch((error) => {
+		callback(error instanceof Error ? error : new Error(String(error)));
+	});
+};
+//#endregion
+module.exports = omnicaIconsLoader;

package/dist/webpack-loader.d.ts

@@ -0,0 +1,9 @@
+import type { IconBuildConfig } from './build.js';
+import type { LoaderDefinitionFunction } from 'webpack';
+interface OmnicaIconsLoaderOptions {
+    readonly config: IconBuildConfig;
+    readonly declarationFile?: string;
+    readonly filename: string;
+}
+declare const omnicaIconsLoader: LoaderDefinitionFunction<OmnicaIconsLoaderOptions>;
+export default omnicaIconsLoader;

package/dist/webpack-runtime.cjs

@@ -0,0 +1,3 @@
+//#region tooling/webpack-runtime.ts
+throw new Error("virtual:omnicajs-icons requires OmnicaIconsPlugin in the Webpack configuration");
+//#endregion

package/dist/webpack.cjs

@@ -0,0 +1,28 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_path = require("node:path");
+//#region tooling/webpack.ts
+var virtualModuleId = "virtual:omnicajs-icons";
+var OmnicaIconsPlugin = class {
+	#options;
+	constructor(options) {
+		this.#options = options;
+	}
+	apply(compiler) {
+		const runtimePath = (0, node_path.join)(__dirname, "webpack-runtime.cjs");
+		const loaderPath = (0, node_path.join)(__dirname, "webpack-loader.cjs");
+		new compiler.webpack.NormalModuleReplacementPlugin(new RegExp(`^${virtualModuleId}$`), runtimePath).apply(compiler);
+		compiler.options.module.rules.unshift({
+			include: runtimePath,
+			use: [{
+				loader: loaderPath,
+				options: {
+					config: this.#options,
+					declarationFile: this.#options.declarationFile,
+					filename: this.#options.filename ?? "icons/omnica-[variant].[contenthash:8].svg"
+				}
+			}]
+		});
+	}
+};
+//#endregion
+exports.OmnicaIconsPlugin = OmnicaIconsPlugin;

package/dist/webpack.d.ts

@@ -0,0 +1,14 @@
+import type { Compiler } from 'webpack';
+import type { IconBuildConfig } from './build.js';
+import type { WebpackPluginInstance } from 'webpack';
+export interface OmnicaIconsPluginOptions extends IconBuildConfig {
+    /** Writes exact declarations for `virtual:omnicajs-icons`. The file must be included by consumer TypeScript. */
+    readonly declarationFile?: string;
+    /** Supports `[variant]`, `[contenthash]`, and `[contenthash:N]`. */
+    readonly filename?: string;
+}
+export declare class OmnicaIconsPlugin implements WebpackPluginInstance {
+    #private;
+    constructor(options: OmnicaIconsPluginOptions);
+    apply(compiler: Compiler): void;
+}