pxd 0.0.64 → 0.1.2

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

@@ -0,0 +1,196 @@
+import { onScopeDispose, shallowRef } from "vue";
+import { getElement } from "../../utils/dom.js";
+import { toValue } from "../../utils/helper.js";
+const DRAG_THRESHOLD = 5;
+const EDGE_SIZE = 32;
+const EDGE_SPEED = 12;
+const EXPAND_DELAY = 500;
+export function useTreeDrag(options) {
+  const value = shallowRef();
+  const target = shallowRef();
+  const x = shallowRef(0);
+  const y = shallowRef(0);
+  let armed;
+  let frame;
+  let autoScroll = 0;
+  let expandTimer;
+  let expandValue;
+  let cachedRects = [];
+  let contentOrigin = 0;
+  function measureRows(container, items) {
+    const rows = toValue(options.rows);
+    const origin = container.getBoundingClientRect().top - container.scrollTop;
+    const list = [];
+    for (const item of Array.from(items)) {
+      const row = rows[Number(item.dataset.index)];
+      if (!row) {
+        continue;
+      }
+      const rect = item.getBoundingClientRect();
+      list.push({ row, top: rect.top - origin, height: rect.height });
+    }
+    cachedRects = list;
+    contentOrigin = origin;
+  }
+  function isCacheStale(items) {
+    if (items.length !== cachedRects.length) {
+      return true;
+    }
+    return Number(items[0]?.dataset.index) !== cachedRects[0]?.row.index;
+  }
+  function resolveTarget(clientY) {
+    const container = getElement(options.container);
+    if (!container) {
+      return void 0;
+    }
+    const items = container.querySelectorAll("[data-tree-item]");
+    if (isCacheStale(items)) {
+      measureRows(container, items);
+    }
+    if (cachedRects.length === 0) {
+      return void 0;
+    }
+    const y2 = clientY - contentOrigin;
+    let nearest;
+    for (const entry of cachedRects) {
+      if (y2 >= entry.top && y2 <= entry.top + entry.height) {
+        return toTarget(entry, y2);
+      }
+      if (!nearest || Math.abs(entry.top - y2) < Math.abs(nearest.top - y2)) {
+        nearest = entry;
+      }
+    }
+    return nearest ? toTarget(nearest, y2) : void 0;
+  }
+  function toTarget(entry, y2) {
+    const dragged = value.value;
+    if (dragged === void 0) {
+      return void 0;
+    }
+    const row = entry.row;
+    const ratio = (y2 - entry.top) / (entry.height || 1);
+    const position = row.hasChildren && ratio > 0.25 && ratio < 0.75 ? "inside" : ratio < 0.5 ? "before" : "after";
+    return options.canDrop(dragged, row.key, position) ? { targetValue: row.key, position } : void 0;
+  }
+  function scheduleExpand(next) {
+    if (!next || next.position !== "inside") {
+      clearExpand();
+      return;
+    }
+    if (expandValue === next.targetValue) {
+      return;
+    }
+    clearExpand();
+    expandValue = next.targetValue;
+    expandTimer = setTimeout(() => {
+      expandTimer = void 0;
+      if (expandValue !== void 0) {
+        options.onExpand(expandValue);
+      }
+    }, EXPAND_DELAY);
+  }
+  function clearExpand() {
+    if (expandTimer !== void 0) {
+      clearTimeout(expandTimer);
+      expandTimer = void 0;
+    }
+    expandValue = void 0;
+  }
+  function tick() {
+    frame = void 0;
+    const container = getElement(options.container);
+    if (container && autoScroll !== 0) {
+      container.scrollTop += autoScroll;
+      target.value = resolveTarget(y.value);
+    }
+    if (autoScroll !== 0) {
+      frame = requestAnimationFrame(tick);
+    }
+  }
+  function updateAutoScroll(clientY) {
+    const container = getElement(options.container);
+    if (!container) {
+      return;
+    }
+    const rect = container.getBoundingClientRect();
+    if (clientY - rect.top < EDGE_SIZE) {
+      autoScroll = -EDGE_SPEED;
+    } else if (rect.bottom - clientY < EDGE_SIZE) {
+      autoScroll = EDGE_SPEED;
+    } else {
+      autoScroll = 0;
+    }
+    if (autoScroll !== 0 && frame === void 0) {
+      frame = requestAnimationFrame(tick);
+    }
+  }
+  function stopAutoScroll() {
+    autoScroll = 0;
+    if (frame !== void 0) {
+      cancelAnimationFrame(frame);
+      frame = void 0;
+    }
+  }
+  function detach() {
+    window.removeEventListener("pointermove", onPointerMove);
+    window.removeEventListener("pointerup", onPointerUp);
+    window.removeEventListener("pointercancel", onPointerCancel);
+    window.removeEventListener("keydown", onKeydown);
+    armed = void 0;
+    cachedRects = [];
+    stopAutoScroll();
+    clearExpand();
+  }
+  function reset() {
+    value.value = void 0;
+    target.value = void 0;
+    detach();
+  }
+  function onPointerMove(event) {
+    if (armed) {
+      const moved = Math.abs(event.clientY - armed.y) >= DRAG_THRESHOLD || Math.abs(event.clientX - armed.x) >= DRAG_THRESHOLD;
+      if (!moved) {
+        return;
+      }
+      window.removeEventListener("keydown", onKeydown);
+      window.addEventListener("keydown", onKeydown);
+      value.value = armed.value;
+      armed = void 0;
+    }
+    if (value.value === void 0) {
+      return;
+    }
+    x.value = event.clientX;
+    y.value = event.clientY;
+    target.value = resolveTarget(event.clientY);
+    scheduleExpand(target.value);
+    updateAutoScroll(event.clientY);
+  }
+  function onPointerUp() {
+    const dragged = value.value;
+    const dropped = target.value;
+    reset();
+    if (dragged !== void 0 && dropped) {
+      options.onCommit(dragged, dropped);
+    }
+  }
+  function onPointerCancel() {
+    reset();
+  }
+  function onKeydown(event) {
+    if (event.key === "Escape") {
+      reset();
+    }
+  }
+  function onPointerDown(nodeValue, event) {
+    if (armed || toValue(options.enabled) === false || event.button !== 0) {
+      return;
+    }
+    armed = { value: nodeValue, x: event.clientX, y: event.clientY };
+    window.addEventListener("pointermove", onPointerMove);
+    window.addEventListener("pointerup", onPointerUp);
+    window.addEventListener("pointercancel", onPointerCancel);
+  }
+  onScopeDispose(reset);
+  return { value, target, x, y, onPointerDown, cancel: reset };
+}

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

