@skdx/vue 0.26.0

package/dist/tree-select/context.d.cts

@@ -0,0 +1,146 @@
+import type { InjectionKey, Ref, VNodeChild } from 'vue';
+import type { TreeCheckedState } from '../tree/context.cjs';
+import type { TreeSelectFlatNode, TreeSelectIndex } from './collection.cjs';
+/**
+ * One node of an `SkdxTreeSelect`'s `collection`. Plain data, not elements:
+ * cascading check state, `valueStrategy` projection, and filtering all need to
+ * see branches that are collapsed (and therefore unmounted), which a
+ * children-based tree cannot offer.
+ */
+export interface TreeSelectNode {
+    /** Unique identifier across the whole collection — what lands in `value`, and what every callback names. */
+    value: string;
+    /**
+     * Human-readable text: rendered as the node's content, matched by `filter`, and shown by `SkdxTreeSelectValue`.
+     * @default undefined — falls back to `value`.
+     */
+    label?: string;
+    /**
+     * Excludes this node from checking, cascade propagation, keyboard
+     * navigation, and its parent's checked-ness calculation. Inherited by the
+     * whole subtree — a disabled branch cannot be toggled through its children.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Child nodes. A node with an empty (or absent) `children` is a leaf: it is
+     * not expandable and reports no `aria-expanded`.
+     * @default undefined — a leaf.
+     */
+    children?: TreeSelectNode[];
+}
+/**
+ * Whether checking a node propagates through its subtree. `'cascade'` makes
+ * the tree a tri-state checkbox tree: checking a parent checks every enabled
+ * descendant, and a partially-checked parent reports `aria-checked="mixed"`.
+ * `'independent'` disables propagation entirely — each node stands alone.
+ *
+ * Only meaningful while `multiple` is set; a single-select tree has one
+ * checked node by definition and never cascades.
+ */
+export type TreeSelectCheckStrategy = 'cascade' | 'independent';
+/**
+ * Which of the checked nodes are actually emitted in `value`.
+ *
+ * - `'all'` — every checked node, parents and descendants alike.
+ * - `'leaf'` — only checked leaves; branches are dropped.
+ * - `'shallowest'` — only the topmost fully-checked node of each branch,
+ *   collapsing a fully-checked subtree to the single node that implies it.
+ *
+ * Ignored (treated as `'all'`) under `check-strategy="independent"`, where no
+ * node implies any other and dropping one would silently lose a selection.
+ */
+export type TreeSelectValueStrategy = 'all' | 'leaf' | 'shallowest';
+/** Predicate deciding whether a node matches the current filter text. */
+export type TreeSelectFilter = (node: TreeSelectNode, inputValue: string) => boolean;
+/**
+ * Renders a node's content — the label, and anything beside it such as an
+ * `SkdxTreeItemIndicator` chevron or an `SkdxTreeSelectItemIndicator` checkmark.
+ * The returned nodes render *inside* the node's `treeitem`, so both indicators
+ * find their context there.
+ */
+export type TreeSelectRenderLabel = (node: TreeSelectNode) => VNodeChild;
+/** @internal Shared state distributed from `SkdxTreeSelect` to its parts via provide/inject. */
+export interface TreeSelectContext {
+    collection: Readonly<Ref<readonly TreeSelectNode[]>>;
+    index: Readonly<Ref<TreeSelectIndex>>;
+    /** Every node value in collection pre-order. */
+    order: Readonly<Ref<readonly string[]>>;
+    /** The emitted value: the checked set projected through `valueStrategy`. */
+    value: Readonly<Ref<readonly string[]>>;
+    multiple: boolean;
+    /** Whether checking actually propagates: `checkStrategy === 'cascade'` *and* `multiple`. */
+    cascade: Readonly<Ref<boolean>>;
+    disabled: boolean;
+    readOnly: boolean;
+    /** A node's tri-state value, derived from its enabled leaf descendants under `cascade`. */
+    checkStateOf(value: string): TreeCheckedState;
+    /** Toggles a node (respecting `checkStrategy`), emits the projected value, and closes when `closeOnSelect`. */
+    commit(value: string): void;
+    open: Readonly<Ref<boolean>>;
+    onOpenChange(open: boolean): void;
+    /** Effective expanded values — the caller's expansion plus, while filtering, the ancestors of every match. */
+    expandedIds: Readonly<Ref<string[]>>;
+    expanded: Readonly<Ref<ReadonlySet<string>>>;
+    setExpanded(value: string, expand: boolean): void;
+    /** Adapter turning the composed `SkdxTree`'s whole-array expansion event back into a single-node change. */
+    onTreeExpandedIdsChange(ids: string[]): void;
+    /** Values whose check state is fully `true`, handed to the composed `SkdxTree` as its `selected-ids`. */
+    selectedIds: Readonly<Ref<string[]>>;
+    /** Whether a node survives the current filter (always `true` when not filtering). */
+    isVisible(value: string): boolean;
+    /** Visible, expanded nodes in navigation order. */
+    flat: Readonly<Ref<readonly TreeSelectFlatNode[]>>;
+    flatMap: Readonly<Ref<ReadonlyMap<string, TreeSelectFlatNode>>>;
+    activeValue: Readonly<Ref<string | null>>;
+    setActiveValue(value: string | null): void;
+    /** DOM id of a node's `treeitem`, for `aria-activedescendant`. */
+    itemId(value: string): string;
+    treeId: string;
+    contentId: string;
+    triggerRef: Ref<HTMLElement | null>;
+    contentRef: Ref<HTMLElement | null>;
+    inputRef: Ref<HTMLInputElement | null>;
+    /** Whether an `SkdxTreeSelectInput` is mounted — it takes DOM focus, and with it `aria-activedescendant`, off the trigger. */
+    hasInput: Readonly<Ref<boolean>>;
+    setHasInput(hasInput: boolean): void;
+    inputValue: Readonly<Ref<string>>;
+    onInputValueChange(value: string): void;
+    /** A node's `label`, or its `value` when it has none. */
+    getLabel(value: string): string;
+    /** Moves DOM focus back to the trigger — what Escape and `closeOnSelect` both do. */
+    focusTrigger(): void;
+    /** The shared keydown handler both `SkdxTreeSelectTrigger` and `SkdxTreeSelectInput` delegate to. */
+    onNavigationKeyDown(event: KeyboardEvent, options: {
+        typeahead: boolean;
+        selectOnSpace: boolean;
+    }): void;
+}
+/** @internal Injection key the TreeSelect root provides so its Trigger, Content, Input, Tree and Items share every piece of state. */
+export declare const TREE_SELECT_CONTEXT: InjectionKey<TreeSelectContext>;
+/** @internal Per-node state distributed from `SkdxTreeSelectItem` to `SkdxTreeSelectItemIndicator`. */
+export interface TreeSelectItemContext {
+    value: string;
+    checkState: TreeCheckedState;
+    disabled: boolean;
+    expanded: boolean;
+    hasChildren: boolean;
+    /** Whether this node is the virtually-focused one named by `aria-activedescendant`. */
+    active: boolean;
+}
+/** @internal Injection key an SkdxTreeSelectItem provides so its ItemIndicator can read the node's check state. */
+export declare const TREE_SELECT_ITEM_CONTEXT: InjectionKey<TreeSelectItemContext>;
+/** @internal Generates the id prefix a TreeSelect keys its `treeitem` DOM ids off. */
+export declare function nextTreeSelectId(suffix: string): string;
+/**
+ * Default `filter`: case-insensitive substring match on the node's
+ * `label ?? value`.
+ *
+ * Lives here rather than in `TreeSelect.vue` because
+ * `withDefaults(defineProps())` is hoisted out of `setup()`, so it cannot
+ * reference a binding declared locally in the same `<script setup>` — only an
+ * imported one.
+ */
+export declare function defaultTreeSelectFilter(node: TreeSelectNode, inputValue: string): boolean;
+/** Default `getMatchCountLabel`: `"1 match available"` / `"3 matches available"`. */
+export declare function defaultGetMatchCountLabel(count: number): string;

