inferred-types 0.51.1 → 0.51.2

package/src/types/dictionary/MapTo.ts

@@ -1,475 +0,0 @@
-/* eslint-disable no-use-before-define */
-import {
-  Dictionary,
-  MergeObjects,
-  OptRequired
-} from "inferred-types/dist/types/index";
-
-/**
- * utility function to take a fully-qualified _user_ config
- * and make it into a FinalizedMapConfig
- */
-const toFinalizedConfig = <
-  IR extends OptRequired,
-  D extends MapCardinalityIllustrated,
-  OR extends OptRequired
->(
-  config: MapConfig<IR, D, OR>
-) => {
-  return { ...config, finalized: true } as FinalizedMapConfig<IR, D, OR>;
-};
-
-export const DEFAULT_ONE_TO_MANY_MAPPING = toFinalizedConfig({
-  input: "req",
-  output: "opt",
-  cardinality: "I -> O[]",
-});
-
-export const DEFAULT_ONE_TO_ONE_MAPPING = toFinalizedConfig({
-  input: "req",
-  output: "req",
-  cardinality: "I -> O",
-});
-
-export const DEFAULT_MANY_TO_ONE_MAPPING = toFinalizedConfig({
-  input: "req",
-  output: "req",
-  cardinality: "I[] -> O",
-});
-
-/**
- * The _default_ One-to-Many mapping that the mapTo() utility provides
- */
-export type DefaultOneToManyMapping = typeof DEFAULT_ONE_TO_MANY_MAPPING;
-
-/**
- * The _default_ One-to-One mapping that the mapTo() utility provides
- */
-export type DefaultOneToOneMapping = typeof DEFAULT_ONE_TO_ONE_MAPPING;
-
-/**
- * The _default_ Many-to-One mapping that the mapTo() utility provides
- */
-export type DefaultManyToOneMapping = typeof DEFAULT_MANY_TO_ONE_MAPPING;
-
-
-/**
- * Expresses relationship between inputs/outputs:
- */
-export enum MapCardinality {
-  /** every input results in 0:M outputs */
-  OneToMany = "I -> O[]",
-  /** every input results in 0:1 outputs */
-  OneToOne = "I -> O",
-  /** every input is an array of type I and reduced to a single O  */
-  ManyToOne = "I[] -> O",
-}
-
-export type MapCardinalityIllustrated = `${string | number}`;
-
-/**
- * The _user_ configuration of a **mapTo** mapper function
- * which will be finalized by merging it with the appropriate
- * default mapping type.
- */
-export interface MapConfig<
-  IR extends OptRequired | undefined = undefined,
-  D extends MapCardinalityIllustrated | undefined = undefined,
-  OR extends OptRequired | undefined = undefined
-> {
-  input?: IR;
-  output?: OR;
-  cardinality?: D;
-  /**
-   * Whether calls to the final `MapFn` will be logged to stderr
-   * for debugging purposes. Defaults to false; if you specify
-   * a _string_ for a value that will be sent to stderr along
-   * with other debugging info.
-   */
-  debug?: boolean | string;
-}
-
-/**
- * A finalized configuration of a **mapTo** mapper functions cardinality
- * relationships between _inputs_ and _outputs_.
- *
- * Note: _this configuration does _not_ yet include the actual mapping
- * configuration between the input and output._
- */
-export type FinalizedMapConfig<
-  IR extends OptRequired = MapIR<DefaultOneToManyMapping & string>,
-  D extends MapCardinalityIllustrated = MapCard<DefaultOneToManyMapping>,
-  OR extends OptRequired = MapOR<DefaultOneToManyMapping>
-> = Required<Omit<MapConfig<IR, D, OR>, "debug">> & { finalized: true; debug: boolean | string };
-
-/**
- * User configuration exposed by a config function which specifies the
- * cardinality already (e.g., `oneToMany()`, `manyToOne()`)
- */
-type MapCardinalityConfig<
-  IR extends OptRequired | undefined,
-  OR extends OptRequired | undefined
-> = {
-  /** whether we the input can _optionally_ be an `undefined` value or not */
-  input?: IR;
-  /** whether we the output can _optionally_ be an `undefined` value or not */
-  output?: OR;
-  /**
-   * Whether calls to the final `MapFn` will be logged to stderr
-   * for debugging purposes. Defaults to false; if you set to a string
-   * value than this will be echoed out with stderr.
-   */
-  debug?: boolean | string;
-};
-
-/**
- * **ConfiguredMap**
- *
- * A partial application of the mapTo() utility which has expressed the
- * configuration of the _inputs_ and _outputs_ and provides a `.map()`
- * method which allows the user configure the specifics of the mapping.
- */
-export type ConfiguredMap<
-  C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
-> = {
-  map: <I, O>(map: MapTo<I, O, C>) => Mapper<I, O, C>;
-  input: MapIR<C>;
-  cardinality: MapCard<C>;
-  output: MapOR<C>;
-  debug: boolean | string;
-};
-
-/**
- * Extracts the IR, Cardinality, and OR generics from a FinalizedMapConfig
- */
-export type DecomposeMapConfig<
-  M extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
-> = M extends MapConfig<infer IR, infer D, infer OR>
-  ? IR extends OptRequired | undefined
-    ? D extends MapCardinalityIllustrated | undefined
-      ? OR extends OptRequired | undefined
-        ? [IR, D, OR]
-        : never
-      : never
-    : never
-  : M extends FinalizedMapConfig<infer IR, infer D, infer OR>
-  ? IR extends OptRequired
-    ? D extends MapCardinalityIllustrated
-      ? OR extends OptRequired
-        ? [IR, D, OR]
-        : never
-      : never
-    : never
-  : never;
-
-/** extracts IR from a `FinalizedMapConfig` */
-export type MapIR<
-  T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
-> = DecomposeMapConfig<T>[0];
-
-/**
- * extracts the MapCardinality from a `FinalizedMapConfig`
- */
-export type MapCard<
-  T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
-> = DecomposeMapConfig<T>[1];
-
-/** extracts OR from a `FinalizedMapConfig` */
-export type MapOR<
-  T extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
-> = DecomposeMapConfig<T>[2];
-
-/**
- * Merges the types of a userland configuration with a default configuration
- */
-export type AsFinalizedConfig<
-  U extends MapConfig<
-    OptRequired | undefined,
-    MapCardinalityIllustrated | undefined,
-    OptRequired | undefined
-  >,
-  D extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
-> = MergeObjects<U & Dictionary, D> extends FinalizedMapConfig<infer IR, infer C, infer OR>
-  ? FinalizedMapConfig<IR, C, OR>
-  : never;
-
-export type MapperApi = {
-  /**
-   * Provides opportunity to configure _input_, _output_, and _cardinality_
-   * prior to providing a mapping function.
-   *
-   * Note: _the defaults for configuration are defined by the_ `DEFAULT_ONE_TO_MANY_MAPPING`
-   * _constant made available as a symbol from this library._
-   */
-  config: <
-    C extends MapConfig<
-      OptRequired, //
-      MapCardinalityIllustrated,
-      OptRequired
-    >
-  >(
-    config: C
-  ) => ConfiguredMap<
-    AsFinalizedConfig<
-      C, //
-      DefaultOneToManyMapping
-    >
-  >;
-
-  /**
-   * Provides a nice 1:1 ratio between the input and output.
-   *
-   * By default the input and output are considered to be _required_
-   * properties but this can be changed with the options hash provided.
-   * ```ts
-   * const mapper = mapTo.oneToOne().map(...);
-   * // add in ability to filter out some inputs
-   * const mapAndFilter = mapTo.oneToOne({ output: "opt" })
-   * ```
-   */
-  oneToOne: <C extends MapCardinalityConfig<OptRequired, OptRequired>>(
-    config?: C
-  ) => ConfiguredMap<
-    AsFinalizedConfig<
-      C, //
-      DefaultOneToOneMapping
-    >
-  >;
-
-  /**
-   * **manyToOne** _mapping_
-   *
-   * Provides a configuration where multiple inputs `I[]` will be mapped to a
-   * single output `O`.
-   *
-   * Choosing this configuration will, by default, set both input and output
-   * to be "required" but you can change this default if you so choose.
-   */
-  manyToOne: <
-    C extends MapCardinalityConfig<
-      OptRequired | undefined, //
-      OptRequired | undefined
-    >
-  >(
-    config?: C
-  ) => ConfiguredMap<
-    AsFinalizedConfig<
-      C, //
-      DefaultManyToOneMapping
-    >
-  >;
-
-  oneToMany: <
-    C extends MapCardinalityConfig<
-      OptRequired | undefined, //
-      OptRequired | undefined
-    >
-  >(
-    config?: C
-  ) => ConfiguredMap<
-    AsFinalizedConfig<
-      C, //
-      DefaultOneToManyMapping
-    >
-  >;
-};
-
-export type MapInput<
-  I, //
-  IR extends OptRequired,
-  C extends MapCardinalityIllustrated
-> = C extends MapCardinality.OneToMany | "I -> O[]"
-  ? IR extends "opt"
-    ? I | undefined
-    : I
-  : C extends MapCardinality.OneToOne | "I -> O"
-  ? IR extends "opt"
-    ? I | undefined
-    : I
-  : C extends MapCardinality.ManyToOne | "I[] -> O"
-  ? IR extends "opt"
-    ? I[] | undefined
-    : I[]
-  : never;
-
-export type MapOutput<
-  O, //
-  OR extends OptRequired,
-  C extends MapCardinalityIllustrated
-> = C extends MapCardinality.OneToMany | "I -> O[]"
-  ? OR extends "opt"
-    ? O[]
-    : [O, ...O[]]
-  : C extends MapCardinality.OneToOne | "I -> O"
-  ? OR extends "opt"
-    ? O | null
-    : O
-  : C extends MapCardinality.ManyToOne | "I[] -> O"
-  ? OR extends "opt"
-    ? O | null
-    : O
-  : never;
-
-/**
- * **MapTo<I, O>**
- *
- * A mapping function between an input type `I` and output type `O`. Defaults to using
- * the _default_ OneToMany mapping config.
- *
- * **Note:** this type is designed to guide the userland mapping; refer
- * to `MapFn` if you want the type output by the `mapFn()` utility.
- */
-export type MapTo<
-  I,
-  O,
-  C extends FinalizedMapConfig<
-    OptRequired,
-    MapCardinalityIllustrated,
-    OptRequired
-  > = DefaultOneToManyMapping
-> = MapIR<C> extends "opt"
-  ? (source?: MapInput<I, MapIR<C>, MapCard<C>>) => MapOutput<O, MapOR<C>, MapCard<C>>
-  : (source: MapInput<I, MapIR<C>, MapCard<C>>) => MapOutput<O, MapOR<C>, MapCard<C>>;
-
-export type MapFnOutput<
-  I,
-  O,
-  S,
-  OR extends OptRequired,
-  C extends MapCardinalityIllustrated
-> = C extends "I -> O[]" | MapCardinality.OneToMany
-  ? S extends I[]
-    ? OR extends "opt"
-      ? O[]
-      : [O, ...O[]]
-    : OR extends "opt"
-    ? O[] | null
-    : O[]
-  : C extends MapCardinality.OneToOne | "I -> O"
-  ? S extends I[]
-    ? OR extends "opt"
-      ? O[]
-      : [O, ...O[]]
-    : OR extends "opt"
-    ? O | null
-    : O
-  : C extends MapCardinality.ManyToOne | "I[] -> O"
-  ? S extends I[][]
-    ? OR extends "opt"
-      ? O[]
-      : [O, ...O[]]
-    : OR extends "opt"
-    ? O | null
-    : O
-  : never;
-
-export type MapFnInput<I, IR extends OptRequired, D extends MapCardinalityIllustrated> = D extends
-  | "I -> O[]"
-  | MapCardinality.OneToMany
-  ? IR extends "opt"
-    ? I | I[] | undefined
-    : I | I[]
-  : D extends MapCardinality.OneToOne | "I -> O"
-  ? IR extends "opt"
-    ? I | I[] | undefined
-    : I | I[]
-  : D extends MapCardinality.ManyToOne | "I[] -> O"
-  ? IR extends "opt"
-    ? I[] | I[][] | undefined
-    : I[] | I[][]
-  : never;
-
-/**
- * The mapping function provided by the `mapFn()` utility. This _fn_
- * is intended to be used in two ways:
- *
- * 1. Iterative:
- *    ```ts
- *    const m = mapTo<I,O>(i => [ ... ]);
- *    // maps inputs to outputs
- *    const out = inputs.map(m);
- *    ```
- * 2. Block:
- *    ```ts
- *    // maps inputs to outputs (filtering or splitting where appr.)
- *    const out2 = m(inputs);
- *    ```
- */
-export type MapFn<
-  I,
-  O,
-  C extends FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
-> = MapIR<C> extends "opt"
-  ? <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(
-      source?: S
-    ) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>
-  : <S extends MapFnInput<I, MapIR<C>, MapCard<C>>>(
-      source: S
-    ) => MapFnOutput<I, O, S, MapOR<C>, MapCard<C>>;
-
-/**
- * **Mapper**
- *
- * A fully configured _mapper_ stemming from the **mapTo()** utility. It is both a mapping
- * function and a dictionary which describes the mapper's properties.
- * ```ts
- * const m = mapTo.oneToOne().map( ... );
- * const mapped = m(inputs);
- * const mappedOver = inputs.map(m);
- * ```
- *
- * Note: the root of a `Mapper` is the mapper function but
- * this is combined with a dictionary of settings and types
- * which you can use. For instance, look at the `fnSignature`
- * property to get the _type_ signature of the map function.
- */
-export type Mapper<
-  I = unknown,
-  O = unknown,
-  C extends FinalizedMapConfig<
-    OptRequired,
-    MapCardinalityIllustrated,
-    OptRequired
-  > = FinalizedMapConfig<OptRequired, MapCardinalityIllustrated, OptRequired>
-> = {
-  input: MapIR<C>;
-  output: MapOR<C>;
-  cardinality: MapCard<C>;
-  debug: boolean | string;
-  inputType: I;
-  outputType: O;
-  /**
-   * Provides the _type_ information for mapper function.
-   *
-   * Note: _this is just a **type**_ not the actual function which positioned
-   * at the root of the Mapper type
-   */
-  fnSignature: MapFn<I, O, C>;
-} & MapFn<I, O, C>;
-
-/**
- * **MapInputFrom**
- *
- * Type utility which extracts the `I` type from a fully configured `Mapper`
- */
-export type MapInputFrom<T extends Mapper> = T extends Mapper<infer I> ? I : never;
-
-/**
- * **MapOutputFrom**
- *
- * Type utility which extracts the output [`O`] type from a fully configured `Mapper`
- */
-
-export type MapOutputFrom<T extends Mapper> = T extends Mapper<any, infer O> ? O : never;
-
-/**
- * **MapCardinalityFrom**
- *
- * Type utility which extracts _cardinality_ of a `Mapper`'s inputs to outputs
- */
-
-export type MapCardinalityFrom<T extends Mapper> = T extends Mapper<any, any, infer C>
-  ? C extends FinalizedMapConfig<OptRequired, infer Cardinality, OptRequired>
-    ? Cardinality
-    : never
-  : never;

