@fluixi/utils 1.0.0-alpha.53

package/dist/lib/functions/functions.js

@@ -0,0 +1,585 @@
+import { isClass } from '@fluixi/utils/object';
+/**
+ * Check if value is a function
+ * @param v - The value to check
+ * @returns True if the value is a function, false otherwise
+ */
+export function isFunction(v) {
+    return typeof v === 'function' && !isClass(v);
+}
+/**
+ * Check if value is a Promise
+ * @param v - The value to check
+ * @returns True if the value is a Promise, false otherwise
+ */
+export function isPromise(v) {
+    return (v instanceof Promise ||
+        (!!v && (typeof v === 'object' || typeof v === 'function') && 'then' in v));
+}
+/**
+ * Check if value is an async function
+ * @param v - The value to check
+ * @returns True if the value is an async function, false otherwise
+ */
+export function isAsyncFunction(v) {
+    return isFunction(v) && v.constructor.name === 'AsyncFunction';
+}
+/**
+ * Memoizes a function, caching results based on arguments
+ * @param fn - Function to memoize
+ * @param resolver - Optional function to generate cache key
+ * @returns Memoized function with cache property
+ * @example
+ * const expensive = memoize((n: number) => {
+ *   return n * n;
+ * });
+ * expensive(5); // Computed
+ * expensive(5); // Cached
+ */
+export function memoize(fn, resolver) {
+    const cache = new Map();
+    const memoized = function (...args) {
+        const key = resolver ? resolver(...args) : JSON.stringify(args);
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+        const result = fn.apply(this, args);
+        cache.set(key, result);
+        return result;
+    };
+    memoized.cache = cache;
+    return memoized;
+}
+/**
+ * Creates a debounced function that delays invoking func until after wait milliseconds
+ * @param fn - Function to debounce
+ * @param wait - Milliseconds to wait
+ * @param options - Debounce options
+ * @returns Debounced function with cancel method
+ * @example
+ * const debounced = debounce(() => console.log('Search'), 300);
+ * debounced(); // Will execute after 300ms of inactivity
+ */
+export function debounce(fn, wait, options = {}) {
+    const { leading = false, trailing = true, maxWait } = options;
+    let timerId;
+    let maxTimerId;
+    let lastCallTime;
+    let lastInvokeTime = 0;
+    let lastArgs;
+    let lastThis;
+    let result;
+    function invokeFunc(time) {
+        const args = lastArgs;
+        const thisArg = lastThis;
+        lastArgs = lastThis = undefined;
+        lastInvokeTime = time;
+        result = fn.apply(thisArg, args);
+        return result;
+    }
+    function startTimer(pendingFunc, wait) {
+        return setTimeout(pendingFunc, wait);
+    }
+    function cancelTimer(id) {
+        if (id !== undefined) {
+            clearTimeout(id);
+        }
+    }
+    function leadingEdge(time) {
+        lastInvokeTime = time;
+        timerId = startTimer(timerExpired, wait);
+        return leading ? invokeFunc(time) : result;
+    }
+    function remainingWait(time) {
+        const timeSinceLastCall = time - lastCallTime;
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        const timeWaiting = wait - timeSinceLastCall;
+        return maxWait !== undefined
+            ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke)
+            : timeWaiting;
+    }
+    function shouldInvoke(time) {
+        const timeSinceLastCall = time - lastCallTime;
+        const timeSinceLastInvoke = time - lastInvokeTime;
+        return (lastCallTime === undefined ||
+            timeSinceLastCall >= wait ||
+            timeSinceLastCall < 0 ||
+            (maxWait !== undefined && timeSinceLastInvoke >= maxWait));
+    }
+    function timerExpired() {
+        const time = Date.now();
+        if (shouldInvoke(time)) {
+            trailingEdge(time);
+            return;
+        }
+        timerId = startTimer(timerExpired, remainingWait(time));
+    }
+    function trailingEdge(time) {
+        timerId = undefined;
+        if (trailing && lastArgs) {
+            return invokeFunc(time);
+        }
+        lastArgs = lastThis = undefined;
+        return result;
+    }
+    function cancel() {
+        cancelTimer(timerId);
+        cancelTimer(maxTimerId);
+        lastInvokeTime = 0;
+        lastArgs = lastCallTime = lastThis = timerId = maxTimerId = undefined;
+    }
+    function flush() {
+        return timerId === undefined ? result : trailingEdge(Date.now());
+    }
+    function pending() {
+        return timerId !== undefined;
+    }
+    function debounced(...args) {
+        const time = Date.now();
+        const isInvoking = shouldInvoke(time);
+        lastArgs = args;
+        lastThis = this;
+        lastCallTime = time;
+        if (isInvoking) {
+            if (timerId === undefined) {
+                return leadingEdge(lastCallTime);
+            }
+            if (maxWait !== undefined) {
+                timerId = startTimer(timerExpired, wait);
+                return invokeFunc(lastCallTime);
+            }
+        }
+        if (timerId === undefined) {
+            timerId = startTimer(timerExpired, wait);
+        }
+        return result;
+    }
+    debounced.cancel = cancel;
+    debounced.flush = flush;
+    debounced.pending = pending;
+    return debounced;
+}
+/**
+ * Creates a throttled function that only invokes func at most once per every wait milliseconds
+ * @param fn - Function to throttle
+ * @param wait - Milliseconds to wait
+ * @param options - Throttle options
+ * @returns Throttled function with cancel method
+ * @example
+ * const throttled = throttle(() => console.log('Scroll'), 100);
+ * window.addEventListener('scroll', throttled);
+ */
+export function throttle(fn, wait, options = {}) {
+    const { leading = true, trailing = true } = options;
+    return debounce(fn, wait, {
+        leading,
+        trailing,
+        maxWait: wait,
+    });
+}
+/**
+ * Creates a function that is restricted to invoking func once
+ * @param fn - Function to restrict
+ * @returns Function that invokes func once
+ * @example
+ * const initialize = once(() => console.log('Initialized'));
+ * initialize(); // Logs 'Initialized'
+ * initialize(); // Does nothing
+ */
+export function once(fn) {
+    let called = false;
+    let result;
+    const wrapped = function (...args) {
+        if (!called) {
+            called = true;
+            result = fn.apply(this, args);
+        }
+        return result;
+    };
+    Object.defineProperty(wrapped, 'called', {
+        get() {
+            return called;
+        },
+    });
+    return wrapped;
+}
+/**
+ * Creates a function that invokes func with arguments arranged according to the specified indexes
+ * @param fn - Function to rearrange arguments for
+ * @param indexes - Argument indexes
+ * @returns New function with rearranged arguments
+ * @example
+ * const rearg = rearg((a, b, c) => [a, b, c], [2, 0, 1]);
+ * rearg('a', 'b', 'c'); // ['c', 'a', 'b']
+ */
+export function rearg(fn, ...indexes) {
+    return function (...args) {
+        const reordered = indexes.map((i) => args[i]);
+        return fn.apply(this, reordered);
+    };
+}
+/**
+ * Curries a function
+ * @param fn - Function to curry
+ * @param arity - Number of arguments (defaults to fn.length)
+ * @returns Curried function
+ * @example
+ * const add = (a: number, b: number, c: number) => a + b + c;
+ * const curried = curry(add);
+ * curried(1)(2)(3); // 6
+ * curried(1, 2)(3); // 6
+ */
+export function curry(fn, arity = fn.length) {
+    return function curried(...args) {
+        if (args.length >= arity) {
+            return fn.apply(this, args);
+        }
+        return function (...nextArgs) {
+            return curried.apply(this, [...args, ...nextArgs]);
+        };
+    };
+}
+/**
+ * Composes functions from right to left
+ * @param fns - Functions to compose
+ * @returns Composed function
+ * @example
+ * const double = (x: number) => x * 2;
+ * const addOne = (x: number) => x + 1;
+ * const composed = compose(double, addOne);
+ * composed(5); // 12 (addOne first, then double)
+ */
+export function compose(...fns) {
+    return fns.reduceRight((prevFn, nextFn) => (value) => nextFn(prevFn(value)), (value) => value);
+}
+/**
+ * Pipes functions from left to right
+ * @param fns - Functions to pipe
+ * @returns Piped function
+ * @example
+ * const double = (x: number) => x * 2;
+ * const addOne = (x: number) => x + 1;
+ * const piped = pipe(double, addOne);
+ * piped(5); // 11 (double first, then addOne)
+ */
+export function pipe(...fns) {
+    return fns.reduce((prevFn, nextFn) => (value) => nextFn(prevFn(value)), (value) => value);
+}
+/**
+ * Creates a function that negates the result of the predicate func
+ * @param predicate - Predicate to negate
+ * @returns Negated predicate
+ * @example
+ * const isEven = (n: number) => n % 2 === 0;
+ * const isOdd = negate(isEven);
+ * isOdd(3); // true
+ */
+export function negate(predicate) {
+    return function (...args) {
+        return !predicate.apply(this, args);
+    };
+}
+/**
+ * Creates a function that invokes func with its arguments transformed
+ * @param fn - Function to wrap
+ * @param transforms - Argument transforms
+ * @returns New function with transformed arguments
+ * @example
+ * const doubled = overArgs((x, y) => [x, y], [x => x * 2, x => x * 3]);
+ * doubled(1, 1); // [2, 3]
+ */
+export function overArgs(fn, ...transforms) {
+    return function (...args) {
+        const transformedArgs = args.map((arg, index) => transforms[index] ? transforms[index](arg) : arg);
+        return fn.apply(this, transformedArgs);
+    };
+}
+/**
+ * Creates a function that invokes func with partials prepended to the arguments
+ * @param fn - Function to partially apply arguments to
+ * @param partials - Arguments to be partially applied
+ * @returns Partially applied function
+ * @example
+ * const greet = (greeting: string, name: string) => `${greeting}, ${name}!`;
+ * const sayHello = partial(greet, 'Hello');
+ * sayHello('World'); // 'Hello, World!'
+ */
+export function partial(fn, ...partials) {
+    return function (...args) {
+        return fn.apply(this, [...partials, ...args]);
+    };
+}
+/**
+ * Creates a function that invokes func with partials appended to the arguments
+ * @param fn - Function to partially apply arguments to
+ * @param partials - Arguments to be partially applied
+ * @returns Partially applied function
+ * @example
+ * const greet = (name: string, greeting: string) => `${greeting}, ${name}!`;
+ * const greetWorld = partialRight(greet, 'Hello');
+ * greetWorld('World'); // 'Hello, World!'
+ */
+export function partialRight(fn, ...partials) {
+    return function (...args) {
+        return fn.apply(this, [...args, ...partials]);
+    };
+}
+/**
+ * Creates a function that invokes func with the this binding of the created function
+ * @param fn - Function to bind
+ * @param thisArg - The this binding of func
+ * @param partials - Arguments to be partially applied
+ * @returns Bound function
+ * @example
+ * const obj = { x: 42 };
+ * const getX = bind(function() { return this.x; }, obj);
+ * getX(); // 42
+ */
+export function bind(fn, thisArg, ...partials) {
+    return function (...args) {
+        return fn.apply(thisArg, [...partials, ...args]);
+    };
+}
+/**
+ * Creates a function that invokes func with arguments reversed
+ * @param fn - Function to flip arguments for
+ * @returns Function with flipped arguments
+ * @example
+ * const flipped = flip((a, b, c) => [a, b, c]);
+ * flipped(1, 2, 3); // [3, 2, 1]
+ */
+export function flip(fn) {
+    return function (...args) {
+        return fn.apply(this, args.reverse());
+    };
+}
+/**
+ * Creates a function that accepts up to n arguments, ignoring any additional arguments
+ * @param fn - Function to cap arguments for
+ * @param n - Arity cap
+ * @returns Function with capped arity
+ * @example
+ * const capped = ary((a, b, c) => [a, b, c], 2);
+ * capped(1, 2, 3, 4); // [1, 2, undefined]
+ */
+export function ary(fn, n) {
+    return function (...args) {
+        return fn.apply(this, args.slice(0, n));
+    };
+}
+/**
+ * Creates a function that accepts up to one argument, ignoring any additional arguments
+ * @param fn - Function to cap arguments for
+ * @returns Unary function
+ * @example
+ * const unary = unary(parseInt);
+ * ['6', '8', '10'].map(unary); // [6, 8, 10] instead of [6, NaN, 2]
+ */
+export function unary(fn) {
+    return function (arg) {
+        return fn.call(this, arg);
+    };
+}
+/**
+ * Defers invoking the func until the current call stack has cleared
+ * @param fn - Function to defer
+ * @param args - Arguments to invoke func with
+ * @returns Timer id
+ * @example
+ * defer(console.log, 'Deferred');
+ */
+export function defer(fn, ...args) {
+    return setTimeout(fn, 1, ...args);
+}
+/**
+ * Delays invoking func until after wait milliseconds
+ * @param fn - Function to delay
+ * @param wait - Milliseconds to delay invocation
+ * @param args - Arguments to invoke func with
+ * @returns Timer id
+ * @example
+ * delay(console.log, 1000, 'Delayed');
+ */
+export function delay(fn, wait, ...args) {
+    return setTimeout(fn, wait, ...args);
+}
+/**
+ * Creates a function that memoizes the result of func with a Time-To-Live (TTL)
+ * @param fn - Function to memoize
+ * @param ttl - Time to live in milliseconds
+ * @param resolver - Optional function to generate cache key
+ * @returns Memoized function with TTL
+ * @example
+ * const expensiveApi = memoizeWithTTL(fetchData, 60000); // Cache for 1 minute
+ */
+export function memoizeWithTTL(fn, ttl, resolver) {
+    const cache = new Map();
+    const memoized = function (...args) {
+        const key = resolver ? resolver(...args) : JSON.stringify(args);
+        const now = Date.now();
+        const cached = cache.get(key);
+        if (cached && cached.expires > now) {
+            return cached.value;
+        }
+        const result = fn.apply(this, args);
+        cache.set(key, { value: result, expires: now + ttl });
+        // Cleanup expired entries
+        for (const [k, v] of cache.entries()) {
+            if (v.expires <= now) {
+                cache.delete(k);
+            }
+        }
+        return result;
+    };
+    memoized.cache = cache;
+    return memoized;
+}
+/**
+ * Creates a function that invokes func at most n times
+ * @param fn - Function to restrict
+ * @param n - Number of calls at which to stop executing func
+ * @returns Restricted function
+ * @example
+ * const limited = before((n) => console.log(n), 3);
+ * limited(1); // Logs 1
+ * limited(2); // Logs 2
+ * limited(3); // Does nothing
+ */
+export function before(fn, n) {
+    let result;
+    let callCount = 0;
+    return function (...args) {
+        if (++callCount < n) {
+            result = fn.apply(this, args);
+        }
+        if (callCount >= n) {
+            // @ts-ignore - Allow clearing function reference
+            fn = undefined;
+        }
+        return result;
+    };
+}
+/**
+ * Creates a function that invokes func once it's called n or more times
+ * @param fn - Function to restrict
+ * @param n - Number of calls before func is invoked
+ * @returns Restricted function
+ * @example
+ * const afterThree = after((n) => console.log('Called!'), 3);
+ * afterThree(); // Does nothing
+ * afterThree(); // Does nothing
+ * afterThree(); // Logs 'Called!'
+ */
+export function after(fn, n) {
+    let callCount = 0;
+    return function (...args) {
+        if (++callCount >= n) {
+            return fn.apply(this, args);
+        }
+        return undefined;
+    };
+}
+/**
+ * Wraps a function to catch and handle errors
+ * @param fn - Function to wrap
+ * @param errorHandler - Error handler function
+ * @returns Wrapped function
+ * @example
+ * const safe = tryCatch(
+ *   () => JSON.parse('invalid'),
+ *   (error) => ({ error: error.message })
+ * );
+ */
+export function tryCatch(fn, errorHandler) {
+    return function (...args) {
+        try {
+            return fn.apply(this, args);
+        }
+        catch (error) {
+            return errorHandler(error, ...args);
+        }
+    };
+}
+/**
+ * Creates a function that returns the result of invoking the given functions with the this binding of the created function,
+ * where each successive invocation is supplied the return value of the previous
+ * @param fns - Functions to invoke
+ * @returns Flow function
+ * @example
+ * const calculate = flow(
+ *   (n: number) => n * 2,
+ *   (n: number) => n + 1,
+ *   (n: number) => n * 3
+ * );
+ * calculate(5); // 33
+ */
+export function flow(...fns) {
+    return pipe(...fns);
+}
+/**
+ * Creates a function that returns the result of invoking the given functions from right to left
+ * @param fns - Functions to invoke
+ * @returns Flow right function
+ * @example
+ * const calculate = flowRight(
+ *   (n: number) => n * 3,
+ *   (n: number) => n + 1,
+ *   (n: number) => n * 2
+ * );
+ * calculate(5); // 33
+ */
+export function flowRight(...fns) {
+    return compose(...fns);
+}
+/**
+ * Wraps an async function to retry on failure
+ * @param fn - Async function to wrap
+ * @param options - Retry options
+ * @returns Wrapped function with retry logic
+ * @example
+ * const fetchWithRetry = retry(fetchData, { retries: 3, delay: 1000 });
+ */
+export function retry(fn, options = {}) {
+    const { retries = 3, delay = 1000, backoff = 2, onRetry } = options;
+    return async function (...args) {
+        let lastError;
+        let currentDelay = delay;
+        for (let attempt = 0; attempt <= retries; attempt++) {
+            try {
+                return await fn.apply(this, args);
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt < retries) {
+                    if (onRetry) {
+                        onRetry(lastError, attempt + 1);
+                    }
+                    await new Promise((resolve) => setTimeout(resolve, currentDelay));
+                    currentDelay *= backoff;
+                }
+            }
+        }
+        throw lastError;
+    };
+}
+/**
+ * Creates a function that invokes func with a timeout
+ * @param fn - Function to wrap with timeout
+ * @param timeout - Timeout in milliseconds
+ * @param onTimeout - Optional callback when timeout occurs
+ * @returns Function with timeout
+ * @example
+ * const timedFetch = withTimeout(fetchData, 5000);
+ */
+export function withTimeout(fn, timeout, onTimeout) {
+    return async function (...args) {
+        return Promise.race([
+            fn.apply(this, args),
+            new Promise((_, reject) => setTimeout(() => {
+                if (onTimeout)
+                    onTimeout();
+                reject(new Error(`Function timed out after ${timeout}ms`));
+            }, timeout)),
+        ]);
+    };
+}

