inferred-types 0.33.0 → 0.33.2

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

@@ -1,7 +1,17 @@
-import { describe, it } from "vitest";
+import { describe, expect, it } from "vitest";
 
 import type { Expect, Equal } from "@type-challenges/utils";
-import { ifBoolean, ifNumber, ifString, ifTrue, ifUndefined } from "src/utility";
+import {
+  ifBoolean,
+  ifNumber,
+  ifString,
+  ifTrue,
+  ifUndefined,
+  isTrue,
+} from "src/runtime/type-checks";
+import { EndsWith, StartsWith } from "src/types";
+import { ifStartsWith, startsWith } from "src/runtime/type-checks/startsWith";
+import { box } from "src/runtime/literals";
 
 describe("runtime if/is", () => {
   it("ifString(v,i,e)", () => {
@@ -50,6 +60,61 @@ describe("runtime if/is", () => {
     const cases: cases = [true, true, true];
   });
 
+  it("ifTrue(v,i,e) with boxed functions", () => {
+    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);
+    };
+    const t2 = <T extends string, B extends boolean>(i: T, nice: B) =>
+      ifTrue(nice, f1.unbox()(i), f2.unbox()(i));
+
+    // both approaches produce correct result
+    const r1 = t("Joe", true);
+    const r2 = t2("Joe", true);
+    expect(r1).toBe("Hello Joe");
+    expect(r2).toBe("Hello Joe");
+
+    // only the "ifTrue" approach resolves fully at design time
+    type R1 = typeof r1;
+    type R2 = typeof r2;
+
+    type cases = [
+      // still get union type with `isTrue` conditional
+      Expect<Equal<R1, "Hello Joe" | "Get out Joe!">>,
+      // but encapsulating both outcomes in `ifTrue` resolves the union
+      Expect<Equal<R2, "Hello Joe">>
+    ];
+    const cases: cases = [true, true];
+  });
+
+  it("ifTrue(v,i,e) with string literal functions", () => {
+    const f1 = <T extends string>(input: T) => `Hello ${input}` as const;
+    const f2 = <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(i) : f2(i);
+    };
+    const t2 = <T extends string, B extends boolean>(i: T, nice: B) => ifTrue(nice, f1(i), f2(i));
+
+    // both approaches produce correct result
+    const r1 = t("Joe", true);
+    const r2 = t2("Joe", true);
+    expect(r1).toBe("Hello Joe");
+    expect(r2).toBe("Hello Joe");
+
+    // only the "ifTrue" approach resolves fully at design time
+    type R1 = typeof r1;
+    type R2 = typeof r2;
+
+    type cases = [
+      // still get union type with `isTrue` conditional
+      Expect<Equal<R1, "Hello Joe" | "Get out Joe!">>,
+      // but encapsulating both outcomes in `ifTrue` resolves the union
+      Expect<Equal<R2, "Hello Joe">>
+    ];
+    const cases: cases = [true, true];
+  });
+
   it("ifUndefined(v,i,e)", () => {
     const t = ifUndefined(undefined, 42, false);
     const f = ifUndefined(false, "yikes", 42);
@@ -62,4 +127,95 @@ describe("runtime if/is", () => {
     ];
     const cases: cases = [true, true, true];
   });
+
+  it("StartsWith<T,U>", () => {
+    type T1 = StartsWith<"foobar", "foo">;
+    type T2 = StartsWith<"foobar", "foot">;
+    type T3 = StartsWith<"foobar", string>;
+    type T4 = StartsWith<string, "foo">;
+    type T5 = StartsWith<string, string>;
+
+    type cases = [
+      Expect<Equal<T1, true>>, //
+      Expect<Equal<T2, false>>,
+      Expect<Equal<T3, boolean>>,
+      Expect<Equal<T4, boolean>>,
+      Expect<Equal<T5, boolean>>
+    ];
+    const cases: cases = [true, true, true, true, true];
+  });
+
+  it("EndsWith<T,U>", () => {
+    type T1 = EndsWith<"foobar", "bar">;
+    type T2 = EndsWith<"foobar", "bart">;
+    type T3 = EndsWith<"foobar", string>;
+    type T4 = EndsWith<string, "bar">;
+    type T5 = EndsWith<string, string>;
+
+    type cases = [
+      Expect<Equal<T1, true>>, //
+      Expect<Equal<T2, false>>,
+      Expect<Equal<T3, boolean>>,
+      Expect<Equal<T4, boolean>>,
+      Expect<Equal<T5, boolean>>
+    ];
+    const cases: cases = [true, true, true, true, true];
+  });
+
+  it("startsWith(t)(v)", () => {
+    const t1 = startsWith("foo")("foobar");
+    const t2 = startsWith("foot")("foobar");
+    const p1 = startsWith("foo");
+
+    // runtime
+    expect(t1).toBe(true);
+    expect(t2).toBe(false);
+    expect(p1("foot")).toBe(true);
+    expect(p1("bart")).toBe(false);
+
+    // design time
+    type cases = [
+      Expect<Equal<typeof t1, true>>, //
+      Expect<Equal<typeof t2, false>> //
+    ];
+    const cases: cases = [true, true];
+  });
+
+  it("ifStartsWith(start, isTrue, isFalse)(v)", () => {
+    const noSir = <T extends string>(i: T) => `no sir didn't like it ${i}` as const;
+    const startWithFoo = ifStartsWith(
+      // condition
+      "foo",
+      // inline
+      (i) => `welcome ${i}` as const,
+      // external
+      noSir
+    );
+    const t = startWithFoo("foobar");
+    type T = typeof t;
+    const f = startWithFoo("nope");
+    type F = typeof f;
+
+    type FS = typeof startWithFoo;
+    type RFS = ReturnType<FS>;
+
+    // runtime
+    expect(t).toBe("welcome foobar");
+    expect(f).toBe("no sir didn't like it nope");
+
+    // TODO: get the design time to be more literal
+
+    type cases = [
+      Expect<Equal<T, `welcome ${string}`>>,
+      Expect<Equal<F, `no sir didn't like it ${string}`>>,
+      Expect<
+        Equal<
+          //
+          RFS,
+          `welcome ${string}` | `no sir didn't like it ${string}`
+        >
+      >
+    ];
+    const cases: cases = [true, true, true];
+  });
 });

