@ubean/icon 0.1.2 → 0.1.3

package/dist/vite.d.ts

@@ -0,0 +1,3 @@
+import { i as IconifyCollection, l as UbeanIconOptions } from "./types-CVT8GSd7.js";
+import { n as ubeanIconPlugin, t as addIconCollection } from "./vite-S6Ivh3te.js";
+export { type IconifyCollection, type UbeanIconOptions, addIconCollection, ubeanIconPlugin };

package/dist/vite.js

@@ -0,0 +1,318 @@
+import { f as parseIconName, h as registerCollectionLoader, m as registerCollection, n as createCollectionFromSvgMap, p as parseSvgToIconData, t as clearCollections, v as scanVueSfcForIcons } from "./core-NcYHbOE5.js";
+import { createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { defu } from "defu";
+import { basename, dirname, join, resolve } from "pathe";
+//#region \0rolldown/runtime.js
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+//#endregion
+//#region src/vite.ts
+const VIRTUAL_MODULE_ID = "virtual:ubean-icon";
+const RESOLVED_VIRTUAL_MODULE_ID = `\0${VIRTUAL_MODULE_ID}`;
+const defaultOptions = {
+	fallbackToApi: true,
+	iconApiEndpoint: "https://api.iconify.design",
+	ssr: true,
+	cssSelectorPrefix: "i-",
+	cssWherePseudo: true,
+	iconifyApiEnabled: true
+};
+function resolveCustomCollections(rootDir, customCollections) {
+	const result = {};
+	if (!customCollections) return result;
+	for (const [key, config] of Object.entries(customCollections)) if (typeof config === "string") result[key] = {
+		prefix: key,
+		dir: resolve(rootDir, config),
+		normalizeIconName: (name) => name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")
+	};
+	else result[key] = {
+		prefix: config.prefix || key,
+		dir: resolve(rootDir, config.dir),
+		normalizeIconName: config.normalizeIconName || ((name) => name.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, ""))
+	};
+	return result;
+}
+function scanSvgDirectory(dir, normalizeFn, prefixPath = "") {
+	const icons = {};
+	if (!existsSync(dir)) return icons;
+	const entries = readdirSync(dir);
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		const stat = statSync(fullPath);
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "node_modules") continue;
+			const subIcons = scanSvgDirectory(fullPath, normalizeFn, prefixPath ? `${prefixPath}-${entry}` : entry);
+			Object.assign(icons, subIcons);
+		} else if (stat.isFile() && /\.svg$/i.test(entry)) {
+			const name = basename(entry, ".svg");
+			const iconName = normalizeFn(prefixPath ? `${prefixPath}-${name}` : name);
+			if (iconName) try {
+				icons[iconName] = readFileSync(fullPath, "utf-8");
+			} catch {}
+		}
+	}
+	return icons;
+}
+function loadCustomCollections(resolvedCustoms) {
+	const result = [];
+	for (const [, config] of Object.entries(resolvedCustoms)) {
+		if (!existsSync(config.dir)) continue;
+		const svgMap = scanSvgDirectory(config.dir, config.normalizeIconName);
+		if (Object.keys(svgMap).length > 0) {
+			const collection = createCollectionFromSvgMap(config.prefix, svgMap);
+			result.push({
+				prefix: config.prefix,
+				collection
+			});
+		}
+	}
+	return result;
+}
+function serveSvgFromCustomCollection(urlPath, resolvedCustoms) {
+	const match = urlPath.match(/^\/([^/]+)\/(.+)\.svg$/);
+	if (!match) return null;
+	const [, prefix, iconName] = match;
+	for (const [, config] of Object.entries(resolvedCustoms)) {
+		if (config.prefix !== prefix) continue;
+		if (!existsSync(config.dir)) continue;
+		const iconFile = findSvgFile(config.dir, iconName, config.normalizeIconName);
+		if (iconFile) {
+			const data = parseSvgToIconData(readFileSync(iconFile, "utf-8"));
+			if (data) {
+				const width = data.width || 24;
+				const height = data.height || 24;
+				return {
+					contentType: "image/svg+xml",
+					content: `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="${data.viewBox || `0 0 ${width} ${height}`}" fill="currentColor">${data.body}</svg>`
+				};
+			}
+		}
+	}
+	return null;
+}
+function findSvgFile(dir, iconName, normalizeFn) {
+	if (!existsSync(dir)) return null;
+	const entries = readdirSync(dir);
+	for (const entry of entries) {
+		const fullPath = join(dir, entry);
+		const stat = statSync(fullPath);
+		if (stat.isDirectory()) {
+			if (entry.startsWith(".") || entry === "node_modules") continue;
+			const normalizedDir = normalizeFn(entry);
+			if (iconName.startsWith(`${normalizedDir}-`)) {
+				const found = findSvgFile(fullPath, iconName.slice(normalizedDir.length + 1), normalizeFn);
+				if (found) return found;
+			}
+		} else if (stat.isFile() && /\.svg$/i.test(entry)) {
+			if (normalizeFn(basename(entry, ".svg")) === iconName) return fullPath;
+		}
+	}
+	return null;
+}
+function ubeanIconPlugin(userOptions = {}) {
+	const options = defu(userOptions, defaultOptions);
+	const scannedIcons = /* @__PURE__ */ new Set();
+	const resolvedCollectionPaths = /* @__PURE__ */ new Map();
+	const customCollectionsCache = /* @__PURE__ */ new Map();
+	let isBuild = false;
+	let rootDir = "";
+	let resolvedCustoms = {};
+	function resolveCollectionPath(prefix) {
+		if (resolvedCollectionPaths.has(prefix)) return resolvedCollectionPaths.get(prefix);
+		const pkgName = `@iconify-json/${prefix}`;
+		try {
+			const path = dirname(__require.resolve(`${pkgName}/icons.json`, { paths: [rootDir] }));
+			resolvedCollectionPaths.set(prefix, path);
+			return path;
+		} catch {
+			resolvedCollectionPaths.set(prefix, null);
+			return null;
+		}
+	}
+	function loadCollectionDataSync(prefix) {
+		if (customCollectionsCache.has(prefix)) return customCollectionsCache.get(prefix);
+		const path = resolveCollectionPath(prefix);
+		if (!path) return null;
+		try {
+			const content = readFileSync(join(path, "icons.json"), "utf-8");
+			return JSON.parse(content);
+		} catch {
+			return null;
+		}
+	}
+	function scanSourceForIcons(source, id) {
+		if (id.includes("node_modules")) return;
+		if (!/\.(vue|tsx?|jsx?)$/.test(id)) return;
+		const icons = scanVueSfcForIcons(source);
+		for (const icon of icons) scannedIcons.add(icon);
+	}
+	function refreshCustomCollections() {
+		for (const [prefix] of customCollectionsCache) customCollectionsCache.delete(prefix);
+		const customs = loadCustomCollections(resolvedCustoms);
+		for (const { prefix, collection } of customs) {
+			customCollectionsCache.set(prefix, collection);
+			registerCollection(collection);
+		}
+	}
+	function generateVirtualModule() {
+		const collectionsToRegister = [];
+		for (const [prefix, collection] of Object.entries(options.collections)) {
+			if (typeof collection === "function") continue;
+			collectionsToRegister.push({
+				prefix,
+				data: collection
+			});
+		}
+		for (const [prefix, collection] of customCollectionsCache) if (!collectionsToRegister.some((c) => c.prefix === prefix)) collectionsToRegister.push({
+			prefix,
+			data: collection
+		});
+		if (isBuild) for (const iconName of scannedIcons) {
+			const parsed = parseIconName(iconName);
+			if (!parsed) continue;
+			if (collectionsToRegister.some((c) => c.prefix === parsed.collection)) continue;
+			const data = loadCollectionDataSync(parsed.collection);
+			if (data) collectionsToRegister.push({
+				prefix: parsed.collection,
+				data
+			});
+		}
+		const collectionsJson = JSON.stringify(Object.fromEntries(collectionsToRegister.map((c) => [c.prefix, c.data])));
+		const loaderPrefixes = /* @__PURE__ */ new Set();
+		for (const [prefix, collection] of Object.entries(options.collections)) if (typeof collection === "function") loaderPrefixes.add(prefix);
+		for (const iconName of scannedIcons) {
+			const parsed = parseIconName(iconName);
+			if (!parsed) continue;
+			if (collectionsToRegister.some((c) => c.prefix === parsed.collection)) continue;
+			if (customCollectionsCache.has(parsed.collection)) continue;
+			loaderPrefixes.add(parsed.collection);
+		}
+		let loaderCode = "";
+		for (const prefix of loaderPrefixes) {
+			const importPath = resolveCollectionPath(prefix) !== null ? `@iconify-json/${prefix}/icons.json` : "";
+			if (importPath) loaderCode += `
+  registerCollectionLoader({
+    prefix: '${prefix}',
+    load: async () => {
+      const data = await import(/* @vite-ignore */ '${importPath}');
+      return data.default || data;
+    }
+  });`;
+		}
+		return `
+import { registerCollection, registerCollectionLoader } from '@ubean/icon/runtime';
+
+const collections = ${collectionsJson};
+for (const [prefix, data] of Object.entries(collections)) {
+  registerCollection(data);
+}
+${loaderCode}
+
+export const iconOptions = ${JSON.stringify({
+			fallbackToApi: options.fallbackToApi,
+			iconApiEndpoint: options.iconApiEndpoint,
+			ssr: options.ssr,
+			iconifyApiEnabled: options.iconifyApiEnabled,
+			customCollectionPrefixes: Object.values(resolvedCustoms).map((c) => c.prefix)
+		})};
+
+export function getScannedIcons() {
+  return ${JSON.stringify([...scannedIcons])};
+}
+`;
+	}
+	return {
+		name: "ubean:icon",
+		enforce: "pre",
+		configResolved(config) {
+			rootDir = config.root;
+			isBuild = config.command === "build";
+			resolvedCustoms = resolveCustomCollections(rootDir, options.customCollections);
+			clearCollections();
+			for (const [prefix, collection] of Object.entries(options.collections)) if (typeof collection !== "function") registerCollection(collection);
+			else registerCollectionLoader({
+				prefix,
+				load: collection
+			});
+			refreshCustomCollections();
+		},
+		resolveId(id) {
+			if (id === VIRTUAL_MODULE_ID) return RESOLVED_VIRTUAL_MODULE_ID;
+			return null;
+		},
+		load(id) {
+			if (id === RESOLVED_VIRTUAL_MODULE_ID) return generateVirtualModule();
+			return null;
+		},
+		transform(code, id) {
+			scanSourceForIcons(code, id);
+			return null;
+		},
+		configureServer(server) {
+			const customDirs = Object.values(resolvedCustoms).map((c) => c.dir);
+			for (const dir of customDirs) if (existsSync(dir)) server.watcher.add(dir);
+			server.watcher.on("change", (file) => {
+				if (customDirs.some((dir) => file.startsWith(dir)) || /\.(vue|tsx?|jsx?)$/.test(file)) {
+					if (file.endsWith(".svg")) refreshCustomCollections();
+					const module = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
+					if (module) server.moduleGraph.invalidateModule(module);
+					server.ws.send({ type: "full-reload" });
+				}
+			});
+			server.watcher.on("add", (file) => {
+				if (file.endsWith(".svg") && customDirs.some((dir) => file.startsWith(dir))) {
+					refreshCustomCollections();
+					const module = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
+					if (module) server.moduleGraph.invalidateModule(module);
+					server.ws.send({ type: "full-reload" });
+				}
+			});
+			server.watcher.on("unlink", (file) => {
+				if (file.endsWith(".svg") && customDirs.some((dir) => file.startsWith(dir))) {
+					refreshCustomCollections();
+					const module = server.moduleGraph.getModuleById(RESOLVED_VIRTUAL_MODULE_ID);
+					if (module) server.moduleGraph.invalidateModule(module);
+					server.ws.send({ type: "full-reload" });
+				}
+			});
+			if (options.iconifyApiEnabled && options.fallbackToApi) {
+				const iconifyHandler = async (req, res, next) => {
+					if (!req.url) return next();
+					try {
+						const targetPath = new URL(req.url, "http://localhost").pathname.replace(/^\//, "");
+						const customResult = serveSvgFromCustomCollection(`/${targetPath}`, resolvedCustoms);
+						if (customResult) {
+							res.setHeader("Content-Type", customResult.contentType);
+							res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+							res.statusCode = 200;
+							res.end(customResult.content);
+							return;
+						}
+						const match = targetPath.match(/^([^/]+)\/(.+)\.svg$/);
+						if (!match) return next();
+						const [, prefix, icon] = match;
+						const apiUrl = `${options.iconApiEndpoint}/${prefix}/${icon}.svg`;
+						const apiRes = await fetch(apiUrl);
+						if (!apiRes.ok) return next();
+						const svg = await apiRes.text();
+						res.setHeader("Content-Type", "image/svg+xml");
+						res.setHeader("Cache-Control", "public, max-age=31536000, immutable");
+						res.statusCode = 200;
+						res.end(svg);
+					} catch {
+						next();
+					}
+				};
+				server.middlewares.use("/_iconify", (req, res, next) => {
+					Promise.resolve(iconifyHandler(req, res, next)).catch(next);
+				});
+			}
+		}
+	};
+}
+function addIconCollection(pluginOptions, prefix, collection) {
+	pluginOptions.collections = pluginOptions.collections || {};
+	pluginOptions.collections[prefix] = collection;
+}
+//#endregion
+export { addIconCollection, ubeanIconPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ubean/icon",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "description": "Icon module for ubean with Iconify integration",
   "files": [
     "dist"