pxd 0.0.64 → 0.1.3

package/dist/components/tabs-item/types.d.ts

@@ -1,10 +0,0 @@
-import type { ComponentLabel } from '../../types/shared'
-import type { TabsValue } from '../tabs/types'
-
-export interface TabsItemProps {
-  label?: ComponentLabel
-  value: TabsValue
-  disabled?: boolean
-}
-
-export interface TabsItemEmits {}

package/dist/composables/use-browser-observer.d.ts

@@ -1,12 +0,0 @@
-import type { Nullable } from '../types/shared/utils';
-import type { MaybeRefOrGetter, Ref } from 'vue';
-export declare const useIntersectionObserver: (target: TargetRef, callback: IntersectionObserverCallback, options?: IntersectionObserverInit) => ObserverResults<IntersectionObserver>;
-export declare const useMutationObserver: (target: TargetRef, callback: MutationCallback, options?: MutationObserverInit) => ObserverResults<MutationObserver>;
-export declare const useResizeObserver: (target: TargetRef, callback: ResizeObserverCallback, options?: ResizeObserverOptions) => ObserverResults<ResizeObserver>;
-type Observers = IntersectionObserver | ResizeObserver | MutationObserver;
-type TargetRef = MaybeRefOrGetter<Nullable<HTMLElement>> | MaybeRefOrGetter<Nullable<HTMLElement>>[] | MaybeRefOrGetter<Nullable<HTMLElement>[]>;
-interface ObserverResults<T extends Observers> {
-    observer: Ref<T | undefined>;
-    stop: () => void;
-}
-export {};

package/dist/composables/use-browser-observer.js

@@ -1,74 +0,0 @@
-import { isNotNil } from "es-toolkit";
-import { computed, onScopeDispose, watch, shallowRef } from "vue";
-import { toArray } from "../utils/format.js";
-import { toValue, unrefElement } from "../utils/ref.js";
-export const useIntersectionObserver = createObserver(
-  globalThis.IntersectionObserver,
-  "IntersectionObserver"
-);
-export const useMutationObserver = createObserver(globalThis.MutationObserver, "MutationObserver");
-export const useResizeObserver = createObserver(globalThis.ResizeObserver, "ResizeObserver");
-function createObserver(ObserverConstructor, type) {
-  function observerWrapper(target, callback, options) {
-    const observer = shallowRef();
-    const targets = computed(
-      () => toArray(toValue(target)).map(unrefElement).filter(isNotNil)
-    );
-    const unwatch = watch(
-      targets,
-      (newTargets) => {
-        if (typeof window === "undefined" || typeof ObserverConstructor === "undefined") {
-          return;
-        }
-        cleanup();
-        if (!newTargets?.length) {
-          return;
-        }
-        if (type === "IntersectionObserver") {
-          observer.value = new ObserverConstructor(
-            callback,
-            options
-          );
-          newTargets.forEach((el) => observer.value.observe(el));
-        } else if (type === "MutationObserver") {
-          observer.value = new ObserverConstructor(
-            callback
-          );
-          newTargets.forEach(
-            (el) => observer.value.observe(el, options)
-          );
-        } else if (type === "ResizeObserver") {
-          observer.value = new ObserverConstructor(
-            callback
-          );
-          newTargets.forEach(
-            (el) => observer.value.observe(el, options)
-          );
-        }
-      },
-      {
-        immediate: true,
-        flush: "post"
-      }
-    );
-    function cleanup() {
-      if (!observer.value) {
-        return;
-      }
-      observer.value.disconnect();
-      observer.value = void 0;
-    }
-    function stop() {
-      cleanup();
-      unwatch();
-    }
-    onScopeDispose(() => {
-      stop();
-    });
-    return {
-      observer,
-      stop
-    };
-  }
-  return observerWrapper;
-}

package/dist/composables/use-focus-trap.js

