@tstdl/base 0.85.17 → 0.85.18

package/package.json

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

package/rxjs/index.d.ts

@@ -7,6 +7,7 @@ export * from './performance-observer.js';
 export * from './resize-observer.js';
 export * from './retry-backoff.js';
 export * from './slow-array.js';
+export * from './start-with-provider.js';
 export * from './teardown.js';
 export * from './timing.js';
 export * from './touch.js';

package/rxjs/index.js

@@ -24,6 +24,7 @@ __reExport(rxjs_exports, require("./performance-observer.js"), module.exports);
 __reExport(rxjs_exports, require("./resize-observer.js"), module.exports);
 __reExport(rxjs_exports, require("./retry-backoff.js"), module.exports);
 __reExport(rxjs_exports, require("./slow-array.js"), module.exports);
+__reExport(rxjs_exports, require("./start-with-provider.js"), module.exports);
 __reExport(rxjs_exports, require("./teardown.js"), module.exports);
 __reExport(rxjs_exports, require("./timing.js"), module.exports);
 __reExport(rxjs_exports, require("./touch.js"), module.exports);

package/rxjs/start-with-provider.d.ts

@@ -0,0 +1,2 @@
+import type { OperatorFunction } from 'rxjs';
+export declare function startWithProvider<T, D>(valueProvider: () => D): OperatorFunction<T, T | D>;

package/rxjs/start-with-provider.js

@@ -0,0 +1,29 @@
+"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 start_with_provider_exports = {};
+__export(start_with_provider_exports, {
+  startWithProvider: () => startWithProvider
+});
+module.exports = __toCommonJS(start_with_provider_exports);
+var import_rxjs = require("rxjs");
+function startWithProvider(valueProvider) {
+  return function startWithProvider2(source) {
+    return (0, import_rxjs.concat)((0, import_rxjs.defer)(() => (0, import_rxjs.of)(valueProvider())), source);
+  };
+}

package/signals/api.d.ts

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

package/signals/api.js

@@ -28,13 +28,13 @@ __export(api_exports, {
   untracked: () => untracked
 });
 module.exports = __toCommonJS(api_exports);
