@skdx/vue 0.27.0 → 0.28.0

package/dist/tree-select/collection.cjs

@@ -1 +1 @@
-function w(n){const s=new Map,r=[],o=(t,e,l,a)=>{for(const c of t){const f=a||c.disabled===!0,i=c.children??[],h={node:c,parent:e,depth:l,childValues:i.map(u=>u.value),descendants:[],leaves:[],disabled:f};if(s.set(c.value,h),r.push(c.value),o(i,c.value,l+1,f),i.length===0)f||h.leaves.push(c.value);else for(const u of i){const d=s.get(u.value);d&&(h.descendants.push(u.value,...d.descendants),h.leaves.push(...d.leaves))}}};return o(n,null,1,!1),{index:s,order:r}}function g(n,s){const r=[];let o=s.get(n)?.parent??null;for(;o!==null;)r.push(o),o=s.get(o)?.parent??null;return r}function v(n,s,r,o){if(!o)return s.has(n);const t=r.get(n);if(!t||t.leaves.length===0)return s.has(n);let e=0;for(const l of t.leaves)s.has(l)&&e++;return e===0?!1:e===t.leaves.length?!0:"mixed"}function y(n,s,r,o){const t=new Set;for(const e of n)s.has(e)&&t.add(e);if(!o)return t;for(const e of[...t]){const l=s.get(e);if(l)for(const a of l.descendants)s.get(a)?.disabled||t.add(a)}for(const e of r){const l=s.get(e);l&&(l.leaves.length===0||l.childValues.length===0||(l.leaves.every(a=>t.has(a))?t.add(e):t.delete(e)))}return t}function b(n,s,r,o){const t=r.filter(e=>n.has(e));return o==="all"?t:o==="leaf"?t.filter(e=>s.get(e)?.childValues.length===0):t.filter(e=>{const l=s.get(e)?.parent??null;return l===null||!n.has(l)})}function C(n,s,r,o,t){if(!t)return new Set([n]);const e=new Set(s),l=r.get(n);if(!o||!l)return e.has(n)?e.delete(n):e.add(n),e;const a=v(n,s,r,!0)!==!0;for(const c of[n,...l.descendants])r.get(c)?.disabled||(a?e.add(c):e.delete(c));for(const c of g(n,r)){const f=r.get(c);f&&(f.leaves.length>0&&f.leaves.every(i=>e.has(i))?e.add(c):e.delete(c))}return e}function V(n,s,r){const o=new Set,t=new Set;let e=0;for(const l of s){const a=n.get(l);if(a&&r(a.node)){e++,o.add(l);for(const c of g(l,n))o.add(c),t.add(c);for(const c of a.descendants)o.add(c)}}return{visible:o,autoExpanded:t,matchCount:e}}function m(n,s,r,o){const t=[],e=a=>r===null||r.has(a.value),l=(a,c)=>{const f=a.filter(e);f.forEach((i,h)=>{const u=s.get(i.value);if(!u)return;const d=(i.children??[]).filter(e),p=o.has(i.value);t.push({value:i.value,parent:c,depth:u.depth,disabled:u.disabled,hasChildren:d.length>0,expanded:p,posinset:h+1,setsize:f.length}),d.length>0&&p&&l(d,i.value)})};return l(n,null),t}exports.ancestorsOf=g;exports.checkStateOf=v;exports.computeFilter=V;exports.flattenVisible=m;exports.indexCollection=w;exports.normalizeChecked=y;exports.projectValue=b;exports.toggleChecked=C;
+function b(e){const t=new Map,r=[],s=(l,n,o,c)=>{for(const a of l){const f=c||a.disabled===!0,i=a.children??[],h={node:a,parent:n,depth:o,childValues:i.map(u=>u.value),descendants:[],leaves:[],disabled:f};if(t.set(a.value,h),r.push(a.value),s(i,a.value,o+1,f),i.length===0)f||h.leaves.push(a.value);else for(const u of i){const d=t.get(u.value);d&&(h.descendants.push(u.value,...d.descendants),h.leaves.push(...d.leaves))}}};return s(e,null,1,!1),{index:t,order:r}}function p(e,t){const r=[];let s=t.get(e)?.parent??null;for(;s!==null;)r.push(s),s=t.get(s)?.parent??null;return r}function g(e){return e==="cascade"||e==="descendants"}function v(e){return e==="cascade"||e==="ancestors"}function C(e,t){return t==="leaf"?v(e)?"leaf":"all":t==="shallowest"?g(e)?"shallowest":"all":t}function V(e,t,r,s){if(s==="independent")return t.has(e);const l=r.get(e);if(!l||l.leaves.length===0)return t.has(e);let n=0;for(const o of l.leaves)t.has(o)&&n++;return n===l.leaves.length||t.has(e)?!0:n===0?!1:"mixed"}function S(e,t,r,s){const l=new Set;for(const n of e)t.has(n)&&l.add(n);if(s==="independent")return l;if(g(s))for(const n of[...l]){const o=t.get(n);if(o)for(const c of o.descendants)t.get(c)?.disabled||l.add(c)}if(v(s))for(const n of r){const o=t.get(n);o&&(o.leaves.length===0||o.childValues.length===0||(o.leaves.every(c=>l.has(c))?l.add(n):s==="cascade"&&l.delete(n)))}return l}function m(e,t,r,s){const l=r.filter(n=>e.has(n));return s==="all"?l:s==="leaf"?l.filter(n=>t.get(n)?.childValues.length===0):l.filter(n=>{const o=t.get(n)?.parent??null;return o===null||!e.has(o)})}function E(e,t,r,s,l){if(!l)return t.size===1&&t.has(e)?new Set:new Set([e]);const n=new Set(t),o=r.get(e);if(s==="independent"||!o)return n.has(e)?n.delete(e):n.add(e),n;const c=V(e,t,r,s)!==!0;for(const a of g(s)?[e,...o.descendants]:[e])r.get(a)?.disabled||(c?n.add(a):n.delete(a));if(v(s))for(const a of p(e,r)){const f=r.get(a);f&&(f.leaves.length>0&&f.leaves.every(i=>n.has(i))?n.add(a):n.delete(a))}return n}function O(e,t,r){const s=new Set,l=new Set;let n=0;for(const o of t){const c=e.get(o);if(c&&r(c.node)){n++,s.add(o);for(const a of p(o,e))s.add(a),l.add(a);for(const a of c.descendants)s.add(a)}}return{visible:s,autoExpanded:l,matchCount:n}}function z(e,t,r,s){const l=[],n=c=>r===null||r.has(c.value),o=(c,a)=>{const f=c.filter(n);f.forEach((i,h)=>{const u=t.get(i.value);if(!u)return;const d=(i.children??[]).filter(n),w=s.has(i.value);l.push({value:i.value,parent:a,depth:u.depth,disabled:u.disabled,hasChildren:d.length>0||i.hasChildren===!0,expanded:w,posinset:h+1,setsize:f.length}),d.length>0&&w&&o(d,i.value)})};return o(e,null),l}exports.ancestorsOf=p;exports.checkStateOf=V;exports.computeFilter=O;exports.effectiveValueStrategy=C;exports.flattenVisible=z;exports.indexCollection=b;exports.normalizeChecked=S;exports.projectValue=m;exports.toggleChecked=E;

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

