inferred-types 0.20.0 → 0.22.0

package/tests/string-literals/Dasherize.spec.ts

@@ -1,19 +1,17 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { Dasherize } from "~/types";
+import { Dasherize } from "src/types";
 
 const target = "two-three-four";
 type TARGET = typeof target;
 
 describe("Dasherize<T> type utility", () => {
-
   it("Dasherize<T> provides an identity to a dasherized string", () => {
     type T1 = Dasherize<"two-three-four">;
     type T2 = Dasherize<"\n two-three-four ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -21,9 +19,7 @@ describe("Dasherize<T> type utility", () => {
   it("Dasherize<T> transform snake_case type", () => {
     type T1 = Dasherize<"two_three_four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -31,9 +27,7 @@ describe("Dasherize<T> type utility", () => {
   it("Dasherize<T> transforms PascalCase type", () => {
     type T1 = Dasherize<"TwoThreeFour">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -51,7 +45,7 @@ describe("Dasherize<T> type utility", () => {
       Expect<Equal<T2, "two-three-four-five">>,
       Expect<Equal<T3, "two-three-four-five-six">>,
       Expect<Equal<T4, "two-three-four-five-six-seven">>,
-      Expect<Equal<T5, "two-three-four-five-six-seven-eight">>,
+      Expect<Equal<T5, "two-three-four-five-six-seven-eight">>
       // Expect<Equal<T6, "two-three-four-five-six-seven-eight-nine">>,
     ];
     const c: cases = [true, true, true, true, true];
@@ -61,9 +55,7 @@ describe("Dasherize<T> type utility", () => {
   it("Dasherize<T> transforms interior space to dasherized type", () => {
     type T1 = Dasherize<"two three four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -73,11 +65,7 @@ describe("Dasherize<T> type utility", () => {
     type T2 = Dasherize<"\n TWO_THREE_FOUR ">;
     type T3 = Dasherize<"\n TWO-THREE-FOUR ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-      Expect<Equal<T3, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>, Expect<Equal<T3, TARGET>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -86,10 +74,7 @@ describe("Dasherize<T> type utility", () => {
     type T1 = Dasherize<"  one two three ">;
     type T2 = Dasherize<"\n  one two three ">;
 
-    type cases = [
-      Expect<Equal<T1, "one-two-three">>,
-      Expect<Equal<T2, "one-two-three">>,
-    ];
+    type cases = [Expect<Equal<T1, "one-two-three">>, Expect<Equal<T2, "one-two-three">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -97,9 +82,7 @@ describe("Dasherize<T> type utility", () => {
   it("Dasherize<T> returns 'string' type when passed a non-literal string", () => {
     type T1 = Dasherize<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -116,10 +99,9 @@ describe("Dasherize<T> type utility", () => {
       Expect<Equal<T2, "one-two-three-four-five-six-seven-eight-nine-ten">>,
       Expect<Equal<T3, "one-two-three-four-five-six-seven-eight-nine-ten">>,
       Expect<Equal<T4, "one-two-three-four-five-six-seven-eight-nine-ten">>,
-      Expect<Equal<T5, "one-two-three-four-five-six-seven-eight-nine-ten">>,
+      Expect<Equal<T5, "one-two-three-four-five-six-seven-eight-nine-ten">>
     ];
     const c: cases = [true, true, true, true, true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/string-literals/HasUppercase.spec.ts

@@ -1,18 +1,15 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { HasUppercase } from "~/types";
+import { HasUppercase } from "src/types";
 
 describe("HasUppercase<T> type utility", () => {
-
   it("finds capitals where they exist", () => {
     type T1 = HasUppercase<"Yup">;
     type T2 = HasUppercase<"yUp">;
     type T3 = HasUppercase<"YUP">;
 
-    type cases = [
-      Expect<Equal<T1, true>>,
-      Expect<Equal<T2, true>>,
-      Expect<Equal<T3, true>>,
-    ];
+    type cases = [Expect<Equal<T1, true>>, Expect<Equal<T2, true>>, Expect<Equal<T3, true>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -21,10 +18,7 @@ describe("HasUppercase<T> type utility", () => {
     type T1 = HasUppercase<"nope">;
     type T2 = HasUppercase<"  noo nooo noooooooooooooo">;
 
-    type cases = [
-      Expect<Equal<T1, false>>,
-      Expect<Equal<T2, false>>,
-    ];
+    type cases = [Expect<Equal<T1, false>>, Expect<Equal<T2, false>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -32,11 +26,8 @@ describe("HasUppercase<T> type utility", () => {
   it("when passed a non literal string, returns 'unknown'", () => {
     type T1 = HasUppercase<string>;
 
-    type cases = [
-      Expect<Equal<T1, "unknown">>,
-    ];
+    type cases = [Expect<Equal<T1, "unknown">>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
 });

package/tests/string-literals/PascalCase.spec.ts

@@ -1,19 +1,17 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { PascalCase } from "~/types";
+import { PascalCase } from "src/types";
 
 const target = "TwoThreeFour";
 type TARGET = typeof target;
 
 describe("PascalCase<T> type utility", () => {
-
   it("PascalCase<T> provides an identity to a PascalCased string", () => {
     type T1 = PascalCase<"TwoThreeFour">;
     type T2 = PascalCase<"\n TwoThreeFour ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -21,9 +19,7 @@ describe("PascalCase<T> type utility", () => {
   it("PascalCase<T> transform snake_case type", () => {
     type T1 = PascalCase<"two_three_four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -32,10 +28,7 @@ describe("PascalCase<T> type utility", () => {
     type T1 = PascalCase<"twoThreeFour">;
     type T2 = PascalCase<"  twoThreeFour \t">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -54,7 +47,7 @@ describe("PascalCase<T> type utility", () => {
       Expect<Equal<T3, "TwoThreeFourFiveSix">>,
       Expect<Equal<T4, "TwoThreeFourFiveSixSeven">>,
       Expect<Equal<T5, "TwoThreeFourFiveSixSevenEight">>,
-      Expect<Equal<T6, "TwoThreeFourFiveSixSevenEightNineTenEleven">>,
+      Expect<Equal<T6, "TwoThreeFourFiveSixSevenEightNineTenEleven">>
     ];
     const c: cases = [true, true, true, true, true, true];
     expect(c).toBe(c);
@@ -63,9 +56,7 @@ describe("PascalCase<T> type utility", () => {
   it("PascalCase<T> transforms interior space to PascalCased type", () => {
     type T1 = PascalCase<"two three four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -75,11 +66,7 @@ describe("PascalCase<T> type utility", () => {
     type T2 = PascalCase<"\n TWO_THREE_FOUR ">;
     type T3 = PascalCase<"\n TWO-THREE-FOUR ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-      Expect<Equal<T3, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>, Expect<Equal<T3, TARGET>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -88,10 +75,7 @@ describe("PascalCase<T> type utility", () => {
     type T1 = PascalCase<"  one two three ">;
     type T2 = PascalCase<"\n  one two three ">;
 
-    type cases = [
-      Expect<Equal<T1, "OneTwoThree">>,
-      Expect<Equal<T2, "OneTwoThree">>,
-    ];
+    type cases = [Expect<Equal<T1, "OneTwoThree">>, Expect<Equal<T2, "OneTwoThree">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -99,9 +83,7 @@ describe("PascalCase<T> type utility", () => {
   it("PascalCase<T> returns 'string' type when passed a non-literal string", () => {
     type T1 = PascalCase<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -119,10 +101,9 @@ describe("PascalCase<T> type utility", () => {
       Expect<Equal<T2, "OneTwoThreeFourFiveSixSevenEightNine">>,
       Expect<Equal<T3, "OneTwoThreeFourFiveSixSevenEightNine">>,
       Expect<Equal<T4, "OneTwoThreeFourFiveSixSevenEightNine">>,
-      Expect<Equal<T5, "OneTwoThreeFourFiveSixSevenEightNine">>,
+      Expect<Equal<T5, "OneTwoThreeFourFiveSixSevenEightNine">>
     ];
     const c: cases = [true, true, true, true, true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/string-literals/SnakeCase.spec.ts

@@ -1,19 +1,17 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { SnakeCase } from "~/types";
+import { SnakeCase } from "src/types";
 
 const target = "two_three_four";
 type TARGET = typeof target;
 
 describe("SnakeCase<T> type utility", () => {
-
   it("SnakeCase<T> provides an identity to a SnakeCased string", () => {
     type T1 = SnakeCase<"TwoThreeFour">;
     type T2 = SnakeCase<"\n TwoThreeFour ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -21,9 +19,7 @@ describe("SnakeCase<T> type utility", () => {
   it("SnakeCase<T> transform snake_case type", () => {
     type T1 = SnakeCase<"two_three_four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -32,10 +28,7 @@ describe("SnakeCase<T> type utility", () => {
     type T1 = SnakeCase<"twoThreeFour">;
     type T2 = SnakeCase<"  twoThreeFour \t">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -53,7 +46,7 @@ describe("SnakeCase<T> type utility", () => {
       Expect<Equal<T2, "two_three_four_five">>,
       Expect<Equal<T3, "two_three_four_five_six">>,
       Expect<Equal<T4, "two_three_four_five_six_seven">>,
-      Expect<Equal<T5, "two_three_four_five_six_seven_eight">>,
+      Expect<Equal<T5, "two_three_four_five_six_seven_eight">>
       // Expect<Equal<T6, "TwoThreeFourFiveSixSevenEightNineTenEleven">>,
     ];
     const c: cases = [true, true, true, true, true];
@@ -63,9 +56,7 @@ describe("SnakeCase<T> type utility", () => {
   it("SnakeCase<T> transforms interior space to SnakeCased type", () => {
     type T1 = SnakeCase<"two three four">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -75,11 +66,7 @@ describe("SnakeCase<T> type utility", () => {
     type T2 = SnakeCase<"\n TWO_THREE_FOUR ">;
     type T3 = SnakeCase<"\n TWO-THREE-FOUR ">;
 
-    type cases = [
-      Expect<Equal<T1, TARGET>>,
-      Expect<Equal<T2, TARGET>>,
-      Expect<Equal<T3, TARGET>>,
-    ];
+    type cases = [Expect<Equal<T1, TARGET>>, Expect<Equal<T2, TARGET>>, Expect<Equal<T3, TARGET>>];
     const c: cases = [true, true, true];
     expect(c).toBe(c);
   });
@@ -88,10 +75,7 @@ describe("SnakeCase<T> type utility", () => {
     type T1 = SnakeCase<"  one two three ">;
     type T2 = SnakeCase<"\n  one two three ">;
 
-    type cases = [
-      Expect<Equal<T1, "one_two_three">>,
-      Expect<Equal<T2, "one_two_three">>,
-    ];
+    type cases = [Expect<Equal<T1, "one_two_three">>, Expect<Equal<T2, "one_two_three">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -99,9 +83,7 @@ describe("SnakeCase<T> type utility", () => {
   it("SnakeCase<T> returns 'string' type when passed a non-literal string", () => {
     type T1 = SnakeCase<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
@@ -119,10 +101,9 @@ describe("SnakeCase<T> type utility", () => {
       Expect<Equal<T2, "one_two_three_four_five_six_seven_eight_nine">>,
       Expect<Equal<T3, "one_two_three_four_five_six_seven_eight_nine">>,
       Expect<Equal<T4, "one_two_three_four_five_six_seven_eight_nine">>,
-      Expect<Equal<T5, "one_two_three_four_five_six_seven_eight_nine">>,
+      Expect<Equal<T5, "one_two_three_four_five_six_seven_eight_nine">>
     ];
     const c: cases = [true, true, true, true, true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/string-literals/whitespace-capture.spec.ts

@@ -1,16 +1,14 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { LeftWhitespace, RightWhitespace } from "~/types";
+import { LeftWhitespace, RightWhitespace } from "src/types";
 
 describe("LeftWhitespace<T> utility", () => {
-
   it("no whitespace results in empty string literal", () => {
     type T1 = LeftWhitespace<"foobar">;
     type T2 = LeftWhitespace<"foobar \n">;
 
-    type cases = [
-      Expect<Equal<T1, "">>,
-      Expect<Equal<T2, "">>,
-    ];
+    type cases = [Expect<Equal<T1, "">>, Expect<Equal<T2, "">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -19,10 +17,7 @@ describe("LeftWhitespace<T> utility", () => {
     type T1 = LeftWhitespace<" foobar">;
     type T2 = LeftWhitespace<"\n\t foobar \n">;
 
-    type cases = [
-      Expect<Equal<T1, " ">>,
-      Expect<Equal<T2, "\n\t ">>,
-    ];
+    type cases = [Expect<Equal<T1, " ">>, Expect<Equal<T2, "\n\t ">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -30,25 +25,18 @@ describe("LeftWhitespace<T> utility", () => {
   it("a 'string' type passed in returns a string", () => {
     type T1 = LeftWhitespace<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
 });
 
 describe("RightWhitespace<T> utility", () => {
-
   it("no whitespace results in empty string literal", () => {
     type T1 = RightWhitespace<"foobar">;
     type T2 = RightWhitespace<"\n\tfoobar">;
 
-    type cases = [
-      Expect<Equal<T1, "">>,
-      Expect<Equal<T2, "">>,
-    ];
+    type cases = [Expect<Equal<T1, "">>, Expect<Equal<T2, "">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -57,10 +45,7 @@ describe("RightWhitespace<T> utility", () => {
     type T1 = RightWhitespace<"foobar ">;
     type T2 = RightWhitespace<"\n\t foobar \n">;
 
-    type cases = [
-      Expect<Equal<T1, " ">>,
-      Expect<Equal<T2, " \n">>,
-    ];
+    type cases = [Expect<Equal<T1, " ">>, Expect<Equal<T2, " \n">>];
     const c: cases = [true, true];
     expect(c).toBe(c);
   });
@@ -68,11 +53,8 @@ describe("RightWhitespace<T> utility", () => {
   it("a 'string' type passed in returns a string", () => {
     type T1 = RightWhitespace<string>;
 
-    type cases = [
-      Expect<Equal<T1, string>>,
-    ];
+    type cases = [Expect<Equal<T1, string>>];
     const c: cases = [true];
     expect(c).toBe(c);
   });
-
-});
+});

package/tests/tuples/TupleToUnion.spec.ts

@@ -1,4 +1,6 @@
-import { TupleToUnion } from "~/types";
+import { describe, it, expect } from "vitest";
+
+import { TupleToUnion } from "src/types";
 import { Expect, Equal } from "@type-challenges/utils";
 
 describe("TupleToUnion<T> type utility", () => {

package/tests/withValue.spec.ts

@@ -1,7 +1,8 @@
-import { createFnWithProps, type, withValue } from "~/utility";
+import { describe, it, expect } from "vitest";
 import type { Expect, Equal } from "@type-challenges/utils";
-import { WithValue } from "~/types/props";
-import { FunctionType } from "~/types";
+
+import { createFnWithProps, type, withValue } from "../src/utility";
+import { FunctionType, WithValue } from "../src";
 
 describe("withValue()() utility", () => {
   it("type reduction with WithValue<T> works as expected", () => {

package/tsconfig.json

@@ -3,37 +3,26 @@
     "module": "ESNEXT",
     "target": "ESNEXT",
     "moduleResolution": "node",
-
     "sourceMap": true,
     "noEmit": true,
     "incremental": true,
     "resolveJsonModule": true,
-
     "strict": true,
     "skipLibCheck": true,
     "noUnusedLocals": true,
     "noUnusedParameters": true,
     "noImplicitReturns": true,
     "allowSyntheticDefaultImports": true,
-
-    "lib": ["ES2020"],
-
+    "lib": [
+      "ES2020"
+    ],
     "baseUrl": ".",
     "declaration": true,
     "outDir": "dist",
     "tsBuildInfoFile": ".tsbuildinfo",
-
-    "paths": {
-      "~/*": ["src/*"],
-      "/~/*": ["src/*"]
-    },
-    "plugins": [
-      // Transform paths in output .js files
-      { "transform": "typescript-transform-paths" },
-
-      // Transform paths in output .d.ts files (Include this line if you output declarations files)
-      { "transform": "typescript-transform-paths", "afterDeclarations": true }
-    ]
   },
-  "include": ["src", "tests"]
-}
+  "include": [
+    "src",
+    "tests"
+  ]
+}

package/vitest.config.ts

@@ -0,0 +1,13 @@
+/// <reference types="vitest" />
+import { defineConfig } from "vite";
+
+// used for testing, library code uses TSUP to build exports
+export default defineConfig({
+  test: {
+    dir: "tests",
+    api: {
+      host: "0.0.0.0",
+    },
+  },
+  plugins: [],
+});

package/jest.config.ts

@@ -1,20 +0,0 @@
-/* eslint-disable unicorn/import-style */
-import type { Config } from "@jest/types";
-import { resolve } from "path";
-
-const config: Config.InitialOptions = {
-  verbose: true,
-  // roots: ["tests", "src"],
-  transform: {
-    "^.+\\.tsx?$": "ts-jest",
-  },
-  testPathIgnorePatterns: ["/node_modules/", "/on-hold/"],
-  moduleNameMapper: {
-    "^[/]{0,1}~/(.*)$": resolve(process.cwd(), "src", "$1"),
-  },
-  testMatch: ["**/?(*[-.])+(spec|test).ts"],
-  setupFilesAfterEnv: ["jest-extended"],
-  testEnvironment: "node",
-};
-
-export default config;

package/on-hold/Builder/Builder.ts

@@ -1,66 +0,0 @@
-import { TypeGuard } from "~/types";
-
-import { MutationIdentity } from "../Mutation";
-import { IdentityToMutationApi, MutationToFluentApi } from "./index";
-
-/* eslint-disable no-use-before-define */
-
-export type BuilderComplete<C, S> = C extends infer U ? (U extends S ? "" : "unwrap") : never;
-
-/**
- * **Builder**
- *
- * Creates a builder pattern that provides a user-friendly (and strongly typed)
- * means of configuring a defined data structure.
- *
- * The _first_ function call establishes a type-guard to validate when the desired
- * configuration has been achieved as well as the fluent API surface that should
- * be used to configure this builder.
- *
- * The _second_ function call allows for setting an initial configuration state.
- *
- * **Example:**
- *
- * ```ts
- * // configure
- * type Config = { foo: number };
- * const typeGuard = (thing: unknown): thing is Config { ... };
- * const config = Builder(typeGuard, api)();
- * // use (and unwrap)
- * const myConfig = config.set(5).add(3).unwrap();
- * ```
- */
-export function Builder<
-  TState extends object,
-  TApi extends { [key: string]: MutationIdentity<any, any> }
->(validate: TypeGuard<TState>, apiDefinition: TApi) {
-  /**
-   * The non-fluent API component of the Builder API
-   */
-  type IEscape<T extends object = {}> = { unwrap: () => TState; current: Partial<TState> } & T;
-
-  return <TCurrent extends Partial<TState>>(state: TCurrent) => {
-    const escapeApi: IEscape = {
-      current: state,
-      unwrap: () => {
-        if (!validate(state)) {
-          throw new Error(
-            `Attempt to unwrap() the state prior to it being completed! The configuration at this point is:\n${JSON.stringify(
-              state,
-              null,
-              2
-            )}`
-          );
-        }
-        return state;
-      },
-    };
-
-    // provide state to identity functions to make them mutation functions
-    const mutationApi = IdentityToMutationApi(state)(apiDefinition);
-    // determine the exclusions
-    type Complete = BuilderComplete<TCurrent, TState>;
-    // transform mutation API to fluent API
-    return MutationToFluentApi<TState, TApi, IEscape, Complete>(validate, apiDefinition)(mutationApi, escapeApi);
-  };
-}

package/on-hold/Builder/BuilderApi.ts

@@ -1,21 +0,0 @@
-/* eslint-disable no-use-before-define */
-import { MutationIdentity } from "~/Mutation";
-
-/**
- * Used to facilitate building **Identity APIs** to be used
- * in the `Builder` primitive.
- */
-export function BuilderApi<T extends object>() {
-  return function BuilderKeyValue<
-    // identity function (s => fn => s)
-    V extends MutationIdentity<PT, any>,
-    // API property
-    K extends string,
-    // KV pair
-    O extends Record<K, V>,
-    /** Provide structure of Partial<T> while using extends to preserve type info */
-    PT extends Partial<T>
-  >(key: K, value: V): O {
-    return { [key as K]: value } as O;
-  };
-}