inferred-types 0.51.1 → 0.51.2

package/src/runtime/type-guards/api-tg.ts

@@ -1,45 +0,0 @@
-import {  Dictionary,  Narrowable, OptionalParamFn, TypedFunction } from "inferred-types/dist/types/index";
-import { isFunction } from "./isFunction";
-import { isObject } from "./isObject"
-
-
-export const isEscapeFunction = <T>(val: T): val is T & (() => unknown) => {
-  return isFunction(val) && "escape" in val && val.escape === true
-}
-
-
-/**
- * **isOptionalParamFunction**`(val)`
- *
- * A type guard which ensures that the value passed in is not only a _function_
- * but also has the `optionalParam` value set to **true** indicating that it
- * is safe to be called _without_ parameters.
- *
- * **Note:** this is similar to an "escape function" but whereas an API can
- * only have one escape function, an API may have as many ze
- */
-export const isOptionalParamFunction = <T>(val: T): val is T & OptionalParamFn => {
-  return isFunction(val) && "optionalParams" in val && val.optionalParams === true
-}
-
-/**
- * **isApi**`(val)`
- *
- * Type guard which validates that the value passed in is an `Api` type
- * with "surface" and "_kind" property.
- *
- * **Related:** `isFluentApi()`
- */
-export const isApi = <T extends Narrowable>(api: T): api is T & { __kind: "api"; surface: Dictionary | TypedFunction} => {
-  return isObject(api) && "surface" in api && "_kind" in api && api._kind === "api";
-}
-
-/**
- * **isApiSurface**`(val)`
- *
- * A type guard which tests whether the value passed in is the SurfaceArea
- * of an API (or could be).
- */
-export const isApiSurface = <T>(val: T): val is T & (Dictionary | TypedFunction) => {
-  return isObject(val) && Object.keys(val).some(k => isEscapeFunction(val[k]));
-}

package/src/runtime/type-guards/geo/index.ts

@@ -1,3 +0,0 @@
-export * from "./isIso3166Alpha2"
-export * from "./isZipCode"
-export * from "./isUsState"

package/src/runtime/type-guards/geo/isIso3166Alpha2.ts

@@ -1,79 +0,0 @@
-import { Iso3166_1_Alpha2, Iso3166_1_Alpha3, Iso3166_1_CountryCode, Iso3166_1_CountryName } from "inferred-types/dist/types/index";
-import { isString } from "../isString";
-import { ISO3166_1 } from "inferred-types/dist/constants/index";
-
-/**
- * Type guard which checks whether `val` is a 2 character country
- * representation found in the ISO3166-1 standard.
- */
-export const isIso3166Alpha2 = (val: unknown): val is Iso3166_1_Alpha2 => {
-  const codes = ISO3166_1.map(i => i["alpha2"]) as string[];
-  return isString(val) && codes.includes(val);
-}
-
-/**
- * Type guard which checks whether `val` is a 2 character country
- * representation found in the ISO3166-1 standard.
- *
- * **Alias:** `isIso3166Alpha2`
- */
-export const isCountryCode2 = (val: unknown): val is Iso3166_1_Alpha2 => {
-  const codes = ISO3166_1.map(i => i["alpha2"]) as string[];
-  return isString(val) && codes.includes(val);
-}
-
-/**
- * Type guard which checks whether `val` is a 3 character country
- * representation found in the ISO3166-1 standard.
- */
-export const isIso3166Alpha3 = (val: unknown): val is Iso3166_1_Alpha3 => {
-  const codes = ISO3166_1.map(i => i["alpha3"]) as string[];
-  return isString(val) && codes.includes(val);
-}
-
-/**
- * Type guard which checks whether `val` is a 3 character country
- * representation found in the ISO3166-1 standard.
- *
- * **Alias:** `isIso3166Alpha3`
- */
-export const isCountryCode3 = (val: unknown): val is Iso3166_1_Alpha3 => {
-  const codes = ISO3166_1.map(i => i["alpha3"]) as string[];
-  return isString(val) && codes.includes(val);
-}
-
-/**
- * Type guard which checks whether `val` is a 3 character country
- * representation found in the ISO3166-1 standard.
- */
-export const isIso3166CountryCode = (val: unknown): val is Iso3166_1_CountryCode => {
-  const codes = ISO3166_1.map(i => i["countryCode"]) as string[];
-  return isString(val) && codes.includes(val);
-}
-
-/**
- * Type guard which checks whether `val` is a 2 or 3 character country
- * abbreviation found in the ISO3166-1 standard.
- */
-export const isCountryAbbrev = (val: unknown): val is Iso3166_1_Alpha2 | Iso3166_1_Alpha3 => {
-  return isCountryCode2(val) || isCountryCode3(val)
-}
-
-/**
- * Type guard which checks whether `val` is a valid ISO3166-1 country name.
- */
-export const isIso3166CountryName = (val: unknown): val is Iso3166_1_CountryName => {
-  const codes = ISO3166_1.map(i => i["name"]) as string[];
-  return isString(val) && codes.includes(val);
-}
-
-
-/**
- * Type guard which checks whether `val` is a valid ISO3166-1 country name.
- *
- * **Alias:** `isIso3166CountryName`
- */
-export const isCountryName = (val: unknown): val is Iso3166_1_CountryName => {
-  const codes = ISO3166_1.map(i => i["name"]) as string[];
-  return isString(val) && codes.includes(val);
-}

