tempest-react-sdk 0.46.0 → 0.48.0

package/dist/icons-virtual.d.ts

@@ -1,22 +1,30 @@
-/**
- * Types for the module the `tempestIcons()` Vite plugin generates.
- *
- * Reference it once from an app's `vite-env.d.ts` (or any ambient `.d.ts`):
- *
- *     /// <reference types="tempest-react-sdk/icons/virtual" />
- *
- * Without it, `import { staticIcons } from "virtual:tempest-icons"` is an
- * unresolved module to `tsc`, even though Vite resolves it at build time.
- */
-declare module "virtual:tempest-icons" {
-    import type { LucideIcon } from "lucide-react";
-
-    /**
-     * Every icon slug found as a literal in the scanned source, mapped to the
-     * statically imported lucide component.
-     *
-     * Pass it to `IconProvider`'s `registry` prop. Slugs resolved from here cost
-     * no extra request — they are ordinary imports the bundler tree-shakes.
-     */
-    export const staticIcons: Record<string, LucideIcon>;
-}
+/// <reference path="./icons-virtual-id.d.ts" />
+import { LucideIcon } from 'lucide-react';
+
+/** A slug → icon-component table, as produced by `createIconRegistry`. */
+declare type IconRegistry = Readonly<Record<string, LucideIcon>>;
+
+/**
+ * The static icon registry, empty until a build plugin fills it in.
+ *
+ * `tempestIcons()` resolves this module id to the table it generated from the
+ * slugs your source mentions. Every other runner — vitest without the plugin,
+ * `tsx`, a Storybook builder, a Node script that imports a component — gets this
+ * stub, so the import always resolves and `<Icon>` falls back to fetching shards.
+ *
+ * That fallback is why the stub exists: before it, an app that imported the
+ * registry could not be loaded outside a Vite build with the plugin installed,
+ * and the failure was the whole module graph refusing to resolve rather than one
+ * icon going missing.
+ *
+ * @example
+ * import { IconProvider } from "tempest-react-sdk/icons";
+ * import { staticIcons } from "tempest-react-sdk/icons/virtual";
+ *
+ * <IconProvider registry={staticIcons}>
+ *     <App />
+ * </IconProvider>
+ */
+export declare const staticIcons: IconRegistry;
+
+export { }

package/dist/icons-virtual.js

@@ -0,0 +1,6 @@
+//#region src/icons/virtual.ts
+var e = {};
+//#endregion
+export { e as staticIcons };
+
+//# sourceMappingURL=icons-virtual.js.map

package/dist/icons-virtual.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"icons-virtual.js","names":[],"sources":["../src/icons/virtual.ts"],"sourcesContent":["import type { IconRegistry } from \"./icon-context\";\n\n/**\n * The static icon registry, empty until a build plugin fills it in.\n *\n * `tempestIcons()` resolves this module id to the table it generated from the\n * slugs your source mentions. Every other runner — vitest without the plugin,\n * `tsx`, a Storybook builder, a Node script that imports a component — gets this\n * stub, so the import always resolves and `<Icon>` falls back to fetching shards.\n *\n * That fallback is why the stub exists: before it, an app that imported the\n * registry could not be loaded outside a Vite build with the plugin installed,\n * and the failure was the whole module graph refusing to resolve rather than one\n * icon going missing.\n *\n * @example\n * import { IconProvider } from \"tempest-react-sdk/icons\";\n * import { staticIcons } from \"tempest-react-sdk/icons/virtual\";\n *\n * <IconProvider registry={staticIcons}>\n *     <App />\n * </IconProvider>\n */\nexport const staticIcons: IconRegistry = {};\n"],"mappings":";AAuBA,IAAa,IAA4B,CAAC"}

package/dist/icons.cjs

