@rimbu/deep 2.0.4 → 2.0.5

package/dist/bun/protected.mts

@@ -1,31 +0,0 @@
-import type { IsAny, IsPlainObj } from '@rimbu/base';
-
-/**
- * A deep readonly typed version of given type T. Makes all properties or elements read only.
- * It maps types using the following rules:
- * - arrays and tuples become readonly counterparts, and all element types are wrapped in `Protected` if applicable
- * - Maps of key type K and value type V become Maps of key type `Protected<K>` and value type `Protected<V>`
- * - Sets of element type E become Sets of element type `Protected<E>`
- * - Promises of value type E become Promises of value type `Protected<E>`
- * - Objects that have only simple properties (no functions or iterators) will have all the properties as Protected if applicable
- * - Any other type will not be mapped
- * @typeparam T - the input type
- */
-export type Protected<T> =
-  IsAny<T> extends true
-    ? // to prevent infinite recursion, any will be any
-      T
-    : T extends readonly any[] & infer A
-      ? // convert all keys to readonly and all values to `Protected`
-        { readonly [K in keyof A]: Protected<A[K]> }
-      : T extends Map<infer K, infer V>
-        ? ReadonlyMap<Protected<K>, Protected<V>>
-        : T extends Set<infer E>
-          ? ReadonlySet<Protected<E>>
-          : T extends Promise<infer E>
-            ? Promise<Protected<E>>
-            : IsPlainObj<T> extends true
-              ? // convert all keys to readonly and all values to `Protected`
-                { readonly [K in keyof T]: Protected<T[K]> }
-              : // nothing to do, just return `T`
-                T;

package/dist/bun/selector.mts

@@ -1,93 +0,0 @@
-import type { IsAnyFunc, IsArray } from '@rimbu/base';
-
-import { Deep, type Path, type Protected } from './internal.mts';
-
-/**
- * Type defining the allowed selectors on an object of type `T`.
- * Selectors can be:
- * - a path string into type `T`.
- * - a function receiving a `Protected` version of type `T`, and returning an arbitrary value.
- * - a tuple of `Selectors` for type `T`
- * - an object where the property values are `Selectors` for type `T`.
- * @typeparam T - the source value type.
- */
-export type Selector<T> =
-  | Path.Get<T>
-  | ((value: Protected<T>) => any)
-  | readonly Selector<T>[]
-  | { readonly [key: string | symbol]: Selector<T> };
-
-export namespace Selector {
-  /**
-   * Type defining the shape of allowed selectors, used to improve compiler checking.
-   * @typeparam SL - the selector type
-   */
-  export type Shape<SL> =
-    IsAnyFunc<SL> extends true
-      ? // functions are allowed, type provided by `Selector`
-        SL
-      : IsArray<SL> extends true
-        ? // ensure tuple type is preserved
-          readonly [...(SL extends readonly unknown[] ? SL : never)]
-        : SL extends { readonly [key: string | number | symbol]: unknown }
-          ? // ensure all object properties satisfy `Shape`
-            { readonly [K in keyof SL]: Selector.Shape<SL[K]> }
-          : // nothing to check
-            SL;
-
-  /**
-   * Type defining the result type of applying the SL selector type to the T value type.
-   * @typeparam T - the source value type
-   * @typeparam SL - the selector type
-   */
-  export type Result<T, SL> =
-    Selector<T> extends SL
-      ? never
-      : SL extends (...args: any[]) => infer R
-        ? R
-        : SL extends string
-          ? Path.Result<T, SL>
-          : {
-              readonly [K in keyof SL]: Selector.Result<T, SL[K]>;
-            };
-}
-
-/**
- * Returns the result of applying the given `selector` shape to the given `source` value.
- * @typeparam T - the patch value type
- * @typeparam SL - the selector shape type
- * @param source - the source value to select from
- * @param selector - a shape indicating the selection from the source values
- * @example
- * ```ts
- * const item = { a: { b:  1, c: 'a' } };
- * Deep.select(item, { q: 'a.c', y: ['a.b', 'a.c'], z: (v) => v.a.b + 1 });
- * // => { q: 'a', y: [1, 'a'], z: 2 }
- * ```
- */
-export function select<T, SL extends Selector<T>>(
-  source: T,
-  selector: Selector.Shape<SL>
-): Selector.Result<T, SL> {
-  if (typeof selector === 'function') {
-    // selector is function, resolve selector function
-    return (selector as any)(source as Protected<T>);
-  } else if (typeof selector === 'string') {
-    // selector is string path, get the value at the given path
-    return Deep.getAt(source, selector as Path.Get<T>) as any;
-  } else if (Array.isArray(selector)) {
-    // selector is tuple, get each tuple item value
-    return selector.map((s) => select(source, s)) as any;
-  }
-
-  // selector is object
-
-  const result: any = {};
-
-  for (const key in selector as any) {
-    // set each selected object key to the selector value
-    result[key] = select(source, (selector as any)[key]);
-  }
-
-  return result;
-}

package/dist/bun/tuple.mts

