@tstdl/base 0.92.151 → 0.92.152

package/api/client/client.js

@@ -4,6 +4,7 @@ import { inject } from '../../injector/inject.js';
 import { Injector } from '../../injector/injector.js';
 import { resolveArgumentType } from '../../injector/interfaces.js';
 import { Schema } from '../../schema/index.js';
+import { DataStream } from '../../sse/data-stream.js';
 import { ServerSentEvents } from '../../sse/server-sent-events.js';
 import { toArray } from '../../utils/array/array.js';
 import { copyObjectProperties, objectEntries } from '../../utils/object/object.js';
@@ -74,6 +75,12 @@ export function compileClient(definition, options = defaultOptions) {
                     }
                     return getServerSentEvents(this[httpClientSymbol].options.baseUrl, resource, endpoint, parameters);
                 }
+                if (endpoint.result == DataStream) {
+                    if (isDefined(requestBody)) {
+                        throw new Error('Body not supported for DataStream.');
+                    }
+                    return getDataStream(this[httpClientSymbol].options.baseUrl, resource, endpoint, parameters);
+                }
                 if (context.endpoint.data?.[bustCacheToken] == true) {
                     context[bustCacheToken] = true;
                 }
@@ -126,6 +133,10 @@ async function getResponseBody(response, schema) {
         : undefined;
     return Schema.parse(schema, body, { mask: true });
 }
+function getDataStream(baseUrl, resource, endpoint, parameters) {
+    const sse = getServerSentEvents(baseUrl, resource, endpoint, parameters);
+    return DataStream.parse(sse);
+}
 function getServerSentEvents(baseUrl, resource, endpoint, parameters) {
     const { parsedUrl, parametersRest } = buildUrl(resource, parameters, { arraySeparator: ',' });
     const url = new URL(parsedUrl, baseUrl);

package/api/server/gateway.js

@@ -18,6 +18,7 @@ import { HttpServerResponse } from '../../http/server/index.js';
 import { InjectArg, ResolveArg, Singleton, resolveArgumentType } from '../../injector/index.js';
 import { Logger } from '../../logger/index.js';
 import { Schema } from '../../schema/index.js';
+import { DataStreamSource } from '../../sse/data-stream-source.js';
 import { ServerSentEventsSource } from '../../sse/server-sent-events-source.js';
 import { toArray } from '../../utils/array/array.js';
 import { composeAsyncMiddleware } from '../../utils/middleware.js';
@@ -192,8 +193,9 @@ let ApiGateway = class ApiGateway {
                 : isBlob(result) ? { stream: result.stream() }
                     : isReadableStream(result) ? { stream: result }
                         : (result instanceof ServerSentEventsSource) ? { events: result }
-                            : (context.endpoint.definition.result == String) ? { text: result }
-                                : { json: result };
+                            : (result instanceof DataStreamSource) ? { events: result.eventSource }
+                                : (context.endpoint.definition.result == String) ? { text: result }
+                                    : { json: result };
         }
         await next();
     }

package/api/types.d.ts

@@ -1,6 +1,8 @@
+import type { Observable } from 'rxjs';
 import type { HttpServerRequest, HttpServerResponse } from '../http/server/index.js';
 import type { HttpMethod } from '../http/types.js';
 import type { SchemaOutput, SchemaTestable } from '../schema/index.js';
+import type { DataStream } from '../sse/index.js';
 import type { ServerSentEventsSource } from '../sse/server-sent-events-source.js';
 import type { ServerSentEvents } from '../sse/server-sent-events.js';
 import type { NonUndefinable, OneOrMany, Record, ReturnTypeOrT } from '../types/index.js';
@@ -91,8 +93,8 @@ export type ApiEndpointParametersSchema<T extends ApiDefinition, K extends ApiEn
 export type ApiEndpointBodySchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['body']>;
 export type ApiEndpointResultSchema<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = NonUndefinable<ApiEndpoint<T, K>['result']>;
 export type ApiBinaryType = typeof Uint8Array | typeof Blob | typeof ReadableStream<any>;
