@rimbu/deep 0.9.2 → 0.10.0

package/dist/types/literal.d.ts

@@ -1,48 +0,0 @@
-declare const LITERAL: unique symbol;
-declare type LITERAL = typeof LITERAL;
-/**
- * Type to represent Literal values for the match and patch functions.
- */
-export interface Literal<T> {
-    readonly [LITERAL]: T;
-}
-export declare namespace Literal {
-    /**
-     * Returns a Literal value embedding the given `value`.
-     * @param value - the value to embed in a Literal type
-     */
-    function of<T>(value: T): Literal<T>;
-    /**
-     * Excludes Iterable types
-     */
-    interface NoIterable {
-        readonly [Symbol.iterator]?: never;
-    }
-    /**
-     * A plain object that is not iterable
-     */
-    type Obj = Record<string, unknown> & NoIterable;
-    /**
-     * Type to determine whether a value needs to be a Literal instance or may be a Literal instance.
-     * @typeparam T - the value type
-     */
-    type Value<T> = T extends {
-        readonly [Symbol.iterator]: any;
-    } | Obj | readonly any[] | undefined | (() => any) ? T extends string ? T | Literal<T> : Literal<T> : T | Literal<T>;
-    /**
-     * Returns true if the given `obj` value is a Literal instance.
-     * @param obj - the object to check
-     */
-    function isLiteral<T>(obj: any): obj is Literal<T>;
-    /**
-     * Returns the value embedded in a Literal instance
-     * @param obj - the Literal instance
-     */
-    function getValue<T>(obj: Literal<T>): T;
-    /**
-     * Returns true if the given `obj` is a plain JS object
-     * @param obj - the object to check
-     */
-    function isPlainObject(obj: any): boolean;
-}
-export {};

package/src/immutable.ts

@@ -1,21 +0,0 @@
-import type { Literal } from './internal';
-
-/**
- * An immutably typed version of given type T. Makes all properties or elements read only.
- * @typeparam T - the input type
- */
-export type Immutable<T> = T extends (infer E)[]
-  ? readonly Immutable<E>[]
-  : T extends Literal.Obj
-  ? { readonly [K in keyof T]: Immutable<T[K]> }
-  : T extends boolean
-  ? boolean
-  : T;
-
-/**
- * Returns the same value wrapped in the Immutable type
- * @param value - the value to wrap
- */
-export function Immutable<T>(value: T): Immutable<T> {
-  return value as any;
-}

package/src/literal.ts

@@ -1,70 +0,0 @@
-const LITERAL = Symbol('LITERAL');
-type LITERAL = typeof LITERAL;
-
-/**
- * Type to represent Literal values for the match and patch functions.
- */
-export interface Literal<T> {
-  readonly [LITERAL]: T;
-}
-
-export namespace Literal {
-  /**
-   * Returns a Literal value embedding the given `value`.
-   * @param value - the value to embed in a Literal type
-   */
-  export function of<T>(value: T): Literal<T> {
-    return { [LITERAL]: value };
-  }
-
-  /**
-   * Excludes Iterable types
-   */
-  export interface NoIterable {
-    readonly [Symbol.iterator]?: never;
-  }
-
-  /**
-   * A plain object that is not iterable
-   */
-  export type Obj = Record<string, unknown> & NoIterable;
-
-  /**
-   * Type to determine whether a value needs to be a Literal instance or may be a Literal instance.
-   * @typeparam T - the value type
-   */
-  export type Value<T> = T extends
-    | { readonly [Symbol.iterator]: any }
-    | Obj
-    | readonly any[]
-    | undefined
-    | (() => any)
-    ? T extends string
-      ? T | Literal<T>
-      : Literal<T>
-    : T | Literal<T>;
-
-  /**
-   * Returns true if the given `obj` value is a Literal instance.
-   * @param obj - the object to check
-   */
-  export function isLiteral<T>(obj: any): obj is Literal<T> {
-    return LITERAL in obj;
-  }
-
-  /**
-   * Returns the value embedded in a Literal instance
-   * @param obj - the Literal instance
-   */
-  export function getValue<T>(obj: Literal<T>): T {
-    return obj[LITERAL];
-  }
-
-  /**
-   * Returns true if the given `obj` is a plain JS object
-   * @param obj - the object to check
-   */
-  export function isPlainObject(obj: any): boolean {
-    return obj.constructor === Object && !(Symbol.iterator in obj);
-  }
-}