@@ -1,54 +0,0 @@
-import { createFocusTrap } from "focus-trap";
-import { onScopeDispose, watch } from "vue";
-import { toValue } from "../utils/ref.js";
-const focusTrapStack = [];
-const AUTO_FOCUS_FIRST_SELECTOR = [
-  'input:not([type="hidden"]):not(:disabled)',
-  "button:not(:disabled)",
-  "select:not(:disabled)",
-  "textarea:not(:disabled)",
-  '[tabindex]:not([tabindex="-1"])'
-].join(",");
-export function useFocusTrap(container, userOptions = {}) {
-  let trapper = null;
-  const unwatch = watch(
-    () => toValue(container),
-    (target, _, onCleanup) => {
-      if (!target) {
-        return;
-      }
-      const { autoFocusElement, ...restOptions } = toValue(userOptions);
-      const defaultOptions = {
-        allowOutsideClick: true,
-        escapeDeactivates: false,
-        clickOutsideDeactivates: false,
-        // A11y + robustness
-        returnFocusOnDeactivate: true,
-        preventScroll: true,
-        fallbackFocus: () => target,
-        initialFocus: () => {
-          if (autoFocusElement) {
-            const elSelector = typeof autoFocusElement === "boolean" ? AUTO_FOCUS_FIRST_SELECTOR : autoFocusElement;
-            return target.querySelector(elSelector) ?? target;
-          }
-          return target;
-        },
-        // Coordinate nested PXD dialogs
-        trapStack: focusTrapStack
-      };
-      trapper = createFocusTrap(target, { ...defaultOptions, ...restOptions });
-      trapper.activate();
-      onCleanup(() => {
-        trapper.deactivate();
-        trapper = null;
-      });
-    },
-    { flush: "post" }
-  );
-  onScopeDispose(() => {
-    unwatch();
-  });
-  return {
-    stop: unwatch
-  };
-}

package/dist/composables/use-list-filter.d.ts

@@ -1,11 +0,0 @@
-import type { ListFilterContext } from '../contexts/list';
-import type { ComputedRef, Ref } from 'vue';
-export type ListFilterFn = (text: string, search: string, keywords: string[]) => boolean;
-export interface UseListFilterOptions {
-    keyword: Ref<string>;
-    filter?: ListFilterFn;
-}
-export interface UseListFilterReturn extends ListFilterContext {
-    visibleCount: ComputedRef<number>;
-}
-export declare function useListFilter({ filter, keyword, }: UseListFilterOptions): UseListFilterReturn;

package/dist/composables/use-list-filter.js

@@ -1,56 +0,0 @@
-import { computed, shallowRef } from "vue";
-import { isMatch } from "../utils/fuzzy-search.js";
-export function useListFilter({
-  filter = isMatch,
-  keyword
-}) {
-  const items = /* @__PURE__ */ new Map();
-  const revision = shallowRef(0);
-  const filterState = computed(() => {
-    void revision.value;
-    let visibleCount2 = 0;
-    const search = keyword.value;
-    const visibleItems = /* @__PURE__ */ new Set();
-    const visibleGroupIds = /* @__PURE__ */ new Set();
-    for (const [id, item] of items) {
-      if (filter(item.getValue(), search, item.getKeywords())) {
-        visibleItems.add(id);
-        visibleCount2++;
-        if (item.groupId) {
-          visibleGroupIds.add(item.groupId);
-        }
-      }
-    }
-    return {
-      visibleItems,
-      visibleGroupIds,
-      visibleCount: visibleCount2
-    };
-  });
-  const visibleCount = computed(() => filterState.value.visibleCount);
-  function registerItem(id, payload) {
-    items.set(id, payload);
-    revision.value++;
-  }
-  function unregisterItem(id) {
-    if (!items.has(id)) {
-      return;
-    }
-    items.delete(id);
-    revision.value++;
-  }
-  function isItemVisible(id) {
-    return filterState.value.visibleItems.has(id);
-  }
-  function isGroupVisible(id) {
-    return filterState.value.visibleGroupIds.has(id);
-  }
-  return {
-    searchValue: keyword,
-    visibleCount,
-    registerItem,
-    isItemVisible,
-    isGroupVisible,
-    unregisterItem
-  };
-}

package/dist/composables/use-list-navigation.d.ts

@@ -1,27 +0,0 @@
-import type { MaybeRefOrGetter, ShallowRef } from 'vue';
-export interface UseListNavigationOptions {
-    loop?: MaybeRefOrGetter<boolean>;
-    itemSelector?: MaybeRefOrGetter<string>;
-    defaultActiveIndex?: MaybeRefOrGetter<number>;
-    toggleOnKeyPress?: MaybeRefOrGetter<boolean>;
-    onToggle?: (index: number) => void;
-    onEnter?: (el: HTMLElement) => void;
-}
-export interface UseListNavigationReturn {
-    activeIndex: ShallowRef<number>;
-    setActiveIndex: (index: number) => void;
-    registerItem: (el: HTMLElement, indexRef: ShallowRef<number>) => void;
-    unregisterItem: (el: HTMLElement) => void;
-    onKeydown: (ev: KeyboardEvent) => void;
-    onPointerOver: (ev: PointerEvent) => void;
-    /**
-     * Request a re-query of the DOM items. Multiple calls made within the same
-     * tick coalesce into a single refresh that runs after `nextTick`. `await`
-     * the returned promise when the caller needs `items` to be up-to-date
-     * before its next action (e.g. `setFirstAsActive` after a search change).
-     */
-    refreshItems: () => Promise<void>;
-    setFirstAsActive: () => void;
-    isEmpty: () => boolean;
-}
-export declare function useListNavigation(containerRef: MaybeRefOrGetter<HTMLElement | undefined>, options: UseListNavigationOptions): UseListNavigationReturn;

