inferred-types 0.51.1 → 0.51.2

package/src/runtime/literals/toPascalCase.ts

@@ -1,38 +0,0 @@
-import { PascalCase, LeftWhitespace, RightWhitespace } from "inferred-types/dist/types/index";
-import { capitalize } from "src/runtime/index";
-
-
-/**
- * **toPascalCase**(str)
- *
- * Converts a string into `PascalCase` while preserving literal strings.
- *
- * **Note:** _by default it also removes surrounding white space (if it exists) but it
- * can be preserved if you change the `preserveWhitespace` flag._
- *
- * **Related:** `toKebabCase`, `toCamelCase`, `toSnakeCase`
- */
-export function toPascalCase<
-  S extends string,
-  P extends boolean | undefined = undefined
->(input: S, preserveWhitespace: P = undefined as P) {
-  const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(
-    input
-  ) as RegExpExecArray;
-
-  const convertInteriorToCap = (i: string) =>
-    i.replace(/[ |_|-]+([0-9]*?[a-z|A-Z]{1})/gs, (_, p1) => p1.toUpperCase());
-  const startingToCap = (i: string) =>
-    i.replace(/^[_|-]*?([0-9]*?[a-z]{1})/gs, (_, p1) => p1.toUpperCase());
-
-  const replaceLeadingTrash = (i: string) => i.replace(/^[-_]/s, "");
-  const replaceTrailingTrash = (i: string) => i.replace(/[-_]$/s, "");
-
-  const pascal = `${preserveWhitespace ? preWhite : ""}${capitalize(
-    replaceTrailingTrash(replaceLeadingTrash(convertInteriorToCap(startingToCap(focus))))
-  )}${preserveWhitespace ? postWhite : ""}`;
-
-  return pascal as true extends P
-    ? `${LeftWhitespace<S>}${PascalCase<S>}${RightWhitespace<S>}`
-    : PascalCase<S>;
-}

package/src/runtime/literals/toSnakeCase.ts

@@ -1,33 +0,0 @@
-import { SnakeCase } from "inferred-types/dist/types/index";
-
-/**
- * **toSnakeCase**(str)
- *
- * Converts a string into `snake_case` while preserving literal strings.
- *
- * **Note:** _by default it also removes surrounding white space (if it exists) but it
- * can be preserved if you change the `preserveWhitespace` flag._
- *
- * **Related:** `toKebabCase`, `toCamelCase`, `toPascalCase`
- */
-export function toSnakeCase<
-  S extends string,
-  P extends boolean = false
->(input: S, preserveWhitespace: P = false as P): SnakeCase<S,P> {
-  const [_, preWhite, focus, postWhite] = /^(\s*)(.*?)(\s*)$/.exec(input) as RegExpExecArray;
-
-  const convertInteriorSpace = (input: string) => input.replace(/\s+/gs, "_");
-  const convertDashes = (input: string) => input.replace(/-/gs, "_");
-  const injectUnderscoreBeforeCaps = (input: string) => input.replace(/([A-Z])/gs, "_$1");
-  const removeLeadingUnderscore = (input: string) =>
-    input.startsWith("_") ? input.slice(1) : input;
-
-  return (
-    (preserveWhitespace ? preWhite : "") +
-    removeLeadingUnderscore(
-      injectUnderscoreBeforeCaps(convertDashes(convertInteriorSpace(focus)))
-    ).toLowerCase() +
-    (preserveWhitespace ? postWhite : "")
-  ).replace(/__/g, "_") as unknown as SnakeCase<S,P>;
-}
-

package/src/runtime/literals/toString.ts

@@ -1,11 +0,0 @@
-import { ToString, Narrowable } from "inferred-types/dist/types/index";
-
-/**
- * **toString**()
- *
- * Runtime utility which converts any given type to a string while
- * preserving literal types.
- */
-export function toString<T extends Narrowable>(val: T): ToString<T> {
-  return String(val) as ToString<T>;
-}

package/src/runtime/literals/toUppercase.ts

@@ -1,13 +0,0 @@
-import { capitalize, ifLowercaseChar } from "src/runtime/index";
-
-/**
- * Converts a string to the "all caps" equivalent.
- * 
- * Note: non-alpha characters are left "as is"
- */
-export function toUppercase<T extends string>(str: T): Uppercase<T> {
-  return str
-    .split("")
-    .map(i => ifLowercaseChar(i, v => capitalize(v), v => v))
-    .join("") as Uppercase<T>;
-}

package/src/runtime/literals/trim.ts

