@ui-organized/vue 0.0.0-stage → 0.1.0

package/dist/components/TreeView/TreeNode.vue.d.ts

@@ -0,0 +1,9 @@
+import type { TreeViewNode } from "./TreeView.types.js";
+type __VLS_Props = {
+    node: TreeViewNode;
+    indexPath: number[];
+    iconSize: number;
+    showIndentGuides: boolean;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/TreeView/TreeView.types.d.ts

@@ -0,0 +1,36 @@
+import type { IconComponent, IconName } from "../Icon/Icon.types.js";
+import type { ControlSize } from "@ui-organized/core";
+export interface TreeViewNode {
+    /** Unique id across the whole tree. Selection and expansion are keyed on this. */
+    id: string;
+    /** Display text. */
+    label: string;
+    /** Child nodes. A node with children renders as a branch, one without as a leaf. */
+    children?: TreeViewNode[];
+    /** Icon shown before the label. Branches default to a folder, leaves to none. */
+    icon?: IconName | IconComponent;
+    /** Prevents selection while keeping the node visible. */
+    disabled?: boolean;
+}
+export interface TreeViewProps {
+    /** The tree to render, in display order. */
+    items: TreeViewNode[];
+    /** Accessible label rendered above the tree. */
+    label?: string;
+    /** Selected node ids. Use `v-model:selected-value` for two-way binding. */
+    selectedValue?: string[];
+    /** Initial selection for the uncontrolled case. */
+    defaultSelectedValue?: string[];
+    /** Expanded branch ids. Use `v-model:expanded-value` for two-way binding. */
+    expandedValue?: string[];
+    /** Branches expanded on first render. */
+    defaultExpandedValue?: string[];
+    /** How many nodes may be selected at once. Defaults to 'single'. */
+    selectionMode?: "single" | "multiple";
+    /** Size variant. Defaults to 'md'. */
+    size?: ControlSize;
+    /** Visual treatment. `bordered` draws a container around the tree. Defaults to 'default'. */
+    variant?: "default" | "bordered";
+    /** Shows the vertical rules that connect a branch to its children. Defaults to true. */
+    showIndentGuides?: boolean;
+}

package/dist/components/TreeView/TreeView.vue.d.ts

@@ -0,0 +1,17 @@
+import type { TreeViewProps } from "./TreeView.types.js";
+import "@ui-organized/core/components/TreeView/TreeView.css";
+declare const _default: import("vue").DefineComponent<TreeViewProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    expandedChange: (value: string[]) => any;
+    "update:selectedValue": (value: string[]) => any;
+    selectionChange: (value: string[]) => any;
+    "update:expandedValue": (value: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<TreeViewProps> & Readonly<{
+    onExpandedChange?: ((value: string[]) => any) | undefined;
+    "onUpdate:selectedValue"?: ((value: string[]) => any) | undefined;
+    onSelectionChange?: ((value: string[]) => any) | undefined;
+    "onUpdate:expandedValue"?: ((value: string[]) => any) | undefined;
+}>, {
+    size: import("@ui-organized/core").ControlSize;
+    showIndentGuides: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/TreeView/index.d.ts

@@ -0,0 +1,3 @@
+export { default as TreeView } from "./TreeView.vue";
+export type { TreeViewProps, TreeViewNode } from "./TreeView.types.js";
+export type { TreeViewVariants } from "@ui-organized/core";

package/dist/context/IconProvider.types.d.ts

@@ -0,0 +1,16 @@
+import type { IconConfig, IconStyle } from "@ui-organized/core";
+import type { IconComponent } from "../icons/registry.js";
+export interface IconProviderProps extends Partial<Omit<IconConfig<IconComponent>, "style">> {
+    /**
+     * Icon style — outline/stroke or solid/filled.
+     *
+     * Spelled `style` in the React and Svelte libraries, and `iconStyle` here
+     * because Vue reserves `style`. See the note in `IconProvider.vue`.
+     */
+    iconStyle?: IconStyle;
+    /**
+     * Never read. Declared only so the wrong spelling can be intercepted and
+     * explained rather than silently rendering the wrong icons.
+     */
+    style?: unknown;
+}

package/dist/context/IconProvider.vue.d.ts

@@ -0,0 +1,16 @@
+import type { IconProviderProps } from "./IconProvider.types.js";
+declare const _default: __VLS_WithSlots<import("vue").DefineComponent<IconProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<IconProviderProps> & Readonly<{}>, {
+    library: import("@ui-organized/core").IconLibrary;
+    strokeAdjustment: boolean;
+    baseSize: number;
+    baseStroke: number;
+    iconStyle: import("@ui-organized/core").IconStyle;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>, {
+    default?: (props: {}) => any;
+}>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/context/iconContext.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The icon configuration, carried on Vue's provide/inject.
+ *
+ * React reads this through `useContext` and Svelte through `getContext`; here it
+ * is `inject` with a default, so a component rendered outside any provider still
+ * gets the shared defaults rather than `undefined`. The config object itself is
+ * common to every framework library — see `IconConfig` in @ui-organized/core.
+ */
+import { type ComputedRef } from "vue";
+import { type IconConfig } from "@ui-organized/core";
+import type { IconComponent } from "../icons/registry.js";
+export type { IconConfig } from "@ui-organized/core";
+export type IconConfigRef = ComputedRef<IconConfig<IconComponent>>;
+export declare function provideIconConfig(config: IconConfigRef): void;
+/**
+ * Held as a ref rather than a snapshot so a provider driven by reactive props
+ * keeps its consumers current — a theme switcher flipping `style` to "solid"
+ * updates every icon already on the page.
+ */
+export declare function useIconConfig(): IconConfigRef;

package/dist/icons/entry-heroicons.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `@ui-organized/vue/icons/heroicons` — the Heroicons adapter.
+ *
+ * Importing this module registers Heroicons, so
+ * `<IconProvider library=\"heroicons\">` draws the components' own glyphs from it;
+ * `registerIcons` below adds the icons you name. This is the
+ * only module that imports `@heroicons/vue`.
+ *
+ * ```ts
+ * import "@ui-organized/vue/icons/heroicons";
+ * ```
+ */
+import { heroiconsOutlineSet, heroiconsSolidSet } from "./heroicons.js";
+import { type IconSet, type RegisterIconsOptions, type IconComponent } from "./registry.js";
+export declare const heroiconsIcons: IconSet;
+export { heroiconsOutlineSet, heroiconsSolidSet };
+/**
+ * Make Heroicons icons available to `<Icon name>` under their own names.
+ *
+ * Pass them as imported and the names follow from the exports
+ * (`CameraIcon` → `"camera"`), or key them by native name yourself where
+ * the export can't be read back unambiguously (`{ h1: H1Icon }`).
+ * Only what you register reaches your bundle.
+ *
+ * ```ts
+ * import { CameraIcon, RocketLaunchIcon } from "@heroicons/vue/24/outline";
+ * registerIcons({ CameraIcon, RocketLaunchIcon });
+ * ```
+ */
+export declare function registerIcons(icons: Record<string, IconComponent>, options?: RegisterIconsOptions): void;

package/dist/icons/entry-heroicons.js

@@ -0,0 +1,127 @@
+import { ArrowUturnLeftIcon as c, EyeDropperIcon as s, CalendarIcon as I, HomeIcon as t, Cog6ToothIcon as l, UserIcon as i, PauseIcon as h, PlayIcon as u, FolderIcon as $, DocumentIcon as p, ListBulletIcon as w, Squares2X2Icon as g, Bars3Icon as C, TagIcon as d, StarIcon as f, EyeSlashIcon as y, EyeIcon as m, MagnifyingGlassIcon as v, InformationCircleIcon as D, ExclamationTriangleIcon as A, ExclamationCircleIcon as T, CheckCircleIcon as P, BarsArrowDownIcon as r, FunnelIcon as E, BarsArrowUpIcon as U, ArrowPathIcon as k, ArrowUpTrayIcon as S, ArrowDownTrayIcon as B, TrashIcon as x, PencilIcon as L, DocumentDuplicateIcon as M, MinusIcon as F, PlusIcon as X, CheckIcon as q, XMarkIcon as G, ChevronRightIcon as H, ChevronLeftIcon as R, ChevronUpIcon as b, ChevronDownIcon as O } from "@heroicons/vue/24/outline";
+import { ArrowUturnLeftIcon as e, EyeDropperIcon as W, CalendarIcon as j, HomeIcon as J, Cog6ToothIcon as K, UserIcon as N, PauseIcon as Q, PlayIcon as V, FolderIcon as Y, DocumentIcon as Z, ListBulletIcon as _, Squares2X2Icon as z, Bars3Icon as oo, TagIcon as no, StarIcon as co, EyeSlashIcon as ro, EyeIcon as eo, MagnifyingGlassIcon as ao, InformationCircleIcon as so, ExclamationTriangleIcon as Io, ExclamationCircleIcon as to, CheckCircleIcon as lo, BarsArrowDownIcon as a, FunnelIcon as io, BarsArrowUpIcon as ho, ArrowPathIcon as uo, ArrowUpTrayIcon as $o, ArrowDownTrayIcon as po, TrashIcon as wo, PencilIcon as go, DocumentDuplicateIcon as Co, MinusIcon as fo, PlusIcon as yo, CheckIcon as mo, XMarkIcon as vo, ChevronRightIcon as Do, ChevronLeftIcon as Ao, ChevronUpIcon as To, ChevronDownIcon as Po } from "@heroicons/vue/24/solid";
+import { c as Eo, d as Uo } from "../registry-DyLcm8o3.js";
+const ko = {
+  "chevron-down": O,
+  "chevron-up": b,
+  "chevron-left": R,
+  "chevron-right": H,
+  close: G,
+  check: q,
+  plus: X,
+  minus: F,
+  copy: M,
+  edit: L,
+  trash: x,
+  download: B,
+  upload: S,
+  refresh: k,
+  undo: c,
+  "sort-asc": U,
+  "sort-desc": r,
+  filter: E,
+  sort: r,
+  "check-circle": P,
+  "alert-circle": T,
+  "alert-triangle": A,
+  info: D,
+  search: v,
+  eye: m,
+  "eye-off": y,
+  star: f,
+  tag: d,
+  menu: C,
+  grid: g,
+  list: w,
+  file: p,
+  folder: $,
+  play: u,
+  pause: h,
+  user: i,
+  settings: l,
+  home: t,
+  calendar: I,
+  pipette: s,
+  // Heroicons ships no clockwise-rotate glyph; ArrowPathIcon is the closest,
+  // and already backs "refresh" and "loader" here for the same reason.
+  "rotate-ccw": c
+}, So = {
+  "chevron-down": Po,
+  "chevron-up": To,
+  "chevron-left": Ao,
+  "chevron-right": Do,
+  close: vo,
+  check: mo,
+  plus: yo,
+  minus: fo,
+  copy: Co,
+  edit: go,
+  trash: wo,
+  download: po,
+  upload: $o,
+  refresh: uo,
+  undo: e,
+  "sort-asc": ho,
+  "sort-desc": a,
+  filter: io,
+  sort: a,
+  "check-circle": lo,
+  "alert-circle": to,
+  "alert-triangle": Io,
+  info: so,
+  search: ao,
+  eye: eo,
+  "eye-off": ro,
+  star: co,
+  tag: no,
+  menu: oo,
+  grid: z,
+  list: _,
+  file: Z,
+  folder: Y,
+  play: V,
+  pause: Q,
+  user: N,
+  settings: K,
+  home: J,
+  calendar: j,
+  pipette: W,
+  "rotate-ccw": e
+}, Bo = {
+  library: "heroicons",
+  outline: ko,
+  solid: So,
+  /**
+   * Sized through `style`, not through attributes — the one adapter that has to.
+   *
+   * `@heroicons/vue` icons are bare render functions that ignore their props and
+   * declare none, and Vue passes only `class`, `style` and `on*` listeners
+   * through to the root of a functional component like that. `width={size}`
+   * simply disappears: the icon renders at the library's own 24px and 1.5
+   * stroke, silently. (React's Heroicons spread their props onto the `<svg>`,
+   * which is why the React adapter can pass `width`/`height`/`strokeWidth`.)
+   *
+   * CSS reaches the same three properties and outranks the presentation
+   * attributes the component hard-codes, so the result is identical. Sizes carry
+   * a unit because CSS lengths need one; `strokeWidth` does not, because
+   * `stroke-width` is unitless in the SVG's own user space — which is what
+   * `resolveIconStroke` already returns.
+   */
+  svgProps: (o, n) => ({
+    style: {
+      width: `${o}px`,
+      height: `${o}px`,
+      ...n !== void 0 ? { strokeWidth: n } : {}
+    }
+  })
+};
+Eo(Bo);
+function Fo(o, n) {
+  Uo("heroicons", o, n);
+}
+export {
+  Bo as heroiconsIcons,
+  ko as heroiconsOutlineSet,
+  So as heroiconsSolidSet,
+  Fo as registerIcons
+};

package/dist/icons/entry-lucide.d.ts

@@ -0,0 +1,40 @@
+/**
+ * `@ui-organized/vue/icons/lucide` — the Lucide adapter.
+ *
+ * Importing this module registers Lucide, so `<IconProvider library=\"lucide\">`
+ * draws the components' own glyphs from it; `registerIcons` below adds the
+ * icons you name. This is the *only* module in the package that
+ * imports `@lucide/vue`; nothing here is reachable from the main entry, which is
+ * what keeps the other icon libraries out of your bundle.
+ *
+ * ```ts
+ * import "@ui-organized/vue/icons/lucide";   // register, then use library="lucide"
+ * ```
+ *
+ * Or pass it explicitly, if you'd rather not rely on import side effects:
+ *
+ * ```vue
+ * <script setup>
+ * import { lucideIcons } from "@ui-organized/vue/icons/lucide";
+ * </script>
+ * <template><IconProvider library="lucide" :icons="lucideIcons"> … </IconProvider></template>
+ * ```
+ */
+import { lucideIconSet } from "./lucide.js";
+import { type IconSet, type RegisterIconsOptions, type IconComponent } from "./registry.js";
+export declare const lucideIcons: IconSet;
+export { lucideIconSet };
+/**
+ * Make Lucide icons available to `<Icon name>` under their own Lucide names.
+ *
+ * Pass them as imported and the names follow from the exports
+ * (`Camera` → `"camera"`), or key them by native name yourself where
+ * the export can't be read back unambiguously (`{ "arrow-down-0-1": ArrowDown01 }`).
+ * Only what you register reaches your bundle.
+ *
+ * ```ts
+ * import { Camera, Rocket } from "@lucide/vue";
+ * registerIcons({ Camera, Rocket });
+ * ```
+ */
+export declare function registerIcons(icons: Record<string, IconComponent>, options?: RegisterIconsOptions): void;

package/dist/icons/entry-lucide.js

@@ -0,0 +1,62 @@
+import { RotateCcw as o, Pipette as t, Calendar as i, House as c, Settings as n, User as s, Pause as l, Play as a, Folder as d, File as h, List as u, Grid2x2 as p, Menu as f, Tag as g, Star as C, EyeOff as v, Eye as w, Search as y, Info as m, TriangleAlert as A, CircleAlert as I, CircleCheckBig as P, ListFilter as S, Funnel as U, ArrowDownAZ as k, ArrowUpAZ as F, Undo2 as D, RefreshCw as L, Upload as R, Download as T, Trash2 as x, Pencil as E, Copy as M, Minus as Z, Plus as b, Check as B, X as G, ChevronRight as H, ChevronLeft as O, ChevronUp as W, ChevronDown as X } from "@lucide/vue";
+import { c as $, d as j } from "../registry-DyLcm8o3.js";
+const q = {
+  "chevron-down": X,
+  "chevron-up": W,
+  "chevron-left": O,
+  "chevron-right": H,
+  close: G,
+  check: B,
+  plus: b,
+  minus: Z,
+  copy: M,
+  edit: E,
+  trash: x,
+  download: T,
+  upload: R,
+  refresh: L,
+  undo: D,
+  "sort-asc": F,
+  "sort-desc": k,
+  filter: U,
+  sort: S,
+  "check-circle": P,
+  "alert-circle": I,
+  "alert-triangle": A,
+  info: m,
+  search: y,
+  eye: w,
+  "eye-off": v,
+  star: C,
+  tag: g,
+  menu: f,
+  grid: p,
+  list: u,
+  file: h,
+  folder: d,
+  play: a,
+  pause: l,
+  user: s,
+  settings: n,
+  home: c,
+  calendar: i,
+  pipette: t,
+  "rotate-ccw": o
+}, z = {
+  library: "lucide",
+  outline: q,
+  // Lucide ships outline only; `style="solid"` falls back to the outline cut.
+  svgProps: (r, e) => ({
+    size: r,
+    ...e !== void 0 ? { strokeWidth: e } : {}
+  })
+};
+$(z);
+function N(r, e) {
+  j("lucide", r, e);
+}
+export {
+  q as lucideIconSet,
+  z as lucideIcons,
+  N as registerIcons
+};

package/dist/icons/entry-tabler.d.ts

@@ -0,0 +1,30 @@
+/**
+ * `@ui-organized/vue/icons/tabler` — the Tabler adapter.
+ *
+ * Importing this module registers Tabler, so `<IconProvider library=\"tabler\">`
+ * draws the components' own glyphs from it; `registerIcons` below adds the
+ * icons you name. This is the only module that imports
+ * `@tabler/icons-vue`.
+ *
+ * ```ts
+ * import "@ui-organized/vue/icons/tabler";
+ * ```
+ */
+import { tablerIconSet, tablerSolidSet } from "./tabler.js";
+import { type IconSet, type RegisterIconsOptions, type IconComponent } from "./registry.js";
+export declare const tablerIcons: IconSet;
+export { tablerIconSet, tablerSolidSet };
+/**
+ * Make Tabler icons available to `<Icon name>` under their own Tabler names.
+ *
+ * Pass them as imported and the names follow from the exports
+ * (`IconCamera` → `"camera"`), or key them by native name yourself where
+ * the export can't be read back unambiguously (`{ "crop-16-9": IconCrop169 }`).
+ * Only what you register reaches your bundle.
+ *
+ * ```ts
+ * import { IconCamera, IconRocket } from "@tabler/icons-vue";
+ * registerIcons({ IconCamera, IconRocket });
+ * ```
+ */
+export declare function registerIcons(icons: Record<string, IconComponent>, options?: RegisterIconsOptions): void;

package/dist/icons/entry-tabler.js

@@ -0,0 +1,86 @@
+import { IconUserFilled as c, IconTrashFilled as n, IconTagFilled as l, IconStarFilled as r, IconSettingsFilled as i, IconSearchFilled as t, IconPlusFilled as I, IconPlayerPauseFilled as a, IconPlayerPlayFilled as s, IconInfoCircleFilled as d, IconHomeFilled as h, IconFolderFilled as F, IconFilterFilled as f, IconFileFilled as g, IconEyeFilled as p, IconPencilFilled as u, IconCopyFilled as y, IconCircleCheckFilled as C, IconCalendarFilled as P, IconAlertTriangleFilled as S, IconAlertCircleFilled as m, IconRotate as v, IconColorPicker as k, IconCalendar as w, IconHome as A, IconSettings as b, IconUser as T, IconPlayerPause as U, IconPlayerPlay as D, IconFolder as E, IconFile as L, IconList as R, IconLayoutGrid as H, IconMenu2 as M, IconTag as x, IconStar as B, IconEyeOff as G, IconEye as O, IconSearch as X, IconInfoCircle as $, IconAlertTriangle as j, IconAlertCircle as q, IconCircleCheck as z, IconArrowsSort as J, IconFilter as K, IconSortDescending as N, IconSortAscending as Q, IconArrowBackUp as V, IconRefresh as W, IconUpload as Y, IconDownload as Z, IconTrash as _, IconPencil as ee, IconCopy as oe, IconMinus as ce, IconPlus as ne, IconCheck as le, IconX as re, IconChevronRight as ie, IconChevronLeft as te, IconChevronUp as Ie, IconChevronDown as ae } from "@tabler/icons-vue";
+import { c as se, d as de } from "../registry-DyLcm8o3.js";
+const he = {
+  "chevron-down": ae,
+  "chevron-up": Ie,
+  "chevron-left": te,
+  "chevron-right": ie,
+  close: re,
+  check: le,
+  plus: ne,
+  minus: ce,
+  copy: oe,
+  edit: ee,
+  trash: _,
+  download: Z,
+  upload: Y,
+  refresh: W,
+  undo: V,
+  "sort-asc": Q,
+  "sort-desc": N,
+  filter: K,
+  sort: J,
+  "check-circle": z,
+  "alert-circle": q,
+  "alert-triangle": j,
+  info: $,
+  search: X,
+  eye: O,
+  "eye-off": G,
+  star: B,
+  tag: x,
+  menu: M,
+  grid: H,
+  list: R,
+  file: L,
+  folder: E,
+  play: D,
+  pause: U,
+  user: T,
+  settings: b,
+  home: A,
+  calendar: w,
+  pipette: k,
+  "rotate-ccw": v
+}, Fe = {
+  "alert-circle": m,
+  "alert-triangle": S,
+  calendar: P,
+  "check-circle": C,
+  copy: y,
+  edit: u,
+  eye: p,
+  file: g,
+  filter: f,
+  folder: F,
+  home: h,
+  info: d,
+  play: s,
+  pause: a,
+  plus: I,
+  search: t,
+  settings: i,
+  star: r,
+  tag: l,
+  trash: n,
+  user: c
+}, fe = {
+  library: "tabler",
+  outline: he,
+  solid: Fe,
+  // Tabler names its stroke prop `stroke`, not `strokeWidth`.
+  svgProps: (o, e) => ({
+    size: o,
+    ...e !== void 0 ? { stroke: e } : {}
+  })
+};
+se(fe);
+function ue(o, e) {
+  de("tabler", o, e);
+}
+export {
+  ue as registerIcons,
+  he as tablerIconSet,
+  fe as tablerIcons,
+  Fe as tablerSolidSet
+};

package/dist/icons/glyph.d.ts

@@ -0,0 +1,17 @@
+/**
+ * The components' own glyphs — Alert's dismiss, Select's chevron — as values
+ * that can go anywhere an icon component can.
+ *
+ * @internal Users name icons the way their library does; see `SystemGlyph` in
+ * @ui-organized/core for why the components alone need a library-neutral key.
+ *
+ * A glyph has to pass through `icon` props as well as `<Icon :name>`, and those
+ * accept a string or a component. A string would be read as a native name, so a
+ * glyph is a component, recognised by `Icon` and resolved against whichever
+ * library the provider has active. It renders nothing on its own.
+ */
+import type { SystemGlyph } from "@ui-organized/core";
+import type { IconComponent } from "./registry.js";
+export declare function glyph(name: SystemGlyph): IconComponent;
+/** The glyph a value stands for, or undefined if it is an ordinary component. */
+export declare function glyphOf(value: unknown): SystemGlyph | undefined;

package/dist/icons/heroicons.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Heroicons adapter.
+ *
+ * Maps each of the components' own glyphs (`SystemGlyph` in @ui-organized/core)
+ * to its `@heroicons/vue` component
+ * for both outline and solid styles. Named imports keep tree-shaking intact.
+ */
+import type { SystemGlyph } from "@ui-organized/core";
+import type { IconComponent } from "./registry.js";
+export declare const heroiconsOutlineSet: Record<SystemGlyph, IconComponent>;
+export declare const heroiconsSolidSet: Record<SystemGlyph, IconComponent>;

package/dist/icons/lucide.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Lucide icon adapter.
+ *
+ * Maps each of the components' own glyphs (`SystemGlyph` in @ui-organized/core)
+ * to its `@lucide/vue` component.
+ * Named imports keep tree-shaking intact — only the icons listed here are pulled
+ * out of the catalogue of thousands.
+ *
+ * ── Why the package is `@lucide/vue`, not `lucide-vue-next` ─────────────────
+ *
+ * `lucide-vue-next` is deprecated on npm and points at `@lucide/vue`.
+ *
+ * ── Why several names differ from packages/react's Lucide map ───────────────
+ *
+ * React pins `lucide-react@^0.400`, which predates Lucide's naming cleanup.
+ * `@lucide/vue` is Lucide v1, where seven of these were renamed:
+ * AlertCircle→CircleAlert, AlertTriangle→TriangleAlert, CheckCircle→CircleCheckBig,
+ * Filter→Funnel, Grid2X2→Grid2x2, Home→House, Loader2→LoaderCircle. The old names
+ * still resolve as deprecated aliases, so copying React's list verbatim would
+ * have compiled and then broken on the release that drops them. Same glyphs,
+ * current names.
+ */
+import type { SystemGlyph } from "@ui-organized/core";
+import type { IconComponent } from "./registry.js";
+export declare const lucideIconSet: Record<SystemGlyph, IconComponent>;

package/dist/icons/registry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * This package's icon-set registry: the shared mechanism from
+ * `@ui-organized/core`, bound to Vue component types.
+ *
+ * The registry itself — why it exists, why it is keyed on `globalThis`, and why
+ * each framework gets its own — is documented in core. All that happens here is
+ * fixing the component type, and choosing a key distinct from the React and
+ * Svelte packages' so none of them can read another's components.
+ */
+import type { Component } from "vue";
+import { type IconNameMap as CoreIconNameMap, type IconSet as CoreIconSet, type SystemGlyphMap as CoreSystemGlyphMap } from "@ui-organized/core";
+export type { IconLibrary, RegisterIconsOptions } from "@ui-organized/core";
+/** An icon component supplied directly — e.g. `Image` from `@lucide/vue`. */
+export type IconComponent = Component;
+/** Native name → Vue component, e.g. `{ \"chevron-down\": ChevronDown }`. */
+export type IconNameMap = CoreIconNameMap<IconComponent>;
+/** One library's adapter. See `IconSet` in @ui-organized/core. */
+export type IconSet = CoreIconSet<IconComponent>;
+/** The components' own glyphs, for one library in one style. */
+export type SystemGlyphMap = CoreSystemGlyphMap<IconComponent>;
+declare const registerIconSet: (set: CoreIconSet<IconComponent>) => void, getIconSet: (library: import("@ui-organized/core").IconLibrary) => CoreIconSet<IconComponent> | undefined, registeredLibraries: () => import("@ui-organized/core").IconLibrary[], registerIcons: (library: import("@ui-organized/core").IconLibrary, icons: Record<string, IconComponent>, options?: import("@ui-organized/core").RegisterIconsOptions) => void, getIcon: (library: import("@ui-organized/core").IconLibrary, name: string, style: "outline" | "solid") => IconComponent | undefined, registeredNames: (library: import("@ui-organized/core").IconLibrary) => string[];
+export { registerIconSet, getIconSet, registeredLibraries, registerIcons, getIcon, registeredNames, };

package/dist/icons/tabler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Tabler icon adapter.
+ *
+ * Maps each of the components' own glyphs (`SystemGlyph` in @ui-organized/core)
+ * to its `@tabler/icons-vue`
+ * component, outline and filled. Named imports keep tree-shaking intact.
+ */
+import type { SystemGlyph } from "@ui-organized/core";
+import type { IconComponent } from "./registry.js";
+export declare const tablerIconSet: Record<SystemGlyph, IconComponent>;
+/**
+ * Tabler's filled cut, which covers about half of the glyphs. The rest have
+ * no official filled variant; `resolveSystemGlyph` falls back to the outline
+ * one rather than leaving a hole.
+ */
+export declare const tablerSolidSet: Partial<Record<SystemGlyph, IconComponent>>;