inferred-types 0.33.1 → 0.33.3

package/src/types/type-checks/EndsWith.ts

@@ -0,0 +1,22 @@
+import { IfStringLiteral } from "src/types/type-checks";
+
+/**
+ * **EndsWith**<T,U>
+ *
+ * A type utility which checks whether `T` _ends with_ the string literal `U`.
+ *
+ * If both `T` and `U` are string literals then the type system will resolve
+ * to a literal `true` or `false` but if either is not a literal that it will
+ * just resolve to `boolean` as the value can not be known at design time..
+ */
+export type EndsWith<T extends unknown, U extends unknown> = T extends string
+  ? U extends string
+    ? T extends `${string}${U}`
+      ? IfStringLiteral<
+          T, //
+          IfStringLiteral<U, true, boolean>,
+          boolean
+        >
+      : IfStringLiteral<T, false, boolean>
+    : false
+  : false;

package/src/types/{TypeInfo → type-checks}/IsStringLiteral.ts

@@ -4,15 +4,11 @@
  * Type utility which returns true/false if the string a _string literal_ versus
  * just the _string_ type.
  */
-export type IsStringLiteral<T> = T extends string
-  ? string extends T ? false : true
-  : false;
+export type IsStringLiteral<T> = [T] extends [string] ? (string extends T ? false : true) : false;
 
 /**
  * **IfStringLiteral**
  *
  * Branch utility which returns `IF` type when `T` is a string literal and `ELSE` otherwise
  */
-export type IfStringLiteral<T extends string, IF, ELSE> = IsStringLiteral<T> extends true
-  ? IF
-  : ELSE;
+export type IfStringLiteral<T, IF, ELSE> = [IsStringLiteral<T>] extends [true] ? IF : ELSE;

package/src/types/type-checks/StartsWith.ts

@@ -0,0 +1,43 @@
+import { IfStringLiteral } from "src/types/type-checks";
+import { Narrowable } from "../Narrowable";
+/**
+ * **StartsWith**<TValue, TStartsWith>
+ *
+ * A type utility which checks whether `T` _starts with_ the string literal `U`.
+ *
+ * If both `T` and `U` are string literals then the type system will resolve
+ * to a literal `true` or `false` but if either is not a literal that it will
+ * just resolve to `boolean` as the value can not be known at design time..
+ */
+export type StartsWith<TValue extends unknown, TStartsWith extends unknown> = TValue extends string
+  ? TStartsWith extends string
+    ? TValue extends `${TStartsWith}${string}`
+      ? IfStringLiteral<
+          TValue, //
+          IfStringLiteral<TStartsWith, true, boolean>,
+          boolean
+        >
+      : IfStringLiteral<TValue, false, boolean>
+    : false
+  : false;
+
+/**
+ * **IfStartsWith**<TValue, TStartsWith, IF, ELSE, MAYBE>
+ *
+ * Type utility which converts type to `IF` type _if_ TValue _starts with_ `TStartsWith` but
+ * otherwise converts type to `ELSE`.
+ *
+ * Note, that there is also an optional `MAYBE` type
+ * which can be stated for cases where TValue or TStartsWith _might_ be the wider `string`
+ * type and therefore the type is unknown at design time.
+ */
+export type IfStartsWith<
+  TValue extends unknown,
+  TStartsWith extends unknown,
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = StartsWith<TValue, TStartsWith> extends true
+  ? IF
+  : StartsWith<TValue, TStartsWith> extends false
+  ? ELSE
+  : IF | ELSE;

package/src/types/{TypeInfo → type-checks}/TypeDefault.ts

@@ -1,4 +1,4 @@
-import { IsObject } from "src/types/TypeInfo";
+import { IsObject } from "src/types/type-checks";
 import { SimplifyObject } from "../SimplifyObject";
 import { IfExtends } from "./Extends";
 import { IfOptionalLiteral } from "./IsLiteral";

package/src/types/{TypeInfo → type-checks}/index.ts

@@ -4,6 +4,9 @@ export * from "./IsNumericLiteral";
 export * from "./IsScalar";
 export * from "./IsStringLiteral";
 export * from "./IsLiteral";
+export * from "./IsUndefined";
 export * from "./Extends";
 export * from "./TypeDefault";
-export * from "./IsObject";
+export * from "./object";
+export * from "./StartsWith";
+export * from "./EndsWith";

package/src/types/type-checks/string.ts

@@ -0,0 +1,21 @@
+import { Narrowable } from "src/types";
+
+/**
+ * **IsString**
+ *
+ * Type utility which returns true/false based on whether `T` is a
+ * string (wide or narrow).
+ */
+export type IsString<T> = T extends string ? true : false;
+
+/**
+ * **IfString**
+ *
+ * Type utility which determines if `T` is a _string_ (wide or narrow) and
+ * returns `IF` type if it is, otherwise returns the type `ELSE`.
+ */
+export type IfString<
+  T extends Narrowable, //
+  IF extends Narrowable,
+  ELSE extends Narrowable
+> = IsString<T> extends true ? IF : ELSE;

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

