inferred-types 0.51.1 → 0.51.2

package/src/runtime/queues/lifo.ts

@@ -1,45 +0,0 @@
-import { FixedLengthArray, LifoQueue, Narrowable } from "inferred-types/dist/types/index";
-
-
-const queue =  <
-  T extends unknown[],
->(state: T): LifoQueue<T[number]> => ({
-  queue: state,
-  size: state.length,
-  isEmpty() {
-    return state.length === 0
-  },
-  push(...add) {
-    state.push(...add);
-  },
-  drop(quantity) {
-    state.splice(-quantity!);
-  },
-  clear() {
-    state.slice(0,0)
-  },
-  drain() {
-    const old_state = [...state];
-    state.slice(0,0);
-    return old_state;
-  },
-  take<Q extends number | undefined>(quantity?: Q) {
-    const result = state.slice(-quantity!);
-    state.splice(-quantity!);
-    return result as FixedLengthArray<T[number], Q extends undefined ? 1 : Q>;
-  },
-  [Symbol.iterator]: function* () {
-    for (let i = state.length - 1; i >= 0; i--) {
-      yield state[i] as T[number];
-    }
-  }
-})
-
-
-export const createLifoQueue = <
-  T extends readonly K[],
-  K extends Narrowable
->(...list: T) => {
-
-  return queue([...list]);
-}

package/src/runtime/runtime-types/README.md

@@ -1,3 +0,0 @@
-# Runtime Utilities
-
-A set of utilities which help to keep the runtime types and the _typings_ in step with one another.

package/src/runtime/runtime-types/asDefineObject.ts

@@ -1,29 +0,0 @@
-import { DefineObject } from "inferred-types/dist/types/index";
-import { FromDefn } from "inferred-types/dist/types/index";
-import { isDoneFn, isFunction, isSimpleToken } from "../type-guards";
-import { asType } from "./asType";
-import { ShapeApiImplementation } from "./shape";
-import { handleDoneFn } from "../api/handleDoneFn";
-import { ShapeCallback } from "inferred-types/dist/types/index";
-import { Never } from "inferred-types/dist/constants/index";
-
-
-export const asDefineObject = <T extends DefineObject>(defn: T) => {
-  const result =  Object.keys(defn).reduce(
-    (acc, i) => isSimpleToken(defn[i])
-      ? { ...acc, [i]: asType(defn[i]) }
-      : isDoneFn(defn[i])
-        ? { ...acc,
-            [i]: handleDoneFn((defn[i] as ShapeCallback)(ShapeApiImplementation))
-        }
-        : isFunction(defn[i])
-          ? {
-              ...acc,
-              [i]: handleDoneFn((defn[i] as ShapeCallback)(ShapeApiImplementation))
-          }
-          : Never,
-    {}
-  ) as unknown;
-
-  return result as FromDefn<T>;
-}

package/src/runtime/runtime-types/asToken.ts

