@tstdl/base 0.92.131 → 0.92.134

package/object-storage/s3/s3.object-storage.js

@@ -7,18 +7,24 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var S3ObjectStorage_1;
 import { Readable } from 'node:stream';
+import { CopyDestinationOptions, CopySourceOptions } from 'minio';
 import { Singleton } from '../../injector/decorators.js';
+import { registerAfterResolve } from '../../injector/resolution.js';
 import { ObjectStorage } from '../../object-storage/index.js';
+import { toArray } from '../../utils/array/array.js';
 import { mapAsync } from '../../utils/async-iterable-helpers/map.js';
 import { toArrayAsync } from '../../utils/async-iterable-helpers/to-array.js';
 import { now } from '../../utils/date-time.js';
+import { mapObjectKeys } from '../../utils/object/object.js';
 import { readableStreamFromPromise } from '../../utils/stream/index.js';
 import { readBinaryStream } from '../../utils/stream/stream-reader.js';
-import { assertStringPass, isObject, isUint8Array } from '../../utils/type-guards.js';
+import { assertDefinedPass, assertInstanceOfPass, isDefined, isObject, isString, isUint8Array, isUndefined } from '../../utils/type-guards.js';
+import { secondsPerDay } from '../../utils/units.js';
 import { S3ObjectStorageProvider } from './s3.object-storage-provider.js';
 import { S3Object } from './s3.object.js';
-let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
+let S3ObjectStorage = S3ObjectStorage_1 = class S3ObjectStorage extends ObjectStorage {
     client;
     bucket;
     prefix;
@@ -27,6 +33,11 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
         this.client = client;
         this.bucket = bucket;
         this.prefix = keyPrefix;
+        registerAfterResolve(this, async (argument) => {
+            const configuration = (isString(argument) ? undefined : argument.configuration) ?? {};
+            await this.ensureBucketExists();
+            await this.configureBucket(configuration);
+        });
     }
     async ensureBucketExists(region, options) {
         const exists = await this.client.bucketExists(this.bucket);
@@ -35,6 +46,49 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
         }
         await this.client.makeBucket(this.bucket, region ?? '', { ObjectLocking: options?.objectLocking ?? false });
     }
+    async configureBucket(configuration) {
+        let currentLifecycle = null;
+        try {
+            currentLifecycle = await this.client.getBucketLifecycle(this.bucket);
+        }
+        catch (error) {
+            // ignore error if lifecycle configuration is not set
+            if (!isObject(error) || (error.code != 'NoSuchLifecycleConfiguration')) {
+                throw error;
+            }
+        }
+        const currentLifecycleRules = isDefined(currentLifecycle?.Rule) ? toArray(currentLifecycle.Rule) : undefined; // https://github.com/minio/minio-js/issues/1407
+        const tstdlRule = currentLifecycleRules?.find((rule) => rule.ID == 'TstdlExpireObjects');
+        const tstdlRuleExpiration = tstdlRule?.Expiration?.Days;
+        const targetExpirationDays = configuration.lifecycle?.expiration?.after;
+        const targetExpiration = isDefined(targetExpirationDays) ? Math.ceil(targetExpirationDays / secondsPerDay) : undefined;
+        if (tstdlRuleExpiration == targetExpiration) {
+            return;
+        }
+        const nonTstdlRules = currentLifecycleRules?.filter((rule) => rule.ID != 'TstdlExpireObjects') ?? [];
+        if (isUndefined(targetExpiration)) {
+            if (nonTstdlRules.length == 0) {
+                await this.client.removeBucketLifecycle(this.bucket);
+            }
+            else {
+                await this.client.setBucketLifecycle(this.bucket, { Rule: nonTstdlRules });
+            }
+        }
+        else {
+            await this.client.setBucketLifecycle(this.bucket, {
+                Rule: [
+                    ...nonTstdlRules,
+                    {
+                        ID: 'TstdlExpireObjects',
+                        Status: 'Enabled',
+                        Expiration: {
+                            Days: targetExpiration,
+                        },
+                    },
+                ],
+            });
+        }
+    }
     async exists(key) {
         const bucketKey = this.getBucketKey(key);
         try {
@@ -50,7 +104,7 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
     }
     async statObject(key) {
         const bucketKey = this.getBucketKey(key);
-        return this.client.statObject(this.bucket, bucketKey);
+        return await this.client.statObject(this.bucket, bucketKey);
     }
     async uploadObject(key, content, options) {
         const bucketKey = this.getBucketKey(key);
@@ -66,10 +120,27 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
             ]);
         }
     }