@@ -1 +1 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./icons/generated/aliases.cjs"),t=require("./icons/generated/icon-names.cjs"),n=require("./icons/icon-context.cjs"),r=require("./icons/shard-cache.cjs"),i=require("./icons/use-icon.cjs"),a=require("./icons/Icon.cjs"),o=require("./icons/IconProvider.cjs"),s=require("./icons/is-icon-name.cjs"),c=require("./icons/material-symbols.cjs");exports.Icon=a.Icon,exports.IconProvider=o.IconProvider,exports.MATERIAL_SYMBOL_FALLBACK=c.MATERIAL_SYMBOL_FALLBACK,exports.createIconRegistry=n.createIconRegistry,exports.fromMaterialSymbol=c.fromMaterialSymbol,exports.iconAliases=e.iconAliases,exports.iconNames=t.iconNames,exports.iconStatus=r.iconStatus,exports.isIconName=s.isIconName,exports.loadIcon=r.loadIcon,exports.materialToLucide=c.materialToLucide,exports.peekIcon=r.peekIcon,exports.preloadIcons=r.preloadIcons,exports.resolveIconAlias=r.resolveIconAlias,exports.useIcon=i.useIcon;
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./icons/generated/aliases.cjs"),t=require("./icons/generated/icon-names.cjs"),n=require("./icons/icon-context.cjs"),r=require("./icons/alias.cjs"),i=require("./icons/normalize-icon-name.cjs"),a=require("./icons/shard-cache.cjs"),o=require("./icons/use-icon.cjs"),s=require("./icons/Icon.cjs"),c=require("./icons/is-icon-name.cjs"),l=require("./icons/validate-icon-name.cjs"),u=require("./icons/IconPicker.cjs"),d=require("./icons/IconProvider.cjs"),f=require("./icons/material-symbols.cjs");exports.DEFAULT_ICON_PICKER_MESSAGE=l.DEFAULT_ICON_PICKER_MESSAGE,exports.Icon=s.Icon,exports.IconPicker=u.IconPicker,exports.IconProvider=d.IconProvider,exports.MATERIAL_SYMBOL_FALLBACK=f.MATERIAL_SYMBOL_FALLBACK,exports.createIconRegistry=n.createIconRegistry,exports.fromMaterialSymbol=f.fromMaterialSymbol,exports.iconAliases=e.iconAliases,exports.iconNames=t.iconNames,exports.iconStatus=a.iconStatus,exports.isIconName=c.isIconName,exports.loadIcon=a.loadIcon,exports.materialToLucide=f.materialToLucide,exports.normalizeIconName=i.normalizeIconName,exports.peekIcon=a.peekIcon,exports.preloadIcons=a.preloadIcons,exports.registerIcons=a.registerIcons,exports.resolveIconAlias=r.resolveIconAlias,exports.subscribeToIconErrors=a.subscribeToIconErrors,exports.useIcon=o.useIcon,exports.validateIconName=l.validateIconName;

package/dist/icons.d.ts

@@ -1,3 +1,5 @@
+/// <reference path="./icons-virtual-id.d.ts" />
+import { InputHTMLAttributes } from 'react';
 import { LucideIcon } from 'lucide-react';
 import { ReactNode } from 'react';
 import { SVGProps } from 'react';
@@ -20,6 +22,9 @@ import { SVGProps } from 'react';
  */
 export declare function createIconRegistry(icons: Record<string, LucideIcon>): IconRegistry;
 
+/** The default message for a slug lucide does not ship. */
+export declare const DEFAULT_ICON_PICKER_MESSAGE = "\u00CDcone inexistente. Use um slug do lucide, em kebab-case.";
+
 /**
  * Translate a Material Symbols code into a lucide slug, always returning one.
  *
@@ -56,11 +61,16 @@ export declare function fromMaterialSymbol(code: string | null | undefined, fall
  * An unknown slug renders `fallback` (nothing, by default) and warns in dev only
  * — it never throws, because a bad name from an API must not take down the tree.
  *
+ * `name` is normalized before the lookup, so a stored `icon_code` renders whether
+ * it was written `shopping_cart`, `" Save"` or under a slug lucide has since
+ * deprecated. Pass `normalize={false}` for a strict lookup.
+ *
  * @example
  * <Icon name="save" size={18} />
  * <Icon name={row.iconSlug} fallback={<span className="skeleton" />} />
+ * <Icon icon={Wrench} size={18} />
  */
