@tstdl/base 0.85.2 → 0.85.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.85.2",
+  "version": "0.85.4",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -33,11 +33,11 @@
     "@types/mjml": "4.7",
     "@types/node": "20",
     "@types/nodemailer": "6.4",
-    "@typescript-eslint/eslint-plugin": "5.60",
-    "@typescript-eslint/parser": "5.60",
+    "@typescript-eslint/eslint-plugin": "5.61",
+    "@typescript-eslint/parser": "5.61",
     "concurrently": "8.2",
     "esbuild": "0.18",
-    "eslint": "8.43",
+    "eslint": "8.44",
     "eslint-import-resolver-typescript": "3.5",
     "eslint-plugin-import": "2.27",
     "tsc-alias": "1.8",

package/signals/api.d.ts

@@ -1,5 +1,5 @@
 import type * as Types from './implementation/index.js';
-export type { CreateComputedOptions, CreateEffectOptions, CreateSignalOptions, EffectRef, Signal, WritableSignal } from './implementation/index.js';
+export type { CreateComputedOptions, CreateEffectOptions, CreateSignalOptions, EffectCleanupRegisterFn, EffectRef, Signal, WritableSignal } from './implementation/index.js';
 export type SignalsConfiguration = {
     signal: typeof Types.signal;
     computed: typeof Types.computed;

package/signals/effect-with-dependencies.d.ts

@@ -0,0 +1,2 @@
+import type { CreateEffectOptions, EffectCleanupRegisterFn, EffectRef, Signal } from './api.js';
+export declare function effectWithDependencies(effectFn: (onCleanup: EffectCleanupRegisterFn) => void, dependencies: Signal<any>[], options?: CreateEffectOptions): EffectRef;

package/signals/effect-with-dependencies.js

@@ -0,0 +1,33 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var effect_with_dependencies_exports = {};
+__export(effect_with_dependencies_exports, {
+  effectWithDependencies: () => effectWithDependencies
+});
+module.exports = __toCommonJS(effect_with_dependencies_exports);
+var import_api = require("./api.js");
+function effectWithDependencies(effectFn, dependencies, options) {
+  function effectFnWithDependencies(onCleanup) {
+    for (let i = 0; i < dependencies.length; i++) {
+      dependencies[i]();
+    }
+    effectFn(onCleanup);
+  }
+  return (0, import_api.effect)(dependencies.length == 0 ? effectFn : effectFnWithDependencies, options);
+}

package/signals/index.d.ts

@@ -1,3 +1,4 @@
 export * from './api.js';
 export * from './computed-with-dependencies.js';
+export * from './effect-with-dependencies.js';
 export * from './pipe.js';

package/signals/index.js

@@ -17,4 +17,5 @@ var signals_exports = {};
 module.exports = __toCommonJS(signals_exports);
 __reExport(signals_exports, require("./api.js"), module.exports);
 __reExport(signals_exports, require("./computed-with-dependencies.js"), module.exports);
+__reExport(signals_exports, require("./effect-with-dependencies.js"), module.exports);
 __reExport(signals_exports, require("./pipe.js"), module.exports);

package/signals/pipe.d.ts

@@ -1,24 +1,30 @@
 import { type OperatorFunction } from 'rxjs';
 import type { Signal } from './api.js';
-export type SignalPipeOptions = {
-    /**
-     * As we need an synchronous value for the resulting signal and effect scheduling is async, use the signals value as the initial value for the pipe.
-     * This would normally result in double emission inside the pipe, but is mitigated by using {@link SignalPipeOptions.distinctUntilChanged}
-     * @default true
-     */
-    startWithSignalValue?: boolean;
-    /**
-     * Whether to distinctUntilChanged source values. This must be disabled if signal mutation is used.
-     * @default startWithSignalValue
-     */
-    distinctUntilChanged?: boolean;
-};
-export declare function pipe<T, A>(signal: Signal<T>, op1: OperatorFunction<T, A>, options?: SignalPipeOptions): Signal<A>;
-export declare function pipe<T, A, B>(signal: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, options?: SignalPipeOptions): Signal<B>;
-export declare function pipe<T, A, B, C>(signal: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, options?: SignalPipeOptions): Signal<C>;
-export declare function pipe<T, A, B, C, D>(signal: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, options?: SignalPipeOptions): Signal<D>;
-export declare function pipe<T, A, B, C, D, E>(signal: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, options?: SignalPipeOptions): Signal<E>;
-export declare function pipe<T, A, B, C, D, E, F>(signal: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, options?: SignalPipeOptions): Signal<F>;
-export declare function pipe<T, A, B, C, D, E, F, G>(signal: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, options?: SignalPipeOptions): Signal<G>;
-export declare function pipe<T, A, B, C, D, E, F, G, H>(signal: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, options?: SignalPipeOptions): Signal<H>;
-export declare function pipe<T, A, B, C, D, E, F, G, H, I>(signal: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>, options?: SignalPipeOptions): Signal<I>;
+/**
+ * As we need an synchronous value for the resulting signal and effect scheduling is async, it uses the source signals value as the initial value for the pipe.
+ * This would normally result in double emission inside the pipe, but is mitigated by using {@link SignalPipeOptions.distinctUntilChanged}. Because of this, mutating source signals are not supported.
+ * If you have an mutating signal or require more control for whatever reason, use {@link rawPipe} instead.
+ */
+export declare function pipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
+export declare function pipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;
+export declare function pipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
+export declare function pipe<T, A, B, C, D>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Signal<D>;
+export declare function pipe<T, A, B, C, D, E>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Signal<E>;
+export declare function pipe<T, A, B, C, D, E, F>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Signal<F>;
+export declare function pipe<T, A, B, C, D, E, F, G>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Signal<G>;
+export declare function pipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Signal<H>;
+export declare function pipe<T, A, B, C, D, E, F, G, H, I>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Signal<I>;
+export declare function pipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;
+/**
+ * As we need an synchronous value for the resulting signal and effect scheduling is async, you have to provide an immediate value on subscription, for example via the {@link startWith} operator, otherwise an error is thrown.
+ */
+export declare function rawPipe<T, A>(source: Signal<T>, op1: OperatorFunction<T, A>): Signal<A>;
+export declare function rawPipe<T, A, B>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>): Signal<B>;
+export declare function rawPipe<T, A, B, C>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
+export declare function rawPipe<T, A, B, C, D>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Signal<D>;
+export declare function rawPipe<T, A, B, C, D, E>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Signal<E>;
+export declare function rawPipe<T, A, B, C, D, E, F>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>): Signal<F>;
+export declare function rawPipe<T, A, B, C, D, E, F, G>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>): Signal<G>;
+export declare function rawPipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>): Signal<H>;
+export declare function rawPipe<T, A, B, C, D, E, F, G, H, I>(source: Signal<T>, op1: OperatorFunction<T, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>, op6: OperatorFunction<E, F>, op7: OperatorFunction<F, G>, op8: OperatorFunction<G, H>, op9: OperatorFunction<H, I>): Signal<I>;
+export declare function rawPipe(source: Signal<unknown>, ...operators: OperatorFunction<unknown, unknown>[]): Signal<unknown>;