package/dist/tree-select/context.d.ts

@@ -0,0 +1,146 @@
+import type { InjectionKey, Ref, VNodeChild } from 'vue';
+import type { TreeCheckedState } from '../tree/context.js';
+import type { TreeSelectFlatNode, TreeSelectIndex } from './collection.js';
+/**
+ * One node of an `SkdxTreeSelect`'s `collection`. Plain data, not elements:
+ * cascading check state, `valueStrategy` projection, and filtering all need to
+ * see branches that are collapsed (and therefore unmounted), which a
+ * children-based tree cannot offer.
+ */
+export interface TreeSelectNode {
+    /** Unique identifier across the whole collection — what lands in `value`, and what every callback names. */
+    value: string;
+    /**
+     * Human-readable text: rendered as the node's content, matched by `filter`, and shown by `SkdxTreeSelectValue`.
+     * @default undefined — falls back to `value`.
+     */
+    label?: string;
+    /**
+     * Excludes this node from checking, cascade propagation, keyboard
+     * navigation, and its parent's checked-ness calculation. Inherited by the
+     * whole subtree — a disabled branch cannot be toggled through its children.
+     * @default false
+     */
+    disabled?: boolean;
+    /**
+     * Child nodes. A node with an empty (or absent) `children` is a leaf: it is
+     * not expandable and reports no `aria-expanded`.
+     * @default undefined — a leaf.
+     */
+    children?: TreeSelectNode[];
+}
+/**
+ * Whether checking a node propagates through its subtree. `'cascade'` makes
+ * the tree a tri-state checkbox tree: checking a parent checks every enabled
+ * descendant, and a partially-checked parent reports `aria-checked="mixed"`.
+ * `'independent'` disables propagation entirely — each node stands alone.
+ *
+ * Only meaningful while `multiple` is set; a single-select tree has one
+ * checked node by definition and never cascades.
+ */
+export type TreeSelectCheckStrategy = 'cascade' | 'independent';
+/**
+ * Which of the checked nodes are actually emitted in `value`.
+ *
+ * - `'all'` — every checked node, parents and descendants alike.
+ * - `'leaf'` — only checked leaves; branches are dropped.
+ * - `'shallowest'` — only the topmost fully-checked node of each branch,
+ *   collapsing a fully-checked subtree to the single node that implies it.
+ *
+ * Ignored (treated as `'all'`) under `check-strategy="independent"`, where no
+ * node implies any other and dropping one would silently lose a selection.
+ */
+export type TreeSelectValueStrategy = 'all' | 'leaf' | 'shallowest';
+/** Predicate deciding whether a node matches the current filter text. */
+export type TreeSelectFilter = (node: TreeSelectNode, inputValue: string) => boolean;
+/**
+ * Renders a node's content — the label, and anything beside it such as an
+ * `SkdxTreeItemIndicator` chevron or an `SkdxTreeSelectItemIndicator` checkmark.
+ * The returned nodes render *inside* the node's `treeitem`, so both indicators
+ * find their context there.
+ */
+export type TreeSelectRenderLabel = (node: TreeSelectNode) => VNodeChild;
+/** @internal Shared state distributed from `SkdxTreeSelect` to its parts via provide/inject. */
+export interface TreeSelectContext {
+    collection: Readonly<Ref<readonly TreeSelectNode[]>>;
+    index: Readonly<Ref<TreeSelectIndex>>;
+    /** Every node value in collection pre-order. */
+    order: Readonly<Ref<readonly string[]>>;
+    /** The emitted value: the checked set projected through `valueStrategy`. */
+    value: Readonly<Ref<readonly string[]>>;
+    multiple: boolean;
+    /** Whether checking actually propagates: `checkStrategy === 'cascade'` *and* `multiple`. */
+    cascade: Readonly<Ref<boolean>>;
+    disabled: boolean;
+    readOnly: boolean;
+    /** A node's tri-state value, derived from its enabled leaf descendants under `cascade`. */
+    checkStateOf(value: string): TreeCheckedState;
+    /** Toggles a node (respecting `checkStrategy`), emits the projected value, and closes when `closeOnSelect`. */
+    commit(value: string): void;
+    open: Readonly<Ref<boolean>>;
+    onOpenChange(open: boolean): void;
+    /** Effective expanded values — the caller's expansion plus, while filtering, the ancestors of every match. */
+    expandedIds: Readonly<Ref<string[]>>;
+    expanded: Readonly<Ref<ReadonlySet<string>>>;
+    setExpanded(value: string, expand: boolean): void;
+    /** Adapter turning the composed `SkdxTree`'s whole-array expansion event back into a single-node change. */
+    onTreeExpandedIdsChange(ids: string[]): void;
+    /** Values whose check state is fully `true`, handed to the composed `SkdxTree` as its `selected-ids`. */
+    selectedIds: Readonly<Ref<string[]>>;
+    /** Whether a node survives the current filter (always `true` when not filtering). */
+    isVisible(value: string): boolean;
+    /** Visible, expanded nodes in navigation order. */
+    flat: Readonly<Ref<readonly TreeSelectFlatNode[]>>;
+    flatMap: Readonly<Ref<ReadonlyMap<string, TreeSelectFlatNode>>>;
+    activeValue: Readonly<Ref<string | null>>;
+    setActiveValue(value: string | null): void;
+    /** DOM id of a node's `treeitem`, for `aria-activedescendant`. */
+    itemId(value: string): string;
+    treeId: string;
+    contentId: string;
+    triggerRef: Ref<HTMLElement | null>;
+    contentRef: Ref<HTMLElement | null>;
+    inputRef: Ref<HTMLInputElement | null>;
+    /** Whether an `SkdxTreeSelectInput` is mounted — it takes DOM focus, and with it `aria-activedescendant`, off the trigger. */
+    hasInput: Readonly<Ref<boolean>>;
+    setHasInput(hasInput: boolean): void;
+    inputValue: Readonly<Ref<string>>;
+    onInputValueChange(value: string): void;
+    /** A node's `label`, or its `value` when it has none. */
+    getLabel(value: string): string;
+    /** Moves DOM focus back to the trigger — what Escape and `closeOnSelect` both do. */
+    focusTrigger(): void;
+    /** The shared keydown handler both `SkdxTreeSelectTrigger` and `SkdxTreeSelectInput` delegate to. */
+    onNavigationKeyDown(event: KeyboardEvent, options: {
+        typeahead: boolean;
+        selectOnSpace: boolean;
+    }): void;
+}
+/** @internal Injection key the TreeSelect root provides so its Trigger, Content, Input, Tree and Items share every piece of state. */
+export declare const TREE_SELECT_CONTEXT: InjectionKey<TreeSelectContext>;
+/** @internal Per-node state distributed from `SkdxTreeSelectItem` to `SkdxTreeSelectItemIndicator`. */
+export interface TreeSelectItemContext {
+    value: string;
+    checkState: TreeCheckedState;
+    disabled: boolean;
+    expanded: boolean;
+    hasChildren: boolean;
+    /** Whether this node is the virtually-focused one named by `aria-activedescendant`. */
+    active: boolean;
+}
+/** @internal Injection key an SkdxTreeSelectItem provides so its ItemIndicator can read the node's check state. */
+export declare const TREE_SELECT_ITEM_CONTEXT: InjectionKey<TreeSelectItemContext>;
+/** @internal Generates the id prefix a TreeSelect keys its `treeitem` DOM ids off. */
+export declare function nextTreeSelectId(suffix: string): string;
+/**
+ * Default `filter`: case-insensitive substring match on the node's
+ * `label ?? value`.
+ *
+ * Lives here rather than in `TreeSelect.vue` because
+ * `withDefaults(defineProps())` is hoisted out of `setup()`, so it cannot
+ * reference a binding declared locally in the same `<script setup>` — only an
+ * imported one.
+ */
+export declare function defaultTreeSelectFilter(node: TreeSelectNode, inputValue: string): boolean;
+/** Default `getMatchCountLabel`: `"1 match available"` / `"3 matches available"`. */
+export declare function defaultGetMatchCountLabel(count: number): string;