@@ -1,155 +0,0 @@
-
-import {
-  SimpleContainerToken,
-  SimpleScalarToken,
-  SimpleType,
-  SimpleUnionToken,
-  TypeToken
-} from "inferred-types/dist/types/index";
-import {
-  identity,
-  isBooleanLike,
-  isNumberLike,
-  isSimpleContainerToken,
-  isSimpleScalarToken,
-  simpleScalarToken,
-  stripAfter,
-  stripBefore,
-  stripLeading,
-  stripSurround,
-  stripTrailing
-} from "src/runtime/index";
-import { Never } from "inferred-types/dist/constants/index";
-
-const scalarToToken = identity({
-  string: "<<string>>",
-  number: "<<number>>",
-  boolean: "<<boolean>>",
-  true: "<<true>>",
-  false: "<<false>>",
-  null: "<<null>>",
-  undefined: "<<undefined>>",
-  unknown: "<<unknown>>",
-  any: "<<any>>" ,
-  never: "<<never>>",
-});
-
-const _containerToToken: Record<string, unknown> = {
-  "array(string)": "",
-  "array(boolean)": "",
-  "array(number)": "",
-  "array(unknown)": "",
-}
-
-const stringLiteral = <T extends string>(str: T) => {
-  return stripAfter(stripBefore(str, "string("), ")")
-}
-const numericLiteral = <T extends string>(str: T) => {
-  return stripAfter(stripBefore(str, "number("), ")")
-}
-
-const handleOptional = <T extends SimpleScalarToken>(token: T) => {
-  const bare = stripTrailing(stripLeading(token, "Opt<"), ">");
-
-  return bare.startsWith("string")
-    ? `<<union::[ <<string>>, <<undefined>> ]>>`
-    : bare.startsWith("number")
-    ? `<<union::[ <<number>>, <<undefined>> ]>>`
-    : bare.startsWith("boolean")
-    ? `<<union::[ <<boolean>>, <<undefined>> ]>>`
-    : bare.startsWith("unknown")
-    ? `<<union::[ <<unknown>>, <<undefined>> ]>>`
-    : `<<never>>`
-}
-
-/**
- * **simpleScalarTokenToTypeToken**`(val)`
- *
- * Receives a `SimpleScalarToken` and converts it's runtime value to a
- * more full fledged `TypeToken` while converting the _type_ to be the
- * type that the token represents.
- *
- * **Related:** `simplContainerTokenToTypeToken`, `asTypeToken`
- */
-export const simpleScalarTokenToTypeToken = <T extends SimpleScalarToken>(val: T) => {
-  return (
-    val in scalarToToken
-    ? scalarToToken[val as keyof typeof scalarToToken] as unknown
-    : val.startsWith("string(")
-      ? stringLiteral(val).includes(",")
-        ? `<<union::[ ${stringLiteral(val).split(/,\s{0,1}/).map(i => `"${i}"`).join(", ")} ]>>`
-        : `<<string::${stringLiteral(val)}>>` as unknown
-    : val.startsWith("number(")
-      ? numericLiteral(val).includes(",")
-        ? `<<union::[ ${numericLiteral(val).split(/,\s{0,1}/).join(", ")} ]>>` as unknown
-        : `<<number::${numericLiteral(val)}>>` as unknown
-    : val.startsWith("Opt<")
-      ? handleOptional(val)
-    : `<<never>>` as unknown
-  ) as SimpleType<T>
-}
-
-/**
- * converts a node in the union to a proper token or tokens
- */
-const unionNode = <
-  T extends string
->(node: T) => {
-  return isNumberLike(node)
-    ? `<<number::${node}>>`
-    : isBooleanLike(node)
-    ? `<<${node}>>`
-    : isSimpleContainerToken(node)
-    ? simpleContainerTokenToTypeToken(node) as unknown
-    : isSimpleScalarToken(node)
-    ? simpleScalarToken(node)
-    : `<<string::${node}>>`
-}
-
-const union = <T extends string | readonly string[]>(nodes: T) => {
-  return Array.isArray(nodes)
-    ? nodes.map(n => unionNode(n))
-    : nodes.includes(",")
-      ? (nodes as string).split(/,\s{0,1}/).map(n => unionNode(n)).join(", ")
-      : unionNode(nodes as string)
-}
-
-const stripUnion = stripSurround("Union(", ")");
-
-/**
- * **simpleUnionTokenToTypeToken**`(val)`
- *
- * Converts a `SimpleUnionToken` to a `TypeToken` and converts the type to
- * the type _represented_ by the token.
- *
- * Note:
- * - when passing in _literals_ such as `opt(42)` it will evaluate the value
- * as being a numeric or a boolean literal and use that type if it is
- */
-export const simpleUnionTokenToTypeToken = <T extends SimpleUnionToken>(val: T) => {
-  return (
-    val.startsWith(`Union(`) && val.endsWith(`)`)
-      ? `<<union::[ ${union(stripUnion(val))} ]>>`
-      : Never
-  ) as SimpleType<T>
-}
-
-/**
- * **simpleContainerTokenToTypeToken**`(val)`
- *
- * Receives a `SimpleContainerToken` and converts it's runtime value to a
- * more full fledged `TypeToken` while converting the _type_ to be the
- * type that the token represents.
- *
- * **Related:** `simpleScalarTokenToTypeToken`, `asTypeToken`
- */
-export const simpleContainerTokenToTypeToken = <T extends SimpleContainerToken>(_val: T) => {
-  // TODO
-}
-
-
-// TODO
-export const asTypeToken = <T extends TypeToken>(_val: T) => {
-  return "not ready"
-}
-

package/src/runtime/runtime-types/asType.ts

