inferred-types 0.51.0 → 0.51.1

package/src/runtime/functional/index.ts

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

package/src/runtime/functional/result.ts

@@ -0,0 +1,309 @@
+// /* eslint-disable @typescript-eslint/no-explicit-any */
+// /* eslint-disable no-use-before-define */
+// import { RESULT } from "inferred-types/dist/constants/index"
+// import {
+//   Ok,
+//   Result,
+//   AsFunction,
+//   Narrowable,
+//   Err,
+//   ResultErr,
+//   ObjectKey,
+//   ResultTuple,
+//   TupleToUnion,
+//   ResultApi,
+//   IfEqual,
+//   IsOk,
+//   IsErr,
+//   ErrInput,
+//   IsFunction,
+//   If,
+// } from "inferred-types/dist/types/index"
+// import { Never } from "inferred-types/dist/constants/index";
+// import { isFunction, isObject, isString } from "../type-guards/index";
+// import { toKebabCase } from "../literals/toKebabCase";
+// import { asUnion } from "../type-conversion/asUnion";
+// import { isRuntimeUnion } from "../type-guards/isRuntimeUnion";
+// import { takeProp } from "../dictionary";
+// import { kindError } from "../errors";
+// import { toPascalCase } from "../literals";
+
+// const errInputs: ErrInput = "undefined" as const;
+
+// export const isResult = (val: unknown): val is Result => {
+//   return typeof val === "object" &&
+//     "__kind" in (val as object) &&
+//     "state" in (val as object) &&
+//     [RESULT.Err, RESULT.Ok].includes((val as any).state)
+// }
+
+
+// function resultTuple<
+//   T,
+//   E extends ErrInput
+// >(val: T, err: E) {
+//   return {
+//     __kind: ["Result", val, err]
+//   } as ResultTuple<T,E>;
+// }
+
+// export const asResult = <
+//   T,
+//   E extends ErrInput
+// >(val: T, err: E): ResultApi<T,E> => ({
+//   kind: "Result API",
+//   result: null as unknown as Result<T,E>,
+//   ok: (v) => {
+//     return {
+//       ...resultTuple(val,err), state: RESULT.Ok, val: v
+//     } as Ok<T>
+//   },
+//   err: (e) => {
+//     return {
+//       ...resultTuple(val,err),
+//       state: RESULT.Err,
+//       err: transformErrInput(e)
+//     } as unknown as Err<E>
+//   },
+//   isErr: (v) => {
+//     return isResult(v) && v.state === RESULT.Err;
+//   },
+//   isOk: (v) => {
+//     return isResult(v) && v.state === RESULT.Ok;
+//   },
+//   okOrElse: (result, otherwise) => {
+//     return result.state === RESULT.Ok
+//       ? result.val
+//       : typeof otherwise === "function"
+//         ? otherwise(result)
+//         : otherwise
+//   },
+//   okOrThrow: (result) => {
+//     if (isErr(result)) {
+//       const { msg, kind, context } = result.err;
+//       throw kindError(kind)(msg, context);
+//     }
+//   }
+// }) as ResultApi<T,E>;
+
+
+
+// /**
+//  * **ok**(val)
+//  *
+//  * Places a value into the `Ok` state of a `Result` structure.
+//  *
+//  * Note: if you need/want the value to be narrowly typed then use `okN()` instead.
+//  */
+// export function ok<
+//   T,
+//   E extends ErrInput
+// >(val: T, _err: E = errInputs as E): IfEqual<E, ErrInput, Ok<T>, Ok<T,E>> {
+//   const tuple = resultTuple(val, _err) as unknown as ResultTuple<T,E>;
+//   return { ...tuple, state: RESULT.Ok, val }
+// }
+
+
+// /**
+//  * **ok**(val)
+//  *
+//  * Places a value into the `Ok` state of a `Result` structure.
+//  *
+//  * Note: this can only receive _narrowable_ types in order to provide the
+//  * narrowest type possible for `T` but if you don't need this then use the
+//  * `ok(val)` function instead.
+//  */
+// export function okN<
+//   T extends Narrowable,
+//   E extends ErrInput
+// >(val: T, _err: E = errInputs as E): Ok<T> {
+//   const tuple = resultTuple(val, "unknown") as unknown as ResultTuple<T,E>;
+//   return { ...tuple, state: RESULT.Ok, val }
+// }
+
+// /**
+//  * Used to convert an `ErrInput` into `ResultErr[]`
+//  */
+// const transformErrInput = <
+//   T extends ErrInput
+// >(input: T): TupleToUnion<Err<T>> => {
+//   const members = (
+//     isRuntimeUnion(input)
+//     ? input.members
+//     : typeof input === "string"
+//     ? [{ msg: input, kind: toKebabCase(input as string), context: {} }]
+//     : typeof input === "object"
+//     ? [{
+//       msg: takeProp((input as Record<ObjectKey, unknown>), "msg", "" as string),
+//       kind: toKebabCase(takeProp((input as Record<ObjectKey, unknown>), "kind", "unspecified-kind") as string),
+//       context: takeProp((input as Record<ObjectKey, unknown>), "context", {} as NonNullable<unknown>),
+//       trace: takeProp((input as Record<ObjectKey, unknown>), "trace", false),
+//     }]
+//     : Array.isArray(input)
+//     ? input
+//     : Never
+//   ) as ResultErr[];
+
+//   const union =  asUnion(...members);
+
+//   return union as unknown as TupleToUnion<Err<T>>;
+// }
+
+// /**
+//  * **createErr**(e) → `<ResultErr>`
+//  *
+//  * Creates a reusable error template which will allow for:
+//  *
+//  * - a strict `kind` definition
+//  * - a _shape_ and default values for the `context` property
+//  * - a strict `stack` definition (default is false)
+//  *
+//  * The `msg` property will be left as `string` allowing each variant of
+//  * this type of error to add their own.
+//  */
+// export const createErr = <
+//   TKind extends string,
+//   TContextDefn extends Record<string, unknown> = NonNullable<unknown>
+// >(kind: TKind, contextDefn?: TContextDefn) => {
+//   return {
+//     msg: "" as string,
+//     kind,
+//     context: (contextDefn || {}) as TContextDefn
+//   } as ResultErr<TKind, TContextDefn>
+// }
+
+// /**
+//  * **err**(input) -> Err`<E>`
+//  *
+//  * Creates a `Err` error for use inside a `Result<T,E>` block.
+//  */
+// export function err<
+//   TErr extends string | ResultErr<any, any>,
+//   TVal = unknown
+// >(
+//   err: TErr,
+//   _val: TVal = null as unknown as ErrInput as TVal
+// ): IfEqual<TVal, unknown, Err<TErr>, Err<TErr,TVal>> {
+//   return {
+//     ...(resultTuple(_val, err)),
+//     state: RESULT.Err,
+//     err: transformErrInput(err)
+//   } as unknown as IfEqual<TVal, unknown, Err<TErr>, Err<TErr,TVal>>
+// }
+
+
+// /**
+//  * **isOk**(result)
+//  *
+//  * Type guard which tests whether the `Result<T,E>` is in the **Ok** state.
+//  */
+// export const isOk = <
+//   T,
+// >(result: Result<T>): result is T & Ok<T> => {
+//   return result.state === RESULT.Ok;
+// }
+
+
+// /**
+//  * **okOrThrow**(result)
+//  *
+//  * Returns the Ok _value_ if it's in the Ok status; otherwise throws
+//  * an error.
+//  */
+// export function okOrThrow<
+//   R extends Result<T,E>,
+//   T = undefined,
+//   E extends ErrInput = ErrInput
+// >(result: R): IsOk<R> extends true ? T : never {
+//   if(result.state === RESULT.Err) {
+//     if (typeof result.err === "string") {
+//       throw new Error(result.err);
+//     } else {
+//       let e = new Error(result.err.msg);
+//       for (const key of Object.keys(result.err)) {
+//         if(key !== "msg") {
+//           e = {...e, [key]: result.err[key as keyof typeof result.err]}
+//         }
+//       }
+//       throw e;
+//     }
+//   }
+//   return result.val as IsOk<R> extends true ? T : never;
+// }
+
+// /**
+//  * **okOrElse**(result, els)
+//  *
+//  * Returns the _value_ of the `Result<T,E>` if in the **Ok** state, otherwise
+//  * returns `els`.
+//  *
+//  * - **Note:** if `els` is a function it will be called while passing the error
+//  * object to the function.
+//  */
+// export function okOrElse<
+//   R extends Result<T,E>,
+//   T,
+//   E extends ResultErr,
+//   Els
+// >(
+//   result: R,
+//   els: Els
+// ): IsOk<R> extends true ? T : If<IsFunction<Els>, ReturnType<AsFunction<Els>>, Els> {
+//   return result.state === RESULT.Err
+//   ? isFunction(els)
+//     ? els(result.err)
+//     : els
+//   : result.val;
+// }
+
+// export function isErr<
+//   T,
+//   E extends ErrInput
+// >(result: Result<T,E>): result is Err<E,T> {
+//   return (
+//       isString(result)
+//       ? {
+//           state: RESULT.Err,
+//           err:{
+//             msg: result,
+//             kind: toPascalCase(result),
+//             context: {},
+//             stack: false
+//           }
+//         }
+//       : isObject(result)
+//         ? {
+//           state: RESULT.Err,
+//           err: {
+//             msg: result.err.msg || "no message",
+//             kind: takeProp(result, "kind", "no-kind"),
+//             context: takeProp(result, "context", {}),
+//             stack: takeProp(result, "stack", false)
+//           }
+//         }
+//         : false
+//     )
+//     ? true
+//     : false
+// }
+
+// /**
+//  * **assertErr**(result)
+//  *
+//  * Asserts that a _result_ is of the `Err` type.
+//  */
+// export function assertErr<
+//   T
+// >(result: T): IsErr<T> {
+//   return (
+//     typeof result === "object" &&
+//     (result as any).state === RESULT.Err && "err" in (result as object) && (
+//       typeof (result as any).err === "string" ||
+//       typeof (result as any).err === "object"
+//     )
+//     ? true
+//     : false
+//   ) as IsErr<typeof result>;
+// }
+
+export const result = "NOT READY"