package/dist/tree-select/context.js

@@ -0,0 +1 @@
+import{nextId as e}from"../utils/id.js";var t=/* @__PURE__ */Symbol("skdx-tree-select-context"),a=/* @__PURE__ */Symbol("skdx-tree-select-item-context");function r(t){return e(`tree-select-${t}`)}function l(e,t){return(e.label??e.value).toLowerCase().includes(t.trim().toLowerCase())}function s(e){return`${e} match${1===e?"":"es"} available`}export{t as TREE_SELECT_CONTEXT,a as TREE_SELECT_ITEM_CONTEXT,s as defaultGetMatchCountLabel,l as defaultTreeSelectFilter,r as nextTreeSelectId};

package/dist/tree-select/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./context.cjs"),r=require("./TreeSelect.vue.cjs"),t=require("./TreeSelectTrigger.vue.cjs"),l=require("./TreeSelectValue.vue.cjs"),u=require("./TreeSelectPortal.vue.cjs"),c=require("./TreeSelectContent.vue.cjs"),S=require("./TreeSelectItem.vue.cjs"),i=require("./TreeSelectTree.vue.cjs"),d=require("./TreeSelectItemIndicator.vue.cjs"),T=require("./TreeSelectEmpty.vue.cjs"),a=require("./TreeSelectInput.vue.cjs");exports.SkdxTreeSelect=r.default;exports.SkdxTreeSelectContent=c.default;exports.SkdxTreeSelectEmpty=T.default;exports.SkdxTreeSelectInput=a.default;exports.SkdxTreeSelectItem=S.default;exports.SkdxTreeSelectItemIndicator=d.default;exports.SkdxTreeSelectPortal=u.default;exports.SkdxTreeSelectTree=i.default;exports.SkdxTreeSelectTrigger=t.default;exports.SkdxTreeSelectValue=l.default;exports.defaultGetMatchCountLabel=e.defaultGetMatchCountLabel;exports.defaultTreeSelectFilter=e.defaultTreeSelectFilter;

