inferred-types 0.51.1 → 0.51.2

package/src/types/dictionary/RequireProps.ts

@@ -1,15 +0,0 @@
-import { EmptyObject, ExpandRecursively } from "inferred-types/dist/types/index";
-
-/**
- * Given a dictionary of type `<T>`, this utility function will
- * make the `<R>` generic property _required_ (use a union to make
- * more than one prop required).
- *
- * ```ts
- * // { foo: string, bar?: number }
- * type Example = RequireProps<{foo?: string, bar?: number}, "foo">;
- * ```
- */
-export type RequireProps<T extends EmptyObject, R extends keyof T> = ExpandRecursively<
-  Required<Pick<T, R>> & T
->;

package/src/types/dictionary/RequiredKeys.ts

@@ -1,27 +0,0 @@
-import {  As, Dictionary, EmptyObject, IfUnset, ObjectKey, Unset } from "inferred-types/dist/types/index";
-
-/**
- * **RequiredKeys**`<T,[V]>`
- *
- * 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:** `OptionalKeys`, `RequiredProps`
- */
-export type RequiredKeys<
-  T extends Dictionary,
-  V = Unset> = As<{
-  [K in keyof T]-?: EmptyObject extends { [P in K]: T[K] }
-    ? never //
-    : IfUnset<
-        V,
-        K,
-        T[K] extends V
-          ? K
-          : never
-      >;
-}[keyof T], ObjectKey>;

package/src/types/dictionary/RequiredProps.ts

@@ -1,8 +0,0 @@
-import { AnyObject, RequiredKeys } from "inferred-types/dist/types/index";
-
-/**
- * **RequiredProps**`<T>`
- *
- * Reduces an object `T` to only those key/value pairs where the key is required
- */
-export type RequiredProps<T extends AnyObject> = Pick<T, RequiredKeys<T>>;

package/src/types/dictionary/RetainProps.ts

@@ -1,45 +0,0 @@
-import { Dictionary, EmptyObject, ObjectKey } from "../base-types";
-import { ComparatorOperation, Compare } from "../boolean-logic";
-import { Keys } from "./Keys";
-import { ExpandDictionary } from "../literals";
-import { AfterFirst } from "../lists/AfterFirst";
-import { First } from "../lists/First";
-
-type Process<
-  TObj extends Dictionary,
-  TComparator,
-  TOp extends ComparatorOperation,
-  TKeys extends readonly ObjectKey[],
-  TResult extends Dictionary = EmptyObject
-> = [] extends TKeys
-? ExpandDictionary< TResult >
-: Process<
-    TObj,
-    TComparator,
-    TOp,
-    AfterFirst<TKeys>,
-    Compare<TObj[First<TKeys>], TOp, TComparator> extends true
-      ? TResult & Record<First<TKeys>, TObj[First<TKeys>]>
-      : TResult
-  >;
-
-/**
- * **RetainProps**`<TObj, TComparator, [TOp]>`
- *
- * Type utility which targets dictionary objects and _retains_
- * the key/value pairs which _extend_ the type `TComparator`.
- *
- * - by default the comparison operation -- dictated by `TOp` -- is
- * "extends" but you can change the comparison operation to
- * `equals`, `startsWith`, `endsWith`, ...
- */
-export type RetainProps<
-  TObj extends Dictionary,
-  TComparator,
-  TOp extends ComparatorOperation = "extends"
-> = Process<
-  TObj,
-  TComparator,
-  TOp,
-  Keys<TObj>
->;

package/src/types/dictionary/SharedKeys.ts

@@ -1,21 +0,0 @@
-import {  IntersectingKeys, ObjectKey } from "inferred-types/dist/types/index";
-
-
-/**
- * **SharedKeys**`<A,B>`
- *
- * Given two objects `A` and `B`, this type utility will provide the
- * _keys_ which both objects contain.
- * ```ts
- * type O1 = { foo: 1; bar: 2; baz: 88 };
- * type O2 = { bar: 5; baz: 3; nada: true };
- * //  ["bar", "baz"]
- * type X = SharedKeys<O1,O2>;
- * ```
- *
- * **Note:** this is now just an alias to `IntersectingKeys`
- */
-export type SharedKeys<
-  A extends Record<ObjectKey, unknown> | object,
-  B extends Record<ObjectKey, unknown> | object
-> = IntersectingKeys<A,B>;

