@feugene/granularity 0.1.0

package/dist/types/src/components/DsTabs/DsTabs.vue.d.ts

@@ -0,0 +1,24 @@
+export type DsTab = {
+    value: string;
+    label: string;
+    badge?: string;
+};
+type __VLS_Props = {
+    modelValue: string;
+    tabs: DsTab[];
+};
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/types/src/components/DsTabs/config.d.ts

@@ -0,0 +1 @@
+export declare const dsTabsConfig: import("../../registry/componentConfig").GranularityComponentConfig<"DsTabs">;

package/dist/types/src/components/DsTabs/index.d.ts

@@ -0,0 +1,5 @@
+export { default } from './DsTabs.vue';
+export { default as DsTabs } from './DsTabs.vue';
+export type { DsTab } from './DsTabs.vue';
+export { dsTabsConfig } from './config';
+export { dsTabsSafelist } from './safelist';

package/dist/types/src/components/DsTabs/safelist.d.ts

@@ -0,0 +1 @@
+export declare const dsTabsSafelist: readonly ["inline-flex", "flex-wrap", "gap-1", "rounded-[var(--ds-radius-lg)]", "border", "border-[var(--brd)]", "bg-[var(--muted)]", "p-1", "h-9", "px-3", "rounded-[10px]", "text-sm", "font-600", "transition-colors", "focus:outline-none", "focus-visible:ring-2", "focus-visible:ring-[var(--ring)]", "bg-[var(--card)]", "text-[var(--fg)]", "text-[var(--muted-fg)]", "hover:text-[var(--fg)]", "hover:bg-[color-mix(in_srgb,var(--card)_70%,transparent)]", "items-center", "gap-2", "text-[11px]", "px-1.5", "py-0.5", "rounded-full", "bg-[var(--secondary)]", "text-[var(--secondary-fg)]"];

package/dist/types/src/components/DsTextarea/DsTextarea.vue.d.ts

@@ -0,0 +1,65 @@
+export type { DsTextareaState } from './dsTextareaStyles';
+import { type DsTextareaState } from './dsTextareaStyles';
+type __VLS_Props = {
+    modelValue: string;
+    placeholder?: string;
+    autocomplete?: string;
+    disabled?: boolean;
+    invalid?: boolean;
+    state?: DsTextareaState;
+    name?: string;
+    id?: string;
+    rows?: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    placeholder: undefined;
+    autocomplete: undefined;
+    disabled: boolean;
+    invalid: boolean;
+    state: string;
+    name: undefined;
+    id: undefined;
+    rows: number;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    placeholder: undefined;
+    autocomplete: undefined;
+    disabled: boolean;
+    invalid: boolean;
+    state: string;
+    name: undefined;
+    id: undefined;
+    rows: number;
+}>>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    name: string;
+    id: string;
+    rows: number;
+    invalid: boolean;
+    placeholder: string;
+    autocomplete: string;
+    state: DsTextareaState;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/src/components/DsTextarea/config.d.ts

@@ -0,0 +1 @@
+export declare const dsTextareaConfig: import("../../registry/componentConfig").GranularityComponentConfig<"DsTextarea">;

package/dist/types/src/components/DsTextarea/dsTextareaStyles.d.ts

@@ -0,0 +1,6 @@
+export type DsTextareaState = 'default' | 'success' | 'warning' | 'danger';
+export declare function dsTextareaClass(options: {
+    state: DsTextareaState;
+    invalid: boolean;
+}): string;
+export declare const dsTextareaSafelist: string[];

package/dist/types/src/components/DsTextarea/index.d.ts

@@ -0,0 +1,5 @@
+export { default } from './DsTextarea.vue';
+export { default as DsTextarea } from './DsTextarea.vue';
+export { dsTextareaConfig } from './config';
+export type { DsTextareaState } from './dsTextareaStyles';
+export { dsTextareaSafelist } from './safelist';

package/dist/types/src/components/DsTextarea/safelist.d.ts

@@ -0,0 +1 @@
+export { dsTextareaSafelist } from './dsTextareaStyles';

package/dist/types/src/components/DsToaster/DsToaster.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/types/src/components/DsToaster/config.d.ts

@@ -0,0 +1 @@
+export declare const dsToasterConfig: import("../../registry/componentConfig").GranularityComponentConfig<"DsToaster">;