-export declare function Icon({ name, size, strokeWidth, fallback, ...rest }: IconProps): ReactNode;
+export declare function Icon({ name, icon, size, strokeWidth, fallback, normalize, ...rest }: IconProps): ReactNode;
 
 /**
  * Lucide's 257 deprecated slugs, mapped to the canonical slug that
@@ -72,6 +82,72 @@ export declare function Icon({ name, size, strokeWidth, fallback, ...rest }: Ico
  */
 export declare const iconAliases: Record<string, string>;
 
+declare interface IconBaseProps extends Omit<SVGProps<SVGSVGElement>, "ref" | "name"> {
+    /** Width and height in px. Defaults to the provider's value, then lucide's `24`. */
+    size?: number | string;
+    /** Stroke width. Defaults to the provider's value, then lucide's `2`. */
+    strokeWidth?: number;
+    /**
+     * Rendered while the icon's shard is in flight, and for a slug that does not
+     * exist at all. Defaults to nothing.
+     *
+     * Pass a same-sized placeholder when the surrounding layout would otherwise
+     * shift. Note that a slug already in the registry or the cache never renders
+     * this — it resolves during render.
+     */
+    fallback?: ReactNode;
+    /**
+     * Clean up `name` before looking it up. Default `true`.
+     *
+     * A stored `icon_code` arrives dirty — `shopping_cart`, `" Save"`, a slug
+     * lucide deprecated two releases ago — and normalizing is what makes those
+     * render instead of falling back. `false` asks for a strict lookup, for the
+     * case where you want an unexpected spelling to be visible rather than
+     * quietly repaired.
+     *
+     * Ignored when the icon is passed as a component.
+     */
+    normalize?: boolean;
+}
+
+/**
+ * Address the icon by component, for a call site that already imported it.
+ *
+ * No lookup, no registry, no shard: the component is rendered as passed. It is
+ * there so a screen mixing literal icons with data-driven ones can keep using one
+ * component instead of alternating between `<Icon name>` and `<Wrench />`, which
+ * is what makes the shared `size`/`strokeWidth` defaults apply to both.
+ */
+declare interface IconByComponentProps extends IconBaseProps {
+    icon: LucideIcon;
+    name?: never;
+}
+
+/**
+ * Address the icon by slug — the reason this component exists.
+ *
+ * The slug is typed as the union of every name lucide ships, so a typo is a
+ * compile error, while still accepting a plain `string` for the case that
+ * motivates the whole module: a name arriving from an API, a CMS or a config
+ * table.
+ */
+declare interface IconByNameProps extends IconBaseProps {
+    name: IconName | (string & {});
+    icon?: never;
+}
+
+/** What a shard failure reports to whoever subscribed. */
+export declare interface IconLoadError {
+    /** The shard key whose chunk could not be fetched. */
+    shard: string;
+    /** The slug whose render asked for it. */
+    slug: string;
+    /** Attempts made before giving up, retries included. */
+    attempts: number;
+    /** The last rejection from the dynamic import. */
+    error: unknown;
+}
+
 /**
  * Every icon slug lucide ships, as a union of string literals.
  *
@@ -89,30 +165,68 @@ export declare type IconName = "a-arrow-down" | "a-arrow-up" | "a-large-small" |
  */
 export declare const iconNames: readonly IconName[];
 