@@ -1,55 +0,0 @@
-import { Trim, TrimLeft, TrimRight } from "inferred-types/dist/types/index";
-
-/**
- * **trim**(input)
- *
- * A runtime utility which trims whitespace on both sides of a string
- * and returns a type-strong string literal where possible.
- */
-export function trim<T extends string>(input: T): Trim<T> {
-  return input.trim() as Trim<T>;
-}
-
-/**
- * **trimLeft**(input)
- *
- * A runtime utility which trims whitespace on the leading/left side of a string
- * and returns a type-strong string literal where possible.
- *
- * @deprecated prefer use of `trimStart` instead
- */
-export function trimLeft<T extends string>(input: T): TrimLeft<T> {
-  return input.trimStart() as TrimLeft<T>;
-}
-
-/**
- * **trimStart**(input)
- *
- * A runtime utility which trims whitespace on the leading/left side of a string
- * and returns a type-strong string literal where possible.
- */
-export function trimStart<T extends string>(input: T): TrimLeft<T> {
-  return input.trimStart() as TrimLeft<T>;
-}
-
-/**
- * **trimRight**(input)
- *
- * A runtime utility which trims whitespace on the tailing/right side of a string
- * and returns a type-strong string literal where possible.
- *
- * @deprecated prefer use of `trimEnd` instead
- */
-export function trimRight<T extends string>(input: T): TrimRight<T> {
-  return input.trimEnd() as TrimRight<T>;
-}
-
-/**
- * **trimEnd**(input)
- *
- * A runtime utility which trims whitespace on the tailing/right side of a string
- * and returns a type-strong string literal where possible.
- */
-export function trimEnd<T extends string>(input: T): TrimRight<T> {
-  return input.trimEnd() as TrimRight<T>;
-}

package/src/runtime/literals/truncate.ts

@@ -1,20 +0,0 @@
-import { Truncate } from "inferred-types/dist/types/index";
-
-
-
-export const truncate = <
-  TStr extends string,
-  TMax extends number,
-  TEllipsis extends boolean | string = false
->(content: TStr, maxLength: TMax, ellipsis: TEllipsis = false as TEllipsis) => {
-  const overLimit = content.length > maxLength;
-
-  return (
-    overLimit
-    ? ellipsis
-      ?  `${content.slice(0,maxLength)}${typeof ellipsis === "string" ? ellipsis : "..."}`
-      :  content.slice(0,maxLength)
-    : content
-  ) as Truncate<TStr,TMax,TEllipsis>;
-
-}

package/src/runtime/literals/tuple.ts

@@ -1,41 +0,0 @@
-import {
-  IsUnionArray,
-  Length,
-  Narrowable,
-  UnionArrayToTuple,
-  UnionToTuple,
-} from "inferred-types/dist/types/index";
-import { asArray } from "src/runtime/index";
-
-/**
- * **tuple**(value)
- *
- * Creates a discrete tuple.
- * ```ts
- * // [1,2,3]
- * const t1 = tuple(1,2,3);
- * const t2 = tuple([1,2,3]);
- * ```
- */
-export const tuple = <
-  N extends Narrowable,
-  K extends PropertyKey,
-  T extends readonly (Record<K, N> | N)[]
->(...values: T) => {
-  const arr = (
-    values.length === 1
-      ? values[0]
-      : values
-  ) as Length<T> extends 1
-    ? T[0] extends readonly unknown[]
-    ? T[0] extends infer Arr
-    ? IsUnionArray<Arr> extends true
-      ? UnionArrayToTuple<Arr>
-      : UnionToTuple<Arr>
-    : T[0]
-    : T[0]
-    : T;
-
-  return asArray(arr) ;
-};
-

package/src/runtime/literals/uncapitalize.ts

@@ -1,9 +0,0 @@
-/**
- * **uncapitalize**()
- * 
- * Run time utility which _un_-capitalizes a word/string and preserves
- * string literal types.
- */
-export function uncapitalize<T extends string>(str: T): Uncapitalize<T> {
-  return `${str?.slice(0,1).toLowerCase()}${str?.slice(1)}` as Uncapitalize<T>;
-}

package/src/runtime/literals/unset.ts

@@ -1,18 +0,0 @@
-// import { Unset, ShapeCallback } from "inferred-types/dist/types/index";
-// import { ShapeApiImplementation, handleEscapeApi, isFunction } from "src/runtime/index";
-
-export const unset = "NOT IMPLEMENTED" as const;
-
-/**
- * **unset**`([type])`
- *
- * Allows you to easily create the `Unset` type while providing a tokenized runtime
- * value for the `type` property.
- */
-// export const unset = <T extends ShapeCallback | Unset = Unset>(type?: T) => {
-//     if(isFunction(type)) {
-//       const _userResponse = handleEscapeApi(ShapeApiImplementation);
-
-//     }
-
-// }

