inferred-types 0.51.1 → 0.51.2

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

@@ -1,36 +0,0 @@
-import {
-  AsLiteralFn,
-  FnArgsDefn,
-  FnPropertiesDefn,
-  FnReturnTypeDefn,
-  FromDefn,
-  FromWideTokens
-} from "inferred-types/dist/types/index";
-
-/**
- * **fn**
- *
- * provides an API surface for function definition
- */
-export const fn = <TArgs extends readonly FnArgsDefn[]>(..._args: TArgs) => ({
-  returns: <TReturn extends FnReturnTypeDefn>(_rtn: TReturn) => ({
-    addProperties: <TProps extends FnPropertiesDefn>(_kv: TProps) => {
-      // TODO
-      return null as unknown as AsLiteralFn<
-        FromWideTokens<TArgs, FromDefn<TArgs>>,
-        FromWideTokens<TReturn, FromDefn<TReturn>>,
-        FromDefn<TProps>
-      >
-    },
-    done: () => {
-      return null as unknown as AsLiteralFn<
-        FromDefn<TArgs>,
-        FromDefn<TReturn>
-      >
-    }
-  }),
-  done: () => {
-    const result:unknown = null;
-    return result as unknown as AsLiteralFn<FromDefn<TArgs>>;
-  }
-});

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

@@ -1,14 +0,0 @@
-import { Shape } from "inferred-types/dist/types/index";
-import {  stripTrailing } from "src/runtime/index"
-
-/**
- * **getTokenData**`(token)`
- *
- * Given a `Shape` token, this function will extract the
- * data parameters from the token.
- */
-export const getTokenData = <T extends Shape>(token: T) => {
-  const [_name, ...rest] = stripTrailing(token, ">>").split("::");
-
-  return rest;
-}

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

@@ -1,13 +0,0 @@
-import { Shape } from "inferred-types/dist/types/index";
-import { stripLeading } from "src/runtime/index"
-
-/**
- * **getTokenName**`(token)`
- *
- * Given a `Shape` token, this function will extract the
- */
-export const getTokenName = <T extends Shape>(token: T) => {
-  const [name, ..._rest] = stripLeading(token, "<<").split("::");
-
-  return name;
-}

package/src/runtime/runtime-types/shape-helpers/literal-containers.ts

@@ -1,18 +0,0 @@
-import { DictionaryTypeDefn, FromDefn, TupleDefn } from "inferred-types/dist/types/index";
-
-
-
-export const dictionary = <T extends DictionaryTypeDefn>(_obj: T) => {
-  // TODO
-
-  return null as unknown as FromDefn<T>
-};
-
-;
-export const tuple = <T extends readonly TupleDefn[]>(..._elements: T) => {
-  // TODO
-  return null as unknown as FromDefn<T>;
-}
-
-
-

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

@@ -1,44 +0,0 @@
-import { isRegExp, isString } from "src/runtime/index";
-import { AsType, SimpleToken } from "inferred-types/dist/types/index";
-
-/**
- * **regexToken**`(re, ...rep)`
- *
- * Creates a `TypeToken` that is a form of string literal and
- * represented in the type system via the use of the `SimpleToken`
- * elements defined in "rep" but then with the RegExp encoded into
- * the token too so that it can be used for validation during
- * runtime.
- */
-export const regexToken = <
-  TExp extends RegExp | string,
-  TRep extends readonly SimpleToken[]
->(re: TExp, ...rep: TRep ) => {
-  let exp: string="";
-
-  if (isString(re)) {
-    // regex's coming in as a string must be validated
-    try {
-      const test = new RegExp(re);
-      if (!isRegExp(test)) {
-       const err = Error(`Invalid RegEx passed into regexToken(${re}, ${JSON.stringify(rep)})!`)
-       err.name ="InvalidRegEx";
-       throw err;
-      } else {
-        exp = re as string;
-      }
-    } catch(_e) {
-      const err = Error(`Invalid RegEx passed into regexToken(${re}, ${JSON.stringify(rep)})!`)
-       err.name ="InvalidRegEx";
-       throw err;
-    }
-  } else if (isRegExp(re)) {
-    // all representations must be stored as as a string
-    exp = re.toString();
-  }
-
-  // exp has been validated as valid
-  const token = `<<string-set::regexp::${encodeURIComponent(exp)}>>`
-
-  return token as AsType<TRep>
-}

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

