@iconify/css-solid 1.0.0

package/dist/basic.d.ts

@@ -0,0 +1,9 @@
+import { CSSIconComponentProps, CSSIconComponentViewbox, CSSIconElementProps } from "./props.js";
+import { JSX } from "solid-js";
+/**
+ * Basic icon component, without fallback
+ *
+ * Can be used when you do not need a fallback icon
+ */
+declare function Icon(props: CSSIconElementProps): JSX.Element;
+export { type CSSIconComponentProps, type CSSIconComponentViewbox, type CSSIconElementProps, Icon };

package/dist/basic.js

@@ -0,0 +1,31 @@
+import { t as renderContent } from "./content-CDW-lEJw.js";
+import { t as getSizeProps } from "./size-B1gNk5pj.js";
+import { createMemo, splitProps } from "solid-js";
+import { mergeProps, spread, template } from "solid-js/web";
+
+const _tmpl$ = /* @__PURE__ */ template(`<svg xmlns=http://www.w3.org/2000/svg>`);
+/**
+* Basic icon component, without fallback
+*
+* Can be used when you do not need a fallback icon
+*/
+function Icon(props) {
+	const [local, others] = splitProps(props, [
+		"content",
+		"fallback",
+		"width",
+		"height",
+		"viewBox"
+	]);
+	const renderedContent = createMemo(() => renderContent(local.content || ""));
+	const size = createMemo(() => getSizeProps(local.width, local.height, local.viewBox));
+	return (() => {
+		const _el$ = _tmpl$();
+		spread(_el$, mergeProps(size, others, { get innerHTML() {
+			return renderedContent();
+		} }), true, false);
+		return _el$;
+	})();
+}
+
+export { Icon };

package/dist/content-CDW-lEJw.js

