inferred-types 0.51.1 → 0.51.2

package/src/types/api/api.ts

@@ -1,368 +0,0 @@
-import {
-  Dictionary,
-  EmptyObject,
-  TypedFunction ,
-  Values,
-  Throw,
-  AfterFirst,
-  First,
-  ExpandRecursively,
-  TupleToUnion,
-  Unset,
-  PublicKeyOf,
-  IfUnset,
-  KeyOf,
-  Fail,
-  Extends,
-  UpsertKeyValue,
-  Tuple,
-  ReduceValues,
-  IsEscapeFunction,
-  RemoveNever,
-  If,
-  WhenNever,
-  HasEscapeFunction,
-  ErrorCondition
-} from "inferred-types/dist/types/index";
-
-/**
- * **ValueCallback**`<TVal, TReturn>`
- *
- * A type utility to build a simple "value callback".
- *
- * ```ts
- * // <V extends string>(v: V) => `hi ${string}`;
- * type T = ValueCallback<string, `hi ${string}`>;
- * ```
- */
-export type ValueCallback<
-  TVal,
-  TReturn
-> = <V extends TVal>(v: V) => TReturn;
-
-
-type _GetEscapeFunction<
-  T extends readonly unknown[]
-> = WhenNever<
-  First<
-    RemoveNever<{
-      [K in keyof T]: If<
-        IsEscapeFunction<T[K]>,
-        T[K],
-        never
-      >
-    }>
-  >,
-  Throw<"no-escape-function">
->;
-
-
-/**
- * **GetEscapeFunction**`<T>`
- *
- * Gets an escape function from an `Api` and from a `Dictionary | TypeFunction`
- * if it exists. If it does not exist then returns an ErrorCondition.
- */
-export type GetEscapeFunction<
-  T extends Dictionary | TypedFunction | Api
-> = T extends Api
-  ? _GetEscapeFunction<Values<T["surface"]>>
-  : _GetEscapeFunction<Values<T>>;
-
-export type FluentState<T> = {
-  state: T;
-  config: {
-    useOnce: keyof T[];
-    used: keyof T[];
-  };
-}
-
-export type FluentFn<
-  TState,
-  TName extends string,
-  TFn extends <TCb extends (
-    <T extends FluentState<TState>>(state: T) => TypedFunction<TState>),
-    TOnce extends boolean
-  >(cb: TCb, useOnce?: TOnce) => void,
-  TOnce extends boolean = false
-> = {
-  name: TName;
-  fn: TFn;
-  useOnce: TOnce;
-}
-
-
-type ExpandFluentFns<
-  TFluentState extends FluentState<any>,
-  TFns extends readonly FluentFn<TFluentState["state"], any, any>[],
-  TFluentApi extends Dictionary = EmptyObject
-> = [] extends TFns
-? TFluentApi
-: ExpandFluentFns<
-    TFluentState,
-    AfterFirst<TFns>,
-    TFluentApi & Record<
-      First<TFns>["name"],
-      First<TFns>["fn"]
-    >
-  >;
-
-
-/**
- * **FluentApi**`<TSurface,TState,TFluentFns>`
- *
- * Defines the callback loop necessary to manage state via a
- * Fluent API.
- */
-export type FluentApi<
-  TSurface extends Dictionary | TypedFunction,
-  TState,
-  TFluentFns extends readonly FluentFn<TState, any, any>[]
-> = <T extends FluentState<TState>>(state: T) => ExpandRecursively<
-  TSurface & ExpandFluentFns<FluentState<TState>,TFluentFns>
->;
-
-/**
- * **ApiState**
- *
- * For API's which manage state, the state should be a Dictionary
- * or Tuple in shape.
- */
-export type ApiState = Dictionary | Tuple;
-
-/**
- * **ApiConfig**`<TSurface,TState>`
- *
- * The configuration of your API provides opportunities to
- * show or mask various parts of your surface area based on
- * the current _state_ you are in.
- */
-export type ApiConfig<
-  TSurface extends ApiSurface<Api> = ApiSurface<Api>,
-  TState extends ApiState = ApiState,
-> = {
-  callOnce: readonly string[],
-  called: readonly string[],
-  mask: ((state: TState, called: readonly string[]) => readonly (KeyOf<TSurface>)[])
-};
-
-// /**
-//  * **ToFluent**`<TSurface,TState,TUseOnce>`
-//  *
-//  * Upgrades a base API to an API which supports state management
-//  * and a Fluent API style.
-//  */
-// export type DefineFluentApi<
-//   TSurface extends Dictionary | TypedFunction = EmptyObject,
-//   TState extends readonly FluentFn<TState, any, any>[] = [],
-//   TConfig extends ApiConfig = { callOnce: ["escapeFn"] }
-// > = {
-//   addFluentFn: <
-//     TName extends string,
-//     TFn extends <TCb extends (
-//       <T extends FluentState<TState>>(state: T) => TypedFunction<TState>
-//     )>(cb: TCb) => void,
-//     TUse extends boolean = false
-//   >(name: TName, fn: TFn, useOnce?: TUse) => DefineFluentApi<
-//       TSurface,
-//       TState,
-//       [
-//         ...TState,
-//         FluentFn<TState,TName,TFn>
-//       ]
-//     >;
-//   done: () => FluentApi<TSurface,TState,TState>;
-// };
-
-// export type AsFluentApi<
-//   TSurface extends Dictionary | TypedFunction,
-//   TState,
-//   TFluentFns extends readonly [FluentFn<TState, any, any>, ...FluentFn<TState, any, any>[]]
-// > = HasEscapeFunction<TSurface> extends true
-// ? FluentApi<TSurface, TState, TFluentFns>
-// : Throw<"no-escape-function">;
-
-
-/**
- * **ApiOptions**`<[TSurface]>`
- *
- * The _options_ which go into defining an API surface.
- */
-export type ApiOptions<
-  TSurface extends Dictionary | TypedFunction | Unset = Unset
->  = {
-  /**
-   * any _state_ which the API is managing (making it a `FluentApi`)
-   *
-   * @default Unset;
-   */
-  state: Unset | Dictionary;
-
-  /**
-   * An array of _keys_ to the API surface which should only be allowed
-   * to be called once (and will be _masked_ thereafter from runtime).
-   *
-   * **Note:** _this only really makes sense when you're managing state_.
-   */
-  callOnce: IfUnset<TSurface, readonly PropertyKey[], readonly PublicKeyOf<AsApi<TSurface>>[]>;
-
-};
-
-
-
-/**
- * **Api**
- *
- * An API definition typically created via `AsApi<TSurface,TOpts>` which is
- * not responsible for managing state.
- *
- * **Related:** `FluentApi`, `AsFluentApi`
- */
-export type Api<
-  TSurface extends Dictionary | TypedFunction = Dictionary | TypedFunction
-> = {
-  _kind: "api";
-  surface: TSurface;
-}
-
-/**
- * **ApiReturn**
- *
- * The expected/desired types that could result from calling the API's
- * _endpoints_.
- *
- * Note: this does not consider the possibility of a user
- */
-export type ApiReturn<
-  T extends Api
-> = "surface" extends keyof T
-? T["surface"] extends Dictionary
-  ? TupleToUnion<ReduceValues<T["surface"]>>
-  : never
-: unknown;
-
-
-/**
- * **ApiSurface**`<T>`
- *
- * Extracts the API's surface area from an `Api`.
- */
-export type ApiSurface<T extends Api> = T["surface"];
-
-/**
- * **ApiCallback**`<TSurface,[TOpts]>`
- *
- * Defines a callback function which receives an API Surface (`TSurface`).
- * It is required that one of the properties on this surface be designated
- * as an `EscapeFunction` and if that is not done this utility will produce
- * an `ErrorCondition<"no-escape-function">`.
- *
- *
- * **Related:** `HandleApiCallback`, `ApiCallbackInfo`
- */
-export type ApiCallback<
-  TApi extends Api
-> = <TCall extends (api: ApiSurface<TApi>) => unknown>(cb: TCall) => ReturnType<TCall>;
-
-
-
-
-type _Fluent<
-  _TStateDefn extends Dictionary,
-  _TState extends _TStateDefn,
-  _TConfig extends {
-    called: readonly KeyOf<_TState>[];
-    callOnce: readonly KeyOf<_TState>[];
-  },
-  _TCaller extends KeyOf<_TState>,
-  _TUpdate extends _TStateDefn
->  = any;
-
-/**
- * **Api**`<TSurface>`
- *
- * Validates a candidate for a _stateless_ API and returns it as an `Api<TSurface>`
- * if valid. If not valid you'll get a `ErrorCondition`.
- */
-export type AsApi<
-  TSurface extends Dictionary | TypedFunction
-> = HasEscapeFunction<TSurface> extends true
-  ? Api<TSurface>
-  : Throw<"no-escape-function">;
-
-export type ApiStateInitializer<
-  TApi
-> = <T extends Dictionary>(state: T) => TApi;
-
-/**
- * A builder API for defining _stateless_ API's.
- *
- * Note: ironically this is **not** a stateless API.
- */
-export type DefineStatelessApi<
-  T extends Dictionary = EmptyObject,
-  _C extends {
-    called: readonly KeyOf<T>[];
-    callOnce: ["escapeFunction"];
-  } = { called: []; callOnce: ["escapeFunction"]}
-> = ({
-  escapeFunction: (state: T) => <
-    TKey extends string,
-    TFn extends () => unknown
-  >(
-    key: Fail<TKey, Extends<TKey,KeyOf<T>> >,
-    fn: TFn
-  ) => ReturnType<TFn>;
-  addFn: (state: T) => <
-    TKey extends string,
-    TFn extends TypedFunction
-  >(key: Fail<TKey, KeyOf<T>>, fn: TFn) =>
-    ExpandRecursively<T["surface"] & Record<TKey, TFn>> extends T["surface"]
-      ?  UpsertKeyValue<T, "surface",  ExpandRecursively<T["surface"] & Record<TKey, TFn>>>
-      : never
-
-});
-
-
-
-/**
- * **ApiEscape**`<T>`
- *
- * Given a `T` which extends `Api` or `ApiCallback`, this utility will expose
- * the escape function.
- */
-export type ApiEscape<
-  T extends Dictionary | TypedFunction | ApiCallback<Api>
-> = T extends ApiCallback<Api>
-? T extends TypedFunction
-  ? Parameters<T>[0] extends Dictionary | TypedFunction
-    ? GetEscapeFunction<Parameters<T>[0]>
-    : never
-  : never
-: GetEscapeFunction<T>;
-
-// /**
-//  * **HandleApiCallback**`<TReturn, TApi>`
-//  *
-//  * Given a returned value `TReturn` from the callback,
-//  * it either proxies that value through if the user completed
-//  * the API calling, or calls the _escape function_ if not.
-//  */
-// export type HandleApiCallback<
-//   TReturn
-// > = TReturn extends Dictionary | TypedFunction
-// ? GetEscapeFunction<TReturn> extends TypedFunction
-//   ? ReturnType<GetEscapeFunction<TReturn>>
-//   : TReturn
-// : TReturn;
-
-
-/**
- * **ApiHandler**`<TApi,THandle>`
- *
- * An API handler for a specific API
- */
-export type ApiHandler<
-  TApi extends Api,
-  _THandle extends (t: unknown, e: ErrorCondition) => unknown
-> = (api: TApi) => <R>(result: R) => unknown;

