inferred-types 0.36.4 → 0.37.1

package/src/types/string-literals/Trim.ts

@@ -1,15 +0,0 @@
-import { Whitespace } from "../alphabetic";
-
-/**
- * Trims off blank spaces, `\n` and `\t` characters from both sides of a _string literal_.
- * ```ts
- * // "foobar"
- * type T = Trim<"\n\t  foobar ">;
- * // string
- * type T = Trim<string>;
- * ```
- */
-export type Trim<S extends string> = string extends S ? string :
-  S extends `${Whitespace}${infer Right}` ?
-  Trim<Right> : S extends `${infer Left}${Whitespace}` ? Trim<Left> : S;
-

package/src/types/string-literals/TrimLeft.ts

@@ -1,14 +0,0 @@
-import { Whitespace } from "../alphabetic";
-
-/**
- * Trims off whitespace on left of string
- * ```ts
- * // "foobar "
- * type T = TrimLeft<"\n\t  foobar ">;
- * // string
- * type T = TrimLeft<string>;
- * ```
- */
-export type TrimLeft<S extends string> = string extends S ? string :
-  S extends `${Whitespace}${infer Right}` ?
-  TrimLeft<Right> : S;

package/src/types/string-literals/TrimRight.ts

@@ -1,14 +0,0 @@
-import { Whitespace } from "../alphabetic";
-
-/**
- * Trims off whitespace on left of string
- * ```ts
- * // "\n foobar"
- * type T = TrimRight<"\n foobar \t">;
- * // string
- * type T = TrimRight<string>;
- * ```
- */
-export type TrimRight<S extends string> = string extends S ? string :
-  S extends `${infer Right}${Whitespace}` ?
-  TrimRight<Right> : S;

package/src/types/string-literals/form-fields.ts

@@ -1,15 +0,0 @@
-import { NumericString } from "../alphabetic/alpha-characters";
-
-/**
- * An email address
- */
-export type Email = `${string}@${string}.${string}`;
-
-
-type Zip5 = `${NumericString}${NumericString}${string}${NumericString}`;
-type Zip4 = `${NumericString}${string}`;
-
-/**
- * A relatively strong type for Zip5 or Zip5+4 zip codes
- */
-export type ZipCode = Zip5 | `${Zip5}-${Zip4}`;

package/src/types/string-literals/index.ts

@@ -1,21 +0,0 @@
-// #autoindex
-// #region auto-indexed files
-// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
-// hash-code: d0cf1562
-
-// file exports
-export * from "./Break";
-export * from "./Concat";
-export * from "./LeftWhitespace";
-export * from "./Replace";
-export * from "./RightWhitespace";
-export * from "./StringLength";
-export * from "./Trim";
-export * from "./TrimLeft";
-export * from "./TrimRight";
-export * from "./form-fields";
-
-// #endregion auto-indexed files
-
-// see https://github.com/inocan-group/do-devops/docs/autoindex.md
-// for more info

package/src/types/tuples/DictArray.ts

@@ -1,21 +0,0 @@
-/* eslint-disable no-use-before-define */
-export type DictArrayFilterCallback<K extends keyof T, T extends object, R extends true | false> = (key: K, value: Pick<T, K>) => R;
-
-/**
- * An element in a `DictArray` shaped as a two element tuple: `[key, kv]`.
- */
-export type DictArrayKv<K extends keyof T, T> = [K, Pick<T, K>];
-
-export type DictKvTuple<K extends string> = [K, Record<K, unknown>];
-
-/**
- * A an array of `DictArrayKv` tuples which can be reconstructed
- * to a strongly typed dictionary object.
- * ```ts
- * const example: DictArray<{ foo: 1, bar: "hi" }> = [
- *   [ "foo", { foo: 1 }],
- *   [ "bar", { bar: "hi" }]
- * ]
- * ```
- */
-export type DictArray<T> = Array<{ [K in keyof T]: DictArrayKv<K, T> }[keyof T]>;

package/src/types/tuples/FirstKey.ts

@@ -1,10 +0,0 @@
-import { Keys } from "../Keys";
-import { UnionToTuple } from "../type-conversion/UnionToTuple";
-
-/**
- * Returns the _first_ key in an object.
- *
- * **Note:** key order is not guarenteed so typically this is used
- * for a key/value pair where only one key is expected
- */
-export type FirstKey<T extends object> = UnionToTuple<Keys<T>>[0];

package/src/types/tuples/FirstKeyValue.ts