package/dist/lib/functions/functions.mjs

@@ -0,0 +1 @@
+import{isClass as F}from"@fluixi/utils/object";function I(e){return typeof e=="function"&&!F(e)}function L(e){return e instanceof Promise||!!e&&(typeof e=="object"||typeof e=="function")&&"then"in e}function z(e){return I(e)&&e.constructor.name==="AsyncFunction"}function O(e,n){let t=new Map,r=function(...a){let i=n?n(...a):JSON.stringify(a);if(t.has(i))return t.get(i);let o=e.apply(this,a);return t.set(i,o),o};return r.cache=t,r}function M(e,n,t={}){let{leading:r=!1,trailing:a=!0,maxWait:i}=t,o,c,s,y=0,p,f,l;function x(u){let T=p,d=f;return p=f=void 0,y=u,l=e.apply(d,T),l}function m(u,T){return setTimeout(u,T)}function R(u){u!==void 0&&clearTimeout(u)}function w(u){return y=u,o=m(g,n),r?x(u):l}function k(u){let T=u-s,d=u-y,v=n-T;return i!==void 0?Math.min(v,i-d):v}function b(u){let T=u-s,d=u-y;return s===void 0||T>=n||T<0||i!==void 0&&d>=i}function g(){let u=Date.now();if(b(u)){P(u);return}o=m(g,k(u))}function P(u){return o=void 0,a&&p?x(u):(p=f=void 0,l)}function A(){R(o),R(c),y=0,p=s=f=o=c=void 0}function E(){return o===void 0?l:P(Date.now())}function C(){return o!==void 0}function h(...u){let T=Date.now(),d=b(T);if(p=u,f=this,s=T,d){if(o===void 0)return w(s);if(i!==void 0)return o=m(g,n),x(s)}return o===void 0&&(o=m(g,n)),l}return h.cancel=A,h.flush=E,h.pending=C,h}function j(e,n,t={}){let{leading:r=!0,trailing:a=!0}=t;return M(e,n,{leading:r,trailing:a,maxWait:n})}function J(e){let n=!1,t,r=function(...a){return n||(n=!0,t=e.apply(this,a)),t};return Object.defineProperty(r,"called",{get(){return n}}),r}function N(e,...n){return function(...t){let r=n.map(a=>t[a]);return e.apply(this,r)}}function _(e,n=e.length){return function t(...r){return r.length>=n?e.apply(this,r):function(...a){return t.apply(this,[...r,...a])}}}function S(...e){return e.reduceRight((n,t)=>r=>t(n(r)),n=>n)}function W(...e){return e.reduce((n,t)=>r=>t(n(r)),n=>n)}function $(e){return function(...n){return!e.apply(this,n)}}function q(e,...n){return function(...t){let r=t.map((a,i)=>n[i]?n[i](a):a);return e.apply(this,r)}}function B(e,...n){return function(...t){return e.apply(this,[...n,...t])}}function G(e,...n){return function(...t){return e.apply(this,[...t,...n])}}function H(e,n,...t){return function(...r){return e.apply(n,[...t,...r])}}function K(e){return function(...n){return e.apply(this,n.reverse())}}function Q(e,n){return function(...t){return e.apply(this,t.slice(0,n))}}function U(e){return function(n){return e.call(this,n)}}function V(e,...n){return setTimeout(e,1,...n)}function X(e,n,...t){return setTimeout(e,n,...t)}function Y(e,n,t){let r=new Map,a=function(...i){let o=t?t(...i):JSON.stringify(i),c=Date.now(),s=r.get(o);if(s&&s.expires>c)return s.value;let y=e.apply(this,i);r.set(o,{value:y,expires:c+n});for(let[p,f]of r.entries())f.expires<=c&&r.delete(p);return y};return a.cache=r,a}function Z(e,n){let t,r=0;return function(...a){return++r<n&&(t=e.apply(this,a)),r>=n&&(e=void 0),t}}function ee(e,n){let t=0;return function(...r){if(++t>=n)return e.apply(this,r)}}function ne(e,n){return function(...t){try{return e.apply(this,t)}catch(r){return n(r,...t)}}}function te(...e){return W(...e)}function re(...e){return S(...e)}function ae(e,n={}){let{retries:t=3,delay:r=1e3,backoff:a=2,onRetry:i}=n;return async function(...o){let c,s=r;for(let y=0;y<=t;y++)try{return await e.apply(this,o)}catch(p){c=p,y<t&&(i&&i(c,y+1),await new Promise(f=>setTimeout(f,s)),s*=a)}throw c}}function ue(e,n,t){return async function(...r){return Promise.race([e.apply(this,r),new Promise((a,i)=>setTimeout(()=>{t&&t(),i(new Error(`Function timed out after ${n}ms`))},n))])}}export{ee as after,Q as ary,Z as before,H as bind,S as compose,_ as curry,M as debounce,V as defer,X as delay,K as flip,te as flow,re as flowRight,z as isAsyncFunction,I as isFunction,L as isPromise,O as memoize,Y as memoizeWithTTL,$ as negate,J as once,q as overArgs,B as partial,G as partialRight,W as pipe,N as rearg,ae as retry,j as throttle,ne as tryCatch,U as unary,ue as withTimeout};

