inferred-types 0.16.0 → 0.18.1

package/dist/types/utility/modelling/IoModel.d.ts

@@ -1,26 +0,0 @@
-import * as t from "io-ts";
-import type { PascalCase } from "../../types/index";
-/**
- * Defines an `io-ts` based **model**.
- *
- * - `<T>` represents type of the model
- * - `<S>` is the model's literal type
- *
- * Note: unlink the default `io-ts` model/codec, the
- * `name` variable is an explicit type alias and not a string
- * type. This helps to preserve it's type inference even though
- * the model itself does have a runtime definition of it's type.
- */
-export declare type IoModel<M, N extends string> = Omit<t.Type<M>, "name"> & {
-    name: N;
-};
-/**
- * **Model**
- *
- * A function which returns a `io-ts` based model/codec but with a _literal_ name
- * property, and a `kind` which uniquely distinguishes itself as a "model".
- *
- * **Note:** the name of a model is expected to be in _PascalCase_ and will be converted
- * to it if not passed in correctly.
- */
-export declare function IoModel<RP extends t.Props, OP extends t.Props | {}, N extends string>(name: N, req: RP, optional?: OP): IoModel<{ [K in keyof RP]: t.TypeOf<RP[K]>; } & { [K_1 in keyof OP]?: t.TypeOf<OP[K_1]> | undefined; }, PascalCase<N>>;

package/dist/types/utility/modelling/Model.d.ts

@@ -1,22 +0,0 @@
-export declare function Model<N extends string, _R extends {} = {}, _O extends {} = {}>(name: N): {
-    required<P extends string>(_prop: P): {
-        required<P_1 extends string>(_prop: P_1): any;
-        optional<P_2 extends string>(_prop: P_2): any;
-        done(): {
-            __model__: N;
-            __kind__: "model";
-        };
-    };
-    optional<P_3 extends string>(_prop: P_3): {
-        required<P_1 extends string>(_prop: P_1): any;
-        optional<P_2 extends string>(_prop: P_2): any;
-        done(): {
-            __model__: N;
-            __kind__: "model";
-        };
-    };
-    done(): {
-        __model__: N;
-        __kind__: "model";
-    };
-};

package/dist/types/utility/modelling/index.d.ts

@@ -1 +0,0 @@
-export * from "./Model";

package/dist/types/utility/ruleset.d.ts

@@ -1,18 +0,0 @@
-import type { Narrowable } from "../types/index";
-/**
- * **ruleSet**
- *
- * Defines a ruleset composed of _dynamic_ and _static_ boolean operators.
- *
- * - the first function call defines _dynamic_ props (_optional_)
- * - the second function call defines static values
- *
- * ```ts
- * const rs = ruleSet(
- *    r => r.state()( { maybe: r => r.extends({ foo: 1 }) })
- * )(
- *    { color: true, age: false }
- * );
- * ```
- */
-export declare function ruleSet<N extends Narrowable, TState extends Record<keyof TState, N>>(defn?: TState): TState | undefined;

package/dist/types/utility/runtime/condition.d.ts

@@ -1,3 +0,0 @@
-import { Narrowable } from "../../types/index";
-export declare type Condition<TInput extends Narrowable, TResult extends boolean> = (input: TInput) => TResult;
-export declare const condition: <TInput extends Narrowable, C extends Condition<Narrowable, boolean>>(c: C, input: TInput) => boolean;

package/dist/types/utility/runtime/conditions/index.d.ts

@@ -1,12 +0,0 @@
-export * from "./isArray";
-export * from "./isBoolean";
-export * from "./isFalse";
-export * from "./isFunction";
-export * from "./isLiteral";
-export * from "./isNull";
-export * from "./isNumber";
-export * from "./isObject";
-export * from "./isString";
-export * from "./isSymbol";
-export * from "./isTrue";
-export * from "./isUndefined";

package/dist/types/utility/runtime/conditions/isArray.d.ts

@@ -1,2 +0,0 @@
-export declare type IsArray<T> = T extends any[] ? true : false;
-export declare function isArray<T>(i: T): IsArray<T>;

package/dist/types/utility/runtime/conditions/isBoolean.d.ts