package/src/types/api/index.ts

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

package/src/types/base-types/AnyArray.ts

@@ -1,6 +0,0 @@
-/**
- * **AnyArray**
- * 
- * Any array, either readonly or otherwise.
- */
-export type AnyArray = unknown[] | readonly unknown[];

package/src/types/base-types/AnyObject.ts

@@ -1,12 +0,0 @@
-
-
-import { EmptyObject, ExplicitlyEmptyObject } from "./EmptyObject";
-import { Dictionary } from "./Dictionary";
-
-/**
- * **AnyObject**
- * 
- * Meant to represent any valid object type (both indexable and not).
- */
-export type AnyObject = Dictionary | EmptyObject | ExplicitlyEmptyObject;
-

package/src/types/base-types/Container.ts

@@ -1,19 +0,0 @@
-import { Dictionary } from "inferred-types/dist/types/index";
-
-/**
- * **Container**
- *
- * A type which represents any container type including:
- *
- *  - any object based type defined with Record<K,V>
- *  - any array or tuple
- *  - any `Map<K,V>`, `WeakMap<K,V>`, or `Set<T>`
- */
-export type Container =
-| Dictionary
-| readonly unknown[]
-| Map<unknown,unknown>
-| WeakMap<object,unknown>
-| Set<unknown>
-| object;
-

