inferred-types 0.20.0 → 0.22.0

package/src/utility/ruleset.ts

@@ -1,5 +1,6 @@
 /* eslint-disable no-use-before-define */
-import type { Narrowable } from "~/types";
+
+import { Narrowable } from "src/types/Narrowable";
 
 // TODO: get ruleset functionality working!
 
@@ -15,21 +16,23 @@ import type { Narrowable } from "~/types";
 
 /**
  * **ruleSet**
- * 
+ *
  * Defines a ruleset composed of _dynamic_ and _static_ boolean operators.
- * 
+ *
  * - the first function call defines _dynamic_ props (_optional_)
  * - the second function call defines static values
- * 
+ *
  * ```ts
- * const rs = ruleSet( 
+ * const rs = ruleSet(
  *    r => r.state()( { maybe: r => r.extends({ foo: 1 }) })
- * )( 
- *    { color: true, age: false } 
+ * )(
+ *    { color: true, age: false }
  * );
  * ```
  */
-export function ruleSet<N extends Narrowable, TState extends Record<keyof TState, N>>(defn?: TState) {
+export function ruleSet<N extends Narrowable, TState extends Record<keyof TState, N>>(
+  defn?: TState
+) {
   // return <
   //   TStatic extends { [K in keyof TStatic]: Readonly<true | false> },
   //   >(rules: TStatic) => {
@@ -37,4 +40,3 @@ export function ruleSet<N extends Narrowable, TState extends Record<keyof TState
   // };
   return defn;
 }
-

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/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>(

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,12 +1,11 @@
 // #autoindex
 // #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: fd5dfde8
+// index last changed at: 7th Jul, 2022, 01:15 PM ( GMT-7 )
+// hash-code: 14769606
 
 // file exports
 export * from "./Configurator";
 export * from "./FluentConfigurator";
-export * from "./KeyStorage";
 
 // #endregion
 

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/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);
   });
-});
+});

package/tests/dictionary/DictPartialApplication.test.ts

@@ -0,0 +1,43 @@
+import { describe, it } from "vitest";
+
+import type { DictPartialApplication } from "src/types";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+describe("DictUnwrapValues<T>", () => {
+  it("happy path", () => {
+    const api = {
+      hi: (name: string) => `hi ${name}`,
+      bye: (name: string) => `bye ${name}`,
+    };
+
+    type Api = typeof api;
+    type T = DictPartialApplication<Api>;
+    type Expected = { hi: string; bye: string };
+
+    type cases = [Expect<Equal<T, Expected>>];
+
+    const cases: cases = [true];
+  });
+
+  it("object which has non-function based props", () => {
+    const api = {
+      theAnswer: 42,
+      hi: (name: string) => `hi ${name}`,
+      bye: (name: string) => `bye ${name}`,
+    };
+
+    type Api = typeof api;
+    type T1 = DictPartialApplication<Api>;
+    type T2 = DictPartialApplication<Api, true>;
+    type T3 = DictPartialApplication<Api, false>;
+    type Expected = { hi: string; bye: string };
+    type Expected3 = { theAnswer: number; hi: string; bye: string };
+
+    type cases = [
+      Expect<Equal<T1, Expected>>,
+      Expect<Equal<T2, Expected>>,
+      Expect<Equal<T3, Expected3>>
+    ];
+    const cases: cases = [true, true, true];
+  });
+});

package/tests/dictionary/DictReturnValues.test.ts

@@ -0,0 +1,32 @@
+import { describe, it } from "vitest";
+
+import type { DictReturnValues } from "src/types";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+describe("DictReturnValues<T, R, O>", () => {
+  it("happy path", () => {
+    const api = {
+      foo: (name: string) => `${name}`,
+      multiply: (v1: number, v2: number) => v1 * v2,
+    };
+
+    type Api = typeof api;
+    // convert all functions
+    type T1 = DictReturnValues<Api, null>;
+    // convert functions with `number` return
+    type T2 = DictReturnValues<Api, null, (...args: any[]) => number>;
+
+    type Expected1 = {
+      foo: (name: string) => null;
+      multiply: (v1: number, v2: number) => null;
+    };
+    type Expected2 = {
+      foo: (name: string) => string;
+      multiply: (v1: number, v2: number) => null;
+    };
+
+    type cases = [Expect<Equal<T1, Expected1>>, Expect<Equal<T2, Expected2>>];
+
+    const cases: cases = [true, true];
+  });
+});

