@rimbu/base 2.0.4 → 2.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rimbu/base",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Utilities to implement Rimbu collections",
   "keywords": [
     "array",
@@ -23,7 +23,7 @@
   ],
   "repository": {
     "type": "git",
-    "url": "https://github.com/rimbu-org/rimbu.git",
+    "url": "https://github.com/rimbu-org/rimbu",
     "directory": "packages/base"
   },
   "type": "module",
@@ -32,7 +32,6 @@
   "types": "./dist/cjs/index.d.cts",
   "exports": {
     ".": {
-      "bun": "./dist/bun/index.mts",
       "import": {
         "types": "./dist/esm/index.d.mts",
         "default": "./dist/esm/index.mjs"
@@ -49,8 +48,7 @@
   ],
   "scripts": {
     "build": "yarn clean && yarn bundle",
-    "bundle": "yarn bundle:cjs && yarn bundle:esm && yarn bundle:bun",
-    "bundle:bun": "node ../../config/bunnify.mjs -mode bun",
+    "bundle": "yarn bundle:cjs && yarn bundle:esm",
     "bundle:cjs": "yarn bundle:cjs-prepare && yarn bundle:cjs-build && yarn bundle:cjs-clean",
     "bundle:cjs-prepare": "node ../../config/bunnify.mjs -mode cjs",
     "bundle:cjs-build": "tsc -p tsconfig.cjs.json",
@@ -68,10 +66,10 @@
     "typecheck": "tsc"
   },
   "dependencies": {
-    "@rimbu/common": "^2.0.4"
+    "@rimbu/common": "^2.0.6"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "bc6bc82af86461c423ba459d6d9809efdd5ffd61"
+  "gitHead": "0d946ea05fda8261f1c55c3bcd6527ed793b90b5"
 }

package/dist/bun/arr.mts

@@ -1,477 +0,0 @@
-import { TraverseState, Update, type ArrayNonEmpty } from '@rimbu/common';
-
-/**
- * Internal helper that appends a value using the modern immutable `toSpliced` API.
- * @internal
- * @typeparam T - the array element type
- * @param array - the source array (not mutated)
- * @param value - the value to append
- * @returns a new non-empty array with the value at the end
- */
-export function _appendNew<T>(array: readonly T[], value: T): ArrayNonEmpty<T> {
-  return array.toSpliced(array.length, 0, value) as ArrayNonEmpty<T>;
-}
-
-/**
- * Internal helper that appends a value by cloning and pushing (legacy fallback).
- * @internal
- * @typeparam T - the array element type
- * @param array - the source array (not mutated)
- * @param value - the value to append
- * @returns a new non-empty array with the value at the end
- */
-export function _appendOld<T>(array: readonly T[], value: T): ArrayNonEmpty<T> {
-  const clone = array.slice();
-  clone.push(value);
-  return clone as ArrayNonEmpty<T>;
-}
-
-/**
- * Returns a copy of the array with the given value appended.
- * Chooses an implementation depending on environment capabilities.
- * @typeparam T - the array element type
- * @param array - the source array (not mutated)
- * @param value - the value to append
- * @returns a new array with the value at the end
- */
-export const append = `toSpliced` in Array.prototype ? _appendNew : _appendOld;
-
-/**
- * Returns the concatenation of two arrays, reusing an input array when the other is empty.
- * @typeparam T - the array element type
- * @param first - the first array
- * @param second - the second array
- * @returns a new array containing all elements of both arrays (or one of the originals if the other is empty)
- */
-export function concat<T>(
-  first: readonly T[],
-  second: readonly T[]
-): readonly T[] {
-  if (first.length === 0) return second;
-  if (second.length === 0) return first;
-  return first.concat(second);
-}
-
-/**
- * Internal helper to create a reversed copy using modern `toReversed` with optional slicing.
- * @internal
- */
-export function _reverseNew<T>(
-  array: readonly T[],
-  start?: number,
-  end?: number
-): T[] {
-  const source =
-    undefined !== start || undefined !== end
-      ? array.slice(start ?? 0, (end ?? array.length - 1) + 1)
-      : array;
-
-  return source.toReversed();
-}
-
-/**
- * Internal helper to create a reversed copy using manual iteration (legacy fallback).
- * @internal
- */
-export function _reverseOld<T>(
-  array: readonly T[],
-  start?: number,
-  end?: number
-): T[] {
-  const _start = start ?? 0;
-  const _end = end ?? array.length - 1;
-  const length = _end - _start + 1;
-  const res = [] as T[];
-
-  let arrayIndex = _start - 1;
-  let resIndex = length - 1;
-
-  while (++arrayIndex <= _end) res[resIndex--] = array[arrayIndex];
-
-  return res;
-}
-
-/**
- * Returns a copy of the array (or a slice) with elements in reversed order.
- * @typeparam T - array element type
- * @param array - the source array
- * @param start - optional start index (inclusive)
- * @param end - optional end index (inclusive)
- */
-export const reverse =
-  'toReversed' in Array.prototype ? _reverseNew : _reverseOld;
-
-/**
- * Performs the given function for each element of the array, optionally in reverse order.
- * Halting is supported through the provided `TraverseState`.
- * @typeparam T - element type
- * @param array - the source array
- * @param f - callback receiving (value, sequential index, halt)
- * @param state - traversal state (created if omitted)
- * @param reversed - whether to traverse in reverse order
- */
-export function forEach<T>(
-  array: readonly T[],
-  f: (value: T, index: number, halt: () => void) => void,
-  state: TraverseState = TraverseState(),
-  reversed = false
-): void {
-  if (state.halted) return;
-
-  const { halt } = state;
-
-  if (reversed) {
-    let i = array.length;
-
-    while (!state.halted && --i >= 0) {
-      f(array[i], state.nextIndex(), halt);
-    }
-  } else {
-    const length = array.length;
-    let i = -1;
-
-    while (!state.halted && ++i < length) {
-      f(array[i], state.nextIndex(), halt);
-    }
-  }
-}
-
-/**
- * Returns a copy of the array where the given function is applied to each element.
- * Supports an index offset useful for composed traversals.
- * @typeparam T - source element type
- * @typeparam R - result element type
- * @param array - the source array
- * @param f - the mapping function
- * @param indexOffset - optional start index value passed to `f`
- */
-export function map<T, R>(
-  array: readonly T[],
-  f: (value: T, index: number) => R,
-  indexOffset = 0
-): R[] {
-  if (indexOffset === 0) {
-    // without offset, can use standard array map
-    return array.map(f);
-  }
-
-  const result: R[] = [];
-
-  let index = indexOffset;
-  let i = -1;
-  const length = array.length;
-  while (++i < length) {
-    result[i] = f(array[i], index++);
-  }
-  return result;
-}
-
-/**
- * Returns a copy of the array where the given function is applied to each element in reverse order.
- * @typeparam T - source element type
- * @typeparam R - result element type
- * @param array - the source array
- * @param f - the mapping function
- * @param indexOffset - optional index offset passed to `f`
- */
-export function reverseMap<T, R>(
-  array: readonly T[],
-  f: (value: T, index: number) => R,
-  indexOffset = 0
-): R[] {
-  const result: R[] = [];
-
-  let index = indexOffset;
-  let arrayIndex = array.length;
-  let resultIndex = 0;
-  while (--arrayIndex >= 0)
-    result[resultIndex++] = f(array[arrayIndex], index++);
-
-  return result;
-}
-
-/**
- * Internal helper to prepend a value using `toSpliced`.
- * @internal
- */
-export function _prependNew<T>(
-  array: readonly T[],
-  value: T
-): ArrayNonEmpty<T> {
-  return array.toSpliced(0, 0, value) as ArrayNonEmpty<T>;
-}
-
-/**
- * Internal helper to prepend a value using legacy cloning.
- * @internal
- */
-export function _prependOld<T>(
-  array: readonly T[],
-  value: T
-): ArrayNonEmpty<T> {
-  const clone = array.slice();
-  clone.unshift(value);
-  return clone as ArrayNonEmpty<T>;
-}
-
-/**
- * Returns a copy of the array with the given value inserted at the start.
- * @typeparam T - element type
- * @param array - the source array
- * @param value - value to insert at index 0
- */
-export const prepend =
-  `toSpliced` in Array.prototype ? _prependNew : _prependOld;
-
-/**
- * Internal helper to obtain the last element using modern `at`.
- * @internal
- */
-export function _lastNew<T>(arr: readonly T[]): T {
-  return arr.at(-1)!;
-}
-
-/**
- * Internal helper to obtain the last element using index arithmetic.
- * @internal
- */
-export function _lastOld<T>(arr: readonly T[]): T {
-  return arr[arr.length - 1];
-}
-
-/**
- * Returns the last element of the array.
- * @typeparam T - element type
- * @param arr - the array
- */
-export const last = `at` in Array.prototype ? _lastNew : _lastOld;
-
-/**
- * Internal helper implementing an immutable index update via `with`.
- * @internal
- */
-export function _updateNew<T>(
-  arr: readonly T[],
-  index: number,
-  updater: Update<T>
-): readonly T[] {
-  if (index < 0 || index >= arr.length) {
-    return arr;
-  }
-  const curValue = arr[index];
-
-  const newValue = Update(curValue, updater);
-  if (Object.is(newValue, curValue)) {
-    return arr;
-  }
-
-  return arr.with(index, newValue);
-}
-
-/**
- * Internal helper implementing an immutable index update via cloning.
- * @internal
- */
-export function _updateOld<T>(
-  arr: readonly T[],
-  index: number,
-  updater: Update<T>
-): readonly T[] {
-  if (index < 0 || index >= arr.length) {
-    return arr;
-  }
-  const curValue = arr[index];
-
-  const newValue = Update(curValue, updater);
-  if (Object.is(newValue, curValue)) {
-    return arr;
-  }
-
-  const newArr = arr.slice();
-  newArr[index] = newValue;
-  return newArr;
-}
-
-/**
- * Returns a copy of the array where the element at the given index is replaced using the provided updater.
- * If the result value is identical (by `Object.is`) the original array is returned.
- * @typeparam T - element type
- * @param arr - the source array
- * @param index - the index to update
- * @param updater - value or function update description
- */
-export const update = `with` in Array.prototype ? _updateNew : _updateOld;
-
-/**
- * Internal helper applying a modifier function via `with`.
- * @internal
- */
-export function _modNew<T>(
-  arr: readonly T[],
-  index: number,
-  f: (value: T) => T
-): readonly T[] {
-  if (index < 0 || index >= arr.length) {
-    return arr;
-  }
-
-  const curValue = arr[index];
-  const newValue = f(curValue);
-
-  if (Object.is(newValue, curValue)) {
-    return arr;
-  }
-
-  return arr.with(index, newValue);
-}
-
-/**
- * Internal helper applying a modifier function via cloning.
- * @internal
- */
-export function _modOld<T>(
-  arr: readonly T[],
-  index: number,
-  f: (value: T) => T
-): readonly T[] {
-  if (index < 0 || index >= arr.length) {
-    return arr;
-  }
-
-  const curValue = arr[index];
-  const newValue = f(curValue);
-
-  if (Object.is(newValue, curValue)) {
-    return arr;
-  }
-
-  const newArr = arr.slice();
-  newArr[index] = newValue;
-  return newArr;
-}
-
-/**
- * Returns a copy of the array where the element at the given index is transformed by a modifier function.
- * If the result value is identical (by `Object.is`) the original array is returned.
- * @typeparam T - element type
- * @param arr - the source array
- * @param index - the index to modify
- * @param f - modifier function receiving the current value
- */
-export const mod = `with` in Array.prototype ? _modNew : _modOld;
-
-/**
- * Internal helper for inserting a value using `toSpliced`.
- * @internal
- */
-export function _insertNew<T>(arr: readonly T[], index: number, value: T): T[] {
-  return arr.toSpliced(index, 0, value);
-}
-
-/**
- * Internal helper for inserting a value using legacy `splice` on a clone.
- * @internal
- */
-export function _insertOld<T>(arr: readonly T[], index: number, value: T): T[] {
-  const clone = arr.slice();
-  clone.splice(index, 0, value);
-  return clone;
-}
-
-/**
- * Returns a copy of the array where at the given index the provided value is inserted.
- * @typeparam T - element type
- * @param arr - the source array
- * @param index - insertion index
- * @param value - value to insert
- */
-export const insert = `toSpliced` in Array.prototype ? _insertNew : _insertOld;
-
-/**
- * Returns a copy of the array without its first element.
- * @typeparam T - element type
- * @param arr - the source array
- */
-export function tail<T>(arr: readonly T[]): T[] {
-  return arr.slice(1);
-}
-
-/**
- * Returns a copy of the array without its last element.
- * @typeparam T - element type
- * @param arr - the source array
- */
-export function init<T>(arr: readonly T[]): T[] {
-  return arr.slice(0, arr.length - 1);
-}
-
-/**
- * Internal helper providing an immutable `splice` using `toSpliced`.
- * @internal
- */
-export function _spliceNew<T>(
-  arr: readonly T[],
-  start: number,
-  deleteCount: number,
-  ...items: T[]
-): T[] {
-  return arr.toSpliced(start, deleteCount, ...items);
-}
-
-/**
- * Internal helper providing an immutable `splice` via cloning.
- * @internal
- */
-export function _spliceOld<T>(
-  arr: readonly T[],
-  start: number,
-  deleteCount: number,
-  ...items: T[]
-): T[] {
-  const clone = arr.slice();
-  clone.splice(start, deleteCount, ...items);
-  return clone;
-}
-
-/**
- * Immutable version of the array `.splice` command, always returning a new array.
- * @typeparam T - element type
- * @param arr - the source array
- * @param start - start index
- * @param deleteCount - number of elements to delete
- * @param items - optional items to insert
- */
-export const splice = `toSpliced` in Array.prototype ? _spliceNew : _spliceOld;
-
-/**
- * Returns a copy of a (potentially) sparse array preserving sparsity (skips holes).
- * @typeparam T - element type
- * @param arr - the source sparse array
- */
-export function copySparse<T>(arr: readonly T[]): T[] {
-  const clone: T[] = [];
-  for (const key in arr) {
-    clone[key] = arr[key];
-  }
-  return clone;
-}
-
-/**
- * Returns a copy of a sparse array applying the given function to each present element, preserving holes.
- * @typeparam T - source element type
- * @typeparam T2 - result element type
- * @param arr - the source sparse array
- * @param f - mapping function
- */
-export function mapSparse<T, T2>(
-  arr: readonly T[],
-  f: (value: T, index: number) => T2
-): T2[] {
-  const result: T2[] = Array(arr.length);
-
-  for (const key in arr) {
-    result[key] = f(arr[key], key as any);
-  }
-
-  return result;
-}

package/dist/bun/entry.mts

@@ -1,21 +0,0 @@
-/**
- * Returns the first element of a 2-tuple.
- * @typeparam K - the first element type
- * @typeparam V - the second element type
- * @param entry - the tuple
- * @returns the first element
- */
-export function first<K, V>(entry: readonly [K, V]): K {
-  return entry[0];
-}
-
-/**
- * Returns the second element of a 2-tuple.
- * @typeparam K - the first element type
- * @typeparam V - the second element type
- * @param entry - the tuple
- * @returns the second element
- */
-export function second<K, V>(entry: readonly [K, V]): V {
-  return entry[1];
-}

package/dist/bun/index.mts

@@ -1,16 +0,0 @@
-/**
- * @packageDocumentation
- *
- * The `@rimbu/base` package provides foundational immutable array utilities, tuple helpers,
- * plain‑object type predicates and structured error types that power all other Rimbu collections.<br/>
- * Use it directly when you need low‑level, performance‑aware primitives for persistent data
- * structures without pulling in the higher‑level collection packages.<br/>
- * See the Rimbu docs and API reference for more information.
- */
-export * as Arr from './arr.mts';
-export * as Entry from './entry.mts';
-export * as RimbuError from './rimbu-error.mts';
-export * from './plain-object.mts';
-
-// Internal exports (may change without notice)
-export * from './internal.mts';

package/dist/bun/internal.mts

@@ -1 +0,0 @@
-export * from './token.mts';

package/dist/bun/plain-object.mts

@@ -1,95 +0,0 @@
-/**
- * Matches any type of function
- */
-export type AnyFunc = (...args: any[]) => any;
-
-/**
- * Gives true if the given type T is a function, false otherwise.
- * @typeparam T - the input type
- */
-export type IsAnyFunc<T> = AnyFunc extends T ? true : false;
-
-/**
- * A predicate type for any record that resolves to true if any of the record
- * properties is a function, false otherwise.
- * This is useful to have a coarse discrimination between pure data objects and class instances.
- * @typeparam T - the input type
- */
-export type IsObjWithoutFunctions<T> = AnyFunc extends T[keyof T]
-  ? false
-  : true;
-
-/**
- * A predicate type that resolves to true if the given type satisfies:
- * - it is an object type (not a primitive)
- * - it is not a function
- * - it is not iterable
- * - it does not have any properties that are functions
- * Otherwise, it resolves to false
- * @typeparam T - the input type
- */
-export type IsPlainObj<T> = T extends
-  | null
-  | undefined
-  | number
-  | string
-  | boolean
-  | bigint
-  | symbol
-  | AnyFunc
-  | Iterable<any>
-  | AsyncIterable<any>
-  ? false
-  : IsObjWithoutFunctions<T>;
-
-/**
- * Utility type that will only accept objects that are considered 'plain objects' according
- * to the `IsPlainObj` predicate type.
- * @typeparam T - the value type to test
- */
-export type PlainObj<T> = IsPlainObj<T> extends true ? T : never;
-
-/**
- * Utility type that will only return true if the input type T is equal to `any`.
- * @typeparam T - the value type to test
- */
-export type IsAny<T> = 0 extends 1 & T ? true : false;
-
-/**
- * Utility type that will only return true if the input type T is a (readonly) array.
- * @typeparm T - the value type to test
- */
-export type IsArray<T> = T extends readonly any[] ? true : false;
-
-/**
- * Utility type to exclude any types that are iterable. Useful in cases where
- * plain objects are required as inputs but not arrays.
- */
-export type NotIterable = {
-  [Symbol.iterator]?: never;
-};
-
-/**
- * Companion function to the `IsRecord<T>` type that checks whether the given object is a pure
- * data object.
- * @param obj - the object to check
- * @returns true if the given object is a pure data object
- * @note does not check whether a record's properties are not functions
- */
-export function isPlainObj(obj: any): obj is object {
-  return (
-    typeof obj === 'object' &&
-    null !== obj &&
-    (obj.constructor === Object || !(obj.constructor instanceof Function)) &&
-    !(Symbol.iterator in obj) &&
-    !(Symbol.asyncIterator in obj)
-  );
-}
-
-/**
- * Returns true if the given object is Iterable
- * @param obj - the object to check
- */
-export function isIterable(obj: any): obj is Iterable<unknown> {
-  return obj !== null && typeof obj === 'object' && Symbol.iterator in obj;
-}

package/dist/bun/rimbu-error.mts

@@ -1,64 +0,0 @@
-import { ErrBase } from '@rimbu/common';
-
-/**
- * Error thrown when an operation assumes a collection is non-empty but it is empty.
- */
-export class EmptyCollectionAssumedNonEmptyError extends ErrBase.CustomError {
-  constructor() {
-    super('empty collection was assumbed to be non-empty');
-  }
-}
-
-/**
- * Error thrown when a builder is modified while it is being iterated.
- */
-export class ModifiedBuilderWhileLoopingOverItError extends ErrBase.CustomError {
-  constructor() {
-    super('an attempt was made to modify a builder while looping over it');
-  }
-}
-
-/**
- * Error indicating an unexpected internal state. Users are encouraged to file an issue.
- */
-export class InvalidStateError extends ErrBase.CustomError {
-  constructor() {
-    super(
-      "something happend that shouldn't happen, please consider creating an issue"
-    );
-  }
-}
-
-/**
- * Error indicating incorrect usage of the API.
- */
-export class InvalidUsageError extends ErrBase.CustomError {}
-
-/**
- * Throws an `EmptyCollectionAssumedNonEmptyError`.
- */
-export function throwEmptyCollectionAssumedNonEmptyError(): never {
-  throw new EmptyCollectionAssumedNonEmptyError();
-}
-
-/**
- * Throws a `ModifiedBuilderWhileLoopingOverItError`.
- */
-export function throwModifiedBuilderWhileLoopingOverItError(): never {
-  throw new ModifiedBuilderWhileLoopingOverItError();
-}
-
-/**
- * Throws an `InvalidStateError`.
- */
-export function throwInvalidStateError(): never {
-  throw new InvalidStateError();
-}
-
-/**
- * Throws an `InvalidUsageError` with the provided message.
- * @param msg - context message describing the invalid usage
- */
-export function throwInvalidUsageError(msg: string): never {
-  throw new InvalidUsageError(msg);
-}

package/dist/bun/token.mts

@@ -1,9 +0,0 @@
-/**
- * Unique symbol used as a nominal token within the base package.
- * Can be employed for branding or sentinel values.
- */
-export const Token = Symbol('Token');
-/**
- * Type alias representing the Token symbol.
- */
-export type Token = typeof Token;