@tstdl/base 0.91.26 → 0.91.28

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.26",
+  "version": "0.91.28",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

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/value-or-provider.d.ts

@@ -4,5 +4,13 @@ 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;
+/**
+ * @deprecated use {@link resolveValueOrAsyncProvider}
+ */
 export declare function resolveAsyncValueOrProvider<T>(valueOrProvider: ValueOrAsyncProvider<T>): Promise<T>;
+export declare function resolveValueOrAsyncProvider<T>(valueOrProvider: ValueOrAsyncProvider<T>): Promise<T>;
+/**
+ * @deprecated use {@link cacheValueOrAsyncProvider}
+ */
 export declare function cacheAsyncValueOrProvider<T>(provider: ValueOrAsyncProvider<T>): () => (T | Promise<T>);
+export declare function cacheValueOrAsyncProvider<T>(provider: ValueOrAsyncProvider<T>): () => (T | Promise<T>);

package/utils/value-or-provider.js

@@ -5,15 +5,27 @@ export function resolveValueOrProvider(valueOrProvider) {
     }
     return valueOrProvider;
 }
+/**
+ * @deprecated use {@link resolveValueOrAsyncProvider}
+ */
 export async function resolveAsyncValueOrProvider(valueOrProvider) {
+    return resolveValueOrAsyncProvider(valueOrProvider);
+}
+export async function resolveValueOrAsyncProvider(valueOrProvider) {
     if (isFunction(valueOrProvider)) {
         return valueOrProvider();
     }
     return valueOrProvider;
 }
+/**
+ * @deprecated use {@link cacheValueOrAsyncProvider}
+ */
 export function cacheAsyncValueOrProvider(provider) {
+    return cacheValueOrAsyncProvider(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;