@tstdl/base 0.87.13 → 0.88.0-alpha1

package/signals/implementation/to-signal.js

@@ -1,31 +1,3 @@
-"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_finalization = require("../../memory/finalization.js");
-var import_computed = require("./computed.js");
-var import_signal = require("./signal.js");
-var import_untracked = require("./untracked.js");
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -33,39 +5,51 @@ var import_untracked = require("./untracked.js");
  * 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 { isDevMode } from '../../core.js';
+import { registerFinalization } from '../../memory/finalization.js';
+import { computed } from './computed.js';
+import { signal } from './signal.js';
+import { untracked } from './untracked.js';
 var StateKind;
-(function(StateKind2) {
-  StateKind2[StateKind2["NoValue"] = 0] = "NoValue";
-  StateKind2[StateKind2["Value"] = 1] = "Value";
-  StateKind2[StateKind2["Error"] = 2] = "Error";
+(function (StateKind) {
+    StateKind[StateKind["NoValue"] = 0] = "NoValue";
+    StateKind[StateKind["Value"] = 1] = "Value";
+    StateKind[StateKind["Error"] = 2] = "Error";
 })(StateKind || (StateKind = {}));
-function toSignal(source, options) {
-  let state;
-  if (options?.requireSync) {
-    state = (0, import_signal.signal)({ kind: StateKind.NoValue });
-  } else {
-    state = (0, import_signal.signal)({ kind: StateKind.Value, value: options?.initialValue });
-  }
-  const sub = source.subscribe({
-    next: (value) => state.set({ kind: StateKind.Value, value }),
-    error: (error) => state.set({ kind: StateKind.Error, error })
-    // Completion of the Observable is meaningless to the signal. Signals don't have a concept of
-    // "complete".
-  });
-  if ((0, import_core.isDevMode)() && options?.requireSync && (0, import_untracked.untracked)(state).kind === StateKind.NoValue) {
-    throw new Error("`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.");
-  }
-  const result = (0, import_computed.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.");
+export function toSignal(source, options) {
+    // Note: T is the Observable value type, and U is the initial value type. They don't have to be
+    // the same - the returned signal gives values of type `T`.
+    let state;
+    if (options?.requireSync) {
+        // Initially the signal is in a `NoValue` state.
+        state = signal({ kind: StateKind.NoValue });
     }
-  });
-  (0, import_finalization.registerFinalization)(result, () => sub.unsubscribe());
-  return result;
+    else {
+        // If an initial value was passed, use it. Otherwise, use `undefined` as the initial value.
+        state = signal({ kind: StateKind.Value, value: options?.initialValue });
+    }
+    const sub = source.subscribe({
+        next: value => state.set({ kind: StateKind.Value, value }),
+        error: error => state.set({ kind: StateKind.Error, error }),
+        // Completion of the Observable is meaningless to the signal. Signals don't have a concept of
+        // "complete".
+    });
+    if (isDevMode() && options?.requireSync && untracked(state).kind === StateKind.NoValue) {
+        throw new Error('`toSignal()` called with `requireSync` but `Observable` did not emit synchronously.');
+    }
+    // The actual returned signal is a `computed` of the `State` signal, which maps the various states
+    // to either values or errors.
+    const result = 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.');
+        }
+    });
+    registerFinalization(result, () => sub.unsubscribe());
+    return result;
 }

package/signals/implementation/untracked.js

@@ -1,27 +1,3 @@
-"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 untracked_exports = {};
-__export(untracked_exports, {
-  untracked: () => untracked
-});
-module.exports = __toCommonJS(untracked_exports);
-var import_graph = require("./graph.js");
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -29,11 +5,19 @@ var import_graph = require("./graph.js");
  * 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
  */