@@ -1,57 +0,0 @@
-import { DefineObject } from "inferred-types/dist/types/index";
-import { FromDefn } from "inferred-types/dist/types/index";
-import {
-  AsType,
-  ShapeCallback,
-  SimpleScalarToken,
-  SimpleToken,
-  SimpleType
-} from "inferred-types/dist/types/index";
-import { isFunction } from "../type-guards/isFunction";
-import {  ShapeApiImplementation } from "./shape";
-import { handleDoneFn } from "../api";
-import { isDefineObject } from "../type-guards";
-import { asDefineObject } from "./asDefineObject";
-
-/**
- * **asType**(token)**
- *
- * Converts a `SimpleToken` into it's corresponding _type_.
- *
- * - also allows a `ShapeCallback` for more advanced types
- *    - this includes `DefineObject` key-values
- *    - also allows tuple generation
- * - note: that tokens generated with the callback approach
- * is not fully reverse engineerable at this point; this will
- * be added later
- */
-export const asType = <
-  T extends [SimpleToken | DefineObject ] | readonly (SimpleToken | DefineObject | ShapeCallback)[]
->(...token: T) => {
-
-  return (
-    isFunction(token)
-      ? token(ShapeApiImplementation)
-      : token.length === 1
-        ? isFunction(token[0])
-          ? handleDoneFn(token[0](ShapeApiImplementation))
-          : isDefineObject(token[0])
-            ? asDefineObject(token[0])
-            : token[0]
-        : token.map(i => isFunction(i) ? handleDoneFn(i(ShapeApiImplementation)) : i)
-  ) as unknown as T extends [SimpleToken]
-    ?  SimpleType<T[0]>
-    : T extends [DefineObject]
-      ? FromDefn<T[0]>
-      : T extends readonly (SimpleToken | DefineObject | ShapeCallback)[]
-      ? FromDefn<T>
-      : never
-}
-
-export const asStringLiteral = <
-  T extends readonly SimpleScalarToken[]
->(...values: T) => {
-
-  return values.map(i => i as unknown as AsType<typeof i>)
-}
-

package/src/runtime/runtime-types/choices.ts

@@ -1,86 +0,0 @@
-// /* eslint-disable @typescript-eslint/no-explicit-any */
-// /* eslint-disable no-use-before-define */
-// import {
-//   Choice,
-//   ChoiceValue,
-//   AsChoice,
-//   Scalar,
-//   CreateChoice,
-//   ChoiceCallback,
-//   ChoiceApiOptions,
-//   ChoiceApiConfig,
-//   ChoiceApi
-// } from "inferred-types/dist/types/index";
-// import {  isDoneFn, isFunction,  isString,  isTuple,  isUndefined } from "../type-guards/index";
-// import { shape } from "./shape";
-// import { Never } from "inferred-types/dist/constants/index";
-
-
-
-// export const createChoice: CreateChoice = <
-//   TName extends string,
-//   TValue extends ChoiceValue
-// >(name: TName, value?: TValue) => {
-//   const result: any = isUndefined(value)
-//     ? { name, value: name }
-//     : isFunction(value)
-//       ? { name, value: value(shape) }
-//       : { name, value }
-
-//   return (
-//     isDoneFn(result)
-//       ? result.done()
-//       : result
-//    ) as AsChoice<TName,TValue>;
-// }
-
-// const configureChoiceApi = <
-// TChoices extends readonly Choice[],
-// TOptions extends ChoiceApiOptions
-// >(
-//   choices: TChoices,
-//   options: TOptions
-// ): ChoiceApiConfig<TChoices,TOptions> => ({
-//   done: () => ({} as unknown as ChoiceApi<TChoices,TOptions>),
-//   allowChoicesToBeUsedOnlyOnce: () => configureChoiceApi(
-//     choices,
-//     {...options, unique: true}
-//   ),
-//   allowChoicesToBeUsedMultipleTimes: () => configureChoiceApi(
-//     choices,
-//     {...options, unique: false}
-//   ),
-//   setStyle: (style) => configureChoiceApi(
-//     choices,
-//     {...options, style}
-//   ),
-//   maximumChoices: (max) => configureChoiceApi(
-//     choices,
-//     {...options, max}
-//   )
-// });
-
-// const toChoices = <
-//   T extends readonly (string | [string, Scalar] | Choice | ChoiceCallback)[]
-// >(values: T) => {
-//   return values.map(i => isString(i)
-//     ? {name: i, value: i }
-//     : isTuple(s => s.string(), s => s.union("Scalar"))(i)
-//     ? {name: i[0], value: i[1]}
-//     : Never
-//   );
-// }
-
-
-// export const createChoiceApi = <
-//   TChoices extends readonly (string | [string, Scalar] | Choice | ChoiceCallback)[]
-// >(...choices: TChoices) => {
-//   configureChoiceApi(toChoices(choices), {
-//     unique: true,
-//     max: null,
-//     style: "fn"
-//   })
-// }
-
-
-export const choices = "NOT READY";

package/src/runtime/runtime-types/dict.hold

