inferred-types 0.37.5 → 0.40.1

package/dist/runtime/src/runtime/literals/identity.d.ts

@@ -0,0 +1,6 @@
+/**
+ * An identity function for any type, with the goal of preserving literal type information
+ * where ever possible.
+ */
+export declare const identity: <T>(v: T) => T;
+//# sourceMappingURL=identity.d.ts.map

package/dist/runtime/src/runtime/literals/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/identity.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,eAAO,MAAM,QAAQ,gBAIf,CAAC"}

package/dist/runtime/src/runtime/literals/identity.js

@@ -0,0 +1,5 @@
+/**
+ * An identity function for any type, with the goal of preserving literal type information
+ * where ever possible.
+ */
+export const identity = (v) => v;

package/dist/runtime/src/runtime/literals/ifLowercase.d.ts

@@ -0,0 +1,15 @@
+import { AfterFirst, IfExtends, LowerAlphaChar } from "src/types";
+type _Index<T extends readonly string[], IF, ELSE, Results extends readonly unknown[] = []> = [] extends T ? Results : _Index<AfterFirst<T>, IF, ELSE, [
+    ...Results,
+    IfExtends<T, LowerAlphaChar, IF, ELSE>
+]>;
+type Returns<T extends string | readonly string[], IF, ELSE> = T extends string ? IfExtends<T, LowerAlphaChar, IF, ELSE> : T extends readonly string[] ? _Index<T, IF, ELSE> : never;
+/**
+ * **ifLowercaseChar**(ch)
+ *
+ * Tests whether a passed in character is lowercase and then uses the appropriate callback to
+ * mutate the value.
+ */
+export declare function ifLowercaseChar<T extends string, IF, ELSE>(ch: T, callbackForMatch: <V extends T>(v: V) => IF, callbackForNoMatch: <V extends T>(v: V) => ELSE): Returns<T, IF, ELSE>;
+export {};
+//# sourceMappingURL=ifLowercase.d.ts.map

package/dist/runtime/src/runtime/literals/ifLowercase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifLowercase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/ifLowercase.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAGlE,KAAK,MAAM,CACT,CAAC,SAAS,SAAS,MAAM,EAAE,EAC3B,EAAE,EACF,IAAI,EACJ,OAAO,SAAS,SAAS,OAAO,EAAE,GAAG,EAAE,IACrC,EAAE,SAAS,CAAC,GACZ,OAAO,GACP,MAAM,CACJ,UAAU,CAAC,CAAC,CAAC,EACb,EAAE,EACF,IAAI,EACJ;IACE,GAAG,OAAO;IACV,SAAS,CAAC,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,IAAI,CAAC;CACvC,CACF,CAAC;AAEN,KAAK,OAAO,CACV,CAAC,SAAS,MAAM,GAAG,SAAS,MAAM,EAAE,EACpC,EAAE,EACF,IAAI,IACF,CAAC,SAAS,MAAM,GAChB,SAAS,CAAC,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,IAAI,CAAC,GACtC,CAAC,SAAS,SAAS,MAAM,EAAE,GACzB,MAAM,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,GACnB,KAAK,CAAC;AAGZ;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,MAAM,EAChB,EAAE,EACF,IAAI,EAEJ,EAAE,EAAE,CAAC,EACL,gBAAgB,EAAE,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,EAC3C,kBAAkB,EAAE,CAAC,CAAC,SAAS,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,IAAI,GAC5C,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,CAStB"}

package/dist/runtime/src/runtime/literals/ifLowercase.js

@@ -0,0 +1,16 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { LOWER_ALPHA_CHARS } from "src/constants";
+/**
+ * **ifLowercaseChar**(ch)
+ *
+ * Tests whether a passed in character is lowercase and then uses the appropriate callback to
+ * mutate the value.
+ */
+export function ifLowercaseChar(ch, callbackForMatch, callbackForNoMatch) {
+    if (ch.length !== 1) {
+        throw new Error(`call to ifUppercaseChar received ${ch.length} characters but is only valid when one character is passed in!`);
+    }
+    return (LOWER_ALPHA_CHARS.includes(ch)
+        ? callbackForMatch(ch)
+        : callbackForNoMatch(ch));
+}

package/dist/runtime/src/runtime/literals/ifUppercase.d.ts

