@rimbu/common 1.0.0 → 2.0.0

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

@@ -25,15 +25,15 @@ __export(async_optlazy_exports, {
 module.exports = __toCommonJS(async_optlazy_exports);
 var AsyncOptLazy;
 ((AsyncOptLazy2) => {
-  function toMaybePromise(optLazy) {
+  function toMaybePromise(optLazy, ...args) {
     if (optLazy instanceof Function)
-      return optLazy();
+      return optLazy(...args);
     return optLazy;
   }
   AsyncOptLazy2.toMaybePromise = toMaybePromise;
-  async function toPromise(optLazy) {
+  async function toPromise(optLazy, ...args) {
     if (optLazy instanceof Function)
-      return optLazy();
+      return optLazy(...args);
     return optLazy;
   }
   AsyncOptLazy2.toPromise = toPromise;