package/src/types/base-types/Defined.ts

@@ -1,8 +0,0 @@
-import {Something} from "inferred-types/dist/types/index";
-
-/**
- * **Defined**
- *
- * Represents **every** type except for the _undefined_ type.
- */
-export type Defined = Something | null;

package/src/types/base-types/Dictionary.ts

@@ -1,14 +0,0 @@
-import { ObjectKey } from "./ObjectKey";
-
-/**
- * **Dictionary**`<[K],[V]>`
- * 
- * Represents a Key/Value dictionary type.
- * 
- * **Note:** this is pretty much the same as the built-in
- * `Record<K,V>` type of Typescript but 
- */
-export type Dictionary<
-  K extends ObjectKey = ObjectKey,
-  V = unknown
-> = Record<K,V>;

package/src/types/base-types/Digital.ts

@@ -1,27 +0,0 @@
-import { Digit, NumericChar, NumericSign } from "inferred-types/dist/types/index";
-
-/**
- * **Digital**
- *
- * A Tuple which represents a number as leading `NumericSign` and then
- * an array of numeric digits.
- *
- * **Related:** `DigitalLiteral`
- */
-export type Digital = [
-  NumericSign,
-  readonly [Digit, ...Digit[]]
-];
-
-/**
- * **DigitalLiteral**
- *
- * A Tuple which represents a number as a leading `NumericSign` and
- * then an array of numeric string literals.
- *
- * **Related:** `Digital`
- */
-export type DigitalLiteral = [
-  NumericSign,
-  readonly [`${NumericChar}`, ...`${NumericChar}`[]]
-];