package/dist/tree-select/index.d.cts

@@ -0,0 +1,12 @@
+export { default as SkdxTreeSelect } from './TreeSelect.vue.cjs';
+export { default as SkdxTreeSelectTrigger } from './TreeSelectTrigger.vue.cjs';
+export { default as SkdxTreeSelectValue } from './TreeSelectValue.vue.cjs';
+export { default as SkdxTreeSelectPortal } from './TreeSelectPortal.vue.cjs';
+export { default as SkdxTreeSelectContent } from './TreeSelectContent.vue.cjs';
+export { default as SkdxTreeSelectTree } from './TreeSelectTree.vue.cjs';
+export { default as SkdxTreeSelectItem } from './TreeSelectItem.vue.cjs';
+export { default as SkdxTreeSelectItemIndicator } from './TreeSelectItemIndicator.vue.cjs';
+export { default as SkdxTreeSelectEmpty } from './TreeSelectEmpty.vue.cjs';
+export { default as SkdxTreeSelectInput } from './TreeSelectInput.vue.cjs';
+export { defaultGetMatchCountLabel, defaultTreeSelectFilter } from './context.cjs';
+export type { TreeSelectCheckStrategy, TreeSelectFilter, TreeSelectNode, TreeSelectRenderLabel, TreeSelectValueStrategy, } from './context.cjs';