package/src/runtime/functions/fnMeta.ts

@@ -0,0 +1,27 @@
+import { AnyFunction,  AsFnMeta } from "inferred-types/dist/types/index";
+
+type _Props<TFn extends AnyFunction> = AsFnMeta<TFn>["props"];
+
+/**
+ * **fnMeta**(func)
+ *
+ * Runtime utility which provides a `fn` and `props` property which are
+ * decomposed from the input function.
+ *
+ * - the `fn` is a clone of the underlying function
+ */
+export const fnMeta = <TFn extends AnyFunction>(func: TFn) => {
+  const fn = <
+    A extends AsFnMeta<TFn>["args"]
+  >(...args:  A) => func(...args);
+
+  const props = Object.keys(fn).reduce(
+    (acc, key) => ({...acc, [key]: fn[key as keyof typeof fn] }),
+    {} as Record<PropertyKey, unknown>,
+  ) as _Props<TFn>;
+
+  return {
+    fn,
+    props
+  };
+};

package/src/runtime/functions/index.ts

@@ -0,0 +1,3 @@
+
+export * from "./fnMeta";
+export * from "./wrapFn";

package/src/runtime/functions/wrapFn.ts

@@ -0,0 +1,32 @@
+// import { FnFrom } from "inferred-types/dist/types/index";
+// import { identity } from "../literals";
+
+
+
+// export const wrapFn = <
+//   TInteriorFn extends TypedFunction,
+// >(fn: TInteriorFn) => {
+//   return <
+//     TWrap extends <I extends ReturnType<TInteriorFn>>(input: I) => unknown
+//   >(wrap: TWrap) => <F extends Parameters<TInteriorFn>>(...input: F) => {
+//     const interior = fn(input) as ReturnType<TInteriorFn>;
+//     return wrap(interior) as ReturnType<TWrap>
+//   }
+// };
+
+// export const wrapFn = <
+//   TWrap extends FnFrom<[any]>,
+// >(wrap: TWrap) => {
+//   return <TInterior extends (...args: any[]) => Parameters<TWrap>[0]>(fn: TInterior) => {
+//     return <TFn extends Parameters<TInterior>>(...args: TFn) => {
+//       const interior = identity(fn(...args) as ReturnType<TInterior>) as ()=>ReturnType<TInterior>;
+//       const wrapped = wrap(interior()) as ReturnType<TWrap>;
+
+//       return wrapped;
+//     }
+//   }
+// };
+
+
+
+export const wrapFn = "NOT IMPLEMENTED" as const;

