@ubean/icon 0.1.1 → 0.1.3

package/dist/core-NcYHbOE5.js

@@ -0,0 +1,212 @@
+//#region src/core.ts
+const loadedCollections = /* @__PURE__ */ new Map();
+const collectionLoaders = /* @__PURE__ */ new Map();
+function parseIconName(name) {
+	if (!name || typeof name !== "string") return null;
+	const sep = name.indexOf(":");
+	if (sep === -1) return null;
+	const collection = name.slice(0, sep);
+	const icon = name.slice(sep + 1);
+	if (!collection || !icon) return null;
+	return {
+		collection,
+		icon
+	};
+}
+function normalizeIconName(name) {
+	return name.trim().toLowerCase().replace(/[^a-z0-9:-]/g, "");
+}
+function registerCollection(collection) {
+	loadedCollections.set(collection.prefix, collection);
+}
+function registerCollectionLoader(loader) {
+	collectionLoaders.set(loader.prefix, loader);
+}
+async function loadCollection(prefix) {
+	if (loadedCollections.has(prefix)) return loadedCollections.get(prefix);
+	const loader = collectionLoaders.get(prefix);
+	if (loader) {
+		const collection = await loader.load();
+		loadedCollections.set(prefix, collection);
+		return collection;
+	}
+	return null;
+}
+function getLoadedCollection(prefix) {
+	return loadedCollections.get(prefix);
+}
+function resolveAlias(collection, iconName, visited = /* @__PURE__ */ new Set()) {
+	if (visited.has(iconName)) return null;
+	visited.add(iconName);
+	const icon = collection.icons[iconName];
+	if (icon) return icon;
+	const alias = collection.aliases?.[iconName];
+	if (!alias) return null;
+	const parentData = resolveAlias(collection, alias.parent, visited);
+	if (!parentData) return null;
+	return {
+		...parentData,
+		...alias,
+		body: alias.body ?? parentData.body
+	};
+}
+function getIconData(collection, iconName) {
+	const icon = resolveAlias(collection, iconName);
+	if (!icon) return null;
+	return icon;
+}
+function resolveIconData(collection, iconName, overrides) {
+	const icon = getIconData(collection, iconName);
+	if (!icon) return null;
+	const width = overrides?.width ?? icon.width ?? collection.width ?? 24;
+	const height = overrides?.height ?? icon.height ?? collection.height ?? 24;
+	let body = icon.body;
+	const rotate = overrides?.rotate ?? icon.rotate ?? 0;
+	const hFlip = overrides?.hFlip ?? icon.hFlip ?? false;
+	const vFlip = overrides?.vFlip ?? icon.vFlip ?? false;
+	const transforms = [];
+	if (rotate) transforms.push(`rotate(${rotate * 90} ${width / 2} ${height / 2})`);
+	if (hFlip) transforms.push(`translate(${width} 0) scale(-1 1)`);
+	if (vFlip) transforms.push(`translate(0 ${height}) scale(1 -1)`);
+	if (transforms.length > 0) body = `<g transform="${transforms.join(" ")}">${body}</g>`;
+	const viewBox = icon.viewBox ?? `0 0 ${width} ${height}`;
+	return {
+		body,
+		width,
+		height,
+		viewBox
+	};
+}
+function generateSvg(resolved, options) {
+	const { body, width, height, viewBox } = resolved;
+	const { className, style, ariaHidden = true, ariaLabel, title } = options ?? {};
+	const attrs = [
+		"xmlns=\"http://www.w3.org/2000/svg\"",
+		`viewBox="${viewBox}"`,
+		`width="${width}"`,
+		`height="${height}"`
+	];
+	if (className) attrs.push(`class="${className}"`);
+	if (style) {
+		const styleStr = Object.entries(style).map(([k, v]) => `${k.replace(/([A-Z])/g, "-$1").toLowerCase()}:${v}`).join(";");
+		attrs.push(`style="${styleStr}"`);
+	}
+	if (ariaHidden && !ariaLabel) attrs.push("aria-hidden=\"true\"");
+	else if (ariaLabel) attrs.push(`role="img" aria-label="${ariaLabel}"`);
+	let titleTag = "";
+	if (title) titleTag = `<title>${escapeHtml(title)}</title>`;
+	return `<svg ${attrs.join(" ")}>${titleTag}${body}</svg>`;
+}
+function escapeHtml(str) {
+	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+async function getIcon(name) {
+	const parsed = parseIconName(name);
+	if (!parsed) return null;
+	const collection = await loadCollection(parsed.collection);
+	if (!collection) return null;
+	return resolveIconData(collection, parsed.icon);
+}
+function getIconSync(name) {
+	const parsed = parseIconName(name);
+	if (!parsed) return null;
+	const collection = loadedCollections.get(parsed.collection);
+	if (!collection) return null;
+	return resolveIconData(collection, parsed.icon);
+}
+function listLoadedCollections() {
+	return Array.from(loadedCollections.keys());
+}
+function clearCollections() {
+	loadedCollections.clear();
+	collectionLoaders.clear();
+}
+function scanVueSfcForIcons(source) {
+	const icons = /* @__PURE__ */ new Set();
+	const attrPattern = /(?:icon|name)\s*=\s*["']([^"']*:[^"']*)["']/g;
+	const boundAttrPattern = /:(?:icon|name)\s*=\s*["']([^"']*:[^"']*)["']/g;
+	const iconFnPattern = /(?:getIcon|useIcon)\(\s*["']([^"']*:[^"']*)["']\s*\)/g;
+	let match;
+	while ((match = attrPattern.exec(source)) !== null) {
+		const name = normalizeIconName(match[1]);
+		if (parseIconName(name)) icons.add(name);
+	}
+	while ((match = boundAttrPattern.exec(source)) !== null) {
+		const name = normalizeIconName(match[1]);
+		if (parseIconName(name)) icons.add(name);
+	}
+	while ((match = iconFnPattern.exec(source)) !== null) {
+		const name = normalizeIconName(match[1]);
+		if (parseIconName(name)) icons.add(name);
+	}
+	return icons;
+}
+const SVG_TAG_RE = /<svg([^>]*)>([\s\S]*?)<\/svg>/i;
+const SVG_ATTR_RE = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^"'<>`\s]+))/g;
+function parseSvgToIconData(svg) {
+	const match = SVG_TAG_RE.exec(svg);
+	if (!match) return null;
+	const attrs = match[1];
+	const body = match[2].trim();
+	if (!body) return null;
+	const attrMap = {};
+	let attrMatch;
+	SVG_ATTR_RE.lastIndex = 0;
+	while ((attrMatch = SVG_ATTR_RE.exec(attrs)) !== null) {
+		const name = attrMatch[1].toLowerCase();
+		attrMap[name] = attrMatch[2] ?? attrMatch[3] ?? attrMatch[4] ?? "";
+	}
+	const result = { body };
+	const width = parseNumber(attrMap.width);
+	const height = parseNumber(attrMap.height);
+	if (width) result.width = width;
+	if (height) result.height = height;
+	const viewBox = attrMap.viewbox;
+	if (viewBox) {
+		result.viewBox = viewBox;
+		const parts = viewBox.split(/[\s,]+/).map(Number).filter((n) => !Number.isNaN(n));
+		if (parts.length === 4 && (!width || !height)) {
+			const vbWidth = parts[2];
+			const vbHeight = parts[3];
+			if (!width && vbWidth) result.width = vbWidth;
+			if (!height && vbHeight) result.height = vbHeight;
+		}
+	}
+	const rootAttrs = [];
+	for (const attr of [
+		"fill",
+		"stroke",
+		"stroke-width",
+		"stroke-linecap",
+		"stroke-linejoin",
+		"stroke-miterlimit"
+	]) if (attrMap[attr]) rootAttrs.push(`${attr}="${escapeHtml(attrMap[attr])}"`);
+	return result;
+}
+function parseNumber(value) {
+	if (!value) return void 0;
+	const n = parseFloat(value);
+	return Number.isFinite(n) && n > 0 ? n : void 0;
+}
+function createCollectionFromSvgMap(prefix, icons) {
+	const iconData = {};
+	let collectionWidth;
+	let collectionHeight;
+	for (const [name, svg] of Object.entries(icons)) {
+		const data = parseSvgToIconData(svg);
+		if (data) {
+			iconData[name] = data;
+			if (data.width && !collectionWidth && true) collectionWidth = data.width;
+			if (data.height && !collectionHeight && true) collectionHeight = data.height;
+		}
+	}
+	const collection = {
+		prefix,
+		icons: iconData
+	};
+	if (collectionWidth) collection.width = collectionWidth;
+	if (collectionHeight) collection.height = collectionHeight;
+	return collection;
+}
+//#endregion
+export { resolveIconData as _, getIcon as a, getLoadedCollection as c, normalizeIconName as d, parseIconName as f, resolveAlias as g, registerCollectionLoader as h, generateSvg as i, listLoadedCollections as l, registerCollection as m, createCollectionFromSvgMap as n, getIconData as o, parseSvgToIconData as p, escapeHtml as r, getIconSync as s, clearCollections as t, loadCollection as u, scanVueSfcForIcons as v };

package/dist/index.d.ts

@@ -0,0 +1,123 @@
+import { a as IconifyIconData, i as IconifyCollection, l as UbeanIconOptions, n as IconCollectionLoader, o as ResolvedCustomCollection, r as IconifyAlias, s as ResolvedIconData, t as CustomCollectionDirConfig } from "./types-CVT8GSd7.js";
+import { n as ubeanIconPlugin, t as addIconCollection } from "./vite-S6Ivh3te.js";
+import { S as scanVueSfcForIcons, _ as parseSvgToIconData, a as clearCollections, c as generateSvg, d as getIconSync, f as getLoadedCollection, g as parseIconName, h as normalizeIconName, i as getIconConfig, l as getIcon, m as loadCollection, n as configureIconRuntime, o as createCollectionFromSvgMap, p as listLoadedCollections, r as fetchIconFromApi, s as escapeHtml, t as buildIconCssIcon, u as getIconData, v as registerCollection, x as resolveIconData, y as registerCollectionLoader } from "./runtime-Hp8OXvtC.js";
+import { PropType } from "vue";
+//#region src/index.d.ts
+interface UbeanIconProps {
+  name: string;
+  size?: string | number;
+  color?: string;
+  className?: string;
+  ariaLabel?: string;
+  title?: string;
+  mode?: 'svg' | 'css';
+  flip?: 'horizontal' | 'vertical' | 'both';
+  rotate?: number | string;
+  inline?: boolean;
+}
+declare const Icon: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+  name: {
+    type: PropType<string>;
+    required: true;
+  };
+  size: {
+    type: PropType<string | number>;
+    default: string;
+  };
+  color: {
+    type: PropType<string>;
+    default: undefined;
+  };
+  className: {
+    type: PropType<string>;
+    default: string;
+  };
+  ariaLabel: {
+    type: PropType<string>;
+    default: undefined;
+  };
+  title: {
+    type: PropType<string>;
+    default: undefined;
+  };
+  mode: {
+    type: PropType<"svg" | "css">;
+    default: string;
+  };
+  flip: {
+    type: PropType<"horizontal" | "vertical" | "both">;
+    default: undefined;
+  };
+  rotate: {
+    type: PropType<string | number>;
+    default: undefined;
+  };
+  inline: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+  [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+  name: {
+    type: PropType<string>;
+    required: true;
+  };
+  size: {
+    type: PropType<string | number>;
+    default: string;
+  };
+  color: {
+    type: PropType<string>;
+    default: undefined;
+  };
+  className: {
+    type: PropType<string>;
+    default: string;
+  };
+  ariaLabel: {
+    type: PropType<string>;
+    default: undefined;
+  };
+  title: {
+    type: PropType<string>;
+    default: undefined;
+  };
+  mode: {
+    type: PropType<"svg" | "css">;
+    default: string;
+  };
+  flip: {
+    type: PropType<"horizontal" | "vertical" | "both">;
+    default: undefined;
+  };
+  rotate: {
+    type: PropType<string | number>;
+    default: undefined;
+  };
+  inline: {
+    type: BooleanConstructor;
+    default: boolean;
+  };
+}>> & Readonly<{}>, {
+  size: string | number;
+  color: string;
+  className: string;
+  ariaLabel: string;
+  title: string;
+  mode: "svg" | "css";
+  flip: "horizontal" | "vertical" | "both";
+  rotate: string | number;
+  inline: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare function defineIconCollection(collection: IconifyCollection): IconifyCollection;
+declare function defineIconCollectionLoader(prefix: string, loader: () => Promise<IconifyCollection>): {
+  prefix: string;
+  load: () => Promise<IconifyCollection>;
+};
+declare function useIcon(name: string): {
+  getSvg: () => Promise<string | null>;
+  getSvgSync: () => string | null;
+};
+//#endregion
+export { type CustomCollectionDirConfig, Icon, Icon as default, type IconCollectionLoader, type IconifyAlias, type IconifyCollection, type IconifyIconData, type ResolvedCustomCollection, type ResolvedIconData, type UbeanIconOptions, UbeanIconProps, addIconCollection, buildIconCssIcon, clearCollections, configureIconRuntime, createCollectionFromSvgMap, defineIconCollection, defineIconCollectionLoader, escapeHtml, fetchIconFromApi, generateSvg, getIcon, getIconConfig, getIconData, getIconSync, getLoadedCollection, listLoadedCollections, loadCollection, normalizeIconName, parseIconName, parseSvgToIconData, registerCollection, registerCollectionLoader, resolveIconData, scanVueSfcForIcons, ubeanIconPlugin, useIcon };

package/dist/index.js

@@ -0,0 +1,176 @@
+import { _ as resolveIconData, a as getIcon, c as getLoadedCollection, d as normalizeIconName, f as parseIconName, h as registerCollectionLoader, i as generateSvg, l as listLoadedCollections, m as registerCollection, n as createCollectionFromSvgMap, o as getIconData, p as parseSvgToIconData, r as escapeHtml, s as getIconSync, t as clearCollections, u as loadCollection, v as scanVueSfcForIcons } from "./core-NcYHbOE5.js";
+import { buildIconCssIcon, configureIconRuntime, fetchIconFromApi, getIconConfig } from "./runtime.js";
+import { addIconCollection, ubeanIconPlugin } from "./vite.js";
+import { computed, defineComponent, h, ref, watchEffect } from "vue";
+//#region src/index.ts
+const Icon = defineComponent({
+	name: "UbeanIcon",
+	props: {
+		name: {
+			type: String,
+			required: true
+		},
+		size: {
+			type: [String, Number],
+			default: "1em"
+		},
+		color: {
+			type: String,
+			default: void 0
+		},
+		className: {
+			type: String,
+			default: ""
+		},
+		ariaLabel: {
+			type: String,
+			default: void 0
+		},
+		title: {
+			type: String,
+			default: void 0
+		},
+		mode: {
+			type: String,
+			default: "svg"
+		},
+		flip: {
+			type: String,
+			default: void 0
+		},
+		rotate: {
+			type: [String, Number],
+			default: void 0
+		},
+		inline: {
+			type: Boolean,
+			default: false
+		}
+	},
+	setup(props) {
+		const svgHtml = ref("");
+		const isLoading = ref(false);
+		const hasError = ref(false);
+		const sizeValue = computed(() => typeof props.size === "number" ? `${props.size}px` : props.size);
+		const transformStyle = computed(() => {
+			const transforms = [];
+			if (props.flip === "horizontal" || props.flip === "both") transforms.push("scaleX(-1)");
+			if (props.flip === "vertical" || props.flip === "both") transforms.push("scaleY(-1)");
+			if (props.rotate !== void 0) {
+				const deg = typeof props.rotate === "number" ? props.rotate : parseInt(props.rotate, 10);
+				if (!isNaN(deg)) transforms.push(`rotate(${deg}deg)`);
+			}
+			return transforms.length > 0 ? transforms.join(" ") : void 0;
+		});
+		const sizeStyle = computed(() => ({
+			width: sizeValue.value,
+			height: sizeValue.value,
+			display: props.inline ? "inline-block" : "inline-block",
+			verticalAlign: props.inline ? "-0.125em" : "middle",
+			transform: transformStyle.value
+		}));
+		const cssClass = computed(() => {
+			const parsed = parseIconName(props.name);
+			if (!parsed) return props.className;
+			const baseClass = `i-${parsed.collection}-${parsed.icon}`;
+			return props.className ? `${baseClass} ${props.className}` : baseClass;
+		});
+		async function loadIconSvg() {
+			if (props.mode === "css") return;
+			isLoading.value = true;
+			hasError.value = false;
+			try {
+				let resolved = getIconSync(props.name);
+				if (!resolved) resolved = await getIcon(props.name);
+				if (!resolved && getIconConfig().fallbackToApi && getIconConfig().iconifyApiEnabled) {
+					const fetchedSvg = await fetchIconFromApi(props.name);
+					if (fetchedSvg) {
+						svgHtml.value = fetchedSvg;
+						return;
+					}
+				}
+				if (resolved) {
+					const parsed = parseIconName(props.name);
+					let finalResolved = resolved;
+					if (parsed) {
+						const collection = getLoadedCollection(parsed.collection);
+						if (collection) finalResolved = resolveIconData(collection, parsed.icon) ?? resolved;
+					}
+					svgHtml.value = generateSvg(finalResolved, {
+						className: props.className || void 0,
+						ariaHidden: !props.ariaLabel,
+						ariaLabel: props.ariaLabel,
+						title: props.title
+					});
+				} else {
+					hasError.value = true;
+					svgHtml.value = "";
+				}
+			} catch {
+				hasError.value = true;
+				svgHtml.value = "";
+			} finally {
+				isLoading.value = false;
+			}
+		}
+		watchEffect(() => {
+			loadIconSvg();
+		});
+		return () => {
+			if (props.mode === "css") return h("span", {
+				class: cssClass.value,
+				style: {
+					...sizeStyle.value,
+					color: props.color
+				},
+				"aria-hidden": props.ariaLabel ? void 0 : "true",
+				"aria-label": props.ariaLabel,
+				role: props.ariaLabel ? "img" : void 0
+			});
+			if (isLoading.value || hasError.value || !svgHtml.value) return h("span", {
+				class: props.className,
+				style: sizeStyle.value,
+				"aria-hidden": "true"
+			});
+			return h("span", {
+				class: props.className,
+				style: {
+					...sizeStyle.value,
+					color: props.color
+				},
+				innerHTML: svgHtml.value,
+				"aria-hidden": props.ariaLabel ? void 0 : "true",
+				"aria-label": props.ariaLabel,
+				role: props.ariaLabel ? "img" : void 0
+			});
+		};
+	}
+});
+function defineIconCollection(collection) {
+	registerCollection(collection);
+	return collection;
+}
+function defineIconCollectionLoader(prefix, loader) {
+	const loaderDef = {
+		prefix,
+		load: loader
+	};
+	registerCollectionLoader(loaderDef);
+	return loaderDef;
+}
+function useIcon(name) {
+	return {
+		getSvg: async () => {
+			const resolved = await getIcon(name);
+			if (resolved) return generateSvg(resolved);
+			if (getIconConfig().fallbackToApi) return fetchIconFromApi(name);
+			return null;
+		},
+		getSvgSync: () => {
+			const resolved = getIconSync(name);
+			return resolved ? generateSvg(resolved) : null;
+		}
+	};
+}
+//#endregion
+export { Icon, Icon as default, addIconCollection, buildIconCssIcon, clearCollections, configureIconRuntime, createCollectionFromSvgMap, defineIconCollection, defineIconCollectionLoader, escapeHtml, fetchIconFromApi, generateSvg, getIcon, getIconConfig, getIconData, getIconSync, getLoadedCollection, listLoadedCollections, loadCollection, normalizeIconName, parseIconName, parseSvgToIconData, registerCollection, registerCollectionLoader, resolveIconData, scanVueSfcForIcons, ubeanIconPlugin, useIcon };

package/dist/runtime-Hp8OXvtC.d.ts

@@ -0,0 +1,55 @@
+import { a as IconifyIconData, i as IconifyCollection, n as IconCollectionLoader, s as ResolvedIconData } from "./types-CVT8GSd7.js";
+//#region src/core.d.ts
+declare function parseIconName(name: string): {
+  collection: string;
+  icon: string;
+} | null;
+declare function normalizeIconName(name: string): string;
+declare function registerCollection(collection: IconifyCollection): void;
+declare function registerCollectionLoader(loader: IconCollectionLoader): void;
+declare function loadCollection(prefix: string): Promise<IconifyCollection | null>;
+declare function getLoadedCollection(prefix: string): IconifyCollection | undefined;
+declare function resolveAlias(collection: IconifyCollection, iconName: string, visited?: Set<string>): IconifyIconData | null;
+declare function getIconData(collection: IconifyCollection, iconName: string): IconifyIconData | null;
+declare function resolveIconData(collection: IconifyCollection, iconName: string, overrides?: Partial<Pick<IconifyIconData, 'width' | 'height' | 'rotate' | 'hFlip' | 'vFlip'>>): ResolvedIconData | null;
+declare function generateSvg(resolved: ResolvedIconData, options?: {
+  className?: string;
+  style?: Record<string, string>;
+  ariaHidden?: boolean;
+  ariaLabel?: string;
+  title?: string;
+}): string;
+declare function escapeHtml(str: string): string;
+declare function getIcon(name: string): Promise<ResolvedIconData | null>;
+declare function getIconSync(name: string): ResolvedIconData | null;
+declare function listLoadedCollections(): string[];
+declare function clearCollections(): void;
+declare function scanVueSfcForIcons(source: string): Set<string>;
+declare function parseSvgToIconData(svg: string): IconifyIconData | null;
+declare function createCollectionFromSvgMap(prefix: string, icons: Record<string, string>): IconifyCollection;
+//#endregion
+//#region src/runtime.d.ts
+declare let config: {
+  fallbackToApi: boolean;
+  iconApiEndpoint: string;
+  ssr: boolean;
+  iconifyApiEnabled: boolean;
+};
+declare function configureIconRuntime(options: Partial<typeof config>): void;
+declare function getIconConfig(): {
+  fallbackToApi: boolean;
+  iconApiEndpoint: string;
+  ssr: boolean;
+  iconifyApiEnabled: boolean;
+};
+declare function fetchIconFromApi(name: string, apiEndpoint?: string): Promise<string | null>;
+declare function buildIconCssIcon(name: string, options?: {
+  size?: string | number;
+  color?: string;
+  className?: string;
+}): {
+  className: string;
+  style: string;
+};
+//#endregion
+export { scanVueSfcForIcons as S, parseSvgToIconData as _, clearCollections as a, resolveAlias as b, generateSvg as c, getIconSync as d, getLoadedCollection as f, parseIconName as g, normalizeIconName as h, getIconConfig as i, getIcon as l, loadCollection as m, configureIconRuntime as n, createCollectionFromSvgMap as o, listLoadedCollections as p, fetchIconFromApi as r, escapeHtml as s, buildIconCssIcon as t, getIconData as u, registerCollection as v, resolveIconData as x, registerCollectionLoader as y };

package/dist/runtime.d.ts

@@ -0,0 +1,3 @@
+import { a as IconifyIconData, c as ScannedIconUsage, i as IconifyCollection, n as IconCollectionLoader, o as ResolvedCustomCollection, r as IconifyAlias, s as ResolvedIconData, t as CustomCollectionDirConfig } from "./types-CVT8GSd7.js";
+import { S as scanVueSfcForIcons, _ as parseSvgToIconData, a as clearCollections, b as resolveAlias, c as generateSvg, d as getIconSync, f as getLoadedCollection, g as parseIconName, h as normalizeIconName, i as getIconConfig, l as getIcon, m as loadCollection, n as configureIconRuntime, o as createCollectionFromSvgMap, p as listLoadedCollections, r as fetchIconFromApi, s as escapeHtml, t as buildIconCssIcon, u as getIconData, v as registerCollection, x as resolveIconData, y as registerCollectionLoader } from "./runtime-Hp8OXvtC.js";
+export { type CustomCollectionDirConfig, type IconCollectionLoader, type IconifyAlias, type IconifyCollection, type IconifyIconData, type ResolvedCustomCollection, type ResolvedIconData, type ScannedIconUsage, buildIconCssIcon, clearCollections, configureIconRuntime, createCollectionFromSvgMap, escapeHtml, fetchIconFromApi, generateSvg, getIcon, getIconConfig, getIconData, getIconSync, getLoadedCollection, listLoadedCollections, loadCollection, normalizeIconName, parseIconName, parseSvgToIconData, registerCollection, registerCollectionLoader, resolveAlias, resolveIconData, scanVueSfcForIcons };

package/dist/runtime.js

@@ -0,0 +1,40 @@
+import { _ as resolveIconData, a as getIcon, c as getLoadedCollection, d as normalizeIconName, f as parseIconName, g as resolveAlias, h as registerCollectionLoader, i as generateSvg, l as listLoadedCollections, m as registerCollection, n as createCollectionFromSvgMap, o as getIconData, p as parseSvgToIconData, r as escapeHtml, s as getIconSync, t as clearCollections, u as loadCollection, v as scanVueSfcForIcons } from "./core-NcYHbOE5.js";
+//#region src/runtime.ts
+let config = {
+	fallbackToApi: true,
+	iconApiEndpoint: "https://api.iconify.design",
+	ssr: true,
+	iconifyApiEnabled: true
+};
+function configureIconRuntime(options) {
+	config = {
+		...config,
+		...options
+	};
+}
+function getIconConfig() {
+	return { ...config };
+}
+async function fetchIconFromApi(name, apiEndpoint = config.iconApiEndpoint) {
+	const parsed = parseIconName(name);
+	if (!parsed) return null;
+	try {
+		const url = `${apiEndpoint}/${parsed.collection}/${parsed.icon}.svg`;
+		const res = await fetch(url);
+		if (!res.ok) return null;
+		return await res.text();
+	} catch {
+		return null;
+	}
+}
+function buildIconCssIcon(name, options) {
+	const { size = "1em", color = "currentColor", className = "" } = options ?? {};
+	const parsed = parseIconName(name);
+	const baseClass = `i-${parsed?.collection || ""}-${parsed?.icon || name}`;
+	return {
+		className: className ? `${baseClass} ${className}` : baseClass,
+		style: `display:inline-block;width:${size};height:${size};color:${color};background-color:currentColor;mask-size:100% 100%;mask-repeat:no-repeat;mask-position:center;-webkit-mask-size:100% 100%;-webkit-mask-repeat:no-repeat;-webkit-mask-position:center;`
+	};
+}
+//#endregion
+export { buildIconCssIcon, clearCollections, configureIconRuntime, createCollectionFromSvgMap, escapeHtml, fetchIconFromApi, generateSvg, getIcon, getIconConfig, getIconData, getIconSync, getLoadedCollection, listLoadedCollections, loadCollection, normalizeIconName, parseIconName, parseSvgToIconData, registerCollection, registerCollectionLoader, resolveAlias, resolveIconData, scanVueSfcForIcons };

package/dist/types-CVT8GSd7.d.ts

@@ -0,0 +1,57 @@
+//#region src/types.d.ts
+interface IconifyCollection {
+  prefix: string;
+  width?: number;
+  height?: number;
+  icons: Record<string, IconifyIconData>;
+  aliases?: Record<string, IconifyAlias>;
+}
+interface IconifyIconData {
+  body: string;
+  width?: number;
+  height?: number;
+  viewBox?: string;
+  rotate?: number;
+  hFlip?: boolean;
+  vFlip?: boolean;
+}
+interface IconifyAlias extends Partial<IconifyIconData> {
+  parent: string;
+}
+interface ResolvedIconData {
+  body: string;
+  width?: number;
+  height?: number;
+  viewBox?: string;
+}
+interface UbeanIconOptions {
+  collections?: Record<string, IconifyCollection | (() => Promise<IconifyCollection>)>;
+  customCollections?: Record<string, string | CustomCollectionDirConfig>;
+  fallbackToApi?: boolean;
+  iconApiEndpoint?: string;
+  ssr?: boolean;
+  cssSelectorPrefix?: string;
+  cssWherePseudo?: boolean;
+  iconifyApiEnabled?: boolean;
+}
+interface CustomCollectionDirConfig {
+  dir: string;
+  prefix?: string;
+  normalizeIconName?: (name: string) => string;
+}
+interface ResolvedCustomCollection {
+  prefix: string;
+  dir: string;
+  normalizeIconName: (name: string) => string;
+}
+interface IconCollectionLoader {
+  prefix: string;
+  load: () => Promise<IconifyCollection>;
+}
+interface ScannedIconUsage {
+  name: string;
+  collection: string;
+  icon: string;
+}
+//#endregion
+export { IconifyIconData as a, ScannedIconUsage as c, IconifyCollection as i, UbeanIconOptions as l, IconCollectionLoader as n, ResolvedCustomCollection as o, IconifyAlias as r, ResolvedIconData as s, CustomCollectionDirConfig as t };