@@ -1,5 +1,3 @@
-import { Mutable } from "../Mutable";
-
 /**
  * Converts a Tuple type into a _union_ of the tuple elements
  * ```ts
@@ -8,4 +6,4 @@ import { Mutable } from "../Mutable";
  * type U = TupleToUnion<typeof arr>;
  * ```
  */
-export type TupleToUnion<T> = Mutable<T> extends any[] ? Mutable<T>[number] : never;
+export type TupleToUnion<T> = T extends readonly any[] ? T[number] : never;

package/tests/ExplicitFunction-spec.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 
-import { ExplicitFunction } from "../src/utility";
+import { ExplicitFunction } from "../src/runtime";
 import type { Expect, Equal } from "@type-challenges/utils";
 
 describe("ExplicitFunction()", () => {

package/tests/arrayToKeyLookup-spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 
 import { Equal, Expect } from "@type-challenges/utils";
-import { arrayToKeyLookup } from "../src/utility";
+import { arrayToKeyLookup } from "../src/runtime";
 
 describe("arrayToKeyLookup()", () => {
   it("simple string array is converted", () => {

package/tests/arrayToObject-spec.ts

@@ -8,7 +8,7 @@ import {
   UniqueDictionary,
   defineType,
   keys,
-} from "../src/utility";
+} from "../src/runtime";
 
 const foo = { name: "foo", age: 123, color: "red" } as const;
 const foo2 = { name: "foo", age: 44, color: "orange" } as const;

package/tests/boolean-logic/boolean.spec.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 // import type { Equal, Expect } from "@type-challenges/utils";
-import { and, filter } from "src/utility";
+import { and, filter } from "src/runtime";
 
 describe("boolean logic", () => {
   it("AND operation", () => {

package/tests/boolean-logic/filter.spec.ts

@@ -1,4 +1,4 @@
-import { filter } from "src/utility";
+import { filter } from "src/runtime";
 import { Equal, Expect } from "@type-challenges/utils";
 import { describe, it, expect } from "vitest";
 

package/tests/defineType-spec.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 
 import type { Expect, Equal } from "@type-challenges/utils";
 import { ExpectExtends } from "../src/types";
-import { defineType } from "../src/utility";
+import { defineType } from "../src/runtime";
 
 describe("inferredType() utility", () => {
   it("only specify a wide type", () => {

package/tests/dictionary/Get.spec.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 
 import { Equal, Expect } from "@type-challenges/utils";
 import { Get } from "src/types";
-import { defineType } from "src/utility";
+import { defineType } from "src/runtime";
 
 describe("Get<T, K> type utility", () => {
   it("Get<T,K> works with literals and wide types", () => {

package/tests/dictionary/TypeDefault.test.ts

@@ -1,7 +1,7 @@
 import { describe, it } from "vitest";
 import { Equal, Expect } from "@type-challenges/utils";
-import { TypeDefault } from "src/types/TypeInfo/TypeDefault";
-import { literal } from "src/utility/literals";
+import { TypeDefault } from "src/types/type-checks/TypeDefault";
+import { literal } from "src/runtime/literals";
 
 describe("TypeDefault<T,D>", () => {
   it("T/D as dictionary", () => {

package/tests/dictionary/mapTo.test.ts

@@ -16,7 +16,7 @@ import {
   DEFAULT_MANY_TO_ONE_MAPPING,
   DEFAULT_ONE_TO_MANY_MAPPING,
   mapTo,
-} from "src/utility/dictionary/mapTo";
+} from "src/runtime/dictionary/mapTo";
 
 type I = { title: string; color: string; products: string[] };
 const i: I = { title: "Test", color: "green", products: ["foo", "bar", "baz"] };

package/tests/dictionary/merge.test.ts

@@ -1,5 +1,5 @@
 import { Equal, Expect } from "@type-challenges/utils";
-import { merge } from "src/utility/dictionary/merge";
+import { merge } from "src/runtime/dictionary/merge";
 import { describe, expect, it } from "vitest";
 
 describe("merge() utility", () => {

package/tests/dictionaryTransform-spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { dictionaryTransform, ExplicitFunction } from "../src/utility";
+import { dictionaryTransform, ExplicitFunction } from "../src/runtime";
 import { Expect, Equal, NotEqual, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
 import { ToFluent, Transformer } from "../src/types";
 

package/tests/ifTypeOf-spec.ts

@@ -2,7 +2,8 @@ import { describe, it, expect } from "vitest";
 
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { Expect, Equal } from "@type-challenges/utils";
-import { ifTypeOf, defineType, literal } from "../src/utility";
+import { defineType, literal } from "../src/runtime";
+import { ifTypeOf } from "src/runtime/type-checks/ifTypeOf";
 
 describe("ifTypeOf() utility", () => {
   it("base validation with extends() returns true/false", () => {
@@ -142,7 +143,7 @@ describe("ifTypeOf() utility", () => {
     // literal types and broader types; this is not hard to express with types
     // but it makes our approach much more awkward and the API much more cumbersome
 
-    // here we see a type that represents this challange but how it fails with
+    // here we see a type that represents this challenge but how it fails with
     // with the runtime
 
     const literal = { foo: 1 } as const;

package/tests/kv/dict-to-kv-and-back.spec.ts

@@ -1,9 +1,9 @@
 import { describe, it, expect } from "vitest";
 
 import { Equal, Expect, NotEqual } from "@type-challenges/utils";
-import { dictToKv, kvToDict } from "src/utility/dictionary";
+import { dictToKv, kvToDict } from "src/runtime/dictionary";
 import { DictFromKv } from "src/types/kv";
-import { keys } from "src/utility";
+import { keys } from "src/runtime";
 
 describe("dictToKv()", () => {
   it.skip("basic structure is correct when forcing to Tuple structure", () => {

package/tests/kv/entries-spec.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect } from "vitest";
 
 import type { Expect, NotEqual, Equal, ExpectExtends } from "@type-challenges/utils";
-import { entries } from "src/utility";
+import { entries } from "src/runtime";
 
 describe("entries() => ", () => {
   it("literal types are retained", () => {

package/tests/kv/keys.spec.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 
 import { Keys } from "src/types/Keys";
 import type { Expect, Equal } from "@type-challenges/utils";
-import { defineType, keys } from "src/utility";
+import { defineType, keys } from "src/runtime";
 
 describe("Keys<T>", () => {
   it("Keys<T> is shorthand for keyof T", () => {

package/tests/kv/kv-spec.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 
-import { keys, kv } from "src/utility";
+import { keys, kv } from "src/runtime";
 
 describe("kv utils", () => {
   it("simple assignment works with strong literal support", () => {

package/tests/lists/First.test.ts

@@ -0,0 +1,43 @@
+import { describe, it } from "vitest";
+import type { Expect, Equal } from "@type-challenges/utils";
+import { AfterFirst, First } from "src/types/lists";
+
+describe("First<T>, AfterFirst<T>", () => {
+  it("First<T> with literals", () => {
+    const arr = ["one", "two", 42] as const;
+    type F = First<typeof arr>;
+    type cases = [Expect<Equal<F, "one">>];
+    const cases: cases = [true];
+  });
+  it("First<T> with wide types but literal array", () => {
+    const arr = ["one" as string, "two", 42] as const;
+    type F = First<typeof arr>;
+    type cases = [Expect<Equal<F, string>>];
+    const cases: cases = [true];
+  });
+  it("First<T> with a non const array", () => {
+    const arr = ["one", "two", 42];
+    type F = First<typeof arr>;
+    type cases = [Expect<Equal<F, string | number>>];
+    const cases: cases = [true];
+  });
+
+  it("AfterFirst<T> with literals", () => {
+    const arr = ["one", "two", 42] as const;
+    type AF = AfterFirst<typeof arr>;
+    type cases = [Expect<Equal<AF, ["two", 42]>>];
+    const cases: cases = [true];
+  });
+  it("AfterFirst<T> with wide types but literal array", () => {
+    const arr = ["one", "two" as string, 42] as const;
+    type AF = AfterFirst<typeof arr>;
+    type cases = [Expect<Equal<AF, [string, 42]>>];
+    const cases: cases = [true];
+  });
+  it("AfterFirst<T> with a non const array", () => {
+    const arr = ["one", "two", 42];
+    type AF = AfterFirst<typeof arr>;
+    type cases = [Expect<Equal<AF, (string | number)[]>>];
+    const cases: cases = [true];
+  });
+});

package/tests/lists/Split.test.ts

@@ -0,0 +1,29 @@
+import { describe, it } from "vitest";
+import type { Expect, Equal } from "@type-challenges/utils";
+import { Split } from "src/types/lists";
+
+describe("Split<T, SEP>", () => {
+  it("Split<T, SEP> with string literals", () => {
+    const str = "hello world, nice to meet you" as const;
+    type S = Split<typeof str, " ">;
+
+    type cases = [Expect<Equal<S, ["hello", "world,", "nice", "to", "meet", "you"]>>];
+    const cases: cases = [true];
+  });
+
+  it("Split<T, SEP> where string and separator are same", () => {
+    const str = "hello world, 42 nice to meet you" as const;
+    type S = Split<typeof str, typeof str>;
+
+    type cases = [Expect<Equal<S, []>>];
+    const cases: cases = [true];
+  });
+
+  it("Split<T, SEP> string is wide type", () => {
+    const str = "hello world, 42 nice to meet you" as string;
+    type S = Split<typeof str, ",">;
+
+    type cases = [Expect<Equal<S, string[]>>];
+    const cases: cases = [true];
+  });
+});

package/tests/lists/asArray.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { asArray } from "src/utility";
+import { asArray } from "src/runtime";
 import { Equal, Expect } from "@type-challenges/utils";
 
 describe("asArray() function", () => {

package/tests/lists/dictArr.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, it } from "vitest";
 import type { Expect, Equal } from "@type-challenges/utils";
-import { dictArr, keys, literal } from "src/utility";
+import { dictArr, keys, literal } from "src/runtime";
 
 type O = {
   id: number;

package/tests/literal-spec.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 
-import { idLiteral, literal } from "../src/utility";
+import { idLiteral, literal } from "../src/runtime";
 import { Equal, NotEqual, Expect, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
 
 describe("literal enforcement", () => {

package/tests/literals/box.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect } from "vitest";
+import { Equal, Expect } from "@type-challenges/utils";
+import { Box, box, BoxedFnParams, BoxValue } from "src/runtime";
+import { First } from "src/types/lists/First";
+
+// [Instantiation Expressions](https://devblogs.microsoft.com/typescript/announcing-typescript-4-7-beta/#instantiation-expressions)
+
+describe("boxing / unboxing", () => {
+  // it("NarrowBox<B,N> utility", () => {
+  //   const fn = <T extends string>(i: T) => `Hello ${i}` as const;
+  //   const b = box(fn);
+  //   const b2 = b.narrow<["foo" | "bar"]>();
+  //   const b3 = b2("foo");
+
+  //   type B = typeof b;
+  // });
+
+  it("box a function with generic", () => {
+    const fn = <T extends string>(i: T) => `Hello ${i}` as const;
+    const b = box(fn);
+    const ub = b.unbox();
+    type UB = typeof ub;
+    const unboxedFn = b.unbox()("foo");
+    const unboxedFn2 = b.unbox()("foo" as string);
+    type UBF = typeof unboxedFn;
+    type UBF2 = typeof unboxedFn2;
+
+    const bn = box(42);
+    type BN = typeof bn;
+    const rn = bn.unbox();
+    type RN = typeof rn;
+    const rn2 = bn.value;
+    type RN2 = typeof rn2;
+
+    type Hybrid = 42 | 56 | typeof fn;
+    const h = box(42 as Hybrid);
+    type H = typeof h;
+    type HV = H["value"];
+
+    // runtime
+    expect(typeof b).toBe("object");
+    expect(typeof ub).toBe("function");
+    expect(unboxedFn).toBe("Hello foo");
+
+    expect(rn).toBe(42);
+    expect(rn2).toBe(42);
+
+    // type tests
+    type B = typeof b;
+    type BV = BoxValue<B>;
+    type BF = First<BoxedFnParams<B>>;
+
+    type cases = [
+      // FUNCTIONS
+      Expect<Equal<B, Box<typeof fn>>>,
+      Expect<Equal<BV, typeof fn>>, //
+      Expect<Equal<BF, string>>,
+      /** unboxing fn results in same fn including generics */
+      Expect<Equal<UB, typeof fn>>,
+      /** generic for fn provides strong literal type after unboxing */
+      Expect<Equal<UBF, "Hello foo">>,
+      /** generic still provides some strong typing when a wide type is passed in */
+      Expect<Equal<UBF2, `Hello ${string}`>>,
+
+      // NUMBER BOXes
+      Expect<Equal<BN, Box<42>>>,
+      /** unboxing preserves numeric literal */
+      Expect<Equal<RN, 42>>,
+      /** can pick off the value prop for same type */
+      Expect<Equal<RN2, 42>>,
+
+      // HYBRID
+      Expect<Equal<HV, Hybrid>>
+    ];
+    const cases: cases = [true, true, true, true, true, true, true, true, true, true];
+  });
+});

package/tests/mapValues-spec.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from "vitest";
 
-import { mapValues, literal } from "../src/utility";
+import { mapValues, literal } from "../src/runtime";
 import type { Expect, Equal, ExpectFalse } from "@type-challenges/utils";
 
 describe("mapValues() utility", () => {

package/tests/runtime/condition.spec.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { condition, isFunction, isTrue } from "src/utility";
+import { condition, isFunction, isTrue } from "src/runtime";
 
 describe("condition() utility", () => {
   it("basic type checks through condition abstraction", () => {