inferred-types 0.19.0 → 0.22.0

package/on-hold/tests/api-spec.ts

@@ -1,73 +0,0 @@
-import { Equal, Expect } from "@type-challenges/utils";
-import { Api, PrivateKeys, PublicKeys } from "~/types";
-import { defineType } from "~/utility";
-import { api } from "~/utility/api/api";
-
-describe("Api<T> type", () => {
-  it("PublicKeys<T> and PrivateKeys<T> type utils extract the right keys", () => {
-    const api = {
-      _state: 123,
-      _name: "hey ho",
-      greet: "hi",
-      age: 12,
-    };
-
-    const f = string;
-
-    type Test = typeof api;
-    type Private = PrivateKeys<Test>;
-    type Public = PublicKeys<Test>;
-
-    type cases = [
-      Expect<Equal<Private, "_state" | "_name">>,
-      Expect<Equal<Public, "greet" | "age">>
-    ];
-    const cases: cases = [true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it.skip("privateApi() creates a definition for a private API", () => {
-    const food = api({ _model: "food", _description: "let's eat" })({
-      category: string,
-      stars: 5 as number,
-    });
-    const pub = food();
-  });
-
-  it("The Api<T> utility hides all private keys while preserving type info", () => {
-    const simple = {
-      _state: 123,
-      _name: "hey ho",
-      greet: "hi",
-      age: 12,
-    };
-    type Simple = Api<typeof simple>;
-
-    const midling = defineType({ id: 123 })({
-      _state: 123,
-      _name: "hey ho",
-      greet: "hi",
-      age: 12,
-    });
-    type Midling = Api<typeof midling>;
-
-    const advanced = defineType({ id: 123, _exclude: ["greet"] })({ greet: "hi", age: 12 });
-    type Advanced = Api<typeof advanced>;
-
-    type cases = [
-      // a simple API with no literals doesn't need generics
-      // to preserve state
-      Expect<Equal<Simple, { greet: string; age: number }>>,
-      // if the public interface has type literals this is
-      // accommodated without any special effort
-      Expect<Equal<Midling, { greet: string; age: number; id: 123 }>>,
-      Expect<Equal<Midling, { greet: string; age: number; id: 123 }>>
-      // in the situation where the private members have
-      // literals that need preservation, we need be assured
-      // the API implementation can preserve this strong typing
-      // However, to start the public API is quite easily preserved
-    ];
-    const cases: cases = [true, true];
-    expect(cases).toBe(cases);
-  });
-});

package/on-hold/tests/data/builder-data.ts

@@ -1,53 +0,0 @@
-import { Builder, BuilderApi } from "~/Builder";
-import { isNonNullObject } from "common-types";
-import { TypeGuard } from "~/types";
-
-
-export type BuilderState = { foo: number; bar: number; baz?: string };
-
-const endpoint = BuilderApi<BuilderState>();
-const f0 = endpoint("setFoo", (s) => (n: number) => ({
-  ...s,
-  foo: n,
-}));
-
-const f1 = endpoint("incFoo", (s) => () => ({
-  ...s,
-  foo: s.foo !== undefined ? s.foo + 1 : 1,
-}));
-const f2 = endpoint("decFoo", (s) => () => ({
-  ...s,
-  foo: s.foo !== undefined ? s.foo - 1 : 0,
-}));
-const f3 = endpoint("setBar", (s) => (n: number) => ({
-  ...s,
-  bar: n,
-}));
-const f4 = endpoint("incBar", (s) => () => ({
-  ...s,
-  bar: s.bar !== undefined ? s.bar + 1 : 1,
-}));
-const f5 = endpoint("setBaz", (s) => (m: string) => ({
-  ...s,
-  baz: m,
-}));
-
-const tg: TypeGuard<BuilderState> = (input: unknown): input is BuilderState => {
-  return (
-    isNonNullObject(input) &&
-    typeof (input as BuilderState).foo === "number" &&
-    typeof (input as BuilderState).bar === "number"
-  );
-};
-
-/**
- * Creates a builder initialized to the state passed in.
- * This builder has foo, bar, and optionally a baz property
- */
-export function createBuilder<T extends Partial<BuilderState>>(s: T) {
-  return Builder(tg, { ...f0, ...f1, ...f2, ...f3, ...f4, ...f5 })(s);
-}
-
-export function createStateIdentityApi() {
-  return { ...f0, ...f1, ...f2, ...f3, ...f4, ...f5 };
-}

package/on-hold/tests/filterDictArray-spec.ts

@@ -1,50 +0,0 @@
-import { defineType, dictToArray, filterDictArray } from "~/utility";
-
-describe("filterDictArray()", () => {
-
-  it("an object converted into a DictArray can be filter down to a subset", () => {
-    const obj = defineType({ id: 123 })({ color: "red", favorite: true });
-
-    const arr = dictToArray(obj);
-
-    const filtered = filterDictArray(arr, (k, _v) => {
-      return k !== "color";
-    });
-
-    // run time tests
-    expect(arr).toHaveLength(3);
-    expect(filtered).toHaveLength(2);
-    expect(filtered.map(i => i[0])).toContain("id");
-    expect(filtered.map(i => i[0])).toContain("favorite");
-    expect(filtered.map(i => i[0])).not.toContain("color");
-
-    // TODO: uncomment type test below once working!
-
-    // type tests
-    type cases = [
-      // now that "color" has been removed from `T` the type
-      // should no longer be the same DictArray
-      // ExpectFalse<Equal<Filtered, DictArray<Obj>>>,
-      // Expect<Equal<Filtered, DictArray<Omit<Obj, "color">>>>,
-    ];
-    const cases: cases = [];
-  });
-
-  // TODO: return this test once functionality is working correctly
-
-  it.skip("a filtered down DictArray can be converted back to an object", () => {
-    // const obj = defineType({ id: 123 })({ color: "red", favorite: true });
-    // type Obj = typeof obj;
-    // const arr = dictToArray(obj);
-    // type Arr = typeof arr;
-
-    // const filtered = filterDictArray(arr, (k, _v) => {
-    //   return k !== "color";
-    // });
-    // type Filtered = typeof filtered;
-
-    // const reverted = arrayToDict(filtered);
-    // type Reverted = typeof reverted;
-  });
-
-});

package/on-hold/tests/run-time-spec.ts

@@ -1,44 +0,0 @@
-import { Equal, Expect } from "@type-challenges/utils";
-import { TypeGuard } from "~/types";
-import { number, string } from "~/utility/runtime";
-
-describe("run-time types", () => {
-
-  it("string()", () => {
-    const s = string();
-    type S = typeof s;
-
-    expect(s.type).toBe("string");
-
-    type cases = [
-      Expect<Equal<S["__kind"], "type">>,
-      Expect<Equal<S["type"], string>>,
-      Expect<Equal<S["is"], TypeGuard<string>>>
-    ];
-    const cases: cases = [true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("number()", () => {
-    const n = number();
-    type N = typeof n;
-
-    expect(n.type).toBe("number");
-
-    type cases = [
-      Expect<Equal<N["__kind"], "type">>,
-      Expect<Equal<N["type"], number>>,
-      Expect<Equal<N["is"], TypeGuard<number>>>
-    ];
-    const cases: cases = [true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("empty object()", () => {
-    // const o = object();
-    // type O = typeof o;
-  });
-
-
-
-});

package/on-hold/type.ts

@@ -1,20 +0,0 @@
-import { TypeGuard } from "~/types";
-import { RuntimeType } from "../../../types/runtime";
-
-/**
- * Creates a run-time type that is conveyed to Typescript as well
- */
-export const type =
-  <T extends any>() =>
-  <N extends string, O extends object>(
-    name: N,
-    validate: TypeGuard<T>,
-    _options: O
-  ): RuntimeType<T> => {
-    return {
-      __kind: "type",
-
-      type: name as unknown as T,
-      is: validate,
-    };
-  };

package/on-hold/types/object.ts

@@ -1,19 +0,0 @@
-// import type { TypeOptions, TypeGuard } from "~/types";
-// import { type } from "./type";
-
-export type ObjectOption<N extends string | undefined> = {
-  name?: N;
-};
-
-// export const object = <N extends string | undefined>(props: PropsCallback, opts: TypeOptions<ObjectOption<N>> = {}) => {
-
-//   /**
-//    * Object based type-guard
-//    */
-//   const tg: TypeGuard<null> = (v: unknown): v is null => {
-//     return v === "null";
-//   };
-
-
-//   return type<null>()("null", tg, opts);
-// };

package/on-hold/types/prop.ts

@@ -1,28 +0,0 @@
-import { isNonNullObject } from "common-types";
-import { TypeGuard } from "~/types/TypeGuard";
-import { keys } from "~/utility/keys";
-import { RuntimeProp, RuntimeType } from "~/types/runtime";
-
-export const prop = <
-  P extends PropertyKey,
-  T extends RuntimeType<any>,
-  O extends object
->(prop: Readonly<P>, type: Readonly<T>, _opts: O = {} as O): RuntimeProp<P, T> => {
-
-  /**
-   * Default type guard for a property; relies on underlying type's typeguard for validation
-   */
-  const tg: TypeGuard<Record<P, T["type"]>> = (v: unknown): v is Record<P, T["type"]> => {
-    return isNonNullObject(v) && keys(v as Record<P, any>).includes(prop) && type.is((v as Record<P, any>)[prop as P]);
-  };
-
-  return {
-    __kind: "prop",
-
-    key: prop,
-    valueType: type.type as unknown as Readonly<T["type"]>,
-    type: type.type as unknown as Record<P, T["type"]>,
-
-    is: tg
-  };
-};

package/on-hold/types/scalar.ts

@@ -1,37 +0,0 @@
-import { TypeGuard } from "~/types";
-import { TypeOptions } from "../../../types/runtime";
-
-export const string = (opts: TypeOptions = {}) => {
-  const tg: TypeGuard<string> = (v: unknown): v is string => {
-    return typeof v === "string";
-  };
-  return type<string>()("string", tg, opts);
-};
-
-export const number = (opts: TypeOptions = {}) => {
-  const tg: TypeGuard<number> = (v: unknown): v is number => {
-    return typeof v === "number";
-  };
-  return type<number>()("number", tg, opts);
-};
-
-export const boolean = (opts: TypeOptions = {}) => {
-  const tg: TypeGuard<boolean> = (v: unknown): v is boolean => {
-    return typeof v === "boolean";
-  };
-  return type<boolean>()("string", tg, opts);
-};
-
-export const fn = (opts: TypeOptions = {}) => {
-  const tg: TypeGuard<Function> = (v: unknown): v is Function => {
-    return typeof v === "function";
-  };
-  return type<Function>()("function", tg, opts);
-};
-
-export const nullValue = (opts: TypeOptions = {}) => {
-  const tg: TypeGuard<null> = (v: unknown): v is null => {
-    return v === "null";
-  };
-  return type<null>()("null", tg, opts);
-};

package/src/types/dictionary/NotEmptyObject.ts

@@ -1,9 +0,0 @@
-import { ExpandRecursively } from "../ExpandRecursively";
-import { Keys, Length, UnionToTuple } from "../index";
-
-/**
- * Accepts an object with at least one property defined on it
- */
-export type NotEmptyObject<T extends {}> = ExpandRecursively<
-  Length<UnionToTuple<Keys<T>>> extends 0 ? false : T
->;

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

@@ -1,13 +0,0 @@
-
-/**
- * Given a dictionary of key/values, where the value is a function, this 
- * type utility will maintain the keys but change the values to whatever
- * the `ReturnType` of the function was.
- * ```ts
- * // { foo: string }
- * type Test = UnwrapValue<{ foo: (name: string) => name }>
- * ```
- */
-export type UnwrapValue<T extends Record<string, (...args: any[]) => any>> = {
-  [K in keyof T]: T[K] extends Function ? ReturnType<T[K]> : never;
-}[keyof T];

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

@@ -1,15 +0,0 @@
-type ValueFunction<T extends any> = <R extends any>(v: T) => R;
-
-/**
- * **SameKeys**
- *
- * Given a dictionary `T` and a type-strong wrapper function `F`, returns a dictionary with the
- * same keys but 
- * 
- * Note: meant to be used as part of an _extends_ clause in most cases.
- */
-export type WrapValue<T extends {}, F extends ValueFunction<T>> = {
-  [P in keyof T]: ReturnType<F>;
-};
-
-

package/src/utility/dictionary/valuesOfProp.ts

@@ -1,13 +0,0 @@
-
-
-// TODO: implement
-
-export function valuesOfProp<_T extends object>() {
-  // return (arr: T[], prop: keyof T) => {
-
-  //   for (const i of arr) {
-  //     const v = literal(i[prop]);
-
-  //   }
-  // };
-}

package/src/utility/state/KeyStorage.ts

@@ -1,23 +0,0 @@
-/* eslint-disable no-use-before-define */
-
-export type KeyStorage<S extends readonly string[]> = (state: S) => {
-  add: <N extends readonly string[]>(...store: N) => KeyStorageApi<readonly [...S, ...N]>;
-  remove: <R extends string>(key: R) => KeyStorageApi<Exclude<S, R>>;
-  done: () => S;
-};
-
-export type KeyStorageApi<S extends readonly string[]> = ReturnType<KeyStorage<S>>;
-
-//TODO: need to make this work or remove
-
-export function KeyStorage() {
-  const api = <S extends readonly string[]>(state: S) => ({
-    add: <N extends readonly string[]>(...store: N) => {
-      return api<readonly [...S, ...N]>([...state, ...store]);
-    },
-    remove: <R extends string>(key: R) => api<Exclude<S, R>>(state.filter(i => i !== key) as unknown as Exclude<S, R>),
-    done: () => state
-  });
-
-  return api([]);
-}