@@ -1,108 +0,0 @@
- import {
-  CivilianTime,
-  Dictionary,
-  Ip4Address,
-  Ip6Address,
-  MilitaryTime,
-  StringTokenUtilities,
-  TimeResolution,
-  TokenBaseType,
-  TupleToUnion,
-  TypeTokenSingletons,
-  Zip5,
-  ZipPlus4,
-  ZipCode,
-  SimpleToken,
-} from "inferred-types/dist/types/index";
-
-import { addToken } from "./addToken"
-import { regexToken } from "./regexToken";
-
-type Token<T extends string> = `<<${T}>>`;
-
-
-/**
- * Generates a token and then types it appropriates for the given Singleton
- */
-const addSingleton = <
-  T extends TypeTokenSingletons,
-  Api extends Dictionary | null = null
->(token: T, api?: Api) => <
-  L extends readonly TokenBaseType<Token<T>>[]
->(
-  ...literals: L
-) => {
-  return (
-    literals.length === 0
-    ? api
-      ? api
-      : addToken(token)
-    : literals.length === 1
-    ? addToken(token,literals[0] as any)
-    : addToken(
-        "union",
-        literals
-          .map((l: TokenBaseType<any>) => addToken(token, `${l}`))
-          .join(",")
-      )
-  ) as unknown as L["length"] extends 0
-    ? Api extends Dictionary
-      ? Api
-      : TokenBaseType<Token<T>>
-    : L["length"] extends 1
-      ? L[0]
-      : TupleToUnion<L>;
-}
-
-
-const stringApi: StringTokenUtilities<string> = ({
-  startsWith: <T extends string>(startsWith: T) => addToken(`string-set`,`startsWith::${startsWith}`) as `${T}${string}`,
-  endsWith: <T extends string>(endsWith: T) => addToken(`string-set`,`endsWith::${endsWith}`) as `${string}${T}`,
-  zip: () => addToken("string-set","Zip5") as Zip5,
-  zipPlus4: () => addToken("string-set", "Zip5_4") as ZipPlus4,
-  zipCode: () => addToken("string-set", "ZipCode") as ZipCode,
-  militaryTime: <T extends TimeResolution="HH:MM">(resolution?: T) => {
-    return addToken(
-      "string-set",
-      "militaryTime",
-      resolution || "HH:MM"
-    ) as unknown as MilitaryTime<T>
-  },
-  civilianTime: <T extends TimeResolution="HH:MM">(resolution?: T) => {
-    return addToken(
-      "string-set",
-      "militaryTime",
-      resolution || "HH:MM"
-    ) as unknown as CivilianTime<T>
-  },
-  numericString: () => addToken("string-set", "numeric") as unknown as `${number}`,
-  ipv4Address: () => addToken("string-set", "ipv4Address") as unknown as Ip4Address,
-  ipv6Address: () => addToken("string-set", "ipv6Address") as unknown as Ip6Address,
-
-  regex: <
-    TExp extends string | RegExp,
-    TRepresentation extends readonly SimpleToken[]
-  >(
-    exp: TExp,
-    ...literalRepresentation: TRepresentation
-  ) => {
-    const token = regexToken(exp, ...literalRepresentation);
-
-    return token
-  },
-
-  done: () => addToken("string")
-})
-/**
- * **string**
- *
- * The API surface for adding string tokens
- */
-export const string = addSingleton("string", stringApi);
-
-/**
- * **number**
- *
- * The API surface for adding number tokens
- */
-export const number = addSingleton("number");

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

@@ -1,15 +0,0 @@
-import { AsUnion, UnionElDefn } from "inferred-types/dist/types/index";
-
-
-/**
- * **union**
- *
- * provides API implementation for defining a union
- */
-export const union = <U extends readonly [UnionElDefn,...UnionElDefn[]]>(...elements: U) => {
-  const result: unknown = elements.map(_el => {
-    // TODO
-  });
-
-  return result as AsUnion<U>
-};

package/src/runtime/runtime-types/shape-helpers/wide-containers.ts

