pxd 0.0.39 → 0.0.41

package/dist/utils/debounce/index.d.ts

@@ -0,0 +1,73 @@
+interface DebounceOptions {
+    /**
+     * An optional AbortSignal to cancel the debounced function.
+     */
+    signal?: AbortSignal;
+    /**
+     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
+     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
+     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
+     * @default ["trailing"]
+     */
+    edges?: Array<'leading' | 'trailing'>;
+}
+export interface DebouncedFunction<F extends (...args: any[]) => void> {
+    (...args: Parameters<F>): void;
+    /**
+     * Schedules the execution of the debounced function after the specified debounce delay.
+     * This method resets any existing timer, ensuring that the function is only invoked
+     * after the delay has elapsed since the last call to the debounced function.
+     * It is typically called internally whenever the debounced function is invoked.
+     *
+     * @returns {void}
+     */
+    schedule: () => void;
+    /**
+     * Cancels any pending execution of the debounced function.
+     * This method clears the active timer and resets any stored context or arguments.
+     */
+    cancel: () => void;
+    /**
+     * Immediately invokes the debounced function if there is a pending execution.
+     * This method executes the function right away if there is a pending execution.
+     */
+    flush: () => void;
+}
+/**
+ * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
+ * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
+ * method to cancel any pending execution.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to debounce.
+ * @param {number} debounceMs - The number of milliseconds to delay.
+ * @param {DebounceOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
+ * @returns A new debounced function with a `cancel` method.
+ *
+ * @example
+ * const debouncedFunction = debounce(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' after 1 second if not called again in that time
+ * debouncedFunction();
+ *
+ * // Will not log anything as the previous call is canceled
+ * debouncedFunction.cancel();
+ *
+ * // With AbortSignal
+ * const controller = new AbortController();
+ * const signal = controller.signal;
+ * const debouncedWithSignal = debounce(() => {
+ *  console.log('Function executed');
+ * }, 1000, { signal });
+ *
+ * debouncedWithSignal();
+ *
+ * // Will cancel the debounced function call
+ * controller.abort();
+ */
+export declare function debounce<F extends (...args: any[]) => void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction<F>;
+export {};

package/dist/utils/debounce/index.js

@@ -0,0 +1,60 @@
+export function debounce(func, debounceMs, { signal, edges } = {}) {
+  let pendingThis;
+  let pendingArgs = null;
+  let timeoutId = null;
+  const leading = edges != null && edges.includes("leading");
+  const trailing = edges == null || edges.includes("trailing");
+  const invoke = () => {
+    if (pendingArgs !== null) {
+      func.apply(pendingThis, pendingArgs);
+      pendingThis = void 0;
+      pendingArgs = null;
+    }
+  };
+  const cancelTimer = () => {
+    if (timeoutId !== null) {
+      clearTimeout(timeoutId);
+      timeoutId = null;
+    }
+  };
+  const cancel = () => {
+    cancelTimer();
+    pendingThis = void 0;
+    pendingArgs = null;
+  };
+  const onTimerEnd = () => {
+    if (trailing) {
+      invoke();
+    }
+    cancel();
+  };
+  const schedule = () => {
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      onTimerEnd();
+    }, debounceMs);
+  };
+  const flush = () => {
+    invoke();
+  };
+  const debounced = function(...args) {
+    if (signal?.aborted) {
+      return;
+    }
+    pendingThis = this;
+    pendingArgs = args;
+    const isFirstCall = timeoutId == null;
+    schedule();
+    if (leading && isFirstCall) {
+      invoke();
+    }
+  };
+  debounced.schedule = schedule;
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  signal?.addEventListener("abort", cancel, { once: true });
+  return debounced;
+}

package/dist/utils/debounce.d.ts

