pxd 0.0.64 → 0.1.3

package/dist/composables/use-view-transition.js

@@ -0,0 +1,80 @@
+import { nextTick } from "vue";
+import { NOOP } from "../utils/event.js";
+import { isServer } from "../utils/is.js";
+const registrations = /* @__PURE__ */ new WeakMap();
+function release(router, registration, shouldTransition) {
+  if (shouldTransition) {
+    const index = registration.shouldTransition.indexOf(shouldTransition);
+    if (index > -1) {
+      registration.shouldTransition.splice(index, 1);
+    }
+  }
+  if (--registration.count > 0) {
+    return;
+  }
+  registrations.delete(router);
+  registration.dispose();
+}
+export function useViewTransition(router, options = {}) {
+  if (isServer() || !document.startViewTransition) {
+    return NOOP;
+  }
+  const { shouldTransition } = options;
+  const registered = registrations.get(router);
+  if (registered) {
+    registered.count++;
+    if (shouldTransition) {
+      registered.shouldTransition.push(shouldTransition);
+    }
+    return () => release(router, registered, shouldTransition);
+  }
+  const registration = {
+    count: 1,
+    shouldTransition: shouldTransition ? [shouldTransition] : [],
+    dispose: NOOP
+  };
+  registrations.set(router, registration);
+  const startViewTransition = document.startViewTransition.bind(document);
+  let settle;
+  const stopBeforeResolve = router.beforeResolve((to, from) => {
+    settle?.();
+    for (const predicate of registration.shouldTransition) {
+      if (!predicate(to, from)) {
+        return;
+      }
+    }
+    let unblock;
+    let finish;
+    const blocked = new Promise((resolve) => {
+      unblock = resolve;
+    });
+    const rendered = new Promise((resolve) => {
+      finish = resolve;
+    });
+    settle = () => {
+      settle = void 0;
+      unblock();
+      void nextTick(finish);
+    };
+    const transition = startViewTransition(() => {
+      unblock();
+      return rendered;
+    });
+    void transition.ready.catch(NOOP);
+    void transition.finished.then(unblock, unblock);
+    return blocked;
+  });
+  const stopAfterEach = router.afterEach(() => {
+    settle?.();
+  });
+  const stopOnError = router.onError(() => {
+    settle?.();
+  });
+  registration.dispose = () => {
+    settle?.();
+    stopBeforeResolve();
+    stopAfterEach();
+    stopOnError();
+  };
+  return () => release(router, registration, shouldTransition);
+}

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

@@ -1,18 +1,21 @@
-import type { MaybeElementRef } from '../types/shared';
+import type { MaybeElementRef } from '../types/shared/utils';
 import type { VirtualItem } from '@tanstack/virtual-core';
-import type { ComponentPublicInstance } from 'vue';
+import type { ComponentPublicInstance, MaybeRefOrGetter } from 'vue';
 import { Virtualizer } from '@tanstack/virtual-core';
 export interface VirtualListItem extends VirtualItem {
     key: string | number;
 }
 export interface VirtualListOptions {
+    enabled?: MaybeRefOrGetter<boolean>;
     status?: 'loading' | 'finished' | 'error' | '';
     dataKey?: string;
-    listData?: any[];
+    items?: any[];
     itemSize?: number;
     overScan?: number;
     columnGap?: number;
     columnCount?: number;
+    scrollPaddingStart?: number;
+    scrollPaddingEnd?: number;
     onBottom?: () => void | Promise<void>;
     bottomThreshold?: number;
 }
@@ -20,8 +23,8 @@ export declare function useVirtualList<Options extends VirtualListOptions>(conta
     virtualItems: import("vue").ComputedRef<VirtualListItem[]>;
     totalSize: import("vue").ComputedRef<number>;
     measureElement: (el: Element | ComponentPublicInstance | null) => void;
-    scrollToIndex: (index: number, { align: initialAlign, behavior, }?: import("@tanstack/virtual-core").ScrollToOptions) => void;
-    scrollToOffset: (toOffset: number, { align, behavior }?: import("@tanstack/virtual-core").ScrollToOptions) => void;
-    scrollBy: (delta: number, { behavior }?: import("@tanstack/virtual-core").ScrollToOptions) => void;
+    scrollToIndex: (index: number, args_1?: import("@tanstack/virtual-core").ScrollToOptions | undefined) => void;
+    scrollToOffset: (toOffset: number, args_1?: import("@tanstack/virtual-core").ScrollToOptions | undefined) => void;
+    scrollBy: (delta: number, args_1?: import("@tanstack/virtual-core").ScrollToOptions | undefined) => void;
     getVirtualizer: () => Virtualizer<HTMLElement, HTMLElement>;
 };

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