-function untracked(nonReactiveReadsFn) {
-  const prevConsumer = (0, import_graph.setActiveConsumer)(null);
-  try {
-    return nonReactiveReadsFn();
-  } finally {
-    (0, import_graph.setActiveConsumer)(prevConsumer);
-  }
+import { setActiveConsumer } from './graph.js';
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ */
+export function untracked(nonReactiveReadsFn) {
+    const prevConsumer = setActiveConsumer(null);
+    // We are not trying to catch any particular errors here, just making sure that the consumers
+    // stack is restored in case of errors.
+    try {
+        return nonReactiveReadsFn();
+    }
+    finally {
+        setActiveConsumer(prevConsumer);
+    }
 }

package/signals/implementation/watch.js

@@ -1,27 +1,3 @@
-"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 watch_exports = {};
-__export(watch_exports, {
-  Watch: () => Watch
-});
-module.exports = __toCommonJS(watch_exports);
-var import_graph = require("./graph.js");
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -29,56 +5,65 @@ var import_graph = require("./graph.js");
  * 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
  */
-const NOOP_CLEANUP_FN = () => {
-};
-class Watch extends import_graph.ReactiveNode {
-  watch;
-  schedule;
-  consumerAllowSignalWrites;
-  dirty = false;
-  cleanupFn = NOOP_CLEANUP_FN;
-  registerOnCleanup = (cleanupFn) => {
-    this.cleanupFn = cleanupFn;
-  };
-  constructor(watch, schedule, allowSignalWrites) {
-    super();
-    this.watch = watch;
-    this.schedule = schedule;
-    this.consumerAllowSignalWrites = allowSignalWrites;
-  }
-  notify() {
-    if (!this.dirty) {
-      this.schedule(this);
+import { ReactiveNode, setActiveConsumer } from './graph.js';
+const NOOP_CLEANUP_FN = () => { };
+/**
+ * Watches a reactive expression and allows it to be scheduled to re-run
+ * when any dependencies notify of a change.
+ *
+ * `Watch` doesn't run reactive expressions itself, but relies on a consumer-
+ * provided scheduling operation to coordinate calling `Watch.run()`.
+ */
+export class Watch extends ReactiveNode {
+    watch;
+    schedule;
+    consumerAllowSignalWrites;
+    dirty = false;
+    cleanupFn = NOOP_CLEANUP_FN;
+    registerOnCleanup = (cleanupFn) => {
+        this.cleanupFn = cleanupFn;
+    };
+    constructor(watch, schedule, allowSignalWrites) {
+        super();
+        this.watch = watch;
+        this.schedule = schedule;
+        this.consumerAllowSignalWrites = allowSignalWrites;
+    }
+    notify() {
+        if (!this.dirty) {
+            this.schedule(this);
+        }
+        this.dirty = true;
+    }
+    onConsumerDependencyMayHaveChanged() {
+        this.notify();
+    }
+    onProducerUpdateValueVersion() {
+        // Watches are not producers.
     }
-    this.dirty = true;
-  }
-  onConsumerDependencyMayHaveChanged() {
-    this.notify();
-  }
-  onProducerUpdateValueVersion() {
-  }
-  /**
-   * Execute the reactive expression in the context of this `Watch` consumer.
-   *
-   * Should be called by the user scheduling algorithm when the provided
-   * `schedule` hook is called by `Watch`.
-   */
-  run() {
-    this.dirty = false;
-    if (this.trackingVersion !== 0 && !this.consumerPollProducersForChange()) {
-      return;
+    /**
+     * Execute the reactive expression in the context of this `Watch` consumer.
+     *
+     * Should be called by the user scheduling algorithm when the provided
+     * `schedule` hook is called by `Watch`.
+     */
+    run() {
+        this.dirty = false;
+        if (this.trackingVersion !== 0 && !this.consumerPollProducersForChange()) {
+            return;
+        }
+        const prevConsumer = setActiveConsumer(this);
+        this.trackingVersion++;
+        try {
+            this.cleanupFn();
+            this.cleanupFn = NOOP_CLEANUP_FN;
+            this.watch(this.registerOnCleanup);
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
     }
-    const prevConsumer = (0, import_graph.setActiveConsumer)(this);
-    this.trackingVersion++;
-    try {
-      this.cleanupFn();
-      this.cleanupFn = NOOP_CLEANUP_FN;
-      this.watch(this.registerOnCleanup);
-    } finally {
-      (0, import_graph.setActiveConsumer)(prevConsumer);
+    cleanup() {
+        this.cleanupFn();
     }
-  }
-  cleanup() {
-    this.cleanupFn();
-  }
 }

package/signals/index.js

@@ -1,26 +1,9 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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("./lazylize.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);
+export * from './api.js';
+export * from './computed-with-dependencies.js';
+export * from './effect-with-dependencies.js';
+export * from './lazylize.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/lazylize.js

@@ -1,28 +1,5 @@
-"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 lazylize_exports = {};
-__export(lazylize_exports, {
-  lazylize: () => lazylize
-});
-module.exports = __toCommonJS(lazylize_exports);
-var import_api = require("./api.js");
-function lazylize(signalProvider) {
-  let source;
-  return (0, import_api.computed)(() => (source ??= (0, import_api.untracked)(() => signalProvider()))());
+import { computed, untracked } from './api.js';
+export function lazylize(signalProvider) {
+    let source;
+    return computed(() => (source ??= untracked(() => signalProvider()))());
 }

package/signals/pipe.js

@@ -1,35 +1,11 @@
-"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,
-  rawPipe: () => rawPipe
-});
-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_start_with_provider.startWithProvider)(source), (0, import_rxjs.distinctUntilChanged)(), ...operators);
+import { distinctUntilChanged } from 'rxjs';
+import { startWithProvider } from '../rxjs/start-with-provider.js';
+import { toObservable } from './api.js';
+import { toSignal2 } from './to-signal-2.js';
+export function pipe(source, ...operators) {
+    return rawPipe(source, startWithProvider(source), distinctUntilChanged(), ...operators);
 }
-function rawPipe(source, ...operators) {
-  const piped = (0, import_api.toObservable)(source).pipe(...operators);
-  return (0, import_to_signal_2.toSignal2)(piped, { requireSync: true });
+export function rawPipe(source, ...operators) {
+    const piped = toObservable(source).pipe(...operators);
+    return toSignal2(piped, { requireSync: true });
 }

package/signals/switch-map.js

@@ -1,28 +1,5 @@
-"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 switch_map_exports = {};
-__export(switch_map_exports, {
-  switchMap: () => switchMap
-});
-module.exports = __toCommonJS(switch_map_exports);
-var import_api = require("./api.js");
-function switchMap(source) {
-  const outerSource = (0, import_api.computed)(() => source());
-  return (0, import_api.computed)(() => outerSource()());
+import { computed } from './api.js';
+export function switchMap(source) {
+    const outerSource = computed(() => source());
+    return computed(() => outerSource()());
 }

package/signals/to-signal-2.js

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

package/signals/types.js

@@ -1,16 +1 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 types_exports = {};
-module.exports = __toCommonJS(types_exports);
+export {};

package/signals/untracked-operator.js

@@ -1,34 +1,12 @@
-"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 untracked_operator_exports = {};
-__export(untracked_operator_exports, {
-  runInUntracked: () => runInUntracked
-});
-module.exports = __toCommonJS(untracked_operator_exports);
-var import_rxjs = require("rxjs");
-var import_api = require("./api.js");
-function runInUntracked() {
-  return function runInUntracked2(source) {
-    return new import_rxjs.Observable((subscriber) => source.subscribe({
-      next: (state) => (0, import_api.untracked)(() => subscriber.next(state)),
-      complete: () => (0, import_api.untracked)(() => subscriber.complete()),
-      error: (error) => (0, import_api.untracked)(() => subscriber.error(error))
-    }));
-  };
+import { Observable } from 'rxjs';
+import { untracked } from './api.js';
+/** wraps observer in {@link untracked} */
+export function runInUntracked() {
+    return function runInUntracked(source) {
+        return new Observable((subscriber) => source.subscribe({
+            next: (state) => untracked(() => subscriber.next(state)),
+            complete: () => untracked(() => subscriber.complete()),
+            error: (error) => untracked(() => subscriber.error(error))
+        }));
+    };
 }