package/src/types/dictionary/MaybeRef.ts

@@ -1,17 +0,0 @@
-import { VueRef } from "inferred-types/dist/types/index";
-
-/**
- * **MaybeRef**`<T>`
- *
- * Used to represent a type which is either of the two:
- *
- * - `T`
- * - `VueRef<T>`
- *
- * **Related:** `IsRef`, `IfRef`
- * ```ts
- * // number | VueRef<number>
- * type T = MaybeRef<number>;
- * ```
- */
-export type MaybeRef<T> = T | VueRef<T>;

package/src/types/dictionary/MergeKVs.ts

@@ -1,30 +0,0 @@
-import { Dictionary, EmptyObject } from "../base-types";
-import { AfterFirst } from "../lists/AfterFirst";
-import { First } from "../lists/First";
-import { ExpandRecursively } from "../literals/ExpandRecursively";
-
-type Process<
-TInput extends readonly {[key: string]: unknown}[],
-TOutput extends Dictionary = EmptyObject
-> = [] extends TInput
-? TOutput extends Record<string, unknown>
-? ExpandRecursively<TOutput> 
-: never
-: Process<
-  AfterFirst<TInput>,
-  First<TInput> extends keyof TOutput
-  ? TOutput
-  : TOutput & First<TInput>
->;
-
-/**
- * **MergeKVs**`<TKVs>`
- * 
- * Receives an array of `Dictionary` types and merges this to 
- * single dictionary.
- * 
- * **Note:** _if key is repeated in the set, only the first one's value will be retained_
- */
-export type MergeKVs<
-  TInput extends readonly {[key: string]: unknown}[]
-> = Process<TInput>

