@astryx-vue/core 0.1.0 → 0.1.1

package/dist/index-CR6sUmRT.d.ts

@@ -0,0 +1,356 @@
+import { CSSProperties, ComputedRef, MaybeRefOrGetter, Ref, VNode, VNodeChild } from "vue";
+//#region src/Table/types.d.ts
+type TableDensity = 'compact' | 'balanced' | 'spacious';
+type TableDividers = 'rows' | 'columns' | 'grid' | 'none';
+type TableTextOverflow = 'wrap' | 'truncate';
+type TableVerticalAlign = 'top' | 'middle' | 'bottom';
+type TableColumnAlign = 'start' | 'center' | 'end';
+type TableSortDirection = 'ascending' | 'descending';
+interface ProportionalWidth {
+  type: 'proportional';
+  value: number;
+  minWidth?: number;
+}
+interface PixelWidth {
+  type: 'pixel';
+  value: number;
+}
+type ColumnWidth = ProportionalWidth | PixelWidth;
+interface TableSortEntry<TSortKey extends string = string> {
+  sortKey: TSortKey;
+  direction: TableSortDirection;
+}
+type TableSortState<TSortKey extends string = string> = TableSortEntry<TSortKey>[];
+interface TableColumn<T extends Record<string, unknown> = Record<string, unknown>> {
+  key: string;
+  header?: string;
+  width?: ColumnWidth;
+  align?: TableColumnAlign;
+  verticalAlign?: TableVerticalAlign;
+  sortable?: boolean | {
+    sortKey?: string;
+    compare?: (a: T, b: T) => number;
+  };
+  /** Field key used by the filtering plugin. */
+  filter?: string;
+  renderCell?: (item: T, index: number) => VNodeChild;
+}
+interface TableFilterField {
+  key: string;
+  label: string;
+  type: 'string' | 'enum';
+  options?: readonly {
+    value: string;
+    label: string;
+  }[];
+}
+type TableFilterValue = string | string[];
+type TableFilterState = Record<string, TableFilterValue>;
+interface TableSortContribution {
+  direction: TableSortDirection | null;
+  rank: number | null;
+  label: string;
+  onClick: (event: MouseEvent) => void;
+}
+interface TableFilterContribution {
+  variant: 'inline' | 'popover';
+  field: TableFilterField;
+  value: TableFilterValue | null;
+  onChange: (value: TableFilterValue | null) => void;
+}
+interface TableSelectionContribution<T> {
+  isAllSelected: () => boolean;
+  isIndeterminate: () => boolean;
+  isSelected: (row: T) => boolean;
+  isSelectable?: (row: T) => boolean;
+  selectAll: (selected: boolean) => void;
+  selectRow: (row: T, selected: boolean) => void;
+  rowLabel?: (row: T) => string;
+  hasRowHighlight?: boolean;
+}
+interface TablePlugin<T extends Record<string, unknown> = Record<string, unknown>> {
+  transformColumns?: (columns: TableColumn<T>[]) => TableColumn<T>[];
+  sortFor?: (column: TableColumn<T>) => TableSortContribution | null;
+  filterFor?: (column: TableColumn<T>) => TableFilterContribution | null;
+  selection?: TableSelectionContribution<T>;
+  widthFor?: (column: TableColumn<T>) => number | undefined;
+  onColumnResizeEnd?: (key: string, width: number) => void;
+  below?: () => VNodeChild;
+}
+interface TableProps<T extends Record<string, unknown> = Record<string, unknown>> {
+  data?: readonly T[];
+  columns?: readonly TableColumn<T>[];
+  idKey?: string;
+  density?: TableDensity;
+  dividers?: TableDividers;
+  isStriped?: boolean;
+  hasHover?: boolean;
+  verticalAlign?: TableVerticalAlign;
+  textOverflow?: TableTextOverflow;
+  plugins?: Record<string, TablePlugin<T> | undefined>;
+  label?: string;
+}
+interface TableSlots {
+  default?: () => VNode[];
+  empty?: () => VNode[];
+}
+interface TableRowProps {
+  isHeaderRow?: boolean;
+}
+interface TableCellProps {
+  align?: TableColumnAlign;
+  colSpan?: number;
+  rowSpan?: number;
+  headers?: string;
+}
+//#endregion
+//#region src/Table/columnUtils.d.ts
+declare function proportional(value?: number, options?: {
+  minWidth?: number;
+}): ProportionalWidth;
+declare function pixel(value: number): PixelWidth;
+interface ResolvedColumnWidth {
+  style: CSSProperties;
+}
+interface ResolvedColumnWidths {
+  columns: Map<string, ResolvedColumnWidth>;
+  tableMinWidth: number;
+}
+declare function resolveColumnWidths<T extends Record<string, unknown>>(columns: readonly TableColumn<T>[]): ResolvedColumnWidths;
+declare function capitalize(value: string): string;
+declare function cellText(value: unknown): string;
+declare function paginateData<T>(data: readonly T[], page: number, pageSize: number): T[];
+declare function generateColumns<T extends Record<string, unknown>>(data: readonly T[]): TableColumn<T>[];
+declare function sortRows<T extends Record<string, unknown>>(rows: readonly T[], sort: readonly {
+  sortKey: string;
+  direction: 'ascending' | 'descending';
+}[], columns?: readonly TableColumn<T>[]): T[];
+//#endregion
+//#region src/Table/plugins/columnResize.d.ts
+interface UseTableColumnResizeConfig {
+  columnWidths: Record<string, number>;
+  onColumnResizeEnd: (updates: Record<string, number>) => void;
+}
+declare function useTableColumnResize<T extends Record<string, unknown>>(config: MaybeRefOrGetter<UseTableColumnResizeConfig>): TablePlugin<T>;
+//#endregion
+//#region src/Table/plugins/columnSettings.d.ts
+interface ColumnSettingsOption<TColumnKey extends string = string> {
+  key: TColumnKey;
+  label: string;
+  isAlwaysVisible?: boolean;
+}
+interface UseTableColumnSettingsConfig<TColumnKey extends string = string> {
+  columns: readonly ColumnSettingsOption<TColumnKey>[];
+  activeColumnKeys: readonly TColumnKey[];
+  onChangeActiveColumnKeys?: (keys: TColumnKey[]) => void;
+}
+declare function useTableColumnSettingsState<TColumnKey extends string>(config: {
+  columns: readonly ColumnSettingsOption<TColumnKey>[];
+  activeColumnKeys: MaybeRefOrGetter<readonly TColumnKey[]>;
+  onChangeActiveColumnKeys: (keys: TColumnKey[]) => void;
+}): {
+  readonly activeColumnKeys: readonly TColumnKey[];
+  setActiveColumnKeys: (keys: readonly TColumnKey[]) => void;
+  columnSettingsConfig: UseTableColumnSettingsConfig<TColumnKey>;
+};
+declare function useTableColumnSettings<T extends Record<string, unknown>, TColumnKey extends string = string>(config: MaybeRefOrGetter<UseTableColumnSettingsConfig<TColumnKey>>): TablePlugin<T>;
+//#endregion
+//#region src/Table/plugins/filtering.d.ts
+interface UseTableFilteringConfig {
+  filters: TableFilterState;
+  onFilterChange: (key: string, value: TableFilterValue | null) => void;
+  fields: readonly TableFilterField[];
+  variant?: 'inline' | 'popover';
+}
+declare function useTableFilterState(initial?: TableFilterState): {
+  filters: Ref<TableFilterState>;
+  onFilterChange: (key: string, value: TableFilterValue | null) => void;
+  clearAll: () => void;
+};
+declare function applyTableFilters<T extends Record<string, unknown>>(rows: readonly T[], filters: TableFilterState, fields?: readonly TableFilterField[]): T[];
+declare function useTableFiltering<T extends Record<string, unknown>>(config: MaybeRefOrGetter<UseTableFilteringConfig>): TablePlugin<T>;
+//#endregion
+//#region src/Table/plugins/pagination.d.ts
+interface UseTablePaginationConfig {
+  page: number;
+  onPageChange: (page: number) => void;
+  totalItems?: number;
+  pageSize?: number;
+  pageSizeOptions?: number[];
+  onPageSizeChange?: (pageSize: number) => void;
+  position?: 'below' | 'above' | 'both' | 'none';
+  align?: 'start' | 'center' | 'end';
+  label?: string;
+}
+declare function useTablePagination<T extends Record<string, unknown>>(config: MaybeRefOrGetter<UseTablePaginationConfig>): TablePlugin<T>;
+//#endregion
+//#region src/Table/plugins/selection.d.ts
+interface UseTableSelectionStateConfig<T extends Record<string, unknown>> {
+  data: MaybeRefOrGetter<readonly T[]>;
+  idKey: keyof T & string;
+  selectedKeys: MaybeRefOrGetter<ReadonlySet<string>>;
+  setSelectedKeys: (keys: Set<string>) => void;
+  getRowLabel?: (item: T) => string;
+  hasRowHighlight?: boolean;
+}
+declare function useTableSelectionState<T extends Record<string, unknown>>(config: UseTableSelectionStateConfig<T>): {
+  selectionConfig: UseTableSelectionConfig<T> & {
+    readonly rows: readonly T[];
+  };
+};
+interface UseTableSelectionConfig<T extends Record<string, unknown>> {
+  getIsItemSelected: (item: T) => boolean;
+  onSelectItem: (event: {
+    item: T;
+    isSelected: boolean;
+  }) => void;
+  onSelectAll: (event: {
+    isAllSelected: boolean;
+  }) => void;
+  getIsAllSelected: () => boolean;
+  getIsIndeterminate?: () => boolean;
+  getIsItemSelectable?: (item: T) => boolean;
+  getRowLabel?: (item: T) => string;
+  hasRowHighlight?: boolean;
+}
+declare function useTableSelection<T extends Record<string, unknown>>(config: MaybeRefOrGetter<UseTableSelectionConfig<T>>): TablePlugin<T>;
+//#endregion
+//#region src/Table/plugins/sortable.d.ts
+interface UseTableSortableConfig<TSortKey extends string = string> {
+  sort: TableSortState<TSortKey>;
+  onSortChange: (sort: TableSortState<TSortKey>) => void;
+  allowUnsortedState?: boolean;
+  isMultiSortEnabled?: boolean;
+}
+declare function useTableSortableState<T extends Record<string, unknown>>(options: {
+  data: MaybeRefOrGetter<readonly T[]>;
+  columns?: MaybeRefOrGetter<readonly TableColumn<T>[]>;
+  defaultSort?: TableSortState;
+}): {
+  sortedData: ComputedRef<T[]>;
+  sort: Ref<TableSortState>;
+  sortConfig: UseTableSortableConfig;
+};
+declare function useTableSortable<T extends Record<string, unknown>>(config: MaybeRefOrGetter<UseTableSortableConfig>): TablePlugin<T>;
+//#endregion
+//#region src/Table/Table.vue.d.ts
+declare const __VLS_export$7: <T extends Record<string, unknown>>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: import("vue").PublicProps & __VLS_PrettifyLocal<TableProps<T>> & (typeof globalThis extends {
+    __VLS_PROPS_FALLBACK: infer P;
+  } ? P : {});
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: TableSlots;
+  emit: {};
+}>) => import("vue").VNode & {
+  __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
+};
+declare const _default$7: typeof __VLS_export$7;
+type __VLS_PrettifyLocal<T> = (T extends any ? { [K in keyof T]: T[K]; } : { [K in keyof T as K]: T[K]; }) & {};
+//#endregion
+//#region src/Table/TableBody.vue.d.ts
+declare var __VLS_1$6: {};
+type __VLS_Slots$6 = {} & {
+  default?: (props: typeof __VLS_1$6) => any;
+};
+declare const __VLS_base$6: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export$6: __VLS_WithSlots$6<typeof __VLS_base$6, __VLS_Slots$6>;
+declare const _default$6: typeof __VLS_export$6;
+type __VLS_WithSlots$6<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/Table/TableCell.vue.d.ts
+declare var __VLS_1$5: {};
+type __VLS_Slots$5 = {} & {
+  default?: (props: typeof __VLS_1$5) => any;
+};
+declare const __VLS_base$5: import("vue").DefineComponent<TableCellProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TableCellProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$5: __VLS_WithSlots$5<typeof __VLS_base$5, __VLS_Slots$5>;
+declare const _default$5: typeof __VLS_export$5;
+type __VLS_WithSlots$5<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/Table/TableFooter.vue.d.ts
+declare var __VLS_1$4: {};
+type __VLS_Slots$4 = {} & {
+  default?: (props: typeof __VLS_1$4) => any;
+};
+declare const __VLS_base$4: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export$4: __VLS_WithSlots$4<typeof __VLS_base$4, __VLS_Slots$4>;
+declare const _default$4: typeof __VLS_export$4;
+type __VLS_WithSlots$4<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/Table/TableHeader.vue.d.ts
+declare var __VLS_1$3: {};
+type __VLS_Slots$3 = {} & {
+  default?: (props: typeof __VLS_1$3) => any;
+};
+declare const __VLS_base$3: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export$3: __VLS_WithSlots$3<typeof __VLS_base$3, __VLS_Slots$3>;
+declare const _default$3: typeof __VLS_export$3;
+type __VLS_WithSlots$3<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/Table/TableHeaderCell.vue.d.ts
+declare var __VLS_1$2: {};
+type __VLS_Slots$2 = {} & {
+  default?: (props: typeof __VLS_1$2) => any;
+};
+declare const __VLS_base$2: import("vue").DefineComponent<TableCellProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TableCellProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$2: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;
+declare const _default$2: typeof __VLS_export$2;
+type __VLS_WithSlots$2<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/Table/TableRow.vue.d.ts
+declare var __VLS_1$1: {};
+type __VLS_Slots$1 = {} & {
+  default?: (props: typeof __VLS_1$1) => any;
+};
+declare const __VLS_base$1: import("vue").DefineComponent<TableRowProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TableRowProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/Table/TableSelectionToolbar.vue.d.ts
+type __VLS_Props = {
+  count: number;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+  default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  clear: () => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+  onClear?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+export { TableTextOverflow as $, generateColumns as A, TableColumn as B, UseTableColumnSettingsConfig as C, useTableColumnResize as D, UseTableColumnResizeConfig as E, sortRows as F, TableFilterState as G, TableDensity as H, ColumnWidth as I, TableProps as J, TableFilterValue as K, PixelWidth as L, pixel as M, proportional as N, capitalize as O, resolveColumnWidths as P, TableSortState as Q, ProportionalWidth as R, ColumnSettingsOption as S, useTableColumnSettingsState as T, TableDividers as U, TableColumnAlign as V, TableFilterField as W, TableSortDirection as X, TableRowProps as Y, TableSortEntry as Z, useTablePagination as _, _default$4 as a, useTableFilterState as b, _default$7 as c, useTableSortableState as d, TableVerticalAlign as et, UseTableSelectionConfig as f, UseTablePaginationConfig as g, useTableSelectionState as h, _default$3 as i, paginateData as j, cellText as k, UseTableSortableConfig as l, useTableSelection as m, _default$1 as n, _default$5 as o, UseTableSelectionStateConfig as p, TablePlugin as q, _default$2 as r, _default$6 as s, _default as t, useTableSortable as u, UseTableFilteringConfig as v, useTableColumnSettings as w, useTableFiltering as x, applyTableFilters as y, TableCellProps as z };

package/dist/index-C_2Z65Rp.d.ts

@@ -0,0 +1,67 @@
+import { Ref, VNode } from "vue";
+//#region src/TreeList/types.d.ts
+type TreeListDensity = 'compact' | 'balanced' | 'spacious';
+type TreeListVariant = 'lineGuides' | 'noGuides';
+interface TreeListItemData {
+  id: string;
+  label: string;
+  description?: string;
+  /** Glyph name, or a CSS icon class starting with `i-`. */
+  icon?: string;
+  /** Trailing glyph or CSS icon class. */
+  endIcon?: string;
+  /** Compact trailing badge, for counts. */
+  badge?: string;
+  children?: TreeListItemData[];
+  href?: string;
+  target?: string;
+  isDisabled?: boolean;
+  isSelected?: boolean;
+  isExpanded?: boolean;
+  onClick?: (event: MouseEvent) => void;
+}
+interface TreeListProps {
+  items: TreeListItemData[];
+  /** @default 'balanced' */
+  density?: TreeListDensity;
+  /** @default 'lineGuides' */
+  variant?: TreeListVariant;
+  header?: string;
+  label?: string;
+}
+interface TreeListSlots {
+  header?: () => VNode[];
+  start?: (props: {
+    item: TreeListItemData;
+  }) => VNode[];
+  end?: (props: {
+    item: TreeListItemData;
+  }) => VNode[];
+}
+//#endregion
+//#region src/TreeList/TreeList.vue.d.ts
+type __VLS_Slots = TreeListSlots;
+declare const __VLS_base: import("vue").DefineComponent<TreeListProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<TreeListProps> & Readonly<{}>, {
+  variant: TreeListVariant;
+  density: TreeListDensity;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/TreeList/useTreeFocus.d.ts
+interface UseTreeFocusOptions {
+  onToggleExpand?: (id: string) => void;
+  onActivate?: (current: HTMLElement) => boolean;
+}
+declare function useTreeFocus(options: UseTreeFocusOptions): {
+  treeRef: Ref<HTMLElement | null>;
+  handleKeyDown: (event: KeyboardEvent) => void;
+  handleFocus: () => void;
+};
+//#endregion
+export { TreeListItemData as a, TreeListVariant as c, TreeListDensity as i, useTreeFocus as n, TreeListProps as o, _default as r, TreeListSlots as s, UseTreeFocusOptions as t };

package/dist/{index-Dw21t7Uf.d.ts → index-CsJpQElv.d.ts}

@@ -34,7 +34,7 @@ declare const __VLS_export: import("vue").DefineComponent<NumberInputProps, {},
   onChange?: ((value: number | null) => any) | undefined;
   "onUpdate:modelValue"?: ((value: number | null) => any) | undefined;
 }>, {
-  size: "sm" | "md" | "lg";
+  size: "md" | "sm" | "lg";
   modelValue: number | null;
   placeholder: string;
   disabled: boolean;

package/dist/index-CtlkhQ55.d.ts

@@ -0,0 +1,36 @@
+//#region src/Thumbnail/types.d.ts
+type ThumbnailRemoveVisibility = 'always' | 'hover';
+interface ThumbnailProps {
+  src?: string;
+  alt?: string;
+  /** Accessible name. Not drawn; used by the tooltip and the remove button. */
+  label?: string;
+  isLoading?: boolean;
+  isDisabled?: boolean;
+  /**
+   * When the remove button is visible. `hover` also reveals it on keyboard
+   * focus, and keeps it visible for coarse pointers.
+   * @default 'hover'
+   */
+  showRemoveOn?: ThumbnailRemoveVisibility;
+}
+interface ThumbnailEmits {
+  remove: [event: MouseEvent];
+  click: [event: MouseEvent];
+}
+//#endregion
+//#region src/Thumbnail/Thumbnail.vue.d.ts
+declare const __VLS_export: import("vue").DefineComponent<ThumbnailProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+  click: (event: MouseEvent) => any;
+  remove: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<ThumbnailProps> & Readonly<{
+  onClick?: ((event: MouseEvent) => any) | undefined;
+  onRemove?: ((event: MouseEvent) => any) | undefined;
+}>, {
+  isDisabled: boolean;
+  isLoading: boolean;
+  showRemoveOn: ThumbnailRemoveVisibility;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { ThumbnailRemoveVisibility as i, ThumbnailEmits as n, ThumbnailProps as r, _default as t };

package/dist/{index-C8NW9xre.d.ts → index-D3V7yRUP.d.ts}

@@ -76,27 +76,27 @@ declare const __VLS_base: import("vue").DefineComponent<MultiSelectorProps, {
   focus: () => void | undefined;
   blur: () => void | undefined;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-  search: (query: string) => any;
   change: (value: (string | number)[]) => any;
-  openChange: (isOpen: boolean) => any;
+  search: (query: string) => any;
   "update:modelValue": (value: (string | number)[]) => any;
+  openChange: (isOpen: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<MultiSelectorProps> & Readonly<{
-  onSearch?: ((query: string) => any) | undefined;
   onChange?: ((value: (string | number)[]) => any) | undefined;
-  onOpenChange?: ((isOpen: boolean) => any) | undefined;
+  onSearch?: ((query: string) => any) | undefined;
   "onUpdate:modelValue"?: ((value: (string | number)[]) => any) | undefined;
+  onOpenChange?: ((isOpen: boolean) => any) | undefined;
 }>, {
   size: MultiSelectorSize;
-  variant: MultiSelectorVariant;
   required: boolean;
+  variant: MultiSelectorVariant;
   modelValue: readonly (string | number)[];
+  status: MultiSelectorStatus;
   labelHidden: boolean;
   disabled: boolean;
-  status: MultiSelectorStatus;
   clearable: boolean;
   optional: boolean;
-  searchable: boolean;
   presentation: MultiSelectorPresentation;
+  searchable: boolean;
   selectAll: boolean;
   triggerDisplay: MultiSelectorTriggerDisplay;
   maxBadges: number;

package/dist/index-Da7Jm8Ht.d.ts

@@ -0,0 +1,10 @@
+import { l as FieldStatusVariant, s as FieldStatusProps } from "./types-3eXh_5os.js";
+//#region src/Field/FieldStatus.vue.d.ts
+declare const __VLS_export: import("vue").DefineComponent<FieldStatusProps, {
+  element: Readonly<import("vue").ShallowRef<HTMLElement | null>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FieldStatusProps> & Readonly<{}>, {
+  variant: FieldStatusVariant;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+//#endregion
+export { _default as t };

package/dist/{index-CPhDtlv-.d.ts → index-FEy8qFSD.d.ts}

@@ -72,10 +72,10 @@ interface TokenizerSlots<T extends SearchableItem = SearchableItem> {
 //#region src/Tokenizer/Tokenizer.vue.d.ts
 declare const __VLS_export: <T extends SearchableItem>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_exposed?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
   props: import("vue").PublicProps & __VLS_PrettifyLocal<TokenizerProps<T> & {
-    onSearch?: ((query: string) => any) | undefined;
     onChange?: ((value: T[], change: TokenizerChange<T>) => any) | undefined;
-    onOpenChange?: ((isOpen: boolean) => any) | undefined;
+    onSearch?: ((query: string) => any) | undefined;
     "onUpdate:modelValue"?: ((value: T[]) => any) | undefined;
+    onOpenChange?: ((isOpen: boolean) => any) | undefined;
   }> & (typeof globalThis extends {
     __VLS_PROPS_FALLBACK: infer P;
   } ? P : {});
@@ -85,7 +85,7 @@ declare const __VLS_export: <T extends SearchableItem>(__VLS_props: NonNullable<
   }>) => void;
   attrs: any;
   slots: TokenizerSlots<T>;
-  emit: ((evt: "search", query: string) => void) & ((evt: "change", value: T[], change: TokenizerChange<T>) => void) & ((evt: "openChange", isOpen: boolean) => void) & ((evt: "update:modelValue", value: T[]) => void);
+  emit: ((evt: "change", value: T[], change: TokenizerChange<T>) => void) & ((evt: "search", query: string) => void) & ((evt: "update:modelValue", value: T[]) => void) & ((evt: "openChange", isOpen: boolean) => void);
 }>) => import("vue").VNode & {
   __ctx?: NonNullable<Awaited<typeof __VLS_setup>>;
 };

package/dist/{index-BeJqhW4l.d.ts → index-Q4gqBSIZ.d.ts}

@@ -24,9 +24,9 @@ declare const __VLS_base: import("vue").DefineComponent<NavItemProps, {}, {}, {}
 }, string, import("vue").PublicProps, Readonly<NavItemProps> & Readonly<{
   onClick?: ((event: MouseEvent) => any) | undefined;
 }>, {
-  isIconOnly: boolean;
-  isDisabled: boolean;
   size: NavItemSize;
+  isDisabled: boolean;
+  isIconOnly: boolean;
   block: boolean;
   isSelected: boolean;
   plain: boolean;

package/dist/{index-Cz9ZHVf6.d.ts → index-g03bmR4K.d.ts}

@@ -84,10 +84,10 @@ declare const __VLS_base$2: import("vue").DefineComponent<__VLS_PublicProps, {},
   onOpenChange?: ((isOpen: boolean) => any) | undefined;
   "onUpdate:isOpen"?: ((value: boolean) => any) | undefined;
 }>, {
-  placement: "above" | "below" | "start" | "end";
-  alignment: "center" | "start" | "end";
-  hideDelay: number;
   hover: boolean;
+  placement: "start" | "end" | "above" | "below";
+  alignment: "start" | "end" | "center";
+  hideDelay: number;
   showDelay: number;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$2: __VLS_WithSlots$2<typeof __VLS_base$2, __VLS_Slots$2>;

package/dist/{index-COxy6LEW.d.ts → index-gW0HW02U.d.ts}

@@ -125,8 +125,8 @@ declare const __VLS_base$1: import("vue").DefineComponent<__VLS_PublicProps, {
   onChange?: ((value: string) => any) | undefined;
   "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
 }>, {
-  isDisabled: boolean;
   size: SegmentedControlSize;
+  isDisabled: boolean;
   layout: SegmentedControlLayout;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;

package/dist/{index-BQa836Vz.d.ts → index-iBLzInje.d.ts}

@@ -1,4 +1,4 @@
-import { a as FieldSlots, l as FieldStatusVariant, n as FieldLabelSlots, r as FieldProps, s as FieldStatusProps, t as FieldLabelProps } from "./types-3eXh_5os.js";
+import { a as FieldSlots, l as FieldStatusVariant, n as FieldLabelSlots, r as FieldProps, t as FieldLabelProps } from "./types-3eXh_5os.js";
 //#region src/Field/Field.vue.d.ts
 type __VLS_Slots$1 = FieldSlots;
 declare const __VLS_base$1: import("vue").DefineComponent<FieldProps, {
@@ -6,8 +6,8 @@ declare const __VLS_base$1: import("vue").DefineComponent<FieldProps, {
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FieldProps> & Readonly<{}>, {
   statusVariant: "tooltip" | FieldStatusVariant;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$2: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
-declare const _default$2: typeof __VLS_export$2;
+declare const __VLS_export$1: __VLS_WithSlots$1<typeof __VLS_base$1, __VLS_Slots$1>;
+declare const _default$1: typeof __VLS_export$1;
 type __VLS_WithSlots$1<T, S> = T & {
   new (): {
     $slots: S;
@@ -22,20 +22,12 @@ declare const __VLS_base: import("vue").DefineComponent<FieldLabelProps, {
   optionalLabel: string;
   requiredLabel: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const __VLS_export$1: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
-declare const _default$1: typeof __VLS_export$1;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
 type __VLS_WithSlots<T, S> = T & {
   new (): {
     $slots: S;
   };
 };
 //#endregion
-//#region src/Field/FieldStatus.vue.d.ts
-declare const __VLS_export: import("vue").DefineComponent<FieldStatusProps, {
-  element: Readonly<import("vue").ShallowRef<HTMLElement | null>>;
-}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FieldStatusProps> & Readonly<{}>, {
-  variant: FieldStatusVariant;
-}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
-declare const _default: typeof __VLS_export;
-//#endregion
-export { _default$1 as n, _default$2 as r, _default as t };
+export { _default$1 as n, _default as t };