package/dist/composables/use-list-navigation.js

@@ -1,159 +0,0 @@
-import { nextTick, shallowRef } from "vue";
-import { toValue, unrefElement } from "../utils/ref.js";
-const DISABLED_KEYS = ["PageUp", "PageDown"];
-const KEY_DIRECTION = {
-  ArrowUp: -1,
-  ArrowLeft: -1,
-  ArrowDown: 1,
-  ArrowRight: 1
-};
-function findNextIndex(len, from, dir, loop) {
-  if (len === 0) {
-    return -1;
-  }
-  const i = from + dir;
-  if (loop) {
-    return (i % len + len) % len;
-  }
-  if (i < 0 || i >= len) {
-    return -1;
-  }
-  return i;
-}
-export function useListNavigation(containerRef, options) {
-  const getLoop = () => toValue(options.loop) ?? true;
-  const getToggleOnKeyPress = () => toValue(options.toggleOnKeyPress) ?? true;
-  const getDefaultActiveIndex = () => toValue(options.defaultActiveIndex) ?? -1;
-  const getItemSelector = () => toValue(options.itemSelector) ?? "[data-list-item]";
-  const activeIndex = shallowRef(getDefaultActiveIndex());
-  const itemIndexRefs = /* @__PURE__ */ new WeakMap();
-  let items = [];
-  let lastPointerX = -1;
-  let lastPointerY = -1;
-  let pendingRefresh = null;
-  function runRefresh() {
-    const container = unrefElement(containerRef);
-    items = container ? Array.from(container.querySelectorAll(getItemSelector())) : [];
-    items.forEach((el, i) => {
-      const ref = itemIndexRefs.get(el);
-      if (ref) {
-        ref.value = i;
-      }
-    });
-    if (activeIndex.value >= items.length) {
-      activeIndex.value = items.length - 1;
-    }
-    const fallback = getDefaultActiveIndex();
-    if (activeIndex.value === -1 && fallback >= 0 && fallback < items.length) {
-      activeIndex.value = fallback;
-    }
-  }
-  function refreshItems() {
-    if (pendingRefresh) {
-      return pendingRefresh;
-    }
-    pendingRefresh = nextTick().then(() => {
-      pendingRefresh = null;
-      runRefresh();
-    });
-    return pendingRefresh;
-  }
-  function setActiveIndex(index) {
-    activeIndex.value = index;
-  }
-  function setFirstAsActive() {
-    activeIndex.value = findNextIndex(items.length, -1, 1, false);
-  }
-  function isEmpty() {
-    return items.length === 0;
-  }
-  function registerItem(el, indexRef) {
-    itemIndexRefs.set(el, indexRef);
-    void refreshItems();
-  }
-  function unregisterItem(el) {
-    itemIndexRefs.delete(el);
-    void refreshItems();
-  }
-  function onPointerOver(ev) {
-    if (ev.pageX === lastPointerX && ev.pageY === lastPointerY) {
-      return;
-    }
-    lastPointerX = ev.pageX;
-    lastPointerY = ev.pageY;
-    const listItem = ev.target.closest(getItemSelector());
-    if (!listItem) {
-      return;
-    }
-    const index = itemIndexRefs.get(listItem)?.value ?? -1;
-    if (index !== -1) {
-      activeIndex.value = index;
-    }
-  }
-  function onKeydown(ev) {
-    if (!getToggleOnKeyPress() || isEmpty()) {
-      return;
-    }
-    const { key, ctrlKey, metaKey, altKey, shiftKey } = ev;
-    if (DISABLED_KEYS.includes(key)) {
-      ev.preventDefault();
-      ev.stopPropagation();
-      return;
-    }
-    if (ctrlKey || metaKey || altKey || shiftKey) {
-      return;
-    }
-    const len = items.length;
-    const current = activeIndex.value;
-    if (key === "Enter") {
-      if (current < 0 || current >= len) {
-        return;
-      }
-      const el = items[current];
-      if (!el) {
-        return;
-      }
-      ev.preventDefault();
-      ev.stopPropagation();
-      if (typeof options.onEnter === "function") {
-        options.onEnter(el);
-      } else {
-        el.click();
-      }
-      return;
-    }
-    let next;
-    if (key === "Home") {
-      next = findNextIndex(len, -1, 1, false);
-    } else if (key === "End") {
-      next = findNextIndex(len, len, -1, false);
-    } else {
-      const dir = KEY_DIRECTION[key];
-      if (!dir) {
-        return;
-      }
-      next = current === -1 ? findNextIndex(len, dir === 1 ? -1 : len, dir, false) : findNextIndex(len, current, dir, getLoop());
-    }
-    if (next === -1) {
-      return;
-    }
-    ev.preventDefault();
-    ev.stopPropagation();
-    if (next !== current) {
-      options.onToggle?.(next);
-      activeIndex.value = next;
-      items[next]?.scrollIntoView({ block: "nearest" });
-    }
-  }
-  return {
-    activeIndex,
-    setActiveIndex,
-    registerItem,
-    unregisterItem,
-    onKeydown,
-    onPointerOver,
-    refreshItems,
-    setFirstAsActive,
-    isEmpty
-  };
-}