package/dist/lib/functions/index.cjs

@@ -0,0 +1 @@
+"use strict";var R=Object.defineProperty;var L=Object.getOwnPropertyDescriptor;var z=Object.getOwnPropertyNames;var j=Object.prototype.hasOwnProperty;var O=(e,n)=>{for(var t in n)R(e,t,{get:n[t],enumerable:!0})},J=(e,n,t,r)=>{if(n&&typeof n=="object"||typeof n=="function")for(let a of z(n))!j.call(e,a)&&a!==t&&R(e,a,{get:()=>n[a],enumerable:!(r=L(n,a))||r.enumerable});return e};var N=e=>J(R({},"__esModule",{value:!0}),e);var pe={};O(pe,{after:()=>ie,ary:()=>ee,before:()=>ue,bind:()=>Y,compose:()=>C,curry:()=>K,debounce:()=>E,defer:()=>te,delay:()=>re,flip:()=>Z,flow:()=>se,flowRight:()=>ye,isAsyncFunction:()=>$,isFunction:()=>A,isPromise:()=>_,memoize:()=>q,memoizeWithTTL:()=>ae,negate:()=>Q,once:()=>G,overArgs:()=>U,partial:()=>V,partialRight:()=>X,pipe:()=>F,rearg:()=>H,retry:()=>Te,throttle:()=>B,tryCatch:()=>oe,unary:()=>ne,withTimeout:()=>ce});module.exports=N(pe);var k=require("@fluixi/utils/object");function A(e){return typeof e=="function"&&!(0,k.isClass)(e)}function _(e){return e instanceof Promise||!!e&&(typeof e=="object"||typeof e=="function")&&"then"in e}function $(e){return A(e)&&e.constructor.name==="AsyncFunction"}function q(e,n){let t=new Map,r=function(...a){let i=n?n(...a):JSON.stringify(a);if(t.has(i))return t.get(i);let o=e.apply(this,a);return t.set(i,o),o};return r.cache=t,r}function E(e,n,t={}){let{leading:r=!1,trailing:a=!0,maxWait:i}=t,o,c,s,y=0,p,f,l;function x(u){let T=p,d=f;return p=f=void 0,y=u,l=e.apply(d,T),l}function m(u,T){return setTimeout(u,T)}function b(u){u!==void 0&&clearTimeout(u)}function I(u){return y=u,o=m(g,n),r?x(u):l}function M(u){let T=u-s,d=u-y,w=n-T;return i!==void 0?Math.min(w,i-d):w}function P(u){let T=u-s,d=u-y;return s===void 0||T>=n||T<0||i!==void 0&&d>=i}function g(){let u=Date.now();if(P(u)){v(u);return}o=m(g,M(u))}function v(u){return o=void 0,a&&p?x(u):(p=f=void 0,l)}function S(){b(o),b(c),y=0,p=s=f=o=c=void 0}function W(){return o===void 0?l:v(Date.now())}function D(){return o!==void 0}function h(...u){let T=Date.now(),d=P(T);if(p=u,f=this,s=T,d){if(o===void 0)return I(s);if(i!==void 0)return o=m(g,n),x(s)}return o===void 0&&(o=m(g,n)),l}return h.cancel=S,h.flush=W,h.pending=D,h}function B(e,n,t={}){let{leading:r=!0,trailing:a=!0}=t;return E(e,n,{leading:r,trailing:a,maxWait:n})}function G(e){let n=!1,t,r=function(...a){return n||(n=!0,t=e.apply(this,a)),t};return Object.defineProperty(r,"called",{get(){return n}}),r}function H(e,...n){return function(...t){let r=n.map(a=>t[a]);return e.apply(this,r)}}function K(e,n=e.length){return function t(...r){return r.length>=n?e.apply(this,r):function(...a){return t.apply(this,[...r,...a])}}}function C(...e){return e.reduceRight((n,t)=>r=>t(n(r)),n=>n)}function F(...e){return e.reduce((n,t)=>r=>t(n(r)),n=>n)}function Q(e){return function(...n){return!e.apply(this,n)}}function U(e,...n){return function(...t){let r=t.map((a,i)=>n[i]?n[i](a):a);return e.apply(this,r)}}function V(e,...n){return function(...t){return e.apply(this,[...n,...t])}}function X(e,...n){return function(...t){return e.apply(this,[...t,...n])}}function Y(e,n,...t){return function(...r){return e.apply(n,[...t,...r])}}function Z(e){return function(...n){return e.apply(this,n.reverse())}}function ee(e,n){return function(...t){return e.apply(this,t.slice(0,n))}}function ne(e){return function(n){return e.call(this,n)}}function te(e,...n){return setTimeout(e,1,...n)}function re(e,n,...t){return setTimeout(e,n,...t)}function ae(e,n,t){let r=new Map,a=function(...i){let o=t?t(...i):JSON.stringify(i),c=Date.now(),s=r.get(o);if(s&&s.expires>c)return s.value;let y=e.apply(this,i);r.set(o,{value:y,expires:c+n});for(let[p,f]of r.entries())f.expires<=c&&r.delete(p);return y};return a.cache=r,a}function ue(e,n){let t,r=0;return function(...a){return++r<n&&(t=e.apply(this,a)),r>=n&&(e=void 0),t}}function ie(e,n){let t=0;return function(...r){if(++t>=n)return e.apply(this,r)}}function oe(e,n){return function(...t){try{return e.apply(this,t)}catch(r){return n(r,...t)}}}function se(...e){return F(...e)}function ye(...e){return C(...e)}function Te(e,n={}){let{retries:t=3,delay:r=1e3,backoff:a=2,onRetry:i}=n;return async function(...o){let c,s=r;for(let y=0;y<=t;y++)try{return await e.apply(this,o)}catch(p){c=p,y<t&&(i&&i(c,y+1),await new Promise(f=>setTimeout(f,s)),s*=a)}throw c}}function ce(e,n,t){return async function(...r){return Promise.race([e.apply(this,r),new Promise((a,i)=>setTimeout(()=>{t&&t(),i(new Error(`Function timed out after ${n}ms`))},n))])}}