@@ -1,5 +0,0 @@
-export declare type IsBoolean<T> = T extends boolean ? true : false;
-/**
- * Runtime and type checks whether a variable is a boolean value.
- */
-export declare function isBoolean<T extends any>(i: T): IsBoolean<T>;

package/dist/types/utility/runtime/conditions/isFalse.d.ts

@@ -1,4 +0,0 @@
-import { Narrowable } from "../../../types/index";
-import { IsBoolean } from "../../index";
-export declare type IsFalse<T extends Narrowable> = IsBoolean<T> extends true ? T extends false ? true : true extends T ? false : unknown : false;
-export declare function isFalse<T>(i: T): IsFalse<T>;

package/dist/types/utility/runtime/conditions/isFunction.d.ts

@@ -1,15 +0,0 @@
-import { FunctionType } from "../../../types/index";
-export declare type IsFunction<T> = T extends FunctionType ? true : false;
-/**
- * Checks whether a passed in value is a function and ensures run-time and types
- * are consistent.
- * ```ts
- * // true
- * const yup = isFunction(() => "hello world");
- * ```
- *
- * Note: the runtime `typeof [variable]` will correctly say "function" when a function is
- * encounted but if that function also has object types defined then the type will be a big
- * and ugly union type. This function will give you a proper boolean value in both cases.
- */
-export declare function isFunction<T extends unknown>(input: T): IsFunction<T>;

package/dist/types/utility/runtime/conditions/isLiteral.d.ts

@@ -1,2 +0,0 @@
-export declare type IsLiteral<L extends string | number, T extends any> = T extends L ? true : false;
-export declare function isLiteral<L extends Readonly<string>>(...allowed: L[]): <T extends unknown>(i: T) => IsLiteral<L, T>;

package/dist/types/utility/runtime/conditions/isNull.d.ts

@@ -1 +0,0 @@
-export declare function isNull<T>(i: T): T extends null ? true : false;

package/dist/types/utility/runtime/conditions/isNumber.d.ts

@@ -1 +0,0 @@
-export declare function isNumber<T>(i: T): T extends number ? true : false;

package/dist/types/utility/runtime/conditions/isObject.d.ts

@@ -1,10 +0,0 @@
-import { FunctionType, Mutable, Narrowable, Not } from "../../../types/index";
-export declare type IsObject<T> = Mutable<T> extends Record<string, any> ? T extends FunctionType ? false : Mutable<T> extends any[] ? false : true : false;
-export declare type ObjectType = Not<Record<string, Narrowable>, FunctionType>;
-/**
- * Detects whether the passed in `v` is of type "object" where an object
- * is defined to be a string keyed dictionary style object. This means that
- * arrays are excluded, as well as functions which also have properties hanging
- * off of them.
- */
-export declare function isObject<T extends unknown>(i: T): IsObject<T>;

package/dist/types/utility/runtime/conditions/isString.d.ts

@@ -1,2 +0,0 @@
-export declare type IsString<T> = T extends string ? true : false;
-export declare function isString<T>(i: T): IsString<T>;

package/dist/types/utility/runtime/conditions/isSymbol.d.ts

@@ -1 +0,0 @@
-export declare function isSymbol<T>(i: T): T extends symbol ? true : false;

package/dist/types/utility/runtime/conditions/isTrue.d.ts

@@ -1,20 +0,0 @@
-import { Narrowable } from "../../../types/index";
-import type { IsBoolean } from "./isBoolean";
-/**
- * Type utility which returns `true` or `false` based on
- * whether the type holds the narrow "true" type.
- * ```ts
- * // true
- * type T = IsTrue<true>;
- * // unknown
- * type U = IsTrue<boolean>;
- * // false
- * type F = IsTrue<false>;
- * type F2 = IsTrue<"false">;
- * ```
- */
-export declare type IsTrue<T> = IsBoolean<T> extends true ? T extends true ? true : T extends false ? false : unknown : false;
-/**
- * Run-time and type checking of whether a variable is `true`.
- */
-export declare function isTrue<T extends Narrowable>(i: T): IsTrue<T>;

package/dist/types/utility/runtime/conditions/isUndefined.d.ts