@@ -1,60 +0,0 @@
-import {
-  ArrayTypeDefn,
-  AsArray,
-  FromDefn,
-  HandleDoneFn,
-  MapKeyDefn,
-  MapValueDefn,
-  ObjKeyDefn,
-  RecordValueTypeDefn,
-  ShapeCallback,
-  WeakMapKeyDefn,
-  WeakMapValueDefn,
-  WideTokenNames
-} from "inferred-types/dist/types/index";
-
-
-export const record = <
-  TKey extends ObjKeyDefn = "string | symbol",
-  TValue extends RecordValueTypeDefn = "unknown"
->(_key?: TKey, _value?: TValue) => {
-  // TODO
-  return null as unknown as Record<FromDefn<TKey>, FromDefn<TValue>>
-}
-
-export const array = <T extends ArrayTypeDefn = "unknown[]">(
-  _type?: T
-) => {
-  // TODO
-  return null as unknown as AsArray<FromDefn<T>>
-};
-
-export const set = <T extends WideTokenNames | ShapeCallback = "unknown">(_type?: T) => {
-  return null as unknown as T extends ShapeCallback
-    ? Set<HandleDoneFn<ReturnType<T>>>
-    : T extends WideTokenNames
-      ? Set<FromDefn<T>>
-      : Set<unknown>;
-};
-
-export const map = <
-  TKey extends MapKeyDefn = "unknown",
-  TValue extends MapValueDefn = "unknown"
->(_key?: TKey, _value?: TValue) => {
-  // TODO
-  return null as unknown as Map<FromDefn<TKey>, FromDefn<TValue>>;
-}
-
-export const weakMap = <
-  TKey extends WeakMapKeyDefn = "object",
-  TValue extends WeakMapValueDefn = "unknown"
->(_key?: TKey, _value?: TValue) => {
-  // TODO
-  return null as unknown as WeakMap<
-    FromDefn<TKey> extends object
-    ? FromDefn<TKey>
-    : never,
-    FromDefn<TValue>
-  >;
-}
-

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

@@ -1,87 +0,0 @@
-import { SHAPE_PREFIXES } from "inferred-types/dist/constants/index";
-import {
-  Shape,
-  ShapeTupleOrUnion,
-  ShapeApi as TShapeApi,
-  ShapeCallback,
-  HandleDoneFn,
-} from "inferred-types/dist/types/index";
-import { isString, hasKeys, isObject, handleDoneFn,  } from "src/runtime/index";
-import { boolean, nullType, undefinedType, unknown } from "./shape-helpers/atomics";
-import { number, string } from "./shape-helpers/singletons";
-import { fn } from "./shape-helpers/functions";
-import { dictionary, tuple } from "./shape-helpers/literal-containers";
-import { array, map, record, set, weakMap } from "./shape-helpers/wide-containers";
-import { union } from "./shape-helpers/union";
-
-const isAddOrDone = <T>(val: T): val is ShapeTupleOrUnion & T => {
-  return isObject(val) && hasKeys("add", "done") && typeof val.done === "function" && typeof val.add === "function"
-}
-
-/*
- * **Shape Api** _Implementation_
- *
- * This API surface is intended to be used to create a string-based
- * **token** which _represents_ a fully typed _type_.
- *
- * Even though the runtime system can interrogate this this token
- * at runtime -- via the `isShape()` type guard -- the
- * runtime will "see" the actual type that the token represents.
- *
- * ```ts
- * // number
- * const token = ShapeApi.number();
- * // <<number>>
- * console.log(token);
- * ```
- */
-export const ShapeApiImplementation = {
-  string,
-  number,
-  boolean,
-  unknown,
-  undefined: undefinedType,
-  null: nullType,
-  union,
-  fn,
-  record,
-  array,
-  set,
-  map,
-  weakMap,
-  dictionary,
-  tuple
-} as unknown as TShapeApi
-
-/**
- * **shape**(s => s.[API])
- *
- * Provides a callback API to allow for defining a type (_which
- * retains a runtime value which will map back to the type_)
- *
- * **Related:** `isShape(val)`
- */
-export const shape = <
-  T extends ShapeCallback
->(cb: T): HandleDoneFn<ReturnType<T>> => {
-  const rtn = cb(ShapeApiImplementation);
-  return handleDoneFn(
-    isAddOrDone(rtn) ? rtn.done() : rtn
-  ) as unknown as HandleDoneFn<ReturnType<T>>;
-}
-
-/**
- * **isShape**(val)
- *
- * Type guard which tests whether a value is a _type_ defined by a `Shape`.
- */
-export const isShape = (v: unknown): v is Shape => {
-  return isString(v) &&
-    v.startsWith("<<") &&
-    v.endsWith(">>") &&
-    SHAPE_PREFIXES.some(i => v.startsWith(`<<${i}`))
-    ? true : false
-}
-
-
-