package/dist/tree-select/index.d.ts

@@ -0,0 +1,12 @@
+export { default as SkdxTreeSelect } from './TreeSelect.vue.js';
+export { default as SkdxTreeSelectTrigger } from './TreeSelectTrigger.vue.js';
+export { default as SkdxTreeSelectValue } from './TreeSelectValue.vue.js';
+export { default as SkdxTreeSelectPortal } from './TreeSelectPortal.vue.js';
+export { default as SkdxTreeSelectContent } from './TreeSelectContent.vue.js';
+export { default as SkdxTreeSelectTree } from './TreeSelectTree.vue.js';
+export { default as SkdxTreeSelectItem } from './TreeSelectItem.vue.js';
+export { default as SkdxTreeSelectItemIndicator } from './TreeSelectItemIndicator.vue.js';
+export { default as SkdxTreeSelectEmpty } from './TreeSelectEmpty.vue.js';
+export { default as SkdxTreeSelectInput } from './TreeSelectInput.vue.js';
+export { defaultGetMatchCountLabel, defaultTreeSelectFilter } from './context.js';
+export type { TreeSelectCheckStrategy, TreeSelectFilter, TreeSelectNode, TreeSelectRenderLabel, TreeSelectValueStrategy, } from './context.js';

package/dist/tree-select/index.js

@@ -0,0 +1 @@
+import{defaultGetMatchCountLabel as e,defaultTreeSelectFilter as t}from"./context.js";import r from"./TreeSelect.vue.js";import l from"./TreeSelectTrigger.vue.js";import o from"./TreeSelectValue.vue.js";import S from"./TreeSelectPortal.vue.js";import a from"./TreeSelectContent.vue.js";import m from"./TreeSelectItem.vue.js";import c from"./TreeSelectTree.vue.js";import T from"./TreeSelectItemIndicator.vue.js";import s from"./TreeSelectEmpty.vue.js";import u from"./TreeSelectInput.vue.js";export{r as SkdxTreeSelect,a as SkdxTreeSelectContent,s as SkdxTreeSelectEmpty,u as SkdxTreeSelectInput,m as SkdxTreeSelectItem,T as SkdxTreeSelectItemIndicator,S as SkdxTreeSelectPortal,c as SkdxTreeSelectTree,l as SkdxTreeSelectTrigger,o as SkdxTreeSelectValue,e as defaultGetMatchCountLabel,t as defaultTreeSelectFilter};

package/dist/tree-select/nodes.cjs

@@ -0,0 +1 @@
+const a=require("../tree/TreeGroup.vue.cjs"),d=require("./context.cjs"),c=require("./TreeSelectItem.vue.cjs");let r=require("vue");var o=(0,r.defineComponent)({name:"SkdxTreeSelectNodes",inheritAttrs:!1,props:{nodes:{type:Array,required:!0},renderLabel:{type:Function,default:void 0}},setup(t){const l=(0,r.inject)(d.TREE_SELECT_CONTEXT);if(!l)throw new Error("SkdxTreeSelectTree must be used within SkdxTreeSelect.");const u=n=>n.filter(e=>l.isVisible(e.value)).map(e=>{const i=(e.children??[]).filter(s=>l.isVisible(s.value));return(0,r.h)(c.default,{node:e,key:e.value},()=>[t.renderLabel?t.renderLabel(e):e.label??e.value,i.length>0?(0,r.h)(a.default,null,()=>u(i)):null])});return()=>u(t.nodes)}});exports.default=o;

