pxd 0.0.64 → 0.1.3

package/dist/utils/fuzzy-match.js

@@ -0,0 +1,182 @@
+const whitespacePattern = /\s/;
+const whitespaceReplacePattern = /\s+/g;
+let cachedSearch = null;
+let cachedPreparedSearch = null;
+const HAYSTACK_CACHE_MAX = 4096;
+const HAYSTACK_CACHE_MAX_LENGTH = 128;
+const haystackCache = /* @__PURE__ */ new Map();
+function getPreparedHaystack(text) {
+  const cached = haystackCache.get(text);
+  if (cached) {
+    return cached;
+  }
+  const lower = text.toLowerCase();
+  const prepared = {
+    lower,
+    compact: whitespacePattern.test(lower) ? lower.replace(whitespaceReplacePattern, "") : lower
+  };
+  if (text.length <= HAYSTACK_CACHE_MAX_LENGTH) {
+    if (haystackCache.size >= HAYSTACK_CACHE_MAX) {
+      haystackCache.clear();
+    }
+    haystackCache.set(text, prepared);
+  }
+  return prepared;
+}
+export function isFuzzyMatch(text, search, keywords) {
+  if (!search) {
+    return true;
+  }
+  const { needle, compactNeedle } = prepareSearch(search);
+  if (!needle) {
+    return true;
+  }
+  if (text && matchesOne(getPreparedHaystack(text), needle, compactNeedle)) {
+    return true;
+  }
+  if (keywords && keywords.length > 0) {
+    for (const kw of keywords) {
+      if (kw && matchesOne(getPreparedHaystack(kw), needle, compactNeedle)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+export function getFuzzyMatchScore(text, search, keywords) {
+  if (!search) {
+    return 0;
+  }
+  const { needle, compactNeedle } = prepareSearch(search);
+  if (!needle) {
+    return 0;
+  }
+  let score = getMatchScore(getPreparedHaystack(text), needle, compactNeedle);
+  if (score === 1e3) {
+    return score;
+  }
+  if (keywords && keywords.length > 0) {
+    for (const keyword of keywords) {
+      score = Math.max(score, getMatchScore(getPreparedHaystack(keyword), needle, compactNeedle));
+      if (score === 1e3) {
+        return score;
+      }
+    }
+  }
+  return score;
+}
+function scoreBase(haystack, needle) {
+  if (!haystack) {
+    return 0;
+  }
+  if (haystack === needle) {
+    return 1e3;
+  }
+  const contiguousIndex = haystack.indexOf(needle);
+  if (contiguousIndex !== -1) {
+    return getContiguousMatchScore(haystack, needle, contiguousIndex);
+  }
+  const subsequence = getSubsequenceMatch(haystack, needle);
+  if (subsequence) {
+    return getSubsequenceMatchScore(haystack, needle, subsequence);
+  }
+  return 0;
+}
+function getMatchScore(prepared, needle, compactNeedle) {
+  const score = scoreBase(prepared.lower, needle);
+  if (score > 0 || prepared.compact === prepared.lower && compactNeedle === needle) {
+    return score;
+  }
+  return scoreBase(prepared.compact, compactNeedle);
+}
+function matchesBase(haystack, needle) {
+  if (!haystack) {
+    return false;
+  }
+  if (haystack === needle) {
+    return true;
+  }
+  if (haystack.startsWith(needle)) {
+    return true;
+  }
+  if (haystack.includes(needle)) {
+    return true;
+  }
+  return hasFuzzySubsequenceMatch(haystack, needle);
+}
+function matchesOne(prepared, needle, compactNeedle) {
+  if (matchesBase(prepared.lower, needle)) {
+    return true;
+  }
+  if (prepared.compact !== prepared.lower || compactNeedle !== needle) {
+    return matchesBase(prepared.compact, compactNeedle);
+  }
+  return false;
+}
+function prepareSearch(search) {
+  if (search === cachedSearch && cachedPreparedSearch) {
+    return cachedPreparedSearch;
+  }
+  const needle = search.toLowerCase().trim();
+  const preparedSearch = {
+    needle,
+    compactNeedle: whitespacePattern.test(needle) ? needle.replace(whitespaceReplacePattern, "") : needle
+  };
+  cachedSearch = search;
+  cachedPreparedSearch = preparedSearch;
+  return preparedSearch;
+}
+function getContiguousMatchScore(haystack, needle, index) {
+  const boundaryBonus = index === 0 || /\W/.test(haystack[index - 1]) ? 30 : 0;
+  const positionBonus = (haystack.length - index) / haystack.length * 20;
+  return 700 + boundaryBonus + getLengthScore(haystack, needle) + positionBonus;
+}
+function getLengthScore(haystack, needle) {
+  return needle.length / haystack.length * 100;
+}
+function hasFuzzySubsequenceMatch(haystack, needle) {
+  let ni = 0;
+  if (needle.length > haystack.length) {
+    return false;
+  }
+  for (let hi = 0; hi < haystack.length && ni < needle.length; hi++) {
+    if (haystack[hi] === needle[ni]) {
+      ni++;
+    }
+  }
+  return ni >= needle.length;
+}
+function getSubsequenceMatchScore(haystack, needle, match) {
+  const span = match.lastIndex - match.firstIndex + 1;
+  const gapPenalty = span - needle.length;
+  const positionBonus = (haystack.length - match.firstIndex) / haystack.length * 20;
+  const continuityBonus = match.longestRun / needle.length * 100;
+  return 200 + continuityBonus + getLengthScore(haystack, needle) + positionBonus - gapPenalty * 5;
+}
+function getSubsequenceMatch(haystack, needle) {
+  if (needle.length > haystack.length) {
+    return null;
+  }
+  let needleIndex = 0;
+  let firstIndex = -1;
+  let lastIndex = -1;
+  let currentRun = 0;
+  let longestRun = 0;
+  for (let haystackIndex = 0; haystackIndex < haystack.length; haystackIndex++) {
+    if (haystack[haystackIndex] !== needle[needleIndex]) {
+      currentRun = 0;
+      continue;
+    }
+    if (firstIndex === -1) {
+      firstIndex = haystackIndex;
+    }
+    lastIndex = haystackIndex;
+    needleIndex++;
+    currentRun++;
+    longestRun = Math.max(longestRun, currentRun);
+    if (needleIndex === needle.length) {
+      return { firstIndex, lastIndex, longestRun };
+    }
+  }
+  return null;
+}

package/dist/utils/helper.d.ts

@@ -0,0 +1,17 @@
+import type { ResponsiveValue } from '../types/shared/props';
+import type { Nullable } from '../types/shared/utils';
+import type { MaybeElement } from '../types/shared/utils';
+import type { ComponentPublicInstance, MaybeRefOrGetter } from 'vue';
+export declare function getUniqueId(prefix?: string): string;
+export declare function getFallbackValue<Variants extends Record<string, any>>(variant: Nullable<string>, variants: Variants, defaultVariant?: keyof Variants): any;
+export declare function getColorByThreshold(value: number, colors: Record<string, string>): string;
+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>;
+export type UnRefElementReturn<T extends MaybeElement = MaybeElement> = T extends ComponentPublicInstance ? Exclude<MaybeElement, ComponentPublicInstance> : T | undefined;
+export declare function toValue<T>(source: MaybeRefOrGetter<T>): T;
+type PromiseWithResolvers<T> = {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+};
+export declare function withResolvers<T>(): PromiseWithResolvers<T>;
+export {};

package/dist/utils/helper.js

@@ -0,0 +1,57 @@
+import { getCurrentInstance, unref } from "vue";
+import { isNil } from "./is.js";
+let fallbackId = 0;
+const uniqueIdMap = /* @__PURE__ */ new WeakMap();
+export function getUniqueId(prefix = "") {
+  const root = getCurrentInstance()?.proxy?.$root;
+  if (!root) {
+    return `${prefix}_pid_${fallbackId++}`;
+  }
+  const id = uniqueIdMap.get(root) ?? 0;
+  uniqueIdMap.set(root, id + 1);
+  return `${prefix}_pid_${id}`;
+}
+export function getFallbackValue(variant, variants, defaultVariant = "default") {
+  return (variant ? variants[variant] : null) ?? variants[defaultVariant];
+}
+export function getColorByThreshold(value, colors) {
+  const keys = Object.keys(colors).sort((a, b) => Number(a) - Number(b));
+  const keyLength = keys.length;
+  if (keyLength === 0) {
+    return "";
+  }
+  for (let i = 0; i < keyLength; i++) {
+    if (value < Number(keys[i])) {
+      return colors[keys[Math.max(0, i - 1)]];
+    }
+  }
+  return colors[keys.at(-1)];
+}
+export function getResponsiveValue(prop, xsValue, valueSetter) {
+  const formatted = Object.assign(
+    isNil(xsValue) ? {} : { xs: xsValue },
+    typeof prop === "object" ? prop : {}
+  );
+  return Object.entries(formatted).reduce(
+    (acc, [bp, value]) => {
+      valueSetter(acc, bp, value);
+      return acc;
+    },
+    {}
+  );
+}
+export function toValue(source) {
+  return typeof source === "function" ? source() : unref(source);
+}
+export function withResolvers() {
+  if (typeof Promise.withResolvers === "function") {
+    return Promise.withResolvers();
+  }
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}

package/dist/utils/is.d.ts

@@ -1,4 +1,8 @@
 export declare const isVue3: () => boolean;
 export declare const isServer: () => boolean;
 export declare const isTouchDevice: () => boolean;
-export declare function isIOS(): boolean | "";
+export declare function isIOS(): boolean;
+export declare const isNil: (value: unknown) => value is null | undefined;
+export declare const isNotNil: <T>(value: T | null | undefined) => value is T;
+export declare const isUndefined: (value: unknown) => value is undefined;
+export declare const isNumber: (value: unknown) => value is number;

package/dist/utils/is.js

@@ -3,7 +3,15 @@ export const isVue3 = () => version.startsWith("3");
 export const isServer = () => typeof document === "undefined";
 export const isTouchDevice = () => isServer() ? false : "ontouchstart" in document;
 export function isIOS() {
-  return !isServer() && navigator?.userAgent && (/iP(?:ad|hone|od)/.test(navigator.userAgent) || // The new iPad Pro Gen3 does not identify itself as iPad, but as Macintosh.
+  if (isServer()) {
+    return false;
+  }
+  const userAgent = navigator?.userAgent || "";
+  return /iP(?:ad|hone|od)/.test(userAgent) || // The new iPad Pro Gen3 does not identify itself as iPad, but as Macintosh.
   // https://github.com/vueuse/vueuse/issues/3577
-  navigator?.maxTouchPoints > 2 && /iPad|Macintosh/.test(navigator.userAgent));
+  navigator?.maxTouchPoints > 2 && /iPad|Macintosh/.test(userAgent);
 }
+export const isNil = (value) => value == null;
+export const isNotNil = (value) => value != null;
+export const isUndefined = (value) => value === void 0;
+export const isNumber = (value) => typeof value === "number";

package/dist/utils/merge.d.ts

@@ -0,0 +1 @@
+export declare function mergeDeep<T extends object>(target: T, source: object): T;

package/dist/utils/merge.js

@@ -0,0 +1,19 @@
+import { isUndefined } from "./is.js";
+function isMergeable(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeObjects(target, source) {
+  const merged = { ...target };
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    if (isUndefined(sourceValue)) {
+      continue;
+    }
+    const targetValue = merged[key];
+    merged[key] = isMergeable(targetValue) && isMergeable(sourceValue) ? mergeObjects(targetValue, sourceValue) : sourceValue;
+  }
+  return merged;
+}
+export function mergeDeep(target, source) {
+  return mergeObjects(target, source);
+}

package/dist/utils/timing.d.ts

@@ -1,8 +1,21 @@
-import type { Callback } from '../types/shared';
-export { debounce } from 'es-toolkit/function';
-export { throttle } from 'es-toolkit/function';
-interface ThrottleByRafReturnType<T extends Callback> {
-    (...args: Parameters<T>): void;
+export interface DebounceOptions {
+    signal?: AbortSignal;
+    edges?: Array<'leading' | 'trailing'>;
+}
+export interface DebouncedFunction<F extends (...args: any[]) => void> {
+    (...args: Parameters<F>): void;
+    schedule: () => void;
+    cancel: () => void;
+    flush: () => void;
+}
+export interface ThrottleOptions {
+    signal?: AbortSignal;
+    edges?: Array<'leading' | 'trailing'>;
+}
+export interface ThrottledFunction<F extends (...args: any[]) => void> {
+    (...args: Parameters<F>): void;
     cancel: () => void;
+    flush: () => void;
 }
-export declare function throttleByRaf<T extends Callback>(callback: T): ThrottleByRafReturnType<T>;
+export declare function debounce<F extends (...args: any[]) => void>(func: F, debounceMs: number, { signal, edges }?: DebounceOptions): DebouncedFunction<F>;
+export declare function throttle<F extends (...args: any[]) => void>(func: F, throttleMs: number, { signal, edges }?: ThrottleOptions): ThrottledFunction<F>;

package/dist/utils/timing.js

@@ -1,22 +1,80 @@
-import { raf, caf } from "./event.js";
-export { debounce } from "es-toolkit/function";
-export { throttle } from "es-toolkit/function";
-export function throttleByRaf(callback) {
-  let animationFrameId = 0;
-  const throttle2 = (...args) => {
-    if (animationFrameId) {
+export function debounce(func, debounceMs, { signal, edges } = {}) {
+  let pendingInvoke = null;
+  let timeoutId = null;
+  const leading = edges?.includes("leading") ?? false;
+  const trailing = edges?.includes("trailing") ?? true;
+  const invoke = () => {
+    if (!pendingInvoke) {
       return;
     }
-    animationFrameId = raf(() => {
-      animationFrameId = 0;
-      callback(...args);
-    });
+    pendingInvoke();
+    pendingInvoke = null;
   };
-  throttle2.cancel = () => {
-    if (animationFrameId) {
-      caf(animationFrameId);
-      animationFrameId = 0;
+  const cancelTimer = () => {
+    if (timeoutId === null) {
+      return;
+    }
+    clearTimeout(timeoutId);
+    timeoutId = null;
+  };
+  const cancel = () => {
+    cancelTimer();
+    pendingInvoke = null;
+  };
+  const schedule = () => {
+    cancelTimer();
+    timeoutId = setTimeout(() => {
+      timeoutId = null;
+      if (trailing) {
+        invoke();
+      }
+      cancel();
+    }, debounceMs);
+  };
+  const debounced = function(...args) {
+    if (signal?.aborted) {
+      return;
+    }
+    pendingInvoke = () => func.apply(this, args);
+    const isFirstCall = !timeoutId;
+    schedule();
+    if (leading && isFirstCall) {
+      invoke();
+    }
+  };
+  debounced.schedule = schedule;
+  debounced.cancel = cancel;
+  debounced.flush = invoke;
+  signal?.addEventListener("abort", cancel, { once: true });
+  return debounced;
+}
+export function throttle(func, throttleMs, { signal, edges = ["leading", "trailing"] } = {}) {
+  let pendingAt = null;
+  const debounced = debounce(
+    function(...args) {
+      pendingAt = Date.now();
+      func.apply(this, args);
+    },
+    throttleMs,
+    { signal, edges }
+  );
+  const throttled = function(...args) {
+    if (signal?.aborted) {
+      return;
+    }
+    if (pendingAt === null) {
+      pendingAt = Date.now();
+    }
+    if (Date.now() - pendingAt >= throttleMs) {
+      pendingAt = Date.now();
+      func.apply(this, args);
+      debounced.cancel();
+      debounced.schedule();
+      return;
     }
+    debounced.apply(this, args);
   };
-  return throttle2;
+  throttled.cancel = debounced.cancel;
+  throttled.flush = debounced.flush;
+  return throttled;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "pxd",
-  "version": "0.0.64",
-  "description": "A Vue 2.7 & 3.2 universal component library. Built-in light/dark theme. PC & mobile ready. Animation-free mode supported.",
+  "version": "0.1.3",
+  "description": "A universal Vue 2.7 & 3.2 component library built from one codebase. Built-in light/dark theme. PC & mobile ready. Animation-free mode supported.",
   "keywords": [
     "component-library",
     "dark-mode",
@@ -25,27 +25,22 @@
     "type": "git",
     "url": "git+https://github.com/libondev/pxd.git"
   },
-  "style": "./dist/styles/index.css",
+  "style": "./dist/styles/styles.css",
   "files": [
     "dist",
     "volar.d.ts"
   ],
   "type": "module",
-  "sideEffects": false,
+  "sideEffects": [
+    "**/*.css"
+  ],
   "main": "./dist/index.js",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "typesVersions": {
-    "*": {
-      "*": [
-        "*",
-        "dist/*",
-        "dist/*.d.ts",
-        "dist/*/index.d.ts"
-      ]
-    }
-  },
   "exports": {
+    "./volar": "./volar.d.ts",
+    "./tw.css": "./dist/styles/tw.css",
+    "./styles.css": "./dist/styles/styles.css",
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
@@ -66,13 +61,6 @@
       "types": "./dist/locales/index.d.ts",
       "default": "./dist/locales/index.js"
     },
-    "./utils": {
-      "types": "./dist/utils/index.d.ts",
-      "default": "./dist/utils/index.js"
-    },
-    "./volar": "./volar.d.ts",
-    "./tw.css": "./dist/styles/tw.css",
-    "./styles.css": "./dist/styles/styles.css",
     "./components/*": {
       "types": "./dist/components/*/index.d.vue.ts",
       "default": "./dist/components/*/index.vue"
@@ -89,73 +77,72 @@
       "types": "./dist/locales/*.d.ts",
       "default": "./dist/locales/*.js"
     },
-    "./types/*": "./dist/types/*.d.ts",
     "./utils/*": {
       "types": "./dist/utils/*.d.ts",
       "default": "./dist/utils/*.js"
     }
   },
   "dependencies": {
-    "@chenglou/pretext": "^0.0.6",
-    "@floating-ui/dom": "^1.7.6",
+    "@chenglou/pretext": "^0.0.9",
+    "@floating-ui/dom": "^1.8.0",
     "@gdsicon/vue": "^1.0.9",
-    "@tanstack/virtual-core": "^3.14.0",
-    "dayjs": "^1.11.20",
-    "es-toolkit": "^1.46.1",
-    "focus-trap": "^8.1.0",
-    "tailwind-merge": "^3.5.0",
-    "tailwind-variants": "^3.2.2"
+    "@tanstack/virtual-core": "^3.19.4",
+    "cn": "^0.4.0",
+    "dayjs": "^1.11.23",
+    "focus-trap": "^8.2.3"
   },
   "devDependencies": {
-    "@tailwindcss/cli": "^4.2.4",
-    "@tsconfig/node22": "^22.0.5",
-    "@types/node": "^25.6.0",
-    "@vitejs/plugin-vue": "^6.0.6",
-    "@vue/test-utils": "^2.4.10",
+    "@tailwindcss/cli": "^4.3.3",
+    "@tsconfig/node22": "^22.0.6",
+    "@types/node": "^26.6.5",
+    "@vitejs/plugin-vue": "^6.0.10",
+    "@vue/test-utils": "^2.5.1",
     "@vue/tsconfig": "^0.9.1",
-    "eslint-plugin-better-tailwindcss": "^4.5.0",
-    "fs-extra": "^11.3.4",
-    "happy-dom": "^20.9.0",
+    "eslint-plugin-better-tailwindcss": "^4.9.1",
+    "happy-dom": "^20.14.6",
     "mkdist": "^2.4.1",
-    "npm-run-all2": "^8.0.4",
-    "tinyglobby": "^0.2.16",
+    "npm-run-all2": "^9.0.3",
+    "tslib": "^2.8.1",
     "typescript": "^6.0.3",
     "unbuild": "^3.6.1",
-    "unplugin-vue-components": "^32.0.0",
-    "vite-plus": "latest",
-    "vue": "^3.5.33",
-    "vue-sfc-transformer": "^0.1.17",
-    "vue-tsc": "^3.2.7"
+    "unplugin-vue-components": "^32.1.0",
+    "vite-plus": "^1.2.0",
+    "vue": "^3.5.44",
+    "vue-router": "4.6.4",
+    "vue-sfc-transformer": "^0.3.0",
+    "vue-tsc": "^3.3.13"
   },
   "peerDependencies": {
-    "vue": ">=2.7.0 || >=3.2.0"
+    "vue": ">=2.7.0 <3.0.0 || >=3.2.0",
+    "vue-router": ">=3.5.0"
+  },
+  "peerDependenciesMeta": {
+    "vue-router": {
+      "optional": true
+    }
   },
   "scripts": {
     "dev": "run-s dev:lib dev:docs",
     "dev:lib": "unbuild --stub",
     "dev:docs": "pnpm --filter docs dev",
-    "build": "run-s update-exports build:core build:docs",
+    "build": "run-s build:lib build:docs",
     "build:lib": "run-s update-exports build:core build:style",
-    "build:core": "mkdist -d --src=src --ext=js --format=esm",
     "build:only": "run-s build:core build:docs",
+    "build:core": "node scripts/build-core.js",
+    "build:style": "node scripts/gen-css-files.js",
     "build:docs": "pnpm --filter docs build",
-    "build:style": "run-s gen-styles-file gen-tw-css-file",
     "update-exports": "node scripts/update-exports.js",
-    "gen-styles-file": "node scripts/gen-css-files.js",
-    "gen-tw-css-file": "tailwindcss -i ./dist/styles/source.css -o ./dist/styles/styles.css -m",
-    "gen-volar-dts": "node scripts/gen-component-dts.js",
-    "lint": "git diff --staged --name-only --diff-filter=ACMR| xargs -r vp lint",
-    "lint:all": "vp lint",
-    "lint:changed": "git diff --name-only --relative --diff-filter=ACMR origin/main ... HEAD | xargs -r vp lint",
-    "lint:fix": "vp lint --fix",
-    "fmt": "git diff --staged --name-only --diff-filter=ACMR| xargs -r vp fmt",
-    "fmt:all": "vp fmt",
-    "fmt:changed": "git diff --name-only --relative --diff-filter=ACMR origin/main ... HEAD | xargs -r vp fmt",
-    "fmt:check": "vp fmt --check",
+    "lint": "vp lint",
+    "lint:fix": "vp lint --fix && node scripts/lint/fmt-file-eol.js",
+    "fmt": "vp fmt",
+    "fmt:all": "run-s fmt fmt:eol",
+    "fmt:eol": "node scripts/lint/fmt-file-eol.js",
+    "check:fmt": "vp fmt --check",
+    "check:type": "vp run typecheck",
     "test": "vp test run",
     "test:watch": "vp test",
-    "bump": "pnpx bumpp",
     "preview": "pnpm --filter docs preview",
-    "postversion": "vp run gen-volar-dts && vp run update-exports"
+    "bump": "pnpx bumpp",
+    "postversion": "pnpm update-exports"
   }
 }