package/src/types/dictionary/MutableProps.ts

@@ -1,9 +0,0 @@
-import {  Dictionary, ReadonlyKeys } from "inferred-types/dist/types/index";
-
-/**
- * **MutableProps**`<T>`
- *
- * Reduces an object down to just the key/value pairs which
- * are mutable.
- */
-export type MutableProps<T extends Dictionary> = Omit<T, ReadonlyKeys<T>>;

package/src/types/dictionary/NonNumericKeys.ts

@@ -1,8 +0,0 @@
-/**
- * **NonNumericKeys**`<T>`
- * 
- * The keys in an array/object `T` which are _not_ numeric keys.
- */
-export type NonNumericKeys<T extends object> = {
-  [K in keyof T]: K extends number ? never : Readonly<K>;
-}[keyof T];

package/src/types/dictionary/NonStringKeys.ts

@@ -1,15 +0,0 @@
-import { AnyObject } from "inferred-types/dist/types/index";
-
-/**
- * **NonStringKeys**`<T>`
- *
- * Builds a union type of the keys of `T` which are _not_
- * _string_ keys. This can be useful as _symbols_ can also
- * be seen as valid keys and these keys are often used for
- * "identity" purposes.
- *
- * **Related:** `StringKeys`
- */
-export type NonStringKeys<T extends AnyObject> = {
-  [K in keyof T]: K extends string ? never : Readonly<K>;
-}[keyof T];

