@tstdl/base 0.91.25 → 0.91.27

package/authentication/client/http-client.middleware.js

@@ -1,8 +1,8 @@
 import { firstValueFrom } from 'rxjs';
-import { cacheAsyncValueOrProvider } from '../../utils/value-or-provider.js';
+import { cacheValueOrAsyncProvider } from '../../utils/value-or-provider.js';
 import { dontWaitForValidToken } from '../authentication.api.js';
 export function waitForAuthenticationCredentialsMiddleware(authenticationServiceOrProvider) {
-    const getAuthenticationService = cacheAsyncValueOrProvider(authenticationServiceOrProvider);
+    const getAuthenticationService = cacheValueOrAsyncProvider(authenticationServiceOrProvider);
     // eslint-disable-next-line @typescript-eslint/no-shadow
     async function waitForAuthenticationCredentialsMiddleware({ request }, next) {
         const endpoint = request.context?.endpoint;

package/disposable/async-disposer.d.ts

@@ -1,6 +1,5 @@
-import type { CancellationSignal } from '../cancellation/token.js';
-import { CancellationToken } from '../cancellation/token.js';
-import type { AsyncDisposable, Disposable } from './disposable.js';
+import { type CancellationSignal, CancellationToken } from '../cancellation/token.js';
+import { type AsyncDisposable, type Disposable } from './disposable.js';
 declare const deferrerToken: unique symbol;
 export type AsyncDisposeTaskFunction = () => any;
 export type AsyncDisposeHandler = AsyncDisposeTaskFunction | Disposable | AsyncDisposable;

package/disposable/async-disposer.js

@@ -1,5 +1,5 @@
-import { isDefined, isNullOrUndefined } from '../utils/type-guards.js';
 import { CancellationToken } from '../cancellation/token.js';
+import { isDefined, isNullOrUndefined } from '../utils/type-guards.js';
 import { MultiError } from '../errors/multi.error.js';
 import { dispose, disposeAsync, isAsyncDisposable, isDisposable } from './disposable.js';
 const deferrerToken = Symbol('DeferrerToken');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.25",
+  "version": "0.91.27",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -152,10 +152,10 @@
     "mongodb": "^6.9",
     "nodemailer": "^6.9",
     "pg": "^8.13",
-    "playwright": "^1.47",
+    "playwright": "^1.48",
     "preact": "^10.24",
     "preact-render-to-string": "^6.5",
-    "undici": "^6.19",
+    "undici": "^6.20",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {

package/utils/cryptography.d.ts

@@ -5,9 +5,9 @@ export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';
 export type HashAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
 export type SymmetricAlgorithm = `AES-${AesMode}`;
 export type AsymmetricAlgorithm = 'RSASSA-PKCS1-v1_5' | 'RSA-PSS' | 'RSA-OAEP' | 'ECDSA' | 'ECDH' | 'NODE-DSA' | 'NODE-DH' | 'NODE-ED25519' | 'NODE-ED448';
-export type CryptionAlgorithm = Parameters<typeof crypto.subtle.encrypt>[0];
-export type SignAlgorithm = Parameters<typeof crypto.subtle.sign>[0];
-export type KeyAlgorithm = Parameters<typeof crypto.subtle.generateKey>[0];
+export type CryptionAlgorithm = Parameters<typeof globalThis.crypto.subtle.encrypt>[0];
+export type SignAlgorithm = Parameters<typeof globalThis.crypto.subtle.sign>[0];
+export type KeyAlgorithm = Parameters<typeof globalThis.crypto.subtle.generateKey>[0];
 export type DeriveAlgorithm = Parameters<typeof globalThis.crypto.subtle.deriveBits>['0'];
 export type KeyType = 'raw' | 'pkcs8' | 'spki' | 'jwk';
 export type Key = JsonWebKey | BinaryData;

package/utils/cryptography.js

@@ -4,7 +4,6 @@ import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
 import { getRandomBytes } from './random.js';
 import { isArray, isDefined, isString } from './type-guards.js';
 import { zBase32Encode } from './z-base32.js';
-const subtle = globalThis.crypto.subtle;
 /**
  * Encrypt data
  * @param algorithm algorithm as supported by Web Crypto API
@@ -13,7 +12,7 @@ const subtle = globalThis.crypto.subtle;
  */
 export function encrypt(algorithm, key, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
-    const encryptedBuffer = subtle.encrypt(algorithm, key, bytes);
+    const encryptedBuffer = globalThis.crypto.subtle.encrypt(algorithm, key, bytes);
     return {
         toBuffer: async () => encryptedBuffer,
         toHex: async () => encodeHex(await encryptedBuffer),
@@ -29,7 +28,7 @@ export function encrypt(algorithm, key, data) {
  * @param data data to decrypt
  */
 export function decrypt(algorithm, key, bytes) {
-    const decryptedBuffer = subtle.decrypt(algorithm, key, bytes);
+    const decryptedBuffer = globalThis.crypto.subtle.decrypt(algorithm, key, bytes);
     return {
         toBuffer: async () => decryptedBuffer,
         toHex: async () => encodeHex(await decryptedBuffer),
@@ -46,7 +45,7 @@ export function decrypt(algorithm, key, bytes) {
  */
 export function digest(algorithm, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
-    const arrayBufferPromise = subtle.digest(algorithm, bytes);
+    const arrayBufferPromise = globalThis.crypto.subtle.digest(algorithm, bytes);
     const result = {
         toBuffer: async () => arrayBufferPromise,
         toHex: async () => encodeHex(await arrayBufferPromise),
@@ -64,7 +63,7 @@ export function digest(algorithm, data) {
  */
 export function sign(algorithm, key, data) {
     const bytes = isString(data) ? encodeUtf8(data) : data;
-    const arrayBufferPromise = subtle.sign(algorithm, key, bytes);
+    const arrayBufferPromise = globalThis.crypto.subtle.sign(algorithm, key, bytes);
     const result = {
         toBuffer: async () => arrayBufferPromise,
         toHex: async () => encodeHex(await arrayBufferPromise),
@@ -84,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 subtle.verify(algorithm, key, signatureBytes, dataBytes);
+    return globalThis.crypto.subtle.verify(algorithm, key, signatureBytes, dataBytes);
 }
 /**
  * Imports a HMAC CryptoKey
@@ -95,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 subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
+        return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
     }
-    return subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
+    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'HMAC', hash: algorithm }, extractable, ['sign', 'verify']);
 }
 /**
  * Imports a CryptoKey for symmetric encryption
@@ -109,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 subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
+        return globalThis.crypto.subtle.importKey('raw', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
     }
-    return subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
+    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: algorithm, length }, extractable, ['encrypt', 'decrypt']);
 }
 /**
  * Imports an ECDSA CryptoKey
@@ -122,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 subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
+        return globalThis.crypto.subtle.importKey('spki', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
     }
-    return subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
+    return globalThis.crypto.subtle.importKey('jwk', binaryKey, { name: 'ECDSA', namedCurve: curve }, extractable, ['verify']);
 }
 /**
  * Import a pbkdf2 CryptoKey
@@ -142,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 subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
+    return globalThis.crypto.subtle.generateKey({ name: 'ECDSA', namedCurve: curve }, extractable, usages);
 }
 /**
  * Generates a pbkdf2 CryptoKey

package/utils/type-guards.d.ts

@@ -35,12 +35,12 @@ export declare const assertNull: AssertFunction<null>;
 export declare const assertNotNull: AssertNotFunction<null>;
 export declare const assertNullPass: AssertPassFunction<null>;
 export declare const assertNotNullPass: AssertNotPassFunction<null>;
-export declare const isNullOrUndefined: IsFunction<null | undefined>;
-export declare const isNotNullOrUndefined: IsNotFunction<null | undefined>;
-export declare const assertNullOrUndefined: AssertFunction<null | undefined>;
-export declare const assertNotNullOrUndefined: AssertNotFunction<null | undefined>;
-export declare const assertNullOrUndefinedPass: AssertPassFunction<null | undefined>;
-export declare const assertNotNullOrUndefinedPass: AssertNotPassFunction<null | undefined>;
+export declare const isNullOrUndefined: (value: any) => value is null | undefined;
+export declare const isNotNullOrUndefined: IsNotFunction<null | undefined | void>;
+export declare const assertNullOrUndefined: (value: any, message?: AssertionMessage) => asserts value is null | undefined;
+export declare const assertNotNullOrUndefined: AssertNotFunction<null | undefined | void>;
+export declare const assertNullOrUndefinedPass: (value: any, message?: AssertionMessage) => null | undefined;
+export declare const assertNotNullOrUndefinedPass: AssertNotPassFunction<null | undefined | void>;
 export declare const isNumber: IsFunction<number>;
 export declare const isNotNumber: IsNotFunction<number>;
 export declare const assertNumber: AssertFunction<number>;

package/utils/type-guards.js

@@ -1,4 +1,7 @@
-/* eslint-disable max-lines, @typescript-eslint/ban-types, @typescript-eslint/no-invalid-void-type, @typescript-eslint/restrict-template-expressions, max-statements-per-line, no-eq-null */
+/* eslint-disable @typescript-eslint/no-unsafe-function-type */
+/* eslint-disable @typescript-eslint/ban-types */
+/* eslint-disable @typescript-eslint/no-invalid-void-type */
+/* eslint-disable @typescript-eslint/no-unnecessary-type-parameters */
 import { supportsBlob, supportsReadableStream } from '../supports.js';
 import { AssertionError } from '../errors/assertion.error.js';
 export function assert(condition, message = 'assertion failed') {
@@ -104,14 +107,14 @@ export const assertSymbol = symbolGuards.assertSymbol;
 export const assertNotSymbol = symbolGuards.assertNotSymbol;
 export const assertSymbolPass = symbolGuards.assertSymbolPass;
 export const assertNotSymbolPass = symbolGuards.assertNotSymbolPass;
-const literalObjectGuards = createGuards('literal object', (value) => (typeof value == 'object') && (value != null) && (Reflect.getPrototypeOf(value) == Object.prototype) && (Reflect.getPrototypeOf(value).constructor == Object));
+const literalObjectGuards = createGuards('literal object', (value) => (typeof value == 'object') && (value !== null) && (Reflect.getPrototypeOf(value) == Object.prototype) && (Reflect.getPrototypeOf(value).constructor == Object));
 export const isLiteralObject = literalObjectGuards.isLiteralObject;
 export const isNotLiteralObject = literalObjectGuards.isNotLiteralObject;
 export const assertLiteralObject = literalObjectGuards.assertLiteralObject;
 export const assertNotLiteralObject = literalObjectGuards.assertNotLiteralObject;
 export const assertLiteralObjectPass = literalObjectGuards.assertLiteralObjectPass;
 export const assertNotLiteralObjectPass = literalObjectGuards.assertNotLiteralObjectPass;
-const objectGuards = createGuards('object', (value) => (typeof value == 'object') && (value != null));
+const objectGuards = createGuards('object', (value) => (typeof value == 'object') && (value !== null));
 export const isObject = objectGuards.isObject;
 export const isNotObject = objectGuards.isNotObject;
 export const assertObject = objectGuards.assertObject;
@@ -313,7 +316,7 @@ export const assertPromise = promiseGuards.assertPromise;
 export const assertNotPromise = promiseGuards.assertNotPromise;
 export const assertPromisePass = promiseGuards.assertPromisePass;
 export const assertNotPromisePass = promiseGuards.assertNotPromisePass;
-const promiseLikeGuards = createGuards('PromiseLike', (value) => isPromise(value) || ((((typeof value == 'object') && (value != null)) || isFunction(value)) && ((typeof value.then) == 'function')));
+const promiseLikeGuards = createGuards('PromiseLike', (value) => isPromise(value) || ((((typeof value == 'object') && (value !== null)) || isFunction(value)) && ((typeof value.then) == 'function')));
 export const isPromiseLike = promiseLikeGuards.isPromiseLike;
 export const isNotPromiseLike = promiseLikeGuards.isNotPromiseLike;
 export const assertPromiseLike = promiseLikeGuards.assertPromiseLike;

package/utils/value-or-provider.d.ts

@@ -4,5 +4,5 @@ export type ValueOrProvider<T> = T extends (() => any) ? never : (T | Provider<T
 export type ValueOrAsyncProvider<T> = T extends (() => any) ? never : (T | Provider<T> | AsyncProvider<T>);
 export type ResolvedValueOrProvider<T extends ValueOrAsyncProvider<any>> = T extends ValueOrAsyncProvider<infer U> ? U : never;
 export declare function resolveValueOrProvider<T>(valueOrProvider: ValueOrProvider<T>): T;
-export declare function resolveAsyncValueOrProvider<T>(valueOrProvider: ValueOrAsyncProvider<T>): Promise<T>;
-export declare function cacheAsyncValueOrProvider<T>(provider: ValueOrAsyncProvider<T>): () => (T | Promise<T>);
+export declare function resolveValueOrAsyncProvider<T>(valueOrProvider: ValueOrAsyncProvider<T>): Promise<T>;
+export declare function cacheValueOrAsyncProvider<T>(provider: ValueOrAsyncProvider<T>): () => (T | Promise<T>);

package/utils/value-or-provider.js

@@ -5,15 +5,15 @@ export function resolveValueOrProvider(valueOrProvider) {
     }
     return valueOrProvider;
 }
-export async function resolveAsyncValueOrProvider(valueOrProvider) {
+export async function resolveValueOrAsyncProvider(valueOrProvider) {
     if (isFunction(valueOrProvider)) {
         return valueOrProvider();
     }
     return valueOrProvider;
 }
-export function cacheAsyncValueOrProvider(provider) {
+export function cacheValueOrAsyncProvider(provider) {
     let getValue = async () => {
-        const valuePromise = resolveAsyncValueOrProvider(provider);
+        const valuePromise = resolveValueOrAsyncProvider(provider);
         getValue = async () => valuePromise;
         void valuePromise.then((resolvedValue) => (getValue = () => resolvedValue));
         return valuePromise;