package/dist/tree-select/nodes.d.cts

@@ -0,0 +1,38 @@
+import { type PropType, type VNodeChild } from 'vue';
+import { type TreeSelectNode, type TreeSelectRenderLabel } from './context.cjs';
+/**
+ * @internal Renders one `SkdxTreeSelectItem` per *visible* collection node,
+ * nesting each branch's children in an `SkdxTreeGroup` (which unmounts itself
+ * while the branch is collapsed).
+ *
+ * A render-function component rather than an SFC because the recursion is the
+ * whole of it, and a template would have to reach for self-reference by
+ * filename plus a wrapper component just to splice in `renderLabel`'s vnodes.
+ * Never exported: `SkdxTreeSelectTree` is the public way to render a tree.
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** The sibling nodes to render at this level, before filtering. */
+    nodes: {
+        type: PropType<readonly TreeSelectNode[]>;
+        required: true;
+    };
+    /** Renders a node's content; defaults to its `label ?? value` as plain text. */
+    renderLabel: {
+        type: PropType<TreeSelectRenderLabel>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** The sibling nodes to render at this level, before filtering. */
+    nodes: {
+        type: PropType<readonly TreeSelectNode[]>;
+        required: true;
+    };
+    /** Renders a node's content; defaults to its `label ?? value` as plain text. */
+    renderLabel: {
+        type: PropType<TreeSelectRenderLabel>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    renderLabel: TreeSelectRenderLabel;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/tree-select/nodes.d.ts

@@ -0,0 +1,38 @@
+import { type PropType, type VNodeChild } from 'vue';
+import { type TreeSelectNode, type TreeSelectRenderLabel } from './context.js';
+/**
+ * @internal Renders one `SkdxTreeSelectItem` per *visible* collection node,
+ * nesting each branch's children in an `SkdxTreeGroup` (which unmounts itself
+ * while the branch is collapsed).
+ *
+ * A render-function component rather than an SFC because the recursion is the
+ * whole of it, and a template would have to reach for self-reference by
+ * filename plus a wrapper component just to splice in `renderLabel`'s vnodes.
+ * Never exported: `SkdxTreeSelectTree` is the public way to render a tree.
+ */
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    /** The sibling nodes to render at this level, before filtering. */
+    nodes: {
+        type: PropType<readonly TreeSelectNode[]>;
+        required: true;
+    };
+    /** Renders a node's content; defaults to its `label ?? value` as plain text. */
+    renderLabel: {
+        type: PropType<TreeSelectRenderLabel>;
+        default: undefined;
+    };
+}>, () => VNodeChild, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /** The sibling nodes to render at this level, before filtering. */
+    nodes: {
+        type: PropType<readonly TreeSelectNode[]>;
+        required: true;
+    };
+    /** Renders a node's content; defaults to its `label ?? value` as plain text. */
+    renderLabel: {
+        type: PropType<TreeSelectRenderLabel>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    renderLabel: TreeSelectRenderLabel;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/tree-select/nodes.js

@@ -0,0 +1 @@
+import e from"../tree/TreeGroup.vue.js";import{TREE_SELECT_CONTEXT as r}from"./context.js";import t from"./TreeSelectItem.vue.js";import{defineComponent as n,h as l,inject as o}from"vue";var i=n({name:"SkdxTreeSelectNodes",inheritAttrs:!1,props:{nodes:{type:Array,required:!0},renderLabel:{type:Function,default:void 0}},setup(n){const i=o(r);if(!i)throw new Error("SkdxTreeSelectTree must be used within SkdxTreeSelect.");const s=r=>r.filter(e=>i.isVisible(e.value)).map(r=>{const o=(r.children??[]).filter(e=>i.isVisible(e.value));return l(t,{node:r,key:r.value},()=>[n.renderLabel?n.renderLabel(r):r.label??r.value,o.length>0?l(e,null,()=>s(o)):null])});return()=>s(n.nodes)}});export{i as default};

package/dist/types.test-d.d.cts

@@ -0,0 +1 @@
+export {};

package/dist/types.test-d.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/MenuSub.vue.cjs

@@ -0,0 +1 @@
+const e=require("./MenuSub.vue_vue_type_script_setup_true_lang.cjs");var u=e.default;exports.default=u;

package/dist/utils/MenuSub.vue.d.cts

@@ -0,0 +1,49 @@
+/**
+ * Root of a nested submenu inside a menu panel: owns the submenu's own open
+ * state and hover grace timer, and wraps its children in a nested popper root
+ * so the SubContent positions against the SubTrigger. Renders no DOM of its
+ * own. Exported per family as `SkdxDropdownMenuSub`, `SkdxContextMenuSub` and
+ * `SkdxMenubarSub`.
+ *
+ * Emits `open-change` the instant the state flips and `open-change-complete`
+ * once the change has finished on screen — after the SubContent's enter or
+ * exit animation ends, or in the same task when it declares none.
+ *
+ * Works controlled (`v-model:open`) or uncontrolled (`default-open`).
+ */
+type __VLS_Props = {
+    /**
+     * The re-exporting family, e.g. `'context-menu'`, which is what lets the
+     * shared SubTrigger and SubContent name their own classes. Supplied by
+     * each family's thin wrapper, never by a consumer.
+     * @internal
+     */
+    family: string;
+    /** Whether the submenu is open, for controlled usage. Pair with `v-model:open`. */
+    open?: boolean;
+    /** Whether the submenu is initially open, for uncontrolled usage. */
+    defaultOpen?: boolean;
+};
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (open: boolean) => any;
+    "open-change": (open: boolean) => any;
+    "open-change-complete": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    "onOpen-change"?: ((open: boolean) => any) | undefined;
+    "onOpen-change-complete"?: ((open: boolean) => any) | undefined;
+}>, {
+    open: boolean;
+    defaultOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/utils/MenuSub.vue.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Root of a nested submenu inside a menu panel: owns the submenu's own open
+ * state and hover grace timer, and wraps its children in a nested popper root
+ * so the SubContent positions against the SubTrigger. Renders no DOM of its
+ * own. Exported per family as `SkdxDropdownMenuSub`, `SkdxContextMenuSub` and
+ * `SkdxMenubarSub`.
+ *
+ * Emits `open-change` the instant the state flips and `open-change-complete`
+ * once the change has finished on screen — after the SubContent's enter or
+ * exit animation ends, or in the same task when it declares none.
+ *
+ * Works controlled (`v-model:open`) or uncontrolled (`default-open`).
+ */
+type __VLS_Props = {
+    /**
+     * The re-exporting family, e.g. `'context-menu'`, which is what lets the
+     * shared SubTrigger and SubContent name their own classes. Supplied by
+     * each family's thin wrapper, never by a consumer.
+     * @internal
+     */
+    family: string;
+    /** Whether the submenu is open, for controlled usage. Pair with `v-model:open`. */
+    open?: boolean;
+    /** Whether the submenu is initially open, for uncontrolled usage. */
+    defaultOpen?: boolean;
+};
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:open": (open: boolean) => any;
+    "open-change": (open: boolean) => any;
+    "open-change-complete": (open: boolean) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    "onOpen-change"?: ((open: boolean) => any) | undefined;
+    "onOpen-change-complete"?: ((open: boolean) => any) | undefined;
+}>, {
+    open: boolean;
+    defaultOpen: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/utils/MenuSub.vue.js

@@ -0,0 +1 @@
+import e from"./MenuSub.vue_vue_type_script_setup_true_lang.js";var t=e;export{t as default};

package/dist/utils/MenuSub.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const m=require("./useOpenChangeComplete.cjs"),_=require("./PopperRoot.vue.cjs"),s=require("./menuSub.cjs");let e=require("vue");var g=(0,e.defineComponent)({__name:"MenuSub",props:{family:{},open:{type:Boolean,default:void 0},defaultOpen:{type:Boolean,default:!1}},emits:["update:open","open-change","open-change-complete"],setup(i,{emit:f}){const o=i,u=f,d=(0,e.ref)(null),r=(0,e.ref)(null),a=(0,e.ref)(o.defaultOpen),c=(0,e.computed)(()=>o.open??a.value);m.useOpenChangeComplete(c,r,n=>u("open-change-complete",n));let l;function p(n){o.open===void 0&&(a.value=n),u("update:open",n),u("open-change",n)}function t(){clearTimeout(l),l=void 0}return(0,e.provide)(s.MENU_SUB_CONTEXT,{family:o.family,open:c,triggerRef:d,contentRef:r,contentId:s.nextMenuSubContentId(),openNow(){t(),p(!0)},closeNow(){t(),p(!1)},scheduleClose(){t(),l=setTimeout(()=>p(!1),150)}}),(0,e.onBeforeUnmount)(t),(n,v)=>((0,e.openBlock)(),(0,e.createBlock)(_.default,null,{default:(0,e.withCtx)(()=>[(0,e.renderSlot)(n.$slots,"default")]),_:3}))}});exports.default=g;

package/dist/utils/MenuSub.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{useOpenChangeComplete as e}from"./useOpenChangeComplete.js";import o from"./PopperRoot.vue.js";import{MENU_SUB_CONTEXT as n,nextMenuSubContentId as t}from"./menuSub.js";import{computed as a,createBlock as p,defineComponent as l,onBeforeUnmount as u,openBlock as s,provide as m,ref as r,renderSlot as f,withCtx as i}from"vue";var d=/* @__PURE__ */l({__name:"MenuSub",props:{family:{},open:{type:Boolean,default:void 0},defaultOpen:{type:Boolean,default:!1}},emits:["update:open","open-change","open-change-complete"],setup(l,{emit:d}){const c=l,v=d,C=r(null),g=r(null),h=r(c.defaultOpen),B=a(()=>c.open??h.value);let y;function O(e){void 0===c.open&&(h.value=e),v("update:open",e),v("open-change",e)}function S(){clearTimeout(y),y=void 0}return e(B,g,e=>v("open-change-complete",e)),m(n,{family:c.family,open:B,triggerRef:C,contentRef:g,contentId:t(),openNow(){S(),O(!0)},closeNow(){S(),O(!1)},scheduleClose(){S(),y=setTimeout(()=>O(!1),150)}}),u(S),(e,n)=>(s(),p(o,null,{default:i(()=>[f(e.$slots,"default")]),_:3}))}});export{d as default};

package/dist/utils/MenuSubContent.vue.cjs

@@ -0,0 +1 @@
+const e=require("./MenuSubContent.vue_vue_type_script_setup_true_lang.cjs");var u=e.default;exports.default=u;

package/dist/utils/MenuSubContent.vue.d.cts

@@ -0,0 +1,62 @@
+import { type Align, type PhysicalSide, type Side } from './popper.cjs';
+/**
+ * The submenu's floating panel: `role="menu"` with
+ * `aria-orientation="vertical"` and `data-state` (`open`/`closed`),
+ * positioned by the shared popper layer against its SubTrigger (`side`
+ * defaults to the logical `'end'` — right under LTR, left under RTL — `align`
+ * to `'start'`, `sideOffset` to `0`) and exposing the resolved
+ * `data-side`/`data-align`.
+ *
+ * Owns its own vertical roving focus and typeahead over its items. ArrowLeft
+ * and Escape close only this submenu and return focus to the SubTrigger,
+ * leaving the parent menu open; under `dir="rtl"` the closing arrow is
+ * ArrowRight. Mounts only while open unless `forceMount` is set. Renders
+ * inline inside the parent menu rather than in a portal — see `menuSub.ts`.
+ * Must be used inside a `Sub` root.
+ */
+type __VLS_Props = {
+    /** Preferred side of the trigger to render the panel on. */
+    side?: Side;
+    /** Alignment of the panel relative to the trigger along the chosen side. */
+    align?: Align;
+    /** Distance (px) between the panel and the trigger. */
+    sideOffset?: number;
+    /** Offset (px) along the alignment axis. */
+    alignOffset?: number;
+    /** Whether to flip/shift the panel to stay within the viewport. */
+    avoidCollisions?: boolean;
+    /** Minimum distance (px) kept from the collision boundary. A number applies to every side; an object sets only the sides it names. */
+    collisionPadding?: number | Partial<Record<PhysicalSide, number>>;
+    /**
+     * Element (or elements) collisions are measured against, instead of the
+     * panel's clipping ancestors. Use it to keep the panel inside a scroll
+     * container or one pane of a split layout rather than the whole viewport.
+     * @default undefined — the panel's clipping ancestors.
+     */
+    collisionBoundary?: Element | Element[] | null;
+    /** Keep this panel mounted even while the submenu is closed, instead of unmounting it. */
+    forceMount?: boolean;
+    /** Whether Up/Down arrow-key navigation wraps from the last item back to the first. */
+    loop?: boolean;
+};
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    forceMount: boolean;
+    side: Side;
+    loop: boolean;
+    align: Align;
+    sideOffset: number;
+    alignOffset: number;
+    avoidCollisions: boolean;
+    collisionPadding: number | Partial<Record<PhysicalSide, number>>;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};