static-injector 6.1.2 → 6.3.0

package/index.mjs

@@ -26,15 +26,6 @@ function getFactoryDef(type, throwNotFound) {
   return () => new type();
 }
 
-// src/import/render3/errors_di.ts
-function throwCyclicDependencyError(token, path) {
-  throw new RuntimeError(-200 /* CYCLIC_DI_DEPENDENCY */, token);
-}
-function throwProviderNotFoundError(token, injectorName) {
-  const errorMessage = void 0;
-  throw new RuntimeError(-201 /* PROVIDER_NOT_FOUND */, errorMessage);
-}
-
 // src/import/util/property.ts
 function getClosureSafeProperty(objWithPropertyToExtract) {
   for (const key in objWithPropertyToExtract) {
@@ -45,6 +36,31 @@ function getClosureSafeProperty(objWithPropertyToExtract) {
   throw Error("");
 }
 
+// src/import/render3/errors_di.ts
+var NG_RUNTIME_ERROR_CODE = getClosureSafeProperty({ ngErrorCode: getClosureSafeProperty });
+var NG_RUNTIME_ERROR_MESSAGE = getClosureSafeProperty({ ngErrorMessage: getClosureSafeProperty });
+var NG_TOKEN_PATH = getClosureSafeProperty({ ngTokenPath: getClosureSafeProperty });
+function cyclicDependencyError(token, path) {
+  const message = "";
+  return createRuntimeError(message, -200 /* CYCLIC_DI_DEPENDENCY */, path);
+}
+function throwProviderNotFoundError(token, injectorName) {
+  const errorMessage = void 0;
+  throw new RuntimeError(-201 /* PROVIDER_NOT_FOUND */, errorMessage);
+}
+function createRuntimeError(message, code, path) {
+  const error = new RuntimeError(code, message);
+  error[NG_RUNTIME_ERROR_CODE] = code;
+  error[NG_RUNTIME_ERROR_MESSAGE] = message;
+  if (path) {
+    error[NG_TOKEN_PATH] = path;
+  }
+  return error;
+}
+function getRuntimeErrorCode(error) {
+  return error[NG_RUNTIME_ERROR_CODE];
+}
+
 // src/import/render3/fields.ts
 var NG_FACTORY_DEF = getClosureSafeProperty({ ɵfac: getClosureSafeProperty });
 var NG_ENV_ID = getClosureSafeProperty({ __NG_ENV_ID__: getClosureSafeProperty });
@@ -213,12 +229,6 @@ function setCurrentInjector(injector) {
 
 // src/primitives/di/src/not_found.ts
 var NOT_FOUND = Symbol("NotFound");
-var NotFoundError = class extends Error {
-  name = "ɵNotFound";
-  constructor(message) {
-    super(message);
-  }
-};
 function isNotFound(e) {
   return e === NOT_FOUND || e?.name === "ɵNotFound";
 }
@@ -249,7 +259,6 @@ var RetrievingInjector = class {
   }
 };
 var NG_TEMP_TOKEN_PATH = "ngTempTokenPath";
-var NG_TOKEN_PATH = "ngTokenPath";
 var NEW_LINE = /\n/gm;
 var NO_NEW_LINE = "ɵ";
 var SOURCE = "__source";
@@ -277,7 +286,7 @@ function ɵɵinject(token, flags = 0 /* Default */) {
 function ɵɵinvalidFactoryDep(index) {
   throw new RuntimeError(202 /* INVALID_FACTORY_DEPENDENCY */, void 0);
 }
-function inject(token, options) {
+function inject2(token, options) {
   return ɵɵinject(token, convertToBitFlags(options));
 }
 function convertToBitFlags(flags) {
@@ -333,16 +342,6 @@ function attachInjectFlag(decorator, flag) {
 function getInjectFlag(token) {
   return token[DI_DECORATOR_FLAG];
 }
-function catchInjectorError(e, token, injectorErrorName, source) {
-  const tokenPath = e[NG_TEMP_TOKEN_PATH];
-  if (token[SOURCE]) {
-    tokenPath.unshift(token[SOURCE]);
-  }
-  e.message = formatError("\n" + e.message, tokenPath, injectorErrorName, source);
-  e[NG_TOKEN_PATH] = tokenPath;
-  e[NG_TEMP_TOKEN_PATH] = null;
-  throw e;
-}
 function formatError(text, obj, injectorErrorName, source = null) {
   text = text && text.charAt(0) === "\n" && text.charAt(1) == NO_NEW_LINE ? text.slice(2) : text;
   let context = stringify(obj);
@@ -377,7 +376,9 @@ var INJECTOR_DEF_TYPES = new InjectionToken("");
 var NullInjector = class {
   get(token, notFoundValue = THROW_IF_NOT_FOUND) {
     if (notFoundValue === THROW_IF_NOT_FOUND) {
-      const error = new NotFoundError(`NullInjectorError: No provider for ${stringify(token)}!`);
+      const message = "";
+      const error = createRuntimeError(message, -201 /* PROVIDER_NOT_FOUND */);
+      error.name = "ɵNotFound";
       throw error;
     }
     return notFoundValue;
@@ -536,23 +537,21 @@ var R3Injector = class extends EnvironmentInjector {
           this.records.set(token, record);
         }
         if (record != null) {
-          return this.hydrate(token, record);
+          return this.hydrate(token, record, flags);
         }
       }
       const nextInjector = !(flags & 2 /* Self */) ? this.parent : getNullInjector();
       notFoundValue = flags & 8 /* Optional */ && notFoundValue === THROW_IF_NOT_FOUND ? null : notFoundValue;
       return nextInjector.get(token, notFoundValue);
-    } catch (e) {
-      if (isNotFound(e)) {
-        const path = e[NG_TEMP_TOKEN_PATH] = e[NG_TEMP_TOKEN_PATH] || [];
-        path.unshift(stringify(token));
-        if (previousInjector) {
-          throw e;
+    } catch (error) {
+      const errorCode = getRuntimeErrorCode(error);
+      if (errorCode === -200 /* CYCLIC_DI_DEPENDENCY */ || errorCode === -201 /* PROVIDER_NOT_FOUND */) {
+        if (false) {
         } else {
-          return catchInjectorError(e, token, "R3InjectorError", this.source);
+          throw new RuntimeError(errorCode, null);
         }
       } else {
-        throw e;
+        throw error;
       }
     } finally {
       setInjectImplementation(previousInjectImplementation);
@@ -612,15 +611,15 @@ var R3Injector = class extends EnvironmentInjector {
     }
     this.records.set(token, record);
   }
-  hydrate(token, record) {
+  hydrate(token, record, flags) {
     try {
       if (record.value === CIRCULAR) {
-        throwCyclicDependencyError(stringify(token));
+        throw cyclicDependencyError(stringify(token));
       } else if (record.value === NOT_YET) {
         record.value = CIRCULAR;
         if (false) {
         } else {
-          record.value = record.factory();
+          record.value = record.factory(void 0, flags);
         }
       }
       if (typeof record.value === "object" && record.value && hasOnDestroy(record.value)) {
@@ -695,7 +694,7 @@ function providerToFactory(provider, ngModuleType, providers) {
     } else if (isFactoryProvider(provider)) {
       factory = () => provider.useFactory(...injectArgs(provider.deps || []));
     } else if (isExistingProvider(provider)) {
-      factory = () => ɵɵinject(resolveForwardRef(provider.useExisting));
+      factory = (_, flags) => ɵɵinject(resolveForwardRef(provider.useExisting), flags !== void 0 && flags & 8 /* Optional */ ? 8 /* Optional */ : void 0);
     } else {
       const classRef = resolveForwardRef(provider && (provider.useClass || provider.provide));
       if (false) {
@@ -840,11 +839,6 @@ function ɵɵinvalidFactory() {
   throw new Error(msg);
 }
 
-// src/primitives/signals/src/equality.ts
-function defaultEquals(a, b) {
-  return Object.is(a, b);
-}
-
 // src/primitives/signals/src/graph.ts
 var activeConsumer = null;
 var inNotificationPhase = false;
@@ -863,12 +857,11 @@ var REACTIVE_NODE = {
   version: 0,
   lastCleanEpoch: 0,
   dirty: false,
-  producerNode: void 0,
-  producerLastReadVersion: void 0,
-  producerIndexOfThis: void 0,
-  nextProducerIndex: 0,
-  liveConsumerNode: void 0,
-  liveConsumerIndexOfThis: void 0,
+  producers: void 0,
+  producersTail: void 0,
+  consumers: void 0,
+  consumersTail: void 0,
+  recomputing: false,
   consumerAllowSignalWrites: false,
   consumerIsAlwaysLive: false,
   kind: "unknown",
@@ -888,19 +881,45 @@ function producerAccessed(node) {
     return;
   }
   activeConsumer.consumerOnSignalRead(node);
-  const idx = activeConsumer.nextProducerIndex++;
-  assertConsumerNode(activeConsumer);
-  if (idx < activeConsumer.producerNode.length && activeConsumer.producerNode[idx] !== node) {
-    if (consumerIsLive(activeConsumer)) {
-      const staleProducer = activeConsumer.producerNode[idx];
-      producerRemoveLiveConsumerAtIndex(staleProducer, activeConsumer.producerIndexOfThis[idx]);
+  const prevProducerLink = activeConsumer.producersTail;
+  if (prevProducerLink !== void 0 && prevProducerLink.producer === node) {
+    return;
+  }
+  let nextProducerLink = void 0;
+  const isRecomputing = activeConsumer.recomputing;
+  if (isRecomputing) {
+    nextProducerLink = prevProducerLink !== void 0 ? prevProducerLink.nextProducer : activeConsumer.producers;
+    if (nextProducerLink !== void 0 && nextProducerLink.producer === node) {
+      activeConsumer.producersTail = nextProducerLink;
+      nextProducerLink.lastReadVersion = node.version;
+      return;
     }
   }
-  if (activeConsumer.producerNode[idx] !== node) {
-    activeConsumer.producerNode[idx] = node;
-    activeConsumer.producerIndexOfThis[idx] = consumerIsLive(activeConsumer) ? producerAddLiveConsumer(node, activeConsumer, idx) : 0;
+  const prevConsumerLink = node.consumersTail;
+  if (prevConsumerLink !== void 0 && prevConsumerLink.consumer === activeConsumer && // However, we have to make sure that the link we've discovered isn't from a node that is incrementally rebuilding its producer list
+  (!isRecomputing || isValidLink(prevConsumerLink, activeConsumer))) {
+    return;
+  }
+  const isLive = consumerIsLive(activeConsumer);
+  const newLink = {
+    producer: node,
+    consumer: activeConsumer,
+    // instead of eagerly destroying the previous link, we delay until we've finished recomputing
+    // the producers list, so that we can destroy all of the old links at once.
+    nextProducer: nextProducerLink,
+    prevConsumer: prevConsumerLink,
+    lastReadVersion: node.version,
+    nextConsumer: void 0
+  };
+  activeConsumer.producersTail = newLink;
+  if (prevProducerLink !== void 0) {
+    prevProducerLink.nextProducer = newLink;
+  } else {
+    activeConsumer.producers = newLink;
+  }
+  if (isLive) {
+    producerAddLiveConsumer(node, newLink);
   }
-  activeConsumer.producerLastReadVersion[idx] = node.version;
 }
 function producerIncrementEpoch() {
   epoch++;
@@ -920,13 +939,14 @@ function producerUpdateValueVersion(node) {
   producerMarkClean(node);
 }
 function producerNotifyConsumers(node) {
-  if (node.liveConsumerNode === void 0) {
+  if (node.consumers === void 0) {
     return;
   }
   const prev = inNotificationPhase;
   inNotificationPhase = true;
   try {
-    for (const consumer of node.liveConsumerNode) {
+    for (let link = node.consumers; link !== void 0; link = link.nextConsumer) {
+      const consumer = link.consumer;
       if (!consumer.dirty) {
         consumerMarkDirty(consumer);
       }
@@ -948,30 +968,38 @@ function producerMarkClean(node) {
   node.lastCleanEpoch = epoch;
 }
 function consumerBeforeComputation(node) {
-  node && (node.nextProducerIndex = 0);
+  if (node) resetConsumerBeforeComputation(node);
   return setActiveConsumer(node);
 }
+function resetConsumerBeforeComputation(node) {
+  node.producersTail = void 0;
+  node.recomputing = true;
+}
 function consumerAfterComputation(node, prevConsumer) {
   setActiveConsumer(prevConsumer);
-  if (!node || node.producerNode === void 0 || node.producerIndexOfThis === void 0 || node.producerLastReadVersion === void 0) {
-    return;
-  }
-  if (consumerIsLive(node)) {
-    for (let i = node.nextProducerIndex; i < node.producerNode.length; i++) {
-      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+  if (node) finalizeConsumerAfterComputation(node);
+}
+function finalizeConsumerAfterComputation(node) {
+  node.recomputing = false;
+  const producersTail = node.producersTail;
+  let toRemove = producersTail !== void 0 ? producersTail.nextProducer : node.producers;
+  if (toRemove !== void 0) {
+    if (consumerIsLive(node)) {
+      do {
+        toRemove = producerRemoveLiveConsumerLink(toRemove);
+      } while (toRemove !== void 0);
+    }
+    if (producersTail !== void 0) {
+      producersTail.nextProducer = void 0;
+    } else {
+      node.producers = void 0;
     }
   }
-  while (node.producerNode.length > node.nextProducerIndex) {
-    node.producerNode.pop();
-    node.producerLastReadVersion.pop();
-    node.producerIndexOfThis.pop();
-  }
 }
 function consumerPollProducersForChange(node) {
-  assertConsumerNode(node);
-  for (let i = 0; i < node.producerNode.length; i++) {
-    const producer = node.producerNode[i];
-    const seenVersion = node.producerLastReadVersion[i];
+  for (let link = node.producers; link !== void 0; link = link.nextProducer) {
+    const producer = link.producer;
+    const seenVersion = link.lastReadVersion;
     if (seenVersion !== producer.version) {
       return true;
     }
@@ -983,67 +1011,87 @@ function consumerPollProducersForChange(node) {
   return false;
 }
 function consumerDestroy(node) {
-  assertConsumerNode(node);
   if (consumerIsLive(node)) {
-    for (let i = 0; i < node.producerNode.length; i++) {
-      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
-    }
-  }
-  node.producerNode.length = node.producerLastReadVersion.length = node.producerIndexOfThis.length = 0;
-  if (node.liveConsumerNode) {
-    node.liveConsumerNode.length = node.liveConsumerIndexOfThis.length = 0;
-  }
-}
-function producerAddLiveConsumer(node, consumer, indexOfThis) {
-  assertProducerNode(node);
-  if (node.liveConsumerNode.length === 0 && isConsumerNode(node)) {
-    for (let i = 0; i < node.producerNode.length; i++) {
-      node.producerIndexOfThis[i] = producerAddLiveConsumer(node.producerNode[i], node, i);
-    }
-  }
-  node.liveConsumerIndexOfThis.push(indexOfThis);
-  return node.liveConsumerNode.push(consumer) - 1;
-}
-function producerRemoveLiveConsumerAtIndex(node, idx) {
-  assertProducerNode(node);
-  if (false) {
-    throw new Error(`Assertion error: active consumer index ${idx} is out of bounds of ${node.liveConsumerNode.length} consumers)`);
+    let link = node.producers;
+    while (link !== void 0) {
+      link = producerRemoveLiveConsumerLink(link);
+    }
+  }
+  node.producers = void 0;
+  node.producersTail = void 0;
+  node.consumers = void 0;
+  node.consumersTail = void 0;
+}
+function producerAddLiveConsumer(node, link) {
+  const consumersTail = node.consumersTail;
+  const wasLive = consumerIsLive(node);
+  if (consumersTail !== void 0) {
+    link.nextConsumer = consumersTail.nextConsumer;
+    consumersTail.nextConsumer = link;
+  } else {
+    link.nextConsumer = void 0;
+    node.consumers = link;
+  }
+  link.prevConsumer = consumersTail;
+  node.consumersTail = link;
+  if (!wasLive) {
+    for (let link2 = node.producers; link2 !== void 0; link2 = link2.nextProducer) {
+      producerAddLiveConsumer(link2.producer, link2);
+    }
+  }
+}
+function producerRemoveLiveConsumerLink(link) {
+  const producer = link.producer;
+  const nextProducer = link.nextProducer;
+  const nextConsumer = link.nextConsumer;
+  const prevConsumer = link.prevConsumer;
+  link.nextConsumer = void 0;
+  link.prevConsumer = void 0;
+  if (nextConsumer !== void 0) {
+    nextConsumer.prevConsumer = prevConsumer;
+  } else {
+    producer.consumersTail = prevConsumer;
   }
-  if (node.liveConsumerNode.length === 1 && isConsumerNode(node)) {
-    for (let i = 0; i < node.producerNode.length; i++) {
-      producerRemoveLiveConsumerAtIndex(node.producerNode[i], node.producerIndexOfThis[i]);
+  if (prevConsumer !== void 0) {
+    prevConsumer.nextConsumer = nextConsumer;
+  } else {
+    producer.consumers = nextConsumer;
+    if (!consumerIsLive(producer)) {
+      let producerLink = producer.producers;
+      while (producerLink !== void 0) {
+        producerLink = producerRemoveLiveConsumerLink(producerLink);
+      }
     }
   }
-  const lastIdx = node.liveConsumerNode.length - 1;
-  node.liveConsumerNode[idx] = node.liveConsumerNode[lastIdx];
-  node.liveConsumerIndexOfThis[idx] = node.liveConsumerIndexOfThis[lastIdx];
-  node.liveConsumerNode.length--;
-  node.liveConsumerIndexOfThis.length--;
-  if (idx < node.liveConsumerNode.length) {
-    const idxProducer = node.liveConsumerIndexOfThis[idx];
-    const consumer = node.liveConsumerNode[idx];
-    assertConsumerNode(consumer);
-    consumer.producerIndexOfThis[idxProducer] = idx;
-  }
+  return nextProducer;
 }
 function consumerIsLive(node) {
-  return node.consumerIsAlwaysLive || (node?.liveConsumerNode?.length ?? 0) > 0;
-}
-function assertConsumerNode(node) {
-  node.producerNode ??= [];
-  node.producerIndexOfThis ??= [];
-  node.producerLastReadVersion ??= [];
-}
-function assertProducerNode(node) {
-  node.liveConsumerNode ??= [];
-  node.liveConsumerIndexOfThis ??= [];
-}
-function isConsumerNode(node) {
-  return node.producerNode !== void 0;
+  return node.consumerIsAlwaysLive || node.consumers !== void 0;
 }
 function runPostProducerCreatedFn(node) {
   postProducerCreatedFn?.(node);
 }
+function isValidLink(checkLink, consumer) {
+  const producersTail = consumer.producersTail;
+  if (producersTail !== void 0) {
+    let link = consumer.producers;
+    do {
+      if (link === checkLink) {
+        return true;
+      }
+      if (link === producersTail) {
+        break;
+      }
+      link = link.nextProducer;
+    } while (link !== void 0);
+  }
+  return false;
+}
+
+// src/primitives/signals/src/equality.ts
+function defaultEquals(a, b) {
+  return Object.is(a, b);
+}
 
 // src/primitives/signals/src/computed.ts
 function createComputed(computation, equal) {
@@ -1255,6 +1303,34 @@ function untracked(nonReactiveReadsFn) {
   }
 }
 
+// src/primitives/signals/src/effect.ts
+var BASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
+  ...REACTIVE_NODE,
+  consumerIsAlwaysLive: true,
+  consumerAllowSignalWrites: true,
+  dirty: true,
+  kind: "effect"
+}))();
+function runEffect(node) {
+  node.dirty = false;
+  if (node.version > 0 && !consumerPollProducersForChange(node)) {
+    return;
+  }
+  node.version++;
+  const prevNode = consumerBeforeComputation(node);
+  try {
+    node.cleanup();
+    node.fn();
+  } finally {
+    consumerAfterComputation(node, prevNode);
+  }
+}
+
+// src/primitives/signals/index.ts
+if (false) {
+  installDevToolsSignalFormatter();
+}
+
 // src/import/render3/reactivity/api.ts
 function isSignal(value) {
   return typeof value === "function" && value[SIGNAL] !== void 0;
@@ -1298,13 +1374,13 @@ var identityFn = (v) => v;
 function linkedSignal(optionsOrComputation, options) {
   if (typeof optionsOrComputation === "function") {
     const getter = createLinkedSignal(optionsOrComputation, identityFn, options?.equal);
-    return upgradeLinkedSignalGetter(getter);
+    return upgradeLinkedSignalGetter(getter, options?.debugName);
   } else {
     const getter = createLinkedSignal(optionsOrComputation.source, optionsOrComputation.computation, optionsOrComputation.equal);
-    return upgradeLinkedSignalGetter(getter);
+    return upgradeLinkedSignalGetter(getter, optionsOrComputation.debugName);
   }
 }
-function upgradeLinkedSignalGetter(getter) {
+function upgradeLinkedSignalGetter(getter, debugName) {
   if (false) {
   }
   const node = getter[SIGNAL];
@@ -1468,7 +1544,7 @@ function effect(effectFn, options) {
   if (false) {
     console.warn(`The 'allowSignalWrites' flag is deprecated and no longer impacts effect() (writes are always allowed)`);
   }
-  const injector = options?.injector ?? inject(Injector);
+  const injector = options?.injector ?? inject2(Injector);
   const destroyRef = options?.manualCleanup !== true ? injector.get(DestroyRef) : null;
   let node;
   const notifier = injector.get(ChangeDetectionScheduler);
@@ -1480,35 +1556,21 @@ function effect(effectFn, options) {
   const effectRef = new EffectRefImpl(node);
   return effectRef;
 }
-var BASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
-  ...REACTIVE_NODE,
-  consumerIsAlwaysLive: true,
-  consumerAllowSignalWrites: true,
-  dirty: true,
-  hasRun: false,
+var EFFECT_NODE = /* @__PURE__ */ (() => ({
+  ...BASE_EFFECT_NODE,
   cleanupFns: void 0,
   zone: null,
-  kind: "effect",
   onDestroyFn: noop,
   run() {
-    this.dirty = false;
     if (false) {
       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);
     try {
-      this.maybeCleanup();
-      this.fn(registerCleanupFn);
+      runEffect(this);
     } finally {
-      consumerAfterComputation(this, prevNode);
     }
   },
-  maybeCleanup() {
+  cleanup() {
     if (!this.cleanupFns?.length) {
       return;
     }
@@ -1524,7 +1586,7 @@ var BASE_EFFECT_NODE = /* @__PURE__ */ (() => ({
   }
 }))();
 var ROOT_EFFECT_NODE = /* @__PURE__ */ (() => ({
-  ...BASE_EFFECT_NODE,
+  ...EFFECT_NODE,
   consumerMarkedDirty() {
     this.scheduler.schedule(this);
     this.notifier.notify(12 /* RootEffect */);
@@ -1532,13 +1594,13 @@ var ROOT_EFFECT_NODE = /* @__PURE__ */ (() => ({
   destroy() {
     consumerDestroy(this);
     this.onDestroyFn();
-    this.maybeCleanup();
+    this.cleanup();
     this.scheduler.remove(this);
   }
 }))();
 function createRootEffect(fn, scheduler, notifier) {
   const node = Object.create(ROOT_EFFECT_NODE);
-  node.fn = fn;
+  node.fn = createEffectFn(node, fn);
   node.scheduler = scheduler;
   node.notifier = notifier;
   node.zone = false ? (void 0).current : null;
@@ -1546,44 +1608,30 @@ function createRootEffect(fn, scheduler, notifier) {
   node.notifier.notify(12 /* RootEffect */);
   return node;
 }
+function createEffectFn(node, fn) {
+  return () => {
+    fn((cleanupFn) => (node.cleanupFns ??= []).push(cleanupFn));
+  };
+}
 
 // src/import/util/callback_scheduler.ts
-function scheduleCallbackWithRafRace(callback) {
-  let timeoutId;
-  let animationFrameId;
-  function cleanup() {
+function scheduleCallbackWithMicrotask(callback) {
+  queueMicrotask(() => callback());
+  return () => {
     callback = noop;
-    try {
-      if (animationFrameId !== void 0 && typeof cancelAnimationFrame === "function") {
-        cancelAnimationFrame(animationFrameId);
-      }
-      if (timeoutId !== void 0) {
-        clearTimeout(timeoutId);
-      }
-    } catch {
-    }
-  }
-  timeoutId = setTimeout(() => {
-    callback();
-    cleanup();
-  });
-  if (typeof requestAnimationFrame === "function") {
-    animationFrameId = requestAnimationFrame(() => {
-      callback();
-      cleanup();
-    });
-  }
-  return () => cleanup();
+  };
 }
 
 // src/import/change_detection/scheduling/zoneless_scheduling_impl.ts
 var ChangeDetectionSchedulerImpl = class {
   runningTick = false;
-  #rootEffectScheduler = inject(EffectScheduler);
+  #rootEffectScheduler = inject2(EffectScheduler);
   cancelScheduledCallback = null;
   notify(source) {
-    this.cancelScheduledCallback = scheduleCallbackWithRafRace(() => {
+    this.cancelScheduledCallback = scheduleCallbackWithMicrotask(() => {
+      this.runningTick = true;
       this.#rootEffectScheduler.flush();
+      this.cleanup();
     });
   }
   cleanup() {
@@ -1612,11 +1660,17 @@ var ErrorHandler = class {
 var INTERNAL_APPLICATION_ERROR_HANDLER = new InjectionToken("", {
   providedIn: "root",
   factory: () => {
-    const injector = inject(EnvironmentInjector);
+    const injector = inject2(EnvironmentInjector);
     let userErrorHandler;
     return (e) => {
-      userErrorHandler ??= injector.get(ErrorHandler);
-      userErrorHandler.handleError(e);
+      if (injector.destroyed && !userErrorHandler) {
+        setTimeout(() => {
+          throw e;
+        });
+      } else {
+        userErrorHandler ??= injector.get(ErrorHandler);
+        userErrorHandler.handleError(e);
+      }
     };
   }
 });
@@ -1679,9 +1733,9 @@ var PendingTasksInternal = class _PendingTasksInternal {
   );
 };
 var PendingTasks = class _PendingTasks {
-  internalPendingTasks = inject(PendingTasksInternal);
-  scheduler = inject(ChangeDetectionScheduler);
-  errorHandler = inject(INTERNAL_APPLICATION_ERROR_HANDLER);
+  internalPendingTasks = inject2(PendingTasksInternal);
+  scheduler = inject2(ChangeDetectionScheduler);
+  errorHandler = inject2(INTERNAL_APPLICATION_ERROR_HANDLER);
   /**
    * Adds a new task that should block application's stability.
    * @returns A cleanup function that removes a task when called.
@@ -1725,20 +1779,12 @@ var PendingTasks = class _PendingTasks {
 };
 
 // src/import/resource/resource.ts
-var RESOURCE_VALUE_THROWS_ERRORS_DEFAULT = true;
 function resource(options) {
   if (false) {
   }
   const oldNameForParams = options.request;
   const params = options.params ?? oldNameForParams ?? (() => null);
-  return new ResourceImpl(
-    params,
-    getLoader(options),
-    options.defaultValue,
-    options.equal ? wrapEqualityFn(options.equal) : void 0,
-    options.injector ?? inject(Injector),
-    RESOURCE_VALUE_THROWS_ERRORS_DEFAULT
-  );
+  return new ResourceImpl(params, getLoader(options), options.defaultValue, options.equal ? wrapEqualityFn(options.equal) : void 0, options.injector ?? inject2(Injector));
 }
 var BaseWritableResource = class {
   value;
@@ -1753,18 +1799,23 @@ var BaseWritableResource = class {
     this.set(updateFn(untracked2(this.value)));
   }
   isLoading = computed(() => this.status() === "loading" || this.status() === "reloading");
-  hasValue() {
+  // Use a computed here to avoid triggering reactive consumers if the value changes while staying
+  // either defined or undefined.
+  isValueDefined = computed(() => {
     if (this.isError()) {
       return false;
     }
     return this.value() !== void 0;
+  });
+  hasValue() {
+    return this.isValueDefined();
   }
   asReadonly() {
     return this;
   }
 };
 var ResourceImpl = class extends BaseWritableResource {
-  constructor(request, loaderFn, defaultValue, equal, injector, throwErrorsFromValue = RESOURCE_VALUE_THROWS_ERRORS_DEFAULT) {
+  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`.
@@ -1778,11 +1829,7 @@ var ResourceImpl = class extends BaseWritableResource {
             return defaultValue;
           }
           if (!isResolved(streamValue)) {
-            if (throwErrorsFromValue) {
-              throw new ResourceValueError(this.error());
-            } else {
-              return defaultValue;
-            }
+            throw new ResourceValueError(this.error());
           }
           return streamValue.value;
         },
@@ -1853,10 +1900,13 @@ var ResourceImpl = class extends BaseWritableResource {
     if (this.destroyed) {
       return;
     }
-    const current = untracked2(this.value);
+    const error = untracked2(this.error);
     const state = untracked2(this.state);
-    if (state.status === "local" && (this.equal ? this.equal(current, value) : current === value)) {
-      return;
+    if (!error) {
+      const current = untracked2(this.value);
+      if (state.status === "local" && (this.equal ? this.equal(current, value) : current === value)) {
+        return;
+      }
     }
     this.state.set({
       extRequest: state.extRequest,
@@ -2023,6 +2073,7 @@ export {
   ChangeDetectionSchedulerImpl,
   DecoratorFlags,
   DestroyRef,
+  EffectScheduler,
   EnvironmentInjector,
   ErrorHandler,
   INJECTOR_SCOPE,
@@ -2055,7 +2106,6 @@ export {
   assertNotDestroyed,
   assertNotInReactiveContext,
   attachInjectFlag,
-  catchInjectorError,
   computed,
   convertToBitFlags,
   createInjector2 as createInjector,
@@ -2068,7 +2118,7 @@ export {
   getInjectableDef,
   getInjectorDef,
   getNullInjector,
-  inject,
+  inject2 as inject,
   injectArgs,
   injectInjectorOnly,
   isInjectable,
@@ -2095,4 +2145,11 @@ export {
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.dev/license
  */
+/**
+ * @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
+ */
 //# sourceMappingURL=index.mjs.map