@@ -0,0 +1,15 @@
+import { IfChar, IfExtends, Narrowable, UpperAlphaChar, ValueCallback } from "src/types";
+type Convert<T, IF, ELSE> = IfExtends<T, UpperAlphaChar, IF, ELSE>;
+/**
+ * **ifUppercaseChar**(ch, callbackForMatch, callbackForNoMatch)
+ *
+ * Tests whether a passed in _character_ is an uppercase character and uses appropriate callback to
+ * mutate the value.
+ *
+ * **Related:** `ifUppercase()`
+ */
+export declare function ifUppercaseChar<T extends string, IF extends Narrowable, ELSE extends Narrowable>(
+/** the character to be tested */
+ch: T & IfChar<T>, callbackForMatch: ValueCallback<T, IF>, callbackForNoMatch: ValueCallback<T, ELSE>): Convert<T, IF, ELSE>;
+export {};
+//# sourceMappingURL=ifUppercase.d.ts.map

package/dist/runtime/src/runtime/literals/ifUppercase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ifUppercase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/ifUppercase.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAEzF,KAAK,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,IAAI,SAAS,CAAC,CAAC,EAAE,cAAc,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;AAEnE;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,CAAC,SAAS,MAAM,EAChB,EAAE,SAAS,UAAU,EACrB,IAAI,SAAS,UAAU;AAEvB,iCAAiC;AACjC,EAAE,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,EACjB,gBAAgB,EAAE,aAAa,CAAC,CAAC,EAAE,EAAE,CAAC,EACtC,kBAAkB,EAAE,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,GACzC,OAAO,CAAC,CAAC,EAAC,EAAE,EAAC,IAAI,CAAC,CASpB"}

package/dist/runtime/src/runtime/literals/ifUppercase.js

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { LOWER_ALPHA_CHARS } from "src/constants";
+/**
+ * **ifUppercaseChar**(ch, callbackForMatch, callbackForNoMatch)
+ *
+ * Tests whether a passed in _character_ is an uppercase character and uses appropriate callback to
+ * mutate the value.
+ *
+ * **Related:** `ifUppercase()`
+ */
+export function ifUppercaseChar(
+/** the character to be tested */
+ch, callbackForMatch, callbackForNoMatch) {
+    if (ch.length !== 1) {
+        throw new Error(`Invalid string length passed to ifUppercaseChar(ch); this function requires a single character but ${ch.length} were received`);
+    }
+    return (LOWER_ALPHA_CHARS.includes(ch)
+        ? callbackForMatch(ch)
+        : callbackForNoMatch(ch));
+}

package/dist/runtime/src/runtime/literals/index.d.ts

@@ -0,0 +1,31 @@
+export * from "./box";
+export * from "./identity";
+export * from "./literal";
+export * from "./stripTrailing";
+export * from "./stripLeading";
+export * from "./ensureTrailing";
+export * from "./ensureLeading";
+export * from "./ifUppercase";
+export * from "./pathJoin";
+export * from "./narrow";
+export * from "./split";
+export * from "./tuple";
+export * from "./capitalize";
+export * from "./uncapitalize";
+export * from "./uppercase";
+export * from "./lowercase";
+export * from "./widen";
+export * from "./toCamelCase";
+export * from "./toKebabCase";
+export * from "./ifLowercase";
+export * from "./toSnakeCase";
+export * from "./toString";
+export * from "./pluralize";
+export * from "./retainAfter";
+export * from "./surround";
+export * from "./stripAfter";
+export * from "./trim";
+export * from "./toPascalCase";
+export * from "./toUppercase";
+export * from "./toNumericArray";
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/src/runtime/literals/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/index.ts"],"names":[],"mappings":"AAMA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,eAAe,CAAC;AAC9B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,QAAQ,CAAC;AACvB,cAAc,gBAAgB,CAAC;AAC/B,cAAc,eAAe,CAAC;AAC9B,cAAc,kBAAkB,CAAC"}

package/dist/runtime/src/runtime/literals/index.js