package/src/runtime/type-guards/geo/isUsState.ts

@@ -1,15 +0,0 @@
-import { UsStateAbbrev, UsStateName } from "inferred-types/dist/types/index"
-import { isString } from "../isString"
-import { US_STATE_LOOKUP } from "inferred-types/dist/constants/index"
-
-const ABBREV = US_STATE_LOOKUP.map(i => i.abbrev);
-const NAME = US_STATE_LOOKUP.map(i => i.name);
-
-export const isUsStateAbbreviation = (val: unknown): val is UsStateAbbrev => {
-  return isString(val) && ABBREV.includes(val as any);
-}
-
-export const isUsStateName = (val: unknown): val is UsStateName => {
-  return isString(val) && NAME.includes(val as any);
-}
-

package/src/runtime/type-guards/geo/isZipCode.ts

@@ -1,45 +0,0 @@
-import { Zip5, ZipCode, ZipPlus4 } from "inferred-types/dist/types/index";
-import { isString } from "../isString";
-import { isNumber } from "../isNumber";
-import { isNumberLike } from "../isNumericString";
-import { retainWhile, stripChars } from "src/runtime/index";
-import { NUMERIC_CHAR } from "inferred-types/dist/constants/index";
-
-/**
- * Type guard which validates that passed in value is a US ZipCode
- * in the `Zip5` format.
- *
- * **Related:** `isZipCode()`, `isZipPlus4()`
- */
-export const isZipCode5 = (val: unknown): val is Zip5 => {
-  if (isNumber(val)) {
-    return isZipCode5(`${val}`);
-  }
-  return isString(val) && val.trim().length === 5 && isNumberLike(val.trim())
-}
-
-/**
- * Type guard which validates that passed in value is a US ZipCode
- * in the `ZipPlus4` format.
- *
- * **Related:** `isZipCode()`, `isZipCode5()`
- */
-export const isZipPlus4 = (val: unknown): val is ZipPlus4 => {
-  if (isString(val)) {
-    const first = retainWhile(val.trim(), ...NUMERIC_CHAR);
-    const next = stripChars(val.trim().replace(first, "").trim(), "-");
-    return first.length === 5 && next.length === 4 && isNumberLike(next)
-  }
-
-  return false;
-}
-
-/**
- * Type guard which validates that passed in value is a US ZipCode
- * in either the `Zip5` or `ZipPlus4` format.
- *
- * **Related:** `isZipCode5()`, `isZipPlus4()`
- */
-export const isZipCode = (val: unknown): val is ZipCode => {
-  return isZipCode5(val) || isZipPlus4(val);
-}

package/src/runtime/type-guards/hasDefaultValue.ts