package/src/runtime/index.ts

@@ -0,0 +1,18 @@
+
+export * from "./api/index";
+export * from "./boolean-logic/index";
+export * from "./combinators/index";
+export * from "./dictionary/index";
+export * from "./errors/index";
+export * from "./functional/index";
+export * from "./functions/index";
+export * from "./initializers/index";
+export * from "./lists/index";
+export * from "./literals/index";
+export * from "./meta/index";
+export * from "./queues/index";
+export * from "./runtime-types/index";
+export * from "./sets/index";
+export * from "./type-conversion/index";
+export * from "./type-guards/index";
+export * from "./vuejs/index"

package/src/runtime/initializers/addFnToProps.ts

@@ -0,0 +1,35 @@
+
+import {  FnWithProps, Narrowable, TypedFunction,  } from "inferred-types/dist/types/index";
+
+/**
+ * **addPropsToFn**(fn, [clone]) => (props) => FnWithProps
+ *
+ * A higher order function which takes a dictionary object and
+ * then a function and combines them into a single type.
+ */
+export const addPropsToFn = <
+  TFn extends TypedFunction,
+  TClone extends boolean | undefined
+>(fn: TFn, clone_fn?: TClone) => {
+    const localFn: any = clone_fn
+      ? <T extends Parameters<TFn>>(...args: T) => fn(args)
+      : fn;
+
+    return <
+      K extends PropertyKey,
+      N extends Narrowable,
+      TProps extends Record<K,N>
+    >(obj: TProps) => {
+
+      for (const k in obj) {
+        localFn[k] = obj[k];
+      }
+
+      return localFn as FnWithProps<
+        TFn,
+        TProps,
+        TClone
+      >;
+
+    };
+};