@@ -0,0 +1,38 @@
+// #autoindex
+// #region auto-indexed files
+// index last changed at: 8th Aug, 2022, 09:51 AM ( GMT-7 )
+// hash-code: 7a22bbbc
+// file exports
+export * from "./box";
+export * from "./identity";
+export * from "./literal";
+export * from "./stripTrailing";
+export * from "./stripLeading";
+export * from "./ensureTrailing";
+export * from "./ensureLeading";
+export * from "./ifUppercase";
+export * from "./pathJoin";
+export * from "./narrow";
+export * from "./split";
+export * from "./tuple";
+export * from "./capitalize";
+export * from "./uncapitalize";
+export * from "./uppercase";
+export * from "./lowercase";
+export * from "./widen";
+export * from "./toCamelCase";
+export * from "./toKebabCase";
+export * from "./ifLowercase";
+export * from "./toSnakeCase";
+export * from "./toString";
+export * from "./pluralize";
+export * from "./retainAfter";
+export * from "./surround";
+export * from "./stripAfter";
+export * from "./trim";
+export * from "./toPascalCase";
+export * from "./toUppercase";
+export * from "./toNumericArray";
+// #endregion auto-indexed files
+// see https://github.com/inocan-group/do-devops/docs/autoindex.md
+// for more info

package/dist/runtime/src/runtime/literals/literal.d.ts

@@ -0,0 +1,42 @@
+import { Narrowable } from "src/types";
+/**
+ * Takes an object as input --which has an `id` property and returns it as the same
+ * run-time content but with the _type_ of the `id` property being forced to a literal type
+ */
+export declare function idLiteral<T extends {
+    id: I;
+}, I extends PropertyKey>(o: T): T & {
+    id: T["id"];
+};
+/**
+ * Takes an object as input --which has an `name` property and returns it as the same
+ * run-time content but with the _type_ of the `name` property being forced to a literal type
+ */
+export declare function nameLiteral<T extends {
+    name: I;
+}, I extends PropertyKey>(o: T): T & {
+    name: T["name"];
+};
+/**
+ * Takes an object as input --which has an `kind` property and returns it as the same
+ * run-time content but with the _type_ of the `kind` property being forced to a literal type
+ */
+export declare function kindLiteral<T extends {
+    kind: I;
+}, I extends PropertyKey>(o: T): T & {
+    kind: T["kind"];
+};
+export declare function idTypeGuard<T extends {
+    id: I;
+}, I extends PropertyKey>(_o: T): _o is T & {
+    id: I;
+};
+/**
+ * Takes an object as input and infers the narrow literal types of the property
+ * values on the object.
+ *
+ * > Note: this addresses this [a known TS gap](https://github.com/microsoft/TypeScript/issues/30680).
+ * > Hopefully at some point this will be addressed in the language.
+ */
+export declare function literal<N extends Narrowable, T extends Record<keyof T, N>>(obj: T): T;
+//# sourceMappingURL=literal.d.ts.map

package/dist/runtime/src/runtime/literals/literal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"literal.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/literal.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;GAGG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,CAAC,CAAA;CAAE,EAAE,CAAC,SAAS,WAAW,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG;IAAE,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAA;CAAE,CAE/F;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,EAAE,CAAC,SAAS,WAAW,EACtE,CAAC,EAAE,CAAC,GACH,CAAC,GAAG;IAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAA;CAAE,CAEzB;AAED;;;GAGG;AACH,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,CAAC,CAAA;CAAE,EAAE,CAAC,SAAS,WAAW,EACtE,CAAC,EAAE,CAAC,GACH,CAAC,GAAG;IAAE,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAA;CAAE,CAEzB;AAED,wBAAgB,WAAW,CAAC,CAAC,SAAS;IAAE,EAAE,EAAE,CAAC,CAAA;CAAE,EAAE,CAAC,SAAS,WAAW,EACpE,EAAE,EAAE,CAAC,GACJ,EAAE,IAAI,CAAC,GAAG;IAAE,EAAE,EAAE,CAAC,CAAA;CAAE,CAErB;AAED;;;;;;GAMG;AACH,wBAAgB,OAAO,CAAC,CAAC,SAAS,UAAU,EAAE,CAAC,SAAS,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,CAAC,KAEjF"}

package/dist/runtime/src/runtime/literals/literal.js

@@ -0,0 +1,35 @@
+/* eslint-disable no-use-before-define */
+/**
+ * Takes an object as input --which has an `id` property and returns it as the same
+ * run-time content but with the _type_ of the `id` property being forced to a literal type
+ */
+export function idLiteral(o) {
+    return { ...o, id: o.id };
+}
+/**
+ * Takes an object as input --which has an `name` property and returns it as the same
+ * run-time content but with the _type_ of the `name` property being forced to a literal type
+ */
+export function nameLiteral(o) {
+    return o;
+}
+/**
+ * Takes an object as input --which has an `kind` property and returns it as the same
+ * run-time content but with the _type_ of the `kind` property being forced to a literal type
+ */
+export function kindLiteral(o) {
+    return o;
+}
+export function idTypeGuard(_o) {
+    return true;
+}
+/**
+ * Takes an object as input and infers the narrow literal types of the property
+ * values on the object.
+ *
+ * > Note: this addresses this [a known TS gap](https://github.com/microsoft/TypeScript/issues/30680).
+ * > Hopefully at some point this will be addressed in the language.
+ */
+export function literal(obj) {
+    return obj;
+}