@@ -1,14 +1,9 @@
 import type { TreeCheckedState } from '../tree/context.cjs';
-import type { TreeSelectNode, TreeSelectValueStrategy } from './context.cjs';
+import type { TreeSelectCheckStrategy, TreeSelectNode, TreeSelectValueStrategy } from './context.cjs';
 /**
- * The whole of `tree-select`'s hard part lives in this module, as plain
- * functions over plain data: cascading check state, the `valueStrategy`
- * projection, and the filter's ancestor-preservation rule. None of it touches
- * Vue or the DOM — which is deliberate, because all three answers must be
- * correct for *collapsed* branches, and a collapsed branch has no DOM at all.
- * (The `tree` family derives its own tri-state from rendered descendants and
- * therefore cannot see them.) Mirrors
- * `packages/react/src/tree-select/collection.ts` line for line.
+ * Tree-select core logic: cascading check state, valueStrategy projection,
+ * and filter ancestor-preservation as plain functions so they work for
+ * collapsed (non-DOM) branches. Matches React version.
  */
 /** @internal Everything derived once per collection about a single node. */
 export interface TreeSelectIndexEntry {
@@ -22,10 +17,8 @@ export interface TreeSelectIndexEntry {
     /** Every descendant's value, in pre-order. */
     descendants: string[];
     /**
-     * The *enabled* leaf descendants this node's tri-state is derived from — or
-     * `[node.value]` when it is itself an enabled leaf, and `[]` when it (or its
-     * whole subtree) is disabled. Excluding disabled leaves is what stops a
-     * branch containing one from being permanently stuck at `"mixed"`.
+     * Enabled leaf descendants for tri-state derivation (or `[node.value]` if
+     * this is an enabled leaf, `[]` if disabled). Excludes disabled leaves.
      */
     leaves: string[];
     /** Own `disabled`, or any ancestor's — disabling a branch disables its subtree. */
@@ -39,7 +32,10 @@ export interface TreeSelectFlatNode {
     parent: string | null;
     depth: number;
     disabled: boolean;
-    /** Whether it has at least one *visible* child, which is what decides `aria-expanded`. */
+    /**
+     * Has ≥1 visible child or declares itself as branch via `hasChildren`
+     * (lazy-loading)—drives `aria-expanded`.
+     */
     hasChildren: boolean;
     expanded: boolean;
     /** 1-based position among its visible siblings — `aria-posinset`. */
@@ -55,29 +51,31 @@ export declare function indexCollection(collection: readonly TreeSelectNode[]):
 /** @internal A node's ancestors, nearest first. */
 export declare function ancestorsOf(value: string, index: TreeSelectIndex): string[];
 /**
- * @internal A node's tri-state value. Without cascading it is plain
- * membership; with it, a branch is `true` only when every enabled leaf below
- * it is checked and `"mixed"` when only some are.
+ * @internal Value strategy that round-trips under `strategy`. `'leaf'` needs
+ * upward propagation, `'shallowest'` needs downward; otherwise silently loses
+ * selections, so fallback to `'all'`.
+ */
+export declare function effectiveValueStrategy(strategy: TreeSelectCheckStrategy, valueStrategy: TreeSelectValueStrategy): TreeSelectValueStrategy;
+/**
+ * @internal Node tri-state: under `'independent'` plain membership; otherwise
+ * `true` when all enabled leaves are checked or was checked directly,
+ * `'mixed'` when some are.
  */
-export declare function checkStateOf(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, cascade: boolean): TreeCheckedState;
+export declare function checkStateOf(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, strategy: TreeSelectCheckStrategy): TreeCheckedState;
 /**
- * @internal Expands an emitted `value` back into the full checked set the
- * component reasons about. This is the inverse of {@link projectValue}, and
- * the pair has to round-trip: `'shallowest'` emits a parent standing in for
- * its subtree, `'leaf'` emits leaves standing in for their parent, and both
- * must come back as the same set.
+ * @internal Inverse of projectValue: expands emitted values back into full
+ * checked set. Must round-trip: `'shallowest'` parent for subtree, `'leaf'`
+ * leaves for parent, both return same set.
  */
-export declare function normalizeChecked(values: readonly string[], index: TreeSelectIndex, order: readonly string[], cascade: boolean): Set<string>;
+export declare function normalizeChecked(values: readonly string[], index: TreeSelectIndex, order: readonly string[], strategy: TreeSelectCheckStrategy): Set<string>;
 /** @internal Reduces the full checked set to the values a consumer actually receives. */
 export declare function projectValue(checked: ReadonlySet<string>, index: TreeSelectIndex, order: readonly string[], strategy: TreeSelectValueStrategy): string[];
 /** @internal The checked set after activating one node. */
-export declare function toggleChecked(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, cascade: boolean, multiple: boolean): Set<string>;
+export declare function toggleChecked(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, strategy: TreeSelectCheckStrategy, multiple: boolean): Set<string>;
 /**
- * @internal Which nodes survive the filter, and which branches have to open to
- * reveal them. A match drags its whole ancestor chain into visibility — a
- * matched leaf whose parent is hidden is unreachable, which is the classic
- * filtered-tree bug — and its whole subtree, so a matched branch can still be
- * explored.
+ * @internal Nodes surviving filter and branches that auto-open. Matches drag
+ * ancestor chain into visibility (fixes classic filtered-tree bug) and whole
+ * subtree (lets branch exploration continue).
  */
 export declare function computeFilter(index: TreeSelectIndex, order: readonly string[], matches: (node: TreeSelectNode) => boolean): {
     visible: Set<string>;

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

@@ -1,14 +1,9 @@
 import type { TreeCheckedState } from '../tree/context.js';
-import type { TreeSelectNode, TreeSelectValueStrategy } from './context.js';
+import type { TreeSelectCheckStrategy, TreeSelectNode, TreeSelectValueStrategy } from './context.js';
 /**
- * The whole of `tree-select`'s hard part lives in this module, as plain
- * functions over plain data: cascading check state, the `valueStrategy`
- * projection, and the filter's ancestor-preservation rule. None of it touches
- * Vue or the DOM — which is deliberate, because all three answers must be
- * correct for *collapsed* branches, and a collapsed branch has no DOM at all.
- * (The `tree` family derives its own tri-state from rendered descendants and
- * therefore cannot see them.) Mirrors
- * `packages/react/src/tree-select/collection.ts` line for line.
+ * Tree-select core logic: cascading check state, valueStrategy projection,
+ * and filter ancestor-preservation as plain functions so they work for
+ * collapsed (non-DOM) branches. Matches React version.
  */
 /** @internal Everything derived once per collection about a single node. */
 export interface TreeSelectIndexEntry {
@@ -22,10 +17,8 @@ export interface TreeSelectIndexEntry {
     /** Every descendant's value, in pre-order. */
     descendants: string[];
     /**
-     * The *enabled* leaf descendants this node's tri-state is derived from — or
-     * `[node.value]` when it is itself an enabled leaf, and `[]` when it (or its
-     * whole subtree) is disabled. Excluding disabled leaves is what stops a
-     * branch containing one from being permanently stuck at `"mixed"`.
+     * Enabled leaf descendants for tri-state derivation (or `[node.value]` if
+     * this is an enabled leaf, `[]` if disabled). Excludes disabled leaves.
      */
     leaves: string[];
     /** Own `disabled`, or any ancestor's — disabling a branch disables its subtree. */
@@ -39,7 +32,10 @@ export interface TreeSelectFlatNode {
     parent: string | null;
     depth: number;
     disabled: boolean;
-    /** Whether it has at least one *visible* child, which is what decides `aria-expanded`. */
+    /**
+     * Has ≥1 visible child or declares itself as branch via `hasChildren`
+     * (lazy-loading)—drives `aria-expanded`.
+     */
     hasChildren: boolean;
     expanded: boolean;
     /** 1-based position among its visible siblings — `aria-posinset`. */
@@ -55,29 +51,31 @@ export declare function indexCollection(collection: readonly TreeSelectNode[]):
 /** @internal A node's ancestors, nearest first. */
 export declare function ancestorsOf(value: string, index: TreeSelectIndex): string[];
 /**
- * @internal A node's tri-state value. Without cascading it is plain
- * membership; with it, a branch is `true` only when every enabled leaf below
- * it is checked and `"mixed"` when only some are.
+ * @internal Value strategy that round-trips under `strategy`. `'leaf'` needs
+ * upward propagation, `'shallowest'` needs downward; otherwise silently loses
+ * selections, so fallback to `'all'`.
+ */
+export declare function effectiveValueStrategy(strategy: TreeSelectCheckStrategy, valueStrategy: TreeSelectValueStrategy): TreeSelectValueStrategy;
+/**
+ * @internal Node tri-state: under `'independent'` plain membership; otherwise
+ * `true` when all enabled leaves are checked or was checked directly,
+ * `'mixed'` when some are.
  */
-export declare function checkStateOf(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, cascade: boolean): TreeCheckedState;
+export declare function checkStateOf(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, strategy: TreeSelectCheckStrategy): TreeCheckedState;
 /**
- * @internal Expands an emitted `value` back into the full checked set the
- * component reasons about. This is the inverse of {@link projectValue}, and
- * the pair has to round-trip: `'shallowest'` emits a parent standing in for
- * its subtree, `'leaf'` emits leaves standing in for their parent, and both
- * must come back as the same set.
+ * @internal Inverse of projectValue: expands emitted values back into full
+ * checked set. Must round-trip: `'shallowest'` parent for subtree, `'leaf'`
+ * leaves for parent, both return same set.
  */
-export declare function normalizeChecked(values: readonly string[], index: TreeSelectIndex, order: readonly string[], cascade: boolean): Set<string>;
+export declare function normalizeChecked(values: readonly string[], index: TreeSelectIndex, order: readonly string[], strategy: TreeSelectCheckStrategy): Set<string>;
 /** @internal Reduces the full checked set to the values a consumer actually receives. */
 export declare function projectValue(checked: ReadonlySet<string>, index: TreeSelectIndex, order: readonly string[], strategy: TreeSelectValueStrategy): string[];
 /** @internal The checked set after activating one node. */
-export declare function toggleChecked(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, cascade: boolean, multiple: boolean): Set<string>;
+export declare function toggleChecked(value: string, checked: ReadonlySet<string>, index: TreeSelectIndex, strategy: TreeSelectCheckStrategy, multiple: boolean): Set<string>;
 /**
- * @internal Which nodes survive the filter, and which branches have to open to
- * reveal them. A match drags its whole ancestor chain into visibility — a
- * matched leaf whose parent is hidden is unreachable, which is the classic
- * filtered-tree bug — and its whole subtree, so a matched branch can still be
- * explored.
+ * @internal Nodes surviving filter and branches that auto-open. Matches drag
+ * ancestor chain into visibility (fixes classic filtered-tree bug) and whole
+ * subtree (lets branch exploration continue).
  */
 export declare function computeFilter(index: TreeSelectIndex, order: readonly string[], matches: (node: TreeSelectNode) => boolean): {
     visible: Set<string>;

package/dist/tree-select/collection.js

@@ -1 +1 @@
-function e(e){const t=/* @__PURE__ */new Map,n=[],s=(e,l,a,o)=>{for(const d of e){const e=o||!0===d.disabled,r=d.children??[],c={node:d,parent:l,depth:a,childValues:r.map(e=>e.value),descendants:[],leaves:[],disabled:e};if(t.set(d.value,c),n.push(d.value),s(r,d.value,a+1,e),0===r.length)e||c.leaves.push(d.value);else for(const e of r){const n=t.get(e.value);n&&(c.descendants.push(e.value,...n.descendants),c.leaves.push(...n.leaves))}}};return s(e,null,1,!1),{index:t,order:n}}function t(e,t){const n=[];let s=t.get(e)?.parent??null;for(;null!==s;)n.push(s),s=t.get(s)?.parent??null;return n}function n(e,t,n,s){if(!s)return t.has(e);const l=n.get(e);if(!l||0===l.leaves.length)return t.has(e);let a=0;for(const e of l.leaves)t.has(e)&&a++;return 0!==a&&(a===l.leaves.length||"mixed")}function s(e,t,n,s){const l=/* @__PURE__ */new Set;for(const n of e)t.has(n)&&l.add(n);if(!s)return l;for(const e of[...l]){const n=t.get(e);if(n)for(const e of n.descendants)t.get(e)?.disabled||l.add(e)}for(const e of n){const n=t.get(e);n&&(0===n.leaves.length||0===n.childValues.length||(n.leaves.every(e=>l.has(e))?l.add(e):l.delete(e)))}return l}function l(e,t,n,s){const l=n.filter(t=>e.has(t));return"all"===s?l:"leaf"===s?l.filter(e=>0===t.get(e)?.childValues.length):l.filter(n=>{const s=t.get(n)?.parent??null;return null===s||!e.has(s)})}function a(e,s,l,a,o){if(!o)/* @__PURE__ */return new Set([e]);const d=new Set(s),r=l.get(e);if(!a||!r)return d.has(e)?d.delete(e):d.add(e),d;const c=!0!==n(e,s,l,!0);for(const t of[e,...r.descendants])l.get(t)?.disabled||(c?d.add(t):d.delete(t));for(const n of t(e,l)){const e=l.get(n);e&&(e.leaves.length>0&&e.leaves.every(e=>d.has(e))?d.add(n):d.delete(n))}return d}function o(e,n,s){const l=/* @__PURE__ */new Set,a=/* @__PURE__ */new Set;let o=0;for(const d of n){const n=e.get(d);if(n&&s(n.node)){o++,l.add(d);for(const n of t(d,e))l.add(n),a.add(n);for(const e of n.descendants)l.add(e)}}return{visible:l,autoExpanded:a,matchCount:o}}function d(e,t,n,s){const l=[],a=e=>null===n||n.has(e.value),o=(e,n)=>{const d=e.filter(a);d.forEach((e,r)=>{const c=t.get(e.value);if(!c)return;const u=(e.children??[]).filter(a),f=s.has(e.value);l.push({value:e.value,parent:n,depth:c.depth,disabled:c.disabled,hasChildren:u.length>0,expanded:f,posinset:r+1,setsize:d.length}),u.length>0&&f&&o(u,e.value)})};return o(e,null),l}export{t as ancestorsOf,n as checkStateOf,o as computeFilter,d as flattenVisible,e as indexCollection,s as normalizeChecked,l as projectValue,a as toggleChecked};
+function e(e){const t=/* @__PURE__ */new Map,n=[],s=(e,a,l,o)=>{for(const d of e){const e=o||!0===d.disabled,r=d.children??[],c={node:d,parent:a,depth:l,childValues:r.map(e=>e.value),descendants:[],leaves:[],disabled:e};if(t.set(d.value,c),n.push(d.value),s(r,d.value,l+1,e),0===r.length)e||c.leaves.push(d.value);else for(const e of r){const n=t.get(e.value);n&&(c.descendants.push(e.value,...n.descendants),c.leaves.push(...n.leaves))}}};return s(e,null,1,!1),{index:t,order:n}}function t(e,t){const n=[];let s=t.get(e)?.parent??null;for(;null!==s;)n.push(s),s=t.get(s)?.parent??null;return n}function n(e){return"cascade"===e||"descendants"===e}function s(e){return"cascade"===e||"ancestors"===e}function a(e,t){return"leaf"===t?s(e)?"leaf":"all":"shallowest"===t?n(e)?"shallowest":"all":t}function l(e,t,n,s){if("independent"===s)return t.has(e);const a=n.get(e);if(!a||0===a.leaves.length)return t.has(e);let l=0;for(const e of a.leaves)t.has(e)&&l++;return!(l!==a.leaves.length&&!t.has(e))||0!==l&&"mixed"}function o(e,t,a,l){const o=/* @__PURE__ */new Set;for(const n of e)t.has(n)&&o.add(n);if("independent"===l)return o;if(n(l))for(const e of[...o]){const n=t.get(e);if(n)for(const e of n.descendants)t.get(e)?.disabled||o.add(e)}if(s(l))for(const e of a){const n=t.get(e);n&&(0===n.leaves.length||0===n.childValues.length||(n.leaves.every(e=>o.has(e))?o.add(e):"cascade"===l&&o.delete(e)))}return o}function d(e,t,n,s){const a=n.filter(t=>e.has(t));return"all"===s?a:"leaf"===s?a.filter(e=>0===t.get(e)?.childValues.length):a.filter(n=>{const s=t.get(n)?.parent??null;return null===s||!e.has(s)})}function r(e,a,o,d,r){if(!r)return 1===a.size&&a.has(e)?/* @__PURE__ */new Set:/* @__PURE__ */new Set([e]);const c=new Set(a),u=o.get(e);if("independent"===d||!u)return c.has(e)?c.delete(e):c.add(e),c;const f=!0!==l(e,a,o,d);for(const t of n(d)?[e,...u.descendants]:[e])o.get(t)?.disabled||(f?c.add(t):c.delete(t));if(s(d))for(const n of t(e,o)){const e=o.get(n);e&&(e.leaves.length>0&&e.leaves.every(e=>c.has(e))?c.add(n):c.delete(n))}return c}function c(e,n,s){const a=/* @__PURE__ */new Set,l=/* @__PURE__ */new Set;let o=0;for(const d of n){const n=e.get(d);if(n&&s(n.node)){o++,a.add(d);for(const n of t(d,e))a.add(n),l.add(n);for(const e of n.descendants)a.add(e)}}return{visible:a,autoExpanded:l,matchCount:o}}function u(e,t,n,s){const a=[],l=e=>null===n||n.has(e.value),o=(e,n)=>{const d=e.filter(l);d.forEach((e,r)=>{const c=t.get(e.value);if(!c)return;const u=(e.children??[]).filter(l),f=s.has(e.value);a.push({value:e.value,parent:n,depth:c.depth,disabled:c.disabled,hasChildren:u.length>0||!0===e.hasChildren,expanded:f,posinset:r+1,setsize:d.length}),u.length>0&&f&&o(u,e.value)})};return o(e,null),a}export{t as ancestorsOf,l as checkStateOf,c as computeFilter,a as effectiveValueStrategy,u as flattenVisible,e as indexCollection,o as normalizeChecked,d as projectValue,r as toggleChecked};

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

@@ -2,63 +2,50 @@ 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.
+ * Node data (not elements), so cascading/filtering see collapsed branches.
  */
 export interface TreeSelectNode {
-    /** Unique identifier across the whole collection — what lands in `value`, and what every callback names. */
+    /** Unique identifier across the collection; what lands in `value`. */
     value: string;
     /**
-     * Human-readable text: rendered as the node's content, matched by `filter`, and shown by `SkdxTreeSelectValue`.
-     * @default undefined — falls back to `value`.
+     * Node label (display, filter). @default undefined → 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
+     * Excludes node/subtree from checking, cascade, navigation. @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.
+     * Child nodes (none = leaf). @default undefined
      */
     children?: TreeSelectNode[];
+    /**
+     * Branch with unloaded children (lazy-loading). @default undefined
+     */
+    hasChildren?: boolean;
 }
 /**
- * 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.
+ * How checking a node propagates through the hierarchy. Only meaningful while `multiple` is set.
  *
- * Only meaningful while `multiple` is set; a single-select tree has one
- * checked node by definition and never cascades.
+ * - `'cascade'` — both directions; a partly-checked parent reports `aria-checked="mixed"`.
+ * - `'descendants'` — downwards only: checking a parent checks its subtree.
+ * - `'ancestors'` — upwards only: checking every leaf under a branch checks the branch.
+ * - `'independent'` — no propagation; each node stands alone.
  */
-export type TreeSelectCheckStrategy = 'cascade' | 'independent';
+export type TreeSelectCheckStrategy = 'cascade' | 'descendants' | 'ancestors' | '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.
+ * - `'shallowest'` — only the topmost fully-checked node of each branch.
  *
- * Ignored (treated as `'all'`) under `check-strategy="independent"`, where no
- * node implies any other and dropping one would silently lose a selection.
+ * Falls back to `'all'` wherever `check-strategy="independent"` would otherwise silently drop 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.
- */
+/** Renders a node's content, including its indicator chevron/checkmark, inside its `treeitem`. */
 export type TreeSelectRenderLabel = (node: TreeSelectNode) => VNodeChild;
 /** @internal Shared state distributed from `SkdxTreeSelect` to its parts via provide/inject. */
 export interface TreeSelectContext {
@@ -66,80 +53,81 @@ export interface TreeSelectContext {
     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`. */
+    /** Emitted value (checked set projected). */
     value: Readonly<Ref<readonly string[]>>;
     multiple: boolean;
-    /** Whether checking actually propagates: `checkStrategy === 'cascade'` *and* `multiple`. */
+    /** Checking propagates (not independent and multiple). */
     cascade: Readonly<Ref<boolean>>;
     disabled: boolean;
     readOnly: boolean;
-    /** A node's tri-state value, derived from its enabled leaf descendants under `cascade`. */
+    /** Node tri-state (derived from enabled leaf descendants). */
     checkStateOf(value: string): TreeCheckedState;
-    /** Toggles a node (respecting `checkStrategy`), emits the projected value, and closes when `closeOnSelect`. */
+    /** Toggle node, emit projected value, close on select. */
     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. */
+    /** Caller's expansion + ancestors of filtered matches. */
     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. */
+    loadingValues: Readonly<Ref<ReadonlySet<string>>>;
+    /** Adapt Tree's whole-array expansion to 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). */
+    readonly expandOnClick: boolean;
     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`. */
+    /** Node's treeitem DOM id (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. */
+    /** Input mounted (aria-activedescendant on input, not 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. */
+    /** Keydown handler (shared by Trigger and Input). */
     onNavigationKeyDown(event: KeyboardEvent, options: {
         typeahead: boolean;
         selectOnSpace: boolean;
     }): void;
+    /**
+     * Node values `SkdxTreeSelectTree` actually renders when its `rows` prop
+     * windows below `flat`; `null` when unrestricted. Navigation and the
+     * initial active node draw from this so `aria-activedescendant` never
+     * names a node with no rendered `treeitem`.
+     */
+    visibleRowValues: Readonly<Ref<ReadonlySet<string> | null>>;
+    /** Reported by `SkdxTreeSelectTree` whenever its `rows` prop changes. */
+    setVisibleRowValues(values: ReadonlySet<string> | null): void;
 }
-/** @internal Injection key the TreeSelect root provides so its Trigger, Content, Input, Tree and Items share every piece of state. */
+/** @internal Injection key sharing state from the TreeSelect root to its parts. */
 export declare const TREE_SELECT_CONTEXT: InjectionKey<TreeSelectContext>;
-/** @internal Per-node state distributed from `SkdxTreeSelectItem` to `SkdxTreeSelectItemIndicator`. */
+/** @internal Per-node state to ItemIndicator. */
 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`. */
+    /** Virtually-focused node (aria-activedescendant). */
     active: boolean;
 }
-/** @internal Injection key an SkdxTreeSelectItem provides so its ItemIndicator can read the node's check state. */
+/** @internal Injection key an SkdxTreeSelectItem provides so its ItemIndicator can read 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.
+ * Default `filter`: case-insensitive substring match on `label ?? value`.
+ * Lives here, not in `TreeSelect.vue`, because `withDefaults(defineProps())`
+ * is hoisted out of `setup()` and can only reference an imported binding.
  */
 export declare function defaultTreeSelectFilter(node: TreeSelectNode, inputValue: string): boolean;
 /** Default `getMatchCountLabel`: `"1 match available"` / `"3 matches available"`. */

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

@@ -2,63 +2,50 @@ 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.
+ * Node data (not elements), so cascading/filtering see collapsed branches.
  */
 export interface TreeSelectNode {
-    /** Unique identifier across the whole collection — what lands in `value`, and what every callback names. */
+    /** Unique identifier across the collection; what lands in `value`. */
     value: string;
     /**
-     * Human-readable text: rendered as the node's content, matched by `filter`, and shown by `SkdxTreeSelectValue`.
-     * @default undefined — falls back to `value`.
+     * Node label (display, filter). @default undefined → 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
+     * Excludes node/subtree from checking, cascade, navigation. @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.
+     * Child nodes (none = leaf). @default undefined
      */
     children?: TreeSelectNode[];
+    /**
+     * Branch with unloaded children (lazy-loading). @default undefined
+     */
+    hasChildren?: boolean;
 }
 /**
- * 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.
+ * How checking a node propagates through the hierarchy. Only meaningful while `multiple` is set.
  *
- * Only meaningful while `multiple` is set; a single-select tree has one
- * checked node by definition and never cascades.
+ * - `'cascade'` — both directions; a partly-checked parent reports `aria-checked="mixed"`.
+ * - `'descendants'` — downwards only: checking a parent checks its subtree.
+ * - `'ancestors'` — upwards only: checking every leaf under a branch checks the branch.
+ * - `'independent'` — no propagation; each node stands alone.
  */
-export type TreeSelectCheckStrategy = 'cascade' | 'independent';
+export type TreeSelectCheckStrategy = 'cascade' | 'descendants' | 'ancestors' | '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.
+ * - `'shallowest'` — only the topmost fully-checked node of each branch.
  *
- * Ignored (treated as `'all'`) under `check-strategy="independent"`, where no
- * node implies any other and dropping one would silently lose a selection.
+ * Falls back to `'all'` wherever `check-strategy="independent"` would otherwise silently drop 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.
- */
+/** Renders a node's content, including its indicator chevron/checkmark, inside its `treeitem`. */
 export type TreeSelectRenderLabel = (node: TreeSelectNode) => VNodeChild;
 /** @internal Shared state distributed from `SkdxTreeSelect` to its parts via provide/inject. */
 export interface TreeSelectContext {
@@ -66,80 +53,81 @@ export interface TreeSelectContext {
     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`. */
+    /** Emitted value (checked set projected). */
     value: Readonly<Ref<readonly string[]>>;
     multiple: boolean;
-    /** Whether checking actually propagates: `checkStrategy === 'cascade'` *and* `multiple`. */
+    /** Checking propagates (not independent and multiple). */
     cascade: Readonly<Ref<boolean>>;
     disabled: boolean;
     readOnly: boolean;
-    /** A node's tri-state value, derived from its enabled leaf descendants under `cascade`. */
+    /** Node tri-state (derived from enabled leaf descendants). */
     checkStateOf(value: string): TreeCheckedState;
-    /** Toggles a node (respecting `checkStrategy`), emits the projected value, and closes when `closeOnSelect`. */
+    /** Toggle node, emit projected value, close on select. */
     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. */
+    /** Caller's expansion + ancestors of filtered matches. */
     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. */
+    loadingValues: Readonly<Ref<ReadonlySet<string>>>;
+    /** Adapt Tree's whole-array expansion to 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). */
+    readonly expandOnClick: boolean;
     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`. */
+    /** Node's treeitem DOM id (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. */
+    /** Input mounted (aria-activedescendant on input, not 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. */
+    /** Keydown handler (shared by Trigger and Input). */
     onNavigationKeyDown(event: KeyboardEvent, options: {
         typeahead: boolean;
         selectOnSpace: boolean;
     }): void;
+    /**
+     * Node values `SkdxTreeSelectTree` actually renders when its `rows` prop
+     * windows below `flat`; `null` when unrestricted. Navigation and the
+     * initial active node draw from this so `aria-activedescendant` never
+     * names a node with no rendered `treeitem`.
+     */
+    visibleRowValues: Readonly<Ref<ReadonlySet<string> | null>>;
+    /** Reported by `SkdxTreeSelectTree` whenever its `rows` prop changes. */
+    setVisibleRowValues(values: ReadonlySet<string> | null): void;
 }
-/** @internal Injection key the TreeSelect root provides so its Trigger, Content, Input, Tree and Items share every piece of state. */
+/** @internal Injection key sharing state from the TreeSelect root to its parts. */
 export declare const TREE_SELECT_CONTEXT: InjectionKey<TreeSelectContext>;
-/** @internal Per-node state distributed from `SkdxTreeSelectItem` to `SkdxTreeSelectItemIndicator`. */
+/** @internal Per-node state to ItemIndicator. */
 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`. */
+    /** Virtually-focused node (aria-activedescendant). */
     active: boolean;
 }
-/** @internal Injection key an SkdxTreeSelectItem provides so its ItemIndicator can read the node's check state. */
+/** @internal Injection key an SkdxTreeSelectItem provides so its ItemIndicator can read 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.
+ * Default `filter`: case-insensitive substring match on `label ?? value`.
+ * Lives here, not in `TreeSelect.vue`, because `withDefaults(defineProps())`
+ * is hoisted out of `setup()` and can only reference an imported binding.
  */
 export declare function defaultTreeSelectFilter(node: TreeSelectNode, inputValue: string): boolean;
 /** Default `getMatchCountLabel`: `"1 match available"` / `"3 matches available"`. */