package/src/types/dictionary/SimplifyObject.ts

@@ -1,11 +0,0 @@
-import { ExpandRecursively , UnionToIntersection } from "inferred-types/dist/types/index";
-
-/**
- * Often when mutating the shape of an object you will end up with the union of a number of
- * `Record<string, x>` and `Record<string, y>` which is messy to look at and take away meaning.
- *
- * This type utility will cleanup an object and return a simple dictionary definition for it.
- */
-export type SimplifyObject<T extends object> = ExpandRecursively<
-  UnionToIntersection<ExpandRecursively<T>>
->;

package/src/types/dictionary/SnakeKeys.ts

@@ -1,42 +0,0 @@
-import { Dictionary, EmptyObject, ObjectKey } from "../base-types";
-import { AfterFirst, First } from "../lists";
-import { ExpandDictionary } from "../literals/ExpandRecursively";
-import {  SnakeCase } 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<SnakeCase<First<TKeys>>, TObj[First<TKeys>]> & TResult
-    : Record<First<TKeys>, TObj[First<TKeys>]> & TResult
-  >;
-
-/**
- * Converts an object's keys to the **kebab-case** equivalent
- * while keeping the values the same.
- */
-export type SnakeKeys<
-  T extends Dictionary
-> = MakeKeysOptional<
-  // make all keys Kebab case and required
-  Process<T, Keys<T>>,
-  // make optional props optional again
-  OptionalKeys<T> extends string
-    ? UnionMutate<OptionalKeys<T>, "SnakeCase"> extends string
-      ? UnionMutate<OptionalKeys<T>, "SnakeCase">
-      : ""
-    : ""
->
-
-

package/src/types/dictionary/StringKeys.ts

@@ -1,8 +0,0 @@
-/**
- * **StringKeys**`<T>`
- * 
- * Creates a union type of all the _string_ keys in `T`.
- */
-export type StringKeys<T extends object> = {
-  [K in keyof T]: K extends string ? Readonly<K> : never;
-}[keyof T];

package/src/types/dictionary/TakeProp.ts

@@ -1,16 +0,0 @@
-
-/**
- * **TakeProp**`<TTest,TProp,[TElse]>`
- * 
- * Takes the property `TTest` and determines if `TProp` is a key of
- * of `TTest`. If it is it will return `TTest[TProp]` otherwise `TElse`
- * (which is defaulted to _undefined_).
- */
-export type TakeProp<
-  TTest,
-  TProp extends PropertyKey,
-  TElse = undefined
-> = TProp extends keyof TTest
-? TTest[TProp]
-: TElse;
-  

package/src/types/dictionary/UpsertKeyValue.ts

@@ -1,29 +0,0 @@
-
-import {
-  AnyObject,
-  ExpandRecursively,
-  ObjectKey,
-} from "inferred-types/dist/types/index";
-
-
-type Process<
-TObj extends AnyObject,
-K extends ObjectKey,
-V
-> = K extends keyof TObj
-? Omit<TObj, K> & Record<K,V>
-: TObj & Record<K,V>;
-
-/**
- * **UpsertKeyValue**`<TObj,TKey,TVal>`
- *
- * Updates the object `TObj` with the provided KV when keys overlap,
- * otherwise just adds the KV to `TObj`.
- *
- * **Related:** `AddKeyValue`
- */
-export type UpsertKeyValue<
-  TObj extends AnyObject,
-  K extends ObjectKey,
-  V
-> = ExpandRecursively<Process<TObj, K, V>>;

package/src/types/dictionary/ValidKey.ts

@@ -1,16 +0,0 @@
-import { AsArray, Container, Keys, TupleToUnion } from "inferred-types/dist/types/index";
-
-
-/**
- * **ValidKey**<TContainer>
- *
- * Similar to the `Keys<T>` utility but returns a union of values
- * which are considered valid for the container.
- *
- * **Related**: `Keys`
- */
-export type ValidKey<
-  TContainer extends Container
-> = TupleToUnion<
-  AsArray<Keys<TContainer>>
->;

package/src/types/dictionary/Values.ts