package/dist/composables/use-lock-scroll.d.ts

@@ -1,5 +0,0 @@
-export declare function useLockScroll(): {
-    isLocked: () => boolean;
-    lockScroll: () => void;
-    unlockScroll: () => void;
-};

package/dist/composables/use-lock-scroll.js

@@ -1,37 +0,0 @@
-import { hasScrollbar, isScrollable } from "../utils/dom.js";
-import { cachedOff, cachedOn, preventDefaultScroll } from "../utils/event.js";
-let rootTouchMoveLocks = 0;
-export function useLockScroll() {
-  const classList = ["pointer-events-none"];
-  function isLocked() {
-    return rootTouchMoveLocks > 0;
-  }
-  function lockScroll() {
-    if (!isLocked()) {
-      const rootEl = document.documentElement;
-      cachedOn(document, "touchmove", preventDefaultScroll, { passive: false });
-      const { x: xScrollbar, y: yScrollbar } = hasScrollbar(rootEl);
-      const { x: xScrollable, y: yScrollable } = isScrollable(rootEl);
-      if (xScrollbar && xScrollable || yScrollbar && yScrollable) {
-        classList.push("scrollbar-stable", "scrollbar-disabled");
-      }
-      rootEl.classList.add(...classList);
-    }
-    rootTouchMoveLocks++;
-  }
-  function unlockScroll() {
-    if (rootTouchMoveLocks <= 0) {
-      return;
-    }
-    rootTouchMoveLocks = Math.max(rootTouchMoveLocks - 1, 0);
-    if (!rootTouchMoveLocks) {
-      cachedOff(document, "touchmove", preventDefaultScroll);
-      document.documentElement.classList.remove(...classList);
-    }
-  }
-  return {
-    isLocked,
-    lockScroll,
-    unlockScroll
-  };
-}

package/dist/composables/use-model-value.js

@@ -1,13 +0,0 @@
-import { computed } from "vue";
-export function useModelValue(props, emits, options = { withChange: true }) {
-  const modelValue = computed({
-    get: options.get || (() => props.modelValue),
-    set: options.set || ((value) => {
-      if (options.withChange) {
-        emits("change", value);
-      }
-      emits("update:modelValue", value);
-    })
-  });
-  return modelValue;
-}

package/dist/composables/use-overlay-manager.js

