inferred-types 0.20.0 → 0.22.5

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

@@ -1,59 +0,0 @@
-
-import { RuleSet } from "~/utility";
-type State = { foo: number; bar: number; baz: { a: number; b: number } };
-const rules1 = { foo: true, bar: true, yup: () => true, nope: () => false, maybe: (s: State) => s.foo > 5 } as const;
-import { Equal, Expect } from "@type-challenges/utils";
-
-
-describe("RuleSet", () => {
-
-  it("stages of application produce correct signatures", () => {
-    const s1 = RuleSet<State>();
-    type S1 = typeof s1;
-    const s2 = s1(rules1);
-    const sl2 = s1({ foo: true, bar: true, yup: () => true, nope: () => false, maybe: (s: State) => s.foo > 5 });
-    type S2 = typeof s2;
-    type SL2 = typeof sl2;
-    const s3 = s2({ foo: 8, bar: 0, baz: { a: 1, b: 2 } });
-    type S3 = typeof s3;
-
-
-    type cases = [
-      // the types returned by the 2nd function call should
-      // always be narrow in type definition, even if not explicitly
-      // stated as as `as const`.
-      // critically we we want to distinguish "true" from "false"
-      Expect<Equal<S2, SL2>>,
-      // at the end we need to arrive at a type which is a string
-      // literal representing the key values which have passed the
-      // rules.
-    ];
-
-  });
-
-  it("dynamic rules are evaluated correctly", () => {
-    const noState = RuleSet<State>()(rules1)();
-    type NoState = typeof noState;
-    const maybePassing = RuleSet<State>()(rules1)({ foo: 8, bar: 0, baz: { a: 1, b: 2 } });
-    type Pass = typeof maybePassing;
-    const maybeFailing = RuleSet<State>()(rules1)({ foo: 0, bar: 0, baz: { a: 1, b: 2 } });
-    type Fail = typeof maybeFailing;
-
-    type cases = [
-      // if no state is passed then only static rules are passed forward
-      Expect<Equal<NoState, "foo" | "bar">>,
-      // "foo" is greater than 5 so results in "maybe" being truthy
-      Expect<Equal<Pass, "foo" | "bar" | "yup" | "maybe">>,
-      // "foo" is less than 5 and therefore "maybe" is falsy
-      Expect<Equal<Fail, "foo" | "bar" | "yup">>,
-    ];
-    const cases: cases = [true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("static rulesets operate to exclude parts of an api", () => {
-    // const rules1 = RuleSet()({ foo: true })();
-    // const rules2 = RuleSet()({ foo: true, baz: true })();
-
-  });
-});

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

@@ -1,60 +0,0 @@
-import type { Expect, Equal, ExpectExtends } from "@type-challenges/utils";
-import { Keys, ToFluent } from "~/types";
-import { BuilderState } from "./data";
-
-const api = {
-  foo: () => 5,
-  bar: () => "hi",
-  baz: (greeting: string) => greeting,
-};
-type Api = typeof api;
-type Fluent = ToFluent<Api>;
-
-describe("ToFluent<T,X> type utility", () => {
-  it("a simple function-based API has it's return types changed to point back to API", () => {
-    type cases = [
-      // all return types on the API return the same Fluent API
-      Expect<Equal<Fluent, ReturnType<Fluent["foo"]>>>,
-      Expect<Equal<Fluent, ReturnType<Fluent["bar"]>>>,
-      Expect<Equal<Fluent, ReturnType<Fluent["baz"]>>>,
-      // this is also true recursively
-      Expect<Equal<Fluent, ReturnType<ReturnType<Fluent["foo"]>["bar"]>>>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  // this allows for non fluent parts of the API to be continued on too as part of fluent
-  // process.
-  it("an API <T> can be made fluent but while including the type <X> as part of the return type", () => {
-    const x = {
-      hi: () => "hello",
-    };
-    type X = typeof x;
-    type FluentX = ToFluent<Api, X>;
-
-    type cases = [
-      // all return types on the API return the same Fluent API
-      Expect<Equal<FluentX, ReturnType<FluentX["foo"]>>>,
-      Expect<Equal<FluentX, ReturnType<FluentX["bar"]>>>,
-      Expect<Equal<FluentX, ReturnType<FluentX["baz"]>>>,
-      // this is also true recursively
-      Expect<Equal<FluentX, ReturnType<ReturnType<FluentX["foo"]>["bar"]>>>,
-      // the non-fluent API also shows up
-      Expect<ExpectExtends<Keys<FluentX>, "hi">>,
-      // the "hi" function returns a string (and breaks out of the fluent loop)
-      Expect<Equal<string, ReturnType<FluentX["hi"]>>>
-    ];
-    const cases: cases = [true, true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("using API structures similar to a builder", () => {
-    const identityApi = {
-      incFoo: <T extends Partial<BuilderState>, T2 extends Partial<BuilderState>>(s: T) => () => ({ ...s, foo: s.foo ? s.foo : 1 } as T2),
-      decBar: <T extends Partial<BuilderState>>(s: T) => () => ({ ...s, foo: s.foo ? s.foo : 1 } as T),
-    };
-    const escapeApi = {};
-    type Escape<T extends object = {}> = { unwrap: () => BuilderState; current: Partial<BuilderState> } & T;
-  });
-});

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/index.ts

@@ -1,34 +0,0 @@
-// #autoindex
-// #region autoindexed files
-// index last changed at: 1st Jan, 2022, 03:27 PM ( GMT-8 )
-// hash-code: da242834
-
-
-
-// #endregion
-
-// This file was created by running: "dd autoindex"; it assumes you have
-// the 'do-devops' pkg (that's "dd" on npm) installed as a dev dep.
-//
-// By default it assumes that exports are named exports but this can be changed by
-// adding a modifier to the '// #autoindex' syntax:
-//
-//    - autoindex:named     same as default, exports "named symbols"
-//    - autoindex:default   assumes each file is exporting a default export and
-//                          converts the default export to the name of the file
-//    - autoindex:offset    assumes files export "named symbols" but that each
-//                          file's symbols should be offset by the file's name
-//
-// You may also exclude certain files or directories by adding it to the
-// autoindex command. As an example:
-//
-//    - autoindex:named, exclude: foo,bar,baz
-//
-// Inversely, if you state a file to be an "orphan" then autoindex files
-// below this file will not reference this autoindex file:
-//
-//    - autoindex:named, orphan
-// 
-// All content outside the "// #region" section in this file will be
-// preserved in situations where you need to do something paricularly awesome.
-// Keep on being awesome.

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/runtime/conditions/isLiteral.ts

@@ -1,7 +0,0 @@
-export type IsLiteral<L extends string | number, T extends any> = T extends L ? true : false;
-
-export function isLiteral<L extends Readonly<string>>(...allowed: L[]) {
-  return <T extends unknown>(i: T) => {
-    return !allowed.every((v) => i !== v) as IsLiteral<L, T>;
-  };
-}

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([]);
-}