@@ -1,65 +0,0 @@
-// import {
-//   AsString,
-//   CreateDictHash,
-//   CreateDictShape,
-//   Dict,
-//   Keys,
-//   NarrowDictProps,
-//   Narrowable,
-//   OptDictProps,
-//   Passthrough,
-//   Values,
-// } from "inferred-types/dist/types/index";
-
-// const process =  <
-//   N extends Narrowable,
-//   TObj extends Record<string, N>,
-//   TNarrow extends readonly string[],
-//   TOpt extends readonly string[]
-// >(obj: TObj, _narrow: TNarrow, _opt: TOpt ) => {
-//   return Object.defineProperty(
-//     obj,
-//     "__id",
-//     { enumerable: false }
-//   ) as unknown as Dict<
-//   CreateDictShape<
-//     TObj,
-//     Keys<TObj> extends readonly (string & keyof TObj)[]
-//       ? Keys<TObj>
-//       : never,
-//     TNarrow,
-//     TOpt
-//   >,
-//   CreateDictHash<
-//     Values<TObj>,
-//     TNarrow,
-//     TOpt
-//   >
-// >
-// }
-
-// /**
-//  * **dict**`(obj, ...props)`
-//  *
-//  * Defines a `Dict` type which mimics the behavior of a normal JS
-//  * object but plays nicer with `let` declarations by not allowing
-//  * re-declarations.
-//  */
-// export const dict = <
-//   N extends Narrowable,
-//   TObj extends Record<string, N>,
-//   TProps extends readonly (string & (keyof TObj | `opt:${AsString<keyof TObj>}`))[] = []
-// >(obj: TObj, ...props: TProps ) => process(
-//   obj,
-//   (props || []).filter(i => !i.startsWith("opt:"))  as Passthrough<
-//     NarrowDictProps<TProps>,
-//     readonly string[],
-//     []
-//   >,
-//   (props || []).filter(i => i.startsWith("opt:")) as Passthrough<
-//     OptDictProps<TProps>,
-//     readonly string[],
-//     []
-//   >
-// );
-

package/src/runtime/runtime-types/index.ts

@@ -1,9 +0,0 @@
-
-export * from "./shape";
-export * from "./choices";
-export * from "./list";
-export * from "./ip6Prefix";
-export * from "./asType";
-export * from "./asToken";
-
-export * from "./tokens/index"

package/src/runtime/runtime-types/ip6Prefix.ts

@@ -1,20 +0,0 @@
-import { AsIp6Prefix, Ip6Group } from "inferred-types/dist/types/index";
-import { addToken } from "./shape-helpers/addToken";
-
-
-export const ip6Prefix = <T extends readonly Ip6Group[]>(...groups: T) => {
-  const empty = addToken("string") as `${string}`;
-  let count = 4 - groups.length;
-  let fillIn: typeof empty[] = [];
-  for (let index = 0; index < count; index++) {
-    fillIn.push(empty);
-  }
-  return [
-    "<<string::",
-    [
-      groups.join(":"),
-      fillIn.join(":"),
-    ].join(":") as string,
-    ">>"
-  ].join("") as unknown as AsIp6Prefix<T>
-}

package/src/runtime/runtime-types/list.ts