package/src/types/dictionary/OptionalKeys.ts

@@ -1,36 +0,0 @@
-
-import {
-  AnyObject,
-  EmptyObject,
-  If,
-  IsEqual,
-  Unset
- } from "inferred-types/dist/types/index";
-
-/**
- * **OptionalKeys**`<T,[V]>`
- *
- * Provides a union type of the _keys_ in `T` which are
- * **optional** properties.
- *
- * **Note:** you also may optionally filter further by specifying a value
- * by the _value_ of the key and then only keys which are required AND
- * who extend `V` will be included in the union.
- *
- * **Related:** `OptionalKeys`, `RequiredProps` * Provides a union type of the _keys_ in `T` which are
- * **required** properties.
- *
- * **Note:** you also may optionally filter further by specifying a value
- * by the _value_ of the key and then only keys which are required AND
- * who extend `V` will be included in the union.
- *
- * **Related:** `RequiredKeys`, `RequiredProps`
- */
-export type OptionalKeys<
-  T extends AnyObject,
-  V = Unset
-> = {
-  [K in keyof T]-?: EmptyObject extends { [P in K]: T[K] }
-    ? If<IsEqual<V,Unset>, K, K extends V ? K : never>
-    : never;
-}[keyof T];

package/src/types/dictionary/OptionalProps.ts

