zakir-core 0.1.0 → 0.1.1

package/dist/function.d.ts

@@ -1,2 +1,49 @@
-export declare function debounce<T extends (...args: any[]) => void>(fn: T, delay?: number): (...args: Parameters<T>) => void;
-export declare function throttle<T extends (...args: any[]) => void>(fn: T, delay?: number): (...args: Parameters<T>) => void;
+export type AnyFn = (...args: any[]) => any;
+export declare function noop(): void;
+export declare function identity<T>(x: T): T;
+export declare function once<T extends AnyFn>(fn: T): T;
+export declare function onceAsync<T extends (...args: any[]) => Promise<any>>(fn: T): T;
+export declare function delay(ms: number): Promise<void>;
+export declare function defer(fn: AnyFn): void;
+export declare function tryCatch<T extends AnyFn>(fn: T, onError?: (err: unknown) => void): (...args: Parameters<T>) => ReturnType<T> | undefined;
+export type Debounced<T extends AnyFn> = ((...args: Parameters<T>) => ReturnType<T> | undefined) & {
+    cancel: () => void;
+    flush: () => ReturnType<T> | undefined;
+    pending: () => boolean;
+};
+export declare function debounce<T extends AnyFn>(fn: T, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+    maxWait?: number;
+}): Debounced<T>;
+export type Throttled<T extends AnyFn> = ((...args: Parameters<T>) => ReturnType<T> | undefined) & {
+    cancel: () => void;
+    flush: () => ReturnType<T> | undefined;
+    pending: () => boolean;
+};
+export declare function throttle<T extends AnyFn>(fn: T, wait?: number, options?: {
+    leading?: boolean;
+    trailing?: boolean;
+}): Throttled<T>;
+type MemoOpts = {
+    maxSize?: number;
+};
+export declare function memoize<T extends AnyFn>(fn: T, keyResolver?: (...args: Parameters<T>) => string | number, options?: MemoOpts): T & {
+    cache: Map<string | number, ReturnType<T>>;
+    clear: () => void;
+    delete: (key: string | number) => boolean;
+};
+export declare function memoizeAsync<T extends (...args: any[]) => Promise<any>>(fn: T, keyResolver?: (...args: Parameters<T>) => string | number, options?: MemoOpts): T & {
+    cache: Map<string | number, ReturnType<T>>;
+    clear: () => void;
+    delete: (key: string | number) => boolean;
+};
+export declare function pipe(): (x: any) => any;
+export declare function pipe<T1, T2>(a: (x: T1) => T2): (x: T1) => T2;
+export declare function pipe<T1, T2, T3>(a: (x: T1) => T2, b: (x: T2) => T3): (x: T1) => T3;
+export declare function pipe<T1, T2, T3, T4>(a: (x: T1) => T2, b: (x: T2) => T3, c: (x: T3) => T4): (x: T1) => T4;
+export declare function compose(): (x: any) => any;
+export declare function compose<T1, T2>(a: (x: T1) => T2): (x: T1) => T2;
+export declare function compose<T1, T2, T3>(a: (x: T2) => T3, b: (x: T1) => T2): (x: T1) => T3;
+export declare function compose<T1, T2, T3, T4>(a: (x: T3) => T4, b: (x: T2) => T3, c: (x: T1) => T2): (x: T1) => T4;
+export {};

package/dist/function.js