@@ -1,9 +0,0 @@
-import { FirstKey } from "./FirstKey";
-
-/**
- * Utility type which operates on a dictionary and provides the **value** of the
- * `First<T>` key of the dictionary. Because dictionary's don't provide assurances
- * about key order, this is typically only used in cases where it's known there is
- * a single key on the object.
- */
-export type FirstKeyValue<T extends object> = FirstKey<T> extends keyof T ? T[FirstKey<T>] : never;

package/src/types/tuples/FirstOfEach.ts

@@ -1,13 +0,0 @@
-/**
- * For a two-dimensional array, returns a _union type_ which combines the first element of the interior
- * array.
- *
- * ```ts
- * const test = [ ["foo", 1], ["bar", 2] ];
- * // "foo" | "bar"
- * type F = FirstOfEach<typeof test>;
- * ```
- */
-export type FirstOfEach<T extends readonly any[][]> = T[number][0] extends T[number][number]
-  ? T[number][0]
-  : never;

package/src/types/tuples/FromDictArray.ts

@@ -1,14 +0,0 @@
-import { ExpandRecursively } from "../ExpandRecursively";
-import { UnionToIntersection } from "../type-conversion";
-
-/**
- * Typescript utility which receives `T` as shape which resembles `DictArray<D>`
- * and if the type `D` can be inferred it is returned.
- * ```ts
- * // { foo: 1; bar: "hi" }
- * type Dict = FromDictArray<[["foo", { foo: 1 }], ["bar", { bar: "hi" }]]>;
- * ```
- */
-export type FromDictArray<T extends [string, Record<string, unknown>][]> = ExpandRecursively<
-  UnionToIntersection<T[number][1]>
->;

package/src/types/tuples/SecondOfEach.ts

@@ -1,13 +0,0 @@
-
-/**
- * For a two-dimensional array, returns a _union type_ which combines the first element of the interior
- * array.
- * 
- * ```ts
- * // 1 | 2
- * type F = SecondOfEach<[ ["foo", 1], ["bar", 2] ]>;
- * ```
- */
-export type SecondOfEach<T extends any[][]> = T[number][1] extends T[number][number]
-  ? T[number][1]
-  : never;

package/src/types/tuples/index.ts

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

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

@@ -1,9 +0,0 @@
-/**
- * Converts a Tuple type into a _union_ of the tuple elements
- * ```ts
- * const arr = [1, 3, 5] as const;
- * // 1 | 3 | 5
- * type U = TupleToUnion<typeof arr>;
- * ```
- */
-export type TupleToUnion<T> = T extends readonly any[] ? T[number] : never;

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

@@ -1,9 +0,0 @@
-/**
- * UnionToIntersection<{ foo: string } | { bar: string }> =
- *  { foo: string } & { bar: string }.
- */
-export type UnionToIntersection<U> = (
-  U extends unknown ? (arg: U) => 0 : never
-) extends (arg: infer I) => 0
-  ? I
-  : never;

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

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-// https://github.com/type-challenges/type-challenges/issues/737
-
-import { UnionToIntersection } from "./UnionToIntersection";
-
-/**
- * LastInUnion<1 | 2> = 2.
- */
-export type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (
-  x: infer L
-) => 0
-  ? L
-  : never;
-
-/**
- * UnionToTuple<1 | 2> = [1, 2].
- */
-export type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]
-  ? []
-  : [...UnionToTuple<Exclude<U, Last>>, Last];

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

@@ -1,22 +0,0 @@
-import { AnyFunction } from "src/runtime";
-import { TupleToUnion } from "./TupleToUnion";
-
-export type Widen<T> = T extends string
-  ? string
-  : T extends number
-  ? number
-  : T extends boolean
-  ? boolean
-  : T extends readonly string[]
-  ? string[]
-  : T extends readonly number[]
-  ? number[]
-  : T extends readonly boolean[]
-  ? boolean[]
-  : T extends readonly AnyFunction[]
-  ? AnyFunction[]
-  : T extends readonly any[]
-  ? TupleToUnion<T>[]
-  : T extends {}
-  ? {}
-  : T;

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

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

package/src/types/type-testing.ts

@@ -1,14 +0,0 @@
-/**
- * Validates that a given type extends another and returns `true` or `false` type
- */
-export type ExpectExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? true : false;
-
-/**
- * Validates that a given type extends another and returns `any` or `never` as a type
- */
-export type AssertExtends<VALUE, EXPECTED> = EXPECTED extends VALUE ? any : never;
-
-/**
- * Give a type `TValue` and a comparison type `TExtends`
- */
-export type IfExtendsThen<VALUE, EXPECTED, THEN> = EXPECTED extends VALUE ? THEN : never;

package/tests/CamelCase-spec.ts

