@rimbu/common 0.12.3 → 1.0.0-alpha.1

package/README.md

@@ -2,6 +2,10 @@
     <img src="https://github.com/rimbu-org/rimbu/raw/main/assets/rimbu_logo.svg" />
 </p>
 
+[![npm version](https://badge.fury.io/js/@rimbu%2Fcommon.svg)](https://www.npmjs.com/package/@rimbu/common) [![Deno](https://shield.deno.dev/x/rimbu)](http://deno.land/x/rimbu)
+
+![Licence](https://img.shields.io/github/license/rimbu-org/rimbu)
+
 # @rimbu/common
 
 This package exports common types and objects used in many other Rimbu packages.
@@ -30,18 +34,31 @@ Or [Try Out Rimbu](https://codesandbox.io/s/github/vitoke/rimbu-sandbox/tree/mai
 
 ## Installation
 
-All types are exported through `@rimbu/core`. It is recommended to use that package.
+### Compabitity
+
+- [`Node >= 16` ![NodeJS](https://img.shields.io/badge/node.js-6DA55F?logo=node.js&logoColor=white)](https://nodejs.org)
+- [`Deno` ![Deno JS](https://img.shields.io/badge/deno%20js-000000?logo=deno&logoColor=white)](https://deno.com/runtime)
+- [`Bun >= 0.6.0` ![Bun](https://img.shields.io/badge/Bun-%23000000.svg?logoColor=white)](https://bun.sh/)
+- `Web` ![HTML5](https://img.shields.io/badge/html5-%23E34F26.svg?logoColor=white)
+
+### Yarn / NPM / Bun
 
-To install this package separately:
+For convenience, all main types are also exported through [`@rimbu/core`](../core).
 
-### Yarn/NPM
+To install this package only:
+
+For `yarn`:
 
 > `yarn add @rimbu/common`
 
-or
+For `npm`:
 
 > `npm i @rimbu/common`
 
+For `bun`:
+
+> `bun add @rimbu/common`
+
 ### Deno
 
 For Deno, the following approach is recommended:

package/{src/async-optlazy.ts → dist/bun/async-optlazy.mts}

@@ -1,4 +1,4 @@
-import type { OptLazy } from './internal';
+import type { OptLazy } from './internal.mts';
 
 /**
  * A type that is either a value T or a promise yielding a value of type T.

package/{src/async-reducer.ts → dist/bun/async-reducer.mts}

@@ -1,11 +1,11 @@
 import {
-  AsyncCollectFun,
+  type AsyncCollectFun,
   AsyncOptLazy,
   CollectFun,
-  MaybePromise,
+  type MaybePromise,
   Reducer,
   Eq,
-} from './internal';
+} from './internal.mts';
 
 /**
  * An `AsyncReducer` is a stand-alone asynchronous calculation that takes input values of type I,
@@ -43,7 +43,7 @@ export namespace AsyncReducer {
      * @param state - the final reducer state
      * @param error - (optional) if an error has occured, it ix passed here
      */
-    onClose?(state: S, error?: unknown): MaybePromise<void>;
+    onClose?: ((state: S, error?: unknown) => MaybePromise<void>) | undefined;
     /**
      * Returns an `AsyncReducer` instance that only passes values to the reducer that satisy the given `pred` predicate.
      * @param pred - a potaentially asynchronous function that returns true if the value should be passed to the reducer based on the following inputs:<br/>
@@ -270,7 +270,9 @@ export namespace AsyncReducer {
     }
 
     dropInput(amount: number): AsyncReducer<I, O> {
-      if (amount <= 0) return this;
+      if (amount <= 0) {
+        return this as AsyncReducer<I, O>;
+      }
 
       return this.filterInput((_, i): boolean => i >= amount);
     }
@@ -308,7 +310,12 @@ export namespace AsyncReducer {
     stateToResult: (state: S) => MaybePromise<O>,
     onClose?: (state: S, error?: unknown) => MaybePromise<void>
   ): AsyncReducer<I, O> {
-    return new AsyncReducer.Base(init, next, stateToResult, onClose);
+    return new AsyncReducer.Base(
+      init,
+      next,
+      stateToResult,
+      onClose
+    ) as AsyncReducer<I, O>;
   }
 
   /**
@@ -456,10 +463,11 @@ export namespace AsyncReducer {
    * // => 3
    * ```
    */
+  // prettier-ignore
   export const min: {
     (): AsyncReducer<number, number | undefined>;
     <O>(otherwise: AsyncOptLazy<O>): AsyncReducer<number, number | O>;
-  } = <O>(otherwise?: AsyncOptLazy<O>) => {
+  } = <O,>(otherwise?: AsyncOptLazy<O>) => {
     return create<number, number | O, number | undefined>(
       undefined,
       (state, next): number =>
@@ -514,10 +522,11 @@ export namespace AsyncReducer {
    * // => 7
    * ```
    */
+  // prettier-ignore
   export const max: {
     (): AsyncReducer<number, number | undefined>;
     <O>(otherwise: AsyncOptLazy<O>): AsyncReducer<number, number | O>;
-  } = <O>(otherwise?: AsyncOptLazy<O>): AsyncReducer<number, number | O> => {
+  } = <O,>(otherwise?: AsyncOptLazy<O>): AsyncReducer<number, number | O> => {
     return create<number, number | O, number | undefined>(
       undefined,
       (state, next): number =>

package/{src/collect.ts → dist/bun/collect.mts}

@@ -1,4 +1,4 @@
-import type { MaybePromise } from './internal';
+import type { MaybePromise } from './internal.mts';
 
 /**
  * A function used in `collect` methods to collect values from a collection. This is basically a single-pass map and filter.

package/{src/comp.ts → dist/bun/comp.mts}

@@ -1,4 +1,4 @@
-import { Eq } from './internal';
+import { Eq } from './internal.mts';
 
 /**
  * An object providing methods to compare two values of type `K`.

package/{src/index-range.ts → dist/bun/index-range.mts}

@@ -1,4 +1,4 @@
-import type { Range } from './internal';
+import type { Range } from './internal.mts';
 
 /**
  * A flexible range specification for numeric indices.

package/{src/index.ts → dist/bun/index.mts}

@@ -4,4 +4,4 @@
  * The `@rimbu/common` package provides many commonly used types and utilities that can also be of use to Rimbu users.<br/>
  */
 
-export * from './internal';
+export * from './internal.mts';

package/dist/bun/internal.mts

@@ -0,0 +1,13 @@
+export * from './collect.mts';
+export * from './comp.mts';
+export * from './eq.mts';
+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/{src/reducer.ts → dist/bun/reducer.mts}

@@ -1,4 +1,4 @@
-import { CollectFun, Eq, OptLazy } from './internal';
+import { CollectFun, Eq, OptLazy } from './internal.mts';
 
 /**
  * A `Reducer` is a stand-alone calculation that takes input values of type I, and, when requested, produces an output value of type O.
@@ -389,10 +389,11 @@ export namespace Reducer {
    * // => 3
    * ```
    */
+  // prettier-ignore
   export const min: {
     (): Reducer<number, number | undefined>;
     <O>(otherwise: OptLazy<O>): Reducer<number, number | O>;
-  } = <O>(otherwise?: OptLazy<O>) => {
+  } = <O,>(otherwise?: OptLazy<O>) => {
     return create<number, number | O, number | undefined>(
       undefined,
       (state, next): number =>
@@ -442,10 +443,11 @@ export namespace Reducer {
    * // => 7
    * ```
    */
+  // prettier-ignore
   export const max: {
     (): Reducer<number, number | undefined>;
     <O>(otherwise: OptLazy<O>): Reducer<number, number | O>;
-  } = <O>(otherwise?: OptLazy<O>): Reducer<number, number | O> => {
+  } = <O,>(otherwise?: OptLazy<O>): Reducer<number, number | O> => {
     return create<number, number | O, number | undefined>(
       undefined,
       (state, next): number =>

package/dist/cjs/async-optlazy.js

@@ -0,0 +1,44 @@
+"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);
+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
+});