-export type ApiInputType<T extends SchemaTestable> = T extends ApiBinaryType ? InstanceType<ApiBinaryType> : T extends typeof ServerSentEvents ? ServerSentEventsSource : T extends SchemaTestable ? SchemaOutput<T> : never;
-export type ApiOutputType<T extends SchemaTestable> = T extends typeof ReadableStream ? ReadableStream<Uint8Array> : T extends SchemaTestable ? SchemaOutput<T> : never;
+export type ApiInputType<T extends SchemaTestable> = T extends ApiBinaryType ? InstanceType<ApiBinaryType> : T extends typeof ServerSentEvents ? ServerSentEventsSource : T extends typeof DataStream<infer U> ? AsyncIterable<U> : T extends SchemaTestable ? SchemaOutput<T> : never;
+export type ApiOutputType<T extends SchemaTestable> = T extends typeof ReadableStream ? ReadableStream<Uint8Array> : T extends typeof DataStream<infer U> ? Observable<U> : T extends SchemaTestable ? SchemaOutput<T> : never;
 export type ApiParameters<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointParametersSchema<T, K>>;
 export type ApiClientBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiInputType<ApiEndpointBodySchema<T, K>>;
 export type ApiServerBody<T extends ApiDefinition, K extends ApiEndpointKeys<T>> = ApiOutputType<ApiEndpointBodySchema<T, K>>;

package/data-structures/array-dictionary.d.ts

@@ -16,5 +16,6 @@ export declare class ArrayDictionary<K, V> extends Dictionary<K, V, ArrayDiction
     keys(): MapIterator<K>;
     values(): MapIterator<V>;
     protected _clear(): void;
+    private _setWithoutUpdate;
     private updateSize;
 }

package/data-structures/array-dictionary.js

