@ls-stack/utils 1.0.0 → 1.2.0

package/dist/arrayUtils.d.ts

@@ -24,7 +24,7 @@ type SortOrder = 'desc' | 'asc';
  *
  * Sort by `ascending` order by default
  *
- * Use `Infinity` as as wildcard to absulute max and min values
+ * Use `Infinity` as as wildcard to absolute max and min values
  *
  * @example
  * const items = [1, 3, 2, 4];
@@ -37,14 +37,15 @@ type SortOrder = 'desc' | 'asc';
  * // return a array to sort by multiple values
  * const sortedItems = sortBy(items, (item) => [item.a, item.b]);
  **/
-declare function sortBy<T>(arr: T[], sortByValue: (item: T) => (number | string)[] | number | string, { order }?: {
+declare function sortBy<T>(arr: T[], sortByValue: (item: T) => (number | string)[] | number | string, props?: {
     order?: SortOrder | SortOrder[];
-}): T[];
+} | SortOrder | SortOrder[]): T[];
 declare function arrayWithPrev<T>(array: T[]): [current: T, prev: T | null][];
 declare function arrayWithPrevAndIndex<T>(array: T[]): {
     item: T;
     prev: T | null;
     index: number;
 }[];
+declare function isInArray<T, const U extends T>(value: T, oneOf: readonly U[]): value is U;
 
-export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, sortBy };
+export { type FilterAndMapReturn, arrayWithPrev, arrayWithPrevAndIndex, filterAndMap, isInArray, sortBy };

package/dist/arrayUtils.js

@@ -2,12 +2,14 @@ import {
   arrayWithPrev,
   arrayWithPrevAndIndex,
   filterAndMap,
+  isInArray,
   sortBy
-} from "./chunk-5SB253CL.js";
+} from "./chunk-W7X6NSGR.js";
 export {
   arrayWithPrev,
   arrayWithPrevAndIndex,
   filterAndMap,
+  isInArray,
   sortBy
 };
 //# sourceMappingURL=arrayUtils.js.map

package/dist/{chunk-5SB253CL.js → chunk-W7X6NSGR.js}

@@ -11,7 +11,8 @@ function filterAndMap(array, mapFilter) {
   }
   return result;
 }
