@skdx/vue 0.26.0

package/dist/tree/TreeItem.vue.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A single node in the tree: renders a `<div role="treeitem">` with
+ * `aria-level` (its depth), `aria-posinset`/`aria-setsize` (its place among
+ * the siblings at its own level), `aria-selected` (unless the tree's
+ * selectionMode is "none"), `aria-expanded` (only if it has a nested
+ * `SkdxTreeGroup`), `data-state` of `"expanded"`/`"collapsed"`, and
+ * `data-disabled`. Detects whether it has children by checking its default
+ * slot for an `SkdxTreeGroup`. Clicking it selects the node and, if it has
+ * children, toggles expansion; focusing it makes it the tree's active
+ * (tabbable) node. Must be used inside `SkdxTree`.
+ *
+ * While the tree's `load-children` is pending for this node it carries
+ * `aria-busy="true"` and `data-loading`. Under
+ * `selection-propagation="descendants"` it also carries `aria-checked`
+ * (`true`/`false`/`"mixed"`) and `data-checked`
+ * (`checked`/`unchecked`/`indeterminate`) derived from its descendants.
+ */
+type __VLS_Props = {
+    /** Unique identifier tracked in the tree's expanded/selected/active state. */
+    nodeId: string;
+    /** Excludes this node (and its subtree) from selection and keyboard activation. */
+    disabled?: 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<{}>, {
+    disabled: 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/tree/TreeItem.vue.js

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

package/dist/tree/TreeItem.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const l=require("./context.cjs"),T=require("./TreeGroup.vue.cjs");let e=require("vue");var b=["aria-level","aria-posinset","aria-setsize","aria-selected","aria-expanded","aria-checked","aria-busy","aria-disabled","data-state","data-checked","data-loading","data-disabled","data-skdx-tree-node-id","data-skdx-tree-parent-id","tabindex"],x=(0,e.defineComponent)({__name:"TreeItem",props:{nodeId:{},disabled:{type:Boolean,default:!1}},setup(n){const d=n,a=(0,e.inject)(l.TREE_CONTEXT);if(!a)throw new Error("SkdxTreeItem must be used within SkdxTree.");const o=(0,e.inject)(l.TREE_AMBIENT_CONTEXT,l.TREE_AMBIENT_DEFAULT),p=(0,e.useSlots)(),i=(0,e.computed)(()=>(p.default?.()??[]).some(t=>t.type===T.default)),r=(0,e.computed)(()=>a.expandedIds.value.has(d.nodeId)),c=(0,e.computed)(()=>a.selectedIds.value.has(d.nodeId)),u=(0,e.computed)(()=>a.loadingIds.value.has(d.nodeId)),I=(0,e.computed)(()=>d.disabled?-1:a.activeNodeId.value===d.nodeId?0:-1);(0,e.onMounted)(()=>a.registerNode(d.nodeId,o.parentId)),(0,e.onUnmounted)(()=>a.unregisterNode(d.nodeId));const v=(0,e.computed)(()=>a.positionOf(d.nodeId)),s=(0,e.computed)(()=>a.selectionPropagation==="descendants"?a.checkedState(d.nodeId):void 0),h=(0,e.computed)(()=>s.value),m=(0,e.computed)(()=>s.value===void 0?void 0:s.value==="mixed"?"indeterminate":s.value?"checked":"unchecked");function k(t){d.disabled||t.target.closest('[role="treeitem"]')!==t.currentTarget||(a.onSelectedChange(d.nodeId),i.value&&a.onExpandedChange(d.nodeId,!r.value))}function g(){d.disabled||a.setActiveNodeId(d.nodeId)}return(0,e.provide)(l.TREE_ITEM_CONTEXT,{get nodeId(){return d.nodeId},get depth(){return o.depth},get expanded(){return r.value},get selected(){return c.value},get disabled(){return d.disabled},get hasChildren(){return i.value},get loading(){return u.value}}),(t,f)=>((0,e.openBlock)(),(0,e.createElementBlock)("div",{class:"skdx-tree__item","data-part":"item",role:"treeitem","aria-level":(0,e.unref)(o).depth,"aria-posinset":v.value?.posinset,"aria-setsize":v.value?.setsize,"aria-selected":(0,e.unref)(a).selectionMode==="none"?void 0:c.value,"aria-expanded":i.value?r.value:void 0,"aria-checked":h.value,"aria-busy":u.value||void 0,"aria-disabled":n.disabled||void 0,"data-state":i.value?r.value?"expanded":"collapsed":void 0,"data-checked":m.value,"data-loading":u.value?"":void 0,"data-disabled":n.disabled?"":void 0,"data-skdx-tree-node-id":n.nodeId,"data-skdx-tree-parent-id":(0,e.unref)(o).parentId??void 0,tabindex:I.value,onClick:k,onFocus:g},[(0,e.renderSlot)(t.$slots,"default")],40,b))}});exports.default=x;

package/dist/tree/TreeItem.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{TREE_AMBIENT_CONTEXT as e,TREE_AMBIENT_DEFAULT as a,TREE_CONTEXT as d,TREE_ITEM_CONTEXT as t}from"./context.js";import o from"./TreeGroup.vue.js";import{computed as n,createElementBlock as s,defineComponent as i,inject as r,onMounted as l,onUnmounted as u,openBlock as v,provide as c,renderSlot as p,unref as I,useSlots as m}from"vue";var h=["aria-level","aria-posinset","aria-setsize","aria-selected","aria-expanded","aria-checked","aria-busy","aria-disabled","data-state","data-checked","data-loading","data-disabled","data-skdx-tree-node-id","data-skdx-tree-parent-id","tabindex"],T=/* @__PURE__ */i({__name:"TreeItem",props:{nodeId:{},disabled:{type:Boolean,default:!1}},setup(i){const T=i,g=r(d);if(!g)throw new Error("SkdxTreeItem must be used within SkdxTree.");const x=r(e,a),E=m(),b=n(()=>(E.default?.()??[]).some(e=>e.type===o)),k=n(()=>g.expandedIds.value.has(T.nodeId)),f=n(()=>g.selectedIds.value.has(T.nodeId)),_=n(()=>g.loadingIds.value.has(T.nodeId)),N=n(()=>T.disabled?-1:g.activeNodeId.value===T.nodeId?0:-1);l(()=>g.registerNode(T.nodeId,x.parentId)),u(()=>g.unregisterNode(T.nodeId));const C=n(()=>g.positionOf(T.nodeId)),S=n(()=>"descendants"===g.selectionPropagation?g.checkedState(T.nodeId):void 0),B=n(()=>S.value),M=n(()=>void 0===S.value?void 0:"mixed"===S.value?"indeterminate":S.value?"checked":"unchecked");function y(e){T.disabled||e.target.closest('[role="treeitem"]')!==e.currentTarget||(g.onSelectedChange(T.nodeId),b.value&&g.onExpandedChange(T.nodeId,!k.value))}function A(){T.disabled||g.setActiveNodeId(T.nodeId)}return c(t,{get nodeId(){return T.nodeId},get depth(){return x.depth},get expanded(){return k.value},get selected(){return f.value},get disabled(){return T.disabled},get hasChildren(){return b.value},get loading(){return _.value}}),(e,a)=>(v(),s("div",{class:"skdx-tree__item","data-part":"item",role:"treeitem","aria-level":I(x).depth,"aria-posinset":C.value?.posinset,"aria-setsize":C.value?.setsize,"aria-selected":"none"===I(g).selectionMode?void 0:f.value,"aria-expanded":b.value?k.value:void 0,"aria-checked":B.value,"aria-busy":_.value||void 0,"aria-disabled":i.disabled||void 0,"data-state":b.value?k.value?"expanded":"collapsed":void 0,"data-checked":M.value,"data-loading":_.value?"":void 0,"data-disabled":i.disabled?"":void 0,"data-skdx-tree-node-id":i.nodeId,"data-skdx-tree-parent-id":I(x).parentId??void 0,tabindex:N.value,onClick:y,onFocus:A},[p(e.$slots,"default")],40,h))}});export{T as default};

package/dist/tree/TreeItemIndicator.vue.cjs

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

package/dist/tree/TreeItemIndicator.vue.d.cts

@@ -0,0 +1,21 @@
+/**
+ * Expand/collapse affordance (e.g. a chevron) within a `SkdxTreeItem`:
+ * renders a `<span aria-hidden="true">` with `data-state` of
+ * `"expanded"`/`"collapsed"` (unset if the item has no children). Clicking
+ * it toggles expansion and stops propagation, so the enclosing
+ * `SkdxTreeItem`'s own click handler doesn't double-toggle it. Must be used
+ * inside an `SkdxTreeItem`.
+ */
+type __VLS_Props = {};
+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<{}>, {}, {}, {}, {}, 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/tree/TreeItemIndicator.vue.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Expand/collapse affordance (e.g. a chevron) within a `SkdxTreeItem`:
+ * renders a `<span aria-hidden="true">` with `data-state` of
+ * `"expanded"`/`"collapsed"` (unset if the item has no children). Clicking
+ * it toggles expansion and stops propagation, so the enclosing
+ * `SkdxTreeItem`'s own click handler doesn't double-toggle it. Must be used
+ * inside an `SkdxTreeItem`.
+ */
+type __VLS_Props = {};
+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<{}>, {}, {}, {}, {}, 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/tree/TreeItemIndicator.vue.js

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

package/dist/tree/TreeItemIndicator.vue_vue_type_script_setup_true_lang.cjs

@@ -0,0 +1 @@
+const a=require("./context.cjs");let e=require("vue");var i=["data-state"],o=(0,e.defineComponent)({__name:"TreeItemIndicator",setup(s){const n=(0,e.inject)(a.TREE_CONTEXT);if(!n)throw new Error("SkdxTreeItemIndicator must be used within SkdxTree.");const t=(0,e.inject)(a.TREE_ITEM_CONTEXT);if(!t)throw new Error("SkdxTreeItemIndicator must be used within SkdxTreeItem.");function d(r){r.stopPropagation(),t.hasChildren&&n.onExpandedChange(t.nodeId,!t.expanded)}return(r,c)=>((0,e.openBlock)(),(0,e.createElementBlock)("span",{class:"skdx-tree__item-indicator","data-part":"item-indicator","aria-hidden":"true","data-state":(0,e.unref)(t).hasChildren?(0,e.unref)(t).expanded?"expanded":"collapsed":void 0,onClick:d},[(0,e.renderSlot)(r.$slots,"default")],8,i))}});exports.default=o;

package/dist/tree/TreeItemIndicator.vue_vue_type_script_setup_true_lang.js

@@ -0,0 +1 @@
+import{TREE_CONTEXT as e,TREE_ITEM_CONTEXT as t}from"./context.js";import{createElementBlock as a,defineComponent as n,inject as r,openBlock as d,renderSlot as o,unref as s}from"vue";var i=["data-state"],c=/* @__PURE__ */n({__name:"TreeItemIndicator",setup(n){const c=r(e);if(!c)throw new Error("SkdxTreeItemIndicator must be used within SkdxTree.");const m=r(t);if(!m)throw new Error("SkdxTreeItemIndicator must be used within SkdxTreeItem.");function p(e){e.stopPropagation(),m.hasChildren&&c.onExpandedChange(m.nodeId,!m.expanded)}return(e,t)=>(d(),a("span",{class:"skdx-tree__item-indicator","data-part":"item-indicator","aria-hidden":"true","data-state":s(m).hasChildren?s(m).expanded?"expanded":"collapsed":void 0,onClick:p},[o(e.$slots,"default")],8,i))}});export{c as default};

package/dist/tree/context.cjs

@@ -0,0 +1 @@
+var T=Symbol("skdx-tree-context"),e=Symbol("skdx-tree-item-context"),t=Symbol("skdx-tree-ambient-context"),_={depth:1,parentId:null};function a(E){return`${E} loaded`}exports.TREE_AMBIENT_CONTEXT=t;exports.TREE_AMBIENT_DEFAULT=_;exports.TREE_CONTEXT=T;exports.TREE_ITEM_CONTEXT=e;exports.defaultGetLoadedLabel=a;

package/dist/tree/context.d.cts

@@ -0,0 +1,126 @@
+import type { InjectionKey, Ref } from 'vue';
+/**
+ * How many nodes a Tree lets the user select at once. `'single'` is
+ * the default and keeps `selectedIds` at no more than one entry — selecting a
+ * node replaces the previous one. `'multiple'` allows any number, puts
+ * `aria-multiselectable` on the tree, and is the only mode where Shift+Arrow
+ * range extension and `selectionPropagation="descendants"` do anything.
+ * `'none'` makes the tree expand/collapse-only: `onSelectedChange` returns
+ * without touching state and items drop `aria-selected` altogether rather than
+ * reporting a permanent `false`.
+ *
+ * @internal
+ */
+export type TreeSelectionMode = 'single' | 'multiple' | 'none';
+/**
+ * Whether selecting a node also selects its subtree. `'descendants'` turns the
+ * tree into a tri-state checkbox tree: toggling a node applies to every one of
+ * its descendants, and a parent reports `aria-checked` of `true`, `false`, or
+ * `"mixed"` derived from them.
+ */
+export type TreeSelectionPropagation = 'none' | 'descendants';
+/** A node's tri-state checkbox value, as reported on `aria-checked`. */
+export type TreeCheckedState = boolean | 'mixed';
+/**
+ * A node's place among its siblings — the ones at its own level under its own
+ * parent, not a flat index over the tree — as reported on `aria-posinset`
+ * (1-based) and `aria-setsize`.
+ */
+export interface TreeNodePosition {
+    posinset: number;
+    setsize: number;
+}
+/**
+ * Injection key a Tree provides so its items can read/drive shared expanded/selected/active state.
+ *
+ * @internal
+ */
+export interface TreeContext {
+    selectionMode: TreeSelectionMode;
+    selectionPropagation: TreeSelectionPropagation;
+    expandedIds: Readonly<Ref<Set<string>>>;
+    selectedIds: Readonly<Ref<Set<string>>>;
+    /** Node ids whose `loadChildren` call is still pending. */
+    loadingIds: Readonly<Ref<Set<string>>>;
+    activeNodeId: Readonly<Ref<string | null>>;
+    setActiveNodeId(id: string): void;
+    onExpandedChange(nodeId: string, expand: boolean): void;
+    onSelectedChange(nodeId: string): void;
+    /**
+     * Tri-state value for a node: derived from its registered descendants when it
+     * has any, otherwise its own membership in `selectedIds`. Always `false` for
+     * every node unless `selectionPropagation` is `'descendants'`.
+     */
+    checkedState(nodeId: string): TreeCheckedState;
+    /**
+     * A node's `aria-posinset`/`aria-setsize`, measured off the rendered DOM in
+     * document order. `undefined` until the first measurement lands (the flush
+     * after mount) or for a node that isn't rendered.
+     */
+    positionOf(nodeId: string): TreeNodePosition | undefined;
+    /** Called by each TreeItem on mount so the root can walk the node hierarchy without touching the DOM. */
+    registerNode(nodeId: string, parentId: string | null): void;
+    unregisterNode(nodeId: string): void;
+}
+/**
+ * Injection key a Tree provides so its items share expanded/selected/active state.
+ *
+ * @internal
+ */
+export declare const TREE_CONTEXT: InjectionKey<TreeContext>;
+/**
+ * Injection key a TreeItem provides so its TreeGroup/TreeItemIndicator descendants can read its state.
+ *
+ * @internal
+ */
+export interface TreeItemContext {
+    nodeId: string;
+    depth: number;
+    expanded: boolean;
+    selected: boolean;
+    disabled: boolean;
+    hasChildren: boolean;
+    /** Whether this node's `loadChildren` call is still pending. */
+    loading: boolean;
+}
+/**
+ * Injection key a TreeItem provides so its TreeGroup/TreeItemIndicator descendants read its node state.
+ *
+ * @internal
+ */
+export declare const TREE_ITEM_CONTEXT: InjectionKey<TreeItemContext>;
+/**
+ * Ambient depth/parent-id passed down to the next level of
+ * TreeItems, with a default for items with no enclosing TreeGroup (the
+ * root level) — unlike TREE_CONTEXT/TREE_ITEM_CONTEXT, `inject()` for this
+ * key never throws.
+ *
+ * @internal
+ */
+export interface TreeAmbient {
+    depth: number;
+    parentId: string | null;
+}
+/**
+ * Injection key carrying the depth and parent-id handed down to the next level of TreeItems.
+ *
+ * @internal
+ */
+export declare const TREE_AMBIENT_CONTEXT: InjectionKey<TreeAmbient>;
+/**
+ * Ambient default (depth 1, no parent) for root-level TreeItems with no enclosing TreeGroup.
+ *
+ * @internal
+ */
+export declare const TREE_AMBIENT_DEFAULT: TreeAmbient;
+/**
+ * Default `getLoadedLabel`, announced when a node's lazy children
+ * finish loading.
+ *
+ * Lives here rather than in `Tree.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.
+ *
+ * @internal
+ */
+export declare function defaultGetLoadedLabel(nodeId: string): string;

package/dist/tree/context.d.ts

@@ -0,0 +1,126 @@
+import type { InjectionKey, Ref } from 'vue';
+/**
+ * How many nodes a Tree lets the user select at once. `'single'` is
+ * the default and keeps `selectedIds` at no more than one entry — selecting a
+ * node replaces the previous one. `'multiple'` allows any number, puts
+ * `aria-multiselectable` on the tree, and is the only mode where Shift+Arrow
+ * range extension and `selectionPropagation="descendants"` do anything.
+ * `'none'` makes the tree expand/collapse-only: `onSelectedChange` returns
+ * without touching state and items drop `aria-selected` altogether rather than
+ * reporting a permanent `false`.
+ *
+ * @internal
+ */
+export type TreeSelectionMode = 'single' | 'multiple' | 'none';
+/**
+ * Whether selecting a node also selects its subtree. `'descendants'` turns the
+ * tree into a tri-state checkbox tree: toggling a node applies to every one of
+ * its descendants, and a parent reports `aria-checked` of `true`, `false`, or
+ * `"mixed"` derived from them.
+ */
+export type TreeSelectionPropagation = 'none' | 'descendants';
+/** A node's tri-state checkbox value, as reported on `aria-checked`. */
+export type TreeCheckedState = boolean | 'mixed';
+/**
+ * A node's place among its siblings — the ones at its own level under its own
+ * parent, not a flat index over the tree — as reported on `aria-posinset`
+ * (1-based) and `aria-setsize`.
+ */
+export interface TreeNodePosition {
+    posinset: number;
+    setsize: number;
+}
+/**
+ * Injection key a Tree provides so its items can read/drive shared expanded/selected/active state.
+ *
+ * @internal
+ */
+export interface TreeContext {
+    selectionMode: TreeSelectionMode;
+    selectionPropagation: TreeSelectionPropagation;
+    expandedIds: Readonly<Ref<Set<string>>>;
+    selectedIds: Readonly<Ref<Set<string>>>;
+    /** Node ids whose `loadChildren` call is still pending. */
+    loadingIds: Readonly<Ref<Set<string>>>;
+    activeNodeId: Readonly<Ref<string | null>>;
+    setActiveNodeId(id: string): void;
+    onExpandedChange(nodeId: string, expand: boolean): void;
+    onSelectedChange(nodeId: string): void;
+    /**
+     * Tri-state value for a node: derived from its registered descendants when it
+     * has any, otherwise its own membership in `selectedIds`. Always `false` for
+     * every node unless `selectionPropagation` is `'descendants'`.
+     */
+    checkedState(nodeId: string): TreeCheckedState;
+    /**
+     * A node's `aria-posinset`/`aria-setsize`, measured off the rendered DOM in
+     * document order. `undefined` until the first measurement lands (the flush
+     * after mount) or for a node that isn't rendered.
+     */
+    positionOf(nodeId: string): TreeNodePosition | undefined;
+    /** Called by each TreeItem on mount so the root can walk the node hierarchy without touching the DOM. */
+    registerNode(nodeId: string, parentId: string | null): void;
+    unregisterNode(nodeId: string): void;
+}
+/**
+ * Injection key a Tree provides so its items share expanded/selected/active state.
+ *
+ * @internal
+ */
+export declare const TREE_CONTEXT: InjectionKey<TreeContext>;
+/**
+ * Injection key a TreeItem provides so its TreeGroup/TreeItemIndicator descendants can read its state.
+ *
+ * @internal
+ */
+export interface TreeItemContext {
+    nodeId: string;
+    depth: number;
+    expanded: boolean;
+    selected: boolean;
+    disabled: boolean;
+    hasChildren: boolean;
+    /** Whether this node's `loadChildren` call is still pending. */
+    loading: boolean;
+}
+/**
+ * Injection key a TreeItem provides so its TreeGroup/TreeItemIndicator descendants read its node state.
+ *
+ * @internal
+ */
+export declare const TREE_ITEM_CONTEXT: InjectionKey<TreeItemContext>;
+/**
+ * Ambient depth/parent-id passed down to the next level of
+ * TreeItems, with a default for items with no enclosing TreeGroup (the
+ * root level) — unlike TREE_CONTEXT/TREE_ITEM_CONTEXT, `inject()` for this
+ * key never throws.
+ *
+ * @internal
+ */
+export interface TreeAmbient {
+    depth: number;
+    parentId: string | null;
+}
+/**
+ * Injection key carrying the depth and parent-id handed down to the next level of TreeItems.
+ *
+ * @internal
+ */
+export declare const TREE_AMBIENT_CONTEXT: InjectionKey<TreeAmbient>;
+/**
+ * Ambient default (depth 1, no parent) for root-level TreeItems with no enclosing TreeGroup.
+ *
+ * @internal
+ */
+export declare const TREE_AMBIENT_DEFAULT: TreeAmbient;
+/**
+ * Default `getLoadedLabel`, announced when a node's lazy children
+ * finish loading.
+ *
+ * Lives here rather than in `Tree.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.
+ *
+ * @internal
+ */
+export declare function defaultGetLoadedLabel(nodeId: string): string;

package/dist/tree/context.js

@@ -0,0 +1 @@
+var e=/* @__PURE__ */Symbol("skdx-tree-context"),t=/* @__PURE__ */Symbol("skdx-tree-item-context"),E=/* @__PURE__ */Symbol("skdx-tree-ambient-context"),T={depth:1,parentId:null};function a(e){return`${e} loaded`}export{E as TREE_AMBIENT_CONTEXT,T as TREE_AMBIENT_DEFAULT,e as TREE_CONTEXT,t as TREE_ITEM_CONTEXT,a as defaultGetLoadedLabel};

package/dist/tree/index.cjs

@@ -0,0 +1 @@
+Object.defineProperty(exports,Symbol.toStringTag,{value:"Module"});const e=require("./Tree.vue.cjs"),r=require("./TreeGroup.vue.cjs"),t=require("./TreeItem.vue.cjs"),u=require("./TreeItemIndicator.vue.cjs");exports.SkdxTree=e.default;exports.SkdxTreeGroup=r.default;exports.SkdxTreeItem=t.default;exports.SkdxTreeItemIndicator=u.default;

package/dist/tree/index.d.cts

@@ -0,0 +1,5 @@
+export { default as SkdxTree } from './Tree.vue.cjs';
+export { default as SkdxTreeItem } from './TreeItem.vue.cjs';
+export { default as SkdxTreeGroup } from './TreeGroup.vue.cjs';
+export { default as SkdxTreeItemIndicator } from './TreeItemIndicator.vue.cjs';
+export type { TreeSelectionPropagation, TreeCheckedState } from './context.cjs';

package/dist/tree/index.d.ts

@@ -0,0 +1,5 @@
+export { default as SkdxTree } from './Tree.vue.js';
+export { default as SkdxTreeItem } from './TreeItem.vue.js';
+export { default as SkdxTreeGroup } from './TreeGroup.vue.js';
+export { default as SkdxTreeItemIndicator } from './TreeItemIndicator.vue.js';
+export type { TreeSelectionPropagation, TreeCheckedState } from './context.js';

package/dist/tree/index.js

@@ -0,0 +1 @@
+import e from"./Tree.vue.js";import r from"./TreeGroup.vue.js";import o from"./TreeItem.vue.js";import m from"./TreeItemIndicator.vue.js";export{e as SkdxTree,r as SkdxTreeGroup,o as SkdxTreeItem,m as SkdxTreeItemIndicator};

package/dist/tree-select/TreeSelect.vue.cjs

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

package/dist/tree-select/TreeSelect.vue.d.cts

@@ -0,0 +1,149 @@
+import { type TreeSelectCheckStrategy, type TreeSelectFilter, type TreeSelectNode, type TreeSelectValueStrategy } from './context.cjs';
+/**
+ * Root of a tree select: a `role="combobox"` trigger whose popup is a
+ * WAI-ARIA `treeview`, for picking from hierarchical data. Owns the checked
+ * set, expansion, filter text, open state and virtual focus, and hands all of
+ * them to every other `SkdxTreeSelect*` part via provide/inject. Renders no DOM
+ * of its own.
+ *
+ * Real DOM focus never enters the tree: it stays on the trigger, or on
+ * `SkdxTreeSelectInput` when one is mounted, and the focused node is tracked as
+ * virtual focus through `aria-activedescendant`. The popup composes the `Tree`
+ * family for its `role="tree"` markup, but drives navigation itself for
+ * exactly that reason.
+ *
+ * The data is a `collection` of plain nodes rather than children, because the
+ * three things this component exists to do — cascade a check through a
+ * subtree, project the checked set through `valueStrategy`, and keep the
+ * ancestors of a filter match visible — all have to be correct for branches
+ * that are collapsed, and a collapsed branch is not in the DOM.
+ *
+ * Emits `open-change` the instant the state flips and `open-change-complete`
+ * once the change has finished on screen — after `SkdxTreeSelectContent`'s enter
+ * or exit animation ends, or in the same task when it declares none.
+ *
+ * Works controlled (`v-model:value`, `v-model:expanded-value`, `v-model:open`,
+ * `v-model:input-value`) or uncontrolled (`default-value`,
+ * `default-expanded-value`, `default-open`, `default-input-value`).
+ */
+type __VLS_Props = {
+    /**
+     * The hierarchical data the popup's tree is built from. Node `value`s must
+     * be unique across the whole collection — every event, `value` entry and
+     * DOM id is keyed by them.
+     */
+    collection: readonly TreeSelectNode[];
+    /**
+     * Checked node values, for controlled usage — always an array, whether or
+     * not `multiple`, and always in the shape `valueStrategy` describes. Pair
+     * with `v-model:value` or `@value-change`.
+     */
+    value?: string[];
+    /** Initially checked node values, for uncontrolled usage. Same shape as `value`. */
+    defaultValue?: string[];
+    /**
+     * Allows more than one node to be checked: the tree gets
+     * `aria-multiselectable`, activating a node toggles it rather than
+     * replacing the selection, and `checkStrategy` starts to mean something.
+     */
+    multiple?: boolean;
+    /** Whether checking a node propagates through its subtree. Ignored unless `multiple`. */
+    checkStrategy?: TreeSelectCheckStrategy;
+    /** Which checked nodes appear in the emitted `value`. Ignored under `check-strategy="independent"`. */
+    valueStrategy?: TreeSelectValueStrategy;
+    /**
+     * Expanded node values, for controlled usage. Pair with
+     * `v-model:expanded-value` or `@expanded-change`. While filtering, the
+     * ancestors of every match are expanded *on top of* this value without
+     * being written back to it.
+     */
+    expandedValue?: string[];
+    /** Initially expanded node values, for uncontrolled usage. Every branch starts collapsed. */
+    defaultExpandedValue?: string[];
+    /** Whether the popup is open, for controlled usage. Pair with `v-model:open` or `@open-change`. */
+    open?: boolean;
+    /** Initial open state, for uncontrolled usage. */
+    defaultOpen?: boolean;
+    /** The `SkdxTreeSelectInput`'s filter text, for controlled usage. Pair with `v-model:input-value`. */
+    inputValue?: string;
+    /** Initial filter text, for uncontrolled usage — unfiltered. */
+    defaultInputValue?: string;
+    /**
+     * Decides whether a node matches the filter text. A match keeps its whole
+     * ancestor chain visible (a matched leaf under a hidden parent would be
+     * unreachable) and its whole subtree visible.
+     */
+    filter?: TreeSelectFilter;
+    /**
+     * Blocks the whole control: the trigger is a disabled `<button>`, the popup
+     * cannot open, and no key changes anything.
+     */
+    disabled?: boolean;
+    /**
+     * Lets the user open, navigate and read the tree but never change the
+     * value — unlike `disabled`, which also removes it from the tab order.
+     */
+    readOnly?: boolean;
+    /**
+     * Closes the popup as soon as a node is checked, returning focus to the
+     * trigger.
+     * @default !multiple — a single-select answer is complete on the first pick; a multi-select one is not.
+     */
+    closeOnSelect?: boolean;
+    /**
+     * Formats the message announced (through the shared live announcer) each
+     * time the number of filter matches changes while the popup is open —
+     * filtering is silent for screen-reader users otherwise. Return an empty
+     * string to announce nothing.
+     */
+    getMatchCountLabel?: (count: number) => string;
+};
+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;
+    "update:value": (value: string[]) => any;
+    "value-change": (value: string[]) => any;
+    "open-change-complete": (open: boolean) => any;
+    "update:inputValue": (inputValue: string) => any;
+    "input-value-change": (inputValue: string) => any;
+    "update:expandedValue": (expandedValue: string[]) => any;
+    "expanded-change": (expandedValue: string[]) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:open"?: ((open: boolean) => any) | undefined;
+    "onOpen-change"?: ((open: boolean) => any) | undefined;
+    "onUpdate:value"?: ((value: string[]) => any) | undefined;
+    "onValue-change"?: ((value: string[]) => any) | undefined;
+    "onOpen-change-complete"?: ((open: boolean) => any) | undefined;
+    "onUpdate:inputValue"?: ((inputValue: string) => any) | undefined;
+    "onInput-value-change"?: ((inputValue: string) => any) | undefined;
+    "onUpdate:expandedValue"?: ((expandedValue: string[]) => any) | undefined;
+    "onExpanded-change"?: ((expandedValue: string[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    filter: TreeSelectFilter;
+    open: boolean;
+    defaultOpen: boolean;
+    value: string[];
+    defaultValue: string[];
+    multiple: boolean;
+    readOnly: boolean;
+    inputValue: string;
+    defaultInputValue: string;
+    closeOnSelect: boolean;
+    checkStrategy: TreeSelectCheckStrategy;
+    valueStrategy: TreeSelectValueStrategy;
+    expandedValue: string[];
+    defaultExpandedValue: string[];
+    getMatchCountLabel: (count: number) => string;
+}, {}, {}, {}, 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;
+    };
+};