inferred-types 0.51.1 → 0.51.2

package/src/runtime/boolean-logic/ifNumber.ts

@@ -1,30 +0,0 @@
-import { IsNumber, Narrowable } from "inferred-types/dist/types/index";
-import { isNumber } from "src/runtime/index";
-
-
-/**
- * **ifNumber**(val, ifVal, elseVal)
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _number_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
- *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is number
- * @param elseVal the value (strongly typed) returned if val is NOT a number
- */
-export function ifNumber<
-  TContent extends Narrowable,
-  TIf extends Narrowable,
-  TElse extends Narrowable,
->(
-  val: TContent,
-  ifVal: <V extends TContent & number>(v: V) => TIf,
-  elseVal: <V extends Exclude<TContent, number>>(v: V) => TElse
-) {
-  return (
-    isNumber(val)
-      ? ifVal(val as TContent & number)
-      : elseVal(val as Exclude<TContent, number>)
-  ) as unknown as IsNumber<TContent> extends true ? TIf : TElse;
-}

package/src/runtime/boolean-logic/ifObject.ts

@@ -1,15 +0,0 @@
-import type { If, IsObject, Narrowable } from "inferred-types/dist/types/index";
-import { isObject } from "src/runtime/index";
-
-
-export function ifObject<
-  T extends Narrowable,
-  IF extends Narrowable,
-  ELSE extends Narrowable
->(
-  val: T,
-  ifObj: IF,
-  notObj: ELSE
-): If<IsObject<T>, IF, ELSE> {
-  return (isObject(val) ? ifObj : notObj) as If<IsObject<T>, IF, ELSE>;
-}

package/src/runtime/boolean-logic/ifSameType.ts

@@ -1,29 +0,0 @@
-import { Narrowable } from "inferred-types/dist/types/index";
-
-/**
- * **ifSameType**(value, comparator, same, notSame)
- *
- * Runtime utility function which compares the variable `value` to a comparison type
- * and based on whether they are the same type, it will call one of the two provided
- * callback functions: `same` or `notSame`.
- */
-export function ifSameType<
-  TValue extends Narrowable,
-  TType extends string | number | boolean | object,
-  IF extends Narrowable,
-  ELSE extends Narrowable
->(
-  value: TValue,
-  comparator: TType,
-  same: <T extends TType & TValue>(v: T) => IF,
-  notSame: <T extends Exclude<TValue, TType>>(v: T) => ELSE
-) {
-  return (
-    // runtime values match
-    (
-      typeof value === typeof comparator
-        ? same(value as TType & TValue)
-        : notSame(value as Exclude<TValue, TType>)
-    ) as TValue extends TType ? IF : ELSE
-  );
-}

package/src/runtime/boolean-logic/ifScalar.ts

@@ -1,42 +0,0 @@
-import {
-  Dictionary,
-  If,
-  IsScalar,
-  Narrowable,
-  Scalar
-} from "inferred-types/dist/types/index";
-import { isScalar } from "../type-guards/isScalar";
-
-
-
-/**
- * **ifScalar**(value, ifCallback, notCallback)
- *
- * A runtime utility which branches based on whether
- * the type is a `T` is a _scalar_ value or not.
- *
- *  - each branch is provided an _optional_ callback to further
- * refine the type.
- * ```ts
- * const val: number | string = 42;
- * const narrow = ifScalar(val);
- * ```
- */
-export function ifScalar<
-  T extends Narrowable,
-  TIf extends Narrowable,
-  TElse extends Narrowable
->(
-  value: T,
-  ifCallback: <
-    V extends Exclude<T, undefined | Dictionary | unknown[]>
-  >(v: V) => TIf,
-  notCallback: <V extends Exclude<T, Scalar>>(v: V) => TElse
-) {
-  const result = isScalar(value)
-    ? ifCallback(
-      value as Exclude<T, undefined | Dictionary | unknown[]>
-    )
-    : notCallback(value as Exclude<T, Scalar>);
-  return result as typeof result & If<IsScalar<T>, TIf, TElse>;
-}

package/src/runtime/boolean-logic/ifString.ts

