inferred-types 0.19.0 → 0.22.0

package/src/types/dictionary/DictPrependWithFn.ts

@@ -0,0 +1,23 @@
+import { SimplifyObject } from "../SimplifyObject";
+
+/**
+ * **DictPrependWithFn**
+ *
+ * Given a strongly typed object `<T>`, this utility will inject a function call with
+ * arguments `<A>` and then return what had subsequently been the value of the property.
+ * 
+ * Should you only want to apply this treatment to _some_ of the properties you can
+ * pass in a value `<E>` which will ensure that only properties which _extend_ `E` will be
+ * modified.
+ */
+export type DictPrependWithFn<
+  T extends Record<string, any>,
+  A extends any[],
+  E extends any = any
+> = SimplifyObject<
+  {
+    [K in keyof T]: T[K] extends E 
+      ? Record<K, (...args: A) => T[K]>
+      : Record<K, T[K]>;
+  }[keyof T]
+>;

package/src/types/dictionary/DictReturnValues.ts

@@ -0,0 +1,27 @@
+import { SimplifyObject } from "../SimplifyObject";
+
+/**
+ * **DictReturnValues**
+ *
+ * A type utility which receives an object `<T>` and then modifies
+ * the return type of any properties which are a function to have this
+ * new **ReturnType** `<R>`. Optionally you can specify a particular return type which
+ * you are targeting and then
+ */
+export type DictReturnValues<
+  /** the object which we expect to have props with function values */
+  T extends Record<string, any>,
+  /** the return type that functions should be modified to have */
+  R extends any,
+  /** optionally this utility can target only functions with a certain existing return value */
+  O extends (...args: any[]) => any = (...args: any[]) => any
+> = SimplifyObject<
+  {
+    [K in keyof T]: T[K] extends O
+      ? // it's a function (or at least the scoped down type of function we're looking for)
+        T[K] extends (...args: infer A) => any
+        ? Record<K, (...args: A) => R>
+        : Record<K, T[K]>
+      : Record<K, T[K]>;
+  }[keyof T]
+>;

package/src/types/dictionary/RequireProps.ts

@@ -0,0 +1,15 @@
+import { ExpandRecursively } from "../ExpandRecursively";
+
+/**
+ * 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 {}, R extends keyof T> = ExpandRecursively<
+  Required<Pick<T, R>> & T
+>;

package/src/types/dictionary/index.ts

@@ -1,11 +1,16 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 6th Jun, 2022, 03:36 AM ( GMT-7 )
-// hash-code: 1f3a5076
+// index last changed at: 7th Jul, 2022, 02:28 PM ( GMT-7 )
+// hash-code: 6e90bc78
 
 // file exports
+export * from "./DictPartialApplication";
+export * from "./DictPrependWithFn";
+export * from "./DictReturnValues";
 export * from "./Get";
-export * from "./NotEmptyObject";
+export * from "./RequireProps";
+export * from "./SameKeys";
+export * from "./props";
 
 // #endregion
 

package/src/types/{props.ts → dictionary/props.ts}

@@ -18,7 +18,7 @@ export type OptionalKeys<T extends object> = {
  * The _keys_ on a given object `T` which have a literal value of `W`.
  *
  * Optionally, you may provide a generic `E` to exclude certain keys in
- * resultset.
+ * result set.
  * ```ts
  * // "foo"
  * type Str = KeysWithValue<{ foo: "hi"; bar: 5 }>;

package/src/types/functions/FinalReturn.ts

@@ -0,0 +1,12 @@
+/**
+ * A type utility which looks at a chain for functions and reduces the type
+ * to the final `ReturnType` of the chain.
+ * 
+ * ```ts
+ * // number
+ * type T = FinalReturn<() => (foo: string) => (bar: string) => () => number>;
+ * ```
+ */
+export type FinalReturn<T extends any> = T extends (...args: any[]) => any
+  ? FinalReturn<ReturnType<T>>
+  : T;

package/{on-hold/types → src/types/functions}/index.ts

@@ -1,9 +1,10 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: da242834
-
+// index last changed at: 6th Jun, 2022, 10:19 AM ( GMT-7 )
+// hash-code: 7fa9afdf
 
+// file exports
+export * from "./FinalReturn";
 
 // #endregion
 

package/src/types/index.ts

@@ -1,7 +1,7 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: 7e6e29a0
+// index last changed at: 7th Jul, 2022, 01:15 PM ( GMT-7 )
+// hash-code: f976e182
 
 // file exports
 export * from "./Api";