package/src/runtime/literals/uppercase.ts

@@ -1,9 +0,0 @@
-/**
- * **uppercase**()
- * 
- * Run time utility which ensures all letters are uppercase while preserving
- * string literal types.
- */
-export function uppercase<T extends string>(str: T): Uppercase<T> {
-  return str.toUpperCase() as Uppercase<T>;
-}

package/src/runtime/literals/widen.ts

@@ -1,13 +0,0 @@
-
-import {  Narrowable, Widen } from "inferred-types/dist/types/index";
-
-
-/**
- * **widen**(value)
- *
- * Runtime utility which takes any _type_ and ensures it's widened to a wide
- * type of passed in value is a literal.
- */
-export function widen<T extends Narrowable>(value: T): Widen<T> {
-  return value as Widen<T>;
-}

package/src/runtime/meta/index.ts

@@ -1,2 +0,0 @@
-export * from "./youtube-meta"
-export * from "./urlMeta"

package/src/runtime/meta/urlMeta.ts

@@ -1,187 +0,0 @@
-import {
-  IsUrl,
-  GetUrlProtocol,
-  GetUrlSource,
-  GetUrlPath,
-  GetUrlQueryParams,
-  NetworkProtocol,
-  GetUrlPort,
-  IsIpAddress,
-  IsIp4Address,
-  IsIp6Address
-} from "inferred-types/dist/types/index";
-import {
-  isUrl,
-  isIp4Address,
-  isIp6Address,
-  isIpAddress,
-  stripAfter,
-  stripBefore,
-  ensureLeading,
-  stripTrailing,
-  isDomainName,
-  takeNumericCharacters,
-} from "src/runtime/index";
-import { NETWORK_PROTOCOL_LOOKUP } from "inferred-types/dist/constants/index";
-import { Never } from "inferred-types/dist/constants/index";
-
-
-export type UrlMeta<T> = {
-  /** the URL passed in */
-  url: T;
-  /** boolean flag indicating whether the value passed in is considered a valid URL */
-  isUrl: IsUrl<T>;
-  /** the `NetworkProtocol` used in the URL */
-  protocol: GetUrlProtocol<T>;
-  path: T extends string ? GetUrlPath<T> : never;
-  queryParams: T extends string ? GetUrlQueryParams<T> : never;
-  /** the port number -- when stated explicitly -- or "default" */
-  port: GetUrlPort<T>;
-
-
-  /** either the domain name or the IP address */
-  source: T extends string
-    ? GetUrlSource<T>
-    : never;
-  /**
-   * Boolean flag which indicates that the _source_ is an IP address (vs. Domain Name)
-   */
-  isIpAddress: IsIpAddress<T>;
-  /**
-   * Boolean flag indicating the _source_ is a IPv4 IP address
-   */
-  isIpV4Address: IsIp4Address<T>;
-
-  /**
-   * Boolean flag indicating the _source_ is a IPv6 IP address
-   */
-  isIpV6Address: IsIp6Address<T>;
-}
-
-const PROTOCOLS = Object.values(NETWORK_PROTOCOL_LOOKUP).flat().filter(i => i !== "") as NetworkProtocol[];
-
-
-export const getUrlProtocol = <
-  T extends string
->(
-  url: T
-) => {
-  const proto = PROTOCOLS.find(p => url.startsWith(`${p}://`));
-
-  return proto as GetUrlProtocol<T>;
-}
-
-export const removeUrlProtocol = <T extends string>(url: T) => {
-  return stripBefore(url, "://")
-}
-
-const ensurePath = (val: string) => {
-  const val2 = ensureLeading(val, "/");
-
-  return val === ""
-  ? ""
-  : stripTrailing(val2, "/");
-}
-
-export const getUrlPath = <
-  T extends string
->(
-  url: T
-) => {
-  return isUrl(url)
-    ? ensurePath(
-        stripAfter(stripBefore(removeUrlProtocol(url), "/"), "?")
-      ) as unknown as GetUrlPath<T>
-    : Never
-}
-
-/**
- * **getUrlQueryParams**`(url, [specific])`
- *
- * Get's the query parameter's part of a URL and optionally allows
- * you to focus in on a specific key in the query parameters.
- *
- * If you do specify a particular query parameter it will decode
- * the value with URIDecode.
- */
-export const getUrlQueryParams = <
-  T extends string,
-  S extends string | undefined
->(
-  url: T,
-  specific: S = undefined as S
-) => {
-  const qp = stripBefore(url, "?");
-  if (specific) {
-    return (
-      qp.includes(`${specific}=`)
-        ? decodeURIComponent(
-            stripAfter(
-              stripBefore(qp, (`${specific}=`)),
-              "&"
-            ).replace(/\+/g, "%20")
-          )
-        : undefined
-    )
-  }
-
-  return (
-    qp === ""
-    ? qp
-    : `?${qp}`
-  ) as GetUrlQueryParams<T,S>;
-}
-
-export const getUrlPort = <
-  T extends string
->(
-  url: T
-) => {
-  const candidate = takeNumericCharacters(
-    stripBefore(removeUrlProtocol(url), ":")
-  );
-  return (
-    candidate === ""
-      ? "default"
-      : Number(candidate)
-  )
-}
-
-export const getUrlSource = <
-  T extends string,
->(
-  url: T
-) => {
-  const candidate = stripAfter(stripAfter(stripAfter(removeUrlProtocol(url), "/"), "?") , ":") as unknown;
-
-  return (
-    isIpAddress(candidate) || isDomainName(candidate)
-    ? candidate
-    : Never
-  ) as unknown as GetUrlSource<T>;
-}
-
-
-/**
- * **urlMeta**`(url)`
- *
- * Analyzes the string passed in and provides a small dictionary of
- * metadata properties about the URL.
- */
-export const urlMeta = <
-  T extends string
->(url: T) => {
-  return {
-    url,
-    isUrl: isUrl(url) as IsUrl<T> ,
-    protocol: getUrlProtocol(url) as GetUrlProtocol<T>,
-    path: getUrlPath(url) as GetUrlPath<T>,
-    queryParameters: getUrlQueryParams(url),
-    port: getUrlPort(url) as GetUrlPort<T>,
-    source: getUrlSource(url) as GetUrlSource<T>,
-    isIpAddress: isIpAddress(getUrlSource(url)) as IsIpAddress<GetUrlSource<T>>,
-    isIp4Address: isIp4Address(getUrlSource(url)) as IsIp4Address<GetUrlSource<T>>,
-    isIp6Address: isIp6Address(getUrlSource(url)) as IsIp6Address<GetUrlSource<T>>,
-  }
-
-}