@@ -1,16 +0,0 @@
-import { Narrowable } from "inferred-types/dist/types/index";
-import { NoDefaultValue } from "inferred-types/dist/constants/index";
-import { isSpecificConstant } from "./isSpecificConstant";
-/**
- * **hasDefaultValue**(value)
- *
- * Type guard which helps to eliminate the use case where a value which _might_ be a
- * `DefaultValue` is _not_ in this initial state and therefore indicating that the value
- * **is** in fact a default value.
- *
- * Probably a better way to phrase this. :)
- */
-export function hasDefaultValue<T extends Narrowable>(value: T): value is Exclude<T, NoDefaultValue> {
-  const noDefault = isSpecificConstant("no-default-value");
-  return noDefault(value) ? false : true;
-}

package/src/runtime/type-guards/hasErrorConditions.ts

@@ -1,8 +0,0 @@
-import { ErrorCondition } from "inferred-types/dist/types/index";
-import { isErrorCondition } from "./isErrorCondition";
-
-export const hasErrorConditions = <
-  T extends readonly unknown[]
->(list: T): list is T & readonly [...unknown[], ErrorCondition<string>] => {
-  return list.some(i => isErrorCondition(i));
-};

package/src/runtime/type-guards/hasIndexOf.ts

@@ -1,36 +0,0 @@
-
-import { Container, IsValidIndex, Dictionary, Tuple } from "inferred-types/dist/types/index";
-import { isErrorCondition, isObject } from "src/runtime/index";
-
-
-/**
- * **hasIndexOf**(value, idx) => boolean
- *
- * A type guard which determines whether container passed in has
- * an explicit index.
- */
-export const hasIndexOf = <
-  TContainer extends Container,
-  TIndex extends PropertyKey,
->(
-    value: TContainer,
-    idx: TIndex
-): value is TContainer &
-  (TContainer extends Tuple
-    ? Tuple<TIndex>
-    : TContainer extends Dictionary
-        ? Record<TIndex,unknown>
-        : never
-) => {
-  const result = isObject(value)
-    ? String(idx) in value
-    : Array.isArray(value)
-      ? Number(idx) in value
-      : false;
-  return (
-    isErrorCondition(result, "invalid-index")
-      ? false
-      : result
-  ) as IsValidIndex<TContainer,TIndex>;
-};
-

package/src/runtime/type-guards/hasKeys.ts

@@ -1,38 +0,0 @@
-import { AsObject, EnsureKeys } from "inferred-types/dist/types/index"
-import { isObject } from "./isObject";
-import { isFunction } from "./isFunction";
-
-/**
- * **hasKeys**(props) => (obj) => `HasKeys<O,P>`
- *
- * Higher order type guard which on first call generates
- * a type guard that can test for the existence of the
- * properties passed into this first call.
- *
- * ```ts
- * const hasFooBar = hasKeys(["foo", "bar"]); // type guard
- * const hasFooBarToo = hasKeys({foo: 1, bar: 1});
- * ```
- */
-export const hasKeys = <
-  P extends readonly string[] | [Record<string, unknown>]
->(...props: P) =>
-/**
- * Type guard which validates whether the configured properties
- * exist on a given `Record<ObjectKey, unknown` and if they do at
- * runtime will provide the type support for them.
- */
-<
-  T
->(val: T): val is T &([EnsureKeys<AsObject<T>, ["name"]>] extends never[]
-  ? never
-  : EnsureKeys<AsObject<T>,P>) => {
-  const keys = Array.isArray(props)
-    ? props
-    : Object.keys(props).filter(i => typeof i === "string") as string[];
-
-
-  return (
-    isFunction(val) || isObject(val)
-  ) && keys.every(k => k in (val as object)) ? true : false
-}

package/src/runtime/type-guards/hasWhitespace.ts

@@ -1,13 +0,0 @@
-import { WHITESPACE_CHARS } from "inferred-types/dist/constants/index"
-import { asChars } from "../type-conversion"
-import { isString } from "./isString"
-
-/**
- * **hasWhiteSpace**`(val)`
- *
- * Type guard which checks whether a string has a any whitespace characters in it
- */
-export const hasWhiteSpace = <T>(val: T): val is T  => {
-  return isString(val) && asChars(val).some(c => WHITESPACE_CHARS.includes(c as any))
-}
-