-function sortBy(arr, sortByValue, { order = "asc" } = {}) {
+function sortBy(arr, sortByValue, props = "asc") {
+  const order = Array.isArray(props) || typeof props === "string" ? props : props.order ?? "asc";
   return [...arr].sort((a, b) => {
     const _aPriority = sortByValue(a);
     const _bPriority = sortByValue(b);
@@ -44,11 +45,20 @@ function arrayWithPrevAndIndex(array) {
     index: i
   }));
 }
+function isInArray(value, oneOf) {
+  for (let i = 0; i < oneOf.length; i++) {
+    if (oneOf[i] === value) {
+      return true;
+    }
+  }
+  return false;
+}
 
 export {
   filterAndMap,
   sortBy,
   arrayWithPrev,
-  arrayWithPrevAndIndex
+  arrayWithPrevAndIndex,
+  isInArray
 };
-//# sourceMappingURL=chunk-5SB253CL.js.map
+//# sourceMappingURL=chunk-W7X6NSGR.js.map

package/dist/chunk-W7X6NSGR.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/arrayUtils.ts"],"sourcesContent":["/**\n * allow to filter and map with better typing ergonomics\n *\n * In the `mapFilter` function return `false` to reject the item, or any other\n * value to map it.\n *\n * @example\n * // Filter reject and turn value into `value mapped`\n * const items = ['value', 'value', 'reject', 'reject'];\n *\n * const mappedItems = filterAndMap(items, (item) =>\n *   item === 'reject'\n *     ? false\n *     : `${item} mapped`,\n * );\n *\n * mappedItems; // ['value mapped', 'value mapped']\n */\nexport function filterAndMap<T, R>(\n  array: IterableIterator<T> | readonly T[],\n  mapFilter: (item: T, index: number) => false | R,\n): R[] {\n  const result: R[] = [];\n\n  let i = -1;\n  for (const item of array) {\n    i += 1;\n    const filterResult = mapFilter(item, i);\n\n    if (filterResult !== false) {\n      result.push(filterResult);\n    }\n  }\n\n  return result;\n}\n\nexport type FilterAndMapReturn<T> = false | T;\n\ntype SortOrder = 'desc' | 'asc';\n\n/**\n * Sort an array based on a value\n *\n * Sort by `ascending` order by default\n *\n * Use `Infinity` as as wildcard to absolute max and min values\n *\n * @example\n * const items = [1, 3, 2, 4];\n *\n * const sortedItems = sortBy(items, (item) => item);\n * // [1, 2, 3, 4]\n *\n * const items2 = [{ a: 1, b: 2 }, { a: 2, b: 1 }, { a: 1, b: 1}]\n *\n * // return a array to sort by multiple values\n * const sortedItems = sortBy(items, (item) => [item.a, item.b]);\n **/\nexport function sortBy<T>(\n  arr: T[],\n  sortByValue: (item: T) => (number | string)[] | number | string,\n  props: { order?: SortOrder | SortOrder[] } | SortOrder | SortOrder[] = 'asc',\n) {\n  const order =\n    Array.isArray(props) || typeof props === 'string' ?\n      props\n    : props.order ?? 'asc';\n\n  return [...arr].sort((a, b) => {\n    const _aPriority = sortByValue(a);\n    const _bPriority = sortByValue(b);\n\n    const aPriority = Array.isArray(_aPriority) ? _aPriority : [_aPriority];\n    const bPriority = Array.isArray(_bPriority) ? _bPriority : [_bPriority];\n\n    for (let i = 0; i < aPriority.length; i++) {\n      const levelOrder: SortOrder =\n        typeof order === 'string' ? order : order[i] ?? 'asc';\n\n      const aP = aPriority[i] ?? 0;\n      const bP = bPriority[i] ?? 0;\n\n      if (aP === bP) {\n        continue;\n      }\n\n      if (bP === Infinity || aP === -Infinity || aP < bP) {\n        return levelOrder === 'asc' ? -1 : 1;\n      }\n\n      if (aP === Infinity || bP === -Infinity || aP > bP) {\n        return levelOrder === 'asc' ? 1 : -1;\n      }\n    }\n\n    return 0;\n  });\n}\n\nexport function arrayWithPrev<T>(array: T[]): [current: T, prev: T | null][] {\n  return array.map((item, i) => [item, array[i - 1] ?? null]);\n}\n\nexport function arrayWithPrevAndIndex<T>(\n  array: T[],\n): { item: T; prev: T | null; index: number }[] {\n  return array.map((item, i) => ({\n    item,\n    prev: array[i - 1] ?? null,\n    index: i,\n  }));\n}\n\nexport function isInArray<T, const U extends T>(\n  value: T,\n  oneOf: readonly U[],\n): value is U {\n  for (let i = 0; i < oneOf.length; i++) {\n    if (oneOf[i] === value) {\n      return true;\n    }\n  }\n\n  return false;\n}\n"],"mappings":";AAkBO,SAAS,aACd,OACA,WACK;AACL,QAAM,SAAc,CAAC;AAErB,MAAI,IAAI;AACR,aAAW,QAAQ,OAAO;AACxB,SAAK;AACL,UAAM,eAAe,UAAU,MAAM,CAAC;AAEtC,QAAI,iBAAiB,OAAO;AAC1B,aAAO,KAAK,YAAY;AAAA,IAC1B;AAAA,EACF;AAEA,SAAO;AACT;AAwBO,SAAS,OACd,KACA,aACA,QAAuE,OACvE;AACA,QAAM,QACJ,MAAM,QAAQ,KAAK,KAAK,OAAO,UAAU,WACvC,QACA,MAAM,SAAS;AAEnB,SAAO,CAAC,GAAG,GAAG,EAAE,KAAK,CAAC,GAAG,MAAM;AAC7B,UAAM,aAAa,YAAY,CAAC;AAChC,UAAM,aAAa,YAAY,CAAC;AAEhC,UAAM,YAAY,MAAM,QAAQ,UAAU,IAAI,aAAa,CAAC,UAAU;AACtE,UAAM,YAAY,MAAM,QAAQ,UAAU,IAAI,aAAa,CAAC,UAAU;AAEtE,aAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACzC,YAAM,aACJ,OAAO,UAAU,WAAW,QAAQ,MAAM,CAAC,KAAK;AAElD,YAAM,KAAK,UAAU,CAAC,KAAK;AAC3B,YAAM,KAAK,UAAU,CAAC,KAAK;AAE3B,UAAI,OAAO,IAAI;AACb;AAAA,MACF;AAEA,UAAI,OAAO,YAAY,OAAO,aAAa,KAAK,IAAI;AAClD,eAAO,eAAe,QAAQ,KAAK;AAAA,MACrC;AAEA,UAAI,OAAO,YAAY,OAAO,aAAa,KAAK,IAAI;AAClD,eAAO,eAAe,QAAQ,IAAI;AAAA,MACpC;AAAA,IACF;AAEA,WAAO;AAAA,EACT,CAAC;AACH;AAEO,SAAS,cAAiB,OAA4C;AAC3E,SAAO,MAAM,IAAI,CAAC,MAAM,MAAM,CAAC,MAAM,MAAM,IAAI,CAAC,KAAK,IAAI,CAAC;AAC5D;AAEO,SAAS,sBACd,OAC8C;AAC9C,SAAO,MAAM,IAAI,CAAC,MAAM,OAAO;AAAA,IAC7B;AAAA,IACA,MAAM,MAAM,IAAI,CAAC,KAAK;AAAA,IACtB,OAAO;AAAA,EACT,EAAE;AACJ;AAEO,SAAS,UACd,OACA,OACY;AACZ,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,QAAI,MAAM,CAAC,MAAM,OAAO;AACtB,aAAO;AAAA,IACT;AAAA,EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/debounce.d.ts

@@ -0,0 +1,45 @@
+type DebounceOptions = {
+    /**
+     * @see _.leading
+     */
+    leading?: boolean;
+    /**
+     * @see _.maxWait
+     */
+    maxWait?: number;
+    /**
+     * @see _.trailing
+     */
+    trailing?: boolean;
+};
+interface DebouncedFunc<T extends (...args: any[]) => void> {
+    /**
+     * Call the original function, but applying the debounce rules.
+     *
+     * If the debounced function can be run immediately, this calls it and returns its return
+     * value.
+     *
+     * Otherwise, it returns the return value of the last invocation, or undefined if the debounced
+     * function was not invoked yet.
+     */
+    (...args: Parameters<T>): ReturnType<T> | undefined;
+    /**
+     * Throw away any pending invocation of the debounced function.
+     */
+    cancel: () => void;
+    /**
+     * If there is a pending invocation of the debounced function, invoke it immediately and return
+     * its return value.
+     *
+     * Otherwise, return the value from the last invocation, or undefined if the debounced function
+     * was never invoked.
+     */
+    flush: () => ReturnType<T> | undefined;
+}
+declare function debounce<T extends (...args: any[]) => void>(func: T, wait: number, options?: DebounceOptions): DebouncedFunc<T>;
+declare function isDebouncedFn<T extends (...args: any[]) => void>(fn: T): fn is T & {
+    cancel: () => void;
+    flush: () => ReturnType<T> | undefined;
+};
+
+export { type DebounceOptions, type DebouncedFunc, debounce, isDebouncedFn };

package/dist/debounce.js

@@ -0,0 +1,100 @@
+// src/debounce.ts
+function debounce(func, wait, options) {
+  let lastArgs;
+  let lastThis;
+  let maxWait;
+  let result;
+  let timerId;
+  let lastCallTime;
+  let lastInvokeTime = 0;
+  let leading = false;
+  let maxing = false;
+  let trailing = true;
+  if (options) {
+    leading = !!options.leading;
+    maxing = "maxWait" in options;
+    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;
+    trailing = "trailing" in options ? !!options.trailing : trailing;
+  }
+  function invokeFunc(time) {
+    const args = lastArgs;
+    const thisArg = lastThis;
+    lastArgs = lastThis = void 0;
+    lastInvokeTime = time;
+    result = func.apply(thisArg, args);
+    return result;
+  }
+  function leadingEdge(time) {
+    lastInvokeTime = time;
+    timerId = setTimeout(timerExpired, wait);
+    return leading ? invokeFunc(time) : result;
+  }
+  function remainingWait(time) {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    const timeWaiting = wait - timeSinceLastCall;
+    return maxing ? Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke) : timeWaiting;
+  }
+  function shouldInvoke(time) {
+    const timeSinceLastCall = time - (lastCallTime ?? 0);
+    const timeSinceLastInvoke = time - lastInvokeTime;
+    return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= (maxWait ?? 0);
+  }
+  function timerExpired() {
+    const time = Date.now();
+    if (shouldInvoke(time)) {
+      return trailingEdge(time);
+    }
+    timerId = setTimeout(timerExpired, remainingWait(time));
+  }
+  function trailingEdge(time) {
+    timerId = void 0;
+    if (trailing && lastArgs) {
+      return invokeFunc(time);
+    }
+    lastArgs = lastThis = void 0;
+    return result;
+  }
+  function cancel() {
+    if (timerId !== void 0) {
+      clearTimeout(timerId);
+    }
+    lastInvokeTime = 0;
+    lastArgs = lastCallTime = lastThis = timerId = void 0;
+  }
+  function flush() {
+    return timerId === void 0 ? result : trailingEdge(Date.now());
+  }
+  function debounced() {
+    const time = Date.now();
+    const isInvoking = shouldInvoke(time);
+    lastArgs = arguments;
+    lastThis = this;
+    lastCallTime = time;
+    if (isInvoking) {
+      if (timerId === void 0) {
+        return leadingEdge(lastCallTime);
+      }
+      if (maxing) {
+        clearTimeout(timerId);
+        timerId = setTimeout(timerExpired, wait);
+        return invokeFunc(lastCallTime);
+      }
+    }
+    if (timerId === void 0) {
+      timerId = setTimeout(timerExpired, wait);
+    }
+    return result;
+  }
+  debounced.cancel = cancel;
+  debounced.flush = flush;
+  return debounced;
+}
+function isDebouncedFn(fn) {
+  return typeof fn === "function" && "cancel" in fn && "flush" in fn;
+}
+export {
+  debounce,
+  isDebouncedFn
+};
+//# sourceMappingURL=debounce.js.map