@@ -0,0 +1,20 @@
+import type { TreeDropTarget, TreeMoveDetail, TreeOptions } from '../../components/tree/types';
+import type { ComponentValue } from '../../types/shared';
+import type { TreeIndex } from './use-tree-rows';
+/**
+ * Walks up from `value` looking for `ancestorValue`. Reached in O(depth) instead of scanning
+ * `index.list`, which the hit test runs on every pointer move.
+ */
+export declare function isTreeDescendant(index: TreeIndex, ancestorValue: ComponentValue, value: ComponentValue): boolean;
+export interface TreeMoveResult {
+    data: TreeOptions;
+    detail: TreeMoveDetail;
+}
+/**
+ * Relocates a node relative to a target row.
+ *
+ * The node is detached before the target is looked up, which is what rejects the whole
+ * family of invalid drops for free: the node itself and its own descendants are no longer
+ * in the tree, so the insertion pass simply never finds them.
+ */
+export declare function moveTreeNode(data: TreeOptions, childrenField: string, value: ComponentValue, target: TreeDropTarget): TreeMoveResult | undefined;

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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,101 @@
+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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,87 @@
+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
+  };
+}

package/dist/composables/_internal/use-word-limit.d.ts

@@ -0,0 +1,24 @@
+import type { ComponentLabel } from '../../types/shared';
+import type { ComputedRef, MaybeRefOrGetter } from 'vue';
+interface WordLimitOptions {
+    modelValue: MaybeRefOrGetter<ComponentLabel>;
+    showWordLimit: MaybeRefOrGetter<unknown>;
+    maxLength: MaybeRefOrGetter<string | number | null | undefined>;
+    wordLimitPosition: MaybeRefOrGetter<'inside' | 'outside' | undefined>;
+    isComposing: MaybeRefOrGetter<boolean>;
+}
+export interface WordLimit {
+    wordCount: ComputedRef<number>;
+    isWordLimitShown: ComputedRef<boolean>;
+    hasMaxLength: ComputedRef<boolean>;
+    isWordLimitOutside: ComputedRef<boolean>;
+    nativeMaxLength: ComputedRef<string | number | undefined>;
+    wordLimitText: ComputedRef<string>;
+    isWordLimitExceeded: ComputedRef<boolean>;
+}
+/**
+ * Shared word-limit state used by PInput and PTextarea.
+ * Keeps the two components' word-count/computed logic in sync.
+ */
+export declare function useWordLimit(options: WordLimitOptions): WordLimit;
+export {};

