@battis/typescript-tricks 0.7.8 → 0.8.0

package/coverage/lcov-report/sorter.js

@@ -0,0 +1,210 @@
+/* eslint-disable */
+var addSorting = (function() {
+    'use strict';
+    var cols,
+        currentSort = {
+            index: 0,
+            desc: false
+        };
+
+    // returns the summary table element
+    function getTable() {
+        return document.querySelector('.coverage-summary');
+    }
+    // returns the thead element of the summary table
+    function getTableHeader() {
+        return getTable().querySelector('thead tr');
+    }
+    // returns the tbody element of the summary table
+    function getTableBody() {
+        return getTable().querySelector('tbody');
+    }
+    // returns the th element for nth column
+    function getNthColumn(n) {
+        return getTableHeader().querySelectorAll('th')[n];
+    }
+
+    function onFilterInput() {
+        const searchValue = document.getElementById('fileSearch').value;
+        const rows = document.getElementsByTagName('tbody')[0].children;
+
+        // Try to create a RegExp from the searchValue. If it fails (invalid regex),
+        // it will be treated as a plain text search
+        let searchRegex;
+        try {
+            searchRegex = new RegExp(searchValue, 'i'); // 'i' for case-insensitive
+        } catch (error) {
+            searchRegex = null;
+        }
+
+        for (let i = 0; i < rows.length; i++) {
+            const row = rows[i];
+            let isMatch = false;
+
+            if (searchRegex) {
+                // If a valid regex was created, use it for matching
+                isMatch = searchRegex.test(row.textContent);
+            } else {
+                // Otherwise, fall back to the original plain text search
+                isMatch = row.textContent
+                    .toLowerCase()
+                    .includes(searchValue.toLowerCase());
+            }
+
+            row.style.display = isMatch ? '' : 'none';
+        }
+    }
+
+    // loads the search box
+    function addSearchBox() {
+        var template = document.getElementById('filterTemplate');
+        var templateClone = template.content.cloneNode(true);
+        templateClone.getElementById('fileSearch').oninput = onFilterInput;
+        template.parentElement.appendChild(templateClone);
+    }
+
+    // loads all columns
+    function loadColumns() {
+        var colNodes = getTableHeader().querySelectorAll('th'),
+            colNode,
+            cols = [],
+            col,
+            i;
+
+        for (i = 0; i < colNodes.length; i += 1) {
+            colNode = colNodes[i];
+            col = {
+                key: colNode.getAttribute('data-col'),
+                sortable: !colNode.getAttribute('data-nosort'),
+                type: colNode.getAttribute('data-type') || 'string'
+            };
+            cols.push(col);
+            if (col.sortable) {
+                col.defaultDescSort = col.type === 'number';
+                colNode.innerHTML =
+                    colNode.innerHTML + '<span class="sorter"></span>';
+            }
+        }
+        return cols;
+    }
+    // attaches a data attribute to every tr element with an object
+    // of data values keyed by column name
+    function loadRowData(tableRow) {
+        var tableCols = tableRow.querySelectorAll('td'),
+            colNode,
+            col,
+            data = {},
+            i,
+            val;
+        for (i = 0; i < tableCols.length; i += 1) {
+            colNode = tableCols[i];
+            col = cols[i];
+            val = colNode.getAttribute('data-value');
+            if (col.type === 'number') {
+                val = Number(val);
+            }
+            data[col.key] = val;
+        }
+        return data;
+    }
+    // loads all row data
+    function loadData() {
+        var rows = getTableBody().querySelectorAll('tr'),
+            i;
+
+        for (i = 0; i < rows.length; i += 1) {
+            rows[i].data = loadRowData(rows[i]);
+        }
+    }
+    // sorts the table using the data for the ith column
+    function sortByIndex(index, desc) {
+        var key = cols[index].key,
+            sorter = function(a, b) {
+                a = a.data[key];
+                b = b.data[key];
+                return a < b ? -1 : a > b ? 1 : 0;
+            },
+            finalSorter = sorter,
+            tableBody = document.querySelector('.coverage-summary tbody'),
+            rowNodes = tableBody.querySelectorAll('tr'),
+            rows = [],
+            i;
+
+        if (desc) {
+            finalSorter = function(a, b) {
+                return -1 * sorter(a, b);
+            };
+        }
+
+        for (i = 0; i < rowNodes.length; i += 1) {
+            rows.push(rowNodes[i]);
+            tableBody.removeChild(rowNodes[i]);
+        }
+
+        rows.sort(finalSorter);
+
+        for (i = 0; i < rows.length; i += 1) {
+            tableBody.appendChild(rows[i]);
+        }
+    }
+    // removes sort indicators for current column being sorted
+    function removeSortIndicators() {
+        var col = getNthColumn(currentSort.index),
+            cls = col.className;
+
+        cls = cls.replace(/ sorted$/, '').replace(/ sorted-desc$/, '');
+        col.className = cls;
+    }
+    // adds sort indicators for current column being sorted
+    function addSortIndicators() {
+        getNthColumn(currentSort.index).className += currentSort.desc
+            ? ' sorted-desc'
+            : ' sorted';
+    }
+    // adds event listeners for all sorter widgets
+    function enableUI() {
+        var i,
+            el,
+            ithSorter = function ithSorter(i) {
+                var col = cols[i];
+
+                return function() {
+                    var desc = col.defaultDescSort;
+
+                    if (currentSort.index === i) {
+                        desc = !currentSort.desc;
+                    }
+                    sortByIndex(i, desc);
+                    removeSortIndicators();
+                    currentSort.index = i;
+                    currentSort.desc = desc;
+                    addSortIndicators();
+                };
+            };
+        for (i = 0; i < cols.length; i += 1) {
+            if (cols[i].sortable) {
+                // add the click event handler on the th so users
+                // dont have to click on those tiny arrows
+                el = getNthColumn(i).querySelector('.sorter').parentElement;
+                if (el.addEventListener) {
+                    el.addEventListener('click', ithSorter(i));
+                } else {
+                    el.attachEvent('onclick', ithSorter(i));
+                }
+            }
+        }
+    }
+    // adds sorting functionality to the UI
+    return function() {
+        if (!getTable()) {
+            return;
+        }
+        cols = loadColumns();
+        loadData();
+        addSearchBox();
+        addSortIndicators();
+        enableUI();
+    };
+})();
+
+window.addEventListener('load', addSorting);