package/dist/runtime/src/runtime/literals/lowercase.d.ts

@@ -0,0 +1,8 @@
+/**
+ * **lowercase**()
+ *
+ * Run time utility which ensures all letters are lowercase while preserving
+ * string literal types.
+ */
+export declare function lowercase<T extends string>(str: T): Lowercase<T>;
+//# sourceMappingURL=lowercase.d.ts.map

package/dist/runtime/src/runtime/literals/lowercase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lowercase.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/lowercase.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAEhE"}

package/dist/runtime/src/runtime/literals/lowercase.js

@@ -0,0 +1,9 @@
+/**
+ * **lowercase**()
+ *
+ * Run time utility which ensures all letters are lowercase while preserving
+ * string literal types.
+ */
+export function lowercase(str) {
+    return str.toLowerCase();
+}

package/dist/runtime/src/runtime/literals/narrow.d.ts

@@ -0,0 +1,18 @@
+import { First, Length, Narrowable, UnionToTuple, IfUnion } from "src/types";
+/**
+ * **narrow**(value)
+ *
+ * An identity function which provides the input in as narrow a form
+ * as possible.
+ * ```ts
+ * const s = narrow("foo"); // "foo"
+ * const n = narrow(42); // 42
+ * // ["foo", "bar"]
+ * const t1 = narrow(["foo", "bar"] as const);
+ * const t2 = narrow("foo", "bar");
+ * // string`[]
+ * const t3 = narrow(["foo", "bar"]);
+ * ```
+ */
+export declare function narrow<N extends Narrowable, K extends PropertyKey, T extends readonly (Record<K, N> | Narrowable)[]>(...values: T): Length<T> extends 1 ? T[0] extends readonly unknown[] ? T[0] extends infer Arr ? IfUnion<First<Arr & readonly unknown[]>, Readonly<UnionToTuple<First<T[0]>>>, T[0]> : Readonly<T[0]> : T[0] : Readonly<T>;
+//# sourceMappingURL=narrow.d.ts.map

package/dist/runtime/src/runtime/literals/narrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"narrow.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/narrow.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EACL,MAAM,EACN,UAAU,EACV,YAAY,EACZ,OAAO,EACR,MAAM,WAAW,CAAC;AAEnB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CACpB,CAAC,SAAS,UAAU,EACpB,CAAC,SAAS,WAAW,EACrB,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,EAAC,CAAC,CAAC,GAAG,UAAU,CAAC,EAAE,EAC/C,GAAG,MAAM,EAAE,CAAC,8MAgBb"}

package/dist/runtime/src/runtime/literals/narrow.js

@@ -0,0 +1,20 @@
+/**
+ * **narrow**(value)
+ *
+ * An identity function which provides the input in as narrow a form
+ * as possible.
+ * ```ts
+ * const s = narrow("foo"); // "foo"
+ * const n = narrow(42); // 42
+ * // ["foo", "bar"]
+ * const t1 = narrow(["foo", "bar"] as const);
+ * const t2 = narrow("foo", "bar");
+ * // string`[]
+ * const t3 = narrow(["foo", "bar"]);
+ * ```
+ */
+export function narrow(...values) {
+    return (values.length === 1
+        ? values[0]
+        : values);
+}

package/dist/runtime/src/runtime/literals/pathJoin.d.ts

@@ -0,0 +1,14 @@
+import { PathJoin } from "src/types";
+/**
+ * **pathJoin**`<T,U>(begin, ...rest)`
+ *
+ * Run time utility which joins two strings together with
+ * the intent to have them be divided by a Posix `/` character
+ * appropriate for Unix file paths and URLs.
+ *
+ * **note:** to support more than two paths being joined there
+ * is now the ability to add a tuple of paths into the _rest_
+ * parameter
+ */
+export declare function pathJoin<T extends string, U extends readonly string[]>(begin: T, ...rest: U): PathJoin<T, U>;
+//# sourceMappingURL=pathJoin.d.ts.map

