@tstdl/base 0.88.5 → 0.88.7

package/database/mongo/mongo-base.repository.js

@@ -1,6 +1,6 @@
 import { NotFoundError } from '../../error/not-found.error.js';
 import { objectKeys } from '../../utils/object/object.js';
-import { assertDefined, isNullOrUndefined } from '../../utils/type-guards.js';
+import { assertDefined, isNull, isNullOrUndefined } from '../../utils/type-guards.js';
 import { mongoDocumentFromMaybeNewEntity, toEntity, toMongoDocument, toMongoProjection, toNewEntity, toProjectedEntity } from './model/document.js';
 import { MongoBulk } from './mongo-bulk.js';
 import { replaceOneOperation, updateOneOperation } from './operations.js';
@@ -116,18 +116,18 @@ export class MongoBaseRepository {
     }
     async tryLoadByFilterAndDelete(filter, options) {
         const result = await this.collection.findOneAndDelete(filter, options);
-        if (result.value == undefined) {
+        if (isNull(result)) {
             return undefined;
         }
-        return toEntity(result.value);
+        return toEntity(result);
     }
     async loadByFilterAndUpdate(filter, update, options) {
         const entity = await this.tryLoadByFilterAndUpdate(filter, update, options);
         return throwIfUndefinedElsePass(entity, this.collection.collectionName);
     }
     async tryLoadByFilterAndUpdate(filter, update, options) {
-        const { value: document } = await this.collection.findOneAndUpdate(filter, update, options);
-        if (document == undefined) {
+        const document = await this.collection.findOneAndUpdate(filter, update, options);
+        if (isNull(document)) {
             return undefined;
         }
         return toEntity(document);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.88.5",
+  "version": "0.88.7",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -120,7 +120,7 @@
     "./utils/string": "./utils/object/index.js"
   },
   "dependencies": {
-    "disposablestack": "^1.1.1",
+    "disposablestack": "^1.1",
     "luxon": "^3.4",
     "reflect-metadata": "^0.1",
     "rxjs": "^7.8",
@@ -159,9 +159,9 @@
     "koa": "^2.14",
     "minio": "^7.1",
     "mjml": "^4.14",
-    "mongodb": "^5.8",
+    "mongodb": "^6.1",
     "nodemailer": "^6.9",
-    "playwright": "^1.37",
+    "playwright": "^1.38",
     "preact": "^10.17",
     "preact-render-to-string": "^6.2",
     "undici": "^5.24",

package/signals/implementation/graph.d.ts

@@ -9,21 +9,8 @@ type Version = number & {
     __brand: 'Version';
 };
 export declare function setActiveConsumer(consumer: ReactiveNode | null): ReactiveNode | null;
-export declare const REACTIVE_NODE: {
-    version: Version;
-    dirty: boolean;
-    producerNode: undefined;
-    producerLastReadVersion: undefined;
-    producerIndexOfThis: undefined;
-    nextProducerIndex: number;
-    liveConsumerNode: undefined;
-    liveConsumerIndexOfThis: undefined;
-    consumerAllowSignalWrites: boolean;
-    consumerIsAlwaysLive: boolean;
-    producerMustRecompute: () => boolean;
-    producerRecomputeValue: () => void;
-    consumerMarkedDirty: () => void;
-};
+export declare function isInNotificationPhase(): boolean;
+export declare const REACTIVE_NODE: ReactiveNode;
 /**
  * A producer and/or consumer which participates in the reactive graph.
  *

package/signals/implementation/graph.js

@@ -17,6 +17,9 @@ export function setActiveConsumer(consumer) {
     activeConsumer = consumer;
     return prev;
 }
+export function isInNotificationPhase() {
+    return inNotificationPhase;
+}
 export const REACTIVE_NODE = {
     version: 0,
     dirty: false,
@@ -153,7 +156,9 @@ export function consumerAfterComputation(node, prevConsumer) {
         }
     }
     // Truncate the producer tracking arrays.
-    for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
+    // Perf note: this is essentially truncating the length to `node.nextProducerIndex`, but
+    // benchmarking has shown that individual pop operations are faster.
+    while (node.producerNode.length > node.nextProducerIndex) {
         node.producerNode.pop();
         node.producerLastReadVersion.pop();
         node.producerIndexOfThis.pop();

package/signals/implementation/to-observable.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import type { Signal } from './api.js';
 /**
- * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
+ * Exposes the value of an `Signal` as an RxJS `Observable`.
  *
  * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
  */

package/signals/implementation/to-observable.js

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { effect } from './effect.js';
 import { untracked } from './untracked.js';
 /**
- * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
+ * Exposes the value of an `Signal` as an RxJS `Observable`.
  *
  * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
  */

package/signals/implementation/watch.d.ts

@@ -24,5 +24,11 @@ export interface Watch {
      */
     run(): void;
     cleanup(): void;
+    /**
+     * Destroy the watcher:
+     * - disconnect it from the reactive graph;
+     * - mark it as destroyed so subsequent run and notify operations are noop.
+     */
+    destroy(): void;
 }
 export declare function watch(fn: (onCleanup: WatchCleanupRegisterFn) => void, schedule: (watch: Watch) => void, allowSignalWrites: boolean): Watch;

package/signals/implementation/watch.js

@@ -5,7 +5,7 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { consumerAfterComputation, consumerBeforeComputation, consumerMarkDirty, consumerPollProducersForChange, REACTIVE_NODE } from './graph.js';
+import { consumerAfterComputation, consumerBeforeComputation, consumerDestroy, consumerMarkDirty, consumerPollProducersForChange, isInNotificationPhase, REACTIVE_NODE } from './graph.js';
 export function watch(fn, schedule, allowSignalWrites) {
     const node = Object.create(WATCH_NODE);
     if (allowSignalWrites) {
@@ -16,7 +16,27 @@ export function watch(fn, schedule, allowSignalWrites) {
     const registerOnCleanup = (cleanupFn) => {
         node.cleanupFn = cleanupFn;
     };
+    function isWatchNodeDestroyed(node) {
+        return node.fn === null && node.schedule === null;
+    }
+    function destroyWatchNode(node) {
+        if (!isWatchNodeDestroyed(node)) {
+            consumerDestroy(node); // disconnect watcher from the reactive graph
+            node.cleanupFn();
+            // nullify references to the integration functions to mark node as destroyed
+            node.fn = null;
+            node.schedule = null;
+            node.cleanupFn = NOOP_CLEANUP_FN;
+        }
+    }
     const run = () => {
+        if (node.fn === null) {
+            // trying to run a destroyed watch is noop
+            return;
+        }
+        if (isInNotificationPhase()) {
+            throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
+        }
         node.dirty = false;
         if (node.hasRun && !consumerPollProducersForChange(node)) {
             return;
@@ -36,6 +56,7 @@ export function watch(fn, schedule, allowSignalWrites) {
         notify: () => consumerMarkDirty(node),
         run,
         cleanup: () => node.cleanupFn(),
+        destroy: () => destroyWatchNode(node),
     };
     return node.ref;
 }
@@ -45,7 +66,9 @@ const WATCH_NODE = {
     consumerIsAlwaysLive: true,
     consumerAllowSignalWrites: false,
     consumerMarkedDirty: (node) => {
-        node.schedule(node.ref);
+        if (node.schedule !== null) {
+            node.schedule(node.ref);
+        }
     },
     hasRun: false,
     cleanupFn: NOOP_CLEANUP_FN,

package/signals/index.d.ts

@@ -4,6 +4,7 @@ export * from './effect-with-dependencies.js';
 export * from './lazylize.js';
 export * from './pipe.js';
 export * from './switch-map.js';
+export * from './to-observable-2.js';
 export * from './to-signal-2.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/index.js

@@ -4,6 +4,7 @@ export * from './effect-with-dependencies.js';
 export * from './lazylize.js';
 export * from './pipe.js';
 export * from './switch-map.js';
+export * from './to-observable-2.js';
 export * from './to-signal-2.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/to-observable-2.d.ts

@@ -0,0 +1,8 @@
+import type { Observable } from 'rxjs';
+import type { Signal } from './api.js';
+/**
+ * Exposes the value of an `Signal` as an RxJS `Observable`.
+ *
+ * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
+ */
+export declare function toObservable2<T>(source: Signal<T>): Observable<T>;

package/signals/to-observable-2.js

@@ -0,0 +1,9 @@
+import { toObservable } from './implementation/to-observable.js';
+/**
+ * Exposes the value of an `Signal` as an RxJS `Observable`.
+ *
+ * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
+ */
+export function toObservable2(source) {
+    return toObservable(source);
+}

package/signals/to-signal-2.d.ts

@@ -5,7 +5,10 @@ export type ToSignal2Options<T> = ToSignalOptions<T> & {
     /** defer subscription until signal is used */
     lazy?: boolean;
 };
-/** like `toSignal`, except that it uses untracked internal operations (required for some scenarios, but might be less safe in terms of bugs catching) and has the ability to subscribe lazily */
+/**
+ * Like `toSignal`, except that it uses untracked internal operations (required for some scenarios, but might be less safe in terms of bugs catching) and has the ability to subscribe lazily.
+ * Subscription to observable is cleaned up using finalization (garbage collection) of the signal.
+ */
 export declare function toSignal2<T>(source: ToSignalInput<T>): Signal<T | undefined>;
 export declare function toSignal2<T>(source: ToSignalInput<T>, options: ToSignal2Options<undefined> & {
     requireSync: true;