package/dist/types/src/components/DsToaster/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './DsToaster.vue';
+export { default as DsToaster } from './DsToaster.vue';
+export { dsToasterConfig } from './config';
+export { dsToasterSafelist } from './safelist';

package/dist/types/src/components/DsToaster/safelist.d.ts

@@ -0,0 +1 @@
+export declare const dsToasterSafelist: readonly ["fixed", "right-4", "top-4", "z-50", "grid", "w-[360px]", "max-w-[calc(100vw-2rem)]", "gap-3", "rounded-[var(--ds-radius-lg)]", "border", "border-[var(--brd)]", "bg-[var(--card)]", "px-4", "py-3", "shadow-[var(--ds-shadow-2)]", "flex", "items-start", "h-5", "w-5", "mt-0.5", "min-w-0", "flex-1", "text-[13px]", "font-700", "ds-muted", "h-4", "w-4"];

package/dist/types/src/components/DsTooltip/DsTooltip.vue.d.ts

@@ -0,0 +1,41 @@
+type __VLS_Props = {
+    text: string;
+    iconColor?: string;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    iconColor: string;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    iconColor: string;
+}>>> & Readonly<{}>, {
+    iconColor: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/src/components/DsTooltip/config.d.ts

@@ -0,0 +1 @@
+export declare const dsTooltipConfig: import("../../registry/componentConfig").GranularityComponentConfig<"DsTooltip">;

package/dist/types/src/components/DsTooltip/index.d.ts

@@ -0,0 +1,4 @@
+export { default } from './DsTooltip.vue';
+export { default as DsTooltip } from './DsTooltip.vue';
+export { dsTooltipConfig } from './config';
+export { dsTooltipSafelist } from './safelist';

package/dist/types/src/components/DsTooltip/safelist.d.ts

@@ -0,0 +1 @@
+export declare const dsTooltipSafelist: readonly ["group", "relative", "inline-flex", "items-center", "justify-center", "text-[var(--ds-tooltip-icon-color)]", "focus:outline-none", "h-4", "w-4", "pointer-events-none", "absolute", "bottom-[calc(100%+8px)]", "left-1/2", "z-10", "-translate-x-1/2", "whitespace-nowrap", "rounded-md", "border", "border-[var(--brd)]", "bg-[var(--popover)]", "px-2", "py-1", "text-[12px]", "text-[var(--popover-fg)]", "opacity-0", "shadow-[var(--ds-shadow-1)]", "transition-opacity", "duration-150", "group-hover:opacity-100", "group-focus-within:opacity-100"];

package/dist/types/src/components/DsTree/DsTree.vue.d.ts

@@ -0,0 +1,35 @@
+import type { DsTreeInstance, DsTreeNode, DsTreeNodeDropType } from './dsTreeTypes';
+import type { DsTreeProps } from './dsTreeProps';
+declare const __VLS_export: <T extends Record<string, any> = any>(__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").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & __VLS_PrettifyLocal<DsTreeProps<T> & {
+        onNodeClick?: ((data: T, node: DsTreeNode<T>) => any) | undefined;
+        onNodeExpand?: ((data: T, node: DsTreeNode<T>) => any) | undefined;
+        onNodeCollapse?: ((data: T, node: DsTreeNode<T>) => any) | undefined;
+        onNodeDrop?: ((draggingNode: DsTreeNode<T>, dropNode: DsTreeNode<T>, dropType: DsTreeNodeDropType) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: import("vue").ShallowUnwrapRef<DsTreeInstance<T>>) => void;
+    attrs: any;
+    slots: {
+        default?: (props: {
+            node: DsTreeNode<T>;
+            data: T;
+        }) => any;
+    };
+    emit: {
+        (event: "nodeClick", data: T, node: DsTreeNode<T>): void;
+        (event: "nodeExpand", data: T, node: DsTreeNode<T>): void;
+        (event: "nodeCollapse", data: T, node: DsTreeNode<T>): void;
+        (event: "nodeDrop", draggingNode: DsTreeNode<T>, dropNode: DsTreeNode<T>, dropType: DsTreeNodeDropType): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/src/components/DsTree/config.d.ts

@@ -0,0 +1 @@
+export declare const dsTreeConfig: import("../../registry/componentConfig").GranularityComponentConfig<"DsTree">;

package/dist/types/src/components/DsTree/dsTreeDataAdapter.d.ts

@@ -0,0 +1,14 @@
+import type { DsTreeKey } from './dsTreeTypes';
+import type { DsTreeDataProps } from './dsTreeProps';
+export type DsTreeDataAdapterOptions<T extends object> = Pick<DsTreeDataProps<T>, 'props' | 'nodeKey'>;
+export type DsTreeDataAdapter<T extends object> = {
+    hasNodeKey: () => boolean;
+    getChildrenKey: () => string;
+    getLabelKey: () => string;
+    getLabel: (data: T) => string;
+    getChildren: (data: T) => T[];
+    ensureChildren: (data: T) => T[];
+    getNodeKey: (data: T, index: number, parentKey: DsTreeKey | undefined) => DsTreeKey;
+    getExplicitNodeKey: (data: T) => DsTreeKey | undefined;
+};
+export declare function createDsTreeDataAdapter<T extends Record<string, any> = any>(options: DsTreeDataAdapterOptions<T>): DsTreeDataAdapter<T>;

package/dist/types/src/components/DsTree/dsTreeInteractionContext.d.ts

@@ -0,0 +1,31 @@
+import type { Ref, ShallowRef } from 'vue';
+import type { DsTreeAllowDropType, DsTreeKey, DsTreeNode, DsTreeNodeDropType } from './dsTreeTypes';
+export type DsTreeDropTarget = {
+    key: DsTreeKey;
+    type: DsTreeNodeDropType;
+    allowed: boolean;
+};
+export type DsTreeInteractionOptions<T> = {
+    draggable?: boolean;
+    allowDrop?: (draggingNode: DsTreeNode<T>, dropNode: DsTreeNode<T>, type: DsTreeAllowDropType) => boolean;
+    allowDrag?: (draggingNode: DsTreeNode<T>) => boolean;
+};
+export type DsTreeInteractionEmitters<T> = {
+    emitNodeClick: (data: T, node: DsTreeNode<T>) => void;
+    emitNodeExpand: (data: T, node: DsTreeNode<T>) => void;
+    emitNodeCollapse: (data: T, node: DsTreeNode<T>) => void;
+    emitNodeDrop: (draggingNode: DsTreeNode<T>, dropNode: DsTreeNode<T>, dropType: DsTreeNodeDropType) => void;
+};
+export type DsTreeInteractionContext<T> = {
+    hoveredKey: Ref<DsTreeKey | undefined>;
+    draggingNode: ShallowRef<DsTreeNode<T> | null>;
+    dropTarget: ShallowRef<DsTreeDropTarget | null>;
+    canDrag: (node: DsTreeNode<T>) => boolean;
+    canDrop: (drag: DsTreeNode<T>, target: DsTreeNode<T>, type: DsTreeAllowDropType) => boolean;
+    resetDragState: () => void;
+    emitNodeClick: (data: T, node: DsTreeNode<T>) => void;
+    emitNodeExpand: (data: T, node: DsTreeNode<T>) => void;
+    emitNodeCollapse: (data: T, node: DsTreeNode<T>) => void;
+    emitNodeDrop: (draggingNode: DsTreeNode<T>, dropNode: DsTreeNode<T>, dropType: DsTreeNodeDropType) => void;
+};
+export declare function createDsTreeInteractionContext<T>(options: DsTreeInteractionOptions<T>, emitters: DsTreeInteractionEmitters<T>): DsTreeInteractionContext<T>;

package/dist/types/src/components/DsTree/dsTreeProps.d.ts

@@ -0,0 +1,57 @@
+import type { HTMLAttributes } from 'vue';
+import type { DsTreeInteractionContext } from './dsTreeInteractionContext';
+import type { DsTreeStore } from './dsTreeStore';
+import type { DsTreeAllowDropType, DsTreeKey, DsTreeNode } from './dsTreeTypes';
+export type NodeKeyProp<T extends object> = Extract<keyof T, string>;
+export type DsTreePropsMap = {
+    children?: string;
+    label?: string;
+};
+export type DsTreeFilterNodeMethod<T extends object = any> = (value: string, data: T, node?: DsTreeNode<T>) => boolean;
+export type DsTreeBranchLineColor<T extends object = any> = string | ((node: DsTreeNode<T>) => string | undefined | null);
+export type DsTreeVisibleRow<T extends object> = {
+    node: DsTreeNode<T>;
+    isExpanded: boolean;
+    isLeaf: boolean;
+    isMatched: boolean;
+};
+export type DsTreeVisibleTreeRow<T extends object> = DsTreeVisibleRow<T> & {
+    children: DsTreeVisibleTreeRow<T>[];
+};
+export type DsTreeClassValue = HTMLAttributes['class'];
+export type DsTreeNodeClass<T extends object> = DsTreeClassValue | ((row: DsTreeVisibleRow<T>) => DsTreeClassValue);
+export type DsTreeDataProps<T extends object> = {
+    data: T[];
+    props?: DsTreePropsMap;
+    nodeKey?: NodeKeyProp<T> | 'id';
+    defaultExpandedKeys?: DsTreeKey[];
+    filterNodeMethod?: DsTreeFilterNodeMethod<T>;
+};
+export type DsTreeViewProps<T extends object> = {
+    highlightCurrent?: boolean;
+    expandIcon?: string;
+    collapseIcon?: string;
+    toggleIconRotate?: boolean;
+    branchLine?: boolean;
+    branchLineColor?: DsTreeBranchLineColor<T>;
+    branchLineActiveColor?: DsTreeBranchLineColor<T>;
+    rowClass?: DsTreeNodeClass<T>;
+    dragHandleClass?: DsTreeNodeClass<T>;
+    toggleClass?: DsTreeNodeClass<T>;
+    toggleIconClass?: DsTreeNodeClass<T>;
+    toggleSpacerClass?: DsTreeNodeClass<T>;
+    contentClass?: DsTreeNodeClass<T>;
+};
+export type DsTreeInteractionProps<T extends object> = {
+    draggable?: boolean;
+    dragHandleIcon?: string;
+    allowDrop?: (draggingNode: DsTreeNode<T>, dropNode: DsTreeNode<T>, type: DsTreeAllowDropType) => boolean;
+    allowDrag?: (draggingNode: DsTreeNode<T>) => boolean;
+};
+export type DsTreeInternalProps<T extends object> = {
+    internalRows?: DsTreeVisibleTreeRow<T>[];
+    internalNested?: boolean;
+    internalStore?: DsTreeStore<T>;
+    internalInteractionContext?: DsTreeInteractionContext<T>;
+};
+export type DsTreeProps<T extends object> = DsTreeDataProps<T> & DsTreeViewProps<T> & DsTreeInteractionProps<T> & DsTreeInternalProps<T>;

package/dist/types/src/components/DsTree/dsTreeStore.d.ts

@@ -0,0 +1,45 @@
+import type { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from 'vue';
+import type { DsTreeKey, DsTreeNode, DsTreeNodeDropType, DsTreeNodeTarget } from './dsTreeTypes';
+import type { DsTreeDataAdapter } from './dsTreeDataAdapter';
+import type { DsTreeDataProps, DsTreeFilterNodeMethod } from './dsTreeProps';
+type TreeModel<T extends object> = {
+    roots: DsTreeNode<T>[];
+    byKey: Map<DsTreeKey, DsTreeNode<T>>;
+    byData: WeakMap<T, DsTreeNode<T>>;
+};
+type FilterInfo = {
+    isActive: boolean;
+    subtreeHasMatch: Map<DsTreeKey, boolean>;
+    matchedKeys: Set<DsTreeKey>;
+    autoExpandKeys: Set<DsTreeKey>;
+};
+export type DsTreeStoreOptions<T extends object> = {
+    data: MaybeRefOrGetter<DsTreeDataProps<T>['data']>;
+    defaultExpandedKeys?: MaybeRefOrGetter<DsTreeDataProps<T>['defaultExpandedKeys']>;
+    filterNodeMethod?: MaybeRefOrGetter<DsTreeFilterNodeMethod<T> | undefined>;
+    adapter: DsTreeDataAdapter<T>;
+};
+export type DsTreeStore<T extends object> = {
+    filterValue: Ref<string>;
+    expandedKeys: ShallowRef<Set<DsTreeKey>>;
+    currentKey: Ref<DsTreeKey | undefined>;
+    treeModel: ComputedRef<TreeModel<T>>;
+    filterInfo: ComputedRef<FilterInfo>;
+    filter: (value: string) => void;
+    isExpandedKey: (key: DsTreeKey) => boolean;
+    setExpandedKey: (key: DsTreeKey, expanded: boolean) => void;
+    toggleExpand: (node: DsTreeNode<T>) => void;
+    setCurrentKey: (key?: DsTreeKey) => void;
+    getCurrentKey: () => DsTreeKey | undefined;
+    getCurrentNode: () => DsTreeNode<T> | undefined;
+    setCurrentNode: (node?: DsTreeNodeTarget<T>) => boolean;
+    getNode: (key: DsTreeKey) => DsTreeNode<T> | undefined;
+    canMoveNode: (node: DsTreeNodeTarget<T>, referenceNode: DsTreeNodeTarget<T>, dropType: DsTreeNodeDropType) => boolean;
+    moveNode: (node: DsTreeNodeTarget<T>, referenceNode: DsTreeNodeTarget<T>, dropType: DsTreeNodeDropType) => DsTreeNode<T> | undefined;
+    appendNode: (data: T, parent: DsTreeNodeTarget<T>) => DsTreeNode<T> | undefined;
+    removeNode: (node: DsTreeNodeTarget<T>) => boolean;
+    insertNodeBefore: (data: T, referenceNode: DsTreeNodeTarget<T>) => DsTreeNode<T> | undefined;
+    insertNodeAfter: (data: T, referenceNode: DsTreeNodeTarget<T>) => DsTreeNode<T> | undefined;
+};
+export declare function createDsTreeStore<T extends Record<string, any> = any>(options: DsTreeStoreOptions<T>): DsTreeStore<T>;
+export {};

package/dist/types/src/components/DsTree/dsTreeTypes.d.ts

@@ -0,0 +1,24 @@
+export type DsTreeKey = string | number;
+export type DsTreeNodeDropType = 'prev' | 'inner' | 'next';
+export type DsTreeAllowDropType = DsTreeNodeDropType;
+export type DsTreeNode<T = any> = {
+    key: DsTreeKey;
+    label: string;
+    data: T;
+    level: number;
+    parent?: DsTreeNode<T>;
+    childNodes: DsTreeNode<T>[];
+};
+export type DsTreeNodeTarget<T = any> = DsTreeKey | DsTreeNode<T> | T;
+export type DsTreeInstance<T = any> = {
+    filter: (value: string) => void;
+    setCurrentKey: (key?: DsTreeKey) => void;
+    getCurrentKey: () => DsTreeKey | undefined;
+    appendNode: (data: T, parent: DsTreeNodeTarget<T>) => DsTreeNode<T> | undefined;
+    removeNode: (node: DsTreeNodeTarget<T>) => boolean;
+    insertNodeBefore: (data: T, referenceNode: DsTreeNodeTarget<T>) => DsTreeNode<T> | undefined;
+    insertNodeAfter: (data: T, referenceNode: DsTreeNodeTarget<T>) => DsTreeNode<T> | undefined;
+    getCurrentNode: () => DsTreeNode<T> | undefined;
+    setCurrentNode: (node?: DsTreeNodeTarget<T>) => boolean;
+    getNode: (key: DsTreeKey) => DsTreeNode<T> | undefined;
+};

package/dist/types/src/components/DsTree/index.d.ts

@@ -0,0 +1,6 @@
+export { default } from './DsTree.vue';
+export { default as DsTree } from './DsTree.vue';
+export type { DsTreeAllowDropType, DsTreeInstance, DsTreeKey, DsTreeNode, DsTreeNodeDropType, DsTreeNodeTarget, } from './dsTreeTypes';
+export type { DsTreeBranchLineColor, DsTreeFilterNodeMethod, DsTreeNodeClass, DsTreeProps, DsTreePropsMap, DsTreeVisibleRow, DsTreeVisibleTreeRow, } from './dsTreeProps';
+export { dsTreeConfig } from './config';
+export { dsTreeSafelist } from './safelist';

package/dist/types/src/components/DsTree/safelist.d.ts

@@ -0,0 +1 @@
+export declare const dsTreeSafelist: readonly ["py-2", "px-2", "ml-6", "i-lucide-chevron-right", "i-lucide-grip-vertical"];

package/dist/types/src/components/DsTreeSelect/DsTreeSelect.vue.d.ts

@@ -0,0 +1,72 @@
+import type { InputHTMLAttributes } from 'vue';
+import { type DsInputSize } from '../DsInput/DsInput.vue';
+import { type DsTreeFilterNodeMethod, type DsTreePropsMap, type DsTreeKey, type DsTreeNode } from '../DsTree';
+import type { DsTreeSelectModelValue, DsTreeSelectValueDisplay } from './dsTreeSelectTypes';
+import { type DsTreeSelectState } from './dsTreeSelectStyles';
+declare const __VLS_export: <T extends Record<string, any> = any>(__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").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & __VLS_PrettifyLocal<{
+        modelValue: DsTreeSelectModelValue;
+        data: T[];
+        props?: DsTreePropsMap;
+        nodeKey?: (keyof T & string) | "id";
+        defaultExpandedKeys?: DsTreeKey[];
+        disabled?: boolean;
+        placeholder?: string;
+        size?: DsInputSize;
+        invalid?: boolean;
+        state?: DsTreeSelectState;
+        multiple?: boolean;
+        clearable?: boolean;
+        /** Как отображать выбранное значение в single-режиме. */
+        valueDisplay?: DsTreeSelectValueDisplay;
+        filterable?: boolean;
+        filterPlaceholder?: string;
+        filterInputmode?: InputHTMLAttributes["inputmode"];
+        filterNodeMethod?: DsTreeFilterNodeMethod<T>;
+        closeOnSelect?: boolean;
+        dropdownMaxHeight?: number;
+    } & {
+        "onUpdate:modelValue"?: ((value: DsTreeSelectModelValue) => any) | undefined;
+        onChange?: ((value: DsTreeSelectModelValue) => any) | undefined;
+        onClear?: (() => any) | undefined;
+        onNodeClick?: ((data: T, node: DsTreeNode<T>) => any) | undefined;
+        onVisibleChange?: ((visible: boolean) => any) | undefined;
+    }> & (typeof globalThis extends {
+        __VLS_PROPS_FALLBACK: infer P;
+    } ? P : {});
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+        /** Рендер значения внутри триггера (вместо дефолтного текста). */
+        value?: (props: {
+            value: DsTreeSelectModelValue;
+            labels: string[];
+            displayValue: string;
+            pathLabels?: string[];
+        }) => any;
+        /** Рендер строки дерева. */
+        node?: (props: {
+            node: DsTreeNode<T>;
+            data: T;
+            selected: boolean;
+        }) => any;
+        /** Содержимое пустого состояния (когда нет данных). */
+        empty?: () => any;
+    };
+    emit: {
+        (e: "update:modelValue", value: DsTreeSelectModelValue): void;
+        (e: "change", value: DsTreeSelectModelValue): void;
+        (e: "visibleChange", visible: boolean): void;
+        (e: "clear"): void;
+        (e: "nodeClick", data: T, node: DsTreeNode<T>): void;
+    };
+}>) => import("vue").VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/types/src/components/DsTreeSelect/config.d.ts

@@ -0,0 +1 @@
+export declare const dsTreeSelectConfig: import("../../registry/componentConfig").GranularityComponentConfig<"DsTreeSelect">;

package/dist/types/src/components/DsTreeSelect/dsTreeSelectStyles.d.ts

@@ -0,0 +1,9 @@
+import type { DsInputSize } from '../DsInput';
+export type DsTreeSelectState = 'default' | 'success' | 'warning' | 'danger';
+export declare function dsTreeSelectClass(options: {
+    size: DsInputSize;
+    state: DsTreeSelectState;
+    invalid: boolean;
+}): string;
+export declare const dsTreeSelectPanelClass = "rounded-[var(--ds-radius-xl)] border border-[var(--brd)] bg-[var(--card)] text-[var(--card-fg)] shadow-[var(--ds-shadow-2)] overflow-hidden";
+export declare const dsTreeSelectSafelist: string[];

package/dist/types/src/components/DsTreeSelect/dsTreeSelectTypes.d.ts

@@ -0,0 +1,3 @@
+import type { DsTreeKey } from '../DsTree/dsTreeTypes';
+export type DsTreeSelectModelValue = DsTreeKey | DsTreeKey[] | null;
+export type DsTreeSelectValueDisplay = 'label' | 'path';

package/dist/types/src/components/DsTreeSelect/index.d.ts

@@ -0,0 +1,5 @@
+export { default } from './DsTreeSelect.vue';
+export { default as DsTreeSelect } from './DsTreeSelect.vue';
+export type { DsTreeSelectModelValue, DsTreeSelectValueDisplay } from './dsTreeSelectTypes';
+export { dsTreeSelectConfig } from './config';
+export { dsTreeSelectSafelist } from './safelist';

package/dist/types/src/components/DsTreeSelect/safelist.d.ts

@@ -0,0 +1 @@
+export { dsTreeSelectSafelist } from './dsTreeSelectStyles';

package/dist/types/src/components/shared/classTokens.d.ts

@@ -0,0 +1 @@
+export declare function splitClassTokens(value: string): string[];

package/dist/types/src/composables/useTheme.d.ts

@@ -0,0 +1,24 @@
+export type ThemeName = 'light' | 'dark';
+export type UseThemeOptions = {
+    /**
+     * Ключ для хранения выбранной темы в localStorage.
+     * По умолчанию: `fint-ds-theme`.
+     */
+    storageKey?: string;
+    /**
+     * Если `false` — не читать/не писать localStorage (полезно для SSR/embedded сценариев).
+     * По умолчанию: `true`.
+     */
+    persist?: boolean;
+};
+/**
+ * Для применения темы максимально рано (до монтирования Vue), чтобы избежать "мигания".
+ */
+export declare function initThemeEarly(options?: UseThemeOptions): void;
+export declare function useTheme(options?: UseThemeOptions): {
+    theme: import("vue").Ref<ThemeName, ThemeName>;
+    isDark: import("vue").ComputedRef<boolean>;
+    setTheme: (next: ThemeName) => void;
+    toggleTheme: () => void;
+    initTheme: () => void;
+};

package/dist/types/src/composables/useToast.d.ts

@@ -0,0 +1,19 @@
+export type ToastVariant = 'info' | 'success' | 'warning' | 'danger';
+export type ToastInput = {
+    title: string;
+    message?: string;
+    variant?: ToastVariant;
+    timeoutMs?: number;
+};
+export type Toast = {
+    id: string;
+    title: string;
+    message?: string;
+    variant: ToastVariant;
+};
+export declare function useToast(): {
+    list: import("vue").ComputedRef<import("vue").Reactive<Toast[]>>;
+    push: (input: ToastInput) => string;
+    dismiss: (id: string) => void;
+    clear: () => void;
+};

package/dist/types/src/directives/autofocus.d.ts

@@ -0,0 +1,11 @@
+import type { Directive } from 'vue';
+export type AutofocusBindingValue = boolean | string | {
+    selector?: string;
+    preventScroll?: boolean;
+    disabled?: boolean;
+};
+/**
+ * `v-autofocus` — универсальный автофокус.
+ * Работает как на нативных элементах, так и на компонентах-обёртках (фокусирует вложенный `input/textarea/...`).
+ */
+export declare const vAutofocus: Directive<HTMLElement, AutofocusBindingValue>;

package/dist/types/src/directives/autosize.d.ts

@@ -0,0 +1,13 @@
+import type { Directive } from 'vue';
+export type AutosizeBindingValue = boolean | {
+    enabled?: boolean;
+};
+/**
+ * `v-autosize` — автоподстройка высоты `textarea`.
+ *
+ * Пример:
+ * ```vue
+ * <textarea v-autosize />
+ * ```
+ */
+export declare const vAutosize: Directive<HTMLElement, AutosizeBindingValue>;

package/dist/types/src/directives/clickOutside.d.ts

@@ -0,0 +1,18 @@
+import type { Directive } from 'vue';
+export type ClickOutsideHandler = (event: MouseEvent | TouchEvent | PointerEvent) => void;
+export type ClickOutsideExclude = HTMLElement | string | (() => HTMLElement | null | undefined);
+export type ClickOutsideBindingValue = ClickOutsideHandler | {
+    handler: ClickOutsideHandler;
+    /** По умолчанию `true`. */
+    enabled?: boolean;
+    /** По умолчанию `true` (слушаем в capture, чтобы stopPropagation внутри не ломал закрытие). */
+    capture?: boolean;
+    /** Список событий. По умолчанию `['click']`. */
+    events?: Array<'click' | 'mousedown' | 'touchstart' | 'pointerdown'>;
+    /** Элементы/селекторы, клики по которым считаются "внутри". */
+    exclude?: ClickOutsideExclude[];
+};
+/**
+ * `v-click-outside` — обработчик клика вне элемента (например, закрытие дропдауна/модалки).
+ */
+export declare const vClickOutside: Directive<HTMLElement, ClickOutsideBindingValue>;