@tstdl/base 0.91.50 → 0.91.52

package/utils/compression.js

@@ -1,11 +1,8 @@
-import { NotSupportedError } from '../errors/not-supported.error.js';
 import { dynamicImport } from '../import.js';
-import { supportsReadableStream } from '../supports.js';
-import { isAsyncIterable } from './async-iterable-helpers/is-async-iterable.js';
 import { encodeBase64, encodeBase64Url } from './base64.js';
 import { decodeText, encodeHex, encodeUtf8 } from './encoding.js';
-import { getReadableStreamFromIterable } from './stream/readable-stream-adapter.js';
-import { isFunction } from './type-guards.js';
+import { readableStreamFromPromise } from './stream/readable-stream-from-promise.js';
+import { assertDefined, isNotNullOrUndefined } from './type-guards.js';
 import { zBase32Encode } from './z-base32.js';
 export function compressString(input, algorithm, options) {
     const inputBuffer = encodeUtf8(input);
@@ -21,19 +18,19 @@ export function compress(buffer, algorithm, options) {
         toZBase32: async () => zBase32Encode(await compressedBuffer)
     };
 }
+const compressFunction = {
+    'gzip': 'gzip',
+    'brotli': 'brotliCompress',
+    'deflate': 'deflate',
+    'deflate-raw': 'deflateRaw'
+};
 async function _compress(buffer, algorithm, options) {
     const zlib = await dynamicImport('zlib');
+    const compressor = zlib[compressFunction[algorithm]];
+    assertDefined(compressor, `Unsupported algorithm ${algorithm}`);
     return new Promise((resolve, reject) => {
-        const compressor = algorithm == 'gzip' ? zlib.gzip
-            : algorithm == 'brotli' ? zlib.brotliDecompress
-                : algorithm == 'deflate' ? zlib.deflate
-                    : algorithm == 'deflate-raw' ? zlib.deflateRaw // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                        : undefined;
-        if (compressor == undefined) {
-            throw new Error(`unsupported algorithm ${algorithm}`);
-        }
         const callback = (error, result) => {
-            if (error != undefined) {
+            if (isNotNullOrUndefined(error)) {
                 reject(error);
             }
             else {
@@ -64,22 +61,22 @@ export function decompress(buffer, algorithm, options) {
     };
 }
 export function decompressStream(stream, algorithm, options) {
-    const decompressedStream = _decompressStream(stream, algorithm, options);
-    return getReadableStreamFromIterable(decompressedStream);
+    const streamPromise = _decompressStream(stream, algorithm, options);
+    return readableStreamFromPromise(streamPromise);
 }
+const decompressFunction = {
+    'gzip': 'gunzip',
+    'brotli': 'brotliDecompress',
+    'deflate': 'inflate',
+    'deflate-raw': 'inflateRaw'
+};
 async function _decompress(buffer, algorithm, options) {
     const zlib = await dynamicImport('zlib');
+    const decompressor = zlib[decompressFunction[algorithm]];
+    assertDefined(decompressor, `Unsupported algorithm ${algorithm}`);
     return new Promise((resolve, reject) => {
-        const decompressor = algorithm == 'gzip' ? zlib.gunzip
-            : algorithm == 'brotli' ? zlib.brotliDecompress
-                : algorithm == 'deflate' ? zlib.inflate
-                    : algorithm == 'deflate-raw' ? zlib.inflateRaw // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                        : undefined;
-        if (decompressor == undefined) {
-            throw new Error(`unsupported algorithm ${algorithm}`);
-        }
         const callback = (error, result) => {
-            if (error != undefined) {
+            if (isNotNullOrUndefined(error)) {
                 reject(error);
             }
             else {
@@ -94,25 +91,20 @@ async function _decompress(buffer, algorithm, options) {
         }
     });
 }
-async function* _decompressStream(stream, algorithm, options) {
+const decompressStreamFunction = {
+    'gzip': 'createGunzip',
+    'brotli': 'createBrotliDecompress',
+    'deflate': 'createInflate',
+    'deflate-raw': 'createInflateRaw'
+};
+async function _decompressStream(stream, algorithm, options) {
     const zlib = await dynamicImport('zlib');
     const nodeStream = await dynamicImport('stream');
-    const decompressor = algorithm == 'gzip' ? zlib.createGunzip(options)
-        : algorithm == 'brotli' ? zlib.createBrotliDecompress(options)
-            : algorithm == 'deflate' ? zlib.createInflate(options)
-                : algorithm == 'deflate-raw' ? zlib.createInflateRaw(options) // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-                    : undefined;
-    if (decompressor == undefined) {
-        throw new Error(`unsupported algorithm ${algorithm}`);
-    }
-    if (stream instanceof nodeStream.Stream) {
-        yield* stream.pipe(decompressor);
-    }
-    if (isAsyncIterable(stream)) {
-        yield* nodeStream.Readable.from(stream).pipe(decompressor);
-    }
-    if (supportsReadableStream && (stream instanceof ReadableStream)) {
-        yield* nodeStream.Readable.fromWeb(stream).pipe(decompressor);
+    const nodeDecompressor = zlib[decompressStreamFunction[algorithm]](options);
+    assertDefined(nodeDecompressor, `Unsupported algorithm ${algorithm}`);
+    const decompressor = nodeStream.Transform.toWeb(nodeDecompressor);
+    if (stream instanceof nodeStream.Readable) {
+        return nodeStream.Readable.toWeb(stream).pipeThrough(decompressor);
     }
-    throw new NotSupportedError(`Stream type (${stream?.constructor.name ?? (isFunction(stream) ? stream.name : 'unknown type')}) not supported.`);
+    return stream.pipeThrough(decompressor);
 }

package/utils/object/dereference.d.ts

@@ -1,12 +1,14 @@
 import { type JsonPathInput } from '../../json-path/index.js';
-export type CompiledDereferencer = (object: object) => unknown;
+export type DereferenceOptions = {
+    optional?: boolean;
+};
 /**
  * Compiles a dereferencer for a specific reference
  * @param object object to dereference
  * @param reference path to property in dot notation or {@link JsonPath}
  * @returns referenced value
  */
-export declare function compileDereferencer(reference: JsonPathInput): (object: object) => unknown;
+export declare function compileDereferencer(reference: JsonPathInput, options?: DereferenceOptions): (object: object) => unknown;
 /**
  * Dereference a reference
  *
@@ -17,7 +19,7 @@ export declare function compileDereferencer(reference: JsonPathInput): (object:
  * @param reference path to property in dot notation or {@link JsonPath}
  * @returns referenced value
  */
-export declare function dereference(object: object, reference: JsonPathInput): unknown;
+export declare function dereference(object: object, reference: JsonPathInput, options?: DereferenceOptions): unknown;
 /**
  * Cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
  *
@@ -29,4 +31,4 @@ export declare function dereference(object: object, reference: JsonPathInput): u
  * @param reference path to property in dot notation or {@link JsonPath}
  * @returns referenced value
  */
-export declare function getCachedDereference(): typeof dereference;
+export declare function getCachedDereference(options?: DereferenceOptions): typeof dereference;

package/utils/object/dereference.js

@@ -1,21 +1,33 @@
 import { JsonPath } from '../../json-path/index.js';
 import { memoizeSingle } from '../function/memoize.js';
+import { isNullOrUndefined } from '../type-guards.js';
 /**
  * Compiles a dereferencer for a specific reference
  * @param object object to dereference
  * @param reference path to property in dot notation or {@link JsonPath}
  * @returns referenced value
  */
-export function compileDereferencer(reference) {
+export function compileDereferencer(reference, options) {
     const nodes = JsonPath.from(reference).nodes;
-    function dereferencer(object) {
+    if (options?.optional == true) {
+        return function optionalDereferencer(object) {
+            let target = object;
+            for (let i = 0; i < nodes.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
+                if (isNullOrUndefined(target)) {
+                    return undefined;
+                }
+                target = target[nodes[i]];
+            }
+            return target;
+        };
+    }
+    return function dereferencer(object) {
         let target = object;
         for (let i = 0; i < nodes.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
             target = target[nodes[i]];
         }
         return target;
-    }
-    return dereferencer;
+    };
 }
 /**
  * Dereference a reference
@@ -27,8 +39,8 @@ export function compileDereferencer(reference) {
  * @param reference path to property in dot notation or {@link JsonPath}
  * @returns referenced value
  */
-export function dereference(object, reference) {
-    return compileDereferencer(reference)(object);
+export function dereference(object, reference, options) {
+    return compileDereferencer(reference, options)(object);
 }
 /**
  * Cached version of {@link dereference}. It caches the internally used dereferencer, but it does *not* cache the referenced value
@@ -41,10 +53,10 @@ export function dereference(object, reference) {
  * @param reference path to property in dot notation or {@link JsonPath}
  * @returns referenced value
  */
-export function getCachedDereference() {
+export function getCachedDereference(options) {
     const memoizedDereferencer = memoizeSingle(compileDereferencer);
     function cachedDereference(object, reference) {
-        return memoizedDereferencer(reference)(object);
+        return memoizedDereferencer(reference, options)(object);
     }
     return cachedDereference;
 }

package/utils/object/object.d.ts

@@ -1,3 +1,4 @@
+import { type JsonPathInput } from '../../json-path/json-path.js';
 import type { BaseType, FromEntries, ObjectLiteral, Optionalize, PickBy, Record, SimplifyObject } from '../../types.js';
 export declare function hasOwnProperty<T extends Record>(obj: T, key: keyof T): boolean;
 /**
@@ -23,5 +24,6 @@ export declare function filterUndefinedObjectProperties<T extends ObjectLiteral>
 export declare function copyObjectProperties<T extends ObjectLiteral, U extends T>(source: T, target: U): void;
 export declare function getGetter<T extends ObjectLiteral, U extends keyof T>(obj: T, property: keyof T, bind: boolean): () => T[U];
 export declare function deepObjectEntries(object: ObjectLiteral, keepInnerObjects?: boolean, prefix?: string): [string, any][];
+export declare function fromDeepObjectEntries(entries: readonly (readonly [JsonPathInput, any])[]): ObjectLiteral;
 export declare function omit<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Omit<T, K>>;
 export declare function pick<T extends Record, K extends keyof T>(object: T, ...keys: K[]): SimplifyObject<Pick<T, K>>;

package/utils/object/object.js

@@ -1,3 +1,4 @@
+import { JsonPath } from '../../json-path/json-path.js';
 import { filterAsync } from '../async-iterable-helpers/filter.js';
 import { mapAsync } from '../async-iterable-helpers/map.js';
 import { toArrayAsync } from '../async-iterable-helpers/to-array.js';
@@ -103,6 +104,25 @@ export function deepObjectEntries(object, keepInnerObjects = false, prefix) {
     }
     return entries;
 }
+export function fromDeepObjectEntries(entries) {
+    const obj = {};
+    for (const [path, value] of entries) {
+        const jsonPath = JsonPath.from(path);
+        let target = obj;
+        for (let i = 0; i < jsonPath.nodes.length - 1; i++) {
+            if (hasOwnProperty(target, jsonPath.nodes[i])) {
+                target = obj[jsonPath.nodes[i]];
+            }
+            else {
+                const child = {};
+                target[jsonPath.nodes[i]] = child;
+                target = child;
+            }
+        }
+        target[jsonPath.nodes.at(-1)] = value;
+    }
+    return obj;
+}
 export function omit(object, ...keys) {
     return filterObject(object, (_, key) => !keys.includes(key));
 }