package/src/runtime/initializers/addPropsToFn.ts

@@ -0,0 +1,42 @@
+import {
+  FnWithProps,
+  Narrowable,
+  TypedFunction
+} from "inferred-types/dist/types/index";
+
+/**
+ * **addFnToProps**(props, [clone]) => (fn) => FnWithProps
+ *
+ * A higher order function which takes
+ *
+ * - `props` - key/value pairs to add to the a _future_ function
+ * - `clone` - optionally state whether you want to use the future function's
+ * type "as is" or you want to purify it's props with a clone (default is `true`)
+ *
+ * This is partially applied to reveal a function which takes a
+ * function as input.
+ */
+export const addFnToProps = <
+  K extends string,
+  N extends Narrowable,
+  TProps extends Record<K,N>,
+  TClone extends boolean | undefined
+
+>(props: TProps, _clone_fn?: TClone) =>
+<
+  TFn extends TypedFunction
+>(fn: TFn) => {
+
+    const localFn: any =  <T extends Readonly<Parameters<TFn>>>(...args: T) => fn(args);
+
+    for (const k in props) {
+      localFn[k] = props[k];
+    }
+
+    return localFn as FnWithProps<TFn,TProps,TClone>;
+
+  };
+
+  // export const narrowFn = <
+  //   TFn extends AnyFunction
+  // >(fn: TFn) => <TArgs extends AsFnMeta<TFn>["args"]>(...args: TArgs) => <R extends AsFnMeta<TFn>["returns"]>(fn(args): R) =>  ;