@@ -1 +0,0 @@
-export declare function isUndefined<T>(i: T): undefined extends T ? true : false;

package/dist/types/utility/runtime/ifTypeOf.d.ts

@@ -1,23 +0,0 @@
-import { Narrowable } from "../../types/Narrowable";
-/**
- * A conditional clause used in the application of the `ifTypeOf` utility
- */
-export declare type ExtendsClause<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = <TBase extends any>(base: TBase) => TValue extends TBase ? true : false;
-/**
- * A conditional clause used in the application of the `ifTypeOf` utility
- */
-export declare type ExtendsNarrowlyClause<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = <NB extends Narrowable, TBase extends Record<keyof TBase, NB> | number | string | boolean | symbol>(base: TBase) => TValue extends TBase ? true : false;
-/**
- * **TypeCondition**
- *
- * A partially applied type from the `ifTypeOf` utility where the base type has been
- * defined and we now need to express the type which is intended to extend it.
- *
- * - `extends` - compares with _wide_ types
- * - `narrowlyExtends` - compares with _narrow_ / _literal_ types
- */
-export declare type TypeCondition<N extends Narrowable, TValue extends Record<keyof TValue, N> | number | string | boolean | symbol> = {
-    extends: ExtendsClause<N, TValue>;
-    narrowlyExtends: ExtendsNarrowlyClause<N, TValue>;
-};
-export declare const ifTypeOf: <N extends Narrowable, TValue extends string | number | boolean | symbol | Record<keyof TValue, N>>(val: TValue) => TypeCondition<N, TValue>;

package/dist/types/utility/runtime/index.d.ts

@@ -1,5 +0,0 @@
-export * from "./condition";
-export * from "./ifTypeOf";
-export * from "./type";
-export * from "./withValue";
-export * from "./conditions/index";

package/dist/types/utility/runtime/type.d.ts

@@ -1,27 +0,0 @@
-import { Narrowable, TypeGuard } from "../../types/index";
-import { isString, isBoolean, isNumber, isFunction, isSymbol, isNull, isTrue, isFalse, isUndefined, isObject, isArray } from "./conditions/index";
-export declare type Type<T extends any, V extends Function> = {
-    name: string;
-    type: T;
-    typeGuard: TypeGuard<T>;
-    is: V;
-};
-export declare const typeApi: () => {
-    readonly string: Type<string, typeof isString>;
-    readonly boolean: Type<boolean, typeof isBoolean>;
-    readonly number: Type<number, typeof isNumber>;
-    readonly function: Type<Function | (Function & {
-        [key: string]: any;
-    }), typeof isFunction>;
-    readonly null: Type<null, typeof isNull>;
-    readonly symbol: Type<symbol, typeof isSymbol>;
-    readonly undefined: Type<undefined, typeof isUndefined>;
-    readonly true: Type<true, typeof isTrue>;
-    readonly false: Type<false, typeof isFalse>;
-    readonly object: Type<Record<string, Narrowable>, typeof isObject>;
-    readonly array: Type<any[], typeof isArray>;
-};
-export declare type TypeApi = ReturnType<typeof typeApi>;
-export declare function isType<T extends any, V extends Function>(t: unknown): t is Type<T, V>;
-export declare type TypeDefinition<T extends any, V extends Function> = (defn: TypeApi) => Type<T, V>;
-export declare function type<T extends any, V extends Function>(fn: TypeDefinition<T, V>): Type<T, V>;

package/dist/types/utility/runtime/withValue.d.ts

@@ -1,19 +0,0 @@
-import { ExpandRecursively, Narrowable } from "../../types/index";
-import { TypeDefinition } from "./index";
-/**
- * **withValue**
- *
- * Reduces a dictionary object -- in both _type_ and _run-time_ structure -- to only those
- * key/value pairs which have a specified value. For instance:
- *
- * ```ts
- * const obj = { foo: 1, bar: 2, message: "hi there" };
- * // { message: "hi there" }
- * const onlyStrings = withValue(t => t.string)(obj);
- * // { foo: 1 }
- * const justOne = withValue(t => t.literal(1))(obj);
- * ```
- *
- * Note: _often useful to provide run-time type profiles with the_ `inferredType` _utility_
- */
-export declare function withValue<T extends any, V extends Function>(td: TypeDefinition<T, V>): <N extends Narrowable, R extends Record<string, N>>(obj: R) => ExpandRecursively<Pick<R, import("../../types/index").KeysWithValue<T, R>>>;

