inferred-types 0.35.0 → 0.36.0

package/tests/literals/PathJoin.test.ts

@@ -13,6 +13,8 @@ describe("PathJoin<T,U>", () => {
     type T2 = PathJoin<"foo/", "bar">;
     type T3 = PathJoin<"foo", "/bar">;
     type T4 = PathJoin<"foo/", "/bar">;
+    type T5 = PathJoin<"/foo/", "/bar">;
+    type T6 = PathJoin<"foo/", "/bar/">;
 
     type cases = [
       // neither have divider
@@ -21,9 +23,27 @@ describe("PathJoin<T,U>", () => {
       Expect<Equal<T2, "foo/bar">>,
       Expect<Equal<T3, "foo/bar">>,
       // both have
-      Expect<Equal<T4, "foo/bar">>
+      Expect<Equal<T4, "foo/bar">>,
+      // leading slash
+      Expect<Equal<T5, "/foo/bar">>,
+      // trailing slash
+      Expect<Equal<T6, "foo/bar/">>
     ];
-    const cases: cases = [true, true, true, true];
+    const cases: cases = [true, true, true, true, true, true];
+  });
+
+  it("PathJoin<T,U> with U as array", () => {
+    type T1 = PathJoin<"foo", ["bar", "baz"]>;
+    type T2 = PathJoin<"/foo/", ["/bar/", "/baz/"]>;
+    type T3 = PathJoin<"/foo/", ["bar", "/baz"]>;
+
+    type cases = [
+      //
+      Expect<Equal<T1, "foo/bar/baz">>,
+      Expect<Equal<T2, "/foo/bar/baz/">>,
+      Expect<Equal<T3, "/foo/bar/baz">>
+    ];
+    const cases: cases = [true, true, true];
   });
 
   it("wide types mixed in", () => {
@@ -43,45 +63,32 @@ describe("PathJoin<T,U>", () => {
 });
 
 describe("pathJoin() runtime util", () => {
-  it("happy path", () => {
-    const t1 = pathJoin("foo", "bar" as string);
-    const t2 = pathJoin("foo/", "bar" as string);
-    const t3 = pathJoin("foo" as string, "/bar");
-    const t4 = pathJoin("foo/" as string, "/bar");
-    const t5 = pathJoin("foo/" as string, "bar");
-
-    // runtime tests
-    [t1, t2, t3, t4].forEach((test) => expect(test).toBe("foo/bar"));
-
-    // type tests
-    type cases = [
-      Expect<Equal<typeof t1, `foo/${string}`>>,
-      Expect<Equal<typeof t2, `foo/${string}`>>,
-      Expect<Equal<typeof t3, `${string}/bar`>>,
-      Expect<Equal<typeof t4, `${string}/bar`>>,
-      Expect<Equal<typeof t5, `${string}bar`>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-  });
-
-  it("with wide types", () => {
+  it("no leading or trailing slashes", () => {
     const t1 = pathJoin("foo", "bar");
     const t2 = pathJoin("foo/", "bar");
     const t3 = pathJoin("foo", "/bar");
     const t4 = pathJoin("foo/", "/bar");
-    // runtime tests
-    [t1, t2, t3, t4].forEach((test) => expect(test, "runtime failure").toBe("foo/bar"));
+    // multi
+    const t5 = pathJoin("foo/", "bar", "/baz");
+    const t6 = pathJoin("foo/", "bar/", "/baz");
 
-    // type tests
-    type cases = [
-      // neither have divider
-      Expect<Equal<typeof t1, "foo/bar">>,
-      // one has, one does not
-      Expect<Equal<typeof t2, "foo/bar">>,
-      Expect<Equal<typeof t3, "foo/bar">>,
-      // both have
-      Expect<Equal<typeof t4, "foo/bar">>
-    ];
-    const cases: cases = [true, true, true, true];
+    [t1, t2, t3, t4].forEach((test) =>
+      expect(test, "no leading or trailing slash").toBe("foo/bar")
+    );
+    [t5, t6].forEach((test) =>
+      expect(test, "no leading or trailing slash (with multi U)").toBe("foo/bar/baz")
+    );
+  });
+
+  it("leading and trailing slashes", () => {
+    const t1 = pathJoin("/foo", "bar");
+    const t2 = pathJoin("foo/", "bar/");
+    const t3 = pathJoin("/foo", "bar", "/baz");
+    const t4 = pathJoin("foo/", "/bar/", "/baz/");
+    // runtime tests
+    expect(t1).toBe("/foo/bar");
+    expect(t2).toBe("foo/bar/");
+    expect(t3).toBe("/foo/bar/baz");
+    expect(t4).toBe("foo/bar/baz/");
   });
 });

package/tests/literals/box.test.ts

@@ -1,29 +1,23 @@
 import { describe, it, expect } from "vitest";
 import { Equal, Expect } from "@type-challenges/utils";
-import { Box, box, BoxedFnParams, BoxValue } from "src/runtime";
+import { Box, box, BoxedFnParams, BoxValue, unbox } 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;
-  // });
+// this exercise was started around the time that Instantiation expressions
+// were first introduced and with the hope that this would help narrow functions
+// which have an inner generic that provides narrow typing.
 
+describe("boxing / unboxing", () => {
   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 globalUnbox = unbox(b);
+    type UB = typeof globalUnbox;
+    const usingValue = b.value("foo");
+    const unboxedNarrow = b.unbox("foo");
+    const unboxedWide = b.unbox("foo" as string);
 
     const bn = box(42);
     type BN = typeof bn;
@@ -39,8 +33,13 @@ describe("boxing / unboxing", () => {
 
     // runtime
     expect(typeof b).toBe("object");
-    expect(typeof ub).toBe("function");
-    expect(unboxedFn).toBe("Hello foo");
+    expect(
+      typeof globalUnbox,
+      `using unbox(fn) should have returned function: ${globalUnbox}`
+    ).toBe("function");
+    expect(usingValue).toBe("Hello foo");
+    expect(unboxedNarrow).toBe("Hello foo");
+    expect(unboxedWide).toBe("Hello foo");
 
     expect(rn).toBe(42);
     expect(rn2).toBe(42);
@@ -57,10 +56,19 @@ describe("boxing / unboxing", () => {
       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}`>>,
+      /** this uses the VALUE prop and provides the TARGET resolution for unbox */
+      Expect<Equal<typeof usingValue, "Hello foo">>,
+      /**
+       * using the passthrough feature of `b.unbox(val)` we would ideally like to
+       * get same narrow type as test above but it is reduced to an "ok" level for
+       * now
+       */
+      Expect<Equal<typeof unboxedNarrow, `Hello ${string}`>>,
+      /**
+       * Note, however, that the wide value of string passed in resolves in the same
+       * manner which helps to point to where resolution is being lost
+       */
+      Expect<Equal<typeof unboxedWide, `Hello ${string}`>>,
 
       // NUMBER BOXes
       Expect<Equal<BN, Box<42>>>,
@@ -72,6 +80,6 @@ describe("boxing / unboxing", () => {
       // HYBRID
       Expect<Equal<HV, Hybrid>>
     ];
-    const cases: cases = [true, true, true, true, true, true, true, true, true, true];
+    const cases: cases = [true, true, true, true, true, true, true, true, true, true, true];
   });
 });

package/tests/runtime/if-is.spec.ts

@@ -6,6 +6,7 @@ import {
   ifArrayPartial,
   ifBoolean,
   ifNumber,
+  ifSameType,
   ifString,
   ifTrue,
   ifUndefined,
@@ -13,13 +14,13 @@ import {
 } from "src/runtime/type-checks";
 import { EndsWith, Extends, LowerAlpha, Or, StartsWith } from "src/types";
 import { ifStartsWith, startsWith } from "src/runtime/type-checks/startsWith";
-import { box } from "src/runtime/literals";
+import { box, wide } from "src/runtime/literals";
 import { or } from "src/runtime";
 
 describe("runtime if/is", () => {
   it("ifString(v,i,e)", () => {
-    const t = ifString("foo", 42, false);
-    const f = ifString(-1, "yikes", 42);
+    const t = ifString("foo", () => 42, false);
+    const f = ifString(-1, () => "yikes", 42);
 
     type cases = [
       Expect<Equal<typeof t, 42>>, //
@@ -67,10 +68,10 @@ describe("runtime if/is", () => {
     const f1 = box(<T extends string>(input: T) => `Hello ${input}` as const);
     const f2 = box(<T extends string>(input: T) => `Get out ${input}!` as const);
     const t = <T extends string, B extends boolean>(i: T, nice: B) => {
-      return isTrue(nice) ? f1.unbox()(i) : f2.unbox()(i);
+      return isTrue(nice) ? f1.value(i) : f2.value(i);
     };
     const t2 = <T extends string, B extends boolean>(i: T, nice: B) =>
-      ifTrue(nice, f1.unbox()(i), f2.unbox()(i));
+      ifTrue(nice, f1.value(i), f2.value(i));
 
     // both approaches produce correct result
     const r1 = t("Joe", true);
@@ -326,4 +327,64 @@ describe("runtime if/is", () => {
     ];
     const cases: cases = [true, true, true];
   });
+
+  it("ifSameType", () => {
+    const t1 = ifSameType(
+      "foo",
+      wide.string,
+      (i) => `Hello ${i}`,
+      (i) => `Goodbye ${i}`
+    );
+    const t2 = ifSameType(
+      42,
+      wide.string,
+      (i) => `Hello ${i}`,
+      (i) => `Goodbye ${i}`
+    );
+    const t3 = ifSameType(
+      "foo" as string,
+      wide.string,
+      (i) => `Hello ${i}`,
+      (i) => `Goodbye ${i}`
+    );
+    const t4 = ifSameType(
+      42 as number,
+      wide.string,
+      (i) => `Hello ${i}`,
+      (i) => `Goodbye ${i}`
+    );
+
+    const nested = ifSameType(
+      false,
+      wide.string,
+      (i) => `Hello ${i}`,
+      (i) =>
+        ifSameType(
+          i,
+          wide.number,
+          (n) => n,
+          (i) =>
+            ifSameType(
+              i,
+              wide.boolean,
+              (b) => `I'm a boolean value of ${b}`,
+              () => ""
+            )
+        )
+    );
+
+    type cases = [
+      // matches (narrow)
+      Expect<Equal<typeof t1, "Hello foo">>,
+      // does not match (narrow)
+      Expect<Equal<typeof t2, `Goodbye 42`>>,
+      // matches (wide)
+      Expect<Equal<typeof t3, `Hello ${string}`>>,
+      // does not match (wide)
+      Expect<Equal<typeof t4, `Goodbye ${number}`>>,
+      // nested
+      Expect<Equal<typeof nested, `I'm a boolean value of false`>>
+    ];
+    const cases: cases = [true, true, true, true, true];
+  });
 });

package/tests/runtime/map-and-convert.test.ts

@@ -0,0 +1,31 @@
+import { Equal, Expect } from "@type-challenges/utils";
+import { createConverter } from "src/runtime/lists/createConverter";
+import { describe, it, expect } from "vitest";
+
+// Note: while type tests fail visible inspection they pass from Vitest
+// standpoint so always be sure to run `tsc --noEmit` over your test files to
+// gain validation that no new type vulnerabilities have cropped up.
+
+describe("createConverter()", () => {
+  it("basic converter setup", () => {
+    const convert = createConverter({
+      string: (s) => `Hello ${s}`,
+      number: (n) => `The number was ${n}`,
+      object: (o) => `An object with keys ${Object.keys(o).join(", ")}`,
+    });
+
+    const t1 = convert("foo");
+    const t2 = convert(42);
+    const t3 = convert({ foo: 42, bar: 12 });
+    expect(t1).toBe("Hello foo");
+    expect(t2).toBe("The number was 42");
+
+    type cases = [
+      // TODO: get the final narrowness resolved ... this should be doable
+      Expect<Equal<typeof t1, `Hello ${string}`>>,
+      Expect<Equal<typeof t2, `The number was ${number}`>>,
+      Expect<Equal<typeof t3, `An object with keys ${string}`>>
+    ];
+    const cases: cases = [true, true, true];
+  });
+});