@rimbu/common 0.12.3 → 1.0.0-alpha.1

package/src/traverse-state.mts

@@ -0,0 +1,59 @@
+/**
+ * An object used to track the state of a traversal, e.g. a `forEach`.
+ */
+export interface TraverseState {
+  /**
+   * Returns true if the traversal has been halted by the user.
+   */
+  readonly halted: boolean;
+  /**
+   * Returns the current index of the traversal.
+   */
+  readonly currentIndex: number;
+
+  /**
+   * Increases the `currentIndex` of this traversal
+   * @returns the next index that the traversal should use
+   */
+  nextIndex(): number;
+  /**
+   * Sets the `halted` value to true.
+   */
+  halt(): void;
+  /**
+   * Sets the `halted` value to false, and resets the `currentIndex`
+   * value to its start value.
+   */
+  reset(): void;
+}
+
+class TraverseStateImpl implements TraverseState {
+  currentIndex: number;
+  halted = false;
+
+  constructor(readonly startIndex: number) {
+    this.currentIndex = startIndex;
+  }
+
+  nextIndex(): number {
+    return this.currentIndex++;
+  }
+
+  readonly halt = (): void => {
+    this.halted = true;
+  };
+
+  reset(): void {
+    this.currentIndex = this.startIndex;
+    this.halted = false;
+  }
+}
+
+/**
+ * Returns a new `TraverseState` instance, using optionally given `startIndex` as a start
+ * index value.
+ * @param startIndex - (default: 0) the start index to use
+ */
+export function TraverseState(startIndex = 0): TraverseState {
+  return new TraverseStateImpl(startIndex);
+}

package/src/types.mts

@@ -0,0 +1,40 @@
+/**
+ * Accepts all types of T and U where T extends U,
+ * and result in the upper bound U.
+ */
+export type SuperOf<U, T> = T extends U ? U : never;
+
+/**
+ * Accepts all types of T and S where S extends T,
+ * and results in the lower bound S.
+ */
+export type SubOf<S, T> = S extends T ? S : never;
+
+/**
+ * Accepts all types of T and U where T extends U or U extends T.
+ */
+export type RelatedTo<T, U> = T | SuperOf<U, T>;
+
+/**
+ * Accepts all arrays with at least one element.
+ */
+export type ArrayNonEmpty<T> = [T, ...T[]];
+
+/**
+ * Accepts all strings with at least one character.
+ */
+export type StringNonEmpty<T> = T extends string
+  ? '' extends T
+    ? never
+    : T
+  : never;
+
+/**
+ * Utility type to convert some object to a JSON serializable format.
+ * @typeparam V - the `value` type
+ * @typeparam D - the `dataType` tag string type
+ */
+export interface ToJSON<V, D extends string = string> {
+  readonly dataType: D;
+  readonly value: V;
+}

package/{dist/main/update.js → src/update.mts}

@@ -1,6 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Update = void 0;
+/**
+ * A value of type T, or a function taking a value of type T and returning a new value of type T.
+ */
+export type Update<T> = T | ((value: T) => T);
+
 /**
  * Returns the result of given `update` parameter, where it can either directly give a new value,
  * or it is a function receiving the given `value`, and returns a new value.
@@ -14,11 +16,9 @@ exports.Update = void 0;
  * Update(1, v => v + 1) // => 2
  * ```
  */
-function Update(value, update) {
-    if (typeof update === 'function') {
-        return update(value);
-    }
-    return update;
+export function Update<T>(value: T, update: Update<T>): T {
+  if (typeof update === 'function') {
+    return (update as (value: T) => T)(value);
+  }
+  return update;
 }
-exports.Update = Update;
-//# sourceMappingURL=update.js.map

package/dist/main/async-optlazy.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncOptLazy = void 0;
-var tslib_1 = require("tslib");
-var 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
-     * @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) {
-        if (optLazy instanceof Function)
-            return optLazy();
-        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
-     * @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) {
-        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()];
-                return [2 /*return*/, optLazy];
-            });
-        });
-    }
-    AsyncOptLazy.toPromise = toPromise;
-})(AsyncOptLazy = exports.AsyncOptLazy || (exports.AsyncOptLazy = {}));
-//# sourceMappingURL=async-optlazy.js.map

package/dist/main/async-optlazy.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"async-optlazy.js","sourceRoot":"","sources":["../../src/async-optlazy.ts"],"names":[],"mappings":";;;;AAcA,IAAiB,YAAY,CAkC5B;AAlCD,WAAiB,YAAY;IAC3B;;;;;;;;;;;OAWG;IACH,SAAgB,cAAc,CAAI,OAAwB;QACxD,IAAI,OAAO,YAAY,QAAQ;YAAE,OAAO,OAAO,EAAE,CAAC;QAClD,OAAO,OAAO,CAAC;IACjB,CAAC;IAHe,2BAAc,iBAG7B,CAAA;IAED;;;;;;;;;;;OAWG;IACH,SAAsB,SAAS,CAAI,OAAwB;;;gBACzD,IAAI,OAAO,YAAY,QAAQ;oBAAE,sBAAO,OAAO,EAAE,EAAC;gBAClD,sBAAO,OAAO,EAAC;;;KAChB;IAHqB,sBAAS,YAG9B,CAAA;AACH,CAAC,EAlCgB,YAAY,GAAZ,oBAAY,KAAZ,oBAAY,QAkC5B"}