package/coverage/lcov.info

@@ -0,0 +1,94 @@
+TN:
+SF:src/JSON.ts
+FN:15,isJSONPrimitive
+FNF:1
+FNH:1
+FNDA:1,isJSONPrimitive
+DA:15,1
+DA:16,1
+LF:2
+LH:2
+BRDA:17,0,0,1
+BRDA:17,0,1,1
+BRDA:17,0,2,0
+BRDA:17,0,3,0
+BRF:4
+BRH:2
+end_of_record
+TN:
+SF:src/Key.ts
+FN:3,isKey
+FN:12,isKeyof
+FNF:2
+FNH:2
+FNDA:18,isKey
+FNDA:5,isKeyof
+DA:3,3
+DA:4,18
+DA:12,3
+DA:16,5
+LF:4
+LH:4
+BRDA:5,0,0,18
+BRDA:5,0,1,18
+BRDA:5,0,2,7
+BRDA:5,0,3,5
+BRDA:7,1,0,7
+BRDA:7,1,1,3
+BRDA:17,2,0,5
+BRDA:17,2,1,5
+BRDA:17,2,2,3
+BRDA:17,2,3,4
+BRDA:17,2,4,1
+BRDA:17,2,5,3
+BRDA:17,2,6,1
+BRF:13
+BRH:13
+end_of_record
+TN:
+SF:src/Record.ts
+FN:1,isRecord
+FN:13,(anonymous_1)
+FN:45,(anonymous_2)
+FNF:3
+FNH:3
+FNDA:10,isRecord
+FNDA:10,(anonymous_1)
+FNDA:200,(anonymous_2)
+DA:1,1
+DA:9,10
+DA:14,10
+DA:45,200
+LF:4
+LH:4
+BRDA:10,0,0,10
+BRDA:10,0,1,9
+BRDA:10,0,2,9
+BRDA:10,0,3,8
+BRDA:14,1,0,10
+BRDA:14,1,1,10
+BRDA:14,1,2,10
+BRDA:14,1,3,10
+BRDA:14,1,4,10
+BRDA:45,2,0,200
+BRDA:45,2,1,95
+BRF:11
+BRH:11
+end_of_record
+TN:
+SF:src/TypeJuggling.ts
+FN:13,isUnknown
+FN:17,isString
+FNF:2
+FNH:2
+FNDA:7,isUnknown
+FNDA:5,isString
+DA:13,1
+DA:14,7
+DA:17,1
+DA:18,5
+LF:4
+LH:4
+BRF:0
+BRH:0
+end_of_record

package/dist/Array.d.ts

@@ -0,0 +1,2 @@
+export type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;
+export declare function isEntries<K extends string | number | symbol = string | number | symbol, V = unknown>(obj: unknown, isK?: (k: unknown) => k is K, isV?: (v: unknown) => v is V): obj is [K, V][];