package/dist/runtime/src/runtime/literals/pathJoin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathJoin.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/pathJoin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AAQrC;;;;;;;;;;GAUG;AACH,wBAAgB,QAAQ,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,SAAS,MAAM,EAAE,EACpE,KAAK,EAAE,CAAC,EACR,GAAG,IAAI,EAAE,CAAC,GACT,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAYhB"}

package/dist/runtime/src/runtime/literals/pathJoin.js

@@ -0,0 +1,21 @@
+import { ensureLeading, ensureTrailing, stripLeading, stripTrailing } from "src/runtime";
+/**
+ * **pathJoin**`<T,U>(begin, ...rest)`
+ *
+ * Run time utility which joins two strings together with
+ * the intent to have them be divided by a Posix `/` character
+ * appropriate for Unix file paths and URLs.
+ *
+ * **note:** to support more than two paths being joined there
+ * is now the ability to add a tuple of paths into the _rest_
+ * parameter
+ */
+export function pathJoin(begin, ...rest) {
+    const start = rest.length > 0 ? ensureTrailing(begin, "/") : begin;
+    const end = rest.length > 0 ? ensureLeading(rest.slice(-1)[0], "/") : "";
+    const middle = rest.length > 1
+        ? rest.slice(0, rest.length - 1).map((i) => stripLeading(stripTrailing(i, "/"), '"'))
+        : [];
+    const midString = stripTrailing(stripLeading(middle.join("/"), "/"), "/");
+    return (rest.length > 1 ? `${start}${midString}${end}` : `${start}${stripLeading(end, "/")}`);
+}

package/dist/runtime/src/runtime/literals/pluralize.d.ts

@@ -0,0 +1,3 @@
+import { Pluralize } from "src/types";
+export declare const pluralize: <T extends string>(word: T) => Pluralize<T>;
+//# sourceMappingURL=pluralize.d.ts.map

package/dist/runtime/src/runtime/literals/pluralize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pluralize.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/pluralize.ts"],"names":[],"mappings":"AAQA,OAAO,EAAY,SAAS,EAAgB,MAAM,WAAW,CAAC;AAkD9D,eAAO,MAAM,SAAS,6CAUrB,CAAC"}

package/dist/runtime/src/runtime/literals/pluralize.js

@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { ALPHA_CHARS, CONSONANTS, PLURAL_EXCEPTIONS, SINGULAR_NOUN_ENDINGS } from "src/constants";
+import { getEach, split, stripTrailing } from "src/runtime";
+const isException = (word) => getEach(PLURAL_EXCEPTIONS, "0").includes(word);
+const exceptionLookup = (word) => {
+    const found = PLURAL_EXCEPTIONS.find(i => i[0] === word);
+    if (found) {
+        const plural = found[1];
+        return plural;
+    }
+    else {
+        throw new Error(`The word "${word}" was supposed to have an exception rule but it couldn't be found!`);
+    }
+};
+const END_IN = [
+    "is",
+    "y",
+    "f",
+    "singular-noun"
+];
+const endingIn = (word, postfix) => {
+    switch (postfix) {
+        case "is":
+            return word.endsWith(postfix) ? `${word}es` : undefined;
+        case "singular-noun":
+            return SINGULAR_NOUN_ENDINGS.some(i => word.endsWith(i))
+                ? split(word).every((i) => ALPHA_CHARS.includes(i))
+                    ? `${word}es`
+                    : undefined
+                : undefined;
+        case "f":
+            return word.endsWith("f")
+                ? stripTrailing(word, "f") + "ves"
+                : word.endsWith("fe")
+                    ? stripTrailing(word, "fe") + "ves"
+                    : undefined;
+        case "y":
+            return word.endsWith("y")
+                ? CONSONANTS.includes(word.slice(-2, 1))
+                    ? stripTrailing(word, "y") + "ies"
+                    : undefined
+                : undefined;
+        default:
+            throw new Error(`endingIn received "${postfix}" as a postfix but this ending is not known!`);
+    }
+};
+export const pluralize = (word) => {
+    return (isException(word)
+        ? exceptionLookup(word)
+        : endingIn(word, "is") ||
+            endingIn(word, "singular-noun") ||
+            endingIn(word, "f") ||
+            endingIn(word, "y") ||
+            `${word}s` // add "s" if no other patterns match
+    );
+};