package/src/types/base-types/EmptyObject.ts

@@ -1,14 +0,0 @@
-/**
- * **EmptyObject**
- * 
- * An object/dictionary with explicitly **no** defined properties.
- */
-export type EmptyObject = NonNullable<unknown>;
-
-/**
- * **ExplicitlyEmptyObject**
- * 
- * An `EmptyObject` with it's index keys set to _never_ (which prohibits any 
- * key from being added)
- */
-export type ExplicitlyEmptyObject = NonNullable<{[x:string]: never; [x:symbol]: never}>;

package/src/types/base-types/FalsyValue.ts

@@ -1,8 +0,0 @@
-/**
- * **FalsyValue**
- * 
- * A union of all _falsy_ values.
- * 
- * Note: any value which is _not_ falsy is "truthy"
- */
-export type FalsyValue = false | 0 | -0 |  "" | null | undefined ;

package/src/types/base-types/Indexable.ts

@@ -1,10 +0,0 @@
-
-import { IndexableObject } from "inferred-types/dist/types/index";
-
-/**
- * **Indexable**
- *
- * A type which can be _indexed_. This means either an array of
- * some sort, an indexable object, a `Map`, or a `WeakMap`.
- */
-export type Indexable = IndexableObject | unknown[] | readonly unknown[] | WeakMap<any, any> | Map<any,any>;

package/src/types/base-types/IndexableObject.ts

@@ -1,36 +0,0 @@
-import {  EmptyObject, ExpandRecursively, IsEqual, If, IsNever, Dictionary, RemoveIndex, RemoveIndexKeys, UnionToTuple } from "inferred-types/dist/types/index";
-
-type Len<T extends Dictionary> = UnionToTuple<keyof RemoveIndexKeys<T>>["length"]
-
-/**
- * **IndexableObject**`<[TObj], [TIndex]>`
- *
- * Type utility which receives a `KV` object and and adds an _index signature_
- * so that other properties may be added in the runtime.
- *
- * - by default the index signature is `{ [key: string]: unknown; [key: symbol]: unknown }`
- * but this can be changed by changing `TIndex`
- *
- * ```ts
- * // { [x: string]: unknown; foo: 1; bar: 2 }
- * type FooBarIdx = IndexableObject<{foo: 1; bar: 2}, KV<string>>;
- * ```
- *
- * **Related:** `EmptyObject`, `IndexedObject`
- */
-export type IndexableObject<
-  TObj extends Dictionary = Dictionary,
-  TIndex extends Dictionary = Dictionary
-> = If<
-  IsNever<TObj>,
-  never,
-  If<
-    IsEqual<TObj,EmptyObject>,
-    Dictionary,
-    If<
-      IsNever<Len<TObj>>,
-      Dictionary,
-      ExpandRecursively<TIndex & RemoveIndex<TObj>>
-    >
-  >
->;

package/src/types/base-types/LikeRegExp.ts

@@ -1,10 +0,0 @@
-
-
-/**
- * **LikeRegExp**
- *
- * Is either a real Regular Expression or a string
- * that has been has been validated it _can_ be a
- * regular expression with utilities like `isLikeRegExp()`
- */
-export type LikeRegExp = RegExp | string;