@tstdl/base 0.87.15 → 0.88.0-alpha2

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, {
-  SIGNAL: () => SIGNAL,
-  defaultEquals: () => defaultEquals,
-  isSignal: () => isSignal
-});
-module.exports = __toCommonJS(api_exports);
 /**
  * @license
  * Copyright Google LLC All Rights Reserved.
@@ -30,10 +5,30 @@ 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.
+ */
+export 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 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,54 +5,83 @@ 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 = Object.create(COMPUTED_NODE);
-  node.computation = computation;
-  options?.equal && (node.equal = options.equal);
-  const computed2 = () => {
-    (0, import_graph.producerUpdateValueVersion)(node);
-    (0, import_graph.producerAccessed)(node);
-    if (node.value === ERRORED) {
-      throw node.error;
-    }
-    return node.value;
-  };
-  computed2[import_api.SIGNAL] = node;
-  return computed2;
+import { SIGNAL, defaultEquals } from './api.js';
+import { REACTIVE_NODE, consumerAfterComputation, consumerBeforeComputation, producerAccessed, producerUpdateValueVersion } from './graph.js';
+/**
+ * Create a computed `Signal` which derives a reactive value from an expression.
+ */
+export function computed(computation, options) {
+    const node = Object.create(COMPUTED_NODE);
+    node.computation = computation;
+    options?.equal && (node.equal = options.equal);
+    const computed = () => {
+        // Check if the value needs updating before returning it.
+        producerUpdateValueVersion(node);
+        // Record that someone looked at this signal.
+        producerAccessed(node);
+        if (node.value === ERRORED) {
+            throw node.error;
+        }
+        return node.value;
+    };
+    computed[SIGNAL] = node;
+    return computed;
 }
-const UNSET = Symbol("UNSET");
-const COMPUTING = Symbol("COMPUTING");
-const ERRORED = Symbol("ERRORED");
+/**
+ * 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');
 const COMPUTED_NODE = {
-  ...import_graph.REACTIVE_NODE,
-  value: UNSET,
-  dirty: true,
-  error: null,
-  equal: import_api.defaultEquals,
-  producerMustRecompute(node) {
-    return node.value === UNSET || node.value === COMPUTING;
-  },
-  producerRecomputeValue(node) {
-    if (node.value === COMPUTING) {
-      throw new Error("Detected cycle in computations.");
-    }
-    const oldValue = node.value;
-    node.value = COMPUTING;
-    const prevConsumer = (0, import_graph.consumerBeforeComputation)(node);
-    let newValue;
-    try {
-      newValue = node.computation();
-    } catch (err) {
-      newValue = ERRORED;
-      node.error = err;
-    } finally {
-      (0, import_graph.consumerAfterComputation)(node, prevConsumer);
-    }
-    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && node.equal(oldValue, newValue)) {
-      node.value = oldValue;
-      return;
-    }
-    node.value = newValue;
-    node.version++;
-  }
+    ...REACTIVE_NODE,
+    value: UNSET,
+    dirty: true,
+    error: null,
+    equal: defaultEquals,
+    producerMustRecompute(node) {
+        // Force a recomputation if there's no current value, or if the current value is in the process
+        // of being calculated (which should throw an error).
+        return node.value === UNSET || node.value === COMPUTING;
+    },
+    producerRecomputeValue(node) {
+        if (node.value === COMPUTING) {
+            // Our computation somehow led to a cyclic read of itself.
+            throw new Error('Detected cycle in computations.');
+        }
+        const oldValue = node.value;
+        node.value = COMPUTING;
+        const prevConsumer = consumerBeforeComputation(node);
+        let newValue;
+        try {
+            newValue = node.computation();
+        }
+        catch (err) {
+            newValue = ERRORED;
+            node.error = err;
+        }
+        finally {
+            consumerAfterComputation(node, prevConsumer);
+        }
+        if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED &&
+            node.equal(oldValue, newValue)) {
+            // No change to `valueVersion` - old and new values are
+            // semantically equivalent.
+            node.value = oldValue;
+            return;
+        }
+        node.value = newValue;
+        node.version++;
+    },
 };

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,57 @@ 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) {
-    const w = (0, import_watch.watch)(effectFn, () => {
-      if (!this.all.has(w)) {
-        return;
-      }
-      this.queue.add(w);
-      if (!this.pendingFlush) {
-        this.pendingFlush = true;
-        queueMicrotask(() => {
-          this.pendingFlush = false;
-          this.flush();
-        });
-      }
-    }, allowSignalWrites);
-    this.all.add(w);
-    w.notify();
-    const destroy = () => {
-      w.cleanup();
-      this.all.delete(w);
-      this.queue.delete(w);
-    };
-    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) {
+        const w = watch(effectFn, () => {
+            if (!this.all.has(w)) {
+                return;
+            }
+            this.queue.add(w);
+            if (!this.pendingFlush) {
+                this.pendingFlush = true;
+                queueMicrotask(() => {
+                    this.pendingFlush = false;
+                    this.flush();
+                });
+            }
+        }, allowSignalWrites);
+        this.all.add(w);
+        // Effects start dirty.
+        w.notify();
+        const destroy = () => {
+            w.cleanup();
+            this.all.delete(w);
+            this.queue.delete(w);
+        };
+        return {
+            destroy
+        };
+    }
+    flush() {
+        if (this.queue.size === 0) {
+            return;
+        }
+        for (const w of this.queue) {
+            this.queue.delete(w);
+            w.run();
+        }
     }
-    for (const w of this.queue) {
-      this.queue.delete(w);
-      w.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?.allowSignalWrites ?? false);
+/**
+ * Create a global `Effect` for the given reactive function.
+ */
+export function effect(effectFn, options) {
+    return effectManager.create(effectFn, options?.allowSignalWrites ?? false);
 }

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;
 }