@tstdl/base 0.84.4 → 0.84.6

package/signals/pipe.d.ts

@@ -0,0 +1,7 @@
+import type { OperatorFunction } from 'rxjs';
+import type { Signal } from './api.js';
+export declare function pipe<I, A>(signal: Signal<I>, op1: OperatorFunction<I, A>): Signal<A>;
+export declare function pipe<I, A, B>(signal: Signal<I>, op1: OperatorFunction<I, A>, op2: OperatorFunction<A, B>): Signal<B>;
+export declare function pipe<I, A, B, C>(signal: Signal<I>, op1: OperatorFunction<I, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>): Signal<C>;
+export declare function pipe<I, A, B, C, D>(signal: Signal<I>, op1: OperatorFunction<I, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>): Signal<D>;
+export declare function pipe<I, A, B, C, D, E>(signal: Signal<I>, op1: OperatorFunction<I, A>, op2: OperatorFunction<A, B>, op3: OperatorFunction<B, C>, op4: OperatorFunction<C, D>, op5: OperatorFunction<D, E>): Signal<E>;

package/signals/pipe.js

@@ -0,0 +1,30 @@
+"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 pipe_exports = {};
+__export(pipe_exports, {
+  pipe: () => pipe
+});
+module.exports = __toCommonJS(pipe_exports);
+var import_to_observable = require("./to-observable.js");
+var import_to_signal = require("./to-signal.js");
+function pipe(signal, ...operators) {
+  const observable = (0, import_to_observable.toObservable)(signal, { emitImmediately: true });
+  const piped = observable.pipe(...operators);
+  return (0, import_to_signal.toSignal)(piped, { requireSync: true });
+}

package/signals/to-observable.d.ts

@@ -0,0 +1,16 @@
+import { Observable } from 'rxjs';
+import type { Signal } from './api.js';
+export type ToObservableOptions = {
+    /**
+     * Immediately run inner effect after creation without scheduling - for advanced use cases.
+     */
+    emitImmediately: boolean;
+};
+/**
+ * Exposes the value of an Angular `Signal` as an RxJS `Observable`.
+ *
+ * The signal's value will be propagated into the `Observable`'s subscribers using an `effect`.
+ *
+ * `toObservable` must be called in an injection context.
+ */
+export declare function toObservable<T>(source: Signal<T>, options?: ToObservableOptions): Observable<T>;

package/signals/to-observable.js

@@ -0,0 +1,38 @@
+"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_observable_exports = {};
+__export(to_observable_exports, {
+  toObservable: () => toObservable
+});
+module.exports = __toCommonJS(to_observable_exports);
+var import_rxjs = require("rxjs");
+var import_api = require("./api.js");
+function toObservable(source, options) {
+  return new import_rxjs.Observable((subscriber) => {
+    const effectRef = (0, import_api.effect)(() => {
+      try {
+        const value = source();
+        (0, import_api.untracked)(() => subscriber.next(value));
+      } catch (error) {
+        (0, import_api.untracked)(() => subscriber.error(error));
+      }
+    }, { allowSignalWrites: true, runImmediately: options?.emitImmediately });
+    return () => effectRef.destroy();
+  });
+}