package/dist/Array.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEntries = isEntries;
+function isEntries(obj, isK, isV) {
+    return (Array.isArray(obj) &&
+        (obj.length === 0 ||
+            obj.reduce((entries, elt) => entries &&
+                Array.isArray(elt) &&
+                elt.length == 2 &&
+                (!isK || isK(elt[0])) &&
+                (!isV || isV(elt[1])), true)));
+}

package/dist/{JSONValue.d.ts → JSON.d.ts}

@@ -4,4 +4,6 @@ export interface JSONObject {
     [k: string]: JSONValue;
 }
 export type JSONValue = JSONPrimitive | JSONArray | JSONObject;
+/** @deprecated Default exports are not best practice */
 export default JSONValue;
+export declare function isJSONPrimitive(value: unknown): value is JSONPrimitive;

package/dist/JSON.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isJSONPrimitive = isJSONPrimitive;
+function isJSONPrimitive(value) {
+    return (value === null ||
+        typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'boolean');
+}

package/dist/Key.d.ts

@@ -0,0 +1,3 @@
+export type Key = string | number | symbol;
+export declare function isKey(value: unknown): value is Key;
+export declare function isKeyof<T extends object>(value: unknown, obj: T): value is keyof T;

package/dist/Key.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isKey = isKey;
+exports.isKeyof = isKeyof;
+function isKey(value) {
+    return (value !== undefined &&
+        (typeof value === 'string' ||
+            (typeof value === 'number' && parseInt(value.toString())) === value ||
+            typeof value === 'symbol'));
+}
+function isKeyof(value, obj) {
+    return (isKey(value) &&
+        ((typeof value === 'string' && Object.keys(obj).includes(value)) ||
+            (typeof value === 'number' &&
+                Object.keys(obj).includes(value.toString())) ||
+            (typeof value === 'symbol' &&
+                Object.getOwnPropertySymbols(obj).includes(value))));
+}

package/dist/{MethodNames.d.ts → Methods.d.ts}

@@ -1,13 +1,11 @@
-/**
- * @see https://stackoverflow.com/a/61940388
- */
+/** @see https://stackoverflow.com/a/61940388 */
 export type MethodNames<T extends {
-    [K in keyof T]: any;
+    [K in keyof T]: unknown;
 }> = {
     [K in keyof T]: T[K] extends Function ? K : never;
 }[keyof T];
 export type MethodNamesMatching<T extends {
-    [K in keyof T]: any;
+    [K in keyof T]: unknown;
 }, P extends Function = Function> = {
     [K in keyof T]: T[K] extends Function ? P extends T[K] ? K : never : never;
 }[keyof T];

package/dist/{MethodNames.js → Methods.js}

@@ -1,2 +1,3 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Object.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @see {@link https://stackoverflow.com/a/69571314/294171 StackOverflow response} on static interfaces
+ *
+ * ```ts
+ * interface InstanceInterface {
+ *   instanceMethod();
+ * }
+ *
+ * interface StaticInterface {
+ *   new(...args: any[]): InstanceInterface;
+ *   staticMethod();
+ * }
+ *
+ * class MyClass implements StaticImplements<StaticInterface, typeof MyClass> {
+ *   static staticMethod() { }
+ *   static ownStaticMethod() { }
+ *   instanceMethod() { }
+ *   ownInstanceMethod() { }
+ * }
+ * ```
+ */
+export type StaticImplements<I extends new (...args: unknown[]) => object, C extends I> = InstanceType<C>;

package/dist/{PropertyRequirements.d.ts → Properties.d.ts}

@@ -1,12 +1,8 @@
-/**
- * @see {@link https://stackoverflow.com/a/49725198/294171 StackOverflow response} on requiring at least one property
- */
+/** @see {@link https://stackoverflow.com/a/49725198/294171 StackOverflow response} on requiring at least one property */
 export type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
     [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
 }[Keys];
-/**
- * @see {@link https://stackoverflow.com/a/49725198/294171 StackOverflow response} on requiring only one property
- */
+/** @see {@link https://stackoverflow.com/a/49725198/294171 StackOverflow response} on requiring only one property */
 export type RequireOnlyOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
     [K in Keys]-?: Required<Pick<T, K>> & Partial<Record<Exclude<Keys, K>, undefined>>;
 }[Keys];