package/dist/lib/functions/index.d.ts

@@ -0,0 +1,3 @@
+export * from './functions.js';
+export type * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/functions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/lib/functions/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,mBAAmB,YAAY,CAAC"}

package/dist/lib/functions/index.js

@@ -0,0 +1 @@
+export * from './functions.js';

package/dist/lib/functions/index.mjs

@@ -0,0 +1 @@
+import{isClass as F}from"@fluixi/utils/object";function I(e){return typeof e=="function"&&!F(e)}function L(e){return e instanceof Promise||!!e&&(typeof e=="object"||typeof e=="function")&&"then"in e}function z(e){return I(e)&&e.constructor.name==="AsyncFunction"}function j(e,n){let t=new Map,r=function(...a){let i=n?n(...a):JSON.stringify(a);if(t.has(i))return t.get(i);let o=e.apply(this,a);return t.set(i,o),o};return r.cache=t,r}function M(e,n,t={}){let{leading:r=!1,trailing:a=!0,maxWait:i}=t,o,c,s,y=0,p,f,l;function x(u){let T=p,d=f;return p=f=void 0,y=u,l=e.apply(d,T),l}function m(u,T){return setTimeout(u,T)}function R(u){u!==void 0&&clearTimeout(u)}function w(u){return y=u,o=m(g,n),r?x(u):l}function k(u){let T=u-s,d=u-y,v=n-T;return i!==void 0?Math.min(v,i-d):v}function b(u){let T=u-s,d=u-y;return s===void 0||T>=n||T<0||i!==void 0&&d>=i}function g(){let u=Date.now();if(b(u)){P(u);return}o=m(g,k(u))}function P(u){return o=void 0,a&&p?x(u):(p=f=void 0,l)}function A(){R(o),R(c),y=0,p=s=f=o=c=void 0}function E(){return o===void 0?l:P(Date.now())}function C(){return o!==void 0}function h(...u){let T=Date.now(),d=b(T);if(p=u,f=this,s=T,d){if(o===void 0)return w(s);if(i!==void 0)return o=m(g,n),x(s)}return o===void 0&&(o=m(g,n)),l}return h.cancel=A,h.flush=E,h.pending=C,h}function O(e,n,t={}){let{leading:r=!0,trailing:a=!0}=t;return M(e,n,{leading:r,trailing:a,maxWait:n})}function J(e){let n=!1,t,r=function(...a){return n||(n=!0,t=e.apply(this,a)),t};return Object.defineProperty(r,"called",{get(){return n}}),r}function N(e,...n){return function(...t){let r=n.map(a=>t[a]);return e.apply(this,r)}}function _(e,n=e.length){return function t(...r){return r.length>=n?e.apply(this,r):function(...a){return t.apply(this,[...r,...a])}}}function S(...e){return e.reduceRight((n,t)=>r=>t(n(r)),n=>n)}function W(...e){return e.reduce((n,t)=>r=>t(n(r)),n=>n)}function $(e){return function(...n){return!e.apply(this,n)}}function q(e,...n){return function(...t){let r=t.map((a,i)=>n[i]?n[i](a):a);return e.apply(this,r)}}function B(e,...n){return function(...t){return e.apply(this,[...n,...t])}}function G(e,...n){return function(...t){return e.apply(this,[...t,...n])}}function H(e,n,...t){return function(...r){return e.apply(n,[...t,...r])}}function K(e){return function(...n){return e.apply(this,n.reverse())}}function Q(e,n){return function(...t){return e.apply(this,t.slice(0,n))}}function U(e){return function(n){return e.call(this,n)}}function V(e,...n){return setTimeout(e,1,...n)}function X(e,n,...t){return setTimeout(e,n,...t)}function Y(e,n,t){let r=new Map,a=function(...i){let o=t?t(...i):JSON.stringify(i),c=Date.now(),s=r.get(o);if(s&&s.expires>c)return s.value;let y=e.apply(this,i);r.set(o,{value:y,expires:c+n});for(let[p,f]of r.entries())f.expires<=c&&r.delete(p);return y};return a.cache=r,a}function Z(e,n){let t,r=0;return function(...a){return++r<n&&(t=e.apply(this,a)),r>=n&&(e=void 0),t}}function ee(e,n){let t=0;return function(...r){if(++t>=n)return e.apply(this,r)}}function ne(e,n){return function(...t){try{return e.apply(this,t)}catch(r){return n(r,...t)}}}function te(...e){return W(...e)}function re(...e){return S(...e)}function ae(e,n={}){let{retries:t=3,delay:r=1e3,backoff:a=2,onRetry:i}=n;return async function(...o){let c,s=r;for(let y=0;y<=t;y++)try{return await e.apply(this,o)}catch(p){c=p,y<t&&(i&&i(c,y+1),await new Promise(f=>setTimeout(f,s)),s*=a)}throw c}}function ue(e,n,t){return async function(...r){return Promise.race([e.apply(this,r),new Promise((a,i)=>setTimeout(()=>{t&&t(),i(new Error(`Function timed out after ${n}ms`))},n))])}}export{ee as after,Q as ary,Z as before,H as bind,S as compose,_ as curry,M as debounce,V as defer,X as delay,K as flip,te as flow,re as flowRight,z as isAsyncFunction,I as isFunction,L as isPromise,j as memoize,Y as memoizeWithTTL,$ as negate,J as once,q as overArgs,B as partial,G as partialRight,W as pipe,N as rearg,ae as retry,O as throttle,ne as tryCatch,U as unary,ue as withTimeout};