package/src/runtime/type-guards/higher-order/endsWith.ts

@@ -1,23 +0,0 @@
-import { Narrowable } from "inferred-types/dist/types/index";
-import { isString, isNumber } from "src/runtime/index";
-
-
-export type EndingWithTypeGuard<T extends string> = <
-  V extends Narrowable
->(val: V) => val is V & `${string}${T}`;
-
-/**
- * **endsWith**(endingIn) => (val)
- *
- * Creates a TypeGuard which checks whether a value _ends with_ a
- * particular string literal.
- */
-export const endsWith = <
-  T extends string
->(endingIn: T): EndingWithTypeGuard<T> => <V extends Narrowable>(val: V): val is V & `${string}${T}` => {
-  return isString(val)
-    ?  val.endsWith(endingIn) ? true : false
-    : isNumber(val)
-      ? String(val).endsWith(endingIn) ? true : false
-      : false;
-};

package/src/runtime/type-guards/higher-order/index.ts

@@ -1,7 +0,0 @@
-export * from "./endsWith";
-export * from "./startsWith";
-export * from "./isEqual";
-export * from "./isLength";
-export * from "./isTypeOf";
-export * from "./isSameTypeOf";
-export * from "./isTuple";

package/src/runtime/type-guards/higher-order/isEqual.ts

@@ -1,23 +0,0 @@
-import { Narrowable , TypeGuard } from "inferred-types/dist/types/index";
-import { isSameTypeOf } from "src/runtime/index";
-
-
-/**
- * A TypeGuard which was generated from `isEqual()` runtime util.
- */
-export type EqualTo<T extends Narrowable> = TypeGuard<T>;
-
-/**
- * **isEqual**(compareTo)(value)
- *
- * Higher order type guard to detect whether two values are equal
- */
-export const isEqual = <
-  TBase extends Narrowable
->(base: TBase): EqualTo<TBase> =>
-   <TValue extends Narrowable>(value: TValue): value is TBase & TValue =>
-    isSameTypeOf(base)(value)
-      ? value === base
-        ? true
-        : false
-      : false;

package/src/runtime/type-guards/higher-order/isLength.ts

@@ -1,36 +0,0 @@
-import {
-  keysOf,
-  isArray,
-  isObject,
-  isString,
-  isEqual
-} from "src/runtime/index";
-
-
-
-
-/**
- * **ifLength**(len) => (value) => boolean
- *
- * Higher order type guard which provides a type-aware check on the
- * "length" of some unit:
- *
- * - **arrays** - the number of elements in the array
- * - **objects** - the number of keys in the object
- * - **string** - the length of the string
- *
- * All other types return `false`
- */
-export function isLength<
-  TValue,
-  TLen extends number
->(value: TValue, len: TLen) {
-    return isArray(value)
-      ? isEqual((value as unknown[]).length)(len) ? true : false
-      : isString(value)
-        ? isEqual(value.length)(len) ? true : false
-        : isObject(value)
-          ? isEqual(keysOf(value))(len) ? true : false
-          : false;
-  }
-

package/src/runtime/type-guards/higher-order/isSameTypeOf.ts

@@ -1,15 +0,0 @@
-import { ConvertTypeOf, GetTypeOf } from "inferred-types/dist/types/index";
-
-/**
- * **isSameTypeOf**(base, compare)
- *
- * A type guard which validates that `base` and `compare` are the same "type"
- * defined by the runtime `typeof` operator.
- *
- * **Note:** if either `TBase` or `TCompare` are
- *
- * **Related:** `IsSameType`
- */
-export const isSameTypeOf = <TBase>(base: TBase) => <TCompare>(compare: TCompare): compare is TCompare & ConvertTypeOf<GetTypeOf<TBase>>  => {
-      return typeof base === typeof compare;
-};

package/src/runtime/type-guards/higher-order/isTuple.ts