@@ -17,10 +13,10 @@ export type RecursivePartial<T> = {
 /**
  * ```ts
  * type A = {
- *   d: number,
- *   e: string
- *   f: boolean
- * }
+ *   d: number;
+ *   e: string;
+ *   f: boolean;
+ * };
  *
  * type B = ReplaceProperty<A, 'e', number[]>;
  * // type B = {
@@ -29,6 +25,7 @@ export type RecursivePartial<T> = {
  * //   f: boolean
  * // }
  * ```
+ *
  * @see {@link https://stackoverflow.com/a/51599774 StackOverflow response}
  */
 export type ReplaceProperty<T, K extends keyof T, TReplace> = Identity<Pick<T, Exclude<keyof T, K>> & {
@@ -37,4 +34,5 @@ export type ReplaceProperty<T, K extends keyof T, TReplace> = Identity<Pick<T, E
 type Identity<T> = {
     [P in keyof T]: T[P];
 };
+export type OptionalProperty<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export {};

package/dist/Record.d.ts

@@ -1 +1 @@
-export declare function isRecord<K extends string | number | symbol, V>(obj: unknown, isK: (k: unknown) => k is K, isV: (v: unknown) => v is V): obj is Record<K, V>;
+export declare function isRecord<K extends string | number | symbol = string | number | symbol, V = unknown>(obj: unknown, isK?: (k: unknown) => k is K, isV?: (v: unknown) => v is V): obj is Record<K, V>;

package/dist/Record.js

@@ -4,10 +4,9 @@ exports.isRecord = isRecord;
 function isRecord(obj, isK, isV) {
     return (typeof obj === 'object' &&
         obj !== null &&
-        Object.keys(obj).reduce((result, key) => result && isK(key), true) &&
-        Object.keys(obj)
-            .map((key) => obj[key])
-            .reduce((result, value) => result && isV(value), true) &&
+        Object.keys(obj).reduce((result, key) => result &&
+            (!isK || isK(key)) &&
+            (!isV || isV(obj[key])), true) &&
         [
             Function,
             Boolean,
@@ -32,6 +31,7 @@ function isRecord(obj, isK, isV) {
             DataView,
             Promise,
             DisposableStack,
-            AsyncDisposableStack
+            AsyncDisposableStack,
+            FormData
         ].reduce((result, T) => result && !(obj instanceof T), true));
 }

package/dist/{OneOf.d.ts → TypeJuggling.d.ts}

@@ -1,3 +1,4 @@
+export type AsynchronousFunction = () => Promise<unknown>;
 /** @see https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types#comment123255834_53229567 */
 type UnionKeys<T> = T extends T ? keyof T : never;
 type Expand<T> = T extends T ? {
@@ -6,4 +7,6 @@ type Expand<T> = T extends T ? {
 export type OneOf<T extends object[]> = {
     [K in keyof T]: Expand<T[K] & Partial<Record<Exclude<UnionKeys<T[number]>, keyof T[K]>, never>>>;
 }[number];
+export declare function isUnknown(obj: unknown): obj is unknown;
+export declare function isString(obj: unknown): obj is string;
 export {};

package/dist/TypeJuggling.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUnknown = isUnknown;
+exports.isString = isString;
+function isUnknown(obj) {
+    return true;
+}
+function isString(obj) {
+    return typeof obj === 'string';
+}

package/dist/_Deprecated.d.ts

@@ -0,0 +1,63 @@
+import { JSONPrimitive } from './JSON.js';
+/** @deprecated Use Error.isError() */
+export declare function isError(error: unknown): error is Error;
+/** @deprecated Use Error.isError() */
+export declare function CoerceError(error: unknown): Error;
+/** @deprecated `null` is part of type unless using utility type `Nonnullable` */
+export type Nullable<T> = T | null;
+/** @deprecated Use `?` */
+export type Optional<T> = T | undefined;
+/** @deprecated Use `Record<string,T>` */
+export type AssociativeArray<T> = {
+    [key: string]: T;
+};
+/** @deprecated Use {@link JSONPrimitive} */
+export type JSONPrimitiveTypes = JSONPrimitive;
+/**
+ * @deprecated See
+ *   {@link https://www.typescriptlang.org/docs/handbook/mixins.html#constrained-mixins TypeScript docs}
+ */
+export type Mixin<T extends (...args: any[]) => any> = InstanceType<ReturnType<T>>;
+/** @deprecated Use {@link filterByType} */
+export declare const instanceOf: typeof filterByType;
+/** @deprecated Use-case unclear */
+export declare function Coerce<T>(u: unknown, isT: (u: unknown) => u is T, toT?: (u: unknown) => T): T;
+/** @deprecated Use-case unclear */
+export type Subset<T, U extends T> = T;
+type EnumObject = {
+    [key: string]: number | string;
+};
+type EnumObjectEnum<E extends EnumObject> = E extends {
+    [key: string]: infer ET | string;
+} ? ET : never;
+/**
+ * @deprecated Use
+ *   {@link   https://www.typescriptlang.org/docs/handbook/enums.html enum}
+ * @see {@link https://blog.oyam.dev/typescript-enum-values/ How to get an array of enum values in TypeScript}
+ */
+export declare function getEnumValues<E extends EnumObject>(enumObject: E): EnumObjectEnum<E>[];
+/** @deprecated Use-case unclear */
+export type Constructor<T = object> = new (...args: unknown[]) => T;
+/** @deprecated Use-case unclear */
+export declare function isConstructor<T = unknown>(value: unknown): value is Constructor<T>;
+/**
+ * ```ts
+ * class A {}
+ * class B {}
+ * class C extends A {}
+ *
+ * const a = new A();
+ * const b = new B();
+ * const c = new C();
+ *
+ * const list = [a, b, c];
+ * const filteredList = filterByType(list, A);
+ * // filteredList = [a, c]
+ * ```
+ *
+ * @ see https://stackoverflow.com/a/65152869/294171
+ *
+ * @deprecated Use-case unclear
+ */
+export declare function filterByType<Elements, Filter extends Elements>(array: Elements[], filterType: Constructor<Filter>): Filter[];
+export {};

package/dist/_Deprecated.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOf = void 0;
+exports.isError = isError;
+exports.CoerceError = CoerceError;
+exports.Coerce = Coerce;
+exports.getEnumValues = getEnumValues;
+exports.isConstructor = isConstructor;
+exports.filterByType = filterByType;
+/** @deprecated Use Error.isError() */
+function isError(error) {
+    return (typeof error === 'object' &&
+        error !== null &&
+        'message' in error &&
+        'name' in error &&
+        typeof error.name === 'string' &&
+        typeof error.message === 'string');
+}
+/** @deprecated Use Error.isError() */
+function CoerceError(error) {
+    return Coerce(error, isError, (e) => e);
+}
+/** @deprecated Use {@link filterByType} */
+exports.instanceOf = filterByType;
+/** @deprecated Use-case unclear */
+function Coerce(u, isT, toT) {
+    if (isT(u)) {
+        return u;
+    }
+    try {
+        if (toT) {
+            return toT(u);
+        }
+        else {
+            throw new Error('No toT() method provided');
+        }
+    }
+    catch (_a) {
+        throw new Error('Attempted coercion to a non-matching type');
+    }
+}
+/**
+ * @deprecated Use
+ *   {@link   https://www.typescriptlang.org/docs/handbook/enums.html enum}
+ * @see {@link https://blog.oyam.dev/typescript-enum-values/ How to get an array of enum values in TypeScript}
+ */
+function getEnumValues(enumObject) {
+    return Object.keys(enumObject)
+        .filter((key) => Number.isNaN(Number(key)))
+        .map((key) => enumObject[key]);
+}
+/** @deprecated Use-case unclear */
+function isConstructor(value) {
+    return (!!value &&
+        typeof value === 'object' &&
+        'prototype' in value &&
+        typeof value.prototype === 'object' &&
+        !!value.prototype &&
+        'constructor' in value.prototype.constructor);
+}
+/**
+ * ```ts
+ * class A {}
+ * class B {}
+ * class C extends A {}
+ *
+ * const a = new A();
+ * const b = new B();
+ * const c = new C();
+ *
+ * const list = [a, b, c];
+ * const filteredList = filterByType(list, A);
+ * // filteredList = [a, c]
+ * ```
+ *
+ * @ see https://stackoverflow.com/a/65152869/294171
+ *
+ * @deprecated Use-case unclear
+ */
+function filterByType(array, filterType) {
+    return array.filter((e) => e instanceof filterType);
+}

package/dist/index.d.ts

@@ -1,14 +1,10 @@
-export * from './ArrayElement';
-export * from './Coerce';
-export * from './Constructor';
-export * from './EnumeratedTypes';
-export * from './Forms';
-export * from './JSONValue';
-export * from './MethodNames';
-export * from './Mixin';
-export * from './OneOf';
-export * from './OptionalProperty';
-export * from './PropertyRequirements';
+export * from './Array';
+export * from './DOM';
+export * from './JSON';
+export * from './Key';
+export * from './Methods';
+export * from './Object';
+export * from './Properties';
 export * from './Record';
-export * from './Shorthand';
-export * from './StaticImplements';
+export * from './TypeJuggling';
+export * from './_Deprecated';