package/dist/types/utility/state/Configurator.d.ts

@@ -1,36 +0,0 @@
-import { ExpandRecursively } from "../../types/index";
-export interface IConfigurator<C = {}> {
-    set<V, K extends string, KV = {
-        [U in K]: V;
-    }>(key: K, value: V): asserts this is IConfigurator<ExpandRecursively<C & KV>>;
-    remove<K extends string & keyof C>(key: K): asserts this is IConfigurator<ExpandRecursively<Omit<C, K>>>;
-    done(): C;
-}
-/**
- * **Configurator**
- *
- * This function provides a configurator which uses TypeScript assertions
- * to narrow the scope of variables. Using type assertions though means we
- * can't also return values and therefore a _fluent_ API style is not possible.
- *
- * Note: this approach does require, that you explicitly use the `IConfigurator`
- * interface exported by this library. Without it you'd getting annoying TS errors
- * on every call to `set()` but adding it is simple enough:
- *
- * ```ts
- * import { Configurator, IConfigurator } from "inferred-types";
- * const config: IConfigurator = Configurator();
- * ```
- *
- * If you want to specify some guideline params which you expect to be set, you
- * can add them like so:
- *
- * ```ts
- * export type IExpected = { foo: number, bar: string };
- * const config: IConfigurator<IExpected> = Configurator<IExpected>();
- * ```
- *
- * This configuration will ensure that `foo` and `bar` will be seen as optional
- * parameters. If you set them they will stop being optional.
- */
-export declare function Configurator(): IConfigurator<{}>;

package/dist/types/utility/state/FluentConfigurator.d.ts

@@ -1,27 +0,0 @@
-import type { ExpandRecursively } from "../../types/index";
-export interface IFluentConfigurator<C> {
-    /**
-     * **set**
-     *
-     * Sets a new key/value pair to the configurator.
-     *
-     * @param key the key to put this new configuration item
-     * @param value the value of the configuration item
-     */
-    set<V, K extends string, KV = {
-        [U in K]: V;
-    }>(key: K, value: V): IFluentConfigurator<C & KV>;
-    done(): ExpandRecursively<C>;
-}
-/**
- * This function will return a basic _configurator_ API surface which allows
- * you to add name/value pairs to a growing dictionary of strongly typed data.
- *
- * When configuration is complete, you call the `done()` endpoint and the typed
- * configuration will be returned with the API removed.
- *
- * > **Note:** the approach taken here requires that you configure using a **fluent style**
- * exclusively. If you don't the non-fluent properties set will not show up
- * in the typing or the run-time object.
- */
-export declare function FluentConfigurator<I>(initial?: I): IFluentConfigurator<{}>;

package/dist/types/utility/state/index.d.ts

@@ -1,3 +0,0 @@
-export * from "./Configurator";
-export * from "./FluentConfigurator";
-export * from "./KeyStorage";

package/src/types/alphabetic/Intrinsic.ts

@@ -1,6 +0,0 @@
-/* eslint @typescript-eslint/no-unused-vars: "off" */
-
-export type Capitalize<T> = intrinsic;
-export type Uncapitalize<T> = intrinsic;
-export type Uppercase<T> = intrinsic;
-export type Lowercase<T> = intrinsic;

package/src/utility/modelling/IoModel.ts