@@ -1,37 +0,0 @@
-import { If, IsFalse, IsString, IsTrue, Narrowable } from "inferred-types/dist/types/index";
-
-
-
-/**
- * **ifString**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * a _string_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
- *
- * @param val the value being tested for being a string
- * @param ifVal the value (strongly typed) returned if val is _string_
- * @param elseVal the value (strongly typed) returned if val is NOT a _string
- */
-export function ifString<
-  TContent,
-  TIf extends Narrowable,
-  TElse extends Narrowable
->(
-  val: TContent,
-  ifVal: <V extends TContent & string>(t: V & TContent) => TIf,
-  elseVal: <V extends Exclude<TContent, string>>(v: V & TContent) => TElse
-) {
-  return (
-    typeof val === "string"
-      ? ifVal(val as string & TContent)
-      : elseVal(val as Exclude<TContent, string>)
-  ) as unknown as
-    If<
-      IsTrue<IsString<TContent>>,
-      TIf,
-      If<IsFalse<IsString<TContent>>, TElse, TIf | TElse>
-    >
-
-
-}

package/src/runtime/boolean-logic/ifTrue.ts

@@ -1,33 +0,0 @@
-import { IsFalse, IsTrue, Narrowable } from "inferred-types/dist/types/index";
-import { isTrue } from "src/runtime/index";
-
-
-/**
- * **ifTrue**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * _true_. Valid outcomes are:
- *
- * - **IF** - returned when T is narrowly typed as `true`
- * - **ELSE** - returned when T is narrowly typed as `false`
- * - **IF | ELSE** - returned when T is a `boolean` type
- */
-export function ifTrue<
-  TContent extends Narrowable,
-  TIf extends Narrowable,
-  TElse extends Narrowable
->(
-  val: TContent,
-  ifVal: <V extends TContent & true>(val: V) => TIf,
-  elseVal: <V extends Exclude<TContent, true>>(val: V) => TElse
-) {
-  return (
-    //
-    isTrue(val)
-      ? ifVal(val as TContent & true)
-      : elseVal(val as Exclude<TContent, true>)
-  ) as unknown as
-    [IsTrue<TContent>] extends [true]
-    ? TIf
-    : [IsFalse<TContent>] extends [true] ? TElse : TIf | TElse;
-}

package/src/runtime/boolean-logic/ifUndefined.ts

@@ -1,39 +0,0 @@
-import { IsUndefined, Narrowable } from "inferred-types/dist/types/index";
-import { isDefined, isUndefined } from "src/runtime/index";
-
-/**
- * **ifUndefined**
- *
- * Strongly type-aware conditional statement which checks whether a value is
- * _undefined_ and returns one of two values (strongly typed) based on the evaluation
- * of this criteria.
- *
- * @param val the value being tested
- * @param ifVal the value (strongly typed) returned if val is `undefined`
- * @param elseVal the value (strongly typed) returned if val is NOT `undefined`
- */
-export function ifUndefined<
-  T extends Narrowable,
-  IF extends Narrowable = undefined,
-  ELSE extends Narrowable = Exclude<T, undefined>
->(
-  val: T,
-  ifUndefined: () => IF,
-  ifDefined: <V extends Exclude<T,undefined>>(v: V) => ELSE
-) {
-  return (
-    isUndefined(val) ? ifUndefined() : ifDefined(val as Exclude<T,undefined> )
-  ) as IsUndefined<T> extends true ? IF : ELSE;
-}
-
-export function ifDefined<
-  T extends Narrowable,
-  IF extends Narrowable = Exclude<T, undefined>,
-  ELSE extends Narrowable = undefined
->(
-  val: T,
-  ifVal: <V extends Exclude<T, undefined>>(v: V) => IF,
-  elseVal: () => ELSE
-) {
-  return isDefined(val) ? ifVal : elseVal;
-}

package/src/runtime/boolean-logic/index.ts

@@ -1,19 +0,0 @@
-export * from "./ifArray";
-export * from "./ifBoolean";
-export * from "./ifNumber";
-export * from "./ifNotNull";
-export * from "./ifSameType";
-export * from "./ifContainer";
-export * from "./ifHasKey";
-export * from "./ifLength";
-export * from "./ifScalar";
-export * from "./ifNull";
-export * from "./ifObject";
-export * from "./ifTrue";
-export * from "./ifFunction";
-export * from "./ifFalse";
-export * from "./ifChar";
-export * from "./ifString";
-export * from "./ifUndefined";
-export * from "./ifArrayPartial";
-

package/src/runtime/combinators/and.ts

@@ -1,11 +0,0 @@
-import type { And } from "inferred-types/dist/types/index";
-
-/**
- * Groups a number of "logic functions" together by combining their results using
- * the logical **AND** operator
- */
-export const and = <
-  TList extends readonly boolean[],
->(...values: TList): And<TList> => {
-  return values.every(i => i === true) as And<TList>;
-};

package/src/runtime/combinators/f2.ts.HOLD

