@tstdl/base 0.90.9 → 0.90.11

package/http/client/http-client.d.ts

@@ -2,6 +2,7 @@ import { resolveArgumentType } from '../../injector/index.js';
 import type { Resolvable } from '../../injector/interfaces.js';
 import type { OneOrMany, UndefinableJson } from '../../types.js';
 import type { HttpMethod, HttpValue } from '../types.js';
+import type { ReadBodyOptions } from '../utils.js';
 import { HttpClientOptions } from './http-client-options.js';
 import type { HttpClientRequestOptions } from './http-client-request.js';
 import { HttpClientRequest } from './http-client-request.js';
@@ -27,7 +28,7 @@ export declare class HttpClient implements Resolvable<HttpClientArgument> {
     getBuffer(url: string, options?: HttpClientRequestOptions): Promise<Uint8Array>;
     getStream(url: string, options?: HttpClientRequestOptions): ReadableStream<string> | ReadableStream<Uint8Array>;
     getTextStream(url: string, options?: HttpClientRequestOptions): ReadableStream<string>;
-    getBinaryStream(url: string, options?: HttpClientRequestOptions): ReadableStream<Uint8Array>;
+    getBinaryStream(url: string, options?: HttpClientRequestOptions, readOptions?: ReadBodyOptions): ReadableStream<Uint8Array>;
     post(url: string, options?: HttpClientRequestOptions): Promise<HttpClientResponse>;
     postText(url: string, options?: HttpClientRequestOptions): Promise<string>;
     postJson<T = UndefinableJson>(url: string, options?: HttpClientRequestOptions): Promise<T>;

package/http/client/http-client.js

@@ -79,10 +79,10 @@ let HttpClient = class HttpClient {
             return response.body.readAsTextStream();
         });
     }
