pxd 0.1.2 → 0.1.3

package/dist/composables/_internal/use-tree-move.js

@@ -1,96 +0,0 @@
-export function isTreeDescendant(index, ancestorValue, value) {
-  const ancestor = index.byValue.get(ancestorValue);
-  let current = index.byValue.get(value);
-  while (current && current.parentValue !== void 0) {
-    const parent = index.byValue.get(current.parentValue);
-    if (!parent) {
-      return false;
-    }
-    if (parent === ancestor) {
-      return true;
-    }
-    current = parent;
-  }
-  return false;
-}
-function removeNode(list, childrenField, value, parentValue) {
-  const at = list.findIndex((node) => node.value === value);
-  if (at !== -1) {
-    return {
-      list: [...list.slice(0, at), ...list.slice(at + 1)],
-      node: list[at],
-      parentValue,
-      index: at
-    };
-  }
-  for (let i = 0; i < list.length; i++) {
-    const children = list[i][childrenField];
-    if (!Array.isArray(children)) {
-      continue;
-    }
-    const result = removeNode(children, childrenField, value, list[i].value);
-    if (!result) {
-      continue;
-    }
-    const next = [...list];
-    next[i] = { ...list[i], [childrenField]: result.list };
-    return { ...result, list: next };
-  }
-  return void 0;
-}
-function insertNode(list, childrenField, target, node, parentValue) {
-  const at = list.findIndex((item) => item.value === target.targetValue);
-  if (at !== -1) {
-    const next = [...list];
-    if (target.position === "inside") {
-      const raw = next[at][childrenField];
-      const children = Array.isArray(raw) ? raw : [];
-      next[at] = { ...next[at], [childrenField]: [...children, node] };
-      return { list: next, parentValue: next[at].value, index: children.length };
-    }
-    const index = target.position === "after" ? at + 1 : at;
-    next.splice(index, 0, node);
-    return { list: next, parentValue, index };
-  }
-  for (let i = 0; i < list.length; i++) {
-    const children = list[i][childrenField];
-    if (!Array.isArray(children)) {
-      continue;
-    }
-    const result = insertNode(children, childrenField, target, node, list[i].value);
-    if (!result) {
-      continue;
-    }
-    const next = [...list];
-    next[i] = { ...list[i], [childrenField]: result.list };
-    return { ...result, list: next };
-  }
-  return void 0;
-}
-export function moveTreeNode(data, childrenField, value, target) {
-  const removal = removeNode(data, childrenField, value);
-  if (!removal) {
-    return void 0;
-  }
-  const insertion = insertNode(removal.list, childrenField, target, removal.node);
-  if (!insertion) {
-    return void 0;
-  }
-  if (removal.parentValue === insertion.parentValue && removal.index === insertion.index) {
-    return void 0;
-  }
-  return {
-    data: insertion.list,
-    detail: {
-      value,
-      node: removal.node,
-      from: { parentValue: removal.parentValue, index: removal.index },
-      to: {
-        parentValue: insertion.parentValue,
-        index: insertion.index,
-        targetValue: target.targetValue,
-        position: target.position
-      }
-    }
-  };
-}

package/dist/composables/_internal/use-tree-rows.d.ts

@@ -1,46 +0,0 @@
-import type { TreeFilterFn, TreeFlatNode, TreeOptions } from '../../components/tree/types';
-import type { ComponentValue } from '../../types/shared';
-import type { ComputedRef, MaybeRefOrGetter } from 'vue';
-export interface TreeNodeMeta {
-    node: TreeOptions[number];
-    children: TreeNodeMeta[];
-    parentValue?: ComponentValue;
-    depth: number;
-    /** Exclusive index in `list` right after this subtree. */
-    end: number;
-}
-export interface TreeIndex {
-    list: TreeNodeMeta[];
-    byValue: Map<ComponentValue, TreeNodeMeta>;
-}
-/** Depth-first pre-order walk: `list` is document order, `end` marks subtree bounds. */
-export declare function createTreeIndex(data: TreeOptions, childrenField: string): TreeIndex;
-export declare function useTreeIndex(data: MaybeRefOrGetter<TreeOptions>, childrenField: MaybeRefOrGetter<string>): ComputedRef<TreeIndex>;
-export interface TreeMatched {
-    /** Every hit plus its ancestor chain: ancestor-closed, so the row walk can prune subtrees. */
-    visible: ReadonlySet<ComponentValue>;
-    /** The hits alone, without the ancestors kept only for context. */
-    exact: ReadonlySet<ComponentValue>;
-}
-/**
- * Splits the current query into the two sets the row walk needs: the ancestor-closed one that
- * prunes whole subtrees, and the hits on their own.
- */
-export declare function useTreeMatched(index: MaybeRefOrGetter<TreeIndex>, query: MaybeRefOrGetter<string>, filter: MaybeRefOrGetter<TreeFilterFn | undefined>): ComputedRef<TreeMatched>;
-export interface UseTreeRowsOptions {
-    query: MaybeRefOrGetter<string>;
-    expanded: MaybeRefOrGetter<ReadonlySet<ComponentValue>>;
-    matched: MaybeRefOrGetter<ReadonlySet<ComponentValue>>;
-    /** The hits without their ancestors; only read when `matchesOnly` is on. */
-    exactMatched?: MaybeRefOrGetter<ReadonlySet<ComponentValue> | undefined>;
-    /** Drop the ancestors that only stayed visible for context, and flatten what is left. */
-    matchesOnly?: MaybeRefOrGetter<boolean | undefined>;
-}
-/**
- * Visible rows in document order. Collapsed subtrees and, while searching,
- * everything outside the matched ancestor chains are pruned.
- *
- * Selection state is deliberately absent: it changes on every click, and putting it here would
- * rebuild all N rows for a change that touches two of them. Read the sets at render time instead.
- */
-export declare function useTreeRows(index: MaybeRefOrGetter<TreeIndex>, options: UseTreeRowsOptions): ComputedRef<TreeFlatNode[]>;