package/signals/pipe.js

@@ -18,25 +18,16 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var pipe_exports = {};
 __export(pipe_exports, {
-  pipe: () => pipe
+  pipe: () => pipe,
+  rawPipe: () => rawPipe
 });
 module.exports = __toCommonJS(pipe_exports);
 var import_rxjs = require("rxjs");
-var import_type_guards = require("../utils/type-guards.js");
 var import_api = require("./api.js");
-function pipe(signal, ...operators) {
-  const last = operators.at(-1);
-  const lastIsOperator = (0, import_type_guards.isFunction)(last);
-  const ops = lastIsOperator ? operators : operators.slice(0, -1);
-  const { startWithSignalValue = true, distinctUntilChanged: distinct } = (lastIsOperator ? void 0 : last) ?? {};
-  const optionOperators = [];
-  if (startWithSignalValue) {
-    optionOperators.push((0, import_rxjs.startWith)(signal()));
-  }
-  if (distinct ?? startWithSignalValue) {
-    optionOperators.push((0, import_rxjs.distinctUntilChanged)());
-  }
-  const observable = (0, import_api.toObservable)(signal);
-  const piped = observable.pipe(...optionOperators, ...ops);
+function pipe(source, ...operators) {
+  return rawPipe(source, (0, import_rxjs.startWith)(source()), (0, import_rxjs.distinctUntilChanged)(), ...operators);
+}
+function rawPipe(source, ...operators) {
+  const piped = (0, import_api.toObservable)(source).pipe(...operators);
   return (0, import_api.toSignal)(piped, { requireSync: true });
 }