@@ -1,11 +0,0 @@
-import { EmptyObject, OptionalKeys, RemoveIndexKeys } from "inferred-types/dist/types/index";
-
-/**
- * **OptionalProps**
- *
- * Reduces an object to only key/value pairs where the key is optional
- */
-export type OptionalProps<T extends object> =
-EmptyObject extends RemoveIndexKeys<Pick<T, OptionalKeys<T>>>
-? RemoveIndexKeys<Pick<T, OptionalKeys<T>>>
-: never;

package/src/types/dictionary/PascalKeys.ts

@@ -1,42 +0,0 @@
-import { Dictionary, EmptyObject, ObjectKey } from "../base-types";
-import { AfterFirst, First } from "../lists";
-import { ExpandDictionary } from "../literals/ExpandRecursively";
-import {  PascalCase } from "../string-literals";
-import { UnionMutate } from "../type-conversion";
-import { Keys } from "./Keys";
-import { MakeKeysOptional } from "./MakeKeysOptional";
-import { OptionalKeys } from "./OptionalKeys";
-
-
-type Process<
-  TObj extends Dictionary,
-  TKeys extends readonly (ObjectKey & keyof TObj)[],
-  TResult extends Dictionary = EmptyObject
-> = [] extends TKeys
-? ExpandDictionary<TResult>
-: Process<
-    TObj,
-    AfterFirst<TKeys>,
-    First<TKeys> extends string
-    ? Record<PascalCase<First<TKeys>>, TObj[First<TKeys>]> & TResult
-    : Record<First<TKeys>, TObj[First<TKeys>]> & TResult
-  >;
-
-/**
- * Converts an object's keys to the **camelCase** equivalent
- * while keeping the values the same.
- */
-export type PascalKeys<
-  T extends Dictionary
-> = MakeKeysOptional<
-  // make all keys camel case and required
-  Process<T, Keys<T>>,
-  // make optional props optional again
-  OptionalKeys<T> extends string
-    ? UnionMutate<OptionalKeys<T>, "PascalCase"> extends string
-      ? UnionMutate<OptionalKeys<T>, "PascalCase">
-      : ""
-    : ""
->
-
-