@@ -1,201 +0,0 @@
-import { Arr } from '@rimbu/base';
-import type { Update } from '@rimbu/common';
-
-/**
- * A readonly array of fixed length and types.
- */
-export type Tuple<T extends Tuple.Source> = Readonly<T>;
-
-export namespace Tuple {
-  /**
-   * A non-empty readonly array that can serve as a source for a Tuple.
-   */
-  export type NonEmptySource = readonly [unknown, ...unknown[]];
-
-  /**
-   * A readonly array that can serve as a source for a Tuple.
-   */
-  export type Source = readonly unknown[];
-
-  /**
-   * Determines whether the given type `T` is a tuple type.
-   * @typeparam T - the input type
-   */
-  export type IsTuple<T> = T extends { length: infer L }
-    ? 0 extends L
-      ? false
-      : true
-    : false;
-
-  /**
-   * Returns the indices/keys that are in a tuple.
-   * @typeparam T - the input tuple type
-   */
-  export type KeysOf<T> = { [K in keyof T]: K }[keyof T & number];
-
-  /**
-   * Convenience method to type Tuple types
-   * @param values - the values of the tuple
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a', true)
-   * // type of t => Tuple<[number, string, boolean]>
-   * ```
-   */
-  export function of<T extends Tuple.NonEmptySource>(...values: T): Tuple<T> {
-    return values as any;
-  }
-
-  /**
-   * Returns the item at the given `index` in the given `tuple`.
-   * @param tuple - the tuple to get the item from
-   * @param index - the index in of the tuple element
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a', true)
-   * console.log(Tuple.getIndex(t, 1))
-   * // => 'a'
-   * ```
-   */
-  export function getIndex<T extends Tuple.Source, K extends keyof T = keyof T>(
-    tuple: T,
-    index: K
-  ): T[K] {
-    return tuple[index];
-  }
-
-  /**
-   * Returns the first element of a Tuple.
-   * @param tuple - the source tuple
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a', true)
-   * console.log(Tuple.first(t))
-   * // => 1
-   * ```
-   */
-  export function first<T extends Tuple.Source>(tuple: T): T[0] {
-    return tuple[0];
-  }
-
-  /**
-   * Returns the second element of a Tuple.
-   * @param tuple - the source tuple
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a', true)
-   * console.log(Tuple.second(t))
-   * // => 'a'
-   * ```
-   */
-  export function second<T extends Tuple.Source>(tuple: T): T[1] {
-    return tuple[1];
-  }
-
-  /**
-   * Returns the last element of a Tuple.
-   * @param tuple - the source tuple
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a', true)
-   * console.log(Tuple.last(t))
-   * // => true
-   * ```
-   */
-  export function last<T extends readonly unknown[], R>(
-    tuple: readonly [...T, R]
-  ): R {
-    return tuple[tuple.length - 1] as any;
-  }
-
-  /**
-   * Returns a copy of the given `tuple` where the element at given `index` is updated with the
-   * given `updater`.
-   * @param tuple - the source tuple
-   * @param index - the index in the tuple
-   * @param updater - the updater for the value
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a', true)
-   * console.log(Tuple.updateAt(t, 1, 'b'))
-   * // => [1, 'b', true]
-   * ```
-   */
-  export function updateAt<T extends Tuple.Source, K extends keyof T = keyof T>(
-    tuple: T,
-    index: K,
-    updater: Update<T[K]>
-  ): T {
-    return Arr.update(tuple, index as number, updater) as T;
-  }
-
-  /**
-   * Returns the given `tuple` with the given `values` appended.
-   * @param tuple - the source tuple
-   * @param values - the values to append
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a')
-   * console.log(Tuple.append(t, true, 5))
-   * // => [1, 'a', true, 5]
-   * ```
-   */
-  export function append<
-    T extends Tuple.Source,
-    V extends readonly [unknown, ...unknown[]],
-  >(tuple: T, ...values: V): readonly [...T, ...V] {
-    return [...tuple, ...values];
-  }
-
-  /**
-   * Returns a Tuple containing the elements of given `tuple1` followed by the elements
-   * of given `tuple2`.
-   * @param tuple1 - the first Tuple
-   * @param tuple2 - the second Tuple
-   * @example
-   * ```ts
-   * const t1 = Tuple.of(1, 'a')
-   * const t2 = Tuple.of(true, 5)
-   * console.log(Tuple.concat(t1, t2))
-   * // => [1, 'a', true, 5]
-   * ```
-   */
-  export function concat<T1 extends Tuple.Source, T2 extends Tuple.Source>(
-    tuple1: T1,
-    tuple2: T2
-  ): readonly [...T1, ...T2] {
-    return tuple1.concat(tuple2) as any;
-  }
-
-  /**
-   * Returns a Tuple containing all but the last element of the given `tuple`.
-   * @param tuple - the source tuple
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a', true)
-   * console.log(Tuple.init(t))
-   * // => [1, 'a']
-   * ```
-   */
-  export function init<T extends readonly unknown[]>(
-    tuple: readonly [...T, unknown]
-  ): Readonly<T> {
-    return Arr.init(tuple) as any;
-  }
-
-  /**
-   * Returns a Tuple containing all but the first element of the given `tuple`.
-   * @param tuple - the source tuple
-   * @example
-   * ```ts
-   * const t = Tuple.of(1, 'a', true)
-   * console.log(Tuple.tail(t))
-   * // => ['a', true]
-   * ```
-   */
-  export function tail<T extends readonly [...unknown[]]>(
-    tuple: readonly [unknown, ...T]
-  ): Readonly<T> {
-    return Arr.tail(tuple) as any;
-  }
-}