@@ -1,31 +0,0 @@
-
-import {
-  ShapeCallback,
-  HandleDoneFn
-} from "inferred-types/dist/types/index"
-import {
-  isDoneFn,
-  ShapeApiImplementation,
-  isArray,
-  isSameTypeOf,
-  isShape
- } from "src/runtime/index"
-
-type FromDefn<
-  T extends readonly ShapeCallback[]
-> = {
-  [K in keyof T]: HandleDoneFn<ReturnType<T[K]>>
-};
-
-export const isTuple = <TDefn extends readonly ShapeCallback[]>(...tuple: TDefn) => {
-  const results = tuple
-    .map(i => i(ShapeApiImplementation))
-    .map(i => isDoneFn(i) ? (i as any).done() : i);
-
-  return <T>(v: T): v is T & FromDefn<TDefn> => {
-    return isArray(v) &&
-      v.length === results.length &&
-      results.every(isShape) &&
-      v.every((item, idx) => isSameTypeOf(results[idx])(item))
-  }
-}

package/src/runtime/type-guards/higher-order/isTypeOf.ts

@@ -1,16 +0,0 @@
-import { TypeOf, ConvertTypeOf } from "inferred-types/dist/types/index";
-
-export type TypeOfTypeGuard<TType extends TypeOf> = <TValue>(value: TValue)=> value is TValue & ConvertTypeOf<TType>;
-
-/**
- * **isTypeOf**(type)(value)
- *
- * Higher order type guard which matches against the runtime operator's `typeof` command.
- *
- * - You first partially apply by specifying the `typeof`
- * - The type guard is then returned based on the type.
- */
-export const isTypeOf = <TType extends TypeOf>(type: TType): TypeOfTypeGuard<TType> =>
-  <TValue>(value: TValue): value is TValue & ConvertTypeOf<TType> => {
-  return typeof value === type;
-};

package/src/runtime/type-guards/higher-order/startsWith.ts

@@ -1,42 +0,0 @@
-import type { Narrowable } from "inferred-types/dist/types/index";
-import { isString, isNumber } from "src/runtime/index";
-
-
-/**
- * **StartingWithTypeGuard**`<literal>`
- *
- * A type guard built using the `startsWith` utility.
- */
-export type StartingWithTypeGuard<TStartsWith extends string> = <
-  TValue extends Narrowable
->(val: TValue) => val is TValue & `${TStartsWith}${string}`;
-
-/**
- * **startsWith**(startingWith) => (val)
- *
- * A higher-level builder pattern which is used to create a TypeGuard
- * which checks whether a string _starts with_ another substring.
- *
- * ```ts
- * // StartingWithTypeGuard<"foo">
- * const foo = startsWith("foo");
- * // true
- * const yup = foo("foobar");
- * // false
- * const nope = foo("bar");
- * // boolean
- * const weWillSee = foo(string);
- * ```
- */
-export const startsWith = <
-  TStartsWith extends string
->(startingWith: TStartsWith): StartingWithTypeGuard<TStartsWith> => <
-  TValue extends Narrowable
->(val: TValue): val is TValue & `${TStartsWith}${string}`=> {
-  return (
-    isString(val) ? val.startsWith(startingWith) ? true : false
-    : isNumber(val) ? String(val).startsWith(startingWith) ? true : false
-    : false
-  ) ;
-};
-

package/src/runtime/type-guards/html/index.ts

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

package/src/runtime/type-guards/html/isHtmlElement.ts

@@ -1,11 +0,0 @@
-import { isObject } from "../isObject";
-
-
-/**
- * **isHtmlElement**`(val)`
- *
- * Type guard which checks whether `val` is an `HtmlElement`.
- */
-export const isHtmlElement = (val: unknown): val is HTMLElement => {
-  return isObject(val) && "attributes" in val && "firstElementChild" in val && "innerHTML" in val;
-}

package/src/runtime/type-guards/index.ts

