vlite3 0.1.10 → 0.2.2

package/utils/functions.d.ts

@@ -7,3 +7,102 @@
  * @returns A new debounced function
  */
 export declare const debounce: (fn: Function, delay: number) => (...args: any[]) => void;
+export declare function getUniqueId(): string;
+export declare const isAppleDevice: () => boolean;
+export declare const downloadFile: (fileUrl?: string, fileName?: string) => Promise<void>;
+export declare const isEmpty: (value: any) => boolean;
+export declare function removeExtraProperties(data: any, propertiesToRemove: string[]): any;
+export declare function flattenArray(arr: any[]): any[];
+export declare const capitalize: (str: any) => any;
+export declare const camelCase: (str: any) => string;
+export declare function throttle<T extends (...args: any[]) => any>(func: T, wait: number): (...args: Parameters<T>) => void;
+/**
+ * Converts a string into a URL-friendly slug.
+ * Handles Unicode characters via NFD normalization, strips diacritics,
+ * collapses whitespace and special characters into single hyphens,
+ * and trims leading/trailing hyphens.
+ *
+ * @param input The string to slugify
+ * @returns A lowercase, hyphen-separated slug
+ *
+ * @example
+ * slugify('Hello World!')       // 'hello-world'
+ * slugify('Crème Brûlée')       // 'creme-brulee'
+ * slugify('  --foo  bar-- ')    // 'foo-bar'
+ */
+export declare const slugify: (input: string) => string;
+/**
+ * Generates a random integer between `min` and `max` (inclusive).
+ * Uses `Math.random()` — not suitable for cryptographic purposes.
+ *
+ * @param min The lower bound (inclusive)
+ * @param max The upper bound (inclusive)
+ * @returns A random integer in the range [min, max]
+ * @throws {TypeError} If `min` or `max` is not a finite number
+ * @throws {RangeError} If `min` is greater than `max`
+ *
+ * @example
+ * randomNumber(1, 10)  // e.g. 7
+ * randomNumber(-5, 5)  // e.g. -2
+ */
+export declare const randomNumber: (min: number, max: number) => number;
+/**
+ * Truncates text to a given length, breaking at the last word boundary
+ * to avoid mid-word cuts.
+ *
+ * @param text The string to truncate
+ * @param length Maximum character length (must be ≥ 0)
+ * @param ellipsis The suffix appended when truncated (default: `'…'`)
+ * @returns The truncated string, or the original if already within the limit
+ *
+ * @example
+ * truncate('Hello, beautiful world!', 13)         // 'Hello,…'
+ * truncate('Hello, beautiful world!', 13, '...')   // 'Hello,...'
+ * truncate('Short', 100)                           // 'Short'
+ */
+export declare const truncate: (text: string, length: number, ellipsis?: string) => string;
+/**
+ * Formats a numeric amount as a locale-aware currency string
+ * using the `Intl.NumberFormat` API.
+ *
+ * @param amount The numeric value to format
+ * @param locale A BCP 47 locale string (default: `'en-US'`)
+ * @param currency An ISO 4217 currency code (default: `'USD'`)
+ * @returns The formatted currency string
+ *
+ * @example
+ * formatCurrency(1234.5)                  // '$1,234.50'
+ * formatCurrency(1234.5, 'de-DE', 'EUR')  // '1.234,50 €'
+ * formatCurrency(0)                       // '$0.00'
+ */
+export declare const formatCurrency: (amount: number, locale?: string, currency?: string) => string;
+/**
+ * Returns a Promise that resolves after the specified number of milliseconds.
+ * Useful for artificial delays, polling intervals, or animation timing.
+ *
+ * @param ms Delay duration in milliseconds (must be ≥ 0)
+ * @returns A Promise that resolves to `void` after the delay
+ *
+ * @example
+ * await delay(1000) // waits 1 second
+ *
+ * // Sequential polling
+ * while (polling) {
+ *   const data = await fetchData()
+ *   await delay(5000)
+ * }
+ */
+export declare const delay: (ms: number) => Promise<void>;
+/**
+ * Copies the given text to the system clipboard.
+ * Uses the modern `navigator.clipboard` API when available,
+ * with a `document.execCommand('copy')` fallback for older browsers.
+ *
+ * @param text The string to copy to the clipboard
+ * @returns A Promise that resolves to `true` on success, `false` on failure
+ *
+ * @example
+ * const ok = await copyToClipboard('Hello!')
+ * if (ok) showToast('Copied!')
+ */
+export declare const copyToClipboard: (text: string) => Promise<boolean>;

