@tstdl/base 0.90.60 → 0.90.61

package/function/log.d.ts

@@ -1,7 +1,8 @@
 import type { Logger } from '../logger/logger.js';
 export type WrapLogOptions = {
     fnName?: string;
+    logResult?: boolean;
     logger?: Logger;
     trace?: boolean;
 };
-export declare function wrapLog(fn: Function, { fnName, logger, trace }?: WrapLogOptions): Function;
+export declare function wrapLog(fn: Function, { fnName, logResult, logger, trace }?: WrapLogOptions): Function;

package/function/log.js

@@ -1,23 +1,28 @@
 /* eslint-disable @typescript-eslint/ban-types */
 import { isArray, isPrimitive, isString } from '../utils/type-guards.js';
 import { typeOf } from '../utils/type-of.js';
-export function wrapLog(fn, { fnName = fn.name, logger, trace = false } = {}) {
+export function wrapLog(fn, { fnName = fn.name, logResult = true, logger, trace = false } = {}) {
     const log = logger?.trace.bind(logger) ?? console.log.bind(console); // eslint-disable-line no-console
     const wrapped = {
         [fnName](...args) {
-            const argString = args.map((arg) => stringifyArg(arg)).join(', ');
+            const argString = args.map((arg) => stringifyValue(arg)).join(', ');
             log(`[call: ${fnName}(${argString})]`);
             if (trace) {
                 console.trace();
             }
-            return Reflect.apply(fn, this, args);
+            const result = Reflect.apply(fn, this, args);
+            if (logResult) {
+                const resultString = stringifyValue(result);
+                log(`[return: ${fnName} => ${resultString}]`);
+            }
+            return result;
         }
     };
     return wrapped[fnName];
 }
-function stringifyArg(arg, depth = 1) {
+function stringifyValue(arg, depth = 1) {
     if (isArray(arg) && (depth > 0)) {
-        const argString = arg.map((innerArg) => stringifyArg(innerArg, depth - 1)).join(', ');
+        const argString = arg.map((innerArg) => stringifyValue(innerArg, depth - 1)).join(', ');
         return `[${argString}]`;
     }
     return isPrimitive(arg) ? isString(arg) ? `"${arg}"` : String(arg) : typeOf(arg);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.90.60",
+  "version": "0.90.61",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -109,7 +109,7 @@
     "luxon": "^3.4",
     "reflect-metadata": "^0.2",
     "rxjs": "^7.8",
-    "type-fest": "4.12"
+    "type-fest": "4.14"
   },
   "devDependencies": {
     "@mxssfd/typedoc-theme": "1.1",
@@ -130,7 +130,7 @@
     "typedoc": "0.25",
     "typedoc-plugin-missing-exports": "2.2",
     "typescript": "5.4",
-    "typescript-eslint": "7.2"
+    "typescript-eslint": "7.3"
   },
   "peerDependencies": {
     "@elastic/elasticsearch": "^8.12",
@@ -148,9 +148,9 @@
     "mongodb": "^6.5",
     "nodemailer": "^6.9",
     "playwright": "^1.42",
-    "preact": "^10.19",
+    "preact": "^10.20",
     "preact-render-to-string": "^6.4",
-    "undici": "^6.9",
+    "undici": "^6.10",
     "urlpattern-polyfill": "^10.0"
   },
   "peerDependenciesMeta": {

package/signals/defer.d.ts

@@ -1,2 +1,2 @@
-import type { Signal } from './api.js';
+import { type Signal } from './api.js';
 export declare function defer<T>(signalFactory: () => Signal<T>): Signal<T>;

package/signals/implementation/effect.d.ts

@@ -21,19 +21,14 @@ export declare abstract class EffectScheduler {
      * It is an error to attempt to execute any effects synchronously during a scheduling operation.
      */
     abstract scheduleEffect(e: SchedulableEffect): void;
-}
-/**
- * Interface to an `EffectScheduler` capable of running scheduled effects synchronously.
- */
-export interface FlushableEffectRunner {
     /**
      * Run any scheduled effects.
      */
-    flush(): void;
+    abstract flush(): void;
 }
-export declare class TstdlEffectScheduler implements EffectScheduler, FlushableEffectRunner {
+export declare class TstdlEffectScheduler implements EffectScheduler {
     private readonly queue;
-    private pendingFlush;
+    private hasPendingFlush;
     scheduleEffect(effect: SchedulableEffect): void;
     flush(): void;
 }

package/signals/implementation/effect.js

@@ -15,13 +15,16 @@ export class EffectScheduler {
 }
 export class TstdlEffectScheduler {
     queue = new Set();
-    pendingFlush = false;
+    hasPendingFlush = false;
     scheduleEffect(effect) {
+        if (this.queue.has(effect)) {
+            return;
+        }
         this.queue.add(effect);
-        if (!this.pendingFlush) {
-            this.pendingFlush = true;
+        if (!this.hasPendingFlush) {
+            this.hasPendingFlush = true;
             queueMicrotask(() => {
-                this.pendingFlush = false;
+                this.hasPendingFlush = false;
                 this.flush();
             });
         }

package/signals/implementation/signal.d.ts

@@ -44,7 +44,7 @@ export interface WritableSignal<T> extends Signal<T> {
     update(updateFn: (value: T) => T): void;
     /**
      * Returns a readonly version of this signal. Readonly signals can be accessed to read their value
-     * but can't be changed using set, update or mutate methods. The readonly signals do _not_ have
+     * but can't be changed using set or update methods. The readonly signals do _not_ have
      * any built-in mechanism that would prevent deep-mutation of their value.
      */
     asReadonly(): Signal<T>;