@dskripchenko/ui 1.5.0 → 1.6.0

package/dist/components/Breadcrumb/UidBreadcrumb.vue.d.ts

@@ -1,7 +1,21 @@
 export interface UidBreadcrumbProps {
     label?: string;
     separator?: string;
+    /** Keep the trail on one line: crumbs do not wrap and long ones truncate with an ellipsis. */
+    nowrap?: boolean;
+    /**
+     * Implies `nowrap`. When the trail does not fit, the middle crumbs (from the
+     * second one on) collapse into "…" until it fits; the first and the last crumb stay.
+     */
+    collapse?: boolean;
+    /** `collapse` mode: the "…" is a button that opens a menu of the collapsed crumbs. Set `false` for a plain "…". */
+    collapseMenu?: boolean;
 }
+/**
+ * Lay every crumb out at its natural width, then hide middle crumbs (second
+ * one first) until the rest plus the "…" fits the list.
+ */
+declare function recompute(): Promise<void>;
 declare function __VLS_template(): {
     attrs: Partial<{}>;
     slots: Readonly<{
@@ -9,14 +23,29 @@ declare function __VLS_template(): {
     }> & {
         default(): unknown;
     };
-    refs: {};
+    refs: {
+        navRef: HTMLElement;
+        listRef: HTMLOListElement;
+        probeRef: HTMLSpanElement;
+        menuRef: HTMLDivElement;
+    };
     rootEl: HTMLElement;
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import('vue').DefineComponent<UidBreadcrumbProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidBreadcrumbProps> & Readonly<{}>, {
+declare const __VLS_component: import('vue').DefineComponent<UidBreadcrumbProps, {
+    recompute: typeof recompute;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<UidBreadcrumbProps> & Readonly<{}>, {
     label: string;
     separator: string;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLElement>;
+    nowrap: boolean;
+    collapse: boolean;
+    collapseMenu: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    navRef: HTMLElement;
+    listRef: HTMLOListElement;
+    probeRef: HTMLSpanElement;
+    menuRef: HTMLDivElement;
+}, HTMLElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;
 type __VLS_WithTemplateSlots<T, S> = T & {

package/dist/components/Breadcrumb/context.d.ts

@@ -2,5 +2,18 @@ import { InjectionKey, Ref } from 'vue';
 export interface BreadcrumbContext {
     /** Bumped after every UidBreadcrumb update so items can re-check whether they are last. */
     tick: Ref<number>;
+    /**
+     * `collapse` mode: the `<li>` elements of the crumbs collapsed into "…", in DOM order.
+     * The first one stays in the layout and shows the "…" in place of its content.
+     */
+    hidden: Ref<readonly HTMLElement[]>;
+    /** Whether the "…" opens a menu of the collapsed crumbs. */
+    menu: Ref<boolean>;
+    /** The menu's element id (for `aria-controls`). */
+    menuId: string;
+    /** Whether that menu is open. */
+    menuOpen: Ref<boolean>;
+    /** Toggle the menu of collapsed crumbs, anchored to the "…" button. */
+    toggleMenu: (trigger: HTMLElement) => void;
 }
 export declare const BREADCRUMB_KEY: InjectionKey<BreadcrumbContext>;

package/dist/components/Select/UidSelect.vue.d.ts

@@ -5,7 +5,15 @@ export interface SelectOption {
     group?: string;
 }
 export type SelectValue = string | number;
-export interface UidSelectProps {
+/**
+ * The v-model type for a given `multiple` flag: `SelectValue | null` in single
+ * mode, `SelectValue[]` with `multiple: true`. A non-literal `boolean` (for
+ * example `:multiple="isMulti"`) gives the union of both.
+ */
+export type SelectModelValue<M extends boolean = false> = M extends true ? SelectValue[] : SelectValue | null;
+export interface UidSelectProps<M extends boolean = boolean> {
+    /** v-model value: `SelectValue | null` in single mode, `SelectValue[]` with `multiple`. */
+    modelValue?: SelectModelValue<M>;
     options: SelectOption[];
     placeholder?: string;
     disabled?: boolean;
@@ -15,33 +23,27 @@ export interface UidSelectProps {
     /**
      * Multi-value mode: v-model is an array, the selected options are shown as
      * removable chips, and picking an option toggles it without closing the dropdown.
+     * The type parameter `M` follows this flag, so `v-model` and the
+     * `update:modelValue` / `change` payloads are typed per mode.
+     * (`boolean & M` keeps the runtime prop a Boolean, so a bare `multiple` attribute works.)
      */
-    multiple?: boolean;
+    multiple?: boolean & M;
     /** Multiple mode: show at most this many chips and collapse the rest into "+N". */
     maxTagCount?: number;
 }
-type __VLS_Props = UidSelectProps;
-type __VLS_PublicProps = {
-    modelValue?: SelectValue | SelectValue[] | null;
-} & __VLS_Props;
-declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
-    "update:modelValue": (value: SelectValue | SelectValue[] | null) => any;
-    change: (value: SelectValue | SelectValue[] | null) => any;
-}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
-    "onUpdate:modelValue"?: ((value: SelectValue | SelectValue[] | null) => any) | undefined;
-    onChange?: ((value: SelectValue | SelectValue[] | null) => any) | undefined;
-}>, {
-    size: "sm" | "md" | "lg";
-    disabled: boolean;
-    multiple: boolean;
-    searchable: boolean;
-    clearable: boolean;
-    maxTagCount: number;
-}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
-    containerRef: HTMLDivElement;
-    triggerRef: HTMLDivElement;
-    dropdownRef: HTMLDivElement;
-    searchRef: HTMLInputElement;
-    listRef: HTMLDivElement;
-}, HTMLDivElement>;
+declare const _default: <M extends boolean = false>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly "onUpdate:modelValue"?: ((value: SelectModelValue<M>) => any) | undefined;
+        readonly onChange?: ((value: SelectModelValue<M>) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onChange" | "onUpdate:modelValue"> & UidSelectProps<M> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: {};
+    emit: ((evt: "update:modelValue", value: SelectModelValue<M>) => void) & ((evt: "change", value: SelectModelValue<M>) => void);
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
 export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

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

@@ -1,2 +1,2 @@
 export { default as UidSelect } from './UidSelect.vue';
-export type { UidSelectProps, SelectOption, SelectValue } from './UidSelect.vue';
+export type { UidSelectProps, SelectOption, SelectValue, SelectModelValue } from './UidSelect.vue';

package/dist/components/Table/UidTable.vue.d.ts

@@ -22,6 +22,12 @@ export interface UidTableProps {
     bordered?: boolean;
     /** Switch on the checkbox column on the left (the header plus every row). */
     selectable?: boolean;
+    /**
+     * Pin the selection column to the left edge while the table scrolls horizontally.
+     * By default it is pinned only together with `fixed: 'left'` columns;
+     * `true` pins it on its own, `false` never pins it.
+     */
+    selectionFixed?: boolean;
     /** The set of ids of the selected rows. */
     selection?: Set<string | number>;
     /** The row's id field. `id` by default. */
@@ -59,6 +65,7 @@ declare const __VLS_component: import('vue').DefineComponent<UidTableProps, {},
     striped: boolean;
     bordered: boolean;
     selectable: boolean;
+    selectionFixed: boolean;
     selection: Set<string | number>;
     rowKey: string | ((row: Record<string, unknown>) => string | number);
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {

package/dist/composables/useRouterLink.d.ts

@@ -0,0 +1,18 @@
+import { Component, ComputedRef } from 'vue';
+export type RouterLocation = string | Record<string, unknown>;
+export interface UseRouterLinkSource {
+    href?: string;
+    to?: RouterLocation;
+}
+export interface UseRouterLink {
+    /** The app's globally registered `RouterLink`, or `null` when `to` is unset or vue-router is not installed. */
+    routerLink: ComputedRef<Component | null>;
+    /** Plain `href` for the `<a>` fallback: explicit `href`, else a string `to`. */
+    fallbackHref: ComputedRef<string | undefined>;
+}
+/**
+ * Resolves `to` against a globally registered RouterLink without warning or rendering a
+ * broken `<routerlink>` element when vue-router is absent; callers fall back to `<a href>`.
+ * Must be called during component setup.
+ */
+export declare function useRouterLink(source: UseRouterLinkSource): UseRouterLink;