package/signals/to-signal.d.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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 type { Observable } from 'rxjs';
+import type { Signal } from './api.js';
+export type ToSignalOptions<T> = {
+    /**
+     * Initial value for the signal produced by `toSignal`.
+     *
+     * This will be the value of the signal until the observable emits its first value.
+     */
+    initialValue?: T;
+    /**
+     * Whether to require that the observable emits synchronously when `toSignal` subscribes.
+     *
+     * If this is `true`, `toSignal` will assert that the observable produces a value immediately upon
+     * subscription. Setting this option removes the need to either deal with `undefined` in the
+     * signal type or provide an `initialValue`, at the cost of a runtime error if this requirement is
+     * not met.
+     */
+    requireSync?: boolean;
+};
+/**
+ * Get the current value of an `Observable` as a reactive `Signal`.
+ *
+ * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
+ * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
+ * have the most recent value emitted by the subscription, and will throw an error if the
+ * `Observable` errors.
+ *
+ * Before the `Observable` emits its first value, the `Signal` will return `undefined`. To avoid
+ * this, either an `initialValue` can be passed or the `requireSync` option enabled.
+ */
+export declare function toSignal<T>(source: Observable<T>): Signal<T | undefined>;
+/**
+ * Get the current value of an `Observable` as a reactive `Signal`.
+ *
+ * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
+ * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
+ * have the most recent value emitted by the subscription, and will throw an error if the
+ * `Observable` errors.
+ *
+ * Before the `Observable` emits its first value, the `Signal` will return the configured
+ * `initialValue`, or `undefined` if no `initialValue` is provided. If the `Observable` is
+ * guaranteed to emit synchronously, then the `requireSync` option can be passed instead.
+ */
+export declare function toSignal<T>(source: Observable<T>, options?: ToSignalOptions<undefined> & {
+    requireSync?: false;
+}): Signal<T | undefined>;
+/**
+ * Get the current value of an `Observable` as a reactive `Signal`.
+ *
+ * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
+ * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
+ * have the most recent value emitted by the subscription, and will throw an error if the
+ * `Observable` errors.
+ *
+ * Before the `Observable` emits its first value, the `Signal` will return the configured
+ * `initialValue`. If the `Observable` is guaranteed to emit synchronously, then the `requireSync`
+ * option can be passed instead.
+ */
+export declare function toSignal<T, U extends T | null | undefined>(source: Observable<T>, options: ToSignalOptions<U> & {
+    initialValue: U;
+    requireSync?: false;
+}): Signal<T | U>;
+/**
+ * Get the current value of an `Observable` as a reactive `Signal`.
+ *
+ * `toSignal` returns a `Signal` which provides synchronous reactive access to values produced
+ * by the given `Observable`, by subscribing to that `Observable`. The returned `Signal` will always
+ * have the most recent value emitted by the subscription, and will throw an error if the
+ * `Observable` errors.
+ *
+ * With `requireSync` set to `true`, `toSignal` will assert that the `Observable` produces a value
+ * immediately upon subscription. No `initialValue` is needed in this case, and the returned signal
+ * does not include an `undefined` type.
+ */
+export declare function toSignal<T>(source: Observable<T>, options: ToSignalOptions<undefined> & {
+    requireSync: true;
+}): Signal<T>;

package/signals/to-signal.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_exports = {};
+__export(to_signal_exports, {
+  toSignal: () => toSignal
+});
+module.exports = __toCommonJS(to_signal_exports);
+var import_core = require("../core.js");
+var import_not_supported_error = require("../error/not-supported.error.js");
+var import_finalization = require("../memory/finalization.js");
+var import_api = require("./api.js");
+/**
+ * @license
+ * Copyright Google LLC All Rights Reserved.
+ *
+ * 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
+ */
+var StateKind;
+(function(StateKind2) {
+  StateKind2[StateKind2["NoValue"] = 0] = "NoValue";
+  StateKind2[StateKind2["Value"] = 1] = "Value";
+  StateKind2[StateKind2["Error"] = 2] = "Error";
+})(StateKind || (StateKind = {}));
+function toSignal(source, options = {}) {
+  const { initialValue, requireSync = false } = options;
+  const initialState = requireSync ? { kind: StateKind.NoValue } : { kind: StateKind.Value, value: initialValue };
+  const state = (0, import_api.signal)(initialState);
+  const subscription = source.subscribe({
+    next: (value) => state.set({ kind: StateKind.Value, value }),
+    error: (error) => state.set({ kind: StateKind.Error, error })
+  });
+  if ((0, import_core.isDevMode)() && requireSync && (0, import_api.untracked)(state).kind === StateKind.NoValue) {
+    throw new Error("`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.");
+  }
+  const result = (0, import_api.computed)(() => {
+    const current = state();
+    switch (current.kind) {
+      case StateKind.Value:
+        return current.value;
+      case StateKind.Error:
+        throw current.error;
+      case StateKind.NoValue:
+        throw new Error("`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.");
+      default:
+        throw new import_not_supported_error.NotSupportedError(`StateKind ${current.kind} not supported.`);
+    }
+  });
+  (0, import_finalization.registerFinalization)(result, () => subscription.unsubscribe());
+  return result;
+}