package/src/runtime/runtime-types/tokens/createTypeToken.ts

@@ -1,114 +0,0 @@
-import {
-  If,
-  IsLength,
-  Join,
-  SimpleType,
-  TypeTokenAtomics,
-  TypeTokenKind,
-  TypeTokenSingletons,
-  UnionToken,
-} from "inferred-types/dist/types/index";
-import {
-  isAtomicToken,
-  isSingletonToken,
-  jsonValues
-} from "src/runtime/index";
-
-type BaseReturn<
-  TBase extends TypeTokenKind
-  > = TBase extends TypeTokenAtomics
-  ? `<<${TBase}>>`
-  : TBase extends TypeTokenSingletons
-  ? SingletonClosure<TBase>
-  : unknown;
-
-
-export type UnionClosure = <T extends readonly unknown[]>(...elements: T) =>
-  `union::[${Join<T, ", ">}]`;
-
-/**
- * **SingletonClosure**
- *
- * Closes out the `string` or `number` base types to conclude as
- * either a wide type or a string literal. It does allow for multiple
- * literal values and in this case will need to add a union token as
- * a parameter
- *
- * ```ts
- * // <<string>>
- * const a = closure<"string">();
- * // <<string::foo>>
- * const b = closure<"string">("foo");
- * // <<string::${UnionClosure("foo", "bar")}>>
- * const c = closure<"string">("foo","bar");
- * ```
- */
-export type SingletonClosure<T extends "string" | "number"> =
-  <TLit extends readonly SimpleType<T>[]>(
-    ...literals: TLit
-) => If<
-  IsLength<TLit, 0>,
-  `<<${T}>>`,
-  If<
-    IsLength<TLit, 1>,
-    `<<${T}::${TLit[0]}>>`,
-    `<<${T}::>>`
-  >
->;
-
-const unionToken = <
-  TElements extends readonly unknown[]
->(...els: TElements) => {
-  return `<<union::[${jsonValues(els)}]>>` as unknown as UnionToken<TElements>
-}
-
-
-const singletonApi = <
-  T extends TypeTokenSingletons
->(
-  base: T
-) => {
-  const handler = <TLit extends readonly SimpleType<T>[]>(
-    ...lits: TLit
-    ) => {
-      return (
-        lits.length === 0
-          ? base === "string" ? `<<string>>` : `<<number>>`
-          : lits.length === 1
-            ? base === "string" ? `<<string::${lits[0]}>>` : `<<number::${lits[0]}>>`
-            : base === "string"
-              ? `<<string::${unionToken(...lits)}>>`
-              : `<<number::${unionToken(...lits)}>>`
-      ) as unknown as If<
-        IsLength<TLit, 0>,
-        `<<${T}>>`,
-        If<
-          IsLength<TLit, 1>,
-          `<<${T}::${TLit[0]}>>`,
-          `<<${T}::>>`
-        >
-      >;
-  }
-
-  return handler as unknown as SingletonClosure<T>;
-}
-
-
-/**
- * **createTypeToken**`(base) => (secondary) => ...`
- *
- * A higher order function designed to creating a valid
- * `TypeToken` simple through a compound process.
- */
-export const createTypeToken = <
-  TBase extends TypeTokenAtomics | TypeTokenSingletons
->(base: TBase): BaseReturn<TBase> => {
-  return (
-    isAtomicToken(base)
-    ? `<<${base}>>`
-    : isSingletonToken(base)
-      ? singletonApi(base)
-      : ""
-  ) as unknown as BaseReturn<TBase>
-}
-

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

@@ -1,2 +0,0 @@
-export * from "./simpleToken"
-export * from "./createTypeToken"

package/src/runtime/runtime-types/tokens/simpleToken.ts