package/tests/runtime/type.spec.ts

@@ -2,7 +2,7 @@ import { describe, it, expect } from "vitest";
 
 import type { Expect, Equal } from "@type-challenges/utils";
 import { FunctionType } from "src/types";
-import { type, createFnWithProps, isFunction, isObject } from "src/utility";
+import { type, createFnWithProps, isFunction, isObject } from "src/runtime";
 
 describe("testing type() utility and some pre-made conditions", () => {
   it("isFunction()", () => {

package/tests/strArrayToDict-spec.ts

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

package/tests/withValue.spec.ts

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

package/vitest.config.ts

@@ -6,15 +6,12 @@ import { resolve } from "pathe";
 export default defineConfig({
   resolve: {
     alias: {
-      src: resolve(__dirname, "./src"),
-      test: resolve(__dirname, "./test"),
+      src: resolve(__dirname, "./src/"),
+      test: resolve(__dirname, "./test/"),
     },
   },
   test: {
     dir: "tests",
-    api: {
-      host: "0.0.0.0",
-    },
   },
   plugins: [],
 });

package/src/Mutation/MutationFunction.ts

@@ -1,26 +0,0 @@
-/* eslint-disable no-use-before-define */
-
-import { MutationIdentity } from "./MutationIdentity";
-
-export type MutationFunction<T extends any, P extends any[]> = (...args: P) => T;
-// export type MutationApi<A extends object, MutationFunction<T,P>> = {[key: U in A]: MutationFunction<T,P>}
-// export type MutationApi<T extends any, K extends string & keyof A, A extends { [key: K]:  MutationFunction<T,P>} =
-
-/**
- * **MutationFunction**
- *
- * Given a `MutationIdentity` higher-order function to work with, _this_ higher order expression
- * allows you to specify the structure of "state" `T` with the first function call; the
- * remaining function then serves as a strongly typed way to do partial application and get
- * back just the _mutation function_ responsible for changing the state. The mutation function
- * will take the form of:
- *
- * ```ts
- * const fn: (...args: P) => T = MutationFunction<T>()(mutationIdentity);
- * ```
- */
-export function createMutationFunction<T extends any>(state: T) {
-  return <M extends MutationIdentity<T, P>, P extends any[]>(mutationIdentity: M) => {
-    return mutationIdentity(state);
-  };
-}

package/src/Mutation/MutationIdentity.ts

@@ -1,36 +0,0 @@
-/* eslint-disable no-use-before-define */
-/**
- * **MutationIdentity**
- *
- * Defines a function which is passed a state `T` and returns a function with
- * an arbitrary -- but strongly typed -- set of parameters `P` which _must_ return
- * the same state `T` back.
- *
- * This allows `T` to be mutated by a relatively unconstrained set of mutation functions with the
- * sole guarentee that the form `T` is preserved.
- */
-export type MutationIdentity<T, P extends any[]> = (state: T) => (...args: P) => T;
-
-/**
- * **MutationIdentity**
- *
- * A function which strongly types the construction of a `MutationIdentity`
- * higher-order function to be built. Usage:
- *
- * - The structure of the _state_ is defined in the first call as `T`
- * - The interior function than defines a mutation function which implicitly
- * defines the calling signature as `P` but is required to return the identity state
- * structure `T`.
- *
- * ```ts
- * type State = { foo: number, bar: number };
- * const incr = MutationIdentity<State>()(
- *    s => () => {...s, foo: s.foo++}
- * );
- * ```
- */
-export function MutationIdentity<T>() {
-  return function <M extends MutationIdentity<T, P>, P extends any[]>(m: M) {
-    return m;
-  };
-}

package/src/Mutation/index.ts

@@ -1,14 +0,0 @@
-// #autoindex
-
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: bd3a442e
-
-// file exports
-export * from "./MutationFunction";
-export * from "./MutationIdentity";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/shared/README.md

@@ -1,3 +0,0 @@
-# Shared
-
-Files which are _not_ directly exported as symbols but rather indirectly leveraged by other code.

package/src/shared/index.ts

@@ -1,15 +0,0 @@
-// #autoindex: orphan
-
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: 3305143b
-
-// file exports
-export * from "./randomString";
-export * from "./uuid";
-export * from "./valueTypes";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/shared/randomString.ts

@@ -1,5 +0,0 @@
-export function randomString() {
-  return Math.trunc((1 + Math.random()) * 0x1_00_00)
-    .toString(16)
-    .slice(1);
-}

package/src/shared/uuid.ts

@@ -1,5 +0,0 @@
-import { randomString } from "./randomString";
-
-export function uuid() {
-  return `${randomString()}${randomString()}-${randomString()}-${randomString()}-${randomString()}-${randomString()}-${randomString()}${randomString()}${randomString()}`;
-}

package/src/types/First.ts

@@ -1,4 +0,0 @@
-/**
- * Returns the first values type in an array of values
- */
-export type First<T extends any[]> = T[0] extends T[number] ? T[0] : never;

package/src/utility/modelling/index.ts

@@ -1,12 +0,0 @@
-// #autoindex, exclude: IoModel
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: db68628c
-
-// file exports
-export * from "./Model";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/tests/MutationIdentity-spec.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { MutationIdentity } from "../src/Mutation";
-import type { Expect, Equal, ExpectExtends } from "@type-challenges/utils";
-
-describe("MutationIdentity type", () => {
-  it("MutationIdentity provides properly typed higher-order function", () => {
-    type State = { foo: number; bar: number };
-    const t1 = MutationIdentity<State>()((s) => () => s);
-    const t2 = MutationIdentity<State>()((s) => (foo: number) => ({
-      ...s,
-      foo,
-    }));
-
-    type cases = [
-      Expect<ExpectExtends<MutationIdentity<State, any>, typeof t1>>,
-      Expect<ExpectExtends<MutationIdentity<State, any>, typeof t2>>,
-      Expect<Equal<MutationIdentity<State, []>, typeof t1>>,
-      Expect<Equal<MutationIdentity<State, [number]>, typeof t2>>
-    ];
-
-    const expected: cases = [true, true, true, true];
-    expect(expected).toBe(expected);
-  });
-});