package/dist/composables/_internal/use-tree-rows.js

@@ -1,101 +0,0 @@
-import { computed } from "vue";
-import { isFuzzyMatch } from "../../utils/fuzzy-match.js";
-import { toValue } from "../../utils/helper.js";
-export function createTreeIndex(data, childrenField) {
-  const list = [];
-  const byValue = /* @__PURE__ */ new Map();
-  function visit(node, parentValue, depth) {
-    const meta = { node, children: [], parentValue, depth, end: 0 };
-    list.push(meta);
-    byValue.set(node.value, meta);
-    const children = node[childrenField];
-    if (Array.isArray(children)) {
-      for (const child of children) {
-        meta.children.push(visit(child, node.value, depth + 1));
-      }
-    }
-    meta.end = list.length;
-    return meta;
-  }
-  for (const node of data) {
-    visit(node, void 0, 0);
-  }
-  return { list, byValue };
-}
-export function useTreeIndex(data, childrenField) {
-  return computed(() => createTreeIndex(toValue(data) ?? [], toValue(childrenField) ?? "children"));
-}
-function defaultFilter(node, query) {
-  return isFuzzyMatch(String(node.label ?? ""), query, node.keywords);
-}
-export function useTreeMatched(index, query, filter) {
-  return computed(() => {
-    const visible = /* @__PURE__ */ new Set();
-    const exact = /* @__PURE__ */ new Set();
-    const needle = (toValue(query) ?? "").trim();
-    if (!needle) {
-      return { visible, exact };
-    }
-    const match = toValue(filter) ?? defaultFilter;
-    const { list, byValue } = toValue(index);
-    for (const meta of list) {
-      if (!match(meta.node, needle)) {
-        continue;
-      }
-      exact.add(meta.node.value);
-      visible.add(meta.node.value);
-      let parentValue = meta.parentValue;
-      while (parentValue !== void 0 && !visible.has(parentValue)) {
-        visible.add(parentValue);
-        parentValue = byValue.get(parentValue)?.parentValue;
-      }
-    }
-    return { visible, exact };
-  });
-}
-export function useTreeRows(index, options) {
-  return computed(() => {
-    const { list } = toValue(index);
-    const expanded = toValue(options.expanded);
-    const matched = toValue(options.matched);
-    const searching = (toValue(options.query) ?? "").trim().length > 0;
-    const matchesOnly = searching && toValue(options.matchesOnly) === true;
-    const exact = toValue(options.exactMatched) ?? matched;
-    const rows = [];
-    let cursor = 0;
-    while (cursor < list.length) {
-      const meta = list[cursor];
-      if (searching && !matched.has(meta.node.value)) {
-        cursor = meta.end;
-        continue;
-      }
-      const value = meta.node.value;
-      if (matchesOnly && !exact.has(value)) {
-        cursor++;
-        continue;
-      }
-      rows.push({
-        key: value,
-        node: meta.node,
-        depth: matchesOnly ? 0 : meta.depth,
-        index: rows.length,
-        parentValue: matchesOnly ? void 0 : meta.parentValue,
-        hasChildren: meta.children.length > 0,
-        expanded: expanded.has(value),
-        matched: matched.has(value)
-      });
-      cursor++;
-      if (meta.children.length > 0 && !searching && !expanded.has(value)) {
-        cursor = meta.end;
-      }
-    }
-    if (searching) {
-      for (let i = 0; i < rows.length - 1; i++) {
-        if (rows[i].hasChildren) {
-          rows[i].expanded = rows[i + 1].depth > rows[i].depth;
-        }
-      }
-    }
-    return rows;
-  });
-}

