@battis/typescript-tricks 0.7.8 → 0.8.0

package/dist/index.js

@@ -14,17 +14,13 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./ArrayElement"), exports);
-__exportStar(require("./Coerce"), exports);
-__exportStar(require("./Constructor"), exports);
-__exportStar(require("./EnumeratedTypes"), exports);
-__exportStar(require("./Forms"), exports);
-__exportStar(require("./JSONValue"), exports);
-__exportStar(require("./MethodNames"), exports);
-__exportStar(require("./Mixin"), exports);
-__exportStar(require("./OneOf"), exports);
-__exportStar(require("./OptionalProperty"), exports);
-__exportStar(require("./PropertyRequirements"), exports);
+__exportStar(require("./Array"), exports);
+__exportStar(require("./DOM"), exports);
+__exportStar(require("./JSON"), exports);
+__exportStar(require("./Key"), exports);
+__exportStar(require("./Methods"), exports);
+__exportStar(require("./Object"), exports);
+__exportStar(require("./Properties"), exports);
 __exportStar(require("./Record"), exports);
-__exportStar(require("./Shorthand"), exports);
-__exportStar(require("./StaticImplements"), exports);
+__exportStar(require("./TypeJuggling"), exports);
+__exportStar(require("./_Deprecated"), exports);

package/jest.config.ts

@@ -24,5 +24,6 @@ export default {
         }
       }
     ]
-  }
+  },
+  collectCoverage: true
 } satisfies Config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@battis/typescript-tricks",
