inferred-types 0.24.3 → 0.26.0

package/tests/lists/asArray.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect } from "vitest";
+import { asArray } from "src/utility";
+import { Equal, Expect } from "@type-challenges/utils";
+
+describe("asArray() function", () => {
+  it("non-array is returned as an array", () => {
+    const i = "a";
+    const o = asArray(i);
+    type O = typeof o;
+
+    // run-time
+    expect(o).toEqual(["a"]);
+    // design-time
+    type cases = [Expect<Equal<O, string[]>>];
+    const cases: cases = [true];
+  });
+
+  it("array is returned as an array", () => {
+    const i = ["a"];
+    const o = asArray(i);
+    type O = typeof o;
+
+    // run-time
+    expect(o).toEqual(["a"]);
+    // design-time
+    type cases = [Expect<Equal<O, string[]>>];
+    const cases: cases = [true];
+  });
+
+  it("non-array literal is returned as an array", () => {
+    const i = "a" as const;
+    const o = asArray(i, false);
+    const o2 = asArray(i, true);
+
+    type O = typeof o;
+    type O2 = typeof o2;
+
+    // run-time
+    expect(o).toEqual(["a"]);
+    // design-time
+    type cases = [
+      Expect<Equal<O, "a"[]>>, //
+      Expect<Equal<O2, string[]>>
+    ];
+    const cases: cases = [true, true];
+  });
+
+  it("handling non-array element which presents as undefined", () => {
+    type T = string | undefined;
+    const i = undefined;
+    const i2: T = undefined;
+    const o = asArray(i);
+    const o2 = asArray(i2 as T);
+    const o3 = asArray(i2 as T, false);
+    type O = typeof o;
+    type O2 = typeof o2;
+    type O3 = typeof o3;
+
+    // run-time
+    expect(o).toEqual([]);
+    expect(o2).toEqual([]);
+    // design-time
+    type cases = [
+      Expect<Equal<O, unknown[]>>, //
+      // TODO: would be nice to extract the unknown[] part of the union
+      Expect<Equal<O2, unknown[] | string[]>>,
+      Expect<Equal<O3, unknown[] | string[]>>
+    ];
+    const cases: cases = [true, true, true];
+  });
+
+  it("handling array element which contains undefined is unaffected", () => {
+    type T = string | undefined;
+    const i = [undefined, "foobar"];
+    const i2: T[] = [undefined, "foobar"];
+    const o = asArray(i);
+    const o2 = asArray(i2 as T[]);
+    type O = typeof o;
+    type O2 = typeof o2;
+
+    // run-time
+    expect(o).toEqual([undefined, "foobar"]);
+    expect(o2).toEqual([undefined, "foobar"]);
+    // design-time
+    type cases = [
+      Expect<Equal<O, (string | undefined)[]>>, //
+      Expect<Equal<O2, T[]>>
+    ];
+    const cases: cases = [true, true];
+  });
+});

package/tsconfig.json

@@ -16,6 +16,14 @@
     "lib": [
       "ES2020"
     ],
+    "paths": {
+      "src/*": [
+        "src/*"
+      ],
+      "test/*": [
+        "test/*"
+      ]
+    },
     "baseUrl": ".",
     "declaration": true,
     "outDir": "dist",

package/vitest.config.ts

@@ -1,8 +1,15 @@
 /// <reference types="vitest" />
 import { defineConfig } from "vite";
+import { resolve } from "pathe";
 
 // used for testing, library code uses TSUP to build exports
 export default defineConfig({
+  resolve: {
+    alias: {
+      src: resolve(__dirname, "./src"),
+      test: resolve(__dirname, "./test"),
+    },
+  },
   test: {
     dir: "tests",
     api: {

package/src/types/Includes.ts

@@ -1,5 +0,0 @@
-/**
- * A type takes the two arguments. The first is an array of string values, the second is the value
- * which is being tested as it whether or not it's _included_ in the array. Result is true or false.
- */
-export type Includes<T extends readonly any[], U> = U extends T[number] ? true : false;

package/src/utility/map-reduce/filter.ts

@@ -1,35 +0,0 @@
-// inspired by [article](https://medium.com/@reidev275/creating-a-type-safe-dsl-for-filtering-in-typescript-53fe68a7942e)]
-
-
-export type Filter<A> =
-  | { kind: "Equals"; field: keyof A; val: A[keyof A] }
-  | { kind: "Greater"; field: keyof A; val: A[keyof A] }
-  | { kind: "Less"; field: keyof A; val: A[keyof A] }
-  | { kind: "And"; a: Filter<A>; b: Filter<A> }
-  | { kind: "Or"; a: Filter<A>; b: Filter<A> };
-
-export const equals = <A, K extends keyof A>(field: K, val: A[K]): Filter<A> => ({
-  kind: "Equals",
-  field,
-  val
-});
-export const greater = <A, K extends keyof A>(field: K, val: A[K]): Filter<A> => ({
-  kind: "Greater",
-  field,
-  val
-});
-export const less = <A, K extends keyof A>(field: K, val: A[K]): Filter<A> => ({
-  kind: "Less",
-  field,
-  val
-});
-export const and = <A>(a: Filter<A>, b: Filter<A>): Filter<A> => ({
-  kind: "And",
-  a,
-  b
-});
-export const or = <A>(a: Filter<A>, b: Filter<A>): Filter<A> => ({
-  kind: "Or",
-  a,
-  b
-});

package/src/utility/map-reduce/index.ts

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