package/dist/runtime/src/runtime/literals/retainAfter.d.ts

@@ -0,0 +1,15 @@
+import { RetainAfter } from "src/types";
+/**
+ * **RetainAfter**(content, find)
+ *
+ * Runtime utility which removes all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // "world"
+ * const world = retainAfter("hello world", " ");
+ * ```
+ */
+export declare function retainAfter<TContent extends string, TBreak extends string>(content: TContent, find: TBreak): RetainAfter<TContent, TBreak>;
+//# sourceMappingURL=retainAfter.d.ts.map

package/dist/runtime/src/runtime/literals/retainAfter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retainAfter.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/retainAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAExC;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CACzB,QAAQ,SAAS,MAAM,EACvB,MAAM,SAAS,MAAM,EACrB,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,iCAIhC"}

package/dist/runtime/src/runtime/literals/retainAfter.js

@@ -0,0 +1,17 @@
+/**
+ * **RetainAfter**(content, find)
+ *
+ * Runtime utility which removes all characters in a given string _until_
+ * it finds the first instance of a substring defined in **find** variable.
+ *
+ * ### Example
+ * ```ts
+ * // "world"
+ * const world = retainAfter("hello world", " ");
+ * ```
+ */
+export function retainAfter(content, find) {
+    const parts = content.split(find);
+    parts.shift();
+    return parts.join(find);
+}

package/dist/runtime/src/runtime/literals/split.d.ts

@@ -0,0 +1,13 @@
+import { Split } from "src/types";
+/**
+ * **split**(str, sep)
+ *
+ * Splits a string on a given separator while preserving string literal typing
+ * where available. Behavior with non-string types is:
+ *
+ * - `number` - converted to string and then split
+ *
+ * All are other types are disallowed.
+ */
+export declare function split<T extends string | number, S extends string>(str: T, sep?: S): (Split<T & string, S> & string) | Split<T & `${number}`, S>;
+//# sourceMappingURL=split.d.ts.map

package/dist/runtime/src/runtime/literals/split.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"split.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/split.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,KAAK,EAAE,MAAM,WAAW,CAAC;AAGlD;;;;;;;;;GASG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,EAAE,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,GAAE,CAAW,+DAM1F"}

package/dist/runtime/src/runtime/literals/split.js

@@ -0,0 +1,19 @@
+import { errorCondition } from "src/types";
+import { isNumber, isString } from "src/runtime";
+/**
+ * **split**(str, sep)
+ *
+ * Splits a string on a given separator while preserving string literal typing
+ * where available. Behavior with non-string types is:
+ *
+ * - `number` - converted to string and then split
+ *
+ * All are other types are disallowed.
+ */
+export function split(str, sep = "") {
+    return isString(str)
+        ? str.split(sep)
+        : isNumber(str)
+            ? String(str).split(sep)
+            : errorCondition("invalid-type", `split() function allows string, numbers, and the null value but found a type of ${typeof str}.`);
+}

package/dist/runtime/src/runtime/literals/stripAfter.d.ts

@@ -0,0 +1,15 @@
+import { StripAfter } from "src/types";
+/**
+ * **stripAfter**(content, find)
+ *
+ * Runtime utility which strips out all characters after (and including)
+ * the "find" string while returning a strong type.
+ *
+ * ### Example
+ * ```ts
+ * // "hello"
+ * const hello = stripAfter("hello world", " ");
+ * ```
+ */
+export declare function stripAfter<TContent extends string, TBreak extends string>(content: TContent, find: TBreak): StripAfter<TContent, TBreak>;
+//# sourceMappingURL=stripAfter.d.ts.map

package/dist/runtime/src/runtime/literals/stripAfter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripAfter.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/stripAfter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvC;;;;;;;;;;;GAWG;AACH,wBAAgB,UAAU,CACxB,QAAQ,SAAS,MAAM,EACvB,MAAM,SAAS,MAAM,EACrB,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,gCAEhC"}

package/dist/runtime/src/runtime/literals/stripAfter.js

@@ -0,0 +1,15 @@
+/**
+ * **stripAfter**(content, find)
+ *
+ * Runtime utility which strips out all characters after (and including)
+ * the "find" string while returning a strong type.
+ *
+ * ### Example
+ * ```ts
+ * // "hello"
+ * const hello = stripAfter("hello world", " ");
+ * ```
+ */
+export function stripAfter(content, find) {
+    return content.split(find).shift();
+}