@@ -1,38 +0,0 @@
-import * as t from "io-ts";
-import { pascalize } from "native-dash";
-import type { PascalCase } from "~/types";
-
-/**
- * Defines an `io-ts` based **model**.
- *
- * - `<T>` represents type of the model
- * - `<S>` is the model's literal type
- *
- * Note: unlink the default `io-ts` model/codec, the
- * `name` variable is an explicit type alias and not a string
- * type. This helps to preserve it's type inference even though
- * the model itself does have a runtime definition of it's type.
- */
-export type IoModel<M, N extends string> = Omit<t.Type<M>, "name"> & { name: N };
-
-/**
- * **Model**
- *
- * A function which returns a `io-ts` based model/codec but with a _literal_ name
- * property, and a `kind` which uniquely distinguishes itself as a "model".
- *
- * **Note:** the name of a model is expected to be in _PascalCase_ and will be converted
- * to it if not passed in correctly.
- */
-export function IoModel<RP extends t.Props, OP extends t.Props | {}, N extends string>(
-  name: N,
-  req: RP,
-  optional: OP = {} as OP
-) {
-  const model = t.intersection([t.type(req), t.partial(optional)], name);
-  type T = t.TypeOf<typeof model>;
-  return {
-    ...(model as t.Type<T>),
-    name: pascalize(name),
-  } as IoModel<T, PascalCase<N>>;
-}

package/tests/FluentApi-spec.ts

