@rimbu/common 1.1.0 → 2.0.1

package/dist/bun/async-optlazy.mts

@@ -9,13 +9,17 @@ export type MaybePromise<T> = T | Promise<T>;
 /**
  * A potentially lazy and/or asynchronous value of type T.
  * @typeparam T - the value type
+ * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
  */
-export type AsyncOptLazy<T> = OptLazy<MaybePromise<T>>;
+export type AsyncOptLazy<T, A extends any[] = []> = OptLazy<MaybePromise<T>, A>;
 
 export namespace AsyncOptLazy {
   /**
    * Returns the value or promised value contained in an `AsyncOptLazy` instance of type T.
    * @param optLazy - the `AsyncOptLazy` value of type T
+   * @param args - when needed, the extra arguments to pass to the lazy invocation
+   * @typeparam T - the value type
+   * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
    * @example
    * ```ts
    * AsyncOptLazy.toMaybePromise(1)              // => 1
@@ -25,14 +29,20 @@ export namespace AsyncOptLazy {
    * AsyncOptLazy.toMaybePromise(Promise.resolve(1))  // => Promise(1)
    * ```
    */
-  export function toMaybePromise<T>(optLazy: AsyncOptLazy<T>): MaybePromise<T> {
-    if (optLazy instanceof Function) return optLazy();
+  export function toMaybePromise<T, A extends any[] = []>(
+    optLazy: AsyncOptLazy<T, A>,
+    ...args: A
+  ): MaybePromise<T> {
+    if (optLazy instanceof Function) return optLazy(...args);
     return optLazy;
   }
 
   /**
    * Returns the value contained in an `AsyncOptLazy` instance of type T as a promise.
    * @param optLazy - the `AsyncOptLazy` value of type T
+   * @param args - when needed, the extra arguments to pass to the lazy invocation
+   * @typeparam T - the value type
+   * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
    * @example
    * ```ts
    * AsyncOptLazy.toPromise(1)              // => Promise(1)
@@ -42,8 +52,11 @@ export namespace AsyncOptLazy {
    * AsyncOptLazy.toPromise(Promise.resolve(1))  // => Promise(1)
    * ```
    */
-  export async function toPromise<T>(optLazy: AsyncOptLazy<T>): Promise<T> {
-    if (optLazy instanceof Function) return optLazy();
+  export async function toPromise<T, A extends any[] = []>(
+    optLazy: AsyncOptLazy<T, A>,
+    ...args: A
+  ): Promise<T> {
+    if (optLazy instanceof Function) return optLazy(...args);
     return optLazy;
   }
 }

package/dist/bun/internal.mts

@@ -5,9 +5,7 @@ export * from './err.mts';
 export * from './index-range.mts';
 export * from './optlazy.mts';
 export * from './range.mts';
-export * from './reducer.mts';
 export * from './traverse-state.mts';
 export * from './types.mts';
 export * from './update.mts';
 export * from './async-optlazy.mts';
-export * from './async-reducer.mts';

package/dist/bun/optlazy.mts

@@ -1,12 +1,16 @@
 /**
  * A potentially lazy value of type T.
  * @typeparam T - the value type
+ * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
  */
-export type OptLazy<T> = T | (() => T);
+export type OptLazy<T, A extends any[] = []> = T | ((...args: A) => T);
 
 /**
  * Returns the value contained in an `OptLazy` instance of type T.
  * @param optLazy - the `OptLazy` value of type T
+ * @param args - when needed, the extra arguments to pass to the lazy invocation
+ * @typeparam T - the value type
+ * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
  * @example
  * ```ts
  * OptLazy(1)              // => 1
@@ -14,8 +18,11 @@ export type OptLazy<T> = T | (() => T);
  * OptLazy(() => () => 1)  // => () => 1
  * ```
  */
-export function OptLazy<T>(optLazy: OptLazy<T>): T {
-  if (optLazy instanceof Function) return optLazy();
+export function OptLazy<T, A extends any[] = []>(
+  optLazy: OptLazy<T, A>,
+  ...args: A
+): T {
+  if (optLazy instanceof Function) return optLazy(...args);
   return optLazy;
 }
 
@@ -32,6 +39,8 @@ export type OptLazyOr<T, O> = T | ((none: O) => T | O);
  * `otherValue` if the lazy function returns it.
  * @param optLazyOr - a value or a function returning a value or otherwise the received value
  * @param otherValue - the value to return if the optLazyOr does not return its own value
+ * @typeparam T - the value type
+ * @typeparam O - the default value type
  * @example
  * ```ts
  * OptLazyOr(1, 'a')               // => 1

package/dist/cjs/async-optlazy.cjs

@@ -1,44 +1,62 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/async-optlazy.mts
-var async_optlazy_exports = {};
-__export(async_optlazy_exports, {
-  AsyncOptLazy: () => AsyncOptLazy
-});
-module.exports = __toCommonJS(async_optlazy_exports);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncOptLazy = void 0;
+var tslib_1 = require("tslib");
 var AsyncOptLazy;
-((AsyncOptLazy2) => {
-  function toMaybePromise(optLazy) {
-    if (optLazy instanceof Function)
-      return optLazy();
-    return optLazy;
-  }
-  AsyncOptLazy2.toMaybePromise = toMaybePromise;
-  async function toPromise(optLazy) {
-    if (optLazy instanceof Function)
-      return optLazy();
-    return optLazy;
-  }
-  AsyncOptLazy2.toPromise = toPromise;
-})(AsyncOptLazy || (AsyncOptLazy = {}));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AsyncOptLazy
-});
+(function (AsyncOptLazy) {
+    /**
+     * Returns the value or promised value contained in an `AsyncOptLazy` instance of type T.
+     * @param optLazy - the `AsyncOptLazy` value of type T
+     * @param args - when needed, the extra arguments to pass to the lazy invocation
+     * @typeparam T - the value type
+     * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
+     * @example
+     * ```ts
+     * AsyncOptLazy.toMaybePromise(1)              // => 1
+     * AsyncOptLazy.toMaybePromise(() => 1)        // => 1
+     * AsyncOptLazy.toMaybePromise(() => () => 1)  // => () => 1
+     * AsyncOptLazy.toMaybePromise(async () => 1)  // => Promise(1)
+     * AsyncOptLazy.toMaybePromise(Promise.resolve(1))  // => Promise(1)
+     * ```
+     */
+    function toMaybePromise(optLazy) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        if (optLazy instanceof Function)
+            return optLazy.apply(void 0, tslib_1.__spreadArray([], tslib_1.__read(args), false));
+        return optLazy;
+    }
+    AsyncOptLazy.toMaybePromise = toMaybePromise;
+    /**
+     * Returns the value contained in an `AsyncOptLazy` instance of type T as a promise.
+     * @param optLazy - the `AsyncOptLazy` value of type T
+     * @param args - when needed, the extra arguments to pass to the lazy invocation
+     * @typeparam T - the value type
+     * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
+     * @example
+     * ```ts
+     * AsyncOptLazy.toPromise(1)              // => Promise(1)
+     * AsyncOptLazy.toPromise(() => 1)        // => Promise(1)
+     * AsyncOptLazy.toPromise(() => () => 1)  // => Promise(() => 1)
+     * AsyncOptLazy.toPromise(async () => 1)  // => Promise(1)
+     * AsyncOptLazy.toPromise(Promise.resolve(1))  // => Promise(1)
+     * ```
+     */
+    function toPromise(optLazy) {
+        var args = [];
+        for (var _i = 1; _i < arguments.length; _i++) {
+            args[_i - 1] = arguments[_i];
+        }
+        return tslib_1.__awaiter(this, void 0, void 0, function () {
+            return tslib_1.__generator(this, function (_a) {
+                if (optLazy instanceof Function)
+                    return [2 /*return*/, optLazy.apply(void 0, tslib_1.__spreadArray([], tslib_1.__read(args), false))];
+                return [2 /*return*/, optLazy];
+            });
+        });
+    }
+    AsyncOptLazy.toPromise = toPromise;
+})(AsyncOptLazy || (exports.AsyncOptLazy = AsyncOptLazy = {}));
+//# sourceMappingURL=async-optlazy.cjs.map

package/dist/cjs/async-optlazy.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-optlazy.cjs","sourceRoot":"","sources":["../../_cjs_prepare/async-optlazy.cts"],"names":[],"mappings":";;;;AAeA,IAAiB,YAAY,CA8C5B;AA9CD,WAAiB,YAAY;IAC3B;;;;;;;;;;;;;;OAcG;IACH,SAAgB,cAAc,CAC5B,OAA2B;QAC3B,cAAU;aAAV,UAAU,EAAV,qBAAU,EAAV,IAAU;YAAV,6BAAU;;QAEV,IAAI,OAAO,YAAY,QAAQ;YAAE,OAAO,OAAO,wDAAI,IAAI,WAAE;QACzD,OAAO,OAAO,CAAC;IACjB,CAAC;IANe,2BAAc,iBAM7B,CAAA;IAED;;;;;;;;;;;;;;OAcG;IACH,SAAsB,SAAS,CAC7B,OAA2B;QAC3B,cAAU;aAAV,UAAU,EAAV,qBAAU,EAAV,IAAU;YAAV,6BAAU;;;;gBAEV,IAAI,OAAO,YAAY,QAAQ;oBAAE,sBAAO,OAAO,wDAAI,IAAI,YAAE;gBACzD,sBAAO,OAAO,EAAC;;;KAChB;IANqB,sBAAS,YAM9B,CAAA;AACH,CAAC,EA9CgB,YAAY,4BAAZ,YAAY,QA8C5B"}

package/dist/cjs/async-optlazy.d.cts

@@ -0,0 +1,46 @@
+import type { OptLazy } from './internal.cjs';
+/**
+ * A type that is either a value T or a promise yielding a value of type T.
+ * @typeparam T - the value type
+ */
+export type MaybePromise<T> = T | Promise<T>;
+/**
+ * A potentially lazy and/or asynchronous value of type T.
+ * @typeparam T - the value type
+ * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
+ */
+export type AsyncOptLazy<T, A extends any[] = []> = OptLazy<MaybePromise<T>, A>;
+export declare namespace AsyncOptLazy {
+    /**
+     * Returns the value or promised value contained in an `AsyncOptLazy` instance of type T.
+     * @param optLazy - the `AsyncOptLazy` value of type T
+     * @param args - when needed, the extra arguments to pass to the lazy invocation
+     * @typeparam T - the value type
+     * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
+     * @example
+     * ```ts
+     * AsyncOptLazy.toMaybePromise(1)              // => 1
+     * AsyncOptLazy.toMaybePromise(() => 1)        // => 1
+     * AsyncOptLazy.toMaybePromise(() => () => 1)  // => () => 1
+     * AsyncOptLazy.toMaybePromise(async () => 1)  // => Promise(1)
+     * AsyncOptLazy.toMaybePromise(Promise.resolve(1))  // => Promise(1)
+     * ```
+     */
+    function toMaybePromise<T, A extends any[] = []>(optLazy: AsyncOptLazy<T, A>, ...args: A): MaybePromise<T>;
+    /**
+     * Returns the value contained in an `AsyncOptLazy` instance of type T as a promise.
+     * @param optLazy - the `AsyncOptLazy` value of type T
+     * @param args - when needed, the extra arguments to pass to the lazy invocation
+     * @typeparam T - the value type
+     * @typeparam A - (default: []) types of the argument array that can be passed in the lazy case
+     * @example
+     * ```ts
+     * AsyncOptLazy.toPromise(1)              // => Promise(1)
+     * AsyncOptLazy.toPromise(() => 1)        // => Promise(1)
+     * AsyncOptLazy.toPromise(() => () => 1)  // => Promise(() => 1)
+     * AsyncOptLazy.toPromise(async () => 1)  // => Promise(1)
+     * AsyncOptLazy.toPromise(Promise.resolve(1))  // => Promise(1)
+     * ```
+     */
+    function toPromise<T, A extends any[] = []>(optLazy: AsyncOptLazy<T, A>, ...args: A): Promise<T>;
+}

package/dist/cjs/collect.cjs

@@ -1,33 +1,11 @@
 "use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/collect.mts
-var collect_exports = {};
-__export(collect_exports, {
-  CollectFun: () => CollectFun
-});
-module.exports = __toCommonJS(collect_exports);
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectFun = void 0;
 var CollectFun;
-((CollectFun2) => {
-  CollectFun2.Skip = Symbol("Skip");
-})(CollectFun || (CollectFun = {}));
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CollectFun
-});
+(function (CollectFun) {
+    /**
+     * Indicates, when returned from a collect function, to skip the value.
+     */
+    CollectFun.Skip = Symbol('Skip');
+})(CollectFun || (exports.CollectFun = CollectFun = {}));
+//# sourceMappingURL=collect.cjs.map

package/dist/cjs/collect.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"collect.cjs","sourceRoot":"","sources":["../../_cjs_prepare/collect.cts"],"names":[],"mappings":";;;AAiBA,IAAiB,UAAU,CAU1B;AAVD,WAAiB,UAAU;IACzB;;OAEG;IACU,eAAI,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;AAMrC,CAAC,EAVgB,UAAU,0BAAV,UAAU,QAU1B"}

package/dist/cjs/collect.d.cts

@@ -0,0 +1,29 @@
+import type { MaybePromise } from './internal.cjs';
+/**
+ * A function used in `collect` methods to collect values from a collection. This is basically a single-pass map and filter.
+ * @param value - the input value
+ * @param index - the index of the input value
+ * @param skip - a token that can be returned to skip the value
+ * @param halt - a function that, when called, ensures no more values are passed
+ * @returns either a new value to collect, or the `skip` token indicating to skip the value
+ */
+export type CollectFun<T, R> = (value: T, index: number, skip: CollectFun.Skip, halt: () => void) => R | CollectFun.Skip;
+export declare namespace CollectFun {
+    /**
+     * Indicates, when returned from a collect function, to skip the value.
+     */
+    const Skip: unique symbol;
+    /**
+     * Indicates, when returned from a collect function, to skip the value.
+     */
+    type Skip = typeof Skip;
+}
+/**
+ * A potentially asynchronous function used in `collect` methods to collect values from a collection. This is basically a single-pass map and filter.
+ * @param value - the input value
+ * @param index - the index of the input value
+ * @param skip - a token that can be returned to skip the value
+ * @param halt - a function that, when called, ensures no more values are passed
+ * @returns either a new value to collect, or the `skip` token indicating to skip the value
+ */
+export type AsyncCollectFun<T, R> = (value: T, index: number, skip: CollectFun.Skip, halt: () => void) => MaybePromise<R | CollectFun.Skip>;