@@ -1,57 +0,0 @@
-export * from "./isDefined";
-export * from "./isFalsy";
-export * from "./isNull";
-export * from "./isNotNull";
-export * from "./isTruthy";
-export * from "./isTypeTuple";
-export * from "./isUndefined";
-export * from "./isBoolean";
-export * from "./isString";
-export * from "./isIndexable";
-export * from "./isObject";
-export * from "./isTrue";
-export * from "./isObject"
-export * from "./isArray";
-export * from "./isConstant";
-export * from "./isNever";
-export * from "./isContainer";
-export * from "./isSpecificConstant";
-export * from "./isReadonlyArray";
-export * from "./hasIndexOf";
-export * from "./isRef";
-export * from "./isFalse";
-export * from "./hasDefaultValue";
-export * from "./isNumericString";
-export * from "./isFnWithParams";
-export * from "./isFunction";
-export * from "./isNumber";
-export * from "./isNothing";
-export * from "./isScalar";
-export * from "./isTypeToken";
-export * from "./isThenable";
-export * from "./isErrorCondition";
-export * from "./isSymbol";
-export * from "./hasKeys";
-export * from "./isDoneFn";
-export * from "./isUrl";
-export * from "./isCssAspectRatio";
-export * from "./isInlineSvg";
-export * from "./network-tg";
-export * from "./isHexadecimal";
-export * from "./isTrimmable";
-export * from "./hasWhitespace";
-export * from "./isEmail";
-export * from "./isPhoneNumber";
-export * from "./isUnset";
-export * from "./api-tg";
-export * from "./isBooleanLike";
-export * from "./isRegExp";
-export * from "./isAlpha";
-
-export * from "./tokens/index";
-export * from "./higher-order/index";
-export * from "./tokens/index";
-export * from "./html/index";
-export * from "./geo/index";
-export * from "./metrics/index";
-export * from "./urls/index";

package/src/runtime/type-guards/isAlpha.ts

@@ -1,13 +0,0 @@
-import { Alpha, AlphaChar, Narrowable } from "inferred-types/dist/types/index";
-import { ALPHA_CHARS } from "inferred-types/dist/constants/index";
-import { isString, split } from "src/runtime/index";
-
-/**
- * **isAlpha**(value)
- *
- * Type guard which ensures that the given value is a string literal with only
- * alphabetic characters.
- */
-export const isAlpha = <T extends Narrowable>(value: T): value is T & Alpha<T> => {
-  return isString(value) && split(value).every(v => ALPHA_CHARS.includes(v as AlphaChar));
-};

package/src/runtime/type-guards/isArray.ts

@@ -1,9 +0,0 @@
-
-/**
- * **isArray**(value)
- * 
- * Type guard to detect if the type is an array (readonly or regular)
- */
-export function isArray<T>(value: T): value is T & unknown[] {
-  return Array.isArray(value) === true;
-}

package/src/runtime/type-guards/isBoolean.ts

@@ -1,10 +0,0 @@
-
-
-/**
- * **isBoolean**(value)
- * 
- * Type guard which validates that type is a boolean value.
- */
-export function isBoolean<T>(value: T): value is T & boolean {
-  return typeof value === "boolean";
-}

package/src/runtime/type-guards/isBooleanLike.ts

@@ -1,17 +0,0 @@
-import { BooleanLike } from "inferred-types/dist/types/index";
-import { isBoolean } from "./isBoolean";
-import { isString } from "./isString";
-
-/**
- * **isBooleanLike**`(val)`
- *
- * A type guard which checks whether `val` is "boolean like; meaning either
- * a boolean value or a string representation of a boolean value.
- */
-export const isBooleanLike = (val: unknown): val is BooleanLike => {
-  return (
-    isBoolean(val) || (
-      isString(val) && ["true","false","boolean"].includes(val)
-    )
-  )
-}

package/src/runtime/type-guards/isConstant.ts

@@ -1,20 +0,0 @@
-
-import { Constant  } from "inferred-types/dist/constants/index";
-import { isObject  } from "src/runtime/index";
-
-/**
- * **isConstant**`(val)`
- *
- * Type guard which checks to see if it is of type
- * `Constant<T>`.
- */
-export function isConstant<
-  K extends string
->(value: unknown): value is Constant<K> {
-  return isObject(value) &&
-  "_type" in value &&
-  "kind" in value &&
-  value._type === "Constant"
-   ? true : false;
-}
-