@@ -1,241 +0,0 @@
-import { AfterFirst,  First,  SimplifyObject, TupleToUnion, UnionToTuple, WithoutValue } from "inferred-types/dist/types/index";
-import { AsArray } from "inferred-types/dist/types/index";
-import { withoutValue } from "inferred-types/dist/types/index";
-
-/** ways in which an "undefined" value should be handled in a filter function */
-export type FilterUndefinedBehavior = "filter out" | "throw error" | "do not allow";
-
-/** the configuration of a filter */
-export interface FilterConfig {
-  config: Readonly<WithoutValue<undefined, {}>>;
-  equals: readonly (string | number)[] | undefined;
-  notEqual: readonly (string | number)[] | undefined;
-  contains: readonly string[] | undefined;
-  startsWith: readonly string[] | undefined;
-  endsWith: readonly string[] | undefined;
-  greaterThan: number | undefined;
-  lessThan: number | undefined;
-  boolean: boolean | undefined;
-  undefined: FilterUndefinedBehavior;
-};
-
-
-export type AddProp<D extends {}, K extends string & keyof FilterConfig, V> = SimplifyObject<D & Record<K,V>> & FilterConfig;
-
-
-export type FilterApi<TExclude extends string[], TConfig extends FilterConfig> = Exclude<{
-  /**
-   * Current filter configuration
-   */
-  config: Readonly<WithoutValue<undefined, TConfig>>;
-  /**
-   * **startsWith**
-   *
-   * A _string_ condition which tests whether a string **starts** with
-   * a substring.
-   *
-   * Note: _if an array is passed in this is always logically OR'd together_
-   */
-  startsWith<S extends readonly string[]>(...v: S): FilterApi<[...TExclude, "startsWith"], AddProp<TConfig, "startsWith", AsArray<S>>>;
-  /**
-   * **endsWith**
-   *
-   * A _string_ condition which tests whether a string **ends** with
-   * a substring.
-   *
-   * Note: _if an array is passed in this is always logically OR'd together_
-   */
-  endsWith<S extends readonly string[]>(...v: S): FilterApi<[...TExclude, "endsWith"], AddProp<TConfig, "endsWith", AsArray<S>>>;
-  /**
-   * **contains**
-   *
-   * A _string_ condition which tests whether a string **contains** a given substring.
-   *
-   * Note: _if an array is passed in this is always logically OR'd together_
-   */
-  contains<S extends readonly string[]>(...v: S): FilterApi<[...TExclude, "contains"], AddProp<TConfig, "contains", S>>;
-
-  /**
-   * **equals**
-   *
-   * A _string_ or a _numeric_ condition which tests whether the passed in element
-   * is **Equal** to the value/values stated here.
-   *
-   * Note: _if an array is passed in this is always logically OR'd together_
-   */
-  equals<M extends readonly (string | number)[]>(v: M): FilterApi<[...TExclude, "equals"], AddProp<TConfig, "equals", M>>;
-
-  /**
-   * **notEqual**
-   *
-   * A _string_ or a _numeric_ condition which tests whether the passed in element
-   * is **NOT Equal** to the value/values stated here.
-   *
-   * Note: _if an array is passed in this is always logically OR'd together_
-   */
-  notEqual<M extends readonly (string | number)[]>(...v: M): FilterApi<[...TExclude, "notEqual"], AddProp<TConfig, "startsWith", AsArray<M>>>;
-
-  /**
-   * **lessThan**
-   *
-   * A _numeric_ condition which tests whether values passed in
-   * are **less than** in value than the amount expressed here.
-   *
-   * Note: _if an array is passed in this is always logically OR'd together_
-   */
-  lessThan<N extends number>(v: N): FilterApi<[...TExclude, "lessThan"], AddProp<TConfig, "lessThan", N>>;
-
-  /**
-   * **greaterThan**
-   *
-   * A _numeric_ condition which tests whether values passed in
-   * are **greater than** in value than the amount expressed here.
-   *
-   * Note: _if an array is passed in this is always logically OR'd together_
-   */
-  greaterThan<N extends number | readonly number[]>(v: N): FilterApi<[...TExclude, "greaterThan"], AddProp<TConfig, "greaterThan", N>>;
-
-  /**
-   * **handleUndefined**
-   *
-   * Allows appropriate handling of undefined values:
-   *
-   * - `filter out` - default behavior which just returns **false** when encountered
-   * - `throw error` - the input type will _allow_ an undefined value but will throw an error if
-   * it encounters one
-   * - `do not allow` - the input type will not allow an undefined type
-   */
-  handleUndefined<H extends FilterUndefinedBehavior>(v: H): FilterApi<[...TExclude, "handleUndefined"], AddProp<TConfig, "undefined", H>>;
-
-  /**
-   * **isTrue**
-   *
-   * A _boolean_ condition which tests whether values passed in
-   * are **true**.
-   */
-  isTrue(): FilterApi<[...TExclude , "isTrue" , "isFalse"], AddProp<TConfig, "boolean", true>>;
-
-  /**
-   * **isFalse**
-   *
-   * A _boolean_ condition which tests whether values passed in
-   * are **false**.
-   */
-  isFalse(): FilterApi<[...TExclude , "isTrue" , "isFalse"], AddProp<TConfig, "boolean", false>>;
-
-
-
-}, TupleToUnion<TExclude>>;
-
-type FilterLookup<T extends string> = T extends "isFalse"
-  ? boolean
-  : T extends "isTrue"
-    ? boolean
-    : T extends "greaterThan"
-      ? number
-      : T extends "lessThan"
-        ? number
-        : T extends "notEqual"
-          ? string | number
-          : T extends "equals"
-            ? string | number
-            : T extends "startsWith"
-              ? string
-              : T extends "endsWith"
-                ? string
-                : T extends "contains"
-                  ? string
-                  : unknown;
-
-type FilterInputArr<TOutput extends readonly any[], TInput extends readonly any[]> = [] extends TInput
-  ? TOutput
-  : FilterInputArr<[...TOutput, FilterLookup<First<TInput>>], AfterFirst<TInput>>;
-
-/**
- * Type utility which receives the conditions which were used in a filter
- * to determine the filter's possible values it can receive.
- */
-export type FilterInput<T extends string> = TupleToUnion<FilterInputArr<[], UnionToTuple<T>>>;
-
-/**
- * **FilterDefn**
- *
- * A filter definition which came from the createFilter utility.
- */
-export type FilterDefn<TCond> = <T extends TCond>(input: T) => boolean;
-
-
-/**
- * **createFilter**
- *
- * A runtime utility that makes creating simple filters super easy and in a type-safe manner.
- *
- * ```ts
- * const filter = createFilter(c => c.startsWith("foo").notEqual("foobar"))
- * ```
- */
-export const createFilter = <T extends readonly string[]>(cb: <C extends FilterConfig>(defn: FilterApi<[], any>) => FilterApi<T, C>) => {
-  const initialConfig = {
-    config: {},
-    equals: undefined,
-    notEqual: undefined,
-    contains: undefined,
-    startsWith: undefined,
-    endsWith: undefined,
-    greaterThan: undefined,
-    lessThan: undefined,
-    boolean: undefined,
-    undefined: "filter out"
-  } satisfies FilterConfig;
-
-  const api = apiDefn(initialConfig)([]);
-  const state = cb(api);
-
-  return <I extends FilterInput<T>>(input: I) => {
-    //
-  };
-};
-
-const onlyConfigured = withoutValue(c => c.undefined());
-
-/**
- * The implementation of the API which maintains the state while user is manipulating it
- */
-const apiDefn = <TConfig extends FilterConfig>(config: TConfig) => <TExclude extends readonly (string & keyof FilterConfig)[]>(exclude: TExclude) => {
-  const api: FilterApi<[], TConfig> = {
-    config: onlyConfigured(config),
-    equals(...v) {
-      return apiDefn({...config, equals: v})([...exclude, "equals"]);
-    },
-    notEqual(...v) {
-      return apiDefn({...config, notEqual: v})([...exclude, "notEqual"]);
-    },
-    contains(...v) {
-      return apiDefn({...config, contains: v})([...exclude, "contains"]);
-    },
-    startsWith(...v) {
-      return apiDefn({...config, startsWith:v})([...exclude, "startsWith"]);
-    },
-    endsWith(...v) {
-      return apiDefn({...config, endsWith: v})([...exclude, "endsWith"]);
-    },
-    lessThan(v) {
-      return apiDefn({...config, lessThan: v})([...exclude, "lessThan"]);
-    },
-    greaterThan(v) {
-      return apiDefn({...config, greaterThan: v})([...exclude, "greaterThan"]);
-    },
-    isTrue() {
-      return apiDefn({...config, boolean: true})([...exclude, "boolean"]);
-    },
-    isFalse() {
-      return apiDefn({...config, boolean: false})([...exclude, "boolean"]);
-    },
-    handleUndefined(v) {
-      return apiDefn({...config, undefined: v})([...exclude, "undefined"]);
-    },
-  };
-
-  return api as FilterApi<TExclude, TConfig>;
-};
-