@@ -1,47 +0,0 @@
-import { Container, Dictionary, ObjectKey, Tuple, TypedFunction } from "../base-types";
-import { AfterFirst, First } from "../lists";
-import { Keys } from "./Keys";
-
-
-type Process<
-  TKeys extends readonly ObjectKey[],
-  TObj extends Record<ObjectKey, unknown>,
-  TResult extends readonly unknown[] = []
-> = [] extends TKeys
-? TResult
-: Process<
-    AfterFirst<TKeys>,
-    TObj,
-    [
-      ...TResult,
-      First<TKeys> extends keyof TObj
-        ? TObj[First<TKeys>]
-        : never
-    ]
-  >
-
-
-/**
- * **Values**`<T>`
- *
- * Produces a tuple of all the _values_ of a container.
- * - for **objects** this would translate to the key values
- * - for **tuples** this is just a _proxy_ of the type
- * - for _wide_ types like `string[]`
- */
-export type Values<
-  T extends Container
-> = T extends Tuple
-? T
-: T extends Dictionary
-  ? Process<
-      Keys<T> extends readonly ObjectKey[]
-        ? Keys<T>
-        : never,
-      T
-    >
-  : T extends TypedFunction
-    ? [T]
-
-  : [];
-

package/src/types/dictionary/WithKeys.ts

@@ -1,42 +0,0 @@
-import {  AnyObject , ExpandRecursively ,  Tuple, TupleToUnion, UnionToIntersection } from "inferred-types/dist/types/index";
-
-type MakeIntoUnion<K extends PropertyKey | readonly PropertyKey[]> =
-  K extends readonly PropertyKey[] ? TupleToUnion<K> : K;
-
-//TODO: this needs to convert a KV (with keys such as "0", "1", etc.) into an array
-type MakeNumericIndex<
-  T,
-> = T;
-
-/**
- * **WithKeys**`<T,K>`
- *
- * This type utility will ensure that the type `T` will _retain_ the key/value
- * pairs which extend `K`.
- *
- * It is very similar to **Pick** but rather `K` being restricted to
- * being a string union, wth **WithKeys** you can use the union type
- * or a readonly array of strings.
- *
- * ```ts
- * type Test = { foo: 1, bar: number, baz: string };
- * // { foo: 1, bar: number }
- * type T1 = WithKeys<Test, "foo" | "bar">; // Pick syntax
- * type T2 = WithKeys<Test, ["foo", "bar"]>;
- * ```
- */
-export type WithKeys<
-  T extends AnyObject | Tuple,
-  K extends PropertyKey | readonly PropertyKey[]
-> =
-ExpandRecursively<
-  UnionToIntersection<
-    MakeIntoUnion<K> extends keyof T
-    ? T extends Tuple
-      ? // Tuple based container
-        MakeNumericIndex<Pick<T,MakeIntoUnion<K>>>
-      : // Object based container
-        Pick<T,MakeIntoUnion<K>>
-    : never
-  >
->;

package/src/types/dictionary/WithNumericKeys.ts

@@ -1,8 +0,0 @@
-import { NonNumericKeys } from "inferred-types/dist/types/index";
-
-/**
- * **WithNumericKeys**`<T>`
- *
- * Reduces an object to only the key/value pairs where the key is numeric.
- */
-export type WithNumericKeys<T extends object> = Omit<T, NonNumericKeys<T>>;

package/src/types/dictionary/WithStringKeys.ts

@@ -1,9 +0,0 @@
-import { AnyObject, NonStringKeys } from "inferred-types/dist/types/index";
-
-/**
- * **WithStringKeys**`<T>`
- *
- * Reduces an object to only the key/value pairs where the key is a
- * string.
- */
-export type WithStringKeys<T extends AnyObject> = Omit<T, NonStringKeys<T>>;

package/src/types/dictionary/WithValue.ts