package/src/types/dictionary/ReadonlyKeys.ts

@@ -1,19 +0,0 @@
-type MyEqual<A, B> = (<X>() => X extends A ? 0 : 1) extends <X>() => X extends B
-  ? 0
-  : 1
-  ? true
-  : false;
-
-type isReadonly<T, K extends keyof T> = MyEqual<
-  { [P in K]: T[P] },
-  { readonly [P in K]: T[P] }
->;
-
-/**
- * **ReadonlyKeys**`<T>`
- * 
- * Creates a union of properties in `T` which are readonly.
- */
-export type ReadonlyKeys<T extends object> = keyof {
-  [K in keyof T as isReadonly<T, K> extends true ? K : never]: T[K];
-};

package/src/types/dictionary/ReadonlyProps.ts

@@ -1,9 +0,0 @@
-import { ReadonlyKeys } from "inferred-types/dist/types/index";
-
-/**
- * **ReadonlyProps**`<T>`
- *
- * Reduces an object down to just the key/value pairs which
- * are readonly.
- */
-export type ReadonlyProps<T extends object> = Pick<T, ReadonlyKeys<T>>;

package/src/types/dictionary/RemoveIndexKeys.ts

@@ -1,22 +0,0 @@
-
-/**
- * **RemoveIndexKeys**`<T>`
- * 
- * Removes _index_ keys which permit key/values to be added to an object while
- * retaining all explicit key/values defined on an object.
- * 
- * ```ts
- * type Obj = { [key: string]: unknown; foo: 42 };
- * // { foo: 42 }
- * type Obj2 = RemoveIndexKeys<Obj>;
- * ```
- */
-export type RemoveIndexKeys<T> = {
-  [K in keyof T as string extends K 
-    ? never 
-    : number extends K 
-      ? never 
-      : symbol extends K
-      ? never
-      : K]: T[K]
-};