-export declare interface IconProps extends Omit<SVGProps<SVGSVGElement>, "ref"> {
+/**
+ * An icon field: native autocomplete over every lucide slug, plus a preview.
+ *
+ * Every panel that lets someone choose an icon was rewriting this — filter the
+ * list, cap the suggestions, build the `<datalist>`, and block submit when the
+ * typed name does not exist. That last step is the one that matters: without it
+ * an invalid value reaches the database and only shows up later as a missing icon
+ * on every screen that renders the record.
+ *
+ * Validation is wired to the **native** form: the input carries a custom validity
+ * message, so a plain `<form>` refuses to submit and the browser points at the
+ * field. `validateIconName` is exported for react-hook-form and zod.
+ *
+ * Built on `<datalist>` rather than a custom listbox on purpose: keyboard,
+ * screen-reader and mobile behaviour come from the platform, and the component
+ * stays small enough that its cost is the slug list it has to import — ~7 KB
+ * brotli, which only a picker pays.
+ *
+ * @example
+ * const [icon, setIcon] = useState("");
+ *
+ * <form onSubmit={save}>
+ *     <IconPicker value={icon} onChange={setIcon} required />
+ *     <button type="submit">Salvar</button>
+ * </form>
+ */
+export declare function IconPicker({ value, onChange, limit, previewSize, invalidMessage, emptyPreview, className, ...rest }: IconPickerProps): ReactNode;
+
+/**
+ * @tempest-limits props-count — value/onChange are the field, limit/placeholder
+ * the suggestion list, and previewSize/invalidMessage the two things a form
+ * around it needs to restyle or translate.
+ */
+export declare interface IconPickerProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "onChange" | "list" | "type"> {
+    /** The chosen slug. Always canonical — see `onChange`. */
+    value: string;
     /**
-     * The lucide slug, kebab-case: `"save"`, `"trash-2"`, `"circle-alert"`.
+     * Fires with the **canonical** slug on every keystroke.
      *
-     * Typed as the union of every slug lucide ships, so a typo is a compile
-     * error — while still accepting a plain `string` for the case this component
-     * exists for: a name that arrives from an API, a CMS or a config table.
+     * Legacy spellings are normalized on the way out (`Shopping_Cart` →
+     * `shopping-cart`, `alert-circle` → `circle-alert`), so what a form stores is
+     * what `<Icon>` resolves without further cleanup.
      */
-    name: IconName | (string & {});
-    /** Width and height in px. Defaults to the provider's value, then lucide's `24`. */
-    size?: number | string;
-    /** Stroke width. Defaults to the provider's value, then lucide's `2`. */
-    strokeWidth?: number;
+    onChange: (slug: string) => void;
     /**
-     * Rendered while the icon's shard is in flight, and for a slug that does not
-     * exist at all. Defaults to nothing.
+     * How many suggestions to render. Default `40`.
      *
-     * Pass a same-sized placeholder when the surrounding layout would otherwise
-     * shift. Note that a slug already in the registry or the cache never renders
-     * this — it resolves during render.
+     * There are 2024 slugs, and building every one as an `<option>` on each
+     * keystroke freezes the datalist — which is the reason this prop exists rather
+     * than a "show everything" default.
      */
-    fallback?: ReactNode;
+    limit?: number;
+    /** Size of the preview glyph, in px. Default `20`. */
+    previewSize?: number;
+    /** Overrides the message shown for a slug that does not exist. */
+    invalidMessage?: string;
+    /** Rendered in the preview box while nothing valid is chosen. */
+    emptyPreview?: ReactNode;
 }
 
+export declare type IconProps = IconByNameProps | IconByComponentProps;
+
 /**
  * Provide a static icon registry and shared `<Icon>` defaults to a subtree.
  *
@@ -151,16 +265,18 @@ export declare interface IconProviderProps {
 export declare type IconRegistry = Readonly<Record<string, LucideIcon>>;
 
 /**
- * Whether a slug is ready, still loading, or not an icon at all.
+ * Whether a slug is ready, loading, unknown, or unreachable.
  *
  * `"missing"` is only reported once that is actually knowable: either lucide has
- * no icons under that initial letter, or the letter's shard already settled
- * without the slug in it.
+ * no icons under that initial letter, or the letter's shard **arrived** without
+ * the slug in it. A shard that failed to load reports `"error"` instead — the two
+ * used to collapse into `"missing"`, which turned a stale deploy into what looked
+ * like a typo and made `Icon` warn about a name that is perfectly valid.
  *
  * @param slug - Any icon slug, canonical or deprecated.
  * @returns The slug's resolution state.
  */
-export declare function iconStatus(slug: string): "ready" | "loading" | "missing";
+export declare function iconStatus(slug: string): "ready" | "loading" | "missing" | "error";
 
 /**
  * Narrow an arbitrary string to a known icon slug.
@@ -216,28 +332,65 @@ export declare const MATERIAL_SYMBOL_FALLBACK: IconName;
  * empty screen: a handful of codes collide by accident, so roughly one row in
  * ten draws the right icon and the bug reads as "some icons went missing".
  *
- * **This is a seed table, not the full vocabulary.** Material Symbols ships
- * ~3600 names and almost none of them will ever appear in an `icon_code` of
- * ours. It grows on demand, one hand-written pair at a time — a map generated by
- * name heuristics gets it badly wrong, starting with `build`, which is a wrench
- * in Material Symbols and not anything to do with construction.
+ * **Still not the full vocabulary.** Material Symbols ships ~3600 names and
+ * almost none of them will ever appear in an `icon_code` of ours, so this grows
+ * on demand, one hand-written pair at a time — a map generated by name
+ * heuristics gets it badly wrong, starting with `build`, which is a wrench in
+ * Material Symbols and nothing to do with construction. What is here covers the
+ * trades lot it started as plus the vocabulary an administrative panel actually
+ * uses: navigation, money, dates, media, and the service categories a seed
+ * tends to carry.
+ *
+ * Every target is checked mechanically against the slug list by
+ * `material-symbols.test.ts`, so a pair pointing at a name lucide does not ship
+ * — or at one it has since deprecated — fails the suite instead of reaching a
+ * grid. What no test can check is whether the *chosen* icon is the right
+ * metaphor, which is why pairs go in by hand.
  *
- * **Approximations, deliberate and not one-to-one:**
+ * **Approximations, deliberate and not one-to-one** (the full list lives in
+ * `docs/icons.md`):
  *
  * - `plumbing` → `shower-head`, because lucide has no pipe.
  * - `build`, `handyman` and `hardware` all land on `wrench` — Material Symbols
  *   distinguishes the tools, lucide does not.
  * - `pedal_bike`, `two_wheeler` and `delivery_dining` all land on `bike`.
+ * - `dentistry` → `face-slightly-smiling`, since lucide ships no tooth.
+ * - `iron` → `shirt` and `cleaning_services` → `spray-can`: the activity, not
+ *   the implement.
+ * - `roofing` → `house`, the same glyph as `home`, because lucide has no roof.
  *
- * The thirteen identity pairs are here on purpose. Their names happen to match
- * in both vocabularies, so they already render today — leaving them out would
- * send them to {@link MATERIAL_SYMBOL_FALLBACK} and make this bridge a
- * regression for exactly the codes that used to work.
+ * The identity pairs are here on purpose. Their names happen to match in both
+ * vocabularies, so they already render today — leaving them out would send them
+ * to {@link MATERIAL_SYMBOL_FALLBACK} and make this bridge a regression for
+ * exactly the codes that used to work.
  *
  * @see fromMaterialSymbol — the lookup you normally call.
  */
 export declare const materialToLucide: Readonly<Record<string, IconName>>;
 
+/**
+ * Clean up an icon code and resolve it to the slug lucide actually ships.
+ *
+ * Every backend that stores an `icon_code` stores it dirty: `snake_case` left over
+ * from an old form, a capital or a stray space from a hand-typed value, and slugs
+ * lucide has since deprecated. Each app was writing the same three-step cleanup
+ * before rendering — trim, lower-case, `_` → `-`, then `resolveIconAlias` — which
+ * is code that should not exist outside the SDK.
+ *
+ * Note that this does **not** check whether the result is a real icon: the point is
+ * to produce the canonical spelling, and deciding what to do with an unknown name
+ * belongs to the caller. Pair it with `isIconName` when you need that answer, or
+ * let `<Icon>` render its `fallback`.
+ *
+ * @example
+ * normalizeIconName("  Alert_Circle ");  // "circle-alert"
+ * normalizeIconName("shopping_cart");    // "shopping-cart"
+ *
+ * @param code - Any stored icon code.
+ * @returns The canonical, lucide-spelled slug.
+ */
+export declare function normalizeIconName(code: string): string;
+
 /**
  * Read an icon out of the cache without triggering a fetch.
  *
@@ -257,18 +410,73 @@ export declare function peekIcon(slug: string): LucideIcon | undefined;
  */
 export declare function preloadIcons(slugs: readonly string[]): Promise<void>;
 
+/**
+ * Make icon components resolvable by slug, with no provider and no plugin.
+ *
+ * Call it once from an entrypoint. The icons land in the same table a fetched
+ * shard fills, so every `<Icon>` below — including one that renders before the
+ * call, since registering notifies subscribers — resolves them synchronously and
+ * never issues a request.
+ *
+ * This is the whole setup for a closed catalog: an admin panel with twenty known
+ * icons pays two lines instead of a build plugin plus a provider. `IconProvider`
+ * stays for what is genuinely tree-scoped — the `size`/`strokeWidth` defaults and
+ * a registry that must override the global one for one subtree.
+ *
+ * A slug lucide does not ship is registered as-is, which is how an app adds its
+ * own artwork to the same `<Icon name>` call site.
+ *
+ * @example
+ * import { registerIcons } from "tempest-react-sdk/icons";
+ * import { Save, Trash2 } from "lucide-react";
+ *
+ * registerIcons({ save: Save, "trash-2": Trash2 });
+ *
+ * @param icons - Slug → icon component. Deprecated slugs are stored under the
+ *   canonical name, so both spellings resolve.
+ */
+export declare function registerIcons(icons: Readonly<Record<string, LucideIcon>>): void;
+
 /**
  * Map a slug to the canonical slug that owns the icon.
  *
  * Lucide keeps 257 deprecated aliases (`alert-circle` → `circle-alert`), and a
  * slug persisted in a database years ago is exactly the case this feature exists
- * for, so an alias must keep resolving after a lucide bump renames it.
+ * for, so an alias must keep resolving after a lucide bump renames it. Resolution
+ * happens before the shard lookup, since only canonical slugs are sharded.
+ *
+ * Its own module, not part of `shard-cache`: everything that merely *names* an
+ * icon needs this — `normalizeIconName`, `validateIconName`, a form checking a
+ * value before submit — and none of that needs the shard loader index. Sharing a
+ * module made a validator that never renders anything drag in all 45 shard
+ * modules.
  *
  * @param slug - Any icon slug, canonical or deprecated.
  * @returns The canonical slug.
  */
 export declare function resolveIconAlias(slug: string): string;
 
+/**
+ * Subscribe to shard fetches that gave up.
+ *
+ * The failure is routine in a long-lived tab: a deploy rotates hashed chunk
+ * names, the old asset leaves the CDN, and the next icon that needs it 404s. That
+ * used to end in a permanent fallback with no signal — nothing for the user,
+ * nothing for observability. Subscribing is what turns it into both.
+ *
+ * @example
+ * import { subscribeToIconErrors } from "tempest-react-sdk/icons";
+ *
+ * subscribeToIconErrors(({ shard, error }) => {
+ *     Sentry.captureException(error, { tags: { iconShard: shard } });
+ *     promptReloadForStaleChunks();
+ * });
+ *
+ * @param listener - Called once per shard that gave up.
+ * @returns An unsubscribe function.
+ */
+export declare function subscribeToIconErrors(listener: (detail: IconLoadError) => void): () => void;
+
 /**
  * Resolve an icon slug to its component.
  *
@@ -286,4 +494,33 @@ export declare function resolveIconAlias(slug: string): string;
  */
 export declare function useIcon(slug: string | undefined): LucideIcon | undefined;
 
+/**
+ * Validate an icon slug the way `IconPicker` does.
+ *
+ * Its own module rather than living next to the component: a file that exports
+ * both a component and other values breaks Fast Refresh in a consuming dev
+ * server, which is what `react-refresh/only-export-components` guards and why
+ * `icon-context.ts` is split off from `IconProvider` too.
+ *
+ * Exported because the picker is not the only place a slug is checked: a form
+ * built on react-hook-form or zod validates before submitting, and duplicating
+ * the rule there is how the two drift apart.
+ *
+ * Empty passes — "no icon chosen" is a `required` question, not a spelling one,
+ * and conflating them would make the field impossible to clear.
+ *
+ * @example
+ * // react-hook-form
+ * register("icon", { validate: (value) => validateIconName(value) ?? true });
+ *
+ * @example
+ * // zod
+ * z.string().refine((value) => !validateIconName(value), { message: "Ícone inexistente" });
+ *
+ * @param value - The slug to check, in any spelling the picker accepts.
+ * @param message - Overrides the default message.
+ * @returns The message when the slug does not exist, `undefined` when it is fine.
+ */
+export declare function validateIconName(value: string, message?: string): string | undefined;
+
 export { }

package/dist/icons.js

@@ -1,10 +1,14 @@
 import { iconAliases as e } from "./icons/generated/aliases.js";
 import { iconNames as t } from "./icons/generated/icon-names.js";
 import { createIconRegistry as n } from "./icons/icon-context.js";
-import { iconStatus as r, loadIcon as i, peekIcon as a, preloadIcons as o, resolveIconAlias as s } from "./icons/shard-cache.js";
-import { useIcon as c } from "./icons/use-icon.js";
-import { Icon as l } from "./icons/Icon.js";
-import { IconProvider as u } from "./icons/IconProvider.js";
-import { isIconName as d } from "./icons/is-icon-name.js";
-import { MATERIAL_SYMBOL_FALLBACK as f, fromMaterialSymbol as p, materialToLucide as m } from "./icons/material-symbols.js";
-export { l as Icon, u as IconProvider, f as MATERIAL_SYMBOL_FALLBACK, n as createIconRegistry, p as fromMaterialSymbol, e as iconAliases, t as iconNames, r as iconStatus, d as isIconName, i as loadIcon, m as materialToLucide, a as peekIcon, o as preloadIcons, s as resolveIconAlias, c as useIcon };
+import { resolveIconAlias as r } from "./icons/alias.js";
+import { normalizeIconName as i } from "./icons/normalize-icon-name.js";
+import { iconStatus as a, loadIcon as o, peekIcon as s, preloadIcons as c, registerIcons as l, subscribeToIconErrors as u } from "./icons/shard-cache.js";
+import { useIcon as d } from "./icons/use-icon.js";
+import { Icon as f } from "./icons/Icon.js";
+import { isIconName as p } from "./icons/is-icon-name.js";
+import { DEFAULT_ICON_PICKER_MESSAGE as m, validateIconName as h } from "./icons/validate-icon-name.js";
+import { IconPicker as g } from "./icons/IconPicker.js";
+import { IconProvider as _ } from "./icons/IconProvider.js";
+import { MATERIAL_SYMBOL_FALLBACK as v, fromMaterialSymbol as y, materialToLucide as b } from "./icons/material-symbols.js";
+export { m as DEFAULT_ICON_PICKER_MESSAGE, f as Icon, g as IconPicker, _ as IconProvider, v as MATERIAL_SYMBOL_FALLBACK, n as createIconRegistry, y as fromMaterialSymbol, e as iconAliases, t as iconNames, a as iconStatus, p as isIconName, o as loadIcon, b as materialToLucide, i as normalizeIconName, s as peekIcon, c as preloadIcons, l as registerIcons, r as resolveIconAlias, u as subscribeToIconErrors, d as useIcon, h as validateIconName };