@@ -1,42 +0,0 @@
-import { MARKED } from "inferred-types/dist/constants/index";
-import {
-  Compare,
-  ExpandRecursively,
-  If,
-  Dictionary,
-  RemoveMarked
-} from "inferred-types/dist/types/index";
-
-
-type Marked = typeof MARKED;
-
-type Process<
-  TObj extends Dictionary,
-  TValue,
-  TOp extends "equals" | "extends"
-> = RemoveMarked<{
-    [K in keyof TObj]: If<
-      Compare<TObj[K], TOp, TValue>,
-      TObj[K],
-      Marked
-    >
-}>;
-
-/**
- * **WithValue**`<TObj,TValue>`
- *
- * Reduces an object's type down to only those key/value pairs where the
- * value is of type `W`.
- * ```ts
- * const foo = { a: 1, b: "hi", c: () => "hello" }
- * // { c: () => "hello" }
- * type W = WithValue<typeof foo, Function>
- * ```
- *
- * **Related:** `WithoutValue`, `WithKeys`, `WithoutKeys`
- */
-export type WithValue<
-  TObj extends Dictionary,
-  TValue,
-  TOp extends "equals" | "extends" = "extends"
-> = ExpandRecursively<Process<TObj,TValue,TOp>>

package/src/types/dictionary/WithoutKeys.ts

@@ -1,40 +0,0 @@
-
-import {
-  TupleToUnion,
-  ObjectKey,
-  Dictionary,
-  ExpandDictionary,
-} from "inferred-types/dist/types/index";
-
-type Process<
-  TObj extends Dictionary,
-  TKeys extends ObjectKey,
-> = [] extends TKeys
-? TObj
-: Omit<TObj, TKeys>
-
-
-
-/**
- * **WithoutKeys**`<TObj, TKeys>`
- *
- * Removes the keys in `TKeys` from an object `TObj`. This is
- * functionally equivalent to the `Omit<T,U>` built-in but rather than
- * taking a union type it takes an array of keys.
- */
-export type WithoutKeys<
-  TObj extends Dictionary,
-  TKeys extends ObjectKey | readonly ObjectKey[]
-> = TKeys extends readonly ObjectKey[]
-? Process<
-    TObj,
-    TupleToUnion<TKeys>
-  >
-: ExpandDictionary<Process<
-  TObj,
-  TKeys extends readonly ObjectKey[]
-    ? TupleToUnion<TKeys>
-    : TKeys
->>;
-
-

package/src/types/dictionary/WithoutValue.ts

@@ -1,20 +0,0 @@
-import { AnyObject , Narrowable, ExpandRecursively, KeysWithoutValue } from "inferred-types/dist/types/index";
-
-/**
- * **WithoutValue**
- *
- * Reduces an object's type down to only those key/value pairs where the
- * value is **NOT** of type `W`.
- *
- * ```ts
- * const foo = { a: 1, b: "hi", c: () => "hello" }
- * // { a: 1, b: "hi" }
- * type W = WithValue<Function, typeof foo>
- * ```
- *
- * You manually exclude keys as well by setting the optional `E` generic.
- */
-export type WithoutValue<
-  TObj extends AnyObject,
-  TValue extends Narrowable,
-> = ExpandRecursively<Pick<TObj, KeysWithoutValue<TObj,TValue>>>;

package/src/types/dictionary/index.ts

@@ -1,64 +0,0 @@
-// #autoindex
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: 55881f7d
-
-// file exports
-export * from "./AddKeyValue";
-export * from "./CombinedKeys";
-export * from "./CreateKV";
-export * from "./DictChangeValue";
-export * from "./Get";
-export * from "./SimplifyObject";
-export * from "./Keys";
-export * from "./Values";
-export * from "./MaybeRef";
-export * from "./FromMaybeRef";
-export * from "./RequiredProps";
-export * from "./OptionalProps";
-export * from "./StringKeys";
-export * from "./NonStringKeys";
-export * from "./KeysWithValue";
-export * from "./KeysWithoutValue";
-export * from "./KeysEqualValue";
-export * from "./KeysNotEqualValue";
-export * from "./OptionalKeys";
-export * from "./RequiredKeys";
-export * from "./MapTo";
-export * from "./MakePropsMutable";
-export * from "./MutableProps";
-export * from "./NonNumericKeys";
-export * from "./NonStringKeys";
-export * from "./RequireProps";
-export * from "./ReadonlyKeys";
-export * from "./ReadonlyProps";
-export * from "./AddKeyValue";
-export * from "./WithKeys";
-export * from "./WithValue";
-export * from "./SharedKeys";
-export * from "./WithoutKeys";
-export * from "./WithoutValue";
-export * from "./WithNumericKeys";
-export * from "./RemoveIndexKeys";
-export * from "./WithStringKeys";
-export * from "./ValidKey";
-export * from "./UpsertKeyValue";
-export * from "./EnsureKeys";
-export * from "./KvFn";
-export * from "./CreateLookup";
-export * from "./MergeKVs"
-export * from "./TakeProp"
-export * from "./MakeKeysOptional";
-export * from "./MakeKeysRequired";
-export * from "./FilterProps";
-export * from "./RetainProps";
-export * from "./CamelKeys";
-export * from "./PascalKeys";
-export * from "./SnakeKeys";
-export * from "./KebabKeys";
-export * from "./DefineObject";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/types/errors/AsError.ts

