inferred-types 0.50.29 → 0.51.1

package/src/runtime/queues/lifo.ts

@@ -0,0 +1,45 @@
+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

@@ -0,0 +1,3 @@
+# 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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,155 @@
+
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,86 @@
+// /* 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

@@ -0,0 +1,65 @@
+// 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

@@ -0,0 +1,9 @@
+
+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

@@ -0,0 +1,20 @@
+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

@@ -0,0 +1,141 @@
+/* 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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,21 @@
+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;