package/dist/composables/_internal/use-word-limit.js

@@ -0,0 +1,36 @@
+import { computed } from "vue";
+import { isTruthyProp } from "../../utils/format.js";
+import { toValue } from "../../utils/helper.js";
+export function useWordLimit(options) {
+  const wordCount = computed(() => String(toValue(options.modelValue) ?? "").length);
+  const isWordLimitShown = computed(() => isTruthyProp(toValue(options.showWordLimit)));
+  const hasMaxLength = computed(() => {
+    const maxLength = toValue(options.maxLength);
+    return maxLength != null && maxLength !== "";
+  });
+  const isWordLimitOutside = computed(() => toValue(options.wordLimitPosition) === "outside");
+  const nativeMaxLength = computed(() => {
+    if (toValue(options.isComposing)) {
+      return void 0;
+    }
+    return toValue(options.maxLength) ?? void 0;
+  });
+  const wordLimitText = computed(() => {
+    if (hasMaxLength.value) {
+      return `${wordCount.value} / ${toValue(options.maxLength)}`;
+    }
+    return `${wordCount.value}`;
+  });
+  const isWordLimitExceeded = computed(
+    () => hasMaxLength.value && wordCount.value > Number(toValue(options.maxLength))
+  );
+  return {
+    wordCount,
+    isWordLimitShown,
+    hasMaxLength,
+    isWordLimitOutside,
+    nativeMaxLength,
+    wordLimitText,
+    isWordLimitExceeded
+  };
+}

package/dist/composables/index.d.ts

@@ -1,4 +1,4 @@
-export * from './use-browser-observer.js';
+export * from './use-backoff-retry.js';
 export * from './use-client-online.js';
 export * from './use-color-scheme.js';
 export * from './use-copy-click.js';
@@ -7,20 +7,17 @@ export * from './use-deferred-value.js';
 export * from './use-delay-change.js';
 export * from './use-delay-destroy.js';
 export * from './use-document-hidden.js';
-export * from './use-focus-trap.js';
-export * from './use-forward-ref-expose.js';
-export * from './use-list-filter.js';
-export * from './use-list-navigation.js';
+export * from './use-intersection-observer.js';
 export * from './use-loading-bar.js';
-export * from './use-lock-scroll.js';
 export * from './use-media-query.js';
 export * from './use-message.js';
-export * from './use-model-value.js';
+export * from './use-mutation-observer.js';
 export * from './use-outside-click.js';
-export * from './use-overlay-manager.js';
-export * from './use-popover-responsive.js';
 export * from './use-repeat-action.js';
-export * from './use-swipe-gesture.js';
+export * from './use-resize-observer.js';
+export * from './use-scrollspy.js';
+export * from './use-stick-to-bottom.js';
 export * from './use-toggle-value.js';
+export * from './use-view-transition.js';
 export * from './use-virtual-list.js';
 export * from './use-window-size.js';