package/src/runtime/initializers/createCssSelector.ts

@@ -0,0 +1,78 @@
+import { If, IsUndefined } from "inferred-types/dist/types/index";
+import {
+  CssClassSelector,
+  CssIdSelector,
+  CssPseudoClass,
+  CssSelector,
+  CssTagSelector,
+  Join
+} from "inferred-types/dist/types/index";
+import { TupleToUnion } from"inferred-types/dist/types/index";
+
+export type CssSelectorOptions = {
+  ids?: readonly CssIdSelector[],
+  classes?: readonly CssClassSelector[],
+  tags?: readonly CssTagSelector[],
+  pseudo?: readonly CssPseudoClass[]
+};
+
+export type AsClassSelector<
+  T extends CssSelectorOptions | undefined
+> = If<
+  IsUndefined<T>,
+  CssSelector<CssIdSelector, CssClassSelector, CssTagSelector, CssPseudoClass>,
+  T extends CssSelectorOptions
+  ? CssSelector<
+      If<
+        IsUndefined<T["ids"]>,
+        CssIdSelector,
+        TupleToUnion<T["ids"]>
+      >,
+      If<
+        IsUndefined<T["classes"]>,
+        CssClassSelector,
+        TupleToUnion<T["classes"]>
+      >,
+      If<
+        IsUndefined<T["tags"]>,
+        CssTagSelector,
+        TupleToUnion<T["tags"]>
+      >,
+      If<
+        IsUndefined<T["pseudo"]>,
+        CssPseudoClass,
+        TupleToUnion<T["pseudo"]>
+      >
+    >
+  : never
+>;
+
+
+
+
+/**
+ * **createCssSelector**`(opt) => (...select) => string`
+ *
+ * A higher order utility which:
+ *
+ * - on first call allows you to _narrow_ the types of selectors which are
+ * available
+ * - afterward it allows 1..M selectors to be chained (including pseudo
+ * classes)
+ *
+ * Ensures correct syntax and aids in auto-completion of CSS props.
+ */
+export const createCssSelector = <
+  TOpt extends CssSelectorOptions,
+>(
+  _opt?: TOpt
+) => <
+  TSelect extends readonly CssSelector<
+    TOpt["ids"] extends readonly CssIdSelector[] ? TupleToUnion<TOpt["ids"]> : CssIdSelector,
+    TOpt["classes"] extends readonly CssClassSelector[] ? TupleToUnion<TOpt["classes"]> : CssClassSelector,
+    TOpt["tags"] extends readonly CssTagSelector[] ? TupleToUnion<TOpt["tags"]> : CssTagSelector,
+    TOpt["pseudo"] extends readonly CssPseudoClass[] ? TupleToUnion<TOpt["pseudo"]> : CssPseudoClass
+  >[]
+>(...selectors: TSelect): Join<TSelect, " "> => {
+  return selectors.join(" ") as string as Join<TSelect, " ">
+}

package/src/runtime/initializers/createFnWithProps.ts