-let signal;
-let computed;
-let effect;
-let untracked;
-let isSignal;
-let toSignal;
-let toObservable;
+let signal = throwSignalsNotConfigured;
+let computed = throwSignalsNotConfigured;
+let effect = throwSignalsNotConfigured;
+let untracked = throwSignalsNotConfigured;
+let isSignal = throwSignalsNotConfigured;
+let toSignal = throwSignalsNotConfigured;
+let toObservable = throwSignalsNotConfigured;
 function configureSignals(configuration) {
   signal = configuration.signal;
   computed = configuration.computed;
@@ -44,3 +44,6 @@ function configureSignals(configuration) {
   toSignal = configuration.toSignal;
   toObservable = configuration.toObservable;
 }
+function throwSignalsNotConfigured() {
+  throw new Error("Signals are not configured. Use configureDefaultSignalsImplementation() for default implementation or configureSignals() for custom implementation.");
+}

package/signals/implementation/graph.js

@@ -71,7 +71,7 @@ class ReactiveNode {
   consumerPollProducersForChange() {
     for (const [producerId, edge] of this.producers) {
       const producer = edge.producerNode.deref();
-      if (producer === void 0 || edge.atTrackingVersion !== this.trackingVersion) {
+      if (producer == null || edge.atTrackingVersion !== this.trackingVersion) {
         this.producers.delete(producerId);
         producer?.consumers.delete(this.id);
         continue;
@@ -91,7 +91,7 @@ class ReactiveNode {
     try {
       for (const [consumerId, edge] of this.consumers) {
         const consumer = edge.consumerNode.deref();
-        if (consumer === void 0 || consumer.trackingVersion !== edge.atTrackingVersion) {
+        if (consumer == null || consumer.trackingVersion !== edge.atTrackingVersion) {
           this.consumers.delete(consumerId);
           consumer?.producers.delete(this.id);
           continue;

package/signals/index.d.ts

@@ -3,5 +3,6 @@ export * from './computed-with-dependencies.js';
 export * from './effect-with-dependencies.js';
 export * from './pipe.js';
 export * from './switch-map.js';
+export * from './to-signal-2.js';
 export * from './types.js';
 export * from './untracked-operator.js';

package/signals/index.js

@@ -20,5 +20,6 @@ __reExport(signals_exports, require("./computed-with-dependencies.js"), module.e
 __reExport(signals_exports, require("./effect-with-dependencies.js"), module.exports);
 __reExport(signals_exports, require("./pipe.js"), module.exports);
 __reExport(signals_exports, require("./switch-map.js"), module.exports);
+__reExport(signals_exports, require("./to-signal-2.js"), module.exports);
 __reExport(signals_exports, require("./types.js"), module.exports);
 __reExport(signals_exports, require("./untracked-operator.js"), module.exports);

package/signals/pipe.d.ts

@@ -16,7 +16,7 @@ export declare function pipe<T, A, B, C, D, E, F, G, H>(source: Signal<T>, op1:
 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.
+ * 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 `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>;

package/signals/pipe.js

@@ -23,11 +23,13 @@ __export(pipe_exports, {
 });
 module.exports = __toCommonJS(pipe_exports);
 var import_rxjs = require("rxjs");
+var import_start_with_provider = require("../rxjs/start-with-provider.js");
 var import_api = require("./api.js");
+var import_to_signal_2 = require("./to-signal-2.js");
 function pipe(source, ...operators) {
-  return rawPipe(source, (0, import_rxjs.startWith)(source()), (0, import_rxjs.distinctUntilChanged)(), ...operators);
+  return rawPipe(source, (0, import_start_with_provider.startWithProvider)(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 });
+  return (0, import_to_signal_2.toSignal2)(piped, { requireSync: true });
 }

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

@@ -0,0 +1,14 @@
+import type { Subscribable } from 'rxjs';
+import type { Signal, ToSignalOptions } from './api.js';
+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 */
+export declare function toSignal2<T>(source: Subscribable<T>): Signal<T | undefined>;
+export declare function toSignal2<T>(source: Subscribable<T>, options: ToSignal2Options<undefined> & {
+    requireSync: true;
+}): Signal<T>;
+export declare function toSignal2<T, const I = undefined>(source: Subscribable<T>, options: ToSignal2Options<I> & {
+    requireSync?: false;
+}): Signal<T | I>;

package/signals/to-signal-2.js

@@ -0,0 +1,67 @@
+"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 to_signal_2_exports = {};
+__export(to_signal_2_exports, {
+  toSignal2: () => toSignal2
+});
+module.exports = __toCommonJS(to_signal_2_exports);
+var import_core = require("../core.js");
+var import_finalization = require("../memory/finalization.js");
+var import_type_guards = require("../utils/type-guards.js");
+var import_api = require("./api.js");
+var StateKind;
+(function(StateKind2) {
+  StateKind2[StateKind2["NoValue"] = 0] = "NoValue";
+  StateKind2[StateKind2["Value"] = 1] = "Value";
+  StateKind2[StateKind2["Error"] = 2] = "Error";
+})(StateKind || (StateKind = {}));
+function toSignal2(source, options) {
+  const initialState = options?.requireSync == true ? { kind: StateKind.NoValue } : { kind: StateKind.Value, value: options?.initialValue };
+  const state = (0, import_api.signal)(initialState);
+  let subscription;
+  if (options?.lazy != true) {
+    subscription = subscribe(source, state, options);
+  }
+  const result = (0, import_api.computed)(() => {
+    if ((0, import_type_guards.isUndefined)(subscription)) {
+      subscription = subscribe(source, state, options);
+    }
+    const current = state();
+    switch (current.kind) {
+      case StateKind.Value:
+        return current.value;
+      case StateKind.Error:
+        throw current.error;
+      case StateKind.NoValue:
+        throw new Error("`toSignalLazy()` called with `requireSync` but `Observable` did not emit synchronously.");
+    }
+  });
+  (0, import_finalization.registerFinalization)(result, () => subscription?.unsubscribe());
+  return result;
+}
+function subscribe(source, state, options) {
+  const subscription = source.subscribe({
+    next: (value) => (0, import_api.untracked)(() => state.set({ kind: StateKind.Value, value })),
+    error: (error) => (0, import_api.untracked)(() => state.set({ kind: StateKind.Error, error }))
+  });
+  if ((0, import_core.isDevMode)() && options?.requireSync == true && (0, import_api.untracked)(state).kind == StateKind.NoValue) {
+    throw new Error("`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.");
+  }
+  return subscription;
+}