@@ -1,80 +0,0 @@
-import { onScopeDispose } from "vue";
-import { cachedOff, cachedOn } from "../utils/event.js";
-import { toValue } from "../utils/ref.js";
-let isKeydownListening = false;
-const overlayStack = [];
-function getTopOverlay() {
-  return overlayStack.at(-1);
-}
-function onEscapeKeydown(ev) {
-  const entry = getTopOverlay();
-  if (!entry) {
-    return;
-  }
-  const { ctrlKey, metaKey, altKey, shiftKey, key } = ev;
-  if (ctrlKey || metaKey || altKey || shiftKey || key !== "Escape") {
-    return;
-  }
-  entry?.onPressEscape?.(ev);
-}
-function ensureKeydownListener() {
-  if (isKeydownListening) {
-    return;
-  }
-  cachedOn(document, "keydown", onEscapeKeydown);
-  isKeydownListening = true;
-}
-function removeKeydownListener() {
-  if (!isKeydownListening || overlayStack.length > 0) {
-    return;
-  }
-  cachedOff(document, "keydown", onEscapeKeydown);
-  isKeydownListening = false;
-}
-export function useOverlayManager(options) {
-  const { enabled, lockScrollOnVisible, lockScroll, unlockScroll, onPressEscape } = options;
-  let isLockedScroll = false;
-  const overlayId = Symbol("pxd-overlay-id");
-  function isTopOverlay(entry) {
-    entry ??= getTopOverlay();
-    return entry?.id === overlayId;
-  }
-  function registerOverlay() {
-    if (!toValue(enabled)) {
-      return;
-    }
-    const shouldLockScroll = toValue(lockScrollOnVisible);
-    if (shouldLockScroll && !isLockedScroll) {
-      lockScroll();
-      isLockedScroll = true;
-    }
-    const idx = overlayStack.findIndex((item) => item.id === overlayId);
-    if (idx !== -1) {
-      overlayStack.splice(idx, 1);
-    }
-    overlayStack.push({
-      id: overlayId,
-      onPressEscape
-    });
-    ensureKeydownListener();
-  }
-  function unregisterOverlay() {
-    const idx = overlayStack.findIndex((item) => item.id === overlayId);
-    if (idx !== -1) {
-      overlayStack.splice(idx, 1);
-    }
-    if (isLockedScroll) {
-      unlockScroll();
-      isLockedScroll = false;
-    }
-    removeKeydownListener();
-  }
-  onScopeDispose(() => {
-    unregisterOverlay();
-  });
-  return {
-    isTopOverlay,
-    registerOverlay,
-    unregisterOverlay
-  };
-}

package/dist/composables/use-swipe-gesture.d.ts

@@ -1,65 +0,0 @@
-import type { MaybeElementRef } from '../types/shared';
-import type { MaybeRefOrGetter } from 'vue';
-export type SwipeDirection = 'left' | 'right' | 'top' | 'bottom';
-export interface SwipePressState {
-    size: number;
-}
-export interface SwipeFollowState {
-    /** Movement since the previous event along the active axis (px). */
-    delta: number;
-    /** Velocity (px / ms) since the previous event along the active axis. */
-    velocity: number;
-    /** `displacement / containerSize` — signed ratio, typically in the range of -1 to 1. */
-    offset: number;
-    /** Signed displacement from the start point along the active axis (px). */
-    displacement: number;
-}
-export interface SwipeReleaseState {
-    /** Whether the gesture qualified as a successful swipe (by velocity or distance). */
-    swiped: boolean;
-    /** Physical swipe direction. `undefined` when `swiped` is `false`. */
-    direction?: SwipeDirection;
-}
-export interface SwipeGestureOptions {
-    disabled?: MaybeRefOrGetter<boolean>;
-    /**
-     * CSS selector for the drag handle element within the container.
-     * When set, gesture events bind to this element instead of the container,
-     * preventing interference with scrollable content inside the container.
-     */
-    handleSelector?: string;
-    /**
-     * Swipe axis. Reactive — accepts a ref or getter.
-     * @default 'horizontal'
-     */
-    direction?: MaybeRefOrGetter<'horizontal' | 'vertical'>;
-    /**
-     * Minimum swipe distance (px) for a successful swipe.
-     * @default 10
-     */
-    swipeThreshold?: number;
-    /**
-     * Fraction of the container size (0–1) the finger must travel
-     * for a slow-drag to count as a successful swipe.
-     * @default 0.35
-     */
-    distanceThreshold?: number;
-    /**
-     * Minimum velocity (px / ms) for a quick-flick to count as a swipe,
-     * regardless of distance traveled.
-     * @default 0.3
-     */
-    velocityThreshold?: number;
-    /** Fires when the pointer touches down and the gesture begins. */
-    onPress?: (state: SwipePressState) => void;
-    /** Fires continuously while the pointer moves. */
-    onFollow?: (state: SwipeFollowState) => void;
-    /**
-     * Fires on pointer-up or pointer-cancel.
-     * Check `state.swiped` to decide whether to commit the transition or snap back.
-     */
-    onRelease?: (state: SwipeReleaseState) => void;
-}
-export declare function useSwipeGesture(containerRef: MaybeElementRef<HTMLElement>, options?: SwipeGestureOptions): {
-    stop: () => void;
-};