@@ -0,0 +1,40 @@
+import {
+  If,
+  IsTrue,
+  Narrowable,
+  ObjectKey,
+} from "inferred-types/dist/types/index";
+import { isTrue } from "src/runtime/index";
+
+
+/**
+ * **createFnWithProps**`(fn, props)`
+ *
+ * creates a strongly typed function along with properties.
+ */
+export const createFnWithProps = <
+  TArgs extends readonly unknown[],
+  TReturn extends Narrowable,
+  N extends Narrowable,
+  TProps extends Record<ObjectKey, N>,
+  TNarrowing extends boolean = false
+>(
+  fn: (...args: TArgs) => TReturn,
+  props: TProps,
+  narrowing: TNarrowing = false as TNarrowing
+) => {
+  let fnWithProps: any = fn;
+  for (let prop of Object.keys(props)) {
+    fnWithProps[prop] = props[prop];
+  }
+
+  return (
+    isTrue(narrowing)
+      ? fnWithProps as (<A extends Readonly<TArgs>>(...args: A) => TReturn) & TProps
+      : fnWithProps as ((...args: TArgs) => TReturn) & TProps
+  ) as If<
+    IsTrue<TNarrowing>,
+    (<A extends TArgs>(...args: A) => TReturn) & TProps,
+    ((...args: TArgs) => TReturn) & TProps
+  >;
+}

package/src/runtime/initializers/defineObj.ts

@@ -0,0 +1,55 @@
+import {
+  EmptyObject,
+  ExpandDictionary,
+  IsNonEmptyObject,
+  Narrowable,
+  RemoveIndex,
+  Widen
+} from "inferred-types/dist/types/index";
+
+/**
+ * **defineObj**(literal) -> (wide) -> object
+ *
+ * A runtime utility designed to create an object _type_ from runtime objects.
+ * The object's keys are all type literals, but the values can be either
+ * _wide_ variants of the value passed in or instead maintain as _narrow_
+ * a type definition as possible.
+ *
+ * ### Example
+ * ```ts
+ * // { foo: 1; bar: number; baz: number }
+ * const fooBarBaz = defineObj({foo: 1})({bar: 2, baz: 3});
+ * ```
+ */
+export function defineObj<
+  N extends Narrowable,
+  TLiteral extends Record<string, N>
+>(
+  literal: TLiteral = {}  as TLiteral
+) {
+  /**
+   * Add any key/value pairs which you want to have _wide_ types associated;
+   * literal types are defined already and stated above.
+   */
+  return <
+    N2 extends Narrowable,
+    TWide extends Record<string,N2>,
+  >(wide: TWide = {} as EmptyObject as TWide) => {
+    const obj = (
+      literal
+        ? { ...literal, ...wide  }
+        : wide
+    ) as unknown;
+
+
+    return obj as ExpandDictionary<
+      RemoveIndex<TLiteral> & (
+        IsNonEmptyObject<TWide> extends true
+          ? Widen<TWide>
+          : EmptyObject
+        )
+      >;
+  };
+};
+
+

package/src/runtime/initializers/defineTuple.ts

@@ -0,0 +1,28 @@
+import { FromDefn, ShapeCallback, TypeDefinition } from "inferred-types/dist/types/index";
+import { isFunction, handleDoneFn, ShapeApiImplementation } from "src/runtime/index";
+
+/**
+ * **createTuple**(...values) -> (...values) -> Tuple
+ *
+ * Runtime utility to define a strongly typed tuple.
+ *
+ * - if you want to _widen_ certain elements in the Tuple you can use
+ * the `widen()` type utility for those elements.
+ *
+ * ### Example
+ * ```ts
+ * // [ "foo", "bar", 42 ]
+ * const foobar = defineTuple("foo", "bar", 42)
+ * // [ string, "bar", 42]
+ * const foey = defineTuple(s => s.string(), "bar", 42)
+ * ```
+ */
+export const defineTuple = <
+  T extends readonly TypeDefinition[]
+>(...values: T) => {
+  return values.map(
+    i => isFunction(i)
+      ? handleDoneFn((i as ShapeCallback)(ShapeApiImplementation))
+      : i
+  ) as unknown as FromDefn<T>
+};

package/src/runtime/initializers/index.ts

@@ -0,0 +1,6 @@
+export * from "./addFnToProps";
+export * from "./addPropsToFn";
+export * from "./createFnWithProps";
+export * from "./defineObj";
+export * from "./defineTuple";
+export * from "./createCssSelector";