@@ -5,7 +5,8 @@ import {
   Virtualizer
 } from "@tanstack/virtual-core";
 import { computed, onMounted, onScopeDispose, watch, shallowRef } from "vue";
-import { toValue } from "../utils/ref.js";
+import { toValue } from "../utils/helper.js";
+import { isNil } from "../utils/is.js";
 const DEFAULTS = {
   status: "",
   itemSize: 50,
@@ -17,32 +18,38 @@ export function useVirtualList(containerRef, options) {
   let reachBottomFired = false;
   let cleanup;
   const triggerVersion = shallowRef(0);
+  const getEnabled = () => toValue(options.enabled) !== false;
   function getItemKey(index) {
     if (options.dataKey) {
-      const item = options.listData?.[index];
+      const item = options.items?.[index];
       const key = item?.[options.dataKey];
-      if (key !== void 0 && key !== null) {
+      if (!isNil(key)) {
         return key;
       }
     }
     return index;
   }
   const virtualizer = new Virtualizer({
-    count: options.listData?.length ?? 0,
-    getScrollElement: () => toValue(containerRef) ?? null,
+    count: 0,
+    getScrollElement: () => getEnabled() ? toValue(containerRef) ?? null : null,
     estimateSize: () => options.itemSize ?? DEFAULTS.itemSize,
     getItemKey,
     overscan: options.overScan ?? DEFAULTS.overScan,
     lanes: options.columnCount ?? DEFAULTS.columnCount,
     gap: options.columnGap ?? DEFAULTS.columnGap,
+    scrollPaddingStart: options.scrollPaddingStart,
+    scrollPaddingEnd: options.scrollPaddingEnd,
     laneAssignmentMode: "measured",
     observeElementRect,
     observeElementOffset,
     scrollToFn: elementScroll,
     onChange: (instance) => {
+      if (!getEnabled()) {
+        return;
+      }
       triggerVersion.value++;
-      const { status = DEFAULTS.status, listData } = options;
-      if (status || listData?.length === 0) {
+      const { status = DEFAULTS.status, items } = options;
+      if (status || items?.length === 0) {
         return;
       }
       const { onBottom, itemSize = DEFAULTS.itemSize, bottomThreshold } = options;
@@ -68,13 +75,22 @@ export function useVirtualList(containerRef, options) {
   });
   const virtualItems = computed(() => {
     void triggerVersion.value;
+    if (!getEnabled()) {
+      return [];
+    }
     return virtualizer.getVirtualItems();
   });
   const totalSize = computed(() => {
     void triggerVersion.value;
+    if (!getEnabled()) {
+      return 0;
+    }
     return virtualizer.getTotalSize();
   });
   function measureElement(el) {
+    if (!getEnabled()) {
+      return;
+    }
     if (!el) {
       virtualizer.measureElement(null);
       return;
@@ -83,37 +99,88 @@ export function useVirtualList(containerRef, options) {
     virtualizer.measureElement(htmlEl);
   }
   function updateVirtualizer() {
+    const enabled = getEnabled();
     virtualizer.setOptions({
       ...virtualizer.options,
-      count: options.listData?.length ?? 0,
+      count: enabled ? options.items?.length ?? 0 : 0,
       estimateSize: () => options.itemSize ?? DEFAULTS.itemSize,
       getItemKey,
+      overscan: options.overScan ?? DEFAULTS.overScan,
       lanes: options.columnCount ?? DEFAULTS.columnCount,
-      gap: options.columnGap ?? DEFAULTS.columnGap
+      gap: options.columnGap ?? DEFAULTS.columnGap,
+      getScrollElement: () => enabled ? toValue(containerRef) ?? null : null
     });
+    if (enabled) {
+      virtualizer._willUpdate();
+    }
+    triggerVersion.value++;
+  }
+  function mountObservers() {
+    if (cleanup || !getEnabled()) {
+      return;
+    }
     virtualizer._willUpdate();
+    cleanup = virtualizer._didMount();
+  }
+  function unmountObservers() {
+    cleanup?.();
+    cleanup = void 0;
     triggerVersion.value++;
   }
   watch(
-    () => [options.itemSize, options.dataKey, options.columnCount, options.columnGap],
-    updateVirtualizer
+    () => [
+      getEnabled(),
+      options.itemSize,
+      options.dataKey,
+      options.columnCount,
+      options.columnGap,
+      options.overScan
+    ],
+    () => {
+      if (getEnabled()) {
+        updateVirtualizer();
+        mountObservers();
+      } else {
+        unmountObservers();
+        updateVirtualizer();
+      }
+    }
   );
-  watch(() => [options.listData, options.listData?.length], updateVirtualizer);
+  watch(() => [options.items, options.items?.length], updateVirtualizer);
   onMounted(() => {
-    virtualizer._willUpdate();
-    cleanup = virtualizer._didMount();
+    if (getEnabled()) {
+      mountObservers();
+      updateVirtualizer();
+    }
   });
   onScopeDispose(() => {
-    cleanup?.();
-    cleanup = void 0;
+    unmountObservers();
   });
+  function scrollToIndex(...args) {
+    if (!getEnabled()) {
+      return;
+    }
+    virtualizer.scrollToIndex(...args);
+  }
+  function scrollToOffset(...args) {
+    if (!getEnabled()) {
+      return;
+    }
+    virtualizer.scrollToOffset(...args);
+  }
+  function scrollBy(...args) {
+    if (!getEnabled()) {
+      return;
+    }
+    virtualizer.scrollBy(...args);
+  }
   return {
     virtualItems,
     totalSize,
     measureElement,
-    scrollToIndex: virtualizer.scrollToIndex.bind(virtualizer),
-    scrollToOffset: virtualizer.scrollToOffset.bind(virtualizer),
-    scrollBy: virtualizer.scrollBy.bind(virtualizer),
+    scrollToIndex,
+    scrollToOffset,
+    scrollBy,
     getVirtualizer: () => virtualizer
   };
 }

package/dist/constants/tooltip-variants.d.ts

@@ -0,0 +1,28 @@
+export declare const TOOLTIP_VARIANTS: {
+    invert: {
+        bg: string;
+        base: string;
+    };
+    default: {
+        bg: string;
+        base: string;
+    };
+    error: {
+        bg: string;
+        base: string;
+    };
+    warning: {
+        bg: string;
+        base: string;
+    };
+    success: {
+        bg: string;
+        base: string;
+    };
+    violet: {
+        bg: string;
+        base: string;
+    };
+};
+export declare const TOOLTIP_CONTENT_CLASS = "px-3 py-2 rounded-md text-13 break-words whitespace-pre-line bg-(--popover-arrow-color) motion-safe:transition-colors";
+export type TooltipVariant = keyof typeof TOOLTIP_VARIANTS;

package/dist/constants/tooltip-variants.js

@@ -0,0 +1,27 @@
+export const TOOLTIP_VARIANTS = {
+  invert: {
+    bg: "var(--color-background-100)",
+    base: "text-foreground border variant-invert"
+  },
+  default: {
+    bg: "var(--color-gray-1000)",
+    base: "text-gray-100"
+  },
+  error: {
+    bg: "var(--color-red-700)",
+    base: "text-gray-100 dark:text-gray-1000"
+  },
+  warning: {
+    bg: "var(--color-amber-700)",
+    base: "text-gray-1000 dark:text-gray-100"
+  },
+  success: {
+    bg: "var(--color-green-700)",
+    base: "text-gray-100 dark:text-gray-1000"
+  },
+  violet: {
+    bg: "var(--color-purple-700)",
+    base: "text-gray-100 dark:text-gray-1000"
+  }
+};
+export const TOOLTIP_CONTENT_CLASS = "px-3 py-2 rounded-md text-13 break-words whitespace-pre-line bg-(--popover-arrow-color) motion-safe:transition-colors";

package/dist/contexts/avatar.js

@@ -1,4 +1,4 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideAvatarGroupContext, useAvatarGroupContext] = createContext(
   "AvatarGroup",
   null

package/dist/contexts/breadcrumb.d.ts

@@ -0,0 +1,2 @@
+import type { BreadcrumbProps } from '../components/breadcrumb/types';
+export declare const provideBreadcrumbContext: (contextValue: BreadcrumbProps) => BreadcrumbProps, useBreadcrumbContext: ((fallback?: BreadcrumbProps | undefined) => BreadcrumbProps) & ((fallback: null) => BreadcrumbProps | null);

package/dist/contexts/breadcrumb.js

@@ -0,0 +1,2 @@
+import { createContext } from "../utils/_internal/context.js";
+export const [provideBreadcrumbContext, useBreadcrumbContext] = createContext("Breadcrumb");

package/dist/contexts/button.js

@@ -1,4 +1,4 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideButtonGroupContext, useButtonGroupContext] = createContext(
   "ButtonGroup",
   null

package/dist/contexts/checkbox.js

@@ -1,2 +1,2 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideCheckboxGroupContext, useCheckboxGroupContext] = createContext("CheckboxGroup", null);

package/dist/contexts/choicebox.d.ts

@@ -1,6 +1,7 @@
 import type { ChoiceboxEmits, ChoiceboxProps } from '../components/choicebox/types';
 import type { EmitFn } from 'vue';
 interface ChoiceboxContext {
+    name: string;
     props: ChoiceboxProps;
     emits: EmitFn<ChoiceboxEmits>;
 }

package/dist/contexts/choicebox.js

@@ -1,2 +1,2 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideChoiceboxContext, useChoiceboxContext] = createContext("ChoiceboxGroup");

package/dist/contexts/collapse.js

@@ -1,2 +1,2 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideCollapseGroupContext, useCollapseGroupContext] = createContext("CollapseGroup", null);

package/dist/contexts/config-provider.d.ts

@@ -1,5 +1,6 @@
 import type { ConfigProviderProps } from '../components/config-provider/types';
-export declare const injectionKey = "ConfigProvider";
-export interface ConfigProviderContext extends Required<ConfigProviderProps> {
+import type { Locale } from '../locales';
+export interface ConfigProviderContext extends Omit<Required<ConfigProviderProps>, 'locale'> {
+    locale: Locale;
 }
 export declare const provideConfigProvider: (contextValue: ConfigProviderContext) => ConfigProviderContext, useConfigProvider: ((fallback?: ConfigProviderContext | undefined) => ConfigProviderContext) & ((fallback: null) => ConfigProviderContext | null);

package/dist/contexts/config-provider.js

@@ -1,11 +1,12 @@
 import enUS from "../locales/en-us.js";
-import { createContext } from "../utils/context.js";
-export const injectionKey = "ConfigProvider";
+import { createContext } from "../utils/_internal/context.js";
+const configProviderKey = "ConfigProvider";
 export const [provideConfigProvider, useConfigProvider] = createContext(
-  injectionKey,
+  configProviderKey,
   {
     size: "md",
     locale: enUS,
-    popoverShowTransition: true
+    enterMotion: true,
+    leaveMotion: true
   }
 );

package/dist/contexts/list.d.ts

@@ -1,28 +1,7 @@
-import type { ListOption } from '../components/list/types';
-import type { ComputedRef, Ref } from 'vue';
+import type { ListOptionSelected } from '../components/list/types';
+import type { Ref } from 'vue';
 export interface ListContext {
-    activeIndex: Ref<number>;
-    registerItem: (el: HTMLElement, indexRef: Ref<number>) => void;
-    unregisterItem: (el: HTMLElement) => void;
-    onOptionClick: ListOption['onClick'];
+    value: Ref<unknown>;
+    onItemSelect: (value: ListOptionSelected['value']) => void;
 }
 export declare const provideListContext: (contextValue: ListContext) => ListContext, useListContext: ((fallback?: ListContext | undefined) => ListContext) & ((fallback: null) => ListContext | null);
-export interface ListFilterItemPayload {
-    groupId: string | null;
-    getValue: () => string;
-    getKeywords: () => string[];
-}
-export interface ListFilterContext {
-    searchValue: Ref<string>;
-    visibleCount: ComputedRef<number>;
-    isItemVisible: (id: string) => boolean;
-    isGroupVisible: (id: string) => boolean;
-    registerItem: (id: string, payload: ListFilterItemPayload) => void;
-    unregisterItem: (id: string) => void;
-}
-export declare const provideListFilterContext: (contextValue: ListFilterContext) => ListFilterContext, useListFilterContext: (fallback?: ListFilterContext | null | undefined) => ListFilterContext | null;
-/**
- * Provided by group containers so nested list items know which group to
- * register into.
- */
-export declare const provideListFilterGroupId: (contextValue: string) => string, useListFilterGroupId: (fallback?: string | null | undefined) => string | null;

package/dist/contexts/list.js

@@ -1,10 +1,2 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideListContext, useListContext] = createContext("List");
-export const [provideListFilterContext, useListFilterContext] = createContext(
-  "ListFilter",
-  null
-);
-export const [provideListFilterGroupId, useListFilterGroupId] = createContext(
-  "ListFilterGroupId",
-  null
-);

package/dist/contexts/radio.js

@@ -1,4 +1,4 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideRadioGroupContext, useRadioGroupContext] = createContext(
   "RadioGroup",
   null

package/dist/contexts/switch.js

@@ -1,2 +1,2 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideSwitchContext, useSwitchContext] = createContext("Switch");

package/dist/contexts/toggle-button.js

@@ -1,2 +1,2 @@
-import { createContext } from "../utils/context.js";
+import { createContext } from "../utils/_internal/context.js";
 export const [provideToggleButtonGroupContext, useToggleButtonGroupContext] = createContext("ToggleButtonGroup", null);

package/dist/index.d.ts

@@ -2,5 +2,6 @@ import type { App } from 'vue';
 export { version } from '../package.json';
 export * from './components/index.js';
 export * from './composables/index.js';
-export type * from './types/shared';
+export type * from './types/shared/props';
+export type * from './types/shared/utils';
 export default function install(app: App, prefix?: string): void;

package/dist/locales/en-us.d.ts

@@ -1,28 +1,36 @@
-declare const _default: {
+declare const enUS: {
     date: {
         now: string;
-        day: {
-            0: string;
-            1: string;
-            2: string;
-            3: string;
-            4: string;
-            5: string;
-            6: string;
-        };
-        month: {
-            0: string;
-            1: string;
-            2: string;
-            3: string;
-            4: string;
-            5: string;
-            6: string;
-            7: string;
-            8: string;
-            9: string;
-            10: string;
-            11: string;
+        today: string;
+        day: string[];
+        month: string[];
+    };
+    timeAgo: {
+        now: string;
+        invalid: string;
+        past: string;
+        future: string;
+        unit: {
+            minute: {
+                one: string;
+                other: string;
+            };
+            hour: {
+                one: string;
+                other: string;
+            };
+            day: {
+                one: string;
+                other: string;
+            };
+            month: {
+                one: string;
+                other: string;
+            };
+            year: {
+                one: string;
+                other: string;
+            };
         };
     };
     compare: {
@@ -31,14 +39,69 @@ declare const _default: {
         next: string;
         prev: string;
     };
-    confirm: {
-        ok: string;
-        conform: string;
+    interaction: {
         cancel: string;
+        close: string;
+        confirm: string;
+        skip: string;
+        submit: string;
+    };
+    questionnaire: {
+        question: string;
+        answer: string;
+        skipAll: string;
+        prev: string;
+        next: string;
+    };
+    tour: {
+        next: string;
+        prev: string;
+        done: string;
+        skip: string;
     };
     results: {
         searchText: string;
         noData: string;
     };
+    pagination: {
+        perPage: string;
+        prev: string;
+        next: string;
+    };
+    reasoning: {
+        thinking: string;
+        thought: string;
+    };
+    toolCall: {
+        pending: string;
+        running: string;
+        completed: string;
+        error: string;
+        input: string;
+        output: string;
+    };
+    approval: {
+        title: string;
+        approve: string;
+        reject: string;
+        remember: string;
+        pending: string;
+        approved: string;
+        rejected: string;
+        dismissed: string;
+    };
+    todo: {
+        title: string;
+        inProgress: string;
+        pending: string;
+        completed: string;
+        canceled: string;
+    };
+    feedback: {
+        thumbUp: string;
+        thumbDown: string;
+        close: string;
+    };
 };
-export default _default;
+export type Locale = typeof enUS;
+export default enUS;