@@ -1,90 +0,0 @@
-import type { Expect, Equal, ExpectExtends, ExpectFalse } from "@type-challenges/utils";
-import { FluentApi, Keys } from "~/types";
-
-const escape = {
-  hi: () => "hello",
-};
-const fluent = {
-  foo: () => ({ ...fluent, ...escape }),
-  bar: () => ({ ...fluent, ...escape }),
-};
-const fluentSolo = {
-  foo: () => fluentSolo,
-  bar: () => fluentSolo,
-};
-
-describe("FluentApi type", () => {
-  it("Fluent API without escape API can be used as FluentAPI", () => {
-    const api: FluentApi<typeof fluentSolo> = fluentSolo;
-    type Api = typeof api;
-
-    type cases = [
-      // Api extends the type FluentApi
-      Expect<ExpectExtends<FluentApi<any, any, any>, Api>>,
-      // the fluent API keys are found on API
-      Expect<ExpectExtends<Keys<Api>, "foo" | "bar">>,
-      // the fluent API returns itself
-      Expect<Equal<Api, ReturnType<Api["bar"]>>>,
-      Expect<Equal<Api, ReturnType<Api["foo"]>>>
-    ];
-    const cases: cases = [true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("Simple fluent API and escape API are combined", () => {
-    const api: FluentApi<typeof fluent, typeof escape> = { ...fluent, ...escape };
-    type Api = typeof api;
-
-    type cases = [
-      // Api extends the type FluentApi
-      Expect<ExpectExtends<FluentApi<any, any, any>, Api>>,
-      // the fluent and escape api keys are found on API
-      Expect<ExpectExtends<Keys<Api>, "foo" | "bar" | "hi">>,
-      // the fluent API returns itself
-      Expect<Equal<Api, ReturnType<Api["bar"]>>>,
-      Expect<Equal<Api, ReturnType<Api["foo"]>>>,
-      // whereas the escape API just returns a string
-      Expect<Equal<string, ReturnType<Api["hi"]>>>
-    ];
-    const cases: cases = [true, true, true, true, true];
-    expect(cases).toBe(cases);
-  });
-
-  it("Exclusion masks certain API endpoints", () => {
-    const api1: FluentApi<typeof fluent, typeof escape, "hi"> = { ...fluent, ...escape };
-    type Api1 = typeof api1;
-    const api2: FluentApi<typeof fluent, typeof escape, "foo" | "bar"> = { ...fluent, ...escape };
-    type Api2 = typeof api2;
-
-    type cases = [
-      // excluding "hi" hides the escape api but leaves fluent API untouched
-      Expect<ExpectExtends<"foo" | "bar", Keys<Api1>>>,
-      ExpectFalse<ExpectExtends<"hi", Keys<Api1>>>,
-      // similarly hiding "foo" and "bar" leaves the escape API untouched
-      Expect<ExpectExtends<"hi", Keys<Api2>>>,
-      ExpectFalse<ExpectExtends<"foo" | "bar", Keys<Api2>>>
-    ];
-
-    const cases: cases = [true, false, true, false];
-    expect(cases).toBe(cases);
-  });
-
-  it("applying different FluentApi exclusions to the same runtime API modifies the API appropriately", () => {
-    const api1: FluentApi<typeof fluent, typeof escape, "hi"> = { ...fluent, ...escape };
-    type Api1 = typeof api1;
-    const api2: FluentApi<typeof fluent, typeof escape, "foo" | "bar"> = api1 as any;
-    type Api2 = typeof api2;
-
-    type cases = [
-      // excluding "hi" hides the escape api but leaves fluent API untouched
-      Expect<ExpectExtends<"foo" | "bar", Keys<Api1>>>,
-      ExpectFalse<ExpectExtends<"hi", Keys<Api1>>>,
-      // similarly hiding "foo" and "bar" leaves the escape API untouched
-      Expect<ExpectExtends<"hi", Keys<Api2>>>,
-      ExpectFalse<ExpectExtends<"foo" | "bar", Keys<Api2>>>
-    ];
-
-    const cases: cases = [true, false, true, false];
-    expect(cases).toBe(cases);
-  });
-});

package/tests/FluentConfigurator-spec.hold

@@ -1,88 +0,0 @@
-import { FluentConfigurator, keys } from "../src";
-import { mySong, Playlist, Song } from "./data/index";
-import { SimpleTable } from "./data/SimpleTable";
-
-describe("Configurator => ", () => {
-  it("Call to configurator returns API", () => {
-    const c = FluentConfigurator();
-    expect(typeof c.done).toBe("function");
-    expect(typeof c.done()).toBe("object");
-    expect(Object.keys(c.done())).toHaveLength(0);
-  });
-
-  it("Configurator with empty initial state, can have props added using set() and fluent API style", () => {
-    const c = FluentConfigurator().set("a", 5).set("b", "foobar").done();
-    expect(c).toHaveProperty("a");
-    expect(typeof c.a).toBe("number");
-    expect(c).toHaveProperty("b");
-    expect(typeof c.b).toBe("string");
-  });
-
-  it("Configurator with starting state, can have props added using fluent API style", () => {
-    const start = { foo: "bar", bar: "baz" };
-    const c = FluentConfigurator(start).set("b", "foobar").set("a", 5).done();
-    console.log(keys(c));
-
-
-    // added state
-    expect(c).toHaveProperty("a", 5);
-    expect(typeof c.a).toBe("number");
-    expect(c).toHaveProperty("b", "foobar");
-    expect(typeof c.b).toBe("string");
-
-    // starting state
-    expect(c).toHaveProperty("foo");
-    // TODO: need to ensure initial state is available to type system
-    // expect(typeof c.foo).toBe("string");
-    // expect(c.foo).toBe(start.foo);
-    expect(c).toHaveProperty("bar");
-    // expect(typeof c.bar).toBe("string");
-    // expect(c.bar).toBe(start.bar);
-  });
-
-  it("Configurator stores Table objects and keeps the typing", () => {
-    const c = FluentConfigurator()
-      .set("songs", SimpleTable(Song))
-      .set("playlists", SimpleTable(Playlist))
-      .done();
-    // structure
-    expect(c).toHaveProperty("songs");
-    expect(c.songs).toHaveProperty("is");
-    expect(c.songs).toHaveProperty("select");
-    expect(c).toHaveProperty("playlists");
-    expect(c.playlists).toHaveProperty("is");
-    expect(c.playlists).toHaveProperty("select");
-    // type guards
-    // TODO: get back to working types
-    expect((c.songs as any).is(mySong)).toBe(true);
-    expect((c.songs as any).is({ foo: false })).toBe(false);
-  });
-
-  it("set() function is able to set a simple value and have type retained", () => {
-    const c = FluentConfigurator()
-      .set("songs", SimpleTable(Song))
-      .set("playlists", SimpleTable(Playlist))
-      .set("foo", 15)
-      .set("bar", 1);
-    const t = c.done();
-    // TODO: get back to working types
-    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");
-  });
-
-  it("a partially typed configurator can be configured with set()", () => {
-    const c = FluentConfigurator<{ songs: object; playlists: object }>()
-      .set("songs", SimpleTable(Song))
-      .set("playlists", SimpleTable(Playlist))
-      .set("foobar", true)
-      .done();
-
-    expect(c.songs.name).toBe("Song");
-    expect(c.playlists.name).toBe("Playlist");
-    expect(c.foobar).toBe(true);
-  });
-});