@@ -1,73 +1 @@
-interface DebounceOptions {
-    /**
-     * An optional AbortSignal to cancel the debounced function.
-     */
-    signal?: AbortSignal;
-    /**
-     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
-     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
-     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
-     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
-     * @default ["trailing"]
-     */
-    edges?: Array<'leading' | 'trailing'>;
-}
-export interface DebouncedFunction<F extends (...args: any[]) => void> {
-    (...args: Parameters<F>): void;
-    /**
-     * Schedules the execution of the debounced function after the specified debounce delay.
-     * This method resets any existing timer, ensuring that the function is only invoked
-     * after the delay has elapsed since the last call to the debounced function.
-     * It is typically called internally whenever the debounced function is invoked.
-     *
-     * @returns {void}
-     */
-    schedule: () => void;
-    /**
-     * Cancels any pending execution of the debounced function.
-     * This method clears the active timer and resets any stored context or arguments.
-     */
-    cancel: () => void;
-    /**
-     * Immediately invokes the debounced function if there is a pending execution.
-     * This method executes the function right away if there is a pending execution.
-     */
-    flush: () => void;
-}
-/**
- * Creates a debounced function that delays invoking the provided function until after `debounceMs` milliseconds
- * have elapsed since the last time the debounced function was invoked. The debounced function also has a `cancel`
- * method to cancel any pending execution.
- *
- * @template F - The type of function.
- * @param {F} func - The function to debounce.
- * @param {number} debounceMs - The number of milliseconds to delay.
- * @param {DebounceOptions} options - The options object
- * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the debounced function.
- * @returns A new debounced function with a `cancel` method.
- *
- * @example
- * const debouncedFunction = debounce(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' after 1 second if not called again in that time
- * debouncedFunction();
- *
- * // Will not log anything as the previous call is canceled
- * debouncedFunction.cancel();
- *
- * // With AbortSignal
- * const controller = new AbortController();
- * const signal = controller.signal;
- * const debouncedWithSignal = debounce(() => {
- *  console.log('Function executed');
- * }, 1000, { signal });
- *
- * debouncedWithSignal();
- *
- * // Will cancel the debounced function call
- * controller.abort();
- */
-export declare function debounce<F extends (...args: any[]) => void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction<F>;
-export {};
+export * from './debounce/index';

package/dist/utils/debounce.js

@@ -1,60 +1 @@
-export function debounce(func, debounceMs, { signal, edges } = {}) {
-  let pendingThis;
-  let pendingArgs = null;
-  let timeoutId = null;
-  const leading = edges != null && edges.includes("leading");
-  const trailing = edges == null || edges.includes("trailing");
-  const invoke = () => {
-    if (pendingArgs !== null) {
-      func.apply(pendingThis, pendingArgs);
-      pendingThis = void 0;
-      pendingArgs = null;
-    }
-  };
-  const cancelTimer = () => {
-    if (timeoutId !== null) {
-      clearTimeout(timeoutId);
-      timeoutId = null;
-    }
-  };
-  const cancel = () => {
-    cancelTimer();
-    pendingThis = void 0;
-    pendingArgs = null;
-  };
-  const onTimerEnd = () => {
-    if (trailing) {
-      invoke();
-    }
-    cancel();
-  };
-  const schedule = () => {
-    if (timeoutId != null) {
-      clearTimeout(timeoutId);
-    }
-    timeoutId = setTimeout(() => {
-      timeoutId = null;
-      onTimerEnd();
-    }, debounceMs);
-  };
-  const flush = () => {
-    invoke();
-  };
-  const debounced = function(...args) {
-    if (signal?.aborted) {
-      return;
-    }
-    pendingThis = this;
-    pendingArgs = args;
-    const isFirstCall = timeoutId == null;
-    schedule();
-    if (leading && isFirstCall) {
-      invoke();
-    }
-  };
-  debounced.schedule = schedule;
-  debounced.cancel = cancel;
-  debounced.flush = flush;
-  signal?.addEventListener("abort", cancel, { once: true });
-  return debounced;
-}
+export * from "./debounce/index.js";

package/dist/utils/event.d.ts

@@ -0,0 +1,9 @@
+import type { Nullable } from '../types/shared';
+type EventHandler<E extends Event = Event> = (event: E) => void;
+export declare function on<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): () => void;
+export declare function off<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
+export declare function once<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
+export declare function optimizedOn<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
+export declare function optimizedOff<E extends Event = Event>(el: Nullable<EventTarget>, event: string, handler: EventHandler<E>, options?: AddEventListenerOptions): void;
+export declare function sleep(ms: number): Promise<unknown>;
+export {};

package/dist/utils/{events.js → event.js}

@@ -69,3 +69,6 @@ export function optimizedOff(el, event, handler, options) {
     delete el[`__cached_${event}`];
   }
 }
+export function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/utils/format.d.ts

@@ -7,7 +7,10 @@ export declare function camelize(str: string): string;
 export declare function pascalize(text: string): string;
 /** KababCase -> kabab-case */
 export declare function uncapitalize(text: string): string;
