inferred-types 0.20.0 → 0.22.5

package/src/utility/runtime/condition.ts

@@ -1,4 +1,4 @@
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 
 export type Condition<TInput extends Narrowable, TResult extends boolean> = (
   input: TInput

package/src/utility/runtime/conditions/index.ts

@@ -1,15 +1,14 @@
 // #autoindex
 
-// #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: a3788912
+// #region auto-indexed files
+// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
+// hash-code: 4324574d
 
 // file exports
 export * from "./isArray";
 export * from "./isBoolean";
 export * from "./isFalse";
 export * from "./isFunction";
-export * from "./isLiteral";
 export * from "./isNull";
 export * from "./isNumber";
 export * from "./isObject";
@@ -18,30 +17,7 @@ export * from "./isSymbol";
 export * from "./isTrue";
 export * from "./isUndefined";
 
-// #endregion
+// #endregion auto-indexed files
 
-// This file was created by running: "dd autoindex"; it assumes you have
-// the 'do-devops' pkg (that's "dd" on npm) installed as a dev dep.
-//
-// By default it assumes that exports are named exports but this can be changed by
-// adding a modifier to the '// #autoindex' syntax:
-//
-//    - autoindex:named     same as default, exports "named symbols"
-//    - autoindex:default   assumes each file is exporting a default export and
-//                          converts the default export to the name of the file
-//    - autoindex:offset    assumes files export "named symbols" but that each
-//                          file's symbols should be offset by the file's name
-//
-// You may also exclude certain files or directories by adding it to the
-// autoindex command. As an example:
-//
-//    - autoindex:named, exclude: foo,bar,baz
-//
-// Inversely, if you state a file to be an "orphan" then autoindex files
-// below this file will not reference this autoindex file:
-//
-//    - autoindex:named, orphan
-// 
-// All content outside the "// #region" section in this file will be
-// preserved in situations where you need to do something paricularly awesome.
-// Keep on being awesome.
+// see https://github.com/inocan-group/do-devops/docs/autoindex.md
+// for more info

package/src/utility/runtime/conditions/isFalse.ts

@@ -1,5 +1,5 @@
-import { Narrowable } from "~/types";
-import { IsBoolean } from "~/utility";
+import { Narrowable } from "src/types/Narrowable";
+import { IsBoolean } from "./isBoolean";
 
 export type IsFalse<T extends Narrowable> = IsBoolean<T> extends true
   ? // is a boolean

package/src/utility/runtime/conditions/isFunction.ts

@@ -1,4 +1,4 @@
-import { FunctionType } from "~/types";
+import { FunctionType } from "src/types/FunctionType";
 
 export type IsFunction<T> = T extends FunctionType ? true : false;
 
@@ -11,7 +11,7 @@ export type IsFunction<T> = T extends FunctionType ? true : false;
  * ```
  *
  * Note: the runtime `typeof [variable]` will correctly say "function" when a function is
- * encounted but if that function also has object types defined then the type will be a big
+ * encountered but if that function also has object types defined then the type will be a big
  * and ugly union type. This function will give you a proper boolean value in both cases.
  */
 export function isFunction<T extends unknown>(input: T): IsFunction<T> {

package/src/utility/runtime/conditions/isObject.ts

@@ -1,4 +1,7 @@
-import { FunctionType, Mutable, Narrowable, Not } from "~/types";
+import { FunctionType } from "src/types/FunctionType";
+import { Mutable } from "src/types/Mutable";
+import { Narrowable } from "src/types/Narrowable";
+import { Not } from "src/types/Not";
 
 export type IsObject<T> = Mutable<T> extends Record<string, any>
   ? // an object of some type

package/src/utility/runtime/conditions/isTrue.ts

@@ -1,4 +1,4 @@
-import { Narrowable } from "~/types";
+import { Narrowable } from "src/types/Narrowable";
 import type { IsBoolean } from "./isBoolean";
 
 /**

package/src/utility/runtime/ifTypeOf.ts

@@ -1,4 +1,4 @@
-import { Narrowable } from "~/types/Narrowable";
+import { Narrowable } from "src/types/Narrowable";
 import { keys } from "../keys";
 
 function runtimeExtendsCheck<TValue extends any, TBase extends any>(
@@ -29,10 +29,11 @@ function runtimeExtendsCheck<TValue extends any, TBase extends any>(
     case "object":
       if (val === null && base === null) {
         return true as TValue extends TBase ? true : false;
+      } else {
+        return keys(base as object).every((i) =>
+          runtimeExtendsCheck((val as TValue)[i], base[i], narrow)
+        ) as TValue extends TBase ? true : false;
       }
-      return keys(base as object).every((i) =>
-        runtimeExtendsCheck(val[i], base[i], narrow)
-      ) as TValue extends TBase ? true : false;
   }
 }
 

package/src/utility/runtime/index.ts

@@ -1,7 +1,7 @@
 // #autoindex
-// #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: 91796b6
+// #region auto-indexed files
+// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
+// hash-code: 687852c8
 
 // file exports
 export * from "./condition";
@@ -11,30 +11,7 @@ export * from "./withValue";
 // directory exports
 export * from "./conditions/index";
 
-// #endregion
+// #endregion auto-indexed files
 
-// This file was created by running: "dd autoindex"; it assumes you have
-// the 'do-devops' pkg (that's "dd" on npm) installed as a dev dep.
-//
-// By default it assumes that exports are named exports but this can be changed by
-// adding a modifier to the '// #autoindex' syntax:
-//
-//    - autoindex:named     same as default, exports "named symbols"
-//    - autoindex:default   assumes each file is exporting a default export and
-//                          converts the default export to the name of the file
-//    - autoindex:offset    assumes files export "named symbols" but that each
-//                          file's symbols should be offset by the file's name
-//
-// You may also exclude certain files or directories by adding it to the
-// autoindex command. As an example:
-//
-//    - autoindex:named, exclude: foo,bar,baz
-//
-// Inversely, if you state a file to be an "orphan" then autoindex files
-// below this file will not reference this autoindex file:
-//
-//    - autoindex:named, orphan
-// 
-// All content outside the "// #region" section in this file will be
-// preserved in situations where you need to do something paricularly awesome.
-// Keep on being awesome.
+// see https://github.com/inocan-group/do-devops/docs/autoindex.md
+// for more info

package/src/utility/runtime/type.ts

@@ -1,4 +1,6 @@
-import { FunctionType, Narrowable, TypeGuard } from "~/types";
+import { FunctionType } from "src/types/FunctionType";
+import { Narrowable } from "src/types/Narrowable";
+import { TypeGuard } from "src/types/TypeGuard";
 import {
   isString,
   isBoolean,

package/src/utility/runtime/withValue.ts

@@ -1,8 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 
-import { ExpandRecursively, Narrowable, WithValue } from "~/types";
-import { entries } from "~/utility/dictionary";
-import { type, TypeDefinition } from "~/utility/runtime";
+import { WithValue } from "src/types/dictionary";
+import { ExpandRecursively } from "src/types/ExpandRecursively";
+import { Narrowable } from "src/types/Narrowable";
+import { entries } from "../dictionary/entries";
+import { type, TypeDefinition } from "./type";
 
 /**
  * **withValue**

package/src/utility/state/Configurator.ts

@@ -1,4 +1,5 @@
-/* eslint-disable unicorn/consistent-function-scoping */
+import { ExpandRecursively } from "src/types/ExpandRecursively";
+
 type Omit<T, K extends keyof T> = Pick<T, Exclude<keyof T, K>>;
 function omit<T extends {}, K extends Array<keyof T>>(obj: T, ...removals: K) {
   const untyped = removals as Array<unknown>;
@@ -8,7 +9,6 @@ function omit<T extends {}, K extends Array<keyof T>>(obj: T, ...removals: K) {
   >;
 }
 
-import { ExpandRecursively } from "~/types";
 export interface IConfigurator<C = {}> {
   set<V, K extends string, KV = { [U in K]: V }>(
     key: K,

package/src/utility/state/FluentConfigurator.ts

@@ -1,4 +1,4 @@
-import type { ExpandRecursively } from "~/types";
+import { ExpandRecursively } from "src/types/ExpandRecursively";
 
 export interface IFluentConfigurator<C> {
   /**
@@ -28,7 +28,7 @@ export function FluentConfigurator<I>(initial: I = {} as I) {
   const api = <C>(current: C): IFluentConfigurator<C> => {
     return {
       set<V, K extends string, KV = { [U in K]: V }>(key: K, value: V) {
-        const keyValue = ({ [key]: value as V } as unknown) as KV;
+        const keyValue = { [key]: value as V } as unknown as KV;
         const updated = { ...keyValue, ...current };
 
         return api<C & KV>(updated);

package/src/utility/state/index.ts

@@ -1,37 +1,13 @@
 // #autoindex
-// #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: fd5dfde8
+// #region auto-indexed files
+// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
+// hash-code: 397c607b
 
 // file exports
 export * from "./Configurator";
 export * from "./FluentConfigurator";
-export * from "./KeyStorage";
 
-// #endregion
+// #endregion auto-indexed files
 
-// This file was created by running: "dd autoindex"; it assumes you have
-// the 'do-devops' pkg (that's "dd" on npm) installed as a dev dep.
-//
-// By default it assumes that exports are named exports but this can be changed by
-// adding a modifier to the '// #autoindex' syntax:
-//
-//    - autoindex:named     same as default, exports "named symbols"
-//    - autoindex:default   assumes each file is exporting a default export and
-//                          converts the default export to the name of the file
-//    - autoindex:offset    assumes files export "named symbols" but that each
-//                          file's symbols should be offset by the file's name
-//
-// You may also exclude certain files or directories by adding it to the
-// autoindex command. As an example:
-//
-//    - autoindex:named, exclude: foo,bar,baz
-//
-// Inversely, if you state a file to be an "orphan" then autoindex files
-// below this file will not reference this autoindex file:
-//
-//    - autoindex:named, orphan
-// 
-// All content outside the "// #region" section in this file will be
-// preserved in situations where you need to do something paricularly awesome.
-// Keep on being awesome.
+// see https://github.com/inocan-group/do-devops/docs/autoindex.md
+// for more info

package/tests/CamelCase-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it, expect } from "vitest";
+
 import { CamelCase } from "../src/types";
 import { Expect, Equal } from "@type-challenges/utils";
 

package/tests/ExplicitFunction-spec.ts

@@ -1,5 +1,6 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import { ExplicitFunction } from "~/utility";
+import { describe, it, expect } from "vitest";
+
+import { ExplicitFunction } from "../src/utility";
 import type { Expect, Equal } from "@type-challenges/utils";
 
 describe("ExplicitFunction()", () => {

package/tests/IncludeAndRetain-spec.ts

@@ -1,4 +1,6 @@
-import { Include, Retain } from "~/types";
+import { describe, it, expect } from "vitest";
+
+import { Include, Retain } from "../src/types";
 import { Equal, Expect } from "@type-challenges/utils";
 
 // INCLUDE
@@ -8,10 +10,7 @@ describe("Include<T, U> utility", () => {
     type Foo = Include<typeof str, string>;
     type NotFoo = Include<typeof str, number>;
 
-    type cases = [
-      Expect<Equal<Foo, "foo">>,
-      Expect<Equal<NotFoo, never>>
-    ];
+    type cases = [Expect<Equal<Foo, "foo">>, Expect<Equal<NotFoo, never>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -33,12 +32,11 @@ describe("Include<T, U> utility", () => {
       Expect<Equal<RelatedFoo, "foo">>,
       // this behavior is adjusted if you include
       // the optional `L` generic as a true value
-      Expect<Equal<NotLiteralFoo, never>>,
+      Expect<Equal<NotLiteralFoo, never>>
     ];
     const c: cases = [true, true, true, true];
     expect(c).toBe(c);
   });
-
 });
 
 // RETAIN
@@ -52,7 +50,7 @@ describe("Retain<T, U> utility", () => {
     type cases = [
       Expect<Equal<FooBar, { foo: number; bar: number }>>,
       Expect<Equal<Baz, { baz: string }>>,
-      Expect<Equal<FooBaz, { foo: number; baz: string }>>,
+      Expect<Equal<FooBaz, { foo: number; baz: string }>>
     ];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
@@ -62,11 +60,8 @@ describe("Retain<T, U> utility", () => {
     type Obj = { foo: 1; bar?: number; baz: "hi" };
     type FooBar = Retain<Obj, "foo" | "bar">;
 
-    type cases = [
-      Expect<Equal<FooBar, { foo: 1; bar?: number }>>,
-    ];
+    type cases = [Expect<Equal<FooBar, { foo: 1; bar?: number }>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
 });

package/tests/Includes-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it, expect } from "vitest";
+
 import type { Includes } from "../src/types";
 import type { ExpectTrue, ExpectFalse } from "@type-challenges/utils";
 

package/tests/KebabCase-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it } from "vitest";
+
 import type { KebabCase } from "../src/types";
 import type { Expect, Equal } from "@type-challenges/utils";
 

package/tests/MutationIdentity-spec.ts

@@ -1,4 +1,5 @@
-/* eslint-disable unicorn/consistent-function-scoping */
+import { describe, it, expect } from "vitest";
+
 import { MutationIdentity } from "../src/Mutation";
 import type { Expect, Equal, ExpectExtends } from "@type-challenges/utils";
 

package/tests/PascalCase-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it, expect } from "vitest";
+
 import type { PascalCase } from "../src/types";
 import type { Expect, Equal } from "@type-challenges/utils";
 

package/tests/Pluralize-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it } from "vitest";
+
 import type { Pluralize } from "../src/types";
 import type { Expect, Equal } from "@type-challenges/utils";
 

package/tests/SnakeCase-spec.ts

@@ -1,3 +1,5 @@
+import { describe, it } from "vitest";
+
 import { SnakeCase } from "../src/types";
 import { Expect, Equal } from "@type-challenges/utils";
 

package/tests/Where.spec.ts

@@ -1,8 +1,9 @@
+import { describe, it, expect } from "vitest";
+
 import { Expect, Equal } from "@type-challenges/utils";
 import { Where, WhereNot } from "../src/types/Where";
 
 describe("Where<T,U> and WhereNot<T,U> type utility", () => {
-
   it("readonly string array works correctly", () => {
     const arr = ["foo", "bar", "baz"] as const;
     type A = typeof arr;
@@ -11,29 +12,27 @@ describe("Where<T,U> and WhereNot<T,U> type utility", () => {
 
     type cases = [
       //
-      Expect<Equal<B, "bar"| "baz">>,
+      Expect<Equal<B, "bar" | "baz">>,
       Expect<Equal<F, "foo">>
     ];
-    
-    const c: cases = [ true, true ];
+
+    const c: cases = [true, true];
     expect(c).toBe(c);
   });
 
   it("object with literal keys works", () => {
-    const arr = {foo: true, bar: true, baz: true} as const;
+    const arr = { foo: true, bar: true, baz: true } as const;
     type A = typeof arr;
     type B = Where<A, `ba${string}`>;
     type F = WhereNot<A, `ba${string}`>;
 
     type cases = [
       //
-      Expect<Equal<B, "bar"| "baz">>,
+      Expect<Equal<B, "bar" | "baz">>,
       Expect<Equal<F, "foo">>
     ];
-    
-    const c: cases = [ true, true ];
+
+    const c: cases = [true, true];
     expect(c).toBe(c);
   });
-
-
 });

package/tests/arrayToKeyLookup-spec.ts

@@ -1,5 +1,7 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { arrayToKeyLookup } from "~/utility";
+import { arrayToKeyLookup } from "../src/utility";
 
 describe("arrayToKeyLookup()", () => {
   it("simple string array is converted", () => {
@@ -8,10 +10,8 @@ describe("arrayToKeyLookup()", () => {
     expect(lookup.bar).toBe(true);
     expect(lookup.baz).toBe(true);
 
-    type cases = [
-      Expect<Equal<typeof lookup, Record<"foo" | "bar" | "baz", true>>>
-    ];
+    type cases = [Expect<Equal<typeof lookup, Record<"foo" | "bar" | "baz", true>>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
-});
+});

package/tests/arrayToObject-spec.ts

@@ -1,15 +1,21 @@
+import { describe, it, expect } from "vitest";
 
 import { Equal, Expect, ExpectExtends } from "@type-challenges/utils";
-import { ArrayConverter, arrayToObject, GeneralDictionary, UniqueDictionary, defineType, keys } from "~/utility";
+import {
+  ArrayConverter,
+  arrayToObject,
+  GeneralDictionary,
+  UniqueDictionary,
+  defineType,
+  keys,
+} from "../src/utility";
 
 const foo = { name: "foo", age: 123, color: "red" } as const;
 const foo2 = { name: "foo", age: 44, color: "orange" } as const;
 const bar = { name: "bar", age: 456, color: "blue" } as const;
 const baz = { name: "baz", age: 42, color: "green" } as const;
 
-
 describe("arrayToObject => ", () => {
-
   it("partial application of arrayToObject()", () => {
     const t1 = arrayToObject("name", false);
     type T1 = typeof t1;
@@ -28,7 +34,7 @@ describe("arrayToObject => ", () => {
       // The response types for each type is as expected
       Expect<ExpectExtends<GeneralDictionary<"name", any, any>, ReturnType<T1>>>,
       Expect<ExpectExtends<UniqueDictionary<"name", any, any>, ReturnType<T2>>>,
-      Expect<ExpectExtends<UniqueDictionary<"name", any, any>, ReturnType<T3>>>,
+      Expect<ExpectExtends<UniqueDictionary<"name", any, any>, ReturnType<T3>>>
     ];
 
     const cases: cases = [true, true, true, true, true, true];
@@ -71,7 +77,7 @@ describe("arrayToObject => ", () => {
       // however when we passed in two "types" for "foo" we get a union
       Expect<Equal<typeof dict2["foo"], SomeFoo>>,
       // once we state that foo is not unique, the type expanded to an array
-      Expect<Equal<typeof dict3["foo"], SomeFoo[]>>,
+      Expect<Equal<typeof dict3["foo"], SomeFoo[]>>
     ];
     const cases: cases = [true, true, true, true, true];
     expect(cases).toBe(cases);
@@ -100,12 +106,10 @@ describe("arrayToObject => ", () => {
       Expect<Equal<Slug["bob"]["slug"], "bob">>,
       // "age" and "color" are expressed as their widened types
       Expect<Equal<Id["1"]["age"], number>>,
-      Expect<Equal<Id["1"]["color"], string>>,
+      Expect<Equal<Id["1"]["color"], string>>
     ];
 
     const cases: cases = [true, true, true, true, true, true];
     expect(cases).toBe(cases);
   });
-
-
 });

package/tests/constructor.spec.ts

@@ -1,3 +1,5 @@
+import { describe, it, expect } from "vitest";
+
 import { Expect, Equal } from "@type-challenges/utils";
 import { Constructor } from "../src/types/Constructor";
 

package/tests/createFnWithProps.spec.ts

@@ -1,5 +1,5 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import { createFnWithProps } from "~/index";
+import { describe, it, expect } from "vitest";
+import { createFnWithProps } from "../src/index";
 
 describe("createFnWithProps()", () => {
   it("simple fn and prop are combined, type is retained", () => {

package/tests/data/index.ts

@@ -1,35 +1,12 @@
 // #autoindex
 
-// #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: da242834
+// #region auto-indexed files
+// index last changed at: 8th Aug, 2022, 06:09 PM ( GMT-7 )
+// hash-code: 683d9860
 
 
 
-// #endregion
+// #endregion auto-indexed files
 
-// This file was created by running: "dd autoindex"; it assumes you have
-// the 'do-devops' pkg (that's "dd" on npm) installed as a dev dep.
-//
-// By default it assumes that exports are named exports but this can be changed by
-// adding a modifier to the '// #autoindex' syntax:
-//
-//    - autoindex:named     same as default, exports "named symbols"
-//    - autoindex:default   assumes each file is exporting a default export and
-//                          converts the default export to the name of the file
-//    - autoindex:offset    assumes files export "named symbols" but that each
-//                          file's symbols should be offset by the file's name
-//
-// You may also exclude certain files or directories by adding it to the
-// autoindex command. As an example:
-//
-//    - autoindex:named, exclude: foo,bar,baz
-//
-// Inversely, if you state a file to be an "orphan" then autoindex files
-// below this file will not reference this autoindex file:
-//
-//    - autoindex:named, orphan
-// 
-// All content outside the "// #region" section in this file will be
-// preserved in situations where you need to do something paricularly awesome.
-// Keep on being awesome.
+// see https://github.com/inocan-group/do-devops/docs/autoindex.md
+// for more info

package/tests/defineType-spec.ts

@@ -1,7 +1,8 @@
-import type { Expect, Equal } from "@type-challenges/utils";
-import { ExpectExtends } from "~/types";
-import { defineType } from "~/utility";
+import { describe, it, expect } from "vitest";
 
+import type { Expect, Equal } from "@type-challenges/utils";
+import { ExpectExtends } from "../src/types";
+import { defineType } from "../src/utility";
 
 describe("inferredType() utility", () => {
   it("only specify a wide type", () => {
@@ -22,7 +23,16 @@ describe("inferredType() utility", () => {
       Expect<Equal<typeof t, { foo: string; bar: number }>>,
       // for some odd reason, when we let the default value for literal
       // we get something odd
-      Expect<Equal<typeof t2, { foo: string; bar: number;[x: string]: string | number | boolean | symbol | void | object | {} | null | undefined }>>,
+      Expect<
+        Equal<
+          typeof t2,
+          {
+            foo: string;
+            bar: number;
+            [x: string]: string | number | boolean | symbol | void | object | {} | null | undefined;
+          }
+        >
+      >,
       // fortunately it does extend the intended type
       Expect<ExpectExtends<typeof t2, { foo: string; bar: number }>>
     ];
@@ -32,9 +42,7 @@ describe("inferredType() utility", () => {
 
   it("only specify a literal type", () => {
     const t = defineType({ foo: 1, bar: "hi" })();
-    type cases = [
-      Expect<Equal<typeof t, { foo: 1; bar: "hi" }>>
-    ];
+    type cases = [Expect<Equal<typeof t, { foo: 1; bar: "hi" }>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
@@ -42,10 +50,8 @@ describe("inferredType() utility", () => {
   it("specify both wide and literal merged type", () => {
     const t = defineType({ bar: 1 })({ foo: "" });
 
-    type cases = [
-      Expect<Equal<typeof t, { foo: string; bar: 1 }>>
-    ];
+    type cases = [Expect<Equal<typeof t, { foo: string; bar: 1 }>>];
     const cases: cases = [true];
     expect(cases).toBe(cases);
   });
-});
+});