package/dist/composables/_internal/use-tree-selection.d.ts

@@ -1,22 +0,0 @@
-import type { TreeModelValue } from '../../components/tree/types';
-import type { ComponentValue } from '../../types/shared';
-import type { TreeIndex } from './use-tree-rows';
-import type { ComputedRef, MaybeRefOrGetter } from 'vue';
-export interface UseTreeSelectionOptions {
-    index: MaybeRefOrGetter<TreeIndex>;
-    modelValue: MaybeRefOrGetter<TreeModelValue | undefined>;
-    multiple: MaybeRefOrGetter<boolean>;
-    /** Keep every node on its own: no cascade, and no parent lit up by its children. */
-    checkStrictly?: MaybeRefOrGetter<boolean | undefined>;
-}
-export interface TreeToggleResult {
-    value: TreeModelValue;
-    /** Parents left partially checked by the new selection, empty without the cascade. */
-    halfCheckedValues: ComponentValue[];
-}
-export interface UseTreeSelectionReturn {
-    checked: ComputedRef<Set<ComponentValue>>;
-    indeterminate: ComputedRef<Set<ComponentValue>>;
-    toggle: (value: ComponentValue) => TreeToggleResult;
-}
-export declare function useTreeSelection(options: UseTreeSelectionOptions): UseTreeSelectionReturn;

package/dist/composables/_internal/use-tree-selection.js

@@ -1,87 +0,0 @@
-import { computed } from "vue";
-import { toValue } from "../../utils/helper.js";
-function collect(modelValue) {
-  if (Array.isArray(modelValue)) {
-    return new Set(modelValue);
-  }
-  return modelValue == null ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([modelValue]);
-}
-function derive(list, selected) {
-  const checked = /* @__PURE__ */ new Set();
-  const indeterminate = /* @__PURE__ */ new Set();
-  const stats = /* @__PURE__ */ new Map();
-  for (let i = list.length - 1; i >= 0; i--) {
-    const meta = list[i];
-    let total = 0;
-    let hit = 0;
-    for (const child of meta.children) {
-      const childStat = stats.get(child);
-      total += childStat?.total ?? 0;
-      hit += childStat?.hit ?? 0;
-    }
-    const selectable = meta.node.disabled !== true;
-    const isChecked = total > 0 ? hit === total : selected.has(meta.node.value);
-    if (isChecked) {
-      checked.add(meta.node.value);
-    } else if (hit > 0) {
-      indeterminate.add(meta.node.value);
-    }
-    stats.set(meta, {
-      total: total + (selectable ? 1 : 0),
-      hit: hit + (isChecked && selectable ? 1 : 0)
-    });
-  }
-  return { checked, indeterminate };
-}
-export function useTreeSelection(options) {
-  const selected = computed(() => collect(toValue(options.modelValue)));
-  const state = computed(() => {
-    if (!toValue(options.multiple) || toValue(options.checkStrictly)) {
-      return { checked: selected.value, indeterminate: /* @__PURE__ */ new Set() };
-    }
-    return derive(toValue(options.index).list, selected.value);
-  });
-  function toToggleResult(list, result) {
-    return {
-      value: list.filter((item) => result.checked.has(item.node.value)).map((item) => item.node.value),
-      halfCheckedValues: list.filter((item) => result.indeterminate.has(item.node.value)).map((item) => item.node.value)
-    };
-  }
-  function toggle(value) {
-    if (!toValue(options.multiple)) {
-      return { value: selected.value.has(value) ? null : value, halfCheckedValues: [] };
-    }
-    const { list, byValue } = toValue(options.index);
-    const meta = byValue.get(value);
-    if (!meta || toValue(options.checkStrictly) && meta.node.disabled) {
-      return toToggleResult(list, state.value);
-    }
-    const next = new Set(selected.value);
-    const willCheck = !state.value.checked.has(value);
-    if (toValue(options.checkStrictly)) {
-      if (willCheck) {
-        next.add(value);
-      } else {
-        next.delete(value);
-      }
-      return toToggleResult(list, { checked: next, indeterminate: /* @__PURE__ */ new Set() });
-    }
-    for (let i = list.indexOf(meta); i < meta.end; i++) {
-      const item = list[i];
-      if (item.node.disabled) {
-        continue;
-      }
-      if (willCheck) {
-        next.add(item.node.value);
-      } else {
-        next.delete(item.node.value);
-      }
-    }
-    return toToggleResult(list, derive(list, next));
-  }
-  return {
-    checked: computed(() => state.value.checked),
-    indeterminate: computed(() => state.value.indeterminate),
-    toggle
-  };
-}