package/src/runtime/meta/youtube-meta.ts

@@ -1,146 +0,0 @@
-import {
-  As,
-  GetYouTubePageType,
-  YouTubeEmbedUrl,
-  YouTubePageType,
-  YouTubeShareUrl,
-  YouTubeUrl,
-  YouTubeVideoUrl
-} from "inferred-types/dist/types/index";
-import {
-  getUrlPath,
-  getUrlQueryParams,
-  hasUrlQueryParameter,
-  isYouTubeCreatorUrl,
-  isYouTubeFeedUrl,
-  isYouTubeShareUrl,
-  isYouTubeUrl,
-  isYouTubeVideoUrl,
-  isYouTubeVideosInPlaylist,
-  last
-} from "src/runtime/index";
-import { Never } from "inferred-types/dist/constants/index";
-
-
-/**
- * **YouTubeMeta**`<T>`
- *
- * Provides metadata about YouTube related URLs.
- */
-export type YouTubeMeta<T extends string> = {
-  /**
-   * The URL passed in
-   */
-  url: T;
-  /**
-   * boolean flag indicating whether the URL is a valid
-   * YouTube URL.
-   */
-  isYouTubeUrl: T extends YouTubeUrl ? true : false;
-
-  /**
-     * boolean flag indicating whether URL is part of YouTube's `https://youtu.be`
-     * URL shortener used when _sharing_ videos.
-     */
-  isShareUrl: T extends YouTubeShareUrl ? true : false;
-
-  pageType: As<
-    GetYouTubePageType<T>,
-    YouTubePageType
-  >
-};
-
-/**
- * **getYouTubePageType**`(url)`
- *
- * Returns a `YouTubePageType` description based on the url passed in (assuming
- * that URL is for YouTube). Returns _never_ if not a YouTube URL.
- */
-export const getYouTubePageType = <T extends string>(url: T) => {
-  return (
-    isYouTubeUrl(url)
-    ? isYouTubeVideoUrl(url) && (hasUrlQueryParameter(url, "v") || isYouTubeShareUrl(url))
-      ? hasUrlQueryParameter(url, "list")
-        ? isYouTubeShareUrl(url)
-          ? hasUrlQueryParameter(url, "t")
-            ? `play::video::in-list::share-link::with-timestamp`
-            : `play::video::in-list::share-link`
-          : `play::video::in-list`
-        : isYouTubeShareUrl(url)
-          ? hasUrlQueryParameter(url, "t")
-            ? `play::video::solo::share-link::with-timestamp`
-            : `play::video::solo::share-link`
-          :  `play::video::solo`
-      : isYouTubeCreatorUrl(url)
-        ? getUrlPath(url).includes("/videos")
-          ? "creator::videos"
-        : getUrlPath(url).includes("/playlists")
-          ? "creator::playlists"
-        : last(getUrlPath(url).split("/")).startsWith("@") ||
-          getUrlPath(url).includes("/featured")
-          ? "creator::featured"
-        : "creator::other"
-      : isYouTubeFeedUrl(url)
-        ? isYouTubeFeedUrl(url, "history")
-          ? "feed::history"
-        : isYouTubeFeedUrl(url, "playlists")
-          ? "feed::playlists"
-        : isYouTubeFeedUrl(url, "liked")
-          ? "feed::liked"
-        : isYouTubeFeedUrl(url, "subscriptions")
-          ? "feed::subscriptions"
-        : isYouTubeFeedUrl(url, "trending")
-          ? "feed::trending"
-          : "feed::other"
-      : isYouTubeVideosInPlaylist(url)
-        ? "playlist::show"
-        : "other"
-    : Never
-  ) as unknown as GetYouTubePageType<T>;
-}
-
-/**
- * **youtubeEmbed**`(url)`
- *
- * Takes a Video URL from YouTube and converts it to a "embed" URL
- * that can be put into an iframe.
- */
-export const youtubeEmbed = (url: YouTubeVideoUrl) =>  {
-  if (hasUrlQueryParameter(url, "v")) {
-    const id= getUrlQueryParams(url, "v")
-    return `https://www.youtube.com/embed/${id}` as YouTubeEmbedUrl
-  } else if (isYouTubeShareUrl(url)) {
-    const id = url.split("/").pop() as string;
-    if (id) {
-      return `https://www.youtube.com/embed/${id}` as YouTubeEmbedUrl
-    } else {
-      throw new Error(`Unexpected problem parsing share URL -- "${url}" -- into a YouTube embed URL`)
-    }
-  } else {
-    throw new Error(`Unexpected URL structure; unable to convert "${url}" to a YouTube embed URL`)
-  }
-}
-
-
-/**
- * **youtube**`(url)`
- *
- * Takes a YouTube URL and converts it to a meta-data object
- * that helps describe the intent of the URL.
- */
-export const youtubeMeta = <T extends string>(url: T): YouTubeMeta<T> => {
-  return (
-    isYouTubeUrl(url)
-    ? {
-        url,
-        isYouTubeUrl: true,
-        isShareUrl: isYouTubeShareUrl(url),
-        pageType: getYouTubePageType(url) as unknown as GetYouTubePageType<T>,
-      }
-    : {
-        url,
-        isYouTubeUrl: false
-      }
-    ) as unknown as YouTubeMeta<T>;
-}
-