@@ -1,17 +1,234 @@
-export function debounce(fn, delay = 300) {
-    let timer;
-    return (...args) => {
-        clearTimeout(timer);
-        timer = setTimeout(() => fn(...args), delay);
+function now() {
+    const p = globalThis.performance;
+    if (p && typeof p.now === "function")
+        return p.now();
+    return Date.now();
+}
+function toIntNonNeg(n) {
+    const x = n | 0;
+    return x < 0 ? 0 : x;
+}
+function lruTouch(m, key) {
+    const v = m.get(key);
+    if (v === undefined && !m.has(key))
+        return;
+    m.delete(key);
+    m.set(key, v);
+}
+function lruTrim(m, maxSize) {
+    if (maxSize <= 0)
+        return;
+    while (m.size > maxSize) {
+        const k = m.keys().next().value;
+        if (k === undefined)
+            return;
+        m.delete(k);
+    }
+}
+export function noop() { }
+export function identity(x) {
+    return x;
+}
+export function once(fn) {
+    let called = false;
+    let value;
+    return function (...args) {
+        if (!called) {
+            called = true;
+            value = fn.apply(this, args);
+        }
+        return value;
+    };
+}
+export function onceAsync(fn) {
+    let p = null;
+    return function (...args) {
+        if (!p)
+            p = fn.apply(this, args);
+        return p;
     };
 }
-export function throttle(fn, delay = 300) {
-    let last = 0;
+export function delay(ms) {
+    const t = toIntNonNeg(ms);
+    return new Promise(resolve => setTimeout(resolve, t));
+}
+export function defer(fn) {
+    setTimeout(fn, 0);
+}
+export function tryCatch(fn, onError) {
     return (...args) => {
-        const now = Date.now();
-        if (now - last >= delay) {
-            last = now;
-            fn(...args);
+        try {
+            return fn(...args);
+        }
+        catch (err) {
+            onError?.(err);
+            return undefined;
         }
     };
 }
+export function debounce(fn, wait = 0, options) {
+    const leading = !!options?.leading;
+    const trailing = options?.trailing !== false;
+    const w = toIntNonNeg(wait);
+    const maxWait = options?.maxWait === undefined ? undefined : toIntNonNeg(options.maxWait);
+    let timer = null;
+    let lastArgs = null;
+    let lastThis = null;
+    let lastCallTime = 0;
+    let lastInvokeTime = 0;
+    let lastResult = undefined;
+    const clearState = () => {
+        lastArgs = null;
+        lastThis = null;
+    };
+    const invoke = () => {
+        if (!lastArgs)
+            return lastResult;
+        const args = lastArgs;
+        const ctx = lastThis;
+        clearState();
+        lastInvokeTime = now();
+        lastResult = fn.apply(ctx, args);
+        return lastResult;
+    };
+    const stopTimer = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = null;
+    };
+    const startTimer = (ms) => {
+        stopTimer();
+        timer = setTimeout(onTimer, ms);
+    };
+    const remainingWait = (t) => {
+        const sinceCall = t - lastCallTime;
+        const sinceInvoke = t - lastInvokeTime;
+        const timeWaiting = w - sinceCall;
+        return maxWait === undefined ? timeWaiting : Math.min(timeWaiting, maxWait - sinceInvoke);
+    };
+    const shouldInvoke = (t) => {
+        const sinceCall = t - lastCallTime;
+        const sinceInvoke = t - lastInvokeTime;
+        return (lastCallTime === 0 ||
+            sinceCall >= w ||
+            sinceCall < 0 ||
+            (maxWait !== undefined && sinceInvoke >= maxWait));
+    };
+    const onTimer = () => {
+        timer = null;
+        const t = now();
+        if (shouldInvoke(t)) {
+            if (trailing)
+                invoke();
+            return;
+        }
+        startTimer(remainingWait(t));
+    };
+    const debounced = function (...args) {
+        const t = now();
+        const isInvoking = shouldInvoke(t);
+        lastArgs = args;
+        lastThis = this;
+        lastCallTime = t;
+        if (!timer) {
+            if (leading && isInvoking) {
+                const r = invoke();
+                if (trailing)
+                    startTimer(w);
+                else
+                    clearState();
+                return r;
+            }
+            if (trailing) {
+                startTimer(w);
+            }
+            else {
+                clearState();
+            }
+            return lastResult;
+        }
+        if (maxWait !== undefined && isInvoking) {
+            if (trailing)
+                startTimer(w);
+            return invoke();
+        }
+        return lastResult;
+    };
+    debounced.cancel = () => {
+        stopTimer();
+        clearState();
+        lastCallTime = 0;
+        lastInvokeTime = 0;
+        lastResult = undefined;
+    };
+    debounced.flush = () => {
+        if (!timer)
+            return lastResult;
+        stopTimer();
+        return trailing ? invoke() : lastResult;
+    };
+    debounced.pending = () => !!timer;
+    return debounced;
+}
+export function throttle(fn, wait = 0, options) {
+    const leading = options?.leading !== false;
+    const trailing = options?.trailing !== false;
+    return debounce(fn, wait, { leading, trailing, maxWait: toIntNonNeg(wait) });
+}
+export function memoize(fn, keyResolver, options) {
+    const cache = new Map();
+    const maxSize = options?.maxSize === undefined ? 0 : toIntNonNeg(options.maxSize);
+    const memoized = function (...args) {
+        const key = keyResolver ? keyResolver(...args) : args[0];
+        if (cache.has(key)) {
+            if (maxSize > 0)
+                lruTouch(cache, key);
+            return cache.get(key);
+        }
+        const result = fn.apply(this, args);
+        cache.set(key, result);
+        if (maxSize > 0)
+            lruTrim(cache, maxSize);
+        return result;
+    };
+    memoized.cache = cache;
+    memoized.clear = () => cache.clear();
+    memoized.delete = (key) => cache.delete(key);
+    return memoized;
+}
+export function memoizeAsync(fn, keyResolver, options) {
+    const cache = new Map();
+    const maxSize = options?.maxSize === undefined ? 0 : toIntNonNeg(options.maxSize);
+    const memoized = function (...args) {
+        const key = keyResolver ? keyResolver(...args) : args[0];
+        const cached = cache.get(key);
+        if (cached) {
+            if (maxSize > 0)
+                lruTouch(cache, key);
+            return cached;
+        }
+        const p = fn.apply(this, args);
+        cache.set(key, p);
+        if (maxSize > 0)
+            lruTrim(cache, maxSize);
+        p.catch(() => {
+            if (cache.get(key) === p)
+                cache.delete(key);
+        });
+        return p;
+    };
+    memoized.cache = cache;
+    memoized.clear = () => cache.clear();
+    memoized.delete = (key) => cache.delete(key);
+    return memoized;
+}
+export function pipe(...fns) {
+    if (fns.length === 0)
+        return (x) => x;
+    return (x) => fns.reduce((v, fn) => fn(v), x);
+}
+export function compose(...fns) {
+    if (fns.length === 0)
+        return (x) => x;
+    return (x) => fns.reduceRight((v, fn) => fn(v), x);
+}

package/dist/string.d.ts

@@ -1,2 +1,29 @@
-export declare function uuid(): string;
-export declare function capitalize(str: string): string;
+type UnknownString = string | null | undefined;
+export declare const translitBase: Record<string, string>;
+export declare function extendTransliteration(map: Record<string, string>): void;
+export declare function capitalize(input: UnknownString, locale?: string): string;
+export declare function capitalizeWords(input: UnknownString, locale?: string): string;
+export declare function lower(input: UnknownString, locale?: string): string;
+export declare function upper(input: UnknownString, locale?: string): string;
+export declare function trim(input: UnknownString): string;
+export declare function normalizeSpaces(input: UnknownString): string;
+export declare function truncate(input: UnknownString, length: number, suffix?: string, locale?: string): string;
+export declare function startsWithIgnoreCase(input: UnknownString, search: string, locale?: string): boolean;
+export declare function endsWithIgnoreCase(input: UnknownString, search: string, locale?: string): boolean;
+export declare function includesIgnoreCase(input: UnknownString, search: string, locale?: string): boolean;
+export declare function removeNonAlphaNumeric(input: UnknownString): string;
+export declare function slugify(input: UnknownString, locale?: string, maxLength?: number): string;
+export declare function repeat(input: UnknownString, times: number): string;
+export declare function padLeft(input: UnknownString, length: number, pad?: string): string;
+export declare function padRight(input: UnknownString, length: number, pad?: string): string;
+export declare function reverse(input: UnknownString, locale?: string): string;
+export declare function isEmptyString(input: UnknownString): boolean;
+export declare function equalsIgnoreCase(a: UnknownString, b: UnknownString, locale?: string): boolean;
+export declare function extractInitials(input: UnknownString, locale?: string): string;
+export declare function safeSubstring(input: UnknownString, start: number, end?: number, locale?: string): string;
+export declare function removeDiacritics(input: UnknownString): string;
+export declare function ensurePrefix(input: UnknownString, prefix: string): string;
+export declare function ensureSuffix(input: UnknownString, suffix: string): string;
+export declare function compareLocale(a: UnknownString, b: UnknownString, locale?: string, sensitivity?: Intl.CollatorOptions["sensitivity"]): number;
+export declare function count(input: UnknownString, needle: string, locale?: string): number;
+export {};

package/dist/string.js

@@ -1,8 +1,239 @@
-export function uuid() {
-    return crypto.randomUUID();
+const HAS_SEGMENTER = typeof Intl !== "undefined" && typeof Intl.Segmenter === "function";
+const HAS_COLLATOR = typeof Intl !== "undefined" && typeof Intl.Collator === "function";
+const SEGMENTER_CACHE_MAX = 16;
+const segmenterCache = new Map();
+const COLLATOR_CACHE_MAX = 16;
+const collatorCache = new Map();
+function getSegmenter(locale) {
+    if (!HAS_SEGMENTER)
+        return null;
+    const existing = segmenterCache.get(locale);
+    if (existing) {
+        segmenterCache.delete(locale);
+        segmenterCache.set(locale, existing);
+        return existing;
+    }
+    const s = new Intl.Segmenter(locale, { granularity: "grapheme" });
+    segmenterCache.set(locale, s);
+    if (segmenterCache.size > SEGMENTER_CACHE_MAX) {
+        const k = segmenterCache.keys().next().value;
+        if (k)
+            segmenterCache.delete(k);
+    }
+    return s;
 }
-export function capitalize(str) {
-    if (!str)
+function getCollator(locale, sensitivity) {
+    if (!HAS_COLLATOR)
+        return null;
+    const key = `${locale}|${sensitivity ?? "base"}`;
+    const existing = collatorCache.get(key);
+    if (existing) {
+        collatorCache.delete(key);
+        collatorCache.set(key, existing);
+        return existing;
+    }
+    const c = new Intl.Collator(locale, {
+        sensitivity: sensitivity ?? "base",
+        usage: "sort"
+    });
+    collatorCache.set(key, c);
+    if (collatorCache.size > COLLATOR_CACHE_MAX) {
+        const k = collatorCache.keys().next().value;
+        if (k)
+            collatorCache.delete(k);
+    }
+    return c;
+}
+function toStringSafe(v) {
+    if (v === null || v === undefined)
+        return "";
+    return String(v);
+}
+function isNonEmptyString(v) {
+    return typeof v === "string" && v.length > 0;
+}
+function splitGraphemes(input, locale) {
+    const seg = getSegmenter(locale);
+    if (!seg)
+        return Array.from(input);
+    return Array.from(seg.segment(input), (x) => x.segment);
+}
+let HAS_UNICODE_PROPS = true;
+try {
+    new RegExp("\\p{L}", "u");
+}
+catch {
+    HAS_UNICODE_PROPS = false;
+}
+const reKeepLettersNumbers = HAS_UNICODE_PROPS
+    ? /[^\p{L}\p{N}]/gu
+    : /[^a-zA-Z0-9]/g;
+const reSlugStrip = HAS_UNICODE_PROPS
+    ? /[^\p{L}\p{N}\s-]/gu
+    : /[^a-z0-9\s-]/g;
+export const translitBase = {
+    "ə": "e", "Ə": "e",
+    "ı": "i", "İ": "i",
+    "ş": "s", "Ş": "s",
+    "ğ": "g", "Ğ": "g",
+    "ç": "c", "Ç": "c",
+    "ö": "o", "Ö": "o",
+    "ü": "u", "Ü": "u",
+    "ñ": "n", "Ñ": "n"
+};
+export function extendTransliteration(map) {
+    for (const k in map)
+        translitBase[k] = map[k];
+}
+function transliterate(input) {
+    let out = "";
+    for (const ch of input)
+        out += translitBase[ch] ?? ch;
+    return out;
+}
+function foldCase(input, locale) {
+    return input.toLocaleLowerCase(locale).normalize("NFKC");
+}
+export function capitalize(input, locale = "en-US") {
+    if (!isNonEmptyString(input))
+        return "";
+    const g = splitGraphemes(input, locale);
+    if (g.length === 0)
+        return "";
+    return g[0].toLocaleUpperCase(locale) + g.slice(1).join("");
+}
+export function capitalizeWords(input, locale = "en-US") {
+    if (!isNonEmptyString(input))
+        return "";
+    return input.trim().split(/\s+/).map(w => capitalize(w, locale)).join(" ");
+}
+export function lower(input, locale = "en-US") {
+    return toStringSafe(input).toLocaleLowerCase(locale);
+}
+export function upper(input, locale = "en-US") {
+    return toStringSafe(input).toLocaleUpperCase(locale);
+}
+export function trim(input) {
+    return toStringSafe(input).trim();
+}
+export function normalizeSpaces(input) {
+    return toStringSafe(input).replace(/\s+/g, " ").trim();
+}
+export function truncate(input, length, suffix = "…", locale = "en-US") {
+    const str = toStringSafe(input);
+    if (length <= 0)
+        return "";
+    const g = splitGraphemes(str, locale);
+    if (g.length <= length)
         return str;
-    return str[0].toUpperCase() + str.slice(1);
+    return g.slice(0, length).join("") + suffix;
+}
+export function startsWithIgnoreCase(input, search, locale = "en-US") {
+    if (!isNonEmptyString(search))
+        return false;
+    return foldCase(toStringSafe(input), locale).startsWith(foldCase(search, locale));
+}
+export function endsWithIgnoreCase(input, search, locale = "en-US") {
+    if (!isNonEmptyString(search))
+        return false;
+    return foldCase(toStringSafe(input), locale).endsWith(foldCase(search, locale));
+}
+export function includesIgnoreCase(input, search, locale = "en-US") {
+    if (!isNonEmptyString(search))
+        return false;
+    return foldCase(toStringSafe(input), locale).includes(foldCase(search, locale));
+}
+export function removeNonAlphaNumeric(input) {
+    return toStringSafe(input).replace(reKeepLettersNumbers, "");
+}
+export function slugify(input, locale = "en-US", maxLength = 0) {
+    let s = normalizeSpaces(input);
+    if (!s)
+        return "";
+    s = transliterate(s)
+        .toLocaleLowerCase(locale)
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .replace(reSlugStrip, "")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    if (maxLength > 0 && s.length > maxLength) {
+        s = s.slice(0, maxLength).replace(/-+$/g, "");
+    }
+    return s;
+}
+export function repeat(input, times) {
+    if (times <= 0)
+        return "";
+    return toStringSafe(input).repeat(times);
+}
+export function padLeft(input, length, pad = " ") {
+    const str = toStringSafe(input);
+    if (str.length >= length)
+        return str;
+    const p = pad.length ? pad : " ";
+    const need = length - str.length;
+    return p.repeat(Math.ceil(need / p.length)).slice(0, need) + str;
+}
+export function padRight(input, length, pad = " ") {
+    const str = toStringSafe(input);
+    if (str.length >= length)
+        return str;
+    const p = pad.length ? pad : " ";
+    const need = length - str.length;
+    return str + p.repeat(Math.ceil(need / p.length)).slice(0, need);
+}
+export function reverse(input, locale = "en-US") {
+    return splitGraphemes(toStringSafe(input), locale).reverse().join("");
+}
+export function isEmptyString(input) {
+    return toStringSafe(input).length === 0;
+}
+export function equalsIgnoreCase(a, b, locale = "en-US") {
+    return foldCase(toStringSafe(a), locale) === foldCase(toStringSafe(b), locale);
+}
+export function extractInitials(input, locale = "en-US") {
+    if (!isNonEmptyString(input))
+        return "";
+    return input.trim().split(/\s+/)
+        .map(w => splitGraphemes(w, locale)[0] || "")
+        .map(ch => (ch ? ch.toLocaleUpperCase(locale) : ""))
+        .join("");
+}
+export function safeSubstring(input, start, end, locale = "en-US") {
+    const g = splitGraphemes(toStringSafe(input), locale);
+    const s = Math.max(0, start);
+    const e = end === undefined ? g.length : Math.max(s, end);
+    return g.slice(s, e).join("");
+}
+export function removeDiacritics(input) {
+    return toStringSafe(input).normalize("NFKD").replace(/[\u0300-\u036f]/g, "");
+}
+export function ensurePrefix(input, prefix) {
+    const str = toStringSafe(input);
+    return str.startsWith(prefix) ? str : prefix + str;
+}
+export function ensureSuffix(input, suffix) {
+    const str = toStringSafe(input);
+    return str.endsWith(suffix) ? str : str + suffix;
+}
+export function compareLocale(a, b, locale = "en-US", sensitivity = "base") {
+    const c = getCollator(locale, sensitivity);
+    if (c)
+        return c.compare(toStringSafe(a), toStringSafe(b));
+    return toStringSafe(a).localeCompare(toStringSafe(b), locale, { sensitivity });
+}
+export function count(input, needle, locale = "en-US") {
+    if (!isNonEmptyString(needle))
+        return 0;
+    const hay = foldCase(toStringSafe(input), locale);
+    const ndl = foldCase(needle, locale);
+    let i = 0;
+    let c = 0;
+    while ((i = hay.indexOf(ndl, i)) !== -1) {
+        c++;
+        i += ndl.length;
+    }
+    return c;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zakir-core",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Core utility functions – zero dependency",
   "type": "module",
   "main": "dist/index.js",