inferred-types 0.22.0 → 0.22.6

package/tests/dictionary/DictReturnValues.test.ts

@@ -25,7 +25,11 @@ describe("DictReturnValues<T, R, O>", () => {
       multiply: (v1: number, v2: number) => null;
     };
 
-    type cases = [Expect<Equal<T1, Expected1>>, Expect<Equal<T2, Expected2>>];
+    type cases = [
+      //
+      Expect<Equal<T1, Expected1>>, 
+      Expect<Equal<T2, Expected2>>
+    ];
 
     const cases: cases = [true, true];
   });

package/tests/dictionary/MutableProps.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from "vitest";
+import type { Expect, Equal } from "@type-challenges/utils";
+
+import { MutableProps } from "src/types/dictionary";
+
+describe("MutableProps<T,M>", () => {
+  it("works as expected", () => {
+    type Test = { foo: string; bar?: number; baz: Readonly<boolean> };
+    type Foo = MutableProps<Test, "foo" | "bar">;
+    type Bar = MutableProps<Test, "bar">;
+    type FooBar = MutableProps<Test, "foo" | "bar">;
+    type FooBaz = MutableProps<Test, "foo" | "baz">;
+
+    type cases = [
+      Expect<Equal<Foo, { foo: string; bar?: Readonly<number>; readonly baz: Readonly<boolean> }>>,
+      Expect<
+        Equal<
+          Bar,
+          { readonly foo: Readonly<string>; bar?: number; readonly baz: Readonly<boolean> }
+        >
+      >,
+      Expect<Equal<FooBar, { foo: string; bar?: number; readonly baz: Readonly<boolean> }>>,
+      Expect<
+        Equal<FooBaz, { foo: string; readonly bar?: Readonly<number>; baz: Readonly<boolean> }>
+      >
+    ];
+    const cases: cases = [true, true, true, true];
+    expect(cases).toBe(cases);
+  });
+});

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

@@ -1,7 +0,0 @@
-export type IsLiteral<L extends string | number, T extends any> = T extends L ? true : false;
-
-export function isLiteral<L extends Readonly<string>>(...allowed: L[]) {
-  return <T extends unknown>(i: T) => {
-    return !allowed.every((v) => i !== v) as IsLiteral<L, T>;
-  };
-}