package/src/runtime/queues/fifo.ts

@@ -1,51 +0,0 @@
-import { FifoQueue, FixedLengthArray, Narrowable } from "inferred-types/dist/types/index";
-
-
-const queue =  <
-  T extends unknown[],
->(state: T): FifoQueue<T[number]> => ({
-  queue: state,
-  size: state.length,
-  isEmpty() {
-    return state.length === 0
-  },
-  clear() {
-    state.slice(0,0)
-  },
-  drain() {
-    const old_state = [...state];
-    state.slice(0,0);
-    return old_state;
-  },
-  push(...add) {
-    state.push(...add);
-  },
-  drop(quantity) {
-    if (quantity && quantity > state.length) {
-      throw new Error("Cannot drop more elements than present in the queue");
-    }
-    state.splice(0, quantity || 1);
-  },
-  take<Q extends number | undefined>(quantity?: Q) {
-    if (quantity && quantity > state.length) {
-      throw new Error("Cannot take more elements than present in the queue");
-    }
-    const result = state.slice(0, quantity || 1);
-    state.splice(0, quantity || 1);
-    return result as FixedLengthArray<T[number], Q extends undefined ? 1 : Q>;
-  },
-  [Symbol.iterator]: function* () {
-    for (let i = 0; i < state.length; i++) {
-      yield state[i] as T[number];
-    }
-  }
-})
-
-
-export const createFifoQueue = <
-  T extends readonly K[],
-  K extends Narrowable
->(...list: T) => {
-
-  return queue([...list]);
-}

package/src/runtime/queues/index.ts

@@ -1,2 +0,0 @@
-export * from "./fifo";
-export * from "./lifo";