@@ -22,12 +22,12 @@ export * from "./Not";
 export * from "./Numeric";
 export * from "./Opaque";
 export * from "./Retain";
+export * from "./SimplifyObject";
 export * from "./Transformer";
 export * from "./TypeGuard";
 export * from "./Where";
 export * from "./append-types";
 export * from "./maybe";
-export * from "./props";
 export * from "./ruleset-types";
 export * from "./runtime";
 export * from "./type-testing";
@@ -35,6 +35,7 @@ export * from "./type-testing";
 export * from "./alphabetic/index";
 export * from "./dictionary/index";
 export * from "./fluent/index";
+export * from "./functions/index";
 export * from "./kv/index";
 export * from "./lists/index";
 export * from "./string-literals/index";

package/src/types/ruleset-types.ts

@@ -1,6 +1,6 @@
-import type { TypeCondition } from "~/utility/runtime/ifTypeOf";
-import { OptionalKeys } from "./props";
-import { SameKeys } from "./type-conversion/SameKeys";
+import { TypeCondition } from "src/utility/runtime";
+import { OptionalKeys } from "./dictionary/props";
+import { SameKeys } from "./dictionary/SameKeys";
 
 /**
  * **RuleDefinition**

package/src/types/runtime.ts

@@ -1,7 +1,7 @@
-import { TypeGuard } from "~/types";
-
 // runtime types relate to the types coming out of the runtime utilities
 
+import { TypeGuard } from "./TypeGuard";
+
 export type RuntimeType<T> = {
   __kind: "type";
 
@@ -14,21 +14,21 @@ export type RuntimeProp<P extends Readonly<PropertyKey>, T extends RuntimeType<a
   key: Readonly<P>;
   valueType: Readonly<T["type"]>;
   /**
- * Provides the _type_ to the type system when used with `typeof`.
- * 
- * ```ts
- * const t = number();
- * // number
- * type T = typeof t.type;
- * ```
- * 
- * **Note:** _the runtime system will get a string equivalent name:_
- * ```ts
- * const t = number();
- * // "number"
- * console.log(t.type);
- * ```
- */
+   * Provides the _type_ to the type system when used with `typeof`.
+   *
+   * ```ts
+   * const t = number();
+   * // number
+   * type T = typeof t.type;
+   * ```
+   *
+   * **Note:** _the runtime system will get a string equivalent name:_
+   * ```ts
+   * const t = number();
+   * // "number"
+   * console.log(t.type);
+   * ```
+   */
   type: Record<P, T["type"]>;
   is: TypeGuard<Record<P, T["type"]>>;
 };
@@ -36,4 +36,4 @@ export type RuntimeProp<P extends Readonly<PropertyKey>, T extends RuntimeType<a
 export type TypeOptions<T extends Partial<object> = {}> = {
   /** each type has a default type guard but you can override if you need to be more specific */
   typeGuard?: TypeGuard<T>;
-} & T;
+} & T;

package/src/types/string-literals/LeftWhitespace.ts

@@ -1,4 +1,5 @@
-import type { Replace, TrimLeft } from "~/types";
+import { Replace } from "./Replace";
+import { TrimLeft } from "./TrimLeft";
 
 /**
  * Provides the _left_ whitespace of a string
@@ -7,4 +8,6 @@ import type { Replace, TrimLeft } from "~/types";
  * type T = LeftWhitespace<"\n\t foobar">;
  * ```
  */
-export type LeftWhitespace<S extends string> = string extends S ? string : Replace<S, TrimLeft<S>, "">;
+export type LeftWhitespace<S extends string> = string extends S
+  ? string
+  : Replace<S, TrimLeft<S>, "">;

package/src/types/string-literals/RightWhitespace.ts

@@ -1,4 +1,5 @@
-import type { Replace, TrimRight } from "~/types";
+import { Replace } from "./Replace";
+import { TrimRight } from "./TrimRight";
 
 /**
  * Provides the _left_ whitespace of a string
@@ -7,4 +8,6 @@ import type { Replace, TrimRight } from "~/types";
  * type T = LeftWhitespace<"\n\t foobar">;
  * ```
  */
-export type RightWhitespace<S extends string> = string extends S ? string : Replace<S, TrimRight<S>, "">;
+export type RightWhitespace<S extends string> = string extends S
+  ? string
+  : Replace<S, TrimRight<S>, "">;

package/src/types/tuples/FirstKey.ts