-export declare function isTruthyProp(value: unknown): unknown;
+/** 'kabab-case' -> 'Kabab Case' */
+export declare function humanize(text: string): string;
+export declare function isTruthyProp(value: unknown): {};
+export declare function clampValue(n: number, min: number, max: number): number;
 export declare function isExternalLink(href: string): boolean;
 export declare function toArray(value: unknown | unknown[]): any[];
 export declare function getCssUnitValue(value: Nullable<CSSValue | string>, fallbackValue?: string): string;

package/dist/utils/format.js

@@ -12,9 +12,15 @@ export function pascalize(text) {
 export function uncapitalize(text) {
   return text.charAt(0).toLowerCase() + text.slice(1).replace(/([A-Z])/g, "-$1").toLowerCase();
 }
+export function humanize(text) {
+  return text.replace(/-/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+}
 export function isTruthyProp(value) {
   return value || value === "";
 }
+export function clampValue(n, min, max) {
+  return min != null && max != null ? Math.min(Math.max(n, min), max) : n;
+}
 export function isExternalLink(href) {
   const firstChar = href.slice(0, 1);
   if (["#", "/"].includes(firstChar)) {

package/dist/utils/ref.d.ts

@@ -1,8 +1,5 @@
-import type { ComponentPublicInstance, MaybeRef, MaybeRefOrGetter } from 'vue';
-import type { Nullable } from '../types/shared/utils';
-export type MaybeElement = Nullable<HTMLElement | SVGElement | ComponentPublicInstance>;
-export type MaybeElementRef<T extends MaybeElement = MaybeElement> = MaybeRef<T>;
-export type MaybeComputedElementRef<T extends MaybeElement = MaybeElement> = MaybeRefOrGetter<T>;
+import type { ComponentPublicInstance, MaybeRefOrGetter } from 'vue';
+import type { MaybeElement } from '../types/shared/utils';
 export type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends ComponentPublicInstance ? Exclude<MaybeElement, ComponentPublicInstance> : T | undefined;
 export declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
 export declare function unrefElement<T extends MaybeElement>(elRef: MaybeRefOrGetter<T>): UnRefElementReturn<T>;

package/dist/utils/regexp.d.ts

@@ -2,3 +2,7 @@ export declare const INTEGER_REGEX: RegExp;
 export declare const FLOATING_REGEX: RegExp;
 export declare const POSITIVE_INTEGER_REGEX: RegExp;
 export declare const SCIENCE_NUMERIC_REGEX: RegExp;
+export declare const DATE_REGEX: RegExp;
+export declare const TIME_REGEX: RegExp;
+export declare const DATE_TIME_REGEX: RegExp;
+export declare const TIME_REGEX_WITH_MILLISECONDS: RegExp;

package/dist/utils/regexp.js

@@ -2,3 +2,7 @@ export const INTEGER_REGEX = /^-?\d+$/;
 export const FLOATING_REGEX = /^-?\d+\.?\d*/;
 export const POSITIVE_INTEGER_REGEX = /^\d+$/;
 export const SCIENCE_NUMERIC_REGEX = /^-?\d+(?:\.\d*)?(e-?\d+)?$/i;
+export const DATE_REGEX = /^(\d{4})-(\d{2})-(\d{2})$/;
+export const TIME_REGEX = /^(\d{2}):(\d{2}):(\d{2})$/;
+export const DATE_TIME_REGEX = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/;
+export const TIME_REGEX_WITH_MILLISECONDS = /^(\d{2}):(\d{2}):(\d{2})\.(\d{1,3})$/;

package/dist/utils/responsive.d.ts

@@ -1,2 +1,3 @@
 import type { ResponsiveValue } from '../types/shared/props';
-export declare function getResponsiveValue<V extends string | number>(prop: ResponsiveValue<V> | undefined, xsValue: V, valueSetter: (acc: Record<string, V>, bp: any, v: V) => void): Record<string, V>;
+import type { Nullable } from '../types/shared/utils';
+export declare function getResponsiveValue<V extends string | number>(prop: ResponsiveValue<V> | undefined, xsValue: Nullable<V>, valueSetter: (acc: Record<string, V>, bp: any, v: V) => void): Record<string, V>;

package/dist/utils/responsive.js

@@ -1,5 +1,8 @@
 export function getResponsiveValue(prop, xsValue, valueSetter) {
-  const formatted = Object.assign({ xs: xsValue }, typeof prop === "object" ? prop : {});
+  const formatted = Object.assign(
+    xsValue ? { xs: xsValue } : {},
+    typeof prop === "object" ? prop : {}
+  );
   return Object.entries(formatted).reduce((acc, [bp, value]) => {
     valueSetter(acc, bp, value);
     return acc;

package/dist/utils/throttle/compat.d.ts

@@ -0,0 +1,79 @@
+import type { DebouncedFunc, DebouncedFuncLeading } from '../debounce/compat';
+interface ThrottleSettings {
+    /**
+     * If `true`, the function will be invoked on the leading edge of the timeout.
+     * @default true
+     */
+    leading?: boolean | undefined;
+    /**
+     * If `true`, the function will be invoked on the trailing edge of the timeout.
+     * @default true
+     */
+    trailing?: boolean | undefined;
+}
+type ThrottleSettingsLeading = (ThrottleSettings & {
+    leading: true;
+}) | Omit<ThrottleSettings, 'leading'>;
+/**
+ * Creates a throttled function that only invokes the provided function at most once
+ * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @param {ThrottleOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function.
+ * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout.
+ * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout.
+ * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ *
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ *
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+export declare function throttle<T extends (...args: any) => any>(func: T, throttleMs?: number, options?: ThrottleSettingsLeading): DebouncedFuncLeading<T>;
+/**
+ * Creates a throttled function that only invokes the provided function at most once
+ * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @param {ThrottleOptions} options - The options object
+ * @param {AbortSignal} options.signal - An optional AbortSignal to cancel the throttled function.
+ * @param {boolean} options.leading - If `true`, the function will be invoked on the leading edge of the timeout.
+ * @param {boolean} options.trailing - If `true`, the function will be invoked on the trailing edge of the timeout.
+ * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ *
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ *
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+export declare function throttle<T extends (...args: any) => any>(func: T, throttleMs?: number, options?: ThrottleSettings): DebouncedFunc<T>;
+export {};

package/dist/utils/throttle/compat.js

@@ -0,0 +1,9 @@
+import { debounce } from "../debounce/compat.js";
+export function throttle(func, throttleMs = 0, options = {}) {
+  const { leading = true, trailing = true } = options;
+  return debounce(func, throttleMs, {
+    leading,
+    maxWait: throttleMs,
+    trailing
+  });
+}

package/dist/utils/throttle/index.d.ts

@@ -0,0 +1,53 @@
+import type { Callback } from '../../types/shared';
+interface ThrottleOptions {
+    /**
+     * An optional AbortSignal to cancel the debounced function.
+     */
+    signal?: AbortSignal;
+    /**
+     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
+     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
+     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
+     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
+     * @default ["leading", "trailing"]
+     */
+    edges?: Array<'leading' | 'trailing'>;
+}
+export interface ThrottledFunction<F extends (...args: any[]) => void> {
+    (...args: Parameters<F>): void;
+    cancel: () => void;
+    flush: () => void;
+}
+/**
+ * Creates a throttled function that only invokes the provided function at most once
+ * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
+ * within the wait time will not trigger the execution of the original function.
+ *
+ * @template F - The type of function.
+ * @param {F} func - The function to throttle.
+ * @param {number} throttleMs - The number of milliseconds to throttle executions to.
+ * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
+ *
+ * @example
+ * const throttledFunction = throttle(() => {
+ *   console.log('Function executed');
+ * }, 1000);
+ *
+ * // Will log 'Function executed' immediately
+ * throttledFunction();
+ *
+ * // Will not log anything as it is within the throttle time
+ * throttledFunction();
+ *
+ * // After 1 second
+ * setTimeout(() => {
+ *   throttledFunction(); // Will log 'Function executed'
+ * }, 1000);
+ */
+export declare function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction<F>;
+interface ThrottleByRafReturnType<T extends Callback> {
+    (...args: Parameters<T>): void;
+    cancel: () => void;
+}
+export declare function throttleByRaf<T extends Callback>(callback: T): ThrottleByRafReturnType<T>;
+export {};

package/dist/utils/throttle/index.js

@@ -0,0 +1,34 @@
+import { debounce } from "../debounce/index.js";
+export function throttle(func, throttleMs, { signal, edges = ["leading", "trailing"] } = {}) {
+  let pendingAt = null;
+  const debounced = debounce(func, throttleMs, { signal, edges });
+  const throttled = function(...args) {
+    if (pendingAt == null) {
+      pendingAt = Date.now();
+    } else {
+      if (Date.now() - pendingAt >= throttleMs) {
+        pendingAt = Date.now();
+        debounced.cancel();
+      }
+    }
+    debounced(...args);
+  };
+  throttled.cancel = debounced.cancel;
+  throttled.flush = debounced.flush;
+  return throttled;
+}
+export function throttleByRaf(callback) {
+  let timer;
+  const throttle2 = (...args) => {
+    timer && window.cancelAnimationFrame(timer);
+    timer = window.requestAnimationFrame(() => {
+      callback(...args);
+      timer = 0;
+    });
+  };
+  throttle2.cancel = () => {
+    window.cancelAnimationFrame(timer);
+    timer = 0;
+  };
+  return throttle2;
+}

package/dist/utils/throttle.d.ts

@@ -1,53 +1 @@
-import type { Callback } from '../types/shared';
-interface ThrottleOptions {
-    /**
-     * An optional AbortSignal to cancel the debounced function.
-     */
-    signal?: AbortSignal;
-    /**
-     * An optional array specifying whether the function should be invoked on the leading edge, trailing edge, or both.
-     * If `edges` includes "leading", the function will be invoked at the start of the delay period.
-     * If `edges` includes "trailing", the function will be invoked at the end of the delay period.
-     * If both "leading" and "trailing" are included, the function will be invoked at both the start and end of the delay period.
-     * @default ["leading", "trailing"]
-     */
-    edges?: Array<'leading' | 'trailing'>;
-}
-export interface ThrottledFunction<F extends (...args: any[]) => void> {
-    (...args: Parameters<F>): void;
-    cancel: () => void;
-    flush: () => void;
-}
-/**
- * Creates a throttled function that only invokes the provided function at most once
- * per every `throttleMs` milliseconds. Subsequent calls to the throttled function
- * within the wait time will not trigger the execution of the original function.
- *
- * @template F - The type of function.
- * @param {F} func - The function to throttle.
- * @param {number} throttleMs - The number of milliseconds to throttle executions to.
- * @returns {(...args: Parameters<F>) => void} A new throttled function that accepts the same parameters as the original function.
- *
- * @example
- * const throttledFunction = throttle(() => {
- *   console.log('Function executed');
- * }, 1000);
- *
- * // Will log 'Function executed' immediately
- * throttledFunction();
- *
- * // Will not log anything as it is within the throttle time
- * throttledFunction();
- *
- * // After 1 second
- * setTimeout(() => {
- *   throttledFunction(); // Will log 'Function executed'
- * }, 1000);
- */
-export declare function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction<F>;
-interface ThrottleByRafReturnType<T extends Callback> {
-    (...args: Parameters<T>): void;
-    cancel: () => void;
-}
-export declare function throttleByRaf<T extends Callback>(callback: T): ThrottleByRafReturnType<T>;
-export {};
+export * from './throttle/index';

package/dist/utils/throttle.js

@@ -1,34 +1 @@
-import { debounce } from "./debounce.js";
-export function throttle(func, throttleMs, { signal, edges = ["leading", "trailing"] } = {}) {
-  let pendingAt = null;
-  const debounced = debounce(func, throttleMs, { signal, edges });
-  const throttled = function(...args) {
-    if (pendingAt == null) {
-      pendingAt = Date.now();
-    } else {
-      if (Date.now() - pendingAt >= throttleMs) {
-        pendingAt = Date.now();
-        debounced.cancel();
-      }
-    }
-    debounced(...args);
-  };
-  throttled.cancel = debounced.cancel;
-  throttled.flush = debounced.flush;
-  return throttled;
-}
-export function throttleByRaf(callback) {
-  let timer;
-  const throttle2 = (...args) => {
-    timer && window.cancelAnimationFrame(timer);
-    timer = window.requestAnimationFrame(() => {
-      callback(...args);
-      timer = 0;
-    });
-  };
-  throttle2.cancel = () => {
-    window.cancelAnimationFrame(timer);
-    timer = 0;
-  };
-  return throttle2;
-}
+export * from "./throttle/index.js";

package/dist/utils/uid.js

@@ -1,4 +1,4 @@
 let _id = 0;
 export function getUniqueId() {
-  return `pxd_${_id++}`;
+  return `_pid_${_id++}`;
 }