package/dist/debounce.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/debounce.ts"],"sourcesContent":["export type DebounceOptions = {\n  /**\n   * @see _.leading\n   */\n  leading?: boolean;\n  /**\n   * @see _.maxWait\n   */\n  maxWait?: number;\n  /**\n   * @see _.trailing\n   */\n  trailing?: boolean;\n};\n\nexport interface DebouncedFunc<T extends (...args: any[]) => void> {\n  /**\n   * Call the original function, but applying the debounce rules.\n   *\n   * If the debounced function can be run immediately, this calls it and returns its return\n   * value.\n   *\n   * Otherwise, it returns the return value of the last invocation, or undefined if the debounced\n   * function was not invoked yet.\n   */\n  (...args: Parameters<T>): ReturnType<T> | undefined;\n\n  /**\n   * Throw away any pending invocation of the debounced function.\n   */\n  cancel: () => void;\n\n  /**\n   * If there is a pending invocation of the debounced function, invoke it immediately and return\n   * its return value.\n   *\n   * Otherwise, return the value from the last invocation, or undefined if the debounced function\n   * was never invoked.\n   */\n  flush: () => ReturnType<T> | undefined;\n}\n\n// forked from lodash/debounce\nexport function debounce<T extends (...args: any[]) => void>(\n  func: T,\n  wait: number,\n  options?: DebounceOptions,\n): DebouncedFunc<T> {\n  let lastArgs: IArguments | undefined;\n  let lastThis: undefined;\n  let maxWait: number | undefined;\n  let result: any;\n  let timerId: NodeJS.Timeout | undefined;\n  let lastCallTime: number | undefined;\n  let lastInvokeTime = 0;\n  let leading = false;\n  let maxing = false;\n  let trailing = true;\n\n  if (options) {\n    leading = !!options.leading;\n    maxing = 'maxWait' in options;\n    maxWait = maxing ? Math.max(options.maxWait || 0, wait) : maxWait;\n    trailing = 'trailing' in options ? !!options.trailing : trailing;\n  }\n\n  function invokeFunc(time: number) {\n    const args = lastArgs;\n    const thisArg = lastThis;\n\n    lastArgs = lastThis = undefined;\n    lastInvokeTime = time;\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument\n    result = func.apply(thisArg, args as any);\n    return result;\n  }\n\n  function leadingEdge(time: number) {\n    // Reset any `maxWait` timer.\n    lastInvokeTime = time;\n    // Start the timer for the trailing edge.\n    timerId = setTimeout(timerExpired, wait);\n    // Invoke the leading edge.\n    return leading ? invokeFunc(time) : result;\n  }\n\n  function remainingWait(time: number) {\n    const timeSinceLastCall = time - (lastCallTime ?? 0);\n    const timeSinceLastInvoke = time - lastInvokeTime;\n    const timeWaiting = wait - timeSinceLastCall;\n\n    return maxing ?\n        Math.min(timeWaiting, (maxWait ?? 0) - timeSinceLastInvoke)\n      : timeWaiting;\n  }\n\n  function shouldInvoke(time: number) {\n    const timeSinceLastCall = time - (lastCallTime ?? 0);\n    const timeSinceLastInvoke = time - lastInvokeTime;\n\n    // Either this is the first call, activity has stopped and we're at the\n    // trailing edge, the system time has gone backwards and we're treating\n    // it as the trailing edge, or we've hit the `maxWait` limit.\n    return (\n      lastCallTime === undefined ||\n      timeSinceLastCall >= wait ||\n      timeSinceLastCall < 0 ||\n      (maxing && timeSinceLastInvoke >= (maxWait ?? 0))\n    );\n  }\n\n  function timerExpired() {\n    const time = Date.now();\n    if (shouldInvoke(time)) {\n      return trailingEdge(time);\n    }\n    // Restart the timer.\n    timerId = setTimeout(timerExpired, remainingWait(time));\n  }\n\n  function trailingEdge(time: number) {\n    timerId = undefined;\n\n    // Only invoke if we have `lastArgs` which means `func` has been\n    // debounced at least once.\n    if (trailing && lastArgs) {\n      return invokeFunc(time);\n    }\n    lastArgs = lastThis = undefined;\n    return result;\n  }\n\n  function cancel() {\n    if (timerId !== undefined) {\n      clearTimeout(timerId);\n    }\n    lastInvokeTime = 0;\n    lastArgs = lastCallTime = lastThis = timerId = undefined;\n  }\n\n  function flush() {\n    return timerId === undefined ? result : trailingEdge(Date.now());\n  }\n\n  function debounced(this: any) {\n    const time = Date.now();\n    const isInvoking = shouldInvoke(time);\n\n    lastArgs = arguments;\n    // eslint-disable-next-line @typescript-eslint/no-this-alias -- this is a forked code, so a refactor is not worth it\n    lastThis = this;\n    lastCallTime = time;\n\n    if (isInvoking) {\n      if (timerId === undefined) {\n        return leadingEdge(lastCallTime);\n      }\n      if (maxing) {\n        // Handle invocations in a tight loop.\n        clearTimeout(timerId);\n        timerId = setTimeout(timerExpired, wait);\n        return invokeFunc(lastCallTime);\n      }\n    }\n    if (timerId === undefined) {\n      timerId = setTimeout(timerExpired, wait);\n    }\n    return result;\n  }\n  debounced.cancel = cancel;\n  debounced.flush = flush;\n\n  return debounced;\n}\n\nexport function isDebouncedFn<T extends (...args: any[]) => void>(\n  fn: T,\n): fn is T & {\n  cancel: () => void;\n  flush: () => ReturnType<T> | undefined;\n} {\n  return typeof fn === 'function' && 'cancel' in fn && 'flush' in fn;\n}\n"],"mappings":";AA2CO,SAAS,SACd,MACA,MACA,SACkB;AAClB,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI,iBAAiB;AACrB,MAAI,UAAU;AACd,MAAI,SAAS;AACb,MAAI,WAAW;AAEf,MAAI,SAAS;AACX,cAAU,CAAC,CAAC,QAAQ;AACpB,aAAS,aAAa;AACtB,cAAU,SAAS,KAAK,IAAI,QAAQ,WAAW,GAAG,IAAI,IAAI;AAC1D,eAAW,cAAc,UAAU,CAAC,CAAC,QAAQ,WAAW;AAAA,EAC1D;AAEA,WAAS,WAAW,MAAc;AAChC,UAAM,OAAO;AACb,UAAM,UAAU;AAEhB,eAAW,WAAW;AACtB,qBAAiB;AAEjB,aAAS,KAAK,MAAM,SAAS,IAAW;AACxC,WAAO;AAAA,EACT;AAEA,WAAS,YAAY,MAAc;AAEjC,qBAAiB;AAEjB,cAAU,WAAW,cAAc,IAAI;AAEvC,WAAO,UAAU,WAAW,IAAI,IAAI;AAAA,EACtC;AAEA,WAAS,cAAc,MAAc;AACnC,UAAM,oBAAoB,QAAQ,gBAAgB;AAClD,UAAM,sBAAsB,OAAO;AACnC,UAAM,cAAc,OAAO;AAE3B,WAAO,SACH,KAAK,IAAI,cAAc,WAAW,KAAK,mBAAmB,IAC1D;AAAA,EACN;AAEA,WAAS,aAAa,MAAc;AAClC,UAAM,oBAAoB,QAAQ,gBAAgB;AAClD,UAAM,sBAAsB,OAAO;AAKnC,WACE,iBAAiB,UACjB,qBAAqB,QACrB,oBAAoB,KACnB,UAAU,wBAAwB,WAAW;AAAA,EAElD;AAEA,WAAS,eAAe;AACtB,UAAM,OAAO,KAAK,IAAI;AACtB,QAAI,aAAa,IAAI,GAAG;AACtB,aAAO,aAAa,IAAI;AAAA,IAC1B;AAEA,cAAU,WAAW,cAAc,cAAc,IAAI,CAAC;AAAA,EACxD;AAEA,WAAS,aAAa,MAAc;AAClC,cAAU;AAIV,QAAI,YAAY,UAAU;AACxB,aAAO,WAAW,IAAI;AAAA,IACxB;AACA,eAAW,WAAW;AACtB,WAAO;AAAA,EACT;AAEA,WAAS,SAAS;AAChB,QAAI,YAAY,QAAW;AACzB,mBAAa,OAAO;AAAA,IACtB;AACA,qBAAiB;AACjB,eAAW,eAAe,WAAW,UAAU;AAAA,EACjD;AAEA,WAAS,QAAQ;AACf,WAAO,YAAY,SAAY,SAAS,aAAa,KAAK,IAAI,CAAC;AAAA,EACjE;AAEA,WAAS,YAAqB;AAC5B,UAAM,OAAO,KAAK,IAAI;AACtB,UAAM,aAAa,aAAa,IAAI;AAEpC,eAAW;AAEX,eAAW;AACX,mBAAe;AAEf,QAAI,YAAY;AACd,UAAI,YAAY,QAAW;AACzB,eAAO,YAAY,YAAY;AAAA,MACjC;AACA,UAAI,QAAQ;AAEV,qBAAa,OAAO;AACpB,kBAAU,WAAW,cAAc,IAAI;AACvC,eAAO,WAAW,YAAY;AAAA,MAChC;AAAA,IACF;AACA,QAAI,YAAY,QAAW;AACzB,gBAAU,WAAW,cAAc,IAAI;AAAA,IACzC;AACA,WAAO;AAAA,EACT;AACA,YAAU,SAAS;AACnB,YAAU,QAAQ;AAElB,SAAO;AACT;AAEO,SAAS,cACd,IAIA;AACA,SAAO,OAAO,OAAO,cAAc,YAAY,MAAM,WAAW;AAClE;","names":[]}