+    async copyObject(sourceKey, destinationKey, options) {
+        const sourceBucketKey = this.getBucketKey(sourceKey);
+        const destinationBucket = isString(destinationKey) ? this.bucket : assertInstanceOfPass(destinationKey[0], S3ObjectStorage_1, 'Destination storage is not an S3ObjectStorage').bucket;
+        const destinationBucketKey = isString(destinationKey) ? destinationKey : destinationKey[0].getBucketKey(destinationKey[1]);
+        const sourceObject = await this.getObject(sourceKey);
+        const sourceMetadata = await sourceObject.getMetadata();
+        await this.client.copyObject(new CopySourceOptions({ Bucket: this.bucket, Object: sourceBucketKey }), new CopyDestinationOptions({
+            Bucket: destinationBucket,
+            Object: destinationBucketKey,
+            MetadataDirective: 'REPLACE',
+            UserMetadata: { ...sourceMetadata, ...options?.metadata },
+        }));
+    }
+    async moveObject(sourceKey, destinationKey, options) {
+        await this.copyObject(sourceKey, destinationKey, options);
+        await this.deleteObject(sourceKey);
+    }
     async getContent(key) {
         const bucketKey = this.getBucketKey(key);
         const result = await this.client.getObject(this.bucket, bucketKey);
-        return readBinaryStream(result);
+        return await readBinaryStream(result);
     }
     getContentStream(key) {
         const bucketKey = this.getBucketKey(key);
@@ -79,7 +150,7 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
         });
     }
     async getObjects() {
-        return toArrayAsync(this.getObjectsCursor());
+        return await toArrayAsync(this.getObjectsCursor());
     }
     getObjectsCursor() {
         const stream = this.client.listObjectsV2(this.bucket, this.prefix, true);
@@ -96,12 +167,13 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
     async getDownloadUrl(key, expirationTimestamp, responseHeaders) {
         const bucketKey = this.getBucketKey(key);
         const { date, expiration } = getDateAndExpiration(expirationTimestamp);
-        return this.client.presignedGetObject(this.bucket, bucketKey, expiration, responseHeaders ?? {}, date);
+        return await this.client.presignedGetObject(this.bucket, bucketKey, expiration, responseHeaders ?? {}, date);
     }
-    async getUploadUrl(key, expirationTimestamp) {
+    async getUploadUrl(key, expirationTimestamp, options) {
         const bucketKey = this.getBucketKey(key);
         const { date, expiration } = getDateAndExpiration(expirationTimestamp);
-        return this.client.presignedUrl('PUT', this.bucket, bucketKey, expiration, {}, date);
+        const query = mapObjectKeys(options?.metadata ?? {}, (key) => `X-Amz-Meta-${key}`);
+        return await this.client.presignedUrl('PUT', this.bucket, bucketKey, expiration, query, date);
     }
     async deleteObject(key) {
         const bucketKey = this.getBucketKey(key);
@@ -122,14 +194,14 @@ let S3ObjectStorage = class S3ObjectStorage extends ObjectStorage {
         return bucketKey.slice(this.prefix.length);
     }
 };
-S3ObjectStorage = __decorate([
+S3ObjectStorage = S3ObjectStorage_1 = __decorate([
     Singleton({
         provider: {
-            useFactory: (argument, context) => context.resolve(S3ObjectStorageProvider).get(assertStringPass(argument, 'resolve argument must be a string (object storage module)')),
-            async afterResolve(value) {
-                await value.ensureBucketExists();
-            }
-        }
+            useFactory: (argument, context) => {
+                const { module } = (isString(argument) ? { module: argument } : assertDefinedPass(argument, 'argument must be a string or an object'));
+                return context.resolve(S3ObjectStorageProvider).get(module);
+            },
+        },
     }),
     __metadata("design:paramtypes", [Function, String, String, String])
 ], S3ObjectStorage);

package/object-storage/s3/s3.object.js

@@ -15,7 +15,6 @@ export class S3Object extends ObjectStorageObject {
     async getResourceUri() {
         return this.resourceUri;
     }
-    // eslint-disable-next-line @typescript-eslint/require-await
     async getContentLength() {
         if (isUndefined(this.contentLength)) {
             const stat = await this.stat();
@@ -28,7 +27,7 @@ export class S3Object extends ObjectStorageObject {
         return stat.metaData;
     }
     async getContent() {
-        return this.storage.getContent(this.key);
+        return await this.storage.getContent(this.key);
     }
     getContentStream() {
         return this.storage.getContentStream(this.key);
@@ -37,6 +36,6 @@ export class S3Object extends ObjectStorageObject {
         if (isUndefined(this.statPromise)) {
             this.statPromise = this.storage.statObject(this.key);
         }
-        return this.statPromise;
+        return await this.statPromise;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.131",
+  "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;
+};