@tstdl/base 0.90.6 → 0.90.8

package/errors/errors.localization.js

@@ -68,7 +68,7 @@ export const germanTstdlErrorsLocalization = {
     },
     enums: [
         enumerationLocalization(HttpErrorReason, {
-            [HttpErrorReason.Unknown]: 'Unbekannt',
+            [HttpErrorReason.Unknown]: 'Unerwarteter Fehler',
             [HttpErrorReason.Cancelled]: 'Anfrage abgebrochen',
             [HttpErrorReason.Network]: 'Netzwerkfehler',
             [HttpErrorReason.InvalidRequest]: 'Ungültige Anfrage',
@@ -145,7 +145,7 @@ export const englishTstdlErrorsLocalization = {
     },
     enums: [
         enumerationLocalization(HttpErrorReason, {
-            [HttpErrorReason.Unknown]: 'Unknown',
+            [HttpErrorReason.Unknown]: 'Unexpected error',
             [HttpErrorReason.Cancelled]: 'Request cancelled',
             [HttpErrorReason.Network]: 'Network error',
             [HttpErrorReason.InvalidRequest]: 'Invalid request',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.6",
+  "version": "0.90.8",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -146,7 +146,7 @@
     "mjml": "^4.14",
     "mongodb": "^6.1",
     "nodemailer": "^6.9",
-    "playwright": "^1.38",
+    "playwright": "^1.39",
     "preact": "^10.18",
     "preact-render-to-string": "^6.2",
     "undici": "^5.26",

package/utils/object/property-name.d.ts

@@ -11,13 +11,13 @@ export type PropertyNameProxyChild<T> = (T extends Record ? (PropertyNameProxy<T
     [cast]: <U extends T>() => PropertyNameProxyChild<U>;
 };
 export type PropertyNameOfExpressionObject<T> = {
-    [P in keyof DeepNonNullable<T>]: PropertyNameOfExpressionObject<DeepNonNullable<T>[P]> & {
-        [cast]: <U extends DeepNonNullable<T>[P]>() => PropertyNameOfExpressionObject<U>;
+    [P in keyof T]: PropertyNameOfExpressionObject<DeepNonNullable<T>[P]> & {
+        [cast]: <U extends T[P]>() => PropertyNameOfExpressionObject<DeepNonNullable<U>>;
     };
 };
 export type FlatPropertyNameOfExpressionObject<T> = {
-    [P in keyof DeepFlatten<DeepNonNullable<T>>]: FlatPropertyNameOfExpressionObject<DeepFlatten<DeepNonNullable<T>>[P]> & {
-        [cast]: <U extends DeepFlatten<DeepNonNullable<T>>[P]>() => FlatPropertyNameOfExpressionObject<U>;
+    [P in keyof DeepFlatten<T>]: FlatPropertyNameOfExpressionObject<DeepFlatten<DeepNonNullable<T>>[P]> & {
+        [cast]: <U extends DeepFlatten<T>[P]>() => FlatPropertyNameOfExpressionObject<DeepNonNullable<U>>;
     };
 };
 export declare function getPropertyName(name: string): PropertyName;

package/utils/stream/index.d.ts

@@ -4,3 +4,4 @@ export * from './readable-stream-from-promise.js';
 export * from './size-limited-stream.js';
 export * from './stream-helper-types.js';
 export * from './stream-reader.js';
+export * from './to-bytes-stream.js';

package/utils/stream/index.js

@@ -4,3 +4,4 @@ export * from './readable-stream-from-promise.js';
 export * from './size-limited-stream.js';
 export * from './stream-helper-types.js';
 export * from './stream-reader.js';
+export * from './to-bytes-stream.js';

package/utils/stream/to-bytes-stream.d.ts

@@ -0,0 +1,4 @@
+export type ToBytesStreamOptions = {
+    ignoreCancel?: boolean;
+};
+export declare function toBytesStream(stream: ReadableStream<ArrayBufferView>, options?: ToBytesStreamOptions): ReadableStream<Uint8Array>;

package/utils/stream/to-bytes-stream.js

@@ -0,0 +1,78 @@
+import { isNotNull, isNull } from '../type-guards.js';
+export function toBytesStream(stream, options) {
+    try { // try to use byob mode from source
+        let byobReader;
+        return new ReadableStream({
+            type: 'bytes',
+            autoAllocateChunkSize: 10240,
+            start() {
+                byobReader = stream.getReader({ mode: 'byob' });
+            },
+            async pull(controller) {
+                const readResult = await byobReader.read(controller.byobRequest.view);
+                if (readResult.done) {
+                    controller.close();
+                    controller.byobRequest.respond(0);
+                    return;
+                }
+                controller.byobRequest.respond(readResult.value.byteLength);
+            },
+            async cancel(reason) {
+                if (options?.ignoreCancel == true) {
+                    byobReader.releaseLock();
+                }
+                else {
+                    await byobReader.cancel(reason);
+                }
+            }
+        });
+    }
+    catch { /* ignore */ }
+    let reader;
+    let buffer = null;
+    return new ReadableStream({
+        type: 'bytes',
+        start() {
+            reader = stream.getReader();
+        },
+        async pull(controller) {
+            const isByobRequest = isNotNull(controller.byobRequest);
+            const bufferIsEmpty = isNull(buffer) || (buffer.byteLength == 0);
+            if (!isByobRequest && !bufferIsEmpty) {
+                // we stil have data left in buffer from previous pull which was byob
+                controller.enqueue(buffer);
+                buffer = null;
+                return;
+            }
+            if (bufferIsEmpty) {
+                const readResult = await reader.read();
+                if (readResult.done) {
+                    controller.close();
+                    controller.byobRequest?.respond(0);
+                    return;
+                }
+                buffer = readResult.value; // eslint-disable-line require-atomic-updates
+            }
+            if (!isByobRequest) {
+                controller.enqueue(buffer);
+                buffer = null;
+                return;
+            }
+            const targetView = controller.byobRequest.view;
+            const targetArray = new Uint8Array(targetView.buffer, targetView.byteOffset, targetView.byteLength);
+            const setLength = Math.min(buffer.byteLength, targetArray.byteLength);
+            const sourceArray = new Uint8Array(buffer.buffer, buffer.byteOffset, setLength);
+            targetArray.set(sourceArray);
+            buffer = new Uint8Array(buffer.buffer, buffer.byteOffset + setLength);
+            controller.byobRequest.respond(setLength);
+        },
+        async cancel(reason) {
+            if (options?.ignoreCancel == true) {
+                reader.releaseLock();
+            }
+            else {
+                await reader.cancel(reason);
+            }
+        }
+    });
+}