@@ -1,85 +0,0 @@
-import { Never } from "inferred-types/dist/constants/index";
-import { isSimpleContainerToken, isSimpleScalarToken } from "src/runtime/index";
-import {
-  SimpleContainerToken,
-  SimpleScalarToken,
-  SimpleToken,
-  SimpleType
-} from "inferred-types/dist/types/index";
-
-/**
- * **simpleToken**`(token)`
- *
- * Creates a `SimpleToken` which assured to be a valid token type.
- *
- * **Related:** `simpleType()`, `simpleScalarToken()`, `simpleContainerToken()`
- */
-export const simpleToken = <T extends SimpleToken>(token: T) => token;
-
-
-/**
- * **simpleScalarToken**`(token)`
- *
- * Creates a `SimpleScalarToken` which is assured to be a valid token type.
- *
- * **Related:** `simpleType()`, `simpleToken()`, `simpleContainerToken()`
- */
-export const simpleScalarToken = <T extends SimpleScalarToken>(token: T) => token;
-
-/**
- * **simpleContainerToken**`(token)`
- *
- * Creates a `SimpleContainerToken` which assured to be a valid token type.
- *
- * **Related:** `simpleType()`, `simpleToken()`, `simpleScalarToken()`
- */
-export const simpleContainerToken = <T extends SimpleContainerToken>(token: T) => token;
-
-
-/**
- * **simpleScalarType**`(token)`
- *
- * Creates a valid runtime token _and_ converts it's type to the type that
- * the token represents.
- *
- * **Related:** `simpleScalarToken`
- */
-export const simpleScalarType = <T extends SimpleScalarToken>(token: T) => {
-  const value: unknown = simpleScalarToken(token) as unknown;
-
-  return value as SimpleType<T>
-}
-
-/**
- * **simpleContainerType**`(token)`
- *
- * Creates a valid runtime token _and_ converts it's type to the type that
- * the token represents.
- *
- * **Related:** `simpleContainerToken`
- */
-export const simpleContainerType = <T extends SimpleContainerToken>(token: T) => {
-  const value: unknown = simpleContainerToken(token) as unknown;
-
-  return value as SimpleType<T>
-}
-
-
-/**
- * **simpleType**`(token)`
- *
- * Creates a valid runtime token of the `SimpleToken` convention and converts
- * the _type_ to the type that the token represents.
- */
-export const simpleType = <T extends SimpleToken>(token: T) => {
-
-  const value: unknown = (
-    isSimpleScalarToken(token)
-      ? simpleScalarType(token)
-      : isSimpleContainerToken(token)
-        ? simpleContainerToken(token)
-        : Never
-  );
-  return value as SimpleType<T>
-}
-

package/src/runtime/sets/index.ts

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

package/src/runtime/sets/uniqueKeys.ts

@@ -1,48 +0,0 @@
-import { Container,    ObjectKey,  UniqueKeys } from "inferred-types/dist/types/index";
-import { isArray } from "../type-guards/isArray";
-
-/**
- * **uniqueKeys**(left, right)
- *
- * Returns a strongly typed `LeftRight` tuple which identifies the
- * unique keys for each participant list passed in.
- */
-export const uniqueKeys = <
-  L extends Container,
-  R extends Container,
->(left: L, right: R): UniqueKeys<L,R> => {
-  const isNumeric = isArray(left) && isArray(right)
-    ? true
-    : false;
-
-  if (
-    (isArray(left) && !isArray(right)) ||
-    (isArray(right) && !isArray(left))
-  ) {
-      throw new Error("uniqueKeys(l,r) given invalid comparison; both left and right values should be an object or an array but not one of each!");
-  }
-
-  const l = (
-    isNumeric
-    ? Object.keys(left).map(i => Number(i))
-    : Object.keys(left)
-  ) as ObjectKey[];
-  const r = (
-    isNumeric
-    ? Object.keys(right).map(i => Number(i))
-    : Object.keys(right)
-  ) as ObjectKey[];
-
-  if (isNumeric) {
-    throw new Error("uniqueKeys does not yet work with tuples")
-  }
-
-  const leftKeys = l.filter(i => !r.includes(i));
-  const rightKeys = r.filter(i => !l.includes(i));
-
-  return [
-    "LeftRight",
-      leftKeys,
-      rightKeys
-  ] as unknown as UniqueKeys<L,R>;
-};