package/dist/runtime/src/runtime/literals/stripLeading.d.ts

@@ -0,0 +1,9 @@
+import { StripLeading } from "src/types";
+/**
+ * **stripLeading**(content, strip)
+ *
+ * Runtime utility which strips of a leading substring from the
+ * primary content if it exists and leaves content unchanged otherwise.
+ */
+export declare function stripLeading<T extends string, U extends string>(content: T, strip: U): StripLeading<T, U>;
+//# sourceMappingURL=stripLeading.d.ts.map

package/dist/runtime/src/runtime/literals/stripLeading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripLeading.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/stripLeading.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAC7D,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,CAAC,GACP,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,CASpB"}

package/dist/runtime/src/runtime/literals/stripLeading.js

@@ -0,0 +1,14 @@
+/**
+ * **stripLeading**(content, strip)
+ *
+ * Runtime utility which strips of a leading substring from the
+ * primary content if it exists and leaves content unchanged otherwise.
+ */
+export function stripLeading(content, strip) {
+    const re = new RegExp(`^${strip}(.*)`);
+    return (content.startsWith(strip)
+        ? // starts with
+            content.replace(re, "$1")
+        : // does not
+            content);
+}

package/dist/runtime/src/runtime/literals/stripTrailing.d.ts

@@ -0,0 +1,9 @@
+import { StripTrailing } from "src/types";
+/**
+ * **stripTrailing**(content, strip)
+ *
+ * Runtime utility which ensures that last part of a string has substring
+ * removed if it exists and that strong typing is preserved.
+ */
+export declare function stripTrailing<T extends string, U extends string>(content: T, strip: U): StripTrailing<T, U>;
+//# sourceMappingURL=stripTrailing.d.ts.map

package/dist/runtime/src/runtime/literals/stripTrailing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stripTrailing.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/stripTrailing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,MAAM,EAC9D,OAAO,EAAE,CAAC,EACV,KAAK,EAAE,CAAC,GACP,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAGrB"}

package/dist/runtime/src/runtime/literals/stripTrailing.js

@@ -0,0 +1,10 @@
+/**
+ * **stripTrailing**(content, strip)
+ *
+ * Runtime utility which ensures that last part of a string has substring
+ * removed if it exists and that strong typing is preserved.
+ */
+export function stripTrailing(content, strip) {
+    const re = new RegExp(`(.*)${strip}$`);
+    return (content?.endsWith(strip) ? content.replace(re, "$1") : content);
+}

package/dist/runtime/src/runtime/literals/surround.d.ts

@@ -0,0 +1,10 @@
+export type SurroundWith<TPrefix extends string, TPostfix extends string> = <TInput extends string>(input: TInput) => `${TPrefix}${TInput}${TPostfix}`;
+/**
+ * **surround**(prefix, postfix) -> (input) -> `${prefix}${input}${postfix}`
+ *
+ * A higher order runtime utility which receives a prefix and postfix string
+ * on it's first call. This returns a secondary function which will _surround_
+ * the given input with the prefix and postfix strings.
+ */
+export declare function surround<TPrefix extends string, TPostfix extends string>(prefix: TPrefix, postfix: TPostfix): SurroundWith<TPrefix, TPostfix>;
+//# sourceMappingURL=surround.d.ts.map

package/dist/runtime/src/runtime/literals/surround.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surround.d.ts","sourceRoot":"","sources":["../../../../../src/runtime/literals/surround.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,YAAY,CACxB,OAAO,SAAS,MAAM,EACtB,QAAQ,SAAS,MAAM,IACnB,CAAC,MAAM,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,QAAQ,EAAE,CAAC;AAE/E;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,OAAO,SAAS,MAAM,EACtB,QAAQ,SAAS,MAAM,EACvB,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,QAAQ,GAAG,YAAY,CAAC,OAAO,EAAE,QAAQ,CAAC,CAErE"}

package/dist/runtime/src/runtime/literals/surround.js

@@ -0,0 +1,10 @@
+/**
+ * **surround**(prefix, postfix) -> (input) -> `${prefix}${input}${postfix}`
+ *
+ * A higher order runtime utility which receives a prefix and postfix string
+ * on it's first call. This returns a secondary function which will _surround_
+ * the given input with the prefix and postfix strings.
+ */
+export function surround(prefix, postfix) {
+    return (input) => `${prefix}${input}${postfix}`;
+}