@fluixi/utils 1.0.0-alpha.83 → 1.0.0-alpha.84

package/dist/lib/functions/functions.mjs

@@ -1 +1,345 @@
-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};
+// src/lib/functions/functions.ts
+import { isClass } from "@fluixi/utils/object";
+function isFunction(v) {
+  return typeof v === "function" && !isClass(v);
+}
+function isPromise(v) {
+  return v instanceof Promise || !!v && (typeof v === "object" || typeof v === "function") && "then" in v;
+}
+function isAsyncFunction(v) {
+  return isFunction(v) && v.constructor.name === "AsyncFunction";
+}
+function memoize(fn, resolver) {
+  const cache = /* @__PURE__ */ 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;
+}
+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 = void 0;
+    lastInvokeTime = time;
+    result = fn.apply(thisArg, args);
+    return result;
+  }
+  function startTimer(pendingFunc, wait2) {
+    return setTimeout(pendingFunc, wait2);
+  }
+  function cancelTimer(id) {
+    if (id !== void 0) {
+      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 !== void 0 ? Math.min(timeWaiting, maxWait - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    const timeSinceLastCall = time - lastCallTime;
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxWait !== void 0 && timeSinceLastInvoke >= maxWait;
+  }
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      trailingEdge(time);
+      return;
+    }
+    timerId = startTimer(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    cancelTimer(timerId);
+    cancelTimer(maxTimerId);
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = maxTimerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(Date.now());
+  }
+  function pending() {
+    return timerId !== void 0;
+  }
+  function debounced(...args) {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = args;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxWait !== void 0) {
+        timerId = startTimer(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = startTimer(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  debounced.pending = pending;
+  return debounced;
+}
+function throttle(fn, wait, options = {}) {
+  const { leading = true, trailing = true } = options;
+  return debounce(fn, wait, {
+    leading,
+    trailing,
+    maxWait: wait
+  });
+}
+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;
+}
+function rearg(fn, ...indexes) {
+  return function(...args) {
+    const reordered = indexes.map((i) => args[i]);
+    return fn.apply(this, reordered);
+  };
+}
+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]);
+    };
+  };
+}
+function compose(...fns) {
+  return fns.reduceRight(
+    (prevFn, nextFn) => (value) => nextFn(prevFn(value)),
+    (value) => value
+  );
+}
+function pipe(...fns) {
+  return fns.reduce(
+    (prevFn, nextFn) => (value) => nextFn(prevFn(value)),
+    (value) => value
+  );
+}
+function negate(predicate) {
+  return function(...args) {
+    return !predicate.apply(this, args);
+  };
+}
+function overArgs(fn, ...transforms) {
+  return function(...args) {
+    const transformedArgs = args.map(
+      (arg, index) => transforms[index] ? transforms[index](arg) : arg
+    );
+    return fn.apply(this, transformedArgs);
+  };
+}
+function partial(fn, ...partials) {
+  return function(...args) {
+    return fn.apply(this, [...partials, ...args]);
+  };
+}
+function partialRight(fn, ...partials) {
+  return function(...args) {
+    return fn.apply(this, [...args, ...partials]);
+  };
+}
+function bind(fn, thisArg, ...partials) {
+  return function(...args) {
+    return fn.apply(thisArg, [...partials, ...args]);
+  };
+}
+function flip(fn) {
+  return function(...args) {
+    return fn.apply(this, args.reverse());
+  };
+}
+function ary(fn, n) {
+  return function(...args) {
+    return fn.apply(this, args.slice(0, n));
+  };
+}
+function unary(fn) {
+  return function(arg) {
+    return fn.call(this, arg);
+  };
+}
+function defer(fn, ...args) {
+  return setTimeout(fn, 1, ...args);
+}
+function delay(fn, wait, ...args) {
+  return setTimeout(fn, wait, ...args);
+}
+function memoizeWithTTL(fn, ttl, resolver) {
+  const cache = /* @__PURE__ */ 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 });
+    for (const [k, v] of cache.entries()) {
+      if (v.expires <= now) {
+        cache.delete(k);
+      }
+    }
+    return result;
+  };
+  memoized.cache = cache;
+  return memoized;
+}
+function before(fn, n) {
+  let result;
+  let callCount = 0;
+  return function(...args) {
+    if (++callCount < n) {
+      result = fn.apply(this, args);
+    }
+    if (callCount >= n) {
+      fn = void 0;
+    }
+    return result;
+  };
+}
+function after(fn, n) {
+  let callCount = 0;
+  return function(...args) {
+    if (++callCount >= n) {
+      return fn.apply(this, args);
+    }
+    return void 0;
+  };
+}
+function tryCatch(fn, errorHandler) {
+  return function(...args) {
+    try {
+      return fn.apply(this, args);
+    } catch (error) {
+      return errorHandler(error, ...args);
+    }
+  };
+}
+function flow(...fns) {
+  return pipe(...fns);
+}
+function flowRight(...fns) {
+  return compose(...fns);
+}
+function retry(fn, options = {}) {
+  const { retries = 3, delay: delay2 = 1e3, backoff = 2, onRetry } = options;
+  return async function(...args) {
+    let lastError;
+    let currentDelay = delay2;
+    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;
+  };
+}
+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)
+      )
+    ]);
+  };
+}
+export {
+  after,
+  ary,
+  before,
+  bind,
+  compose,
+  curry,
+  debounce,
+  defer,
+  delay,
+  flip,
+  flow,
+  flowRight,
+  isAsyncFunction,
+  isFunction,
+  isPromise,
+  memoize,
+  memoizeWithTTL,
+  negate,
+  once,
+  overArgs,
+  partial,
+  partialRight,
+  pipe,
+  rearg,
+  retry,
+  throttle,
+  tryCatch,
+  unary,
+  withTimeout
+};