@@ -0,0 +1,164 @@
+import { n as replaceIDs } from "./id-T2WpjqBw.js";
+import { n as defaultIconProps, r as defaultIconTransformations } from "./defaults-Chz3Ncto.js";
+import { n as calculateSize } from "./size-B1gNk5pj.js";
+
+/**
+* Default icon customisations values
+*/
+const defaultIconSizeCustomisations = Object.freeze({
+	width: null,
+	height: null
+});
+const defaultIconCustomisations = Object.freeze({
+	...defaultIconSizeCustomisations,
+	...defaultIconTransformations
+});
+
+function splitSVGDefs(content, tag = "defs") {
+	let defs = "";
+	const index = content.indexOf("<" + tag);
+	while (index >= 0) {
+		const start = content.indexOf(">", index);
+		const end = content.indexOf("</" + tag);
+		if (start === -1 || end === -1) break;
+		const endEnd = content.indexOf(">", end);
+		if (endEnd === -1) break;
+		defs += content.slice(start + 1, end).trim();
+		content = content.slice(0, index).trim() + content.slice(endEnd + 1);
+	}
+	return {
+		defs,
+		content
+	};
+}
+/**
+* Merge defs and content
+*/
+function mergeDefsAndContent(defs, content) {
+	return defs ? "<defs>" + defs + "</defs>" + content : content;
+}
+/**
+* Wrap SVG content, without wrapping definitions
+*/
+function wrapSVGContent(body, start, end) {
+	const split = splitSVGDefs(body);
+	return mergeDefsAndContent(split.defs, start + split.content + end);
+}
+
+/**
+* Check if value should be unset. Allows multiple keywords
+*/
+const isUnsetKeyword = (value) => value === "unset" || value === "undefined" || value === "none";
+/**
+* Get SVG attributes and content from icon + customisations
+*
+* Does not generate style to make it compatible with frameworks that use objects for style, such as React.
+* Instead, it generates 'inline' value. If true, rendering engine should add verticalAlign: -0.125em to icon.
+*
+* Customisations should be normalised by platform specific parser.
+* Result should be converted to <svg> by platform specific parser.
+* Use replaceIDs to generate unique IDs for body.
+*/
+function iconToSVG(icon, customisations) {
+	const fullIcon = {
+		...defaultIconProps,
+		...icon
+	};
+	const fullCustomisations = {
+		...defaultIconCustomisations,
+		...customisations
+	};
+	const box = {
+		left: fullIcon.left,
+		top: fullIcon.top,
+		width: fullIcon.width,
+		height: fullIcon.height
+	};
+	let body = fullIcon.body;
+	[fullIcon, fullCustomisations].forEach((props) => {
+		const transformations = [];
+		const hFlip = props.hFlip;
+		const vFlip = props.vFlip;
+		let rotation = props.rotate;
+		if (hFlip) if (vFlip) rotation += 2;
+		else {
+			transformations.push("translate(" + (box.width + box.left).toString() + " " + (0 - box.top).toString() + ")");
+			transformations.push("scale(-1 1)");
+			box.top = box.left = 0;
+		}
+		else if (vFlip) {
+			transformations.push("translate(" + (0 - box.left).toString() + " " + (box.height + box.top).toString() + ")");
+			transformations.push("scale(1 -1)");
+			box.top = box.left = 0;
+		}
+		let tempValue;
+		if (rotation < 0) rotation -= Math.floor(rotation / 4) * 4;
+		rotation = rotation % 4;
+		switch (rotation) {
+			case 1:
+				tempValue = box.height / 2 + box.top;
+				transformations.unshift("rotate(90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+				break;
+			case 2:
+				transformations.unshift("rotate(180 " + (box.width / 2 + box.left).toString() + " " + (box.height / 2 + box.top).toString() + ")");
+				break;
+			case 3:
+				tempValue = box.width / 2 + box.left;
+				transformations.unshift("rotate(-90 " + tempValue.toString() + " " + tempValue.toString() + ")");
+				break;
+		}
+		if (rotation % 2 === 1) {
+			if (box.left !== box.top) {
+				tempValue = box.left;
+				box.left = box.top;
+				box.top = tempValue;
+			}
+			if (box.width !== box.height) {
+				tempValue = box.width;
+				box.width = box.height;
+				box.height = tempValue;
+			}
+		}
+		if (transformations.length) body = wrapSVGContent(body, "<g transform=\"" + transformations.join(" ") + "\">", "</g>");
+	});
+	const customisationsWidth = fullCustomisations.width;
+	const customisationsHeight = fullCustomisations.height;
+	const boxWidth = box.width;
+	const boxHeight = box.height;
+	let width;
+	let height;
+	if (customisationsWidth === null) {
+		height = customisationsHeight === null ? "1em" : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+		width = calculateSize(height, boxWidth / boxHeight);
+	} else {
+		width = customisationsWidth === "auto" ? boxWidth : customisationsWidth;
+		height = customisationsHeight === null ? calculateSize(width, boxHeight / boxWidth) : customisationsHeight === "auto" ? boxHeight : customisationsHeight;
+	}
+	const attributes = {};
+	const setAttr = (prop, value) => {
+		if (!isUnsetKeyword(value)) attributes[prop] = value.toString();
+	};
+	setAttr("width", width);
+	setAttr("height", height);
+	const viewBox = [
+		box.left,
+		box.top,
+		boxWidth,
+		boxHeight
+	];
+	attributes.viewBox = viewBox.join(" ");
+	return {
+		attributes,
+		viewBox,
+		body
+	};
+}
+
+/**
+* Convert content to string, replacing IDs to make them unique
+*/
+function renderContent(content) {
+	return replaceIDs(typeof content === "string" ? content : iconToSVG(content).body);
+}
+
+export { renderContent as t };

package/dist/create-Dw3RUxi7.js

@@ -0,0 +1,66 @@
+import { t as matchIconName } from "./name-IUXED86s.js";
+
+const indexCache = /* @__PURE__ */ new Map();
+const delay = 750;
+let _fetch = fetch;
+/**
+* Set custom fetch function
+*/
+function setFetch(fetchFn) {
+	_fetch = fetchFn;
+}
+/**
+* Fetch JSON data
+*/
+function fetchJSON(hosts, endpoint, init, controller) {
+	const cacheKey = hosts.join(",");
+	const startIndex = indexCache.get(cacheKey) || 0;
+	const total = hosts.length;
+	controller = controller || new AbortController();
+	init = init || {};
+	init.signal = controller.signal;
+	const promises = [];
+	for (let i = 0; i < total; i++) {
+		const scopeIndex = i;
+		const index = (startIndex + scopeIndex) % total;
+		const url = `${hosts[index]}${endpoint}`;
+		const promise = async () => {
+			for (let i = 0; i < scopeIndex; i++) {
+				await new Promise((resolve) => setTimeout(resolve, delay));
+				if (controller.signal.aborted) throw new Error("Fetch aborted");
+			}
+			const response = await _fetch(url, init);
+			if (!response.ok) throw new Error(`HTTP error! status: ${response.status}`);
+			const result = await response.json();
+			indexCache.set(cacheKey, index);
+			controller.abort();
+			return result;
+		};
+		promises.push(promise());
+	}
+	return Promise.any(promises);
+}
+
+/**
+* Create loader for Iconify API
+*/
+function createIconifyAPILoader(host, init, checkSSR = true) {
+	const hosts = Array.isArray(host) ? host : [host];
+	const isSSR = checkSSR ? typeof window === "undefined" || !window.document : checkSSR;
+	return {
+		maxCount: 32,
+		maxLength: 480,
+		validateNames: true,
+		hosts,
+		loadIcons: async (names, prefix) => {
+			if (isSSR || !matchIconName.test(prefix)) return {
+				prefix,
+				icons: Object.create(null),
+				not_found: names
+			};
+			return await fetchJSON(hosts, `/${prefix}.json?icons=${names.join(",")}`, init);
+		}
+	};
+}
+
+export { fetchJSON as n, setFetch as r, createIconifyAPILoader as t };

package/dist/defaults-Chz3Ncto.js

@@ -0,0 +1,26 @@
+/** Default values for dimensions */
+const defaultIconDimensions = Object.freeze({
+	left: 0,
+	top: 0,
+	width: 16,
+	height: 16
+});
+/** Default values for transformations */
+const defaultIconTransformations = Object.freeze({
+	rotate: 0,
+	vFlip: false,
+	hFlip: false
+});
+/** Default values for all optional IconifyIcon properties */
+const defaultIconProps = Object.freeze({
+	...defaultIconDimensions,
+	...defaultIconTransformations
+});
+/** Default values for all properties used in ExtendedIconifyIcon */
+const defaultExtendedIconProps = Object.freeze({
+	...defaultIconProps,
+	body: "",
+	hidden: false
+});
+
+export { defaultIconProps as n, defaultIconTransformations as r, defaultExtendedIconProps as t };

package/dist/helpers/add.d.ts

@@ -0,0 +1,6 @@
+import { IconifyJSON } from "@iconify/types";
+/**
+ * Add icon set to storage
+ */
+declare function addIconSetToStorage(data: IconifyJSON, provider?: string): Set<string>;
+export { addIconSetToStorage as addIconSet };

package/dist/helpers/add.js

@@ -0,0 +1,4 @@
+import { t as addIconSetToStorage } from "../parse-BHmkG8X9.js";
+import "../storage-B47thT4x.js";
+
+export { addIconSetToStorage as addIconSet };

package/dist/helpers/api.d.ts

@@ -0,0 +1,63 @@
+import { IconifyIcon, IconifyJSON } from "@iconify/types";
+/**
+ * Set custom fetch function
+ */
+declare function setFetch(fetchFn: typeof fetch): void;
+/**
+ * Fetch JSON data
+ */
+declare function fetchJSON<T>(hosts: string[], endpoint: string, init?: RequestInit, controller?: AbortController): Promise<T>;
+/**
+ * Configuration for splitting queue into multiple queues
+ */
+interface QueueSplitConfig {
+  maxLength?: number;
+  maxCount?: number;
+}
+/**
+ * Loader for one icon
+ */
+type IconLoader = (name: string, prefix: string, provider: string) => Promise<IconifyIcon | null>;
+interface ConfigWithIconLoader {
+  loadIcon: IconLoader;
+}
+/**
+ * Loader for multiple icons at once
+ */
+type BulkIconLoader = (names: string[], prefix: string, provider: string) => Promise<IconifyJSON | null>;
+interface ConfigWithBulkIconLoader {
+  loadIcons: BulkIconLoader;
+}
+/**
+ * Loader: either for one icon or multiple icons
+ */
+type IconLoaderConfig = ConfigWithIconLoader | ConfigWithBulkIconLoader;
+/**
+ * Various properties
+ */
+interface ConfigProps extends QueueSplitConfig {
+  validateNames?: boolean;
+  allowReload?: boolean;
+  hosts?: string[];
+}
+/**
+ * Configuration for loader
+ */
+type LoaderConfig = ConfigProps & IconLoaderConfig;
+/**
+ * Create loader for Iconify API
+ */
+declare function createIconifyAPILoader(host: string | string[], init?: RequestInit, checkSSR?: boolean): LoaderConfig;
+/**
+ * Set custom loader for an icon set
+ */
+declare function setLoader(prefix: string, loader: LoaderConfig): void;
+/**
+ * Set custom loader for a provider
+ */
+declare function setProviderLoader(provider: string, loader: LoaderConfig): void;
+/**
+ * Get loader
+ */
+declare function getLoader(provider: string, prefix: string): LoaderConfig | undefined;
+export { type LoaderConfig, createIconifyAPILoader, fetchJSON, getLoader, setFetch, setLoader, setProviderLoader };

package/dist/helpers/api.js

@@ -0,0 +1,4 @@
+import { n as setLoader, r as setProviderLoader, t as getLoader } from "../loaders-DBdOeKSg.js";
+import { n as fetchJSON, r as setFetch, t as createIconifyAPILoader } from "../create-Dw3RUxi7.js";
+
+export { createIconifyAPILoader, fetchJSON, getLoader, setFetch, setLoader, setProviderLoader };

package/dist/helpers/get-icon.d.ts

@@ -0,0 +1,9 @@
+import { t as IconifyIconName } from "../name-DNHxp3hA.js";
+import { IconifyIcon } from "@iconify/types";
+/**
+ * Get icon data
+ *
+ * Returns icon data if icon is loaded, null if icon is missing, undefined if icon is unknown
+ */
+declare function getLoadedIcon(iconName: string | IconifyIconName): IconifyIcon | null | undefined;
+export { getLoadedIcon };

package/dist/helpers/get-icon.js

@@ -0,0 +1,16 @@
+import { n as stringToIcon } from "../name-IUXED86s.js";
+import { t as getIconStorage } from "../storage-B47thT4x.js";
+
+/**
+* Get icon data
+*
+* Returns icon data if icon is loaded, null if icon is missing, undefined if icon is unknown
+*/
+function getLoadedIcon(iconName) {
+	const icon = typeof iconName === "string" ? stringToIcon(iconName) : iconName;
+	if (!icon) return null;
+	const storage = getIconStorage(icon.provider, icon.prefix);
+	return storage.icons[icon.name] ?? (storage.missing.has(icon.name) ? null : void 0);
+}
+
+export { getLoadedIcon };

package/dist/helpers/ids.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Clear ID cache
+ */
+declare function clearIDCache(): void;
+export { clearIDCache };

package/dist/helpers/ids.js

@@ -0,0 +1,3 @@
+import { t as clearIDCache } from "../id-T2WpjqBw.js";
+
+export { clearIDCache };

package/dist/helpers/load-icon.d.ts

@@ -0,0 +1,7 @@
+import { t as IconifyIconName } from "../name-DNHxp3hA.js";
+import { IconifyIcon } from "@iconify/types";
+/**
+ * Load icon
+ */
+declare function loadIcon(iconName: string | IconifyIconName): Promise<IconifyIcon | null>;
+export { loadIcon };

package/dist/helpers/load-icon.js

@@ -0,0 +1,32 @@
+import "../loaders-DBdOeKSg.js";
+import { n as stringToIcon } from "../name-IUXED86s.js";
+import "../parse-BHmkG8X9.js";
+import { t as getIconStorage } from "../storage-B47thT4x.js";
+import { n as unsubscribeFromIconStorage, t as subscribeToIconStorage } from "../subscription-CamYRvPj.js";
+import { t as loadIcons } from "../queue-Bmgy8iLP.js";
+
+/**
+* Load icon
+*/
+function loadIcon(iconName) {
+	return new Promise((resolve) => {
+		const icon = typeof iconName === "string" ? stringToIcon(iconName) : iconName;
+		if (!icon) return resolve(null);
+		const { provider, prefix, name } = icon;
+		const storage = getIconStorage(provider, prefix);
+		const check = () => {
+			if (storage.icons[name]) resolve(storage.icons[name]);
+			else if (storage.missing.has(name)) resolve(null);
+			else return true;
+		};
+		if (check()) {
+			const subscriber = subscribeToIconStorage(storage, [name], () => {
+				unsubscribeFromIconStorage(storage, subscriber);
+				if (check()) resolve(null);
+			});
+			loadIcons({ [provider]: { [prefix]: [name] } });
+		}
+	});
+}
+
+export { loadIcon };

package/dist/helpers/load-icons.d.ts

@@ -0,0 +1,16 @@
+import { t as IconifyIconName } from "../name-DNHxp3hA.js";
+/**
+ * Provider specific data mixin: [prefix] = T
+ */
+type ProviderData<T> = Record<string, T>;
+/**
+ * Icons data mixin: [provider][prefix] = T
+ */
+type IconsData<T> = Record<string, ProviderData<T>>;
+/**
+ * Load icon(s)
+ *
+ * Returns function that can be used to cancel loading
+ */
+declare function loadIconsWithCallback(iconNames: (string | IconifyIconName)[] | IconsData<string[]>, callback: (loaded: string[], missing: string[], pending: string[]) => void): () => void;
+export { loadIconsWithCallback };

package/dist/helpers/load-icons.js

@@ -0,0 +1,84 @@
+import "../loaders-DBdOeKSg.js";
+import "../parse-BHmkG8X9.js";
+import { n as iterateIconStorage, t as getIconStorage } from "../storage-B47thT4x.js";
+import { n as unsubscribeFromIconStorage, t as subscribeToIconStorage } from "../subscription-CamYRvPj.js";
+import { n as splitIconNames, t as loadIcons } from "../queue-Bmgy8iLP.js";
+
+/**
+* Unsubscribe from all icon storage updates
+*/
+function unsubscribeFromAllIconStorage(key) {
+	iterateIconStorage((storage) => {
+		unsubscribeFromIconStorage(storage, key);
+	});
+}
+/**
+* Watch icon storage updates for specific names
+*/
+function toggleIconStorage(names, callback, key) {
+	key = key || Symbol();
+	for (const provider in names) {
+		const prefixes = names[provider];
+		for (const prefix in prefixes) {
+			const icons = prefixes[prefix];
+			const storage = getIconStorage(provider, prefix);
+			if (icons.length) subscribeToIconStorage(storage, icons, callback, key);
+			else unsubscribeFromIconStorage(storage, key);
+		}
+	}
+	return key;
+}
+
+/**
+* Load icon(s)
+*
+* Returns function that can be used to cancel loading
+*/
+function loadIconsWithCallback(iconNames, callback) {
+	const key = Symbol();
+	let aborted = false;
+	const abort = () => {
+		aborted = true;
+		unsubscribeFromAllIconStorage(key);
+	};
+	const icons = Array.isArray(iconNames) ? splitIconNames(iconNames) : iconNames;
+	let lastPending = -1;
+	const check = () => {
+		const loaded = [];
+		const missing = [];
+		const pending = [];
+		for (const provider in icons) {
+			const providerData = icons[provider];
+			for (const prefix in providerData) {
+				const names = providerData[prefix];
+				if (names.length) {
+					const storage = getIconStorage(provider, prefix);
+					for (const name of names) {
+						const partialName = `${prefix}:${name}`;
+						const fullName = provider ? `@${provider}:${partialName}` : partialName;
+						if (storage.icons[name]) loaded.push(fullName);
+						else if (storage.missing.has(name)) missing.push(fullName);
+						else pending.push(fullName);
+					}
+				}
+			}
+		}
+		if (lastPending === -1 || lastPending !== pending.length) {
+			lastPending = pending.length;
+			if (loaded.length || missing.length) callback(loaded, missing, pending);
+		}
+	};
+	check();
+	if (lastPending > 0) {
+		toggleIconStorage(icons, () => {
+			if (!aborted) {
+				check();
+				if (!lastPending) abort();
+			}
+		}, key);
+		loadIcons(icons);
+	}
+	return abort;
+}
+
+export { loadIconsWithCallback };

package/dist/helpers/preload.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Preload icons used in fallback mode
+ *
+ * Icons are preloaded only if fallback mode is used
+ */
+declare function preloadIcons(iconNames: string[]): void;
+export { preloadIcons };

package/dist/helpers/preload.js

@@ -0,0 +1,16 @@
+import "../loaders-DBdOeKSg.js";
+import "../parse-BHmkG8X9.js";
+import "../storage-B47thT4x.js";
+import { n as splitIconNames, t as loadIcons } from "../queue-Bmgy8iLP.js";
+import { t as renderCSS } from "../status-AnfUd3wQ.js";
+
+/**
+* Preload icons used in fallback mode
+*
+* Icons are preloaded only if fallback mode is used
+*/
+function preloadIcons(iconNames) {
+	if (!renderCSS) loadIcons(splitIconNames(iconNames), true);
+}
+
+export { preloadIcons };

package/dist/helpers/size.d.ts

@@ -0,0 +1,16 @@
+interface Size {
+  width?: string;
+  height?: string;
+  viewBox?: string;
+}
+interface ViewBox {
+  width: number;
+  height: number;
+  left?: number;
+  top?: number;
+}
+/**
+ * Get size properties for icon
+ */
+declare function getSizeProps(width: string | undefined, height: string | undefined, ratio: number | ViewBox): Size;
+export { getSizeProps };

package/dist/helpers/size.js

@@ -0,0 +1,3 @@
+import { t as getSizeProps } from "../size-B1gNk5pj.js";
+
+export { getSizeProps };

package/dist/helpers/subscribe.d.ts

@@ -0,0 +1,17 @@
+import { t as IconifyIconName } from "../name-DNHxp3hA.js";
+import { IconifyIcon } from "@iconify/types";
+type Callback = (data: IconifyIcon | null | undefined) => void;
+interface Result {
+  change: (iconName: string | IconifyIconName | IconifyIcon) => void;
+  unsubscribe: () => void;
+  data: IconifyIcon | null | undefined;
+}
+/**
+ * Subscribe to icon data updates
+ *
+ * Can change icon name to watch updates for different icon
+ *
+ * Intended to be used with reactive frameworks to watch for icon data when name can change
+ */
+declare function subscribeToIconData(iconToRender: string | IconifyIconName | IconifyIcon, callback: Callback): Result;
+export { subscribeToIconData };

package/dist/helpers/subscribe.js

@@ -0,0 +1,7 @@
+import "../loaders-DBdOeKSg.js";
+import "../parse-BHmkG8X9.js";
+import "../storage-B47thT4x.js";
+import "../queue-Bmgy8iLP.js";
+import { t as subscribeToIconData } from "../subscribe-B6af4-2Z.js";
+
+export { subscribeToIconData };

package/dist/helpers/support.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Check if browser supports `d` property in CSS
+ *
+ * On failure to check, assume that it is supported.
+ */
+declare function supportsCSS(): boolean;
+export { supportsCSS };

package/dist/helpers/support.js

@@ -0,0 +1,3 @@
+import { t as supportsCSS } from "../support-CYSnYd4U.js";
+
+export { supportsCSS };