@@ -1,10 +1,10 @@
-import type { Keys, UnionToTuple } from "~/types";
+import { Keys } from "../Keys";
+import { UnionToTuple } from "../type-conversion/UnionToTuple";
 
 /**
  * Returns the _first_ key in an object.
- * 
+ *
  * **Note:** key order is not guarenteed so typically this is used
  * for a key/value pair where only one key is expected
  */
 export type FirstKey<T extends object> = UnionToTuple<Keys<T>>[0];
-

package/src/types/tuples/FromDictArray.ts

@@ -1,5 +1,5 @@
-import { ExpandRecursively, UnionToIntersection } from "~/types";
-
+import { ExpandRecursively } from "../ExpandRecursively";
+import { UnionToIntersection } from "../type-conversion";
 
 /**
  * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
@@ -9,5 +9,6 @@ import { ExpandRecursively, UnionToIntersection } from "~/types";
  * type Dict = FromDictArray<[["foo", { foo: 1 }], ["bar", { bar: "hi" }]]>;
  * ```
  */
-export type FromDictArray<T extends [string, Record<string, unknown>][]> =
-  ExpandRecursively<UnionToIntersection<T[number][1]>>;
+export type FromDictArray<T extends [string, Record<string, unknown>][]> = ExpandRecursively<
+  UnionToIntersection<T[number][1]>
+>;

package/src/types/type-conversion/index.ts

@@ -1,16 +1,13 @@
 // #autoindex
 
 // #region autoindexed files
-// index last changed at: 6th Jun, 2022, 03:36 AM ( GMT-7 )
-// hash-code: ac142b94
+// index last changed at: 6th Jun, 2022, 10:18 AM ( GMT-7 )
+// hash-code: b346a5f3
 
 // file exports
-export * from "./SameKeys";
 export * from "./TupleToUnion";
 export * from "./UnionToIntersection";
 export * from "./UnionToTuple";
-export * from "./UnwrapValue";
-export * from "./WrapValue";
 
 // #endregion
 

package/src/utility/api/api.ts

@@ -1,9 +1,10 @@
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 
-export const api = <N extends Narrowable, TPrivate extends Readonly<Record<any, N>>>(priv: TPrivate) => <TPublic extends object>(pub: TPublic) => {
-  const surface = () => pub as TPublic;
-  surface.prototype.priv = () => priv as TPrivate;
-
-  return surface;
-};
+export const api =
+  <N extends Narrowable, TPrivate extends Readonly<Record<any, N>>>(priv: TPrivate) =>
+  <TPublic extends object>(pub: TPublic) => {
+    const surface = () => pub as TPublic;
+    surface.prototype.priv = () => priv as TPrivate;
 
+    return surface;
+  };

package/src/utility/createFnWithProps.ts

@@ -1,3 +1,4 @@
+import { Narrowable } from "../types/Narrowable";
 import { keys } from "./keys";
 
 export function createFnWithProps<F extends Function, P extends {}>(fn: F, props: P) {
@@ -9,4 +10,28 @@ export function createFnWithProps<F extends Function, P extends {}>(fn: F, props
     }
     return combined;
   })() as unknown as F & P;
-}
+}
+
+/**
+ * Adds a dictionary of key/value pairs to a function.
+ */
+export function fnWithProps<A extends any[], R extends any, P extends {}>(fn: ((...args: A) => R), props: P) {
+  // eslint-disable-next-line prefer-const
+  let combined: any = fn;
+  for (const prop of keys(props)) {
+    combined[prop] = props[prop];
+  }
+  return combined as ((...args: A) => R) & P;
+}
+
+/**
+ * Adds read-only (and narrowly typed) key/value pairs to a function
+ */
+export function readonlyFnWithProps<A extends any[], R extends any, N extends Narrowable, P extends Record<keyof P, N>>(fn: ((...args: A) => R), props: P) {
+  // eslint-disable-next-line prefer-const
+  let combined: any = fn;
+  for (const prop of keys(props)) {
+    combined[prop] = props[prop];
+  }
+  return combined as ((...args: A) => R) & Readonly<P>;
+}

package/src/utility/dictionary/dictionaryTransform.ts

@@ -1,6 +1,8 @@
 /* eslint-disable no-use-before-define */