-  "version": "0.7.8",
+  "version": "0.8.0",
   "description": "A handful of useful types and operators",
   "homepage": "https://github.com/battis/typescript-config/tree/main/packages/typescript-tricks#readme",
   "repository": {

package/tests/Array/isEntries.test.ts

@@ -0,0 +1,25 @@
+import { isEntries } from '../../src/Array';
+import { isString } from '../../src/TypeJuggling';
+
+test('truthy', () => {
+  expect(isEntries([])).toBeTruthy();
+  expect(isEntries([[1, 2]])).toBeTruthy();
+  expect(
+    isEntries([
+      ['a', 1],
+      [2, 'b']
+    ])
+  ).toBeTruthy();
+});
+
+test('falsy', () => {
+  expect(isEntries({ a: 123 })).toBeFalsy();
+  expect(isEntries([1, 2, 3])).toBeFalsy();
+  expect(isEntries('foo')).toBeFalsy();
+  expect(isEntries(['a', ['b', 1]])).toBeFalsy();
+  expect(isEntries([['a', 1], ['b', 2], 'c'])).toBeFalsy();
+});
+
+test('typed', () => {
+  expect(isEntries<string>([], isString)).toBeTruthy();
+});

package/tests/JSON/isJSONPrimitive.test.ts

@@ -0,0 +1,16 @@
+import { isJSONPrimitive } from '../../src/JSON';
+
+test('truthy', () => {
+  expect(isJSONPrimitive('foo')).toBeTruthy();
+  expect(isJSONPrimitive(1)).toBeTruthy();
+  expect(isJSONPrimitive(3.14159)).toBeTruthy();
+  expect(isJSONPrimitive(true)).toBeTruthy();
+  expect(isJSONPrimitive(false)).toBeTruthy();
+  expect(isJSONPrimitive(null)).toBeTruthy();
+});
+
+test('falsy', () => {
+  expect(isJSONPrimitive([])).toBeFalsy();
+  expect(isJSONPrimitive({ a: 1 })).toBeFalsy();
+  expect(isJSONPrimitive(undefined)).toBeFalsy();
+});

package/tests/Key/isKey.test.ts

@@ -0,0 +1,13 @@
+import { isKey } from '../../src/Key';
+
+test('truthy', () => {
+  expect(isKey('a')).toBeTruthy();
+  expect(isKey(0)).toBeTruthy();
+  expect(isKey(Symbol('foo'))).toBeTruthy();
+});
+
+test('falsy', () => {
+  expect(isKey(true)).toBeFalsy();
+  expect(isKey({ foo: 'bar' })).toBeFalsy();
+  expect(isKey(3.14159)).toBeFalsy();
+});

package/tests/Key/isKeyof.test.ts

@@ -0,0 +1,13 @@
+import { isKeyof } from '../../src/Key';
+
+test('truthy', () => {
+  expect(isKeyof('a', { a: 1 })).toBeTruthy();
+  expect(isKeyof(1, { 1: 'foo' })).toBeTruthy();
+  const s = Symbol('foo');
+  expect(isKeyof(s, { [s]: 'bar' })).toBeTruthy();
+});
+
+test('falsy', () => {
+  expect(isKeyof('a', { b: 2 })).toBeFalsy();
+  expect(isKeyof('a', new Date())).toBeFalsy();
+});

package/tests/Record/isRecord.test.ts

@@ -1,22 +1,7 @@
-import { JSONPrimitive } from '../../src/JSONValue.js';
+import { isJSONPrimitive, JSONPrimitive } from '../../src/JSON.js';
+import { isKey, Key } from '../../src/Key.js';
 import { isRecord } from '../../src/Record.js';
-import { isJSONPrimitive } from '../JSONValue/JSONPrimitive.test.js';
-
-function isKey(obj: unknown): obj is keyof object {
-  return (
-    typeof obj === 'string' ||
-    typeof obj === 'number' ||
-    typeof obj === 'symbol'
-  );
-}
-
-function isUnknown(obj: unknown): obj is unknown {
-  return true;
-}
-
-function isString(obj: unknown): obj is string {
-  return typeof obj === 'string';
-}
+import { isString, isUnknown } from '../../src/TypeJuggling.js';
 
 test('Record<string,string>', () => {
   expect(
@@ -36,21 +21,13 @@ test('Record<string,JSONPrimitive>', () => {
 
 test('built-in objects', () => {
   expect(
-    isRecord<keyof object, unknown>(new String('foo bar'), isKey, isUnknown)
-  ).toBeFalsy();
-  expect(
-    isRecord<keyof object, unknown>(new Number(123), isKey, isUnknown)
-  ).toBeFalsy();
-  expect(
-    isRecord<keyof object, unknown>(Math.PI, isKey, isUnknown)
-  ).toBeFalsy();
-  expect(
-    isRecord<keyof object, unknown>(new Uint8Array(0), isKey, isUnknown)
-  ).toBeFalsy();
-  expect(
-    isRecord<keyof object, unknown>(new Map(), isKey, isUnknown)
+    isRecord<Key, unknown>(new String('foo bar'), isKey, isUnknown)
   ).toBeFalsy();
+  expect(isRecord<Key, unknown>(new Number(123), isKey, isUnknown)).toBeFalsy();
+  expect(isRecord<Key, unknown>(Math.PI, isKey, isUnknown)).toBeFalsy();
   expect(
-    isRecord<keyof object, unknown>(new Date(), isKey, isUnknown)
+    isRecord<Key, unknown>(new Uint8Array(0), isKey, isUnknown)
   ).toBeFalsy();
+  expect(isRecord<Key, unknown>(new Map(), isKey, isUnknown)).toBeFalsy();
+  expect(isRecord<Key, unknown>(new Date(), isKey, isUnknown)).toBeFalsy();
 });

package/tests/TypeJuggling/isString.test.ts

@@ -0,0 +1,14 @@
+import { isString } from '../../src/TypeJuggling';
+
+test('truthy', () => {
+  expect(isString('foo')).toBeTruthy();
+  expect(isString('')).toBeTruthy();
+  expect(isString(`bar`)).toBeTruthy();
+});
+
+test('falsy', () => {
+  expect(isString(1)).toBeFalsy();
+  expect(isString(undefined)).toBeFalsy();
+  expect(isString(null)).toBeFalsy();
+  expect(isString({ a: 123 })).toBeFalsy();
+});

package/tests/TypeJuggling/isUnknown.test.ts

@@ -0,0 +1,7 @@
+import { isUnknown } from '../../src/TypeJuggling';
+
+test('truthy', () => {
+  expect(isUnknown(true)).toBeTruthy();
+  expect(isUnknown(null)).toBeTruthy();
+  expect(isUnknown({ a: 123 })).toBeTruthy();
+});

package/dist/ArrayElement.d.ts

@@ -1 +0,0 @@
-export type ArrayElement<ArrayType extends readonly unknown[]> = ArrayType extends readonly (infer ElementType)[] ? ElementType : never;

package/dist/Coerce/Coerce.d.ts

@@ -1 +0,0 @@
-export declare function Coerce<T>(u: unknown, isT: (u: unknown) => u is T, toT?: (u: unknown) => T): T;

package/dist/Coerce/Coerce.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Coerce = Coerce;
-function FailedCoercion() {
-    throw new TypeError('Attempted coercion to a non-matching type');
-}
-function Coerce(u, isT, toT = (FailedCoercion)) {
-    if (isT(u)) {
-        return u;
-    }
-    return toT(u);
-}

package/dist/Coerce/Error.d.ts

@@ -1,2 +0,0 @@
-export declare function isError(error: unknown): error is Error;
-export declare function CoerceError(error: unknown): Error;

package/dist/Coerce/Error.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isError = isError;
-exports.CoerceError = CoerceError;
-const Coerce_js_1 = require("./Coerce.js");
-function isError(error) {
-    return (typeof error === 'object' &&
-        error !== null &&
-        'message' in error &&
-        'name' in error &&
-        typeof error.name === 'string' &&
-        typeof error.message === 'string');
-}
-function CoerceError(error) {
-    return (0, Coerce_js_1.Coerce)(error, isError, (e) => e);
-}

package/dist/Coerce.d.ts

@@ -1,2 +0,0 @@
-export * from './Coerce/Coerce';
-export * from './Coerce/Error';

package/dist/Coerce.js

@@ -1,18 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./Coerce/Coerce"), exports);
-__exportStar(require("./Coerce/Error"), exports);

package/dist/Constructor.d.ts

@@ -1,21 +0,0 @@
-export type Constructor<T = object> = new (...args: any[]) => T;
-export declare const isConstructor: (value: any) => value is Constructor<any>;
-/**
- * ```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 = instanceOf(list, A);
- * // filteredList = [a, c]
- * ```
- * @ see https://stackoverflow.com/a/65152869/294171
- */
-export declare function filterByType<Elements, Filter extends Elements>(array: Elements[], filterType: Constructor<Filter>): Filter[];
-/** @deprecated use {@link filterByType} */
-export declare const instanceOf: typeof filterByType;

package/dist/Constructor.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.instanceOf = exports.isConstructor = void 0;
-exports.filterByType = filterByType;
-const isConstructor = (value) => {
-    return !!value && !!value.prototype && !!value.prototype.constructor;
-};
-exports.isConstructor = isConstructor;
-/**
- * ```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 = instanceOf(list, A);
- * // filteredList = [a, c]
- * ```
- * @ see https://stackoverflow.com/a/65152869/294171
- */
-function filterByType(array, filterType) {
-    return array.filter((e) => e instanceof filterType);
-}
-/** @deprecated use {@link filterByType} */
-exports.instanceOf = filterByType;

package/dist/EnumeratedTypes.d.ts

@@ -1,11 +0,0 @@
-type EnumObject = {
-    [key: string]: number | string;
-};
-type EnumObjectEnum<E extends EnumObject> = E extends {
-    [key: string]: infer ET | string;
-} ? ET : never;
-/**
- * @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>[];
-export {};

package/dist/EnumeratedTypes.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEnumValues = getEnumValues;
-/**
- * @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]);
-}

package/dist/Mixin.d.ts

@@ -1,2 +0,0 @@
-/** @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>>;

package/dist/Mixin.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/OneOf.js

@@ -1,3 +0,0 @@
-"use strict";
-/** @see https://stackoverflow.com/questions/42123407/does-typescript-support-mutually-exclusive-types#comment123255834_53229567 */
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/OptionalProperty.d.ts

@@ -1 +0,0 @@
-export type OptionalProperty<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/dist/OptionalProperty.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/PropertyRequirements.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Shorthand.d.ts

@@ -1,11 +0,0 @@
-export type AsynchronousFunction = () => Promise<any>;
-/** @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;
-export type Subset<T, U extends T> = T;
-/** @deprecated use `Record<string,T>` */
-export type AssociativeArray<T> = {
-    [key: string]: T;
-};
-export type JSONPrimitiveTypes = string | number | boolean | null;

package/dist/Shorthand.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/StaticImplements.d.ts

@@ -1,23 +0,0 @@
-/**
-
-@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: any[]) => any, C extends I> = InstanceType<C>;

package/dist/StaticImplements.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/tests/JSONValue/JSONPrimitive.test.ts

@@ -1,25 +0,0 @@
-import { JSONPrimitive } from '../../src/JSONValue.js';
-
-export function isJSONPrimitive(obj: unknown): obj is JSONPrimitive {
-  return (
-    obj === null ||
-    typeof obj === 'number' ||
-    typeof obj === 'string' ||
-    typeof obj === 'string'
-  );
-}
-
-test('truthy', () => {
-  expect(isJSONPrimitive(null)).toBeTruthy();
-  expect(isJSONPrimitive(123)).toBeTruthy();
-  expect(isJSONPrimitive(3.14159)).toBeTruthy();
-  expect(isJSONPrimitive('foo bar')).toBeTruthy();
-  expect(isJSONPrimitive(`interpolate ${new Date()}`)).toBeTruthy();
-});
-
-test('falsy', () => {
-  expect(isJSONPrimitive(undefined)).toBeFalsy();
-  expect(isJSONPrimitive([1, 2, 3])).toBeFalsy();
-  expect(isJSONPrimitive({ foo: 'bar' })).toBeFalsy();
-  expect(isJSONPrimitive(new Date())).toBeFalsy();
-});