-    getBinaryStream(url, options) {
+    getBinaryStream(url, options, readOptions) {
         return readableStreamFromPromise(async () => {
             const response = await this.request('GET', url, { ...options });
-            return response.body.readAsBinaryStream();
+            return response.body.readAsBinaryStream(readOptions);
         });
     }
     async post(url, options) {

package/http/utils.js

@@ -16,6 +16,7 @@ export function readBodyAsBinaryStream(body, headers, options = {}) {
             ? body.stream()
             : (isUint8Array(body))
                 ? new ReadableStream({
+                    type: 'bytes',
                     start: (controller) => {
                         controller.enqueue(body);
                         controller.close();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.9",
+  "version": "0.90.11",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/utils/index.d.ts

@@ -39,6 +39,7 @@ export * from './periodic-sampler.js';
 export * from './provider-function-iterable.js';
 export * from './proxy.js';
 export * from './random.js';
+export * from './reactive-value-to-signal.js';
 export * from './reflection.js';
 export * from './repl.js';
 export * from './set.js';

package/utils/index.js

@@ -39,6 +39,7 @@ export * from './periodic-sampler.js';
 export * from './provider-function-iterable.js';
 export * from './proxy.js';
 export * from './random.js';
+export * from './reactive-value-to-signal.js';
 export * from './reflection.js';
 export * from './repl.js';
 export * from './set.js';

package/utils/reactive-value-to-signal.d.ts

@@ -0,0 +1,13 @@
+import type { Signal, ToSignalOptions } from '../signals/api.js';
+import type { ReactiveValue } from '../types.js';
+export type ReactiveValueToSignalOptions<T> = ToSignalOptions<T>;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options?: ReactiveValueToSignalOptions<undefined> & {
+    requireSync?: false;
+}): Signal<T | undefined>;
+export declare function reactiveValueToSignal<T, I>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<I> & {
+    initialValue: I;
+    requireSync?: false;
+}): Signal<T | I>;
+export declare function reactiveValueToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<undefined> & {
+    requireSync: true;
+}): Signal<T>;

package/utils/reactive-value-to-signal.js

@@ -0,0 +1,11 @@
+import { isObservable } from 'rxjs';
+import { computed, isSignal, toSignal } from '../signals/api.js';
+export function reactiveValueToSignal(source, options) {
+    if (isSignal(source)) {
+        return source;
+    }
+    if (isObservable(source)) {
+        return toSignal(source, options);
+    }
+    return computed(() => source);
+}

package/utils/stream/index.d.ts

@@ -2,6 +2,7 @@ export * from './finalize-stream.js';
 export * from './readable-stream-adapter.js';
 export * from './readable-stream-from-promise.js';
 export * from './size-limited-stream.js';
+export * from './slice.js';
 export * from './stream-helper-types.js';
 export * from './stream-reader.js';
 export * from './to-bytes-stream.js';

package/utils/stream/index.js

@@ -2,6 +2,7 @@ export * from './finalize-stream.js';
 export * from './readable-stream-adapter.js';
 export * from './readable-stream-from-promise.js';
 export * from './size-limited-stream.js';
+export * from './slice.js';
 export * from './stream-helper-types.js';
 export * from './stream-reader.js';
 export * from './to-bytes-stream.js';

package/utils/stream/slice.d.ts

@@ -0,0 +1,2 @@
+export declare function sliceStream(stream: ReadableStream<ArrayBufferView>, offset: number, length: number, type?: 'bytes'): ReadableStream<Uint8Array>;
+export declare function sliceStream<T>(stream: ReadableStream<T>, offset: number, length: number, type: 'chunks'): ReadableStream<T>;

package/utils/stream/slice.js

@@ -0,0 +1,75 @@
+import { assert } from '../type-guards.js';
+import { kibibyte, mebibyte } from '../units.js';
+import { toBytesStream } from './to-bytes-stream.js';
+export function sliceStream(stream, offset, length, type = 'bytes') {
+    assert(length > 0, 'Length must be positive');
+    let chunksRead = 0;
+    if (type == 'chunks') {
+        const reader = stream.getReader();
+        return new ReadableStream({
+            async pull(controller) {
+                while (chunksRead < offset) {
+                    const result = await reader.read();
+                    chunksRead++;
+                    if (result.done) {
+                        controller.close();
+                        return;
+                    }
+                }
+                if ((chunksRead - offset) == length) {
+                    await reader.cancel();
+                    controller.close();
+                    return;
+                }
+                const result = await reader.read();
+                chunksRead++;
+                if (result.done) {
+                    controller.close();
+                    return;
+                }
+                controller.enqueue(result.value);
+            },
+            async cancel(reason) {
+                await reader.cancel(reason);
+            }
+        });
+    }
+    const byobReader = toBytesStream(stream).getReader({ mode: 'byob' });
+    let bytesRead = 0;
+    let offsetBuffer = new ArrayBuffer(mebibyte);
+    return new ReadableStream({
+        type: 'bytes',
+        autoAllocateChunkSize: 100 * kibibyte,
+        async pull(controller) {
+            while (bytesRead < offset) {
+                const readResult = await byobReader.read(new Uint8Array(offsetBuffer, 0, Math.min(offsetBuffer.byteLength, offset - bytesRead)));
+                if (readResult.done) {
+                    controller.close();
+                    controller.byobRequest.respond(0);
+                    return;
+                }
+                bytesRead += readResult.value.byteLength;
+                if (bytesRead == offset) {
+                    offsetBuffer = null; // eslint-disable-line require-atomic-updates
+                }
+            }
+            if ((bytesRead - offset) == length) {
+                await byobReader.cancel();
+                controller.close();
+                controller.byobRequest.respond(0);
+                return;
+            }
+            const view = controller.byobRequest.view;
+            const readResult = await byobReader.read(new Uint8Array(view.buffer, view.byteOffset, Math.min(view.byteLength, length - (bytesRead - offset))));
+            bytesRead += readResult.value.byteLength;
+            if (readResult.done) {
+                await byobReader.cancel();
+                controller.close();
+            }
+            controller.byobRequest.respondWithNewView(readResult.value);
+        },
+        async cancel(reason) {
+            await byobReader.cancel(reason);
+        }
+    });
+}

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

@@ -1,10 +1,11 @@
 import { isNotNull, isNull } from '../type-guards.js';
+import { kibibyte } from '../units.js';
 export function toBytesStream(stream, options) {
     try { // try to use byob mode from source
         let byobReader;
         return new ReadableStream({
             type: 'bytes',
-            autoAllocateChunkSize: 10240,
+            autoAllocateChunkSize: 100 * kibibyte,
             start() {
                 byobReader = stream.getReader({ mode: 'byob' });
             },
@@ -12,8 +13,6 @@ export function toBytesStream(stream, options) {
                 const readResult = await byobReader.read(controller.byobRequest.view);
                 if (readResult.done) {
                     controller.close();
-                    controller.byobRequest.respond(0);
-                    return;
                 }
                 controller.byobRequest.respondWithNewView(readResult.value);
             },