@@ -1,110 +0,0 @@
-import {
-  AnyObject,
-  AsIndexOf,
-  Concat,
-  IfNever,
-  IsEqual,
-  ToString,
-  ErrorCondition,
-  EmptyObject,
-  TypeErrorInfo,
-  Throw,
-} from "inferred-types/dist/types/index";
-
-interface Error<
-  TName extends string = string,
-  TMsg extends string = string
-> {
-  name: TName;
-  message: TMsg;
-  stack?: string;
-}
-
-
-export type AsError__Meta = [
-  kind: string,
-  msg: string,
-  context: TypeErrorInfo
-] | [
-  kind: string,
-  msg: string
-];
-
-type Props<T extends AnyObject | undefined> = T extends AnyObject
-? T
-: EmptyObject;
-
-type IdFrom<T extends AnyObject> = AsIndexOf<T,"id",never>;
-type LibraryFrom<T extends AnyObject> = AsIndexOf<T,"library",never>;
-
-type Process<
-  T extends AsError__Meta
-> = IsEqual<T, [string, string]> extends true
-? ErrorCondition<T[0], T[1], never >
-: T extends [string, string, TypeErrorInfo]
-  ? Throw<
-    T[0],
-    T[1],
-    "AsError",
-    {
-      id: IdFrom<Props<T[2]>>;
-      library: LibraryFrom<Props<T[2]>>;
-    }
-  >
-  : ErrorCondition<
-      T[0],
-      T[1],
-      never
-    >;
-
-/**
- * **AsError**`<T>`
- *
- * Proxies through all `T`'s which are already extended from `ErrorCondition`
- * unchanged but converts all other types into
- *
- * If no known formula's are found to convert to an ErrorCondition then a
- * `ErrorCondition<"failed-to-wrap">` error will be produced:
- *
- * #### Known Formulas:
- * - `never` - converted to `ErrorCondition<"never-value">`
- * - `Error` - a JS `Error` type is converted to `ErrorCondition<"runtime-error"> and it's properties are available in the error conditions hash storage as `error`
- * - `ErrorCondition` - any pre-existing `ErrorCondition` will just be proxied through
- * - `[kind, msg, [context]]` - it will:
- *    - the first two parameters will map directly into the error condition properties of the same name
- *    - the optional `context` object is a dictionary of key value pairs; where:
- *      - when the keys match one of the root properties of `ErrorCondition` it will be
- *        mapped onto that property (assuming that the _type_ is appropriate)
- *      - otherwise it will be added to the `context` dictionary appearing as a prop on
- *        `ErrorCondition`.
- *
- * **Related:** `Throw`
- */
-export type AsError<
-  TType,
-> = TType extends ErrorCondition ? TType : IfNever<
-  TType,
-  ErrorCondition<
-    "never-value",
-    "a 'never' type was encountered which is not allowed in this context!"
-  >,
-  TType extends Error<string>
-  ? Throw<
-      "runtime-error",
-      `the JS runtime's Error class was found with the message: '${TType["message"]}'`,
-      "AsError",
-      { library: "inferred-types" }
-    >
-  : TType extends AsError__Meta
-      ? Process<TType>
-      : Throw<
-          "failed-to-wrap",
-          Concat<[
-            "An unexpected value -- ",
-            ToString<TType>,
-            " -- was passed into the AsError<T> type utility!"
-          ]>,
-          "AsError",
-          { library: "inferred-types" }
-        >
->;