package/utils/functions.js

@@ -1,11 +1,95 @@
-const r = (t, o) => {
-  let e;
-  return (...u) => {
-    clearTimeout(e), e = setTimeout(() => {
-      t(...u);
-    }, o);
+const f = (e, t) => {
+  let r;
+  return (...n) => {
+    clearTimeout(r), r = setTimeout(() => {
+      e(...n);
+    }, t);
   };
 };
+function p() {
+  const e = Math.floor(Date.now() / 1e3).toString(16).padStart(8, "0"), t = Array.from(crypto.getRandomValues(new Uint8Array(5))).map((n) => n.toString(16).padStart(2, "0")).join(""), r = Math.floor(Math.random() * 16777215).toString(16).padStart(6, "0");
+  return e + t + r;
+}
+const d = () => {
+  const e = /Mac|MacIntel|MacPPC/.test(navigator.platform) && !/iPad|iPhone|iPod/.test(navigator.platform), t = /iPhone/.test(navigator.platform) || /iPhone/.test(navigator.userAgent), r = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
+  return e || t || r;
+}, y = async (e = "", t = "file") => {
+  try {
+    const r = t || "file", n = e?.includes(".application/") ? `${r}.${e?.split("/").pop()}` : `${r}.${e?.split(".").pop()}`, i = await (await fetch(e)).blob(), a = window.URL.createObjectURL(i), c = document.createElement("a");
+    c.href = a, c.setAttribute("download", n), document.body.appendChild(c), c.click(), document.body.removeChild(c), window.URL.revokeObjectURL(a);
+  } catch (r) {
+    console.error("Download error:", r);
+  }
+}, l = (e) => e == null || e === "" || typeof e == "number" && e === 0 || Array.isArray(e) && e.length === 0 ? !0 : typeof e == "object" && !Array.isArray(e) ? Object.keys(e).length === 0 || Object.values(e).every(l) : !1;
+function s(e, t) {
+  return !e || typeof e != "object" ? e : Array.isArray(e) ? e.map((r) => s(r, t)) : Object.entries(e).reduce(
+    (r, [n, o]) => (t.includes(n) || (r[n] = s(o, t)), r),
+    {}
+  );
+}
+function u(e) {
+  return e.reduce((t, r) => Array.isArray(r) ? t.concat(u(r)) : r && typeof r == "object" ? t.concat(
+    Object?.values(r)?.flatMap?.((n) => typeof n == "object" ? u([n]) : [n])
+  ) : t.concat(r), []);
+}
+const m = (e) => typeof e == "string" ? e?.replace(/(^\w|[.!?]\s+\w)/g, (t) => t.toUpperCase()) : e, b = (e) => !e || typeof e != "string" ? "" : e[0].toLowerCase() + e.slice(1);
+function g(e, t) {
+  let r = null, n = null, o = null;
+  const i = () => {
+    n && o ? (e.apply(o, n), n = null, o = null, r = setTimeout(i, t)) : r = null;
+  };
+  return (...a) => {
+    r ? (n = a, o = this) : (e.apply(this, a), r = setTimeout(i, t));
+  };
+}
+const h = (e) => typeof e != "string" ? "" : e.normalize("NFD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9\s-]/g, "").replace(/[\s-]+/g, "-").replace(/^-+|-+$/g, ""), w = (e, t) => {
+  if (!Number.isFinite(e) || !Number.isFinite(t))
+    throw new TypeError("Both min and max must be finite numbers");
+  if (e > t)
+    throw new RangeError(`min (${e}) must not be greater than max (${t})`);
+  const r = Math.ceil(e), n = Math.floor(t);
+  return Math.floor(Math.random() * (n - r + 1)) + r;
+}, A = (e, t, r = "…") => {
+  if (typeof e != "string") return "";
+  if (!Number.isFinite(t) || t < 0 || e.length <= t) return e;
+  const n = t - r.length;
+  if (n <= 0) return r.slice(0, t);
+  const o = e.slice(0, n), i = o.lastIndexOf(" ");
+  return (i > 0 ? o.slice(0, i) : o) + r;
+}, j = (e, t = "en-US", r = "USD") => Number.isFinite(e) ? new Intl.NumberFormat(t, {
+  style: "currency",
+  currency: r
+}).format(e) : "", C = (e) => !Number.isFinite(e) || e < 0 ? Promise.reject(new RangeError("Delay must be a non-negative finite number")) : new Promise((t) => setTimeout(t, e)), M = async (e) => {
+  if (typeof e != "string") return !1;
+  if (navigator?.clipboard?.writeText)
+    try {
+      return await navigator.clipboard.writeText(e), !0;
+    } catch {
+    }
+  try {
+    const t = document.createElement("textarea");
+    t.value = e, t.setAttribute("readonly", ""), t.style.position = "fixed", t.style.left = "-9999px", t.style.opacity = "0", document.body.appendChild(t), t.select();
+    const r = document.execCommand("copy");
+    return document.body.removeChild(t), r;
+  } catch {
+    return !1;
+  }
+};
 export {
-  r as debounce
+  b as camelCase,
+  m as capitalize,
+  M as copyToClipboard,
+  f as debounce,
+  C as delay,
+  y as downloadFile,
+  u as flattenArray,
+  j as formatCurrency,
+  p as getUniqueId,
+  d as isAppleDevice,
+  l as isEmpty,
+  w as randomNumber,
+  s as removeExtraProperties,
+  h as slugify,
+  g as throttle,
+  A as truncate
 };

package/utils/index.d.ts

@@ -1,2 +1,4 @@
 export * from './object';
 export * from './functions';
+export * from './search.util';
+export * from './env';

package/utils/search.util.d.ts

@@ -0,0 +1,127 @@
+/** Comparison operators for numeric/string range and equality checks */
+export interface SearchOperators<V = any> {
+    /** Exact equality */
+    $eq?: V;
+    /** Not equal */
+    $ne?: V;
+    /** Greater than (numeric) */
+    $gt?: number;
+    /** Greater than or equal (numeric) */
+    $gte?: number;
+    /** Less than (numeric) */
+    $lt?: number;
+    /** Less than or equal (numeric) */
+    $lte?: number;
+    /** Case-insensitive substring match */
+    $in?: string;
+    /** NOT case-insensitive substring match */
+    $nin?: string;
+    /** Regex test */
+    $regex?: string | RegExp;
+    /** Field existence check: true = must exist & not be null/undefined, false = must NOT exist */
+    $exists?: boolean;
+}
+/** A query value for a single field: direct value or operator object */
+export type QueryValue<V = any> = V | SearchOperators<V>;
+/** A query object: partial map of field names to query values */
+export type QueryObject<T = Record<string, any>> = {
+    [K in keyof T]?: QueryValue<T[K]>;
+};
+/** The full query input: string (for primitive arrays), single query, or OR-array of queries */
+export type SearchQuery<T = any> = T extends string ? string | QueryObject<T> | QueryObject<T>[] : string | QueryObject<T> | QueryObject<T>[];
+/** Returned from `search()` */
+export interface SearchResult<T> {
+    /** Matching items */
+    results: T[];
+    /** Clears the cached index for the associated model key */
+    reset: () => void;
+    /** Whether the search engine is still building indexes (always false for sync `search()`) */
+    loading: boolean;
+}
+/** Returned from `lazySearch()` — a pre-configured, reusable search instance */
+export interface LazySearchResult<T> {
+    /** Execute a search query against the pre-indexed dataset */
+    search: (query: string) => T[];
+    /** Clear the cached index and rebuild on next search */
+    reset: () => void;
+    /** Whether the index is currently being built */
+    loading: boolean;
+}
+/**
+ * Reset cached indexes.
+ * @param modelKey — If provided, only that model's cache is cleared.
+ *                   If omitted, ALL caches are cleared.
+ */
+export declare function resetSearchIndex(modelKey?: string): void;
+/**
+ * High-performance search engine with indexing and caching.
+ *
+ * Supports primitive arrays (string search), object arrays with exact/substring match,
+ * query operators ($in, $gte, $lte, etc.), OR queries (array of query objects),
+ * and AND queries (multiple rest-parameter query objects).
+ *
+ * @param data        — The dataset to search (array of primitives or objects)
+ * @param queries     — One or more queries. Last argument may be a `modelKey` string.
+ *                      - `string` — substring search on primitive arrays
+ *                      - `QueryObject` — AND of all field conditions
+ *                      - `QueryObject[]` — OR across the array (union)
+ *                      - Multiple `QueryObject` args — AND across queries (intersection)
+ * @param modelKey    — Optional cache key (like a Mongoose model name). Pass as the
+ *                      last argument. When reused, indexes are cached and not rebuilt.
+ *
+ * @returns `{ results, reset }` — `results` is the matched items in original order;
+ *          `reset()` clears the cached index for this model key.
+ *
+ * @example
+ * // Primitive search
+ * const { results } = search(['apple', 'banana', 'cherry'], 'an')
+ * // results: ['banana']
+ *
+ * @example
+ * // Object search with exact match
+ * const { results } = search(users, { name: 'Jane' }, 'User')
+ *
+ * @example
+ * // Multiple AND queries
+ * const { results } = search(products, { category: 'clothes' }, { price: { $gte: 200 } }, 'Product')
+ *
+ * @example
+ * // OR query (array)
+ * const { results } = search(users, [{ name: 'John' }, { age: 25 }], 'User')
+ */
+export declare function search<T>(data: T[], ...args: any[]): SearchResult<T>;
+/**
+ * Creates a pre-configured, reusable search instance.
+ *
+ * Unlike `search()`, which takes a full query each time, `lazySearch()` accepts
+ * the dataset and a list of searchable fields upfront, builds the index once,
+ * and returns a lightweight `search(query)` function for fast repeated lookups.
+ *
+ * Think of it like creating a Fuse.js instance — you configure once, search many times.
+ *
+ * @param data       — The dataset to search (array of objects or primitives)
+ * @param keys       — Array of field paths (dot-notation supported) to search across.
+ *                     For primitive arrays, this is optional.
+ * @param modelKey   — Optional cache key for index persistence across calls
+ *
+ * @returns `{ search, reset, loading }`
+ *          - `search(query)` — returns matching items for a string query
+ *          - `reset()` — clears the cached index
+ *          - `loading` — whether the index is being built
+ *
+ * @example
+ * const people = [
+ *   { name: { firstName: 'Jesse', lastName: 'Bowen' }, state: 'Seattle' },
+ *   { name: { firstName: 'Jane', lastName: 'Doe' }, state: 'London' },
+ * ]
+ *
+ * const { search, reset, loading } = lazySearch(people, ['name.firstName', 'state'])
+ * const results = search('ess')
+ * // results: [{ name: { firstName: 'Jesse', lastName: 'Bowen' }, state: 'Seattle' }]
+ *
+ * @example
+ * // Primitive array — keys not needed
+ * const { search } = lazySearch(['apple', 'banana', 'cherry'])
+ * search('an') // ['banana']
+ */
+export declare function lazySearch<T>(data: T[], keys?: string[], modelKey?: string): LazySearchResult<T>;