package/src/runtime/combinators/index.ts

@@ -1,2 +0,0 @@
-export * from "./and";
-export * from "./or";

package/src/runtime/combinators/or.ts

@@ -1,13 +0,0 @@
-import type { Or } from "inferred-types/dist/types/index";
-
-/**
- * **or**(conditions) -> boolean
- *
- * If you have a discrete list of boolean values then you can use this
- * function to perform a logical OR operation on them.
- */
-export function or<TList extends readonly boolean[]>(...conditions: TList) {
-  const values: unknown = conditions.some((v: boolean) => v === true ? true : false);
-
-  return values as Or<TList>;
-}

package/src/runtime/dictionary/defineOptions.ts

@@ -1,82 +0,0 @@
-import {
-  Dictionary,
-  KeyOf,
-  MakeKeysOptional,
-  MakeKeysRequired,
-  RequiredKeys,
-} from "inferred-types/dist/types/index"
-import {
-  createFnWithProps,
-} from "src/runtime/index"
-
-
-export type UserOptions<
-  TDefn extends Dictionary,
-  TReq extends ((string|symbol) & keyof TDefn)
-> = TReq extends ""
-? <
-    T extends Partial<TDefn>,
-    R extends TDefn
-  >(opt?: T) => R & { param: MakeKeysRequired<Partial<TDefn>, TReq> }
-: TReq extends readonly (keyof TDefn)[]
-? <
-    T extends MakeKeysRequired<Partial<TDefn>, TReq>,
-    R extends TDefn
-  >(opt: T) => R & { param: MakeKeysRequired<Partial<TDefn>, TReq> }
-: never;
-
-
-export type AsUserOptions<
-  TDefn extends Dictionary,
-  _TDefaults extends Partial<TDefn>
-> = UserOptions<
-TDefn,
-RequiredKeys<TDefn>
->;
-
-const _userOptions = <
-  TDefn extends Dictionary,
-  TDefaults extends Partial<TDefn>
->(def_values: TDefaults) => createFnWithProps(
-  <T extends KeyOf<TDefaults> extends ""
-    ? TDefn
-    : MakeKeysOptional<TDefn, KeyOf<TDefaults>>>(opt: T) => {
-    return {
-      ...def_values,
-      opt
-    } as unknown as TDefn & TDefaults & T
-  },
-  { param: null as unknown as MakeKeysOptional<TDefn, KeyOf<TDefaults>> }
-);
-
-/**
- * **defineOptions**`<T>(def_values?: () => { .. }) → UserOptions<T, TReq>`
- *
- * Defines:
- *   1. a set of options,
- *   2. allows default values to be assigned,
- *   3. then provides
- * a type for user input which makes all properties that were optional or have
- * a default value be optional while also providing a type-strong merge function
- * to merge in their results.
- * ```ts
- * // {
- * //    userOptions: {width?: number; height: number}},
- * //    merge<U>(user: U) => T
- * // }
- * const opts = defineOptions<{width: number; height: number}() => ({width: 640});
- * ```
- */
-// export const defineOptions = <
-//   T extends Dictionary
-// >(a: ({defaults: (<D extends Partial<T>>() => D)): void) => {
-
-//   return userOptions(cb());
-// };
-
-
-
-
-
-
-

package/src/runtime/dictionary/entries.ts

@@ -1,34 +0,0 @@
-import { KeyValue, Narrowable } from "inferred-types/dist/types/index";
-import { keysOf } from "src/runtime/index";
-
-
-/**
- * **entries**
- *
- * Provides an _iterable_ over the passed in dictionary object where each iteration
- * provides a tuple of `[ key, value ]` which preserve type literals.
- *
- * For example:
- * ```ts
- * const obj = { foo: 1, bar: "hi" };
- * // k type is "foo" then "bar"; v type is 1 then "hi"
- * for (const [k, v] of entries(obj)) { ... }
- * ```
- */
-export function entries<
-  N extends Narrowable,
-  T extends Record<PropertyKey, N>,
-  I extends KeyValue<T, keyof T>
->(obj: T) {
-  const iterable = {
-    *[Symbol.iterator]() {
-      for (const k of keysOf(obj)) {
-        // const [k, v] = entry as KeyValue<T, First<typeof entry>>;
-        yield [k, obj[k]] as KeyValue<T, typeof k> as I;
-      }
-    },
-  };
-
-  return iterable;
-}
-