-import { keys } from "~/utility/keys";
-import { SameKeys, Transformer } from "~/types";
+
+import { SameKeys } from "src/types/dictionary";
+import { Transformer } from "src/types/Transformer";
+import { keys } from "../keys";
 
 /**
  * Takes a dictionary of type `I` and converts it to a dictionary of type `O` where
@@ -13,9 +15,8 @@ export function dictionaryTransform<I extends object, O extends SameKeys<I>>(
   input: I,
   transform: Transformer<I, O>
 ) {
-
   return keys(input).reduce((acc, i) => {
     const key = i as string & keyof I;
-    return {...acc, [key]: transform(input, key)};
+    return { ...acc, [key]: transform(input, key) };
   }, {} as O);
 }

package/src/utility/dictionary/entries.ts

@@ -1,10 +1,11 @@
-import { KeyValue, Narrowable } from "~/types";
+import { KeyValue } from "src/types/kv";
+import { Narrowable } from "src/types/Narrowable";
 import { keys } from "../keys";
 
 /**
  * **entries**
  *
- * Provides an _interable_ over the passed in dictionary object where each iteration 
+ * Provides an _iterable_ over the passed in dictionary object where each iteration
  * provides a tuple of `[ key, value ]` which preserve type literals.
  *
  * For example:
@@ -14,8 +15,11 @@ import { keys } from "../keys";
  * for (const [k, v] of entries(obj)) { ... }
  * ```
  */