@@ -1,141 +0,0 @@
-/* eslint-disable no-use-before-define */
-import {
-  TupleToUnion,
-  WidenUnion,
-  List,
-  IsUnion,
-  Tuple,
-  IsTuple,
-  ObjectKey,
-  IsEqual,
-  First,
-  IsStringLiteral,
-  IsNumericLiteral,
-  AfterFirst,
-  Chars,
-  Narrowable,
-  UnionToTuple,
-  AsString,
-  IsNever,
-} from "inferred-types/dist/types/index"
-
-import { isArray } from "src/runtime/index";
-
-type ListWideType<
-  T extends readonly unknown[]
-> = IsNever<WidenUnion<TupleToUnion<T>>> extends true
-? unknown
-: WidenUnion<TupleToUnion<T>>;
-
-
-type Describe<T> = IsUnion<T> extends true
-  ? `9${AsString<UnionToTuple<T>["length"]>}`
-  : T extends string
-  ? "1"
-  : T extends number
-  ? "2"
-  : T extends boolean
-  ? "3"
-  : T extends Tuple
-    ? IsTuple<T> extends true
-      ? "tuple"
-      : "array"
-  : T extends Record<ObjectKey, infer V>
-    ? `0x${Describe<V>}>`
-  : T extends Map<unknown, infer V>
-    ? `1x${Describe<V>}>`
-  : IsEqual<T, unknown> extends true
-    ? `4`
-  : IsEqual<T, null> extends true
-    ? `5`
-  : `6`;
-
-
-type Lit<T> = T extends string
-    ? IsStringLiteral<T> extends true
-      ? First<Chars<T>>
-      : ""
-    : T extends number
-      ? IsNumericLiteral<T> extends true
-        ? `${T}`
-        : ""
-      : "";
-
-type DescribeLit<
-  T extends readonly unknown[],
-  TResult extends string = ""
-> = [] extends T
-? TResult
-: DescribeLit<
-    AfterFirst<T>,
-    `${TResult}${Lit<First<T>>}`
-  >;
-
-
-type ListHash<
-  T extends readonly unknown[]
-> = [IsEqual<T["length"], number>] extends [true]
-? `0${Describe<ListWideType<T>>}`
-: `${T["length"]}${Describe<ListWideType<T>>}${DescribeLit<T>}`
-
-export type AsList<
-  T extends readonly unknown[]
-> = List<
-  ListWideType<T>,
-  ListHash<T>
->;
-
-const createProxy = <
-  TArr extends readonly unknown[],
->(...initialize: TArr) => {
-  const state = initialize as unknown as List<ListWideType<TArr>, ListHash<TArr>>;
-  state.id = null as unknown as ListHash<TArr>;
-
-  const proxy = new Proxy(state, {}) as List<
-    ListWideType<TArr>,
-    ListHash<TArr>
-  >;
-  Object.defineProperty(proxy, "id", {
-    enumerable: false
-  })
-
-  return proxy;
-}
-
-
-/**
- * **list**([init])
- *
- * Creates a `List` container which aims to behave _exactly_ like a
- * [Javascript Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
- * but with the exception that when declared as a variable (aka, `let` or `var`,
- * not `const`), the variable can't be replaced with another raw array declaration.
- *
- * ```ts
- * // List<number>
- * let a = list([1,2,3]);
- * // mutate the list
- * a.push(4);
- * // NOT allowed
- * a = [4,5,6];
- * // pass into fn as a reference
- * const fn = (v: List<number>) => { v.push(4); return v; }
- * // List<number> with values [1,2,3,4]
- * fn(list([1,2,3]));
- * ```
- */
-export const list = <
-  TList extends readonly N[] | readonly [ readonly N[] ],
-  N extends Narrowable,
->(...init: TList) => {
-
-  return (
-    init.length === 1 && isArray(init[0])
-      ? createProxy(...init[0])
-      : createProxy(...init)
-  ) as unknown as TList extends readonly [ readonly N[] ]
-    ? List<ListWideType<TList[0]>, ListHash<TList[0]>>
-    : TList extends readonly N[]
-    ? List<ListWideType<TList>, ListHash<TList>>
-    : never;
-}

package/src/runtime/runtime-types/rec.ts

@@ -1,11 +0,0 @@
-import { Narrowable } from "inferred-types/dist/types/index";
-
-
-export const rec = <
-  N extends Narrowable,
-  TObj extends Record<string, N>
->(
-  _obj: TObj
-) => {
-  //
-};

package/src/runtime/runtime-types/shape-helpers/addToken.ts

@@ -1,11 +0,0 @@
-import { TypeToken, TypeTokenKind } from "inferred-types/dist/types/index";
-
-/**
- * Adds any `TypeToken` by receiving the `TypeTokenKind` and then whatever
- * parameters that type requires.
- */
-export const addToken = <
-  T extends TypeTokenKind,
-  TData extends readonly string[]
->(token: T, ...params: TData) =>
-  `<<${token}${params.length> 0 ? `::${params.join("::")}` : ""}>>` as TypeToken;

package/src/runtime/runtime-types/shape-helpers/atomics.ts

@@ -1,21 +0,0 @@
-import { isDefined, isFalse, isTrue } from "src/runtime/index";
-import { addToken } from "./addToken";
-import { If, IsTrue, IsFalse } from "inferred-types/dist/types/index";
-
-export const boolean = <L extends boolean>(literal?: L) => (
-  isDefined(literal)
-    ? isTrue(literal)
-      ? addToken("true")
-      : isFalse(literal)
-        ? addToken("false")
-        : addToken("boolean")
-    : addToken("boolean")
-) as unknown as If<IsTrue<L>, true, If<IsFalse<L>, false, boolean>>;
-
-export const unknown = () => "<<unknown>>" as unknown;
-
-export const undefinedType = () => "<<undefined>>" as unknown as undefined;
-
-export const nullType = () => "<<null>>" as unknown as null;
-
-export const never = () => "<<never>>" as unknown as never;