package/tests/dictionary/Get.spec.ts

@@ -1,6 +1,8 @@
+import { describe, it, expect } from "vitest";
+
 import { Equal, Expect } from "@type-challenges/utils";
-import { Get } from "~/types";
-import { defineType } from "~/utility";
+import { Get } from "src/types";
+import { defineType } from "src/utility";
 
 describe("Get<T, K> type utility", () => {
   it("Get<T,K> works with literals and wide types", () => {
@@ -17,7 +19,7 @@ describe("Get<T, K> type utility", () => {
       Expect<Equal<Id, 1234>>,
       Expect<Equal<Foo, number>>,
       Expect<Equal<Bar, string>>,
-      // non-existant props return never
+      // non-existent props return never
       Expect<Equal<Nada, never>>
     ];
     const c: cases = [true, true, true, true];

package/tests/dictionary/PrependValuesWithFunction.ts

@@ -0,0 +1,34 @@
+import { describe, it, expect } from "vitest";
+
+import type { DictPrependWithFn } from "src/types";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+describe("WrapValuesWithFunction<T, R, O>", () => {
+  it("happy path", () => {
+    const api = {
+      static: 42,
+      foo: (name: string) => `${name}`,
+      multiply: (v1: number, v2: number) => v1 * v2,
+    };
+
+    type Api = typeof api;
+    type T1 = DictPrependWithFn<Api, [name: string, age: number]>;
+    type T2 = DictPrependWithFn<Api, [name: string, age: number], Function>;
+
+    type Expected1 = {
+      static: (name: string, age: number) => number;
+      foo: (name: string, age: number) => (name: string) => string;
+      multiply: (name: string, age: number) => (v1: number, v2: number) => number;
+    };
+
+    type Expected2 = {
+      static: number;
+      foo: (name: string, age: number) => (name: string) => string;
+      multiply: (name: string, age: number) => (v1: number, v2: number) => number;
+    };
+
+    type cases = [Expect<Equal<T1, Expected1>>, Expect<Equal<T2, Expected2>>];
+    const cases: cases = [true, true];
+    expect(cases).toBe(cases);
+  });
+});

package/tests/dictionary/RequireProps.test.ts

@@ -0,0 +1,21 @@
+import { describe, it, expect } from "vitest";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+import { RequireProps } from "src/types/dictionary";
+
+describe("RequireProps<T,R>", () => {
+  it("works as expected", () => {
+    type Start = { foo?: string; bar?: number };
+    type Foo = RequireProps<Start, "foo">;
+    type Bar = RequireProps<Start, "bar">;
+    type Both = RequireProps<Start, "foo" | "bar">;
+
+    type cases = [
+      Expect<Equal<Foo, { foo: string; bar?: number }>>,
+      Expect<Equal<Bar, { foo?: string; bar: number }>>,
+      Expect<Equal<Both, { foo: string; bar: number }>>
+    ];
+    const cases: cases = [true, true, true];
+    expect(cases).toBe(cases);
+  });
+});

package/tests/dictionaryTransform-spec.ts

@@ -1,7 +1,7 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import { dictionaryTransform, ExplicitFunction } from "~/utility";
+import { describe, it, expect } from "vitest";
+import { dictionaryTransform, ExplicitFunction } from "../src/utility";
 import { Expect, Equal, NotEqual, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
-import { ToFluent, Transformer } from "~/types";
+import { ToFluent, Transformer } from "../src/types";
 
 describe("dictionaryTransform()", () => {
   type A = { foo: string; bar: string };