package/dist/lib/functions/types.cjs

@@ -0,0 +1 @@
+"use strict";var t=Object.defineProperty;var a=Object.getOwnPropertyDescriptor;var b=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var d=(o,e,x,r)=>{if(e&&typeof e=="object"||typeof e=="function")for(let p of b(e))!c.call(o,p)&&p!==x&&t(o,p,{get:()=>e[p],enumerable:!(r=a(e,p))||r.enumerable});return o};var f=o=>d(t({},"__esModule",{value:!0}),o);var g={};module.exports=f(g);

package/dist/lib/functions/types.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/lib/functions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/functions/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAA"}

package/dist/lib/functions/types.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/helpers.cjs

@@ -0,0 +1 @@
+"use strict";var u=Object.defineProperty;var s=Object.getOwnPropertyDescriptor;var p=Object.getOwnPropertyNames;var c=Object.prototype.hasOwnProperty;var a=(n,e)=>{for(var r in e)u(n,r,{get:e[r],enumerable:!0})},m=(n,e,r,o)=>{if(e&&typeof e=="object"||typeof e=="function")for(let t of p(e))!c.call(n,t)&&t!==r&&u(n,t,{get:()=>e[t],enumerable:!(o=s(e,t))||o.enumerable});return n};var y=n=>m(u({},"__esModule",{value:!0}),n);var w={};a(w,{generateID:()=>k,generateUUID:()=>U,getKind:()=>T,isDefined:()=>b,isNull:()=>g,isPrimitive:()=>d,isUndefined:()=>v,isUndefinedOrNull:()=>O});module.exports=y(w);var x=require("@fluixi/utils/primitive"),i=require("@fluixi/utils/object"),f=require("@fluixi/utils/array"),l=require("@fluixi/utils/functions");function g(n){return n===null}function v(n){return n===void 0}var O=n=>typeof n>"u"||n===null;function d(n){let e=typeof n;return n===null||e==="string"||e==="number"||e==="boolean"||e==="symbol"||e==="bigint"||e==="undefined"||(0,x.isDate)(n)}function b(n){return n!=null}function T(n){return n===null?"null":n===void 0?"undefined":(0,x.isDate)(n)?"date":(0,i.isClass)(n)?"class":(0,l.isFunction)(n)?"function":(0,f.isArray)(n)?"array":d(n)?"primitive":(0,i.isObject)(n)?"object":"primitive"}var U=()=>"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g,function(n){let e=Math.random()*16|0;return(n==="x"?e:e&3|8).toString(16)}),k=()=>"xxyxxxxxxy-4xx8".replace(/[xy]/g,function(n){let e=Math.random()*16|0;return(n==="x"?e:e&3|8).toString(16)});

