@tstdl/base 0.85.13 → 0.86.0-beta1

package/signals/computed-with-dependencies.js

@@ -1,33 +1,10 @@
-"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 computed_with_dependencies_exports = {};
-__export(computed_with_dependencies_exports, {
-  computedWithDependencies: () => computedWithDependencies
-});
-module.exports = __toCommonJS(computed_with_dependencies_exports);
-var import_api = require("./api.js");
-function computedWithDependencies(computation, dependencies, options = {}) {
-  function computationWithDependencies() {
-    for (let i = 0; i < dependencies.length; i++) {
-      dependencies[i]();
+import { computed as actualComputed } from './api.js';
+export function computedWithDependencies(computation, dependencies, options = {}) {
+    function computationWithDependencies() {
+        for (let i = 0; i < dependencies.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
+            dependencies[i]();
+        }
+        return computation();
     }
-    return computation();
-  }
-  return (0, import_api.computed)(dependencies.length == 0 ? computation : computationWithDependencies, options);
+    return actualComputed((dependencies.length == 0) ? computation : computationWithDependencies, options);
 }

package/signals/effect-with-dependencies.js

@@ -1,33 +1,10 @@
-"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 effect_with_dependencies_exports = {};
-__export(effect_with_dependencies_exports, {
-  effectWithDependencies: () => effectWithDependencies
-});
-module.exports = __toCommonJS(effect_with_dependencies_exports);
-var import_api = require("./api.js");
-function effectWithDependencies(effectFn, dependencies, options) {
-  function effectFnWithDependencies(onCleanup) {
-    for (let i = 0; i < dependencies.length; i++) {
-      dependencies[i]();
+import { effect as actualEffect } from './api.js';
+export function effectWithDependencies(effectFn, dependencies, options) {
+    function effectFnWithDependencies(onCleanup) {
+        for (let i = 0; i < dependencies.length; i++) { // eslint-disable-line @typescript-eslint/prefer-for-of
+            dependencies[i]();
+        }
+        effectFn(onCleanup);
     }
-    effectFn(onCleanup);
-  }
-  return (0, import_api.effect)(dependencies.length == 0 ? effectFn : effectFnWithDependencies, options);
+    return actualEffect((dependencies.length == 0) ? effectFn : effectFnWithDependencies, options);
 }

package/signals/implementation/api.js

@@ -1,28 +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 api_exports = {};
-__export(api_exports, {
-  createSignalFromFunction: () => createSignalFromFunction,
-  defaultEquals: () => defaultEquals,
-  isSignal: () => isSignal
-});
-module.exports = __toCommonJS(api_exports);
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -30,14 +5,39 @@ module.exports = __toCommonJS(api_exports);
  * 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 SIGNAL = Symbol("SIGNAL");
-function isSignal(value) {
-  return typeof value === "function" && value[SIGNAL] !== void 0;
+/**
+ * Symbol used to tell `Signal`s apart from other functions.
+ *
+ * This can be used to auto-unwrap signals in various cases, or to auto-wrap non-signal values.
+ */
+const SIGNAL = Symbol('SIGNAL');
+/**
+ * Checks if the given `value` is a reactive `Signal`.
+ */
+export function isSignal(value) {
+    return typeof value === 'function' && value[SIGNAL] !== undefined;
 }
-function createSignalFromFunction(node, fn, extraApi = {}) {
-  fn[SIGNAL] = node;
-  return Object.assign(fn, extraApi);
+/**
+ * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`), and
+ * potentially add some set of extra properties (passed as an object record `extraApi`).
+ */
+export function createSignalFromFunction(node, fn, extraApi = {}) {
+    fn[SIGNAL] = node;
+    // Copy properties from `extraApi` to `fn` to complete the desired API of the `Signal`.
+    return Object.assign(fn, extraApi);
 }
-function defaultEquals(a, b) {
-  return (a === null || typeof a !== "object") && Object.is(a, b);
+/**
+ * The default equality function used for `signal` and `computed`, which treats objects and arrays
+ * as never equal, and all other primitive values using identity semantics.
+ *
+ * This allows signals to hold non-primitive values (arrays, objects, other collections) and still
+ * propagate change notification upon explicit mutation without identity change.
+ */
+export function defaultEquals(a, b) {
+    // `Object.is` compares two values using identity semantics which is desired behavior for
+    // primitive values. If `Object.is` determines two values to be equal we need to make sure that
+    // those don't represent objects (we want to make sure that 2 objects are always considered
+    // "unequal"). The null check is needed for the special case of JavaScript reporting null values
+    // as objects (`typeof null === 'object'`).
+    return (a === null || typeof a !== 'object') && Object.is(a, b);
 }

package/signals/implementation/computed.js

@@ -1,28 +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 computed_exports = {};
-__export(computed_exports, {
-  computed: () => computed
-});
-module.exports = __toCommonJS(computed_exports);
-var import_api = require("./api.js");
-var import_graph = require("./graph.js");
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -30,89 +5,135 @@ 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 computed(computation, options) {
-  const node = new ComputedImpl(computation, options?.equal ?? import_api.defaultEquals);
-  return (0, import_api.createSignalFromFunction)(node, node.signal.bind(node));
+import { createSignalFromFunction, defaultEquals } from './api.js';
+import { ReactiveNode, setActiveConsumer } from './graph.js';
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ */
+export function computed(computation, options) {
+    const node = new ComputedImpl(computation, options?.equal ?? defaultEquals);
+    // Casting here is required for g3, as TS inference behavior is slightly different between our
+    // version/options and g3's.
+    return createSignalFromFunction(node, node.signal.bind(node));
 }
-const UNSET = Symbol("UNSET");
-const COMPUTING = Symbol("COMPUTING");
-const ERRORED = Symbol("ERRORED");
-class ComputedImpl extends import_graph.ReactiveNode {
-  computation;
-  equal;
-  constructor(computation, equal) {
-    super();
-    this.computation = computation;
-    this.equal = equal;
-  }
-  /**
-   * Current value of the computation.
-   *
-   * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.
-   */
-  value = UNSET;
-  /**
-   * If `value` is `ERRORED`, the error caught from the last computation attempt which will
-   * be re-thrown.
-   */
-  error = null;
-  /**
-   * Flag indicating that the computation is currently stale, meaning that one of the
-   * dependencies has notified of a potential change.
-   *
-   * It's possible that no dependency has _actually_ changed, in which case the `stale`
-   * state can be resolved without recomputing the value.
-   */
-  stale = true;
-  consumerAllowSignalWrites = false;
-  onConsumerDependencyMayHaveChanged() {
-    if (this.stale) {
-      return;
-    }
-    this.stale = true;
-    this.producerMayHaveChanged();
-  }
-  onProducerUpdateValueVersion() {
-    if (!this.stale) {
-      return;
-    }
-    if (this.value !== UNSET && this.value !== COMPUTING && !this.consumerPollProducersForChange()) {
-      this.stale = false;
-      return;
+/**
+ * A dedicated symbol used before a computed value has been calculated for the first time.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const UNSET = Symbol('UNSET');
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * is in progress. Used to detect cycles in computation chains.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const COMPUTING = Symbol('COMPUTING');
+/**
+ * A dedicated symbol used in place of a computed signal value to indicate that a given computation
+ * failed. The thrown error is cached until the computation gets dirty again.
+ * Explicitly typed as `any` so we can use it as signal's value.
+ */
+const ERRORED = Symbol('ERRORED');
+/**
+ * A computation, which derives a value from a declarative reactive expression.
+ *
+ * `Computed`s are both producers and consumers of reactivity.
+ */
+class ComputedImpl extends ReactiveNode {
+    computation;
+    equal;
+    constructor(computation, equal) {
+        super();
+        this.computation = computation;
+        this.equal = equal;
     }
-    this.recomputeValue();
-  }
-  recomputeValue() {
-    if (this.value === COMPUTING) {
-      throw new Error("Detected cycle in computations.");
+    /**
+     * Current value of the computation.
+     *
+     * This can also be one of the special values `UNSET`, `COMPUTING`, or `ERRORED`.
+     */
+    value = UNSET;
+    /**
+     * If `value` is `ERRORED`, the error caught from the last computation attempt which will
+     * be re-thrown.
+     */
+    error = null;
+    /**
+     * Flag indicating that the computation is currently stale, meaning that one of the
+     * dependencies has notified of a potential change.
+     *
+     * It's possible that no dependency has _actually_ changed, in which case the `stale`
+     * state can be resolved without recomputing the value.
+     */
+    stale = true;
+    consumerAllowSignalWrites = false;
+    onConsumerDependencyMayHaveChanged() {
+        if (this.stale) {
+            // We've already notified consumers that this value has potentially changed.
+            return;
+        }
+        // Record that the currently cached value may be stale.
+        this.stale = true;
+        // Notify any consumers about the potential change.
+        this.producerMayHaveChanged();
     }
-    const oldValue = this.value;
-    this.value = COMPUTING;
-    this.trackingVersion++;
-    const prevConsumer = (0, import_graph.setActiveConsumer)(this);
-    let newValue;
-    try {
-      newValue = this.computation();
-    } catch (err) {
-      newValue = ERRORED;
-      this.error = err;
-    } finally {
-      (0, import_graph.setActiveConsumer)(prevConsumer);
+    onProducerUpdateValueVersion() {
+        if (!this.stale) {
+            // The current value and its version are already up to date.
+            return;
+        }
+        // The current value is stale. Check whether we need to produce a new one.
+        if (this.value !== UNSET && this.value !== COMPUTING &&
+            !this.consumerPollProducersForChange()) {
+            // Even though we were previously notified of a potential dependency update, all of
+            // our dependencies report that they have not actually changed in value, so we can
+            // resolve the stale state without needing to recompute the current value.
+            this.stale = false;
+            return;
+        }
+        // The current value is stale, and needs to be recomputed. It still may not change -
+        // that depends on whether the newly computed value is equal to the old.
+        this.recomputeValue();
     }
-    this.stale = false;
-    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && this.equal(oldValue, newValue)) {
-      this.value = oldValue;
-      return;
+    recomputeValue() {
+        if (this.value === COMPUTING) {
+            // Our computation somehow led to a cyclic read of itself.
+            throw new Error('Detected cycle in computations.');
+        }
+        const oldValue = this.value;
+        this.value = COMPUTING;
+        // As we're re-running the computation, update our dependent tracking version number.
+        this.trackingVersion++;
+        const prevConsumer = setActiveConsumer(this);
+        let newValue;
+        try {
+            newValue = this.computation();
+        }
+        catch (err) {
+            newValue = ERRORED;
+            this.error = err;
+        }
+        finally {
+            setActiveConsumer(prevConsumer);
+        }
+        this.stale = false;
+        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+            this.equal(oldValue, newValue)) {
+            // No change to `valueVersion` - old and new values are
+            // semantically equivalent.
+            this.value = oldValue;
+            return;
+        }
+        this.value = newValue;
+        this.valueVersion++;
     }
-    this.value = newValue;
-    this.valueVersion++;
-  }
-  signal() {
-    this.onProducerUpdateValueVersion();
-    this.producerAccessed();
-    if (this.value === ERRORED) {
-      throw this.error;
+    signal() {
+        // Check if the value needs updating before returning it.
+        this.onProducerUpdateValueVersion();
+        // Record that someone looked at this signal.
+        this.producerAccessed();
+        if (this.value === ERRORED) {
+            throw this.error;
+        }
+        return this.value;
     }
-    return this.value;
-  }
 }

package/signals/implementation/configure.js

@@ -1,42 +1,19 @@
-"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 configure_exports = {};
-__export(configure_exports, {
-  configureDefaultSignalsImplementation: () => configureDefaultSignalsImplementation
-});
-module.exports = __toCommonJS(configure_exports);
-var import_api = require("../api.js");
-var import_api2 = require("./api.js");
-var import_computed = require("./computed.js");
-var import_effect = require("./effect.js");
-var import_signal = require("./signal.js");
-var import_to_observable = require("./to-observable.js");
-var import_to_signal = require("./to-signal.js");
-var import_untracked = require("./untracked.js");
-function configureDefaultSignalsImplementation() {
-  (0, import_api.configureSignals)({
-    signal: import_signal.signal,
-    computed: import_computed.computed,
-    effect: import_effect.effect,
-    untracked: import_untracked.untracked,
-    isSignal: import_api2.isSignal,
-    toSignal: import_to_signal.toSignal,
-    toObservable: import_to_observable.toObservable
-  });
+import { configureSignals } from '../api.js';
+import { isSignal } from './api.js';
+import { computed } from './computed.js';
+import { effect } from './effect.js';
+import { signal } from './signal.js';
+import { toObservable } from './to-observable.js';
+import { toSignal } from './to-signal.js';
+import { untracked } from './untracked.js';
+export function configureDefaultSignalsImplementation() {
+    configureSignals({
+        signal,
+        computed,
+        effect,
+        untracked,
+        isSignal,
+        toSignal,
+        toObservable
+    });
 }

package/signals/implementation/effect.js

@@ -1,28 +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 effect_exports = {};
-__export(effect_exports, {
-  EffectManager: () => EffectManager,
-  effect: () => effect
-});
-module.exports = __toCommonJS(effect_exports);
-var import_watch = require("./watch.js");
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -30,49 +5,56 @@ var import_watch = require("./watch.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
  */
-class EffectManager {
-  all = /* @__PURE__ */ new Set();
-  queue = /* @__PURE__ */ new Set();
-  pendingFlush;
-  create(effectFn, { allowSignalWrites = false } = {}) {
-    const watch = new import_watch.Watch(effectFn, (watch2) => {
-      if (!this.all.has(watch2)) {
-        return;
-      }
-      this.queue.add(watch2);
-      if (!this.pendingFlush) {
-        this.pendingFlush = true;
-        queueMicrotask(() => {
-          this.pendingFlush = false;
-          this.flush();
-        });
-      }
-    }, allowSignalWrites);
-    this.all.add(watch);
-    watch.notify();
-    const destroy = () => {
-      watch.cleanup();
-      this.all.delete(watch);
-      this.queue.delete(watch);
-    };
-    return {
-      destroy
-    };
-  }
-  flush() {
-    if (this.queue.size == 0) {
-      return;
+import { Watch } from './watch.js';
+/**
+ * Tracks all effects registered within a given application and runs them via `flush`.
+ */
+export class EffectManager {
+    all = new Set();
+    queue = new Set();
+    pendingFlush;
+    create(effectFn, { allowSignalWrites = false } = {}) {
+        const watch = new Watch(effectFn, (watch) => {
+            if (!this.all.has(watch)) {
+                return;
+            }
+            this.queue.add(watch);
+            if (!this.pendingFlush) {
+                this.pendingFlush = true;
+                queueMicrotask(() => {
+                    this.pendingFlush = false;
+                    this.flush();
+                });
+            }
+        }, allowSignalWrites);
+        this.all.add(watch);
+        watch.notify();
+        const destroy = () => {
+            watch.cleanup();
+            this.all.delete(watch);
+            this.queue.delete(watch);
+        };
+        return {
+            destroy
+        };
+    }
+    flush() {
+        if (this.queue.size == 0) {
+            return;
+        }
+        for (const watch of this.queue) {
+            this.queue.delete(watch);
+            watch.run();
+        }
     }
-    for (const watch of this.queue) {
-      this.queue.delete(watch);
-      watch.run();
+    get isQueueEmpty() {
+        return this.queue.size === 0;
     }
-  }
-  get isQueueEmpty() {
-    return this.queue.size === 0;
-  }
 }
 const effectManager = new EffectManager();
-function effect(effectFn, options) {
-  return effectManager.create(effectFn, options);
+/**
+ * Create a global `Effect` for the given reactive function.
+ */
+export function effect(effectFn, options) {
+    return effectManager.create(effectFn, options);
 }

package/signals/implementation/errors.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 errors_exports = {};
-__export(errors_exports, {
-  setThrowInvalidWriteToSignalError: () => setThrowInvalidWriteToSignalError,
-  throwInvalidWriteToSignalError: () => throwInvalidWriteToSignalError
-});
-module.exports = __toCommonJS(errors_exports);
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -30,12 +6,12 @@ module.exports = __toCommonJS(errors_exports);
  * found in the LICENSE file at https://angular.io/license
  */
 function defaultThrowError() {
-  throw new Error();
+    throw new Error();
 }
 let throwInvalidWriteToSignalErrorFn = defaultThrowError;
-function throwInvalidWriteToSignalError() {
-  throwInvalidWriteToSignalErrorFn();
+export function throwInvalidWriteToSignalError() {
+    throwInvalidWriteToSignalErrorFn();
 }
-function setThrowInvalidWriteToSignalError(fn) {
-  throwInvalidWriteToSignalErrorFn = fn;
+export function setThrowInvalidWriteToSignalError(fn) {
+    throwInvalidWriteToSignalErrorFn = fn;
 }