@@ -1,20 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { CamelCase } from "../src/types";
-import { Expect, Equal } from "@type-challenges/utils";
-
-type camelCase1 = CamelCase<"hello_world_with_types">;
-type camelCase2 = CamelCase<"HELLO_WORLD_WITH_TYPES">;
-type Dash = CamelCase<"hello-world-with-types">;
-
-describe("CamelCase type modifier", () => {
-  it("camel_case is converted to proper CamelCase", () => {
-    type cases = [
-      Expect<Equal<camelCase1, "helloWorldWithTypes">>,
-      Expect<Equal<camelCase2, "helloWorldWithTypes">>,
-      Expect<Equal<Dash, "helloWorldWithTypes">>
-    ];
-    const typeTests: cases = [true, true, true];
-    expect(typeTests).toBe(typeTests);
-  });
-});

package/tests/Configurator-spec.hold

@@ -1,106 +0,0 @@
-/* eslint-disable unicorn/consistent-function-scoping */
-import { Configurator, IConfigurator } from "../src/utility/state/Configurator";
-import { mySong, Playlist, SimpleTable, Song } from "./data";
-
-describe("Configurator => ", () => {
-  it("adding basic types to config works", () => {
-    const c: IConfigurator = Configurator();
-    c.set("foo", 5);
-    c.set("bar", 10);
-    c.set("baz", "no sir, didn't like it");
-
-    const t = c.done();
-
-    expect(t).toHaveProperty("foo", 5);
-    expect(t).toHaveProperty("bar", 10);
-    expect(t).toHaveProperty("baz", "no sir, didn't like it");
-  });
-
-  it("Fluent API is not exposed; set returns name/value pair instead", () => {
-    const c: IConfigurator = Configurator();
-    const v1 = c.set("foo", 5);
-
-    expect(v1).not.toHaveProperty("set");
-    expect(v1).not.toHaveProperty("done");
-    expect(v1).toStrictEqual({ foo: 5 });
-  });
-
-  it("set() function is able to set a simple value and have type retained", () => {
-    const c: IConfigurator = Configurator();
-    c.set("songs", SimpleTable(Song));
-    c.set("playlists", SimpleTable(Playlist));
-    c.set("foo", 15);
-    c.set("bar", 1);
-    const t = c.done();
-    // TODO: get the typeing back to a working state
-    expect((t.songs as any).is(mySong)).toBe(true);
-    expect((t.songs as any).is({ foo: false })).toBe(false);
-    expect(typeof t.songs).toBe("object");
-    expect(typeof t.playlists).toBe("object");
-    expect(typeof t.foo).toBe("number");
-    expect(typeof t.bar).toBe("number");
-  });
-
-  // TODO: get this back to working
-  it.skip("initializing with an interface ensures base types", () => {
-    // type ITest = { foo: number; bar: string };
-    // const c: IConfigurator<ITest> = Configurator();
-    // c.set("foo", 55);
-    // const config = c.done();
-    // expect(config).toHaveProperty("foo", 55);
-    // expect(config).not.toHaveProperty("bar");
-    // expect(config.bar).toBe(undefined);
-  });
-
-  it.skip("initializing with an interface works with more complex types", () => {
-    // type ITest = Record<string, any> & { bar: number };
-    // const c: IConfigurator<ITest> = Configurator<ITest>();
-    // c.set("foo", 55);
-    // c.set("songs", SimpleTable(Song));
-    // const config = c.done();
-    // expect(config.foo).toBe(55);
-    // expect(config).not.toHaveProperty("bar");
-    // expect(config.songs).toHaveProperty("is");
-    // expect(config.songs.select("artist")).toBe("You did it");
-  });
-
-  it("Passing the configurator object to another function preserves typing", () => {
-    const receiver = <T extends Record<string, any>>(obj: T) => {
-      expect(obj).toHaveProperty("songs");
-      expect(obj.songs).toHaveProperty("is");
-      if (obj.songs.is(mySong)) {
-        expect(mySong.artist).toBe("Billy Idol");
-      }
-      expect(obj.songs.select(""));
-    };
-
-    const c: IConfigurator = Configurator();
-    c.set("songs", SimpleTable(Song));
-    const config = c.done();
-
-    receiver(config);
-  });
-
-  it("using remove in API works as expected", () => {
-    const c: IConfigurator = Configurator();
-    c.set("foo", 1);
-    c.set("bar", 2);
-    c.remove("foo");
-    c.set("baz", 3);
-
-    const v = c.done();
-
-    expect(v.bar).toBeDefined();
-    expect(v.baz).toBeDefined();
-    expect((v as any).foo).not.toBeDefined();
-
-    type cases = [
-      // TODO: hovering over "remove" it would look like should work
-      // but it doesn't remove the type currently
-      // Expect<Equal<typeof v, { bar: number; baz: number }>>
-    ];
-
-    const cases: cases = [];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/ExplicitFunction-spec.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { ExplicitFunction } from "../src/runtime";
-import type { Expect, Equal } from "@type-challenges/utils";
-
-describe("ExplicitFunction()", () => {
-  it("empty params function made explicit", () => {
-    const fn = () => 42;
-    type F = typeof fn;
-    const efn = ExplicitFunction(fn);
-    type E = typeof efn;
-
-    type cases = [Expect<Equal<F, E>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("singular param function made explicit", () => {
-    const fn = (n: number) => n;
-    type F = typeof fn;
-    const efn = ExplicitFunction(fn);
-    type E = typeof efn;
-
-    type cases = [Expect<Equal<F, E>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("multiple param function made explicit", () => {
-    const fn = (n: number, greeting: string) => `${greeting} ${n}`;
-    type F = typeof fn;
-    const efn = ExplicitFunction(fn);
-    type E = typeof efn;
-
-    type cases = [Expect<Equal<F, E>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-
-  it("higher order function", () => {
-    const fn = (g: string) => (n: number) => `${g} ${n}`;
-    type F = typeof fn;
-    const efn = ExplicitFunction(fn);
-    type E = typeof efn;
-
-    type cases = [Expect<Equal<F, E>>];
-    const cases: cases = [true];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/IncludeAndRetain-spec.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import { Include, Retain } from "../src/types";
-import { Equal, Expect } from "@type-challenges/utils";
-
-// INCLUDE
-describe("Include<T, U> utility", () => {
-  it(" wide type test", () => {
-    const str = "foo";
-    type Foo = Include<typeof str, string>;
-    type NotFoo = Include<typeof str, number>;
-
-    type cases = [Expect<Equal<Foo, "foo">>, Expect<Equal<NotFoo, never>>];
-    const c: cases = [true, true];
-    expect(c).toBe(c);
-  });
-
-  it("narrow type test", () => {
-    const str = "foo";
-    type Foo = Include<typeof str, "foo">;
-    type NotFoo = Include<typeof str, "bar">;
-    type RelatedFoo = Include<typeof str, string>;
-    type NotLiteralFoo = Include<typeof str, string, true>;
-
-    type cases = [
-      Expect<Equal<Foo, "foo">>,
-      Expect<Equal<NotFoo, never>>,
-      // this is the intended outcome but means
-      // that this utility has an implicit bias
-      // toward wide types; meaning the literal
-      // type is not lost but it does match on "string"
-      Expect<Equal<RelatedFoo, "foo">>,
-      // this behavior is adjusted if you include
-      // the optional `L` generic as a true value
-      Expect<Equal<NotLiteralFoo, never>>
-    ];
-    const c: cases = [true, true, true, true];
-    expect(c).toBe(c);
-  });
-});
-
-// RETAIN
-describe("Retain<T, U> utility", () => {
-  it("base test", () => {
-    const obj = { foo: 1, bar: 2, baz: "hi" };
-    type FooBar = Retain<typeof obj, "foo" | "bar">;
-    type Baz = Retain<typeof obj, "baz">;
-    type FooBaz = Retain<typeof obj, "foo" | "baz">;
-
-    type cases = [
-      Expect<Equal<FooBar, { foo: number; bar: number }>>,
-      Expect<Equal<Baz, { baz: string }>>,
-      Expect<Equal<FooBaz, { foo: number; baz: string }>>
-    ];
-    const c: cases = [true, true, true];
-    expect(c).toBe(c);
-  });
-
-  it("optional params and literals", () => {
-    type Obj = { foo: 1; bar?: number; baz: "hi" };
-    type FooBar = Retain<Obj, "foo" | "bar">;
-
-    type cases = [Expect<Equal<FooBar, { foo: 1; bar?: number }>>];
-    const c: cases = [true];
-    expect(c).toBe(c);
-  });
-});

package/tests/Includes-spec.ts

@@ -1,36 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import type { Includes } from "../src/types";
-import type { Equal, Expect } from "@type-challenges/utils";
-
-describe("Includes type check", () => {
-  it("Includes works on a string source", () => {
-    type T = Includes<"Hello World", "Hello">;
-    type F = Includes<"Hello World", "nada">;
-    type U = Includes<string, "who cares">;
-    type N = Includes<"Hello World", string>;
-    type cases = [
-      Expect<Equal<T, true>>, //
-      Expect<Equal<F, false>>,
-      Expect<Equal<U, boolean>>,
-      Expect<Equal<N, boolean>>
-    ];
-    const typeTests: cases = [true, true, true, true];
-    expect(typeTests).toBe(typeTests);
-  });
-
-  it("Includes works on a string[] source", () => {
-    type T = Includes<["Hello", "World"], "Hello">;
-    type F = Includes<["Hello", "World"], "nada">;
-    type U = Includes<string[], "who cares">;
-    type N = Includes<["Hello", "World"], string>;
-    type cases = [
-      Expect<Equal<T, true>>, //
-      Expect<Equal<F, false>>,
-      Expect<Equal<U, boolean>>,
-      Expect<Equal<N, boolean>>
-    ];
-    const typeTests: cases = [true, true, true, true];
-    expect(typeTests).toBe(typeTests);
-  });
-});

package/tests/KebabCase-spec.ts

@@ -1,21 +0,0 @@
-import { describe, it } from "vitest";
-
-import type { KebabCase } from "../src/types";
-import type { Expect, Equal } from "@type-challenges/utils";
-
-type Pascal = KebabCase<"HelloWorldWithTypes">;
-type Camel = KebabCase<"helloWorldWithTypes">;
-type Snake = KebabCase<"hello_world_with_types">;
-type Dash = KebabCase<"hello-world-with-types">;
-
-describe("KebabCase type modifier", () => {
-  it("other naming conventions are converted to kebab-case", () => {
-    //@ts-ignore
-    type cases = [
-      Expect<Equal<Pascal, "hello-world-with-types">>,
-      Expect<Equal<Camel, "hello-world-with-types">>,
-      Expect<Equal<Snake, "hello-world-with-types">>,
-      Expect<Equal<Dash, "hello-world-with-types">>
-    ];
-  });
-});

package/tests/PascalCase-spec.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect } from "vitest";
-
-import type { PascalCase } from "../src/types";
-import type { Expect, Equal } from "@type-challenges/utils";
-
-type Snake = PascalCase<"hello_world_with_types">;
-type UpperSnake = PascalCase<"HELLO_WORLD_WITH_TYPES">;
-type Camel = PascalCase<"helloWorldWithTypes">;
-type Dash = PascalCase<"hello-world-with-types">;
-
-describe("PascalCase type modifier", () => {
-  it("pascal_case is converted to proper PascalCase", () => {
-    type cases = [
-      Expect<Equal<Snake, "HelloWorldWithTypes">>,
-      Expect<Equal<UpperSnake, "HelloWorldWithTypes">>,
-      Expect<Equal<Camel, "HelloWorldWithTypes">>,
-      Expect<Equal<Dash, "HelloWorldWithTypes">>
-    ];
-    const typeTests: cases = [true, true, true, true];
-    expect(typeTests).toBe(typeTests);
-  });
-});

package/tests/Pluralize-spec.ts

@@ -1,23 +0,0 @@
-import { describe, it } from "vitest";
-
-import type { Pluralize } from "../src/types";
-import type { Expect, Equal } from "@type-challenges/utils";
-
-type Bugs = Pluralize<"bug">;
-type Cases = Pluralize<"case">;
-type Bunnies = Pluralize<"bunny">;
-type Elves = Pluralize<"elf">;
-type People = Pluralize<"person">;
-
-describe("Pluralization of a string literal", () => {
-  it("test strings all converted to plural equivalent", () => {
-    // @ts-ignore
-    type cases = [
-      Expect<Equal<Bugs, "bugs">>,
-      Expect<Equal<Cases, "cases">>,
-      Expect<Equal<Bunnies, "bunnies">>,
-      Expect<Equal<Elves, "elves">>,
-      Expect<Equal<People, "people">>
-    ];
-  });
-});

package/tests/SnakeCase-spec.ts

@@ -1,21 +0,0 @@
-import { describe, it } from "vitest";
-
-import { SnakeCase } from "../src/types";
-import { Expect, Equal } from "@type-challenges/utils";
-
-type Pascal = SnakeCase<"HelloWorldWithTypes">;
-type Camel = SnakeCase<"helloWorldWithTypes">;
-type Snake = SnakeCase<"hello_world_with_types">;
-type Dash = SnakeCase<"hello-world-with-types">;
-
-describe("SnakeCase type modifier", () => {
-  it("other naming conventions are converted to kebab-case", () => {
-    //@ts-ignore
-    type cases = [
-      Expect<Equal<Pascal, "hello_world_with_types">>,
-      Expect<Equal<Camel, "hello_world_with_types">>,
-      Expect<Equal<Snake, "hello_world_with_types">>,
-      Expect<Equal<Dash, "hello_world_with_types">>
-    ];
-  });
-});