package/dist/lib/helpers.d.ts

@@ -0,0 +1,13 @@
+import { ObjectKind, ObjectType, UndefinedOrNullType } from '@fluixi/utils/primitive';
+/** Check if value is null */
+export declare function isNull(v: unknown): v is null;
+/** Check if value is undefined */
+export declare function isUndefined(v: unknown): v is undefined;
+export declare const isUndefinedOrNull: (element: unknown) => element is UndefinedOrNullType;
+/** Check if value is primitive */
+export declare function isPrimitive(v: unknown): v is string | number | boolean | symbol | bigint | null | undefined | Date;
+export declare function isDefined(obj: unknown): obj is ObjectType;
+export declare function getKind<T>(obj: T): ObjectKind;
+export declare const generateUUID: () => string;
+export declare const generateID: () => string;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/lib/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../src/lib/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,UAAU,EACV,UAAU,EACV,mBAAmB,EACpB,MAAM,yBAAyB,CAAC;AAKjC,6BAA6B;AAC7B,wBAAgB,MAAM,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,IAAI,CAE5C;AAED,kCAAkC;AAClC,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,GAAG,CAAC,IAAI,SAAS,CAEtD;AAED,eAAO,MAAM,iBAAiB,GAC5B,SAAS,OAAO,KACf,OAAO,IAAI,mBAGb,CAAC;AACF,kCAAkC;AAClC,wBAAgB,WAAW,CACzB,CAAC,EAAE,OAAO,GACT,CAAC,IAAI,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAY5E;AAED,wBAAgB,SAAS,CAAC,GAAG,EAAE,OAAO,GAAG,GAAG,IAAI,UAAU,CAEzD;AAED,wBAAgB,OAAO,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,UAAU,CAY7C;AAED,eAAO,MAAM,YAAY,cAMxB,CAAC;AACF,eAAO,MAAM,UAAU,cAMtB,CAAC"}