-export function entries<N extends Narrowable, T extends Record<string, N>, I extends KeyValue<T, keyof T>>(obj: T) {
-
+export function entries<
+  N extends Narrowable,
+  T extends Record<string, N>,
+  I extends KeyValue<T, keyof T>
+>(obj: T) {
   const iterable = {
     *[Symbol.iterator]() {
       for (const k of keys(obj)) {
@@ -26,4 +30,4 @@ export function entries<N extends Narrowable, T extends Record<string, N>, I ext
   };
 
   return iterable;
-}
+}

package/src/utility/dictionary/index.ts

@@ -1,7 +1,7 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: c3587066
+// index last changed at: 7th Jul, 2022, 01:47 PM ( GMT-7 )
+// hash-code: dd2bf50a
 
 // file exports
 export * from "./arrayToKeyLookup";
@@ -9,7 +9,6 @@ export * from "./dictionaryTransform";
 export * from "./entries";
 export * from "./mapValues";
 export * from "./strArrayToDict";
-export * from "./valuesOfProp";
 // directory exports
 export * from "./kv/index";
 

package/src/utility/dictionary/kv/dictToKv.ts

@@ -1,6 +1,8 @@
-import { Mutable, Narrowable, UnionToTuple } from "~/types";
-import { KvFrom } from "~/types/kv/KvFrom";
-import { keys } from "~/utility/keys";
+import { KvFrom } from "src/types/kv";
+import { Mutable } from "src/types/Mutable";
+import { Narrowable } from "src/types/Narrowable";
+import { UnionToTuple } from "src/types/type-conversion";
+import { keys } from "src/utility/keys";
 
 /**
  * Converts a dictionary object into an array of dictionaries with `key` and `value` properties

package/src/utility/dictionary/kv/filterDictArray.ts

@@ -1,5 +1,5 @@
-import type { DictArray, DictArrayFilterCallback } from "~/types";
-import { Configurator, IConfigurator } from "~/utility/state";
+import { DictArray, DictArrayFilterCallback } from "src/types/tuples";
+import { Configurator, IConfigurator } from "src/utility/state";
 
 export interface Array<T> {
   filter<U extends T>(pred: (a: T) => a is U): U[];
@@ -11,12 +11,11 @@ export interface Array<T> {
  */
 export function filterDictArray<
   T extends object,
-  C extends DictArrayFilterCallback<keyof T, T, true | false>,
-  >(dictArr: DictArray<T>, cb: C) {
-
+  C extends DictArrayFilterCallback<keyof T, T, true | false>
+>(dictArr: DictArray<T>, cb: C) {
   const state: IConfigurator = Configurator();
 
-  const updated = dictArr.filter(i => {
+  const updated = dictArr.filter((i) => {
     const [k, v] = i;
     const keep = cb(k, v);
     if (!keep) {
@@ -30,4 +29,3 @@ export function filterDictArray<
   type ExcludedKeys = "";
   return updated as unknown as DictArray<Omit<T, ExcludedKeys>>;
 }
-

package/src/utility/dictionary/kv/kv.ts

@@ -1,13 +1,18 @@
-import { ExpandRecursively, Narrowable } from "~/types";
+import { ExpandRecursively } from "src/types/ExpandRecursively";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Build a key-value pair where both _key_ and _value_ are inferred. This
  * includes ensuring that the _key_ is a type literal not just a "string".
  *
  * > note: the value will be inferred but if you need to constrain it
- * > to a narrower type then both inferrences will break and you should
+ * > to a narrower type then both inferences will break and you should
  * > instead use `KV2` to get this capability.
  */
-export function kv<K extends string, N extends Narrowable, V extends Record<any, N> | boolean | number | string | null | undefined>(key: K, value: V) {
+export function kv<
+  K extends string,
+  N extends Narrowable,
+  V extends Record<any, N> | boolean | number | string | null | undefined
+>(key: K, value: V) {
   return { [key]: value } as ExpandRecursively<Record<K, V>>;
 }

package/src/utility/dictionary/kv/kvToDict.ts

@@ -1,5 +1,6 @@
-import { Mutable, Narrowable } from "~/types";
-import { DictFromKv } from "~/types/kv";
+import { DictFromKv } from "src/types/kv";
+import { Mutable } from "src/types/Mutable";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Converts an array of dictionaries with `key` and `value` properties to a singular dictionary.

package/src/utility/dictionary/mapValues.ts

@@ -1,20 +1,23 @@
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 import { entries } from "./entries";
 
 /**
  * **mapValues**
- * 
+ *
  * Maps over a dictionary, preserving the keys but allowing the values to be mutated.
- * 
+ *
  * ```ts
  * const colors = { red: 4, blue: 2, green: 3 };
  * // { red: 8, blue: 4, green: 6 }
  * const twoX = mapValues(colors, v => v * 2);
  * ```
  */
-export function mapValues<N extends Narrowable, T extends Record<string, N>, V>(obj: T, valueMapper: (k: T[keyof T]) => V) {
+export function mapValues<N extends Narrowable, T extends Record<string, N>, V>(
+  obj: T,
+  valueMapper: (k: T[keyof T]) => V
+) {
   return Object.fromEntries(
     // TODO: fix the type error with v and valueMapper
     [...entries(obj)].map(([k, v]) => [k, valueMapper(v as any)])
   ) as { [K in keyof T]: V };
-}
+}

package/src/utility/dictionary/strArrayToDict.ts

@@ -1,5 +1,4 @@
-import { ExpandRecursively } from "~/types/ExpandRecursively";
-
+import { ExpandRecursively } from "src/types/ExpandRecursively";
 
 /**
  * converts an array of strings `["a", "b", "c"]` into a more type friendly

package/src/utility/keys.ts

@@ -1,12 +1,16 @@
-import { Keys, Length } from "~/types";
+import { Keys } from "src/types/Keys";
+import { Length } from "src/types/Length";
 
 /**
  * Provides the _keys_ of an object with the `keyof T` made explicit.
  */
 export function keys<T extends {}, W extends readonly string[]>(obj: T, ...without: W) {
-  const v = without.length > 0
-    ? Object.keys(obj).filter(k => !without.includes(k)) as unknown as Array<Exclude<keyof T, Keys<W>>>
-    : Object.keys(obj) as unknown as Array<keyof T>;
+  const v =
+    without.length > 0
+      ? (Object.keys(obj).filter((k) => !without.includes(k)) as unknown as Array<
+          Exclude<keyof T, Keys<W>>
+        >)
+      : (Object.keys(obj) as unknown as Array<keyof T>);
 
   return v as unknown as Length<W> extends 0 ? Array<keyof T> : Array<Exclude<keyof T, Keys<W>>>;
 }

package/src/utility/lists/groupBy.ts

@@ -1,5 +1,4 @@
-import { Narrowable } from "~/types";
-// import { UniqueForProp } from "~/types/lists/UniqueForProp";
+import { Narrowable } from "src/types/Narrowable";
 
 /**
  * Groups an array of data based on the value of a property
@@ -11,12 +10,6 @@ import { Narrowable } from "~/types";
  *
  * @ignore not implemented
  */
-export function groupBy<T extends Record<string, Narrowable>, K extends keyof T & string>(
-  _data: Readonly<T[]>
-) {
+export function groupBy<T extends Record<string, Narrowable>>(_data: Readonly<T[]>) {
   throw new Error("not implemented");
-  return (_groupBy: K) => {
-    // type _GroupedBy = UniqueForProp<typeof data, K>;
-    // const _output = {} as Record<GroupedBy, Narrowable>;
-  };
 }