@@ -10,7 +10,6 @@ export class ArrayDictionary extends Dictionary {
         this.valueArray = [];
         if (isDefined(items)) {
             this.addMany(items);
-            this.updateSize();
         }
     }
     has(key) {
@@ -24,14 +23,7 @@ export class ArrayDictionary extends Dictionary {
         return this.valueArray[index];
     }
     set(key, value) {
-        const index = this.keyArray.indexOf(key);
-        if (index == -1) {
-            this.keyArray.push(key);
-            this.valueArray.push(value);
-        }
-        else {
-            this.valueArray[index] = value;
-        }
+        this._setWithoutUpdate(key, value);
         this.updateSize();
     }
     delete(key) {
@@ -58,14 +50,7 @@ export class ArrayDictionary extends Dictionary {
     }
     addMany(items) {
         for (const [key, value] of items) {
-            const index = this.keyArray.indexOf(key);
-            if (index == -1) {
-                this.keyArray.push(key);
-                this.valueArray.push(value);
-            }
-            else {
-                this.valueArray[index] = value;
-            }
+            this._setWithoutUpdate(key, value);
         }
         this.updateSize();
     }
@@ -91,7 +76,17 @@ export class ArrayDictionary extends Dictionary {
         this.keyArray = [];
         this.valueArray = [];
     }
+    _setWithoutUpdate(key, value) {
+        const index = this.keyArray.indexOf(key);
+        if (index == -1) {
+            this.keyArray.push(key);
+            this.valueArray.push(value);
+        }
+        else {
+            this.valueArray[index] = value;
+        }
+    }
     updateSize() {
-        this.setSize(this.keyArray.length / 2);
+        this.setSize(this.keyArray.length);
     }
 }

package/data-structures/array-list.js

@@ -100,7 +100,7 @@ export class ArrayList extends List {
         }
     }
     _clear() {
-        this.backingArray.splice(0, this.backingArray.length);
+        this.backingArray.length = 0;
     }
     updateSize() {
         this.setSize(this.backingArray.length);

package/data-structures/cache.js

@@ -5,12 +5,16 @@ export class Cache {
         return this._capacity;
     }
     set capacity(capacity) {
-        this.removeEntries(this._capacity - capacity);
+        if (capacity < 0) {
+            throw new Error('Capacity must be positive.');
+        }
+        const itemsToRemove = Math.max(0, this.cache.size - capacity);
+        this.removeEntries(itemsToRemove);
         this._capacity = capacity;
     }
     constructor(capacity) {
-        this._capacity = capacity;
         this.cache = new Map();
+        this.capacity = capacity;
     }
     get(key) {
         if (!this.cache.has(key)) {
@@ -29,7 +33,7 @@ export class Cache {
         this.cache.set(key, value);
     }
     delete(key) {
-        this.delete(key);
+        this.cache.delete(key);
     }
     removeEntries(count) {
         if (count <= 0) {

package/data-structures/dictionary.js

@@ -6,7 +6,7 @@ export class Dictionary extends Collection {
     }
     /** Returns an adapter that has the same interface as {@link Map}. No copying of data involved. */
     asMap() {
-        return new DictionaryAdapter(this); // eslint-disable-line @typescript-eslint/no-use-before-define
+        return new DictionaryAdapter(this);
     }
 }
 export class DictionaryAdapter {

package/data-structures/distinct-collection.d.ts

@@ -6,6 +6,10 @@ export declare abstract class DistinctCollection<T, TThis extends DistinctCollec
     asSet(): Set<T>;
     abstract has(value: T): boolean;
     abstract delete(value: T): boolean;
+    /**
+     * @internal
+     * Do not use directly. For internal adapter optimization.
+     */
     protected abstract _getBackingSet(): ReadonlySet<T> | undefined;
 }
 export declare class SetAdapter<T> implements Set<T> {

package/data-structures/distinct-collection.js

@@ -14,7 +14,7 @@ export class SetAdapter {
     collection;
     [Symbol.toStringTag] = 'SetAdapter';
     get fastestBackingSet() {
-        return this.collection._backingSet ?? this.collection.toSet();
+        return this.collection._getBackingSet() ?? this.collection.toSet();
     }
     get size() {
         return this.collection.size;

package/data-structures/iterable-weak-map.d.ts

@@ -1,5 +1,5 @@
-import { Collection } from './collection.js';
-export declare class IterableWeakMap<K extends object, V> extends Collection<[K, V], MapIterator<[K, V]>, IterableWeakMap<K, V>> implements Map<K, V> {
+import { Dictionary } from './dictionary.js';
+export declare class IterableWeakMap<K extends object, V> extends Dictionary<K, V, IterableWeakMap<K, V>> implements Map<K, V> {
     private weakMap;
     private refMap;
     private finalizationRegistry;

package/data-structures/iterable-weak-map.js

@@ -1,9 +1,9 @@
+import { takeUntil } from 'rxjs';
 import { ObservableFinalizationRegistry } from '../memory/observable-finalization-registry.js';
 import { drain } from '../utils/iterable-helpers/drain.js';
 import { isDefined, isUndefined } from '../utils/type-guards.js';
-import { takeUntil } from 'rxjs';
-import { Collection } from './collection.js';
-export class IterableWeakMap extends Collection {
+import { Dictionary } from './dictionary.js';
+export class IterableWeakMap extends Dictionary {
     weakMap;
     refMap;
     finalizationRegistry;

package/data-structures/set-collection.js

@@ -10,6 +10,7 @@ export class SetCollection extends DistinctCollection {
     static withBackingSet(set) {
         const collection = new SetCollection();
         collection.backingSet = set;
+        collection.updateSize();
         return collection;
     }
     includes(item) {

package/data-structures/sorted-array-list.js

@@ -133,7 +133,7 @@ let SortedArrayList = SortedArrayList_1 = class SortedArrayList extends List {
         }
     }
     _clear() {
-        this.backingArray.splice(0, this.backingArray.length);
+        this.backingArray.length = 0;
     }
     updateSize() {
         this.setSize(this.backingArray.length);

package/data-structures/weak-ref-map.d.ts

@@ -1,5 +1,5 @@
-import { Collection } from './collection.js';
-export declare class WeakRefMap<K, V extends object> extends Collection<[K, V], MapIterator<[K, V]>, WeakRefMap<K, V>> implements Map<K, V> {
+import { Dictionary } from './dictionary.js';
+export declare class WeakRefMap<K, V extends object> extends Dictionary<K, V, WeakRefMap<K, V>> implements Map<K, V> {
     private readonly backingMapProvider;
     private backingMap;
     private finalizationRegistry;

package/data-structures/weak-ref-map.js

@@ -1,8 +1,8 @@
+import { takeUntil } from 'rxjs';
 import { ObservableFinalizationRegistry } from '../memory/observable-finalization-registry.js';
 import { isDefined, isUndefined } from '../utils/type-guards.js';
-import { takeUntil } from 'rxjs';
-import { Collection } from './collection.js';
-export class WeakRefMap extends Collection {
+import { Dictionary } from './dictionary.js';
+export class WeakRefMap extends Dictionary {
     backingMapProvider;
     backingMap;
     finalizationRegistry;

package/document-management/api/document-management.api.d.ts

@@ -1,5 +1,5 @@
 import { bustCacheToken } from '../../http/tokens.js';
-import { ServerSentEvents } from '../../sse/server-sent-events.js';
+import { DataStream } from '../../sse/index.js';
 import { Document, DocumentCategory, DocumentRequest, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentType } from '../models/index.js';
 import { DocumentCategoryView, DocumentManagementData, DocumentRequestsTemplateData } from '../service-models/index.js';
 export type DocumentManagementApiDefinition = typeof documentManagementApiDefinition;
@@ -21,7 +21,10 @@ export declare const documentManagementApiDefinition: {
             parameters: import("../../schema/index.js").ObjectSchema<{
                 collectionIds: string | string[];
             }>;
-            result: typeof ServerSentEvents;
+            result: {
+                new (): DataStream<DocumentManagementData>;
+                parse<T>(eventSource: import("../../sse/index.js").ServerSentEvents): import("rxjs").Observable<T>;
+            };
             credentials: true;
             data: {
                 [bustCacheToken]: boolean;
@@ -418,7 +421,10 @@ declare const _DocumentManagementApi: import("../../api/client/index.js").ApiCli
             parameters: import("../../schema/index.js").ObjectSchema<{
                 collectionIds: string | string[];
             }>;
-            result: typeof ServerSentEvents;
+            result: {
+                new (): DataStream<DocumentManagementData>;
+                parse<T>(eventSource: import("../../sse/index.js").ServerSentEvents): import("rxjs").Observable<T>;
+            };
             credentials: true;
             data: {
                 [bustCacheToken]: boolean;

package/document-management/api/document-management.api.js

@@ -8,9 +8,9 @@ import { compileClient } from '../../api/client/index.js';
 import { defineApi } from '../../api/index.js';
 import { defaultAccessControlAllowHeaders } from '../../api/utils.js';
 import { bustCacheToken } from '../../http/tokens.js';
-import { ReplaceClass } from '../../injector/decorators.js';
+import { ReplaceClass } from '../../injector/index.js';
 import { array, boolean, literal, number, object, optional, string } from '../../schema/index.js';
-import { ServerSentEvents } from '../../sse/server-sent-events.js';
+import { DataStream } from '../../sse/index.js';
 import { policy } from '../authorization/index.js';
 import { Document, DocumentCategory, DocumentRequest, DocumentRequestsTemplate, DocumentRequestTemplate, DocumentType } from '../models/index.js';
 import { addOrArchiveDocumentToOrFromCollectionParametersSchema, applyDocumentRequestsTemplateParametersSchema, createDocumentCategoryParametersSchema, createDocumentParametersSchema, createDocumentRequestParametersSchema, createDocumentRequestsTemplateParametersSchema, createDocumentRequestTemplateParametersSchema, createDocumentTypeParametersSchema, deleteDocumentRequestParametersSchema, deleteDocumentRequestsTemplateParametersSchema, deleteDocumentRequestTemplateParametersSchema, DocumentCategoryView, DocumentManagementData, DocumentRequestsTemplateData, loadDataParametersSchema, updateDocumentParametersSchema, updateDocumentRequestParametersSchema, updateDocumentRequestsTemplateParametersSchema, updateDocumentRequestTemplateParametersSchema } from '../service-models/index.js';
@@ -28,7 +28,7 @@ export const documentManagementApiDefinition = defineApi({
             resource: 'data/stream',
             method: 'GET',
             parameters: loadDataParametersSchema,
-            result: ServerSentEvents,
+            result: (DataStream),
             credentials: true,
             data: {
                 [bustCacheToken]: true,

package/document-management/server/api/document-management.api.d.ts

@@ -1,9 +1,9 @@
-import { type ApiController, type ApiRequestContext, type ApiServerResult } from '../../../api/index.js';
+import type { ApiController, ApiRequestContext, ApiServerResult } from '../../../api/index.js';
 import { type DocumentManagementApiDefinition } from '../../api/index.js';
 export declare class DocumentManagementApiController implements ApiController<DocumentManagementApiDefinition> {
     #private;
     loadData(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadData'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadData'>>;
-    loadDataStream(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadDataStream'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadDataStream'>>;
+    loadDataStream(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadDataStream'>): ApiServerResult<DocumentManagementApiDefinition, 'loadDataStream'>;
     loadDocumentRequestsTemplateData(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadDocumentRequestsTemplateData'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadDocumentRequestsTemplateData'>>;
     loadAvailableCategories(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadAvailableCategories'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadAvailableCategories'>>;
     loadContent(context: ApiRequestContext<DocumentManagementApiDefinition, 'loadContent'>): Promise<ApiServerResult<DocumentManagementApiDefinition, 'loadContent'>>;

package/document-management/server/api/document-management.api.js

@@ -6,9 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 var _a;
 var DocumentManagementApiController_1;
-import { create as createDiffPatch } from 'jsondiffpatch';
 import { match, P } from 'ts-pattern';
-import { createErrorResponse } from '../../../api/index.js';
 import { apiController } from '../../../api/server/index.js';
 import { CancellationSignal } from '../../../cancellation/token.js';
 import { ForbiddenError, NotImplementedError } from '../../../errors/index.js';
@@ -16,24 +14,11 @@ import { HttpServerResponse } from '../../../http/index.js';
 import { inject } from '../../../injector/index.js';
 import { Logger } from '../../../logger/logger.js';
 import { injectRepository } from '../../../orm/server/repository.js';
-import { ServerSentEventsSource } from '../../../sse/server-sent-events-source.js';
 import { toArray } from '../../../utils/array/index.js';
-import { tryIgnoreAsync } from '../../../utils/try-ignore.js';
-import { isDefined, isUndefined } from '../../../utils/type-guards.js';
 import { documentManagementApiDefinition } from '../../api/index.js';
 import { DocumentManagementAuthorizationService } from '../../authorization/index.js';
 import { DocumentRequestCollectionAssignment } from '../../models/document-request-collection-assignment.model.js';
 import { DocumentCategoryTypeService, DocumentFileService, DocumentManagementService, DocumentRequestService, DocumentService, DocumentWorkflowService } from '../services/index.js';
-const jsonDiffPatch = createDiffPatch({
-    omitRemovedValues: true,
-    arrays: {
-        detectMove: true,
-        includeValueOnMove: false,
-    },
-    objectHash(item, index) {
-        return item['id'] ?? String(index);
-    },
-});
 let DocumentManagementApiController = DocumentManagementApiController_1 = class DocumentManagementApiController {
     #documentManagementService = inject(DocumentManagementService);
     #authorizationService = inject(DocumentManagementAuthorizationService);
@@ -56,7 +41,7 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
         }
         return await this.#documentManagementService.loadData(tenantId, toArray(context.parameters.collectionIds));
     }
-    async loadDataStream(context) {
+    async *loadDataStream(context) {
         const token = await context.getToken();
         const tenantId = await this.#authorizationService.getTenantId(token);
         for (const collectionId of context.parameters.collectionIds) {
@@ -65,37 +50,7 @@ let DocumentManagementApiController = DocumentManagementApiController_1 = class
                 throw new ForbiddenError(`You are not allowed to read collection ${collectionId}`);
             }
         }
-        const stream = this.#documentManagementService.loadDataStream(tenantId, toArray(context.parameters.collectionIds), this.#cancellationSignal);
-        const eventSource = new ServerSentEventsSource();
-        void (async () => {
-            let lastData;
-            try {
-                for await (const data of stream) {
-                    if (eventSource.closed()) {
-                        break;
-                    }
-                    if (isUndefined(lastData)) {
-                        await eventSource.sendJson({ name: 'data', data });
-                    }
-                    else {
-                        const delta = jsonDiffPatch.diff(lastData, data);
-                        if (isDefined(delta)) {
-                            await eventSource.sendJson({ name: 'delta', data: delta });
-                        }
-                    }
-                    lastData = data;
-                }
-            }
-            catch (error) {
-                this.#logger.error(error);
-                await tryIgnoreAsync(async () => await eventSource.sendJson({ name: 'error', data: createErrorResponse(error).error }));
-                await tryIgnoreAsync(async () => await eventSource.close());
-            }
-            finally {
-                await tryIgnoreAsync(async () => await eventSource.close());
-            }
-        })();
-        return eventSource;
+        yield* this.#documentManagementService.loadDataStream(tenantId, toArray(context.parameters.collectionIds), this.#cancellationSignal);
     }
     async loadDocumentRequestsTemplateData(context) {
         const token = await context.getToken();

package/document-management/server/services/document-management.service.d.ts

@@ -94,7 +94,7 @@ export declare class DocumentManagementService extends Transactional {
      * @param documentId The ID of the document to retrieve collection IDs for.
      */
     getRelevantDocumentCollectionIds(tenantId: string, documentId: string): Promise<string[]>;
-    loadDataStream(tenantId: string, collectionIds: string[], cancellationSignal: CancellationSignal): AsyncIterableIterator<DocumentManagementData>;
+    loadDataStream(tenantId: string, collectionIds: string[], cancellationSignal: CancellationSignal): AsyncGenerator<DocumentManagementData>;
     loadData(tenantId: string, collectionIds: string[]): Promise<DocumentManagementData>;
     loadDocumentRequestsTemplateData(tenantId: string | null): Promise<DocumentRequestsTemplateData>;
     initializeCategoriesAndTypes<CategoryKey extends string, TypeKey extends string, DocumentPropertyKey extends string>(tenantId: string | null, data: CategoriesAndTypesInitializationData<CategoryKey, TypeKey, DocumentPropertyKey>): Promise<{

package/dom/observation/resize-observer.d.ts

@@ -1,4 +1,4 @@
-import { type Signal } from '../../signals/api.js';
 import { type Observable } from 'rxjs';
+import { type Signal } from '../../signals/api.js';
 export declare function observeResize$(element: Element, options?: ResizeObserverOptions): Observable<ResizeObserverEntry>;
 export declare function observeResize(elements: Element, options?: ResizeObserverOptions): Signal<ResizeObserverEntry | undefined>;

package/dom/observation/resize-observer.js

@@ -1,8 +1,8 @@
+import { Subject, filter, fromEventPattern, map, shareReplay } from 'rxjs';
 import { IterableWeakMap } from '../../data-structures/iterable-weak-map.js';
 import { toSignal } from '../../signals/api.js';
 import { FactoryMap } from '../../utils/factory-map.js';
 import { isDefined } from '../../utils/type-guards.js';
-import { Subject, filter, fromEventPattern, map, shareReplay } from 'rxjs';
 let observer;
 let subject;
 const elementObservablesMap = new FactoryMap(() => ({}), new IterableWeakMap());

package/orm/decorators.d.ts

@@ -121,7 +121,7 @@ export declare function createColumnDecorator(data?: OrmColumnReflectionData): P
  * @param data - The ORM reflection data to add.
  * @returns A class or property decorator.
  */
-export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): PropertyDecorator & ClassDecorator;
+export declare function createTableAndColumnDecorator(data?: OrmColumnReflectionData): ClassDecorator & PropertyDecorator;
 /**
  * Decorator to specify ORM column options.
  * @param options - Column configuration options.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.92.151",
+  "version": "0.92.152",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -11,6 +11,7 @@
     "build:watch": "concurrently --raw --kill-others npm:tsc:watch npm:tsc-alias:watch",
     "build:production": "rm -rf dist && npm run build && npm run build:production:copy-files",
     "build:production:copy-files": "cp package.json eslint.config.js tsconfig.server.json dist/ && cp tsconfig.base.json dist/tsconfig.json && npm run copy:orm",
+    "build:dts": "tsc -p tsconfig.dts.json",
     "build:docs": "typedoc",
     "build:docs:watch": "typedoc --watch",
     "lint": "eslint --cache source/",
@@ -167,7 +168,7 @@
     "preact": "^10.27",
     "preact-render-to-string": "^6.5",
     "sharp": "^0.34",
-    "undici": "^7.13",
+    "undici": "^7.14",
     "urlpattern-polyfill": "^10.1"
   },
   "peerDependenciesMeta": {
@@ -183,7 +184,7 @@
     "@types/minio": "7.1",
     "@types/mjml": "4.7",
     "@types/node": "24",
-    "@types/nodemailer": "6.4",
+    "@types/nodemailer": "7.0",
     "@types/pg": "8.15",
     "concurrently": "9.2",
     "drizzle-kit": "0.31",

package/sse/data-stream-source.d.ts

@@ -0,0 +1,18 @@
+import type { AnyIterable } from '../utils/any-iterable-iterator.js';
+import { ServerSentEventsSource } from './server-sent-events-source.js';
+export type DataStreamSourceOptions = {
+    /**
+     * Whether to send deltas (the changes) between the last and current data or always the full data.
+     */
+    delta?: boolean;
+};
+export declare class DataStreamSource<T> {
+    #private;
+    readonly eventSource: ServerSentEventsSource;
+    readonly closed: import("../signals/api.js").Signal<boolean>;
+    constructor(options?: DataStreamSourceOptions);
+    static fromIterable<T>(iterable: AnyIterable<T>, options?: DataStreamSourceOptions): DataStreamSource<T>;
+    send(data: T): Promise<void>;
+    close(): Promise<void>;
+    error(error: unknown): Promise<void>;
+}

package/sse/data-stream-source.js

@@ -0,0 +1,66 @@
+import { create as createDiffPatch } from 'jsondiffpatch';
+import { createErrorResponse } from '../api/index.js';
+import { tryIgnoreAsync } from '../utils/try-ignore.js';
+import { isDefined } from '../utils/type-guards.js';
+import { ServerSentEventsSource } from './server-sent-events-source.js';
+const jsonDiffPatch = createDiffPatch({
+    omitRemovedValues: true,
+    arrays: {
+        detectMove: true,
+        includeValueOnMove: false,
+    },
+    objectHash(item, index) {
+        return item['id'] ?? String(index);
+    },
+});
+export class DataStreamSource {
+    #options;
+    eventSource = new ServerSentEventsSource();
+    closed = this.eventSource.closed;
+    #lastData;
+    constructor(options = { delta: true }) {
+        this.#options = options;
+    }
+    static fromIterable(iterable, options) {
+        const source = new DataStreamSource(options);
+        void (async () => {
+            try {
+                for await (const data of iterable) {
+                    if (source.closed()) {
+                        break;
+                    }
+                    await source.send(data);
+                }
+            }
+            catch (error) {
+                await tryIgnoreAsync(async () => await source.error(error));
+            }
+            finally {
+                await tryIgnoreAsync(async () => await source.close());
+            }
+        })();
+        return source;
+    }
+    async send(data) {
+        if (this.eventSource.closed()) {
+            throw new Error('Cannot send data to a closed DataStreamSource connection.');
+        }
+        if (this.#options.delta && isDefined(this.#lastData)) {
+            const delta = jsonDiffPatch.diff(this.#lastData, data);
+            await this.eventSource.sendJson({ name: 'delta', data: delta });
+        }
+        else {
+            await this.eventSource.sendJson({ name: 'data', data });
+        }
+        if (this.#options.delta) {
+            this.#lastData = data;
+        }
+    }
+    async close() {
+        await this.eventSource.close();
+    }
+    async error(error) {
+        await tryIgnoreAsync(async () => await this.eventSource.sendJson({ name: 'error', data: createErrorResponse(error).error }));
+        await tryIgnoreAsync(async () => await this.eventSource.close());
+    }
+}

package/sse/data-stream.d.ts

@@ -0,0 +1,8 @@
+import { type Observable } from 'rxjs';
+import type { ServerSentEvents } from './server-sent-events.js';
+declare const dataStreamType: unique symbol;
+export declare class DataStream<T> {
+    readonly [dataStreamType]?: T;
+    static parse<T>(eventSource: ServerSentEvents): Observable<T>;
+}
+export {};

package/sse/data-stream.js

@@ -0,0 +1,15 @@
+import { patch } from 'jsondiffpatch';
+import { hasOwnProperty } from '../utils/object/object.js';
+import { finalize, map, merge, scan } from 'rxjs';
+export class DataStream {
+    static parse(eventSource) {
+        const data$ = eventSource.message$('data').pipe(map((message) => ({ data: JSON.parse(message.data) })));
+        const delta$ = eventSource.message$('delta').pipe(map((message) => ({ delta: JSON.parse(message.data) })));
+        return merge(data$, delta$).pipe(scan((data, message) => {
+            if (hasOwnProperty(message, 'data')) {
+                return message.data;
+            }
+            return patch(structuredClone(data), message.delta);
+        }, undefined), finalize(() => eventSource.close()));
+    }
+}

package/sse/index.d.ts

@@ -1,3 +1,5 @@
+export * from './data-stream-source.js';
+export * from './data-stream.js';
 export * from './model.js';
 export * from './server-sent-events-source.js';
 export * from './server-sent-events.js';

package/sse/index.js

@@ -1,3 +1,5 @@
+export * from './data-stream-source.js';
+export * from './data-stream.js';
 export * from './model.js';
 export * from './server-sent-events-source.js';
 export * from './server-sent-events.js';

package/utils/math.js

@@ -1,4 +1,3 @@
-import { NotSupportedError } from '../errors/not-supported.error.js';
 import { defaultRandomNumberGeneratorFn } from '../random/number-generator/random-number-generator-function.js';
 import { isNull } from './type-guards.js';
 /**
@@ -44,7 +43,7 @@ export function average(values) {
  */
 export function minimum(values) {
     if (values.length == 0) {
-        throw new NotSupportedError('No values provided.');
+        throw new Error('No values provided.');
     }
     return values.reduce((previous, current) => Math.min(previous, current), Number.POSITIVE_INFINITY);
 }
@@ -55,7 +54,7 @@ export function minimum(values) {
  */
 export function maximum(values) {
     if (values.length == 0) {
-        throw new NotSupportedError('No values provided.');
+        throw new Error('No values provided.');
     }
     return values.reduce((previous, current) => Math.max(previous, current), Number.NEGATIVE_INFINITY);
 }