@tstdl/base 0.92.132 → 0.92.134

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.132",
+  "version": "0.92.134",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/search-index/elastic/module.js

@@ -8,7 +8,7 @@ import { Client } from '@elastic/elasticsearch';
 import { ElasticSearchIndexConfig } from './config.js';
 export const elasticsearchModuleConfig = {
     defaultOptions: { node: 'http://localhost:9200' },
-    logPrefix: 'ELASTIC'
+    logPrefix: 'ELASTIC',
 };
 export const ELASTIC_SEARCH_INDEX_CONFIG = injectionToken('ElasticSearchIndexConfig');
 export function configureElasticsearch(config = {}) {
@@ -20,19 +20,19 @@ Injector.registerSingleton(Client, {
         assertDefined(argument, 'missing elasticsearch client options');
         context.data.logger = inject(Logger, elasticsearchModuleConfig.logPrefix);
         const client = new Client(argument);
-        context.addDisposeHandler(async () => client.close().then(() => context.data.logger.info('closed connection')));
+        context.addDisposeHandler(async () => await client.close().then(() => context.data.logger.info('closed connection')));
         return client;
     },
     async afterResolve(client, options, { cancellationSignal, data: { logger } }) {
         const url = getUrl(options.node ?? options.nodes);
-        await connect(`elasticsearch (${url})`, async () => client.ping().then((alive) => assert(alive, 'failed to connect')), logger, cancellationSignal);
+        await connect(`elasticsearch (${url})`, async () => await client.ping().then((alive) => assert(alive, 'failed to connect')), logger, cancellationSignal);
     },
     defaultArgumentProvider() {
         return elasticsearchModuleConfig.defaultOptions;
-    }
+    },
 });
 Injector.registerSingleton(ELASTIC_SEARCH_INDEX_CONFIG, {
-    useFactory: (argument, context) => context.resolve(ElasticSearchIndexConfig, argument)
+    useFactory: (argument, context) => context.resolve(ElasticSearchIndexConfig, argument),
 });
 function getUrl(node) {
     if (isString(node)) {

package/utils/cryptography.js

@@ -14,11 +14,11 @@ export function encrypt(algorithm, key, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
     const encryptedBuffer = globalThis.crypto.subtle.encrypt(algorithm, key, bytes);
     return {
-        toBuffer: async () => encryptedBuffer,
+        toBuffer: async () => await encryptedBuffer,
         toHex: async () => encodeHex(await encryptedBuffer),
         toBase64: async () => encodeBase64(await encryptedBuffer),
         toBase64Url: async () => encodeBase64Url(await encryptedBuffer),
-        toZBase32: async () => zBase32Encode(await encryptedBuffer)
+        toZBase32: async () => zBase32Encode(await encryptedBuffer),
     };
 }
 /**
@@ -30,12 +30,12 @@ export function encrypt(algorithm, key, data) {
 export function decrypt(algorithm, key, bytes) {
     const decryptedBuffer = globalThis.crypto.subtle.decrypt(algorithm, key, bytes);
     return {
-        toBuffer: async () => decryptedBuffer,
+        toBuffer: async () => await decryptedBuffer,
         toHex: async () => encodeHex(await decryptedBuffer),
         toBase64: async () => encodeBase64(await decryptedBuffer),
         toBase64Url: async () => encodeBase64Url(await decryptedBuffer),
         toZBase32: async () => zBase32Encode(await decryptedBuffer),
-        toUtf8: async () => decodeText(await decryptedBuffer)
+        toUtf8: async () => decodeText(await decryptedBuffer),
     };
 }
 /**
@@ -47,11 +47,11 @@ export function digest(algorithm, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
     const arrayBufferPromise = globalThis.crypto.subtle.digest(algorithm, bytes);
     const result = {
-        toBuffer: async () => arrayBufferPromise,
+        toBuffer: async () => await arrayBufferPromise,
         toHex: async () => encodeHex(await arrayBufferPromise),
         toBase64: async () => encodeBase64(await arrayBufferPromise),
         toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
-        toZBase32: async () => zBase32Encode(await arrayBufferPromise)
+        toZBase32: async () => zBase32Encode(await arrayBufferPromise),
     };
     return result;
 }
@@ -65,11 +65,11 @@ export function sign(algorithm, key, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
     const arrayBufferPromise = globalThis.crypto.subtle.sign(algorithm, key, bytes);
     const result = {
-        toBuffer: async () => arrayBufferPromise,
+        toBuffer: async () => await arrayBufferPromise,
         toHex: async () => encodeHex(await arrayBufferPromise),
         toBase64: async () => encodeBase64(await arrayBufferPromise),
         toBase64Url: async () => encodeBase64Url(await arrayBufferPromise),
-        toZBase32: async () => zBase32Encode(await arrayBufferPromise)
+        toZBase32: async () => zBase32Encode(await arrayBufferPromise),
     };
     return result;
 }
@@ -83,7 +83,7 @@ export function sign(algorithm, key, data) {
 export async function verify(algorithm, key, signature, data) {
     const signatureBytes = isString(signature) ? encodeUtf8(signature) : signature;
     const dataBytes = isString(data) ? encodeUtf8(data) : data;
-    return globalThis.crypto.subtle.verify(algorithm, key, signatureBytes, dataBytes);
+    return await globalThis.crypto.subtle.verify(algorithm, key, signatureBytes, dataBytes);
 }
 /**
  * Imports a HMAC CryptoKey
@@ -94,9 +94,9 @@ export async function verify(algorithm, key, signature, data) {
 export async function importHmacKey(algorithm, key, extractable = false) {
     const binaryKey = isString(key) ? encodeUtf8(key) : key;
     if (isBinaryKey(binaryKey)) {
-        return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
+        return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
     }
-    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
+    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
 }
 /**
  * Imports a CryptoKey for symmetric encryption
@@ -108,9 +108,9 @@ export async function importHmacKey(algorithm, key, extractable = false) {
 export async function importSymmetricKey(algorithm, length, key, extractable = false) {
     const binaryKey = isString(key) ? encodeUtf8(key) : key;
     if (isBinaryKey(binaryKey)) {
-        return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
+        return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
     }
-    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
+    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
 }
 /**
  * Imports an ECDSA CryptoKey
@@ -121,9 +121,9 @@ export async function importSymmetricKey(algorithm, length, key, extractable = f
 export async function importEcdsaKey(curve, key, extractable = false) {
     const binaryKey = isString(key) ? encodeUtf8(key) : key;
     if (isBinaryKey(binaryKey)) {
-        return globalThis.crypto.subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
+        return await globalThis.crypto.subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
     }
-    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
+    return await globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
 }
 /**
  * Import a pbkdf2 CryptoKey
@@ -132,7 +132,7 @@ export async function importEcdsaKey(curve, key, extractable = false) {
  */
 export async function importPbkdf2Key(key, extractable = false) {
     const binaryKey = isString(key) ? encodeUtf8(key) : key;
-    return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'PBKDF2' }, extractable, ['deriveKey', 'deriveBits']);
+    return await globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'PBKDF2' }, extractable, ['deriveKey', 'deriveBits']);
 }
 /**
  * Generates a new ECDSA CryptoKeyPair
@@ -141,7 +141,7 @@ export async function importPbkdf2Key(key, extractable = false) {
  * @param usages whether to generate a key for signing, verifiying or both. Defaults to both
  */
 export async function generateEcdsaKey(curve, extractable = false, usages = ['sign', 'verify']) {
-    return globalThis.crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
+    return await globalThis.crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
 }
 /**
  * Generates a pbkdf2 CryptoKey
@@ -149,7 +149,7 @@ export async function generateEcdsaKey(curve, extractable = false, usages = ['si
  */
 export async function generatePbkdf2Key(extractable = false) {
     const key = getRandomBytes(16);
-    return importPbkdf2Key(key, extractable);
+    return await importPbkdf2Key(key, extractable);
 }
 /**
  * Derive byte array from key

package/utils/object/object.d.ts

@@ -13,9 +13,10 @@ export declare function objectKeys<T extends ObjectLiteral>(object: T): (keyof T
 export declare function objectValues<T extends ObjectLiteral>(object: T): (T[keyof T])[];
 export declare function fromEntries<A>(entries: A): FromEntries<A>;
 export declare function fromEntries<K extends PropertyKey, T>(entries: Iterable<readonly [K, T]>): Record<K, T>;
-export declare function mapObject<T extends ObjectLiteral, K extends string | number | symbol, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => [key: K, value: V]): Record<K, V>;
-export declare function mapObjectAsync<T extends ObjectLiteral, K extends string | number | symbol, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<[key: K, value: V]>): Promise<Record<K, V>>;
+export declare function mapObject<T extends ObjectLiteral, K extends PropertyKey, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => [key: K, value: V]): Record<K, V>;
+export declare function mapObjectAsync<T extends ObjectLiteral, K extends PropertyKey, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<[key: K, value: V]>): Promise<Record<K, V>>;
 export declare function mapObjectValues<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => V): Record<keyof T, V>;
+export declare function mapObjectKeys<T extends ObjectLiteral, K extends PropertyKey>(object: T, mapper: (key: keyof T, value: T[keyof T]) => K): Record<K, T[keyof T]>;
 export declare function mapObjectValuesAsync<T extends ObjectLiteral, V>(object: T, mapper: (value: T[keyof T], key: keyof T) => Promise<V>): Promise<Record<keyof T, V>>;
 export declare function filterObject<T extends ObjectLiteral, U extends T[keyof T]>(object: T, predicate: (value: T[keyof T], key: keyof T) => value is U): PickBy<T, U>;
 export declare function filterObject<T extends ObjectLiteral>(object: T, predicate: (value: T[keyof T], key: keyof T) => boolean): Partial<T>;

package/utils/object/object.js

@@ -31,14 +31,17 @@ export function mapObject(object, mapper) {
 }
 export async function mapObjectAsync(object, mapper) {
     const entries = objectKeys(object);
-    const mappedEntries = await toArrayAsync(mapAsync(entries, async (key) => mapper(object[key], key)));
+    const mappedEntries = await toArrayAsync(mapAsync(entries, async (key) => await mapper(object[key], key)));
     return Object.fromEntries(mappedEntries);
 }
 export function mapObjectValues(object, mapper) {
     return mapObject(object, (value, key) => [key, mapper(value, key)]);
 }
+export function mapObjectKeys(object, mapper) {
+    return mapObject(object, (value, key) => [mapper(key, value), value]);
+}
 export async function mapObjectValuesAsync(object, mapper) {
-    return mapObjectAsync(object, async (value, key) => [key, await mapper(value, key)]);
+    return await mapObjectAsync(object, async (value, key) => [key, await mapper(value, key)]);
 }
 export function filterObject(object, predicate) {
     const mappedEntries = objectEntries(object).filter(([key, value]) => predicate(value, key));

package/utils/stream/size-limited-stream.js

@@ -8,6 +8,6 @@ export function sizeLimitTransform(maxBytes, writableStrategy, readableStrategy)
                 throw MaxBytesExceededError.fromBytes(maxBytes);
             }
             controller.enqueue(chunk);
-        }
+        },
     }, writableStrategy, readableStrategy);
 }

package/utils/type-guards.d.ts

@@ -1,4 +1,4 @@
-import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, TypedArray } from '../types.js';
+import type { AbstractConstructor, BinaryData, JsonPrimitive, PascalCase, Primitive, Type, TypedArray } from '../types.js';
 export type AssertionMessage = string | (() => string);
 export type IsFunction<T> = <U extends T = T>(value: any) => value is U;
 export type IsNotFunction<T> = <V>(value: V) => value is Exclude<V, T>;
@@ -257,3 +257,9 @@ export declare const assertReadableStream: <T = any>(value: any, message?: Asser
 export declare const assertNotReadableStream: AssertNotFunction<ReadableStream>;
 export declare const assertReadableStreamPass: <T = any>(value: any, message?: AssertionMessage) => ReadableStream<T>;
 export declare const assertNotReadableStreamPass: AssertNotPassFunction<ReadableStream>;
+export declare const isInstanceOf: <T>(value: any, type: Type<T>) => value is T;
+export declare const isNotInstanceOf: <V, T>(value: V, type: Type<T>) => value is Exclude<V, T>;
+export declare const assertInstanceOf: <T>(value: any, type: Type<T>, message?: AssertionMessage) => asserts value is T;
+export declare const assertNotInstanceOf: <V, T>(value: V, type: Type<T>, message?: AssertionMessage) => asserts value is Exclude<V, T>;
+export declare const assertInstanceOfPass: <T>(value: any, type: Type<T>, message?: AssertionMessage) => T;
+export declare const assertNotInstanceOfPass: <V, T>(value: V, type: Type<T>, message?: AssertionMessage) => Exclude<V, T>;

package/utils/type-guards.js

@@ -36,7 +36,7 @@ export function createGuards(name, testFn) {
         [`assertNot${normalizedName}Pass`](value, message = defaultNotMessage) {
             assertNot(testFn(value), message);
             return value;
-        }
+        },
     };
 }
 export function createInstanceGuards(name, type) {
@@ -335,3 +335,15 @@ export const assertReadableStream = readableStreamGuards.assertReadableStream;
 export const assertNotReadableStream = readableStreamGuards.assertNotReadableStream;
 export const assertReadableStreamPass = readableStreamGuards.assertReadableStreamPass;
 export const assertNotReadableStreamPass = readableStreamGuards.assertNotReadableStreamPass;
+export const isInstanceOf = (value, type) => value instanceof type;
+export const isNotInstanceOf = (value, type) => !isInstanceOf(value, type);
+export const assertInstanceOf = (value, type, message) => assert(isInstanceOf(value, type), message);
+export const assertNotInstanceOf = (value, type, message) => assertNot(isInstanceOf(value, type), message);
+export const assertInstanceOfPass = (value, type, message) => {
+    assert(isInstanceOf(value, type), message);
+    return value;
+};
+export const assertNotInstanceOfPass = (value, type, message) => {
+    assertNot(isInstanceOf(value, type), message);
+    return value;
+};