@angular/core 20.0.0-next.4 → 20.0.0-next.6

package/fesm2022/primitives/signals.mjs

@@ -1,11 +1,13 @@
 /**
- * @license Angular v20.0.0-next.4
+ * @license Angular v20.0.0-next.6
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 
-import { c as consumerMarkDirty, S as SIGNAL, a as consumerDestroy, i as isInNotificationPhase, b as consumerPollProducersForChange, d as consumerBeforeComputation, e as consumerAfterComputation, R as REACTIVE_NODE } from '../untracked-DkcXpNb_.mjs';
-export { x as SIGNAL_NODE, f as createComputed, g as createLinkedSignal, y as createSignal, j as defaultEquals, k as getActiveConsumer, m as isReactive, l as linkedSignalSetFn, h as linkedSignalUpdateFn, p as producerAccessed, n as producerIncrementEpoch, o as producerMarkClean, q as producerNotifyConsumers, r as producerUpdateValueVersion, t as producerUpdatesAllowed, u as runPostProducerCreatedFn, z as runPostSignalSetFn, v as setActiveConsumer, D as setAlternateWeakRefImpl, w as setPostProducerCreatedFn, A as setPostSignalSetFn, s as setThrowInvalidWriteToSignalError, B as signalSetFn, C as signalUpdateFn, E as untracked } from '../untracked-DkcXpNb_.mjs';
+import { consumerMarkDirty, SIGNAL, consumerDestroy, isInNotificationPhase, consumerPollProducersForChange, consumerBeforeComputation, consumerAfterComputation, REACTIVE_NODE } from '../signal-B6pMq7KS.mjs';
+export { SIGNAL_NODE, createComputed, createSignal, defaultEquals, getActiveConsumer, isReactive, producerAccessed, producerIncrementEpoch, producerMarkClean, producerNotifyConsumers, producerUpdateValueVersion, producerUpdatesAllowed, runPostProducerCreatedFn, runPostSignalSetFn, setActiveConsumer, setPostProducerCreatedFn, setPostSignalSetFn, setThrowInvalidWriteToSignalError, signalGetFn, signalSetFn, signalUpdateFn } from '../signal-B6pMq7KS.mjs';
+export { createLinkedSignal, linkedSignalSetFn, linkedSignalUpdateFn, untracked } from '../untracked-Bz5WMeU1.mjs';
+export { setAlternateWeakRefImpl } from '../weak_ref-BaIq-pgY.mjs';
 
 function createWatch(fn, schedule, allowSignalWrites) {
     const node = Object.create(WATCH_NODE);

package/fesm2022/primitives/signals.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"signals.mjs","sources":["../../../../../../../packages/core/primitives/signals/src/watch.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {\n  consumerAfterComputation,\n  consumerBeforeComputation,\n  consumerDestroy,\n  consumerMarkDirty,\n  consumerPollProducersForChange,\n  isInNotificationPhase,\n  REACTIVE_NODE,\n  ReactiveNode,\n  SIGNAL,\n} from './graph';\n\n/**\n * A cleanup function that can be optionally registered from the watch logic. If registered, the\n * cleanup logic runs before the next watch execution.\n */\nexport type WatchCleanupFn = () => void;\n\n/**\n * A callback passed to the watch function that makes it possible to register cleanup logic.\n */\nexport type WatchCleanupRegisterFn = (cleanupFn: WatchCleanupFn) => void;\n\nexport interface Watch {\n  notify(): void;\n\n  /**\n   * Execute the reactive expression in the context of this `Watch` consumer.\n   *\n   * Should be called by the user scheduling algorithm when the provided\n   * `schedule` hook is called by `Watch`.\n   */\n  run(): void;\n\n  cleanup(): void;\n\n  /**\n   * Destroy the watcher:\n   * - disconnect it from the reactive graph;\n   * - mark it as destroyed so subsequent run and notify operations are noop.\n   */\n  destroy(): void;\n\n  [SIGNAL]: WatchNode;\n}\nexport interface WatchNode extends ReactiveNode {\n  hasRun: boolean;\n  fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;\n  schedule: ((watch: Watch) => void) | null;\n  cleanupFn: WatchCleanupFn;\n  ref: Watch;\n}\n\nexport function createWatch(\n  fn: (onCleanup: WatchCleanupRegisterFn) => void,\n  schedule: (watch: Watch) => void,\n  allowSignalWrites: boolean,\n): Watch {\n  const node: WatchNode = Object.create(WATCH_NODE);\n  if (allowSignalWrites) {\n    node.consumerAllowSignalWrites = true;\n  }\n\n  node.fn = fn;\n  node.schedule = schedule;\n\n  const registerOnCleanup = (cleanupFn: WatchCleanupFn) => {\n    node.cleanupFn = cleanupFn;\n  };\n\n  function isWatchNodeDestroyed(node: WatchNode) {\n    return node.fn === null && node.schedule === null;\n  }\n\n  function destroyWatchNode(node: WatchNode) {\n    if (!isWatchNodeDestroyed(node)) {\n      consumerDestroy(node); // disconnect watcher from the reactive graph\n      node.cleanupFn();\n\n      // nullify references to the integration functions to mark node as destroyed\n      node.fn = null;\n      node.schedule = null;\n      node.cleanupFn = NOOP_CLEANUP_FN;\n    }\n  }\n\n  const run = () => {\n    if (node.fn === null) {\n      // trying to run a destroyed watch is noop\n      return;\n    }\n\n    if (isInNotificationPhase()) {\n      throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);\n    }\n\n    node.dirty = false;\n    if (node.hasRun && !consumerPollProducersForChange(node)) {\n      return;\n    }\n    node.hasRun = true;\n\n    const prevConsumer = consumerBeforeComputation(node);\n    try {\n      node.cleanupFn();\n      node.cleanupFn = NOOP_CLEANUP_FN;\n      node.fn(registerOnCleanup);\n    } finally {\n      consumerAfterComputation(node, prevConsumer);\n    }\n  };\n\n  node.ref = {\n    notify: () => consumerMarkDirty(node),\n    run,\n    cleanup: () => node.cleanupFn(),\n    destroy: () => destroyWatchNode(node),\n    [SIGNAL]: node,\n  };\n\n  return node.ref;\n}\n\nconst NOOP_CLEANUP_FN: WatchCleanupFn = () => {};\n\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nconst WATCH_NODE: Partial<WatchNode> = /* @__PURE__ */ (() => {\n  return {\n    ...REACTIVE_NODE,\n    consumerIsAlwaysLive: true,\n    consumerAllowSignalWrites: false,\n    consumerMarkedDirty: (node: WatchNode) => {\n      if (node.schedule !== null) {\n        node.schedule(node.ref);\n      }\n    },\n    hasRun: false,\n    cleanupFn: NOOP_CLEANUP_FN,\n  };\n})();\n"],"names":[],"mappings":";;;;;;;;;SA6DgB,WAAW,CACzB,EAA+C,EAC/C,QAAgC,EAChC,iBAA0B,EAAA;IAE1B,MAAM,IAAI,GAAc,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;IACjD,IAAI,iBAAiB,EAAE;AACrB,QAAA,IAAI,CAAC,yBAAyB,GAAG,IAAI;;AAGvC,IAAA,IAAI,CAAC,EAAE,GAAG,EAAE;AACZ,IAAA,IAAI,CAAC,QAAQ,GAAG,QAAQ;AAExB,IAAA,MAAM,iBAAiB,GAAG,CAAC,SAAyB,KAAI;AACtD,QAAA,IAAI,CAAC,SAAS,GAAG,SAAS;AAC5B,KAAC;IAED,SAAS,oBAAoB,CAAC,IAAe,EAAA;QAC3C,OAAO,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI;;IAGnD,SAAS,gBAAgB,CAAC,IAAe,EAAA;AACvC,QAAA,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE;AAC/B,YAAA,eAAe,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,SAAS,EAAE;;AAGhB,YAAA,IAAI,CAAC,EAAE,GAAG,IAAI;AACd,YAAA,IAAI,CAAC,QAAQ,GAAG,IAAI;AACpB,YAAA,IAAI,CAAC,SAAS,GAAG,eAAe;;;IAIpC,MAAM,GAAG,GAAG,MAAK;AACf,QAAA,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,EAAE;;YAEpB;;QAGF,IAAI,qBAAqB,EAAE,EAAE;AAC3B,YAAA,MAAM,IAAI,KAAK,CAAC,CAAA,iEAAA,CAAmE,CAAC;;AAGtF,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK;QAClB,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,8BAA8B,CAAC,IAAI,CAAC,EAAE;YACxD;;AAEF,QAAA,IAAI,CAAC,MAAM,GAAG,IAAI;AAElB,QAAA,MAAM,YAAY,GAAG,yBAAyB,CAAC,IAAI,CAAC;AACpD,QAAA,IAAI;YACF,IAAI,CAAC,SAAS,EAAE;AAChB,YAAA,IAAI,CAAC,SAAS,GAAG,eAAe;AAChC,YAAA,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC;;gBAClB;AACR,YAAA,wBAAwB,CAAC,IAAI,EAAE,YAAY,CAAC;;AAEhD,KAAC;IAED,IAAI,CAAC,GAAG,GAAG;AACT,QAAA,MAAM,EAAE,MAAM,iBAAiB,CAAC,IAAI,CAAC;QACrC,GAAG;AACH,QAAA,OAAO,EAAE,MAAM,IAAI,CAAC,SAAS,EAAE;AAC/B,QAAA,OAAO,EAAE,MAAM,gBAAgB,CAAC,IAAI,CAAC;QACrC,CAAC,MAAM,GAAG,IAAI;KACf;IAED,OAAO,IAAI,CAAC,GAAG;AACjB;AAEA,MAAM,eAAe,GAAmB,MAAK,GAAG;AAEhD;AACA;AACA;AACA,MAAM,UAAU,mBAAuC,CAAC,MAAK;IAC3D,OAAO;AACL,QAAA,GAAG,aAAa;AAChB,QAAA,oBAAoB,EAAE,IAAI;AAC1B,QAAA,yBAAyB,EAAE,KAAK;AAChC,QAAA,mBAAmB,EAAE,CAAC,IAAe,KAAI;AACvC,YAAA,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE;AAC1B,gBAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC;;SAE1B;AACD,QAAA,MAAM,EAAE,KAAK;AACb,QAAA,SAAS,EAAE,eAAe;KAC3B;AACH,CAAC,GAAG;;;;"}
+{"version":3,"file":"signals.mjs","sources":["../../../../../../../packages/core/primitives/signals/src/watch.ts"],"sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.dev/license\n */\n\nimport {\n  consumerAfterComputation,\n  consumerBeforeComputation,\n  consumerDestroy,\n  consumerMarkDirty,\n  consumerPollProducersForChange,\n  isInNotificationPhase,\n  REACTIVE_NODE,\n  ReactiveNode,\n  SIGNAL,\n} from './graph';\n\n/**\n * A cleanup function that can be optionally registered from the watch logic. If registered, the\n * cleanup logic runs before the next watch execution.\n */\nexport type WatchCleanupFn = () => void;\n\n/**\n * A callback passed to the watch function that makes it possible to register cleanup logic.\n */\nexport type WatchCleanupRegisterFn = (cleanupFn: WatchCleanupFn) => void;\n\nexport interface Watch {\n  notify(): void;\n\n  /**\n   * Execute the reactive expression in the context of this `Watch` consumer.\n   *\n   * Should be called by the user scheduling algorithm when the provided\n   * `schedule` hook is called by `Watch`.\n   */\n  run(): void;\n\n  cleanup(): void;\n\n  /**\n   * Destroy the watcher:\n   * - disconnect it from the reactive graph;\n   * - mark it as destroyed so subsequent run and notify operations are noop.\n   */\n  destroy(): void;\n\n  [SIGNAL]: WatchNode;\n}\nexport interface WatchNode extends ReactiveNode {\n  hasRun: boolean;\n  fn: ((onCleanup: WatchCleanupRegisterFn) => void) | null;\n  schedule: ((watch: Watch) => void) | null;\n  cleanupFn: WatchCleanupFn;\n  ref: Watch;\n}\n\nexport function createWatch(\n  fn: (onCleanup: WatchCleanupRegisterFn) => void,\n  schedule: (watch: Watch) => void,\n  allowSignalWrites: boolean,\n): Watch {\n  const node: WatchNode = Object.create(WATCH_NODE);\n  if (allowSignalWrites) {\n    node.consumerAllowSignalWrites = true;\n  }\n\n  node.fn = fn;\n  node.schedule = schedule;\n\n  const registerOnCleanup = (cleanupFn: WatchCleanupFn) => {\n    node.cleanupFn = cleanupFn;\n  };\n\n  function isWatchNodeDestroyed(node: WatchNode) {\n    return node.fn === null && node.schedule === null;\n  }\n\n  function destroyWatchNode(node: WatchNode) {\n    if (!isWatchNodeDestroyed(node)) {\n      consumerDestroy(node); // disconnect watcher from the reactive graph\n      node.cleanupFn();\n\n      // nullify references to the integration functions to mark node as destroyed\n      node.fn = null;\n      node.schedule = null;\n      node.cleanupFn = NOOP_CLEANUP_FN;\n    }\n  }\n\n  const run = () => {\n    if (node.fn === null) {\n      // trying to run a destroyed watch is noop\n      return;\n    }\n\n    if (isInNotificationPhase()) {\n      throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);\n    }\n\n    node.dirty = false;\n    if (node.hasRun && !consumerPollProducersForChange(node)) {\n      return;\n    }\n    node.hasRun = true;\n\n    const prevConsumer = consumerBeforeComputation(node);\n    try {\n      node.cleanupFn();\n      node.cleanupFn = NOOP_CLEANUP_FN;\n      node.fn(registerOnCleanup);\n    } finally {\n      consumerAfterComputation(node, prevConsumer);\n    }\n  };\n\n  node.ref = {\n    notify: () => consumerMarkDirty(node),\n    run,\n    cleanup: () => node.cleanupFn(),\n    destroy: () => destroyWatchNode(node),\n    [SIGNAL]: node,\n  };\n\n  return node.ref;\n}\n\nconst NOOP_CLEANUP_FN: WatchCleanupFn = () => {};\n\n// Note: Using an IIFE here to ensure that the spread assignment is not considered\n// a side-effect, ending up preserving `COMPUTED_NODE` and `REACTIVE_NODE`.\n// TODO: remove when https://github.com/evanw/esbuild/issues/3392 is resolved.\nconst WATCH_NODE: Partial<WatchNode> = /* @__PURE__ */ (() => {\n  return {\n    ...REACTIVE_NODE,\n    consumerIsAlwaysLive: true,\n    consumerAllowSignalWrites: false,\n    consumerMarkedDirty: (node: WatchNode) => {\n      if (node.schedule !== null) {\n        node.schedule(node.ref);\n      }\n    },\n    hasRun: false,\n    cleanupFn: NOOP_CLEANUP_FN,\n  };\n})();\n"],"names":[],"mappings":";;;;;;;;;;;SA6DgB,WAAW,CACzB,EAA+C,EAC/C,QAAgC,EAChC,iBAA0B,EAAA;IAE1B,MAAM,IAAI,GAAc,MAAM,CAAC,MAAM,CAAC,UAAU,CAAC;IACjD,IAAI,iBAAiB,EAAE;AACrB,QAAA,IAAI,CAAC,yBAAyB,GAAG,IAAI;;AAGvC,IAAA,IAAI,CAAC,EAAE,GAAG,EAAE;AACZ,IAAA,IAAI,CAAC,QAAQ,GAAG,QAAQ;AAExB,IAAA,MAAM,iBAAiB,GAAG,CAAC,SAAyB,KAAI;AACtD,QAAA,IAAI,CAAC,SAAS,GAAG,SAAS;AAC5B,KAAC;IAED,SAAS,oBAAoB,CAAC,IAAe,EAAA;QAC3C,OAAO,IAAI,CAAC,EAAE,KAAK,IAAI,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI;;IAGnD,SAAS,gBAAgB,CAAC,IAAe,EAAA;AACvC,QAAA,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,EAAE;AAC/B,YAAA,eAAe,CAAC,IAAI,CAAC,CAAC;YACtB,IAAI,CAAC,SAAS,EAAE;;AAGhB,YAAA,IAAI,CAAC,EAAE,GAAG,IAAI;AACd,YAAA,IAAI,CAAC,QAAQ,GAAG,IAAI;AACpB,YAAA,IAAI,CAAC,SAAS,GAAG,eAAe;;;IAIpC,MAAM,GAAG,GAAG,MAAK;AACf,QAAA,IAAI,IAAI,CAAC,EAAE,KAAK,IAAI,EAAE;;YAEpB;;QAGF,IAAI,qBAAqB,EAAE,EAAE;AAC3B,YAAA,MAAM,IAAI,KAAK,CAAC,CAAA,iEAAA,CAAmE,CAAC;;AAGtF,QAAA,IAAI,CAAC,KAAK,GAAG,KAAK;QAClB,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,8BAA8B,CAAC,IAAI,CAAC,EAAE;YACxD;;AAEF,QAAA,IAAI,CAAC,MAAM,GAAG,IAAI;AAElB,QAAA,MAAM,YAAY,GAAG,yBAAyB,CAAC,IAAI,CAAC;AACpD,QAAA,IAAI;YACF,IAAI,CAAC,SAAS,EAAE;AAChB,YAAA,IAAI,CAAC,SAAS,GAAG,eAAe;AAChC,YAAA,IAAI,CAAC,EAAE,CAAC,iBAAiB,CAAC;;gBAClB;AACR,YAAA,wBAAwB,CAAC,IAAI,EAAE,YAAY,CAAC;;AAEhD,KAAC;IAED,IAAI,CAAC,GAAG,GAAG;AACT,QAAA,MAAM,EAAE,MAAM,iBAAiB,CAAC,IAAI,CAAC;QACrC,GAAG;AACH,QAAA,OAAO,EAAE,MAAM,IAAI,CAAC,SAAS,EAAE;AAC/B,QAAA,OAAO,EAAE,MAAM,gBAAgB,CAAC,IAAI,CAAC;QACrC,CAAC,MAAM,GAAG,IAAI;KACf;IAED,OAAO,IAAI,CAAC,GAAG;AACjB;AAEA,MAAM,eAAe,GAAmB,MAAK,GAAG;AAEhD;AACA;AACA;AACA,MAAM,UAAU,mBAAuC,CAAC,MAAK;IAC3D,OAAO;AACL,QAAA,GAAG,aAAa;AAChB,QAAA,oBAAoB,EAAE,IAAI;AAC1B,QAAA,yBAAyB,EAAE,KAAK;AAChC,QAAA,mBAAmB,EAAE,CAAC,IAAe,KAAI;AACvC,YAAA,IAAI,IAAI,CAAC,QAAQ,KAAK,IAAI,EAAE;AAC1B,gBAAA,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC;;SAE1B;AACD,QAAA,MAAM,EAAE,KAAK;AACb,QAAA,SAAS,EAAE,eAAe;KAC3B;AACH,CAAC,GAAG;;;;"}

package/fesm2022/resource-CPPwEcg7.mjs

@@ -0,0 +1,619 @@
+/**
+ * @license Angular v20.0.0-next.6
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+import { inject, RuntimeError, formatRuntimeError, ErrorHandler, DestroyRef, assertNotInReactiveContext, assertInInjectionContext, Injector, ViewContext, ChangeDetectionScheduler, EffectScheduler, setInjectorProfilerContext, emitEffectCreatedEvent, EFFECTS, noop, FLAGS, markAncestorsForTraversal, setIsRefreshingViews, NodeInjectorDestroyRef, InjectionToken, signalAsReadonlyFn, PendingTasks, signal } from './root_effect_scheduler-VSXfCzDX.mjs';
+import { setActiveConsumer, createComputed, SIGNAL, REACTIVE_NODE, consumerDestroy, isInNotificationPhase, consumerPollProducersForChange, consumerBeforeComputation, consumerAfterComputation } from './signal-B6pMq7KS.mjs';
+import { untracked as untracked$1, createLinkedSignal, linkedSignalSetFn, linkedSignalUpdateFn } from './untracked-Bz5WMeU1.mjs';
+
+/**
+ * An `OutputEmitterRef` is created by the `output()` function and can be
+ * used to emit values to consumers of your directive or component.
+ *
+ * Consumers of your directive/component can bind to the output and
+ * subscribe to changes via the bound event syntax. For example:
+ *
+ * ```html
+ * <my-comp (valueChange)="processNewValue($event)" />
+ * ```
+ *
+ * @publicAPI
+ */
+class OutputEmitterRef {
+    destroyed = false;
+    listeners = null;
+    errorHandler = inject(ErrorHandler, { optional: true });
+    /** @internal */
+    destroyRef = inject(DestroyRef);
+    constructor() {
+        // Clean-up all listeners and mark as destroyed upon destroy.
+        this.destroyRef.onDestroy(() => {
+            this.destroyed = true;
+            this.listeners = null;
+        });
+    }
+    subscribe(callback) {
+        if (this.destroyed) {
+            throw new RuntimeError(953 /* RuntimeErrorCode.OUTPUT_REF_DESTROYED */, ngDevMode &&
+                'Unexpected subscription to destroyed `OutputRef`. ' +
+                    'The owning directive/component is destroyed.');
+        }
+        (this.listeners ??= []).push(callback);
+        return {
+            unsubscribe: () => {
+                const idx = this.listeners?.indexOf(callback);
+                if (idx !== undefined && idx !== -1) {
+                    this.listeners?.splice(idx, 1);
+                }
+            },
+        };
+    }
+    /** Emits a new value to the output. */
+    emit(value) {
+        if (this.destroyed) {
+            console.warn(formatRuntimeError(953 /* RuntimeErrorCode.OUTPUT_REF_DESTROYED */, ngDevMode &&
+                'Unexpected emit for destroyed `OutputRef`. ' +
+                    'The owning directive/component is destroyed.'));
+            return;
+        }
+        if (this.listeners === null) {
+            return;
+        }
+        const previousConsumer = setActiveConsumer(null);
+        try {
+            for (const listenerFn of this.listeners) {
+                try {
+                    listenerFn(value);
+                }
+                catch (err) {
+                    this.errorHandler?.handleError(err);
+                }
+            }
+        }
+        finally {
+            setActiveConsumer(previousConsumer);
+        }
+    }
+}
+/** Gets the owning `DestroyRef` for the given output. */
+function getOutputDestroyRef(ref) {
+    return ref.destroyRef;
+}
+
+/**
+ * Execute an arbitrary function in a non-reactive (non-tracking) context. The executed function
+ * can, optionally, return a value.
+ */
+function untracked(nonReactiveReadsFn) {
+    return untracked$1(nonReactiveReadsFn);
+}
+
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ */
+function computed(computation, options) {
+    const getter = createComputed(computation, options?.equal);
+    if (ngDevMode) {
+        getter.toString = () => `[Computed: ${getter()}]`;
+        getter[SIGNAL].debugName = options?.debugName;
+    }
+    return getter;
+}
+
+class EffectRefImpl {
+    [SIGNAL];
+    constructor(node) {
+        this[SIGNAL] = node;
+    }
+    destroy() {
+        this[SIGNAL].destroy();
+    }
+}
+/**
+ * Registers an "effect" that will be scheduled & executed whenever the signals that it reads
+ * changes.
+ *
+ * Angular has two different kinds of effect: component effects and root effects. Component effects
+ * are created when `effect()` is called from a component, directive, or within a service of a
+ * component/directive. Root effects are created when `effect()` is called from outside the
+ * component tree, such as in a root service.
+ *
+ * The two effect types differ in their timing. Component effects run as a component lifecycle
+ * event during Angular's synchronization (change detection) process, and can safely read input
+ * signals or create/destroy views that depend on component state. Root effects run as microtasks
+ * and have no connection to the component tree or change detection.
+ *
+ * `effect()` must be run in injection context, unless the `injector` option is manually specified.
+ */
+function effect(effectFn, options) {
+    ngDevMode &&
+        assertNotInReactiveContext(effect, 'Call `effect` outside of a reactive context. For example, schedule the ' +
+            'effect inside the component constructor.');
+    !options?.injector && assertInInjectionContext(effect);
+    if (ngDevMode && options?.allowSignalWrites !== undefined) {
+        console.warn(`The 'allowSignalWrites' flag is deprecated and no longer impacts effect() (writes are always allowed)`);
+    }
+    const injector = options?.injector ?? inject(Injector);
+    let destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
+    let node;
+    const viewContext = injector.get(ViewContext, null, { optional: true });
+    const notifier = injector.get(ChangeDetectionScheduler);
+    if (viewContext !== null) {
+        // This effect was created in the context of a view, and will be associated with the view.
+        node = createViewEffect(viewContext.view, notifier, effectFn);
+        if (destroyRef instanceof NodeInjectorDestroyRef && destroyRef._lView === viewContext.view) {
+            // The effect is being created in the same view as the `DestroyRef` references, so it will be
+            // automatically destroyed without the need for an explicit `DestroyRef` registration.
+            destroyRef = null;
+        }
+    }
+    else {
+        // This effect was created outside the context of a view, and will be scheduled independently.
+        node = createRootEffect(effectFn, injector.get(EffectScheduler), notifier);
+    }
+    node.injector = injector;
+    if (destroyRef !== null) {
+        // If we need to register for cleanup, do that here.
+        node.onDestroyFn = destroyRef.onDestroy(() => node.destroy());
+    }
+    const effectRef = new EffectRefImpl(node);
+    if (ngDevMode) {
+        node.debugName = options?.debugName ?? '';
+        const prevInjectorProfilerContext = setInjectorProfilerContext({ injector, token: null });
+        try {
+            emitEffectCreatedEvent(effectRef);
+        }
+        finally {
+            setInjectorProfilerContext(prevInjectorProfilerContext);
+        }
+    }
+    return effectRef;
+}
+/**
+ * Not public API, which guarantees `EffectScheduler` only ever comes from the application root
+ * injector.
+ */
+/* @__PURE__ */ new InjectionToken('', {
+    providedIn: 'root',
+    factory: () => inject(EffectScheduler),
+});
+const BASE_EFFECT_NODE = 
+/* @__PURE__ */ (() => ({
+    ...REACTIVE_NODE,
+    consumerIsAlwaysLive: true,
+    consumerAllowSignalWrites: true,
+    dirty: true,
+    hasRun: false,
+    cleanupFns: undefined,
+    zone: null,
+    kind: 'effect',
+    onDestroyFn: noop,
+    run() {
+        this.dirty = false;
+        if (ngDevMode && isInNotificationPhase()) {
+            throw new Error(`Schedulers cannot synchronously execute watches while scheduling.`);
+        }
+        if (this.hasRun && !consumerPollProducersForChange(this)) {
+            return;
+        }
+        this.hasRun = true;
+        const registerCleanupFn = (cleanupFn) => (this.cleanupFns ??= []).push(cleanupFn);
+        const prevNode = consumerBeforeComputation(this);
+        // We clear `setIsRefreshingViews` so that `markForCheck()` within the body of an effect will
+        // cause CD to reach the component in question.
+        const prevRefreshingViews = setIsRefreshingViews(false);
+        try {
+            this.maybeCleanup();
+            this.fn(registerCleanupFn);
+        }
+        finally {
+            setIsRefreshingViews(prevRefreshingViews);
+            consumerAfterComputation(this, prevNode);
+        }
+    },
+    maybeCleanup() {
+        if (!this.cleanupFns?.length) {
+            return;
+        }
+        const prevConsumer = setActiveConsumer(null);
+        try {
+            // Attempt to run the cleanup functions. Regardless of failure or success, we consider
+            // cleanup "completed" and clear the list for the next run of the effect. Note that an error
+            // from the cleanup function will still crash the current run of the effect.
+            while (this.cleanupFns.length) {
+                this.cleanupFns.pop()();
+            }
+        }
+        finally {
+            this.cleanupFns = [];
+            setActiveConsumer(prevConsumer);
+        }
+    },
+}))();
+const ROOT_EFFECT_NODE = 
+/* @__PURE__ */ (() => ({
+    ...BASE_EFFECT_NODE,
+    consumerMarkedDirty() {
+        this.scheduler.schedule(this);
+        this.notifier.notify(12 /* NotificationSource.RootEffect */);
+    },
+    destroy() {
+        consumerDestroy(this);
+        this.onDestroyFn();
+        this.maybeCleanup();
+        this.scheduler.remove(this);
+    },
+}))();
+const VIEW_EFFECT_NODE = 
+/* @__PURE__ */ (() => ({
+    ...BASE_EFFECT_NODE,
+    consumerMarkedDirty() {
+        this.view[FLAGS] |= 8192 /* LViewFlags.HasChildViewsToRefresh */;
+        markAncestorsForTraversal(this.view);
+        this.notifier.notify(13 /* NotificationSource.ViewEffect */);
+    },
+    destroy() {
+        consumerDestroy(this);
+        this.onDestroyFn();
+        this.maybeCleanup();
+        this.view[EFFECTS]?.delete(this);
+    },
+}))();
+function createViewEffect(view, notifier, fn) {
+    const node = Object.create(VIEW_EFFECT_NODE);
+    node.view = view;
+    node.zone = typeof Zone !== 'undefined' ? Zone.current : null;
+    node.notifier = notifier;
+    node.fn = fn;
+    view[EFFECTS] ??= new Set();
+    view[EFFECTS].add(node);
+    node.consumerMarkedDirty(node);
+    return node;
+}
+function createRootEffect(fn, scheduler, notifier) {
+    const node = Object.create(ROOT_EFFECT_NODE);
+    node.fn = fn;
+    node.scheduler = scheduler;
+    node.notifier = notifier;
+    node.zone = typeof Zone !== 'undefined' ? Zone.current : null;
+    node.scheduler.add(node);
+    node.notifier.notify(12 /* NotificationSource.RootEffect */);
+    return node;
+}
+
+/**
+ * Status of a `Resource`.
+ *
+ * @experimental
+ */
+var ResourceStatus;
+(function (ResourceStatus) {
+    /**
+     * The resource has no valid request and will not perform any loading.
+     *
+     * `value()` will be `undefined`.
+     */
+    ResourceStatus[ResourceStatus["Idle"] = 0] = "Idle";
+    /**
+     * Loading failed with an error.
+     *
+     * `value()` will be `undefined`.
+     */
+    ResourceStatus[ResourceStatus["Error"] = 1] = "Error";
+    /**
+     * The resource is currently loading a new value as a result of a change in its `request`.
+     *
+     * `value()` will be `undefined`.
+     */
+    ResourceStatus[ResourceStatus["Loading"] = 2] = "Loading";
+    /**
+     * The resource is currently reloading a fresh value for the same request.
+     *
+     * `value()` will continue to return the previously fetched value during the reloading operation.
+     */
+    ResourceStatus[ResourceStatus["Reloading"] = 3] = "Reloading";
+    /**
+     * Loading has completed and the resource has the value returned from the loader.
+     */
+    ResourceStatus[ResourceStatus["Resolved"] = 4] = "Resolved";
+    /**
+     * The resource's value was set locally via `.set()` or `.update()`.
+     */
+    ResourceStatus[ResourceStatus["Local"] = 5] = "Local";
+})(ResourceStatus || (ResourceStatus = {}));
+
+const identityFn = (v) => v;
+function linkedSignal(optionsOrComputation, options) {
+    if (typeof optionsOrComputation === 'function') {
+        const getter = createLinkedSignal(optionsOrComputation, (identityFn), options?.equal);
+        return upgradeLinkedSignalGetter(getter);
+    }
+    else {
+        const getter = createLinkedSignal(optionsOrComputation.source, optionsOrComputation.computation, optionsOrComputation.equal);
+        return upgradeLinkedSignalGetter(getter);
+    }
+}
+function upgradeLinkedSignalGetter(getter) {
+    if (ngDevMode) {
+        getter.toString = () => `[LinkedSignal: ${getter()}]`;
+    }
+    const node = getter[SIGNAL];
+    const upgradedGetter = getter;
+    upgradedGetter.set = (newValue) => linkedSignalSetFn(node, newValue);
+    upgradedGetter.update = (updateFn) => linkedSignalUpdateFn(node, updateFn);
+    upgradedGetter.asReadonly = signalAsReadonlyFn.bind(getter);
+    return upgradedGetter;
+}
+
+function resource(options) {
+    options?.injector || assertInInjectionContext(resource);
+    const request = (options.request ?? (() => null));
+    return new ResourceImpl(request, getLoader(options), options.defaultValue, options.equal ? wrapEqualityFn(options.equal) : undefined, options.injector ?? inject(Injector));
+}
+/**
+ * Base class which implements `.value` as a `WritableSignal` by delegating `.set` and `.update`.
+ */
+class BaseWritableResource {
+    value;
+    constructor(value) {
+        this.value = value;
+        this.value.set = this.set.bind(this);
+        this.value.update = this.update.bind(this);
+        this.value.asReadonly = signalAsReadonlyFn;
+    }
+    update(updateFn) {
+        this.set(updateFn(untracked(this.value)));
+    }
+    isLoading = computed(() => this.status() === ResourceStatus.Loading || this.status() === ResourceStatus.Reloading);
+    hasValue() {
+        return this.value() !== undefined;
+    }
+    asReadonly() {
+        return this;
+    }
+}
+/**
+ * Implementation for `resource()` which uses a `linkedSignal` to manage the resource's state.
+ */
+class ResourceImpl extends BaseWritableResource {
+    loaderFn;
+    defaultValue;
+    equal;
+    pendingTasks;
+    /**
+     * The current state of the resource. Status, value, and error are derived from this.
+     */
+    state;
+    /**
+     * Combines the current request with a reload counter which allows the resource to be reloaded on
+     * imperative command.
+     */
+    extRequest;
+    effectRef;
+    pendingController;
+    resolvePendingTask = undefined;
+    destroyed = false;
+    constructor(request, loaderFn, defaultValue, equal, injector) {
+        super(
+        // Feed a computed signal for the value to `BaseWritableResource`, which will upgrade it to a
+        // `WritableSignal` that delegates to `ResourceImpl.set`.
+        computed(() => {
+            const streamValue = this.state().stream?.();
+            return streamValue && isResolved(streamValue) ? streamValue.value : this.defaultValue;
+        }, { equal }));
+        this.loaderFn = loaderFn;
+        this.defaultValue = defaultValue;
+        this.equal = equal;
+        // Extend `request()` to include a writable reload signal.
+        this.extRequest = linkedSignal({
+            source: request,
+            computation: (request) => ({ request, reload: 0 }),
+        });
+        // The main resource state is managed in a `linkedSignal`, which allows the resource to change
+        // state instantaneously when the request signal changes.
+        this.state = linkedSignal({
+            // Whenever the request changes,
+            source: this.extRequest,
+            // Compute the state of the resource given a change in status.
+            computation: (extRequest, previous) => {
+                const status = extRequest.request === undefined ? ResourceStatus.Idle : ResourceStatus.Loading;
+                if (!previous) {
+                    return {
+                        extRequest,
+                        status,
+                        previousStatus: ResourceStatus.Idle,
+                        stream: undefined,
+                    };
+                }
+                else {
+                    return {
+                        extRequest,
+                        status,
+                        previousStatus: projectStatusOfState(previous.value),
+                        // If the request hasn't changed, keep the previous stream.
+                        stream: previous.value.extRequest.request === extRequest.request
+                            ? previous.value.stream
+                            : undefined,
+                    };
+                }
+            },
+        });
+        this.effectRef = effect(this.loadEffect.bind(this), {
+            injector,
+            manualCleanup: true,
+        });
+        this.pendingTasks = injector.get(PendingTasks);
+        // Cancel any pending request when the resource itself is destroyed.
+        injector.get(DestroyRef).onDestroy(() => this.destroy());
+    }
+    status = computed(() => projectStatusOfState(this.state()));
+    error = computed(() => {
+        const stream = this.state().stream?.();
+        return stream && !isResolved(stream) ? stream.error : undefined;
+    });
+    /**
+     * Called either directly via `WritableResource.set` or via `.value.set()`.
+     */
+    set(value) {
+        if (this.destroyed) {
+            return;
+        }
+        const current = untracked(this.value);
+        const state = untracked(this.state);
+        if (state.status === ResourceStatus.Local &&
+            (this.equal ? this.equal(current, value) : current === value)) {
+            return;
+        }
+        // Enter Local state with the user-defined value.
+        this.state.set({
+            extRequest: state.extRequest,
+            status: ResourceStatus.Local,
+            previousStatus: ResourceStatus.Local,
+            stream: signal({ value }),
+        });
+        // We're departing from whatever state the resource was in previously, so cancel any in-progress
+        // loading operations.
+        this.abortInProgressLoad();
+    }
+    reload() {
+        // We don't want to restart in-progress loads.
+        const { status } = untracked(this.state);
+        if (status === ResourceStatus.Idle || status === ResourceStatus.Loading) {
+            return false;
+        }
+        // Increment the request reload to trigger the `state` linked signal to switch us to `Reload`
+        this.extRequest.update(({ request, reload }) => ({ request, reload: reload + 1 }));
+        return true;
+    }
+    destroy() {
+        this.destroyed = true;
+        this.effectRef.destroy();
+        this.abortInProgressLoad();
+        // Destroyed resources enter Idle state.
+        this.state.set({
+            extRequest: { request: undefined, reload: 0 },
+            status: ResourceStatus.Idle,
+            previousStatus: ResourceStatus.Idle,
+            stream: undefined,
+        });
+    }
+    async loadEffect() {
+        const extRequest = this.extRequest();
+        // Capture the previous status before any state transitions. Note that this is `untracked` since
+        // we do not want the effect to depend on the state of the resource, only on the request.
+        const { status: currentStatus, previousStatus } = untracked(this.state);
+        if (extRequest.request === undefined) {
+            // Nothing to load (and we should already be in a non-loading state).
+            return;
+        }
+        else if (currentStatus !== ResourceStatus.Loading) {
+            // We're not in a loading or reloading state, so this loading request is stale.
+            return;
+        }
+        // Cancel any previous loading attempts.
+        this.abortInProgressLoad();
+        // Capturing _this_ load's pending task in a local variable is important here. We may attempt to
+        // resolve it twice:
+        //
+        //  1. when the loading function promise resolves/rejects
+        //  2. when cancelling the loading operation
+        //
+        // After the loading operation is cancelled, `this.resolvePendingTask` no longer represents this
+        // particular task, but this `await` may eventually resolve/reject. Thus, when we cancel in
+        // response to (1) below, we need to cancel the locally saved task.
+        let resolvePendingTask = (this.resolvePendingTask =
+            this.pendingTasks.add());
+        const { signal: abortSignal } = (this.pendingController = new AbortController());
+        try {
+            // The actual loading is run through `untracked` - only the request side of `resource` is
+            // reactive. This avoids any confusion with signals tracking or not tracking depending on
+            // which side of the `await` they are.
+            const stream = await untracked(() => {
+                return this.loaderFn({
+                    request: extRequest.request,
+                    abortSignal,
+                    previous: {
+                        status: previousStatus,
+                    },
+                });
+            });
+            // If this request has been aborted, or the current request no longer
+            // matches this load, then we should ignore this resolution.
+            if (abortSignal.aborted || untracked(this.extRequest) !== extRequest) {
+                return;
+            }
+            this.state.set({
+                extRequest,
+                status: ResourceStatus.Resolved,
+                previousStatus: ResourceStatus.Resolved,
+                stream,
+            });
+        }
+        catch (err) {
+            if (abortSignal.aborted || untracked(this.extRequest) !== extRequest) {
+                return;
+            }
+            this.state.set({
+                extRequest,
+                status: ResourceStatus.Resolved,
+                previousStatus: ResourceStatus.Error,
+                stream: signal({ error: err }),
+            });
+        }
+        finally {
+            // Resolve the pending task now that the resource has a value.
+            resolvePendingTask?.();
+            resolvePendingTask = undefined;
+        }
+    }
+    abortInProgressLoad() {
+        untracked(() => this.pendingController?.abort());
+        this.pendingController = undefined;
+        // Once the load is aborted, we no longer want to block stability on its resolution.
+        this.resolvePendingTask?.();
+        this.resolvePendingTask = undefined;
+    }
+}
+/**
+ * Wraps an equality function to handle either value being `undefined`.
+ */
+function wrapEqualityFn(equal) {
+    return (a, b) => (a === undefined || b === undefined ? a === b : equal(a, b));
+}
+function getLoader(options) {
+    if (isStreamingResourceOptions(options)) {
+        return options.stream;
+    }
+    return async (params) => {
+        try {
+            return signal({ value: await options.loader(params) });
+        }
+        catch (err) {
+            return signal({ error: err });
+        }
+    };
+}
+function isStreamingResourceOptions(options) {
+    return !!options.stream;
+}
+/**
+ * Project from a state with `ResourceInternalStatus` to the user-facing `ResourceStatus`
+ */
+function projectStatusOfState(state) {
+    switch (state.status) {
+        case ResourceStatus.Loading:
+            return state.extRequest.reload === 0 ? ResourceStatus.Loading : ResourceStatus.Reloading;
+        case ResourceStatus.Resolved:
+            return isResolved(untracked(state.stream)) ? ResourceStatus.Resolved : ResourceStatus.Error;
+        default:
+            return state.status;
+    }
+}
+function isResolved(state) {
+    return state.error === undefined;
+}
+
+export { OutputEmitterRef, ResourceImpl, ResourceStatus, computed, effect, getOutputDestroyRef, linkedSignal, resource, untracked };
+//# sourceMappingURL=resource-CPPwEcg7.mjs.map