package/dist/main.d.ts

@@ -4,6 +4,7 @@
 ///<reference path="consoleFmt.d.ts" />
 ///<reference path="conversions.d.ts" />
 ///<reference path="createThrottleController.d.ts" />
+///<reference path="debounce.d.ts" />
 ///<reference path="dedent.d.ts" />
 ///<reference path="deepEqual.d.ts" />
 ///<reference path="enhancedMap.d.ts" />

package/dist/parallelAsyncResultCalls.js

@@ -1,10 +1,10 @@
-import {
-  sleep
-} from "./chunk-HLFWWIDK.js";
 import {
   Result,
   normalizeError
 } from "./chunk-HYFUWQ2E.js";
+import {
+  sleep
+} from "./chunk-HLFWWIDK.js";
 import "./chunk-4DRNU53E.js";
 import {
   invariant,

package/dist/testUtils.js

@@ -1,3 +1,6 @@
+import {
+  deepEqual
+} from "./chunk-JZUOIOMU.js";
 import {
   clampMin
 } from "./chunk-J66LUDLH.js";
@@ -8,13 +11,10 @@ import {
 import {
   arrayWithPrevAndIndex,
   filterAndMap
-} from "./chunk-5SB253CL.js";
+} from "./chunk-W7X6NSGR.js";
 import {
   isObject
 } from "./chunk-JT3EBBCA.js";
-import {
-  deepEqual
-} from "./chunk-JZUOIOMU.js";
 
 // src/testUtils.ts
 function createLoggerStore({

package/dist/typingFnUtils.d.ts

@@ -1,5 +1,15 @@
 import { NonPartial } from './typingUtils.js';
 
 declare function asNonPartial<T extends Record<string, unknown>>(obj: T): NonPartial<T>;
+/** a wrapper to Object.entries with a better typing inference */
+declare function typedObjectEntries<T extends Record<string, unknown>>(obj: T): NonNullable<{
+    [K in keyof T]: [K, T[K]];
+}[keyof T]>[];
+/** a wrapper to Object.keys with a better typing inference */
+declare function typedObjectKeys<T extends Record<string, unknown>>(obj: T): (keyof T)[];
+/** a safe way to cast types, use to substitute the `as Type` */
+declare function asType<T = unknown>(value: T): T;
+/** narrow a string to a union of strings */
+declare function narrowStringToUnion<const T extends string>(key: string | undefined | null, union: T[]): T | undefined;
 
-export { asNonPartial };
+export { asNonPartial, asType, narrowStringToUnion, typedObjectEntries, typedObjectKeys };

package/dist/typingFnUtils.js

@@ -2,7 +2,26 @@
 function asNonPartial(obj) {
   return obj;
 }
+function typedObjectEntries(obj) {
+  return Object.entries(obj);
+}
+function typedObjectKeys(obj) {
+  return Object.keys(obj);
+}
+function asType(value) {
+  return value;
+}
+function narrowStringToUnion(key, union) {
+  if (key && union.includes(key)) {
+    return key;
+  }
+  return void 0;
+}
 export {
-  asNonPartial
+  asNonPartial,
+  asType,
+  narrowStringToUnion,
+  typedObjectEntries,
+  typedObjectKeys
 };
 //# sourceMappingURL=typingFnUtils.js.map

package/dist/typingFnUtils.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/typingFnUtils.ts"],"sourcesContent":["import { NonPartial } from './typingUtils';\n\nexport function asNonPartial<T extends Record<string, unknown>>(\n  obj: T,\n): NonPartial<T> {\n  return obj;\n}\n"],"mappings":";AAEO,SAAS,aACd,KACe;AACf,SAAO;AACT;","names":[]}
+{"version":3,"sources":["../src/typingFnUtils.ts"],"sourcesContent":["import { NonPartial } from './typingUtils';\n\nexport function asNonPartial<T extends Record<string, unknown>>(\n  obj: T,\n): NonPartial<T> {\n  return obj;\n}\n\n/** a wrapper to Object.entries with a better typing inference */\nexport function typedObjectEntries<T extends Record<string, unknown>>(\n  obj: T,\n): NonNullable<\n  {\n    [K in keyof T]: [K, T[K]];\n  }[keyof T]\n>[] {\n  return Object.entries(obj) as any;\n}\n\n/** a wrapper to Object.keys with a better typing inference */\nexport function typedObjectKeys<T extends Record<string, unknown>>(\n  obj: T,\n): (keyof T)[] {\n  return Object.keys(obj) as any;\n}\n\n/** a safe way to cast types, use to substitute the `as Type` */\nexport function asType<T = unknown>(value: T): T {\n  return value;\n}\n\n/** narrow a string to a union of strings */\nexport function narrowStringToUnion<const T extends string>(\n  key: string | undefined | null,\n  union: T[],\n): T | undefined {\n  if (key && union.includes(key as T)) {\n    return key as T;\n  }\n\n  return undefined;\n}\n"],"mappings":";AAEO,SAAS,aACd,KACe;AACf,SAAO;AACT;AAGO,SAAS,mBACd,KAKE;AACF,SAAO,OAAO,QAAQ,GAAG;AAC3B;AAGO,SAAS,gBACd,KACa;AACb,SAAO,OAAO,KAAK,GAAG;AACxB;AAGO,SAAS,OAAoB,OAAa;AAC/C,SAAO;AACT;AAGO,SAAS,oBACd,KACA,OACe;AACf,MAAI,OAAO,MAAM,SAAS,GAAQ,GAAG;AACnC,WAAO;AAAA,EACT;AAEA,SAAO;AACT;","names":[]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ls-stack/utils",
   "description": "Typescript utils",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "license": "MIT",
   "files": [
     "dist"
@@ -40,6 +40,10 @@
       "import": "./dist/createThrottleController.js",
       "types": "./dist/createThrottleController.d.ts"
     },
+    "./debounce": {
+      "import": "./dist/debounce.js",
+      "types": "./dist/debounce.d.ts"
+    },
     "./dedent": {
       "import": "./dist/dedent.js",
       "types": "./dist/dedent.d.ts"
@@ -159,6 +163,9 @@
       "createThrottleController": [
         "./dist/createThrottleController.d.ts"
       ],
+      "debounce": [
+        "./dist/debounce.d.ts"
+      ],
       "dedent": [
         "./dist/dedent.d.ts"
       ],

package/dist/chunk-5SB253CL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/arrayUtils.ts"],"sourcesContent":["/**\n * allow to filter and map with better typing ergonomics\n *\n * In the `mapFilter` function return `false` to reject the item, or any other\n * value to map it.\n *\n * @example\n * // Filter reject and turn value into `value mapped`\n * const items = ['value', 'value', 'reject', 'reject'];\n *\n * const mappedItems = filterAndMap(items, (item) =>\n *   item === 'reject'\n *     ? false\n *     : `${item} mapped`,\n * );\n *\n * mappedItems; // ['value mapped', 'value mapped']\n */\nexport function filterAndMap<T, R>(\n  array: IterableIterator<T> | readonly T[],\n  mapFilter: (item: T, index: number) => false | R,\n): R[] {\n  const result: R[] = [];\n\n  let i = -1;\n  for (const item of array) {\n    i += 1;\n    const filterResult = mapFilter(item, i);\n\n    if (filterResult !== false) {\n      result.push(filterResult);\n    }\n  }\n\n  return result;\n}\n\nexport type FilterAndMapReturn<T> = false | T;\n\ntype SortOrder = 'desc' | 'asc';\n\n/**\n * Sort an array based on a value\n *\n * Sort by `ascending` order by default\n *\n * Use `Infinity` as as wildcard to absulute max and min values\n *\n * @example\n * const items = [1, 3, 2, 4];\n *\n * const sortedItems = sortBy(items, (item) => item);\n * // [1, 2, 3, 4]\n *\n * const items2 = [{ a: 1, b: 2 }, { a: 2, b: 1 }, { a: 1, b: 1}]\n *\n * // return a array to sort by multiple values\n * const sortedItems = sortBy(items, (item) => [item.a, item.b]);\n **/\nexport function sortBy<T>(\n  arr: T[],\n  sortByValue: (item: T) => (number | string)[] | number | string,\n  { order = 'asc' }: { order?: SortOrder | SortOrder[] } = {},\n) {\n  return [...arr].sort((a, b) => {\n    const _aPriority = sortByValue(a);\n    const _bPriority = sortByValue(b);\n\n    const aPriority = Array.isArray(_aPriority) ? _aPriority : [_aPriority];\n    const bPriority = Array.isArray(_bPriority) ? _bPriority : [_bPriority];\n\n    for (let i = 0; i < aPriority.length; i++) {\n      const levelOrder: SortOrder =\n        typeof order === 'string' ? order : order[i] ?? 'asc';\n\n      const aP = aPriority[i] ?? 0;\n      const bP = bPriority[i] ?? 0;\n\n      if (aP === bP) {\n        continue;\n      }\n\n      if (bP === Infinity || aP === -Infinity || aP < bP) {\n        return levelOrder === 'asc' ? -1 : 1;\n      }\n\n      if (aP === Infinity || bP === -Infinity || aP > bP) {\n        return levelOrder === 'asc' ? 1 : -1;\n      }\n    }\n\n    return 0;\n  });\n}\n\nexport function arrayWithPrev<T>(array: T[]): [current: T, prev: T | null][] {\n  return array.map((item, i) => [item, array[i - 1] ?? null]);\n}\n\nexport function arrayWithPrevAndIndex<T>(\n  array: T[],\n): { item: T; prev: T | null; index: number }[] {\n  return array.map((item, i) => ({\n    item,\n    prev: array[i - 1] ?? null,\n    index: i,\n  }));\n}\n"],"mappings":";AAkBO,SAAS,aACd,OACA,WACK;AACL,QAAM,SAAc,CAAC;AAErB,MAAI,IAAI;AACR,aAAW,QAAQ,OAAO;AACxB,SAAK;AACL,UAAM,eAAe,UAAU,MAAM,CAAC;AAEtC,QAAI,iBAAiB,OAAO;AAC1B,aAAO,KAAK,YAAY;AAAA,IAC1B;AAAA,EACF;AAEA,SAAO;AACT;AAwBO,SAAS,OACd,KACA,aACA,EAAE,QAAQ,MAAM,IAAyC,CAAC,GAC1D;AACA,SAAO,CAAC,GAAG,GAAG,EAAE,KAAK,CAAC,GAAG,MAAM;AAC7B,UAAM,aAAa,YAAY,CAAC;AAChC,UAAM,aAAa,YAAY,CAAC;AAEhC,UAAM,YAAY,MAAM,QAAQ,UAAU,IAAI,aAAa,CAAC,UAAU;AACtE,UAAM,YAAY,MAAM,QAAQ,UAAU,IAAI,aAAa,CAAC,UAAU;AAEtE,aAAS,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;AACzC,YAAM,aACJ,OAAO,UAAU,WAAW,QAAQ,MAAM,CAAC,KAAK;AAElD,YAAM,KAAK,UAAU,CAAC,KAAK;AAC3B,YAAM,KAAK,UAAU,CAAC,KAAK;AAE3B,UAAI,OAAO,IAAI;AACb;AAAA,MACF;AAEA,UAAI,OAAO,YAAY,OAAO,aAAa,KAAK,IAAI;AAClD,eAAO,eAAe,QAAQ,KAAK;AAAA,MACrC;AAEA,UAAI,OAAO,YAAY,OAAO,aAAa,KAAK,IAAI;AAClD,eAAO,eAAe,QAAQ,IAAI;AAAA,MACpC;AAAA,IACF;AAEA,WAAO;AAAA,EACT,CAAC;AACH;AAEO,SAAS,cAAiB,OAA4C;AAC3E,SAAO,MAAM,IAAI,CAAC,MAAM,MAAM,CAAC,MAAM,MAAM,IAAI,CAAC,KAAK,IAAI,CAAC;AAC5D;AAEO,SAAS,sBACd,OAC8C;AAC9C,SAAO,MAAM,IAAI,CAAC,MAAM,OAAO;AAAA,IAC7B;AAAA,IACA,MAAM,MAAM,IAAI,CAAC,KAAK;AAAA,IACtB,OAAO;AAAA,EACT,EAAE;AACJ;","names":[]}