@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/signals/computed-with-dependencies.js

@@ -1,10 +1,33 @@
-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();
+"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]();
     }
-    return actualComputed((dependencies.length == 0) ? computation : computationWithDependencies, options);
+    return computation();
+  }
+  return (0, import_api.computed)(dependencies.length == 0 ? computation : computationWithDependencies, options);
 }

package/signals/effect-with-dependencies.js

@@ -1,10 +1,33 @@
-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);
+"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]();
     }
-    return actualEffect((dependencies.length == 0) ? effectFn : effectFnWithDependencies, options);
+    effectFn(onCleanup);
+  }
+  return (0, import_api.effect)(dependencies.length == 0 ? effectFn : effectFnWithDependencies, options);
 }

package/signals/implementation/api.js

@@ -1,3 +1,28 @@
+"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.
@@ -5,39 +30,14 @@
  * 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
  */
-/**
- * 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;
+const SIGNAL = Symbol("SIGNAL");
+function isSignal(value) {
+  return typeof value === "function" && value[SIGNAL] !== void 0;
 }
-/**
- * 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 createSignalFromFunction(node, fn, extraApi = {}) {
+  fn[SIGNAL] = node;
+  return Object.assign(fn, extraApi);
 }
-/**
- * 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);
+function defaultEquals(a, b) {
+  return (a === null || typeof a !== "object") && Object.is(a, b);
 }

package/signals/implementation/computed.js

@@ -1,3 +1,28 @@
+"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.
@@ -5,135 +30,89 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { 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));
+function computed(computation, options) {
+  const node = new ComputedImpl(computation, options?.equal ?? import_api.defaultEquals);
+  return (0, import_api.createSignalFromFunction)(node, node.signal.bind(node));
 }
-/**
- * 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;
+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;
     }
-    /**
-     * 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();
+    this.recomputeValue();
+  }
+  recomputeValue() {
+    if (this.value === COMPUTING) {
+      throw new Error("Detected cycle in computations.");
     }
-    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();
+    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);
     }
-    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.stale = false;
+    if (oldValue !== UNSET && oldValue !== ERRORED && newValue !== ERRORED && this.equal(oldValue, newValue)) {
+      this.value = oldValue;
+      return;
     }
-    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;
+    this.value = newValue;
+    this.valueVersion++;
+  }
+  signal() {
+    this.onProducerUpdateValueVersion();
+    this.producerAccessed();
+    if (this.value === ERRORED) {
+      throw this.error;
     }
+    return this.value;
+  }
 }

package/signals/implementation/configure.js

@@ -1,19 +1,42 @@
-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
-    });
+"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
+  });
 }

package/signals/implementation/effect.js

@@ -1,3 +1,28 @@
+"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.
@@ -5,56 +30,49 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
-import { 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();
-        }
+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;
     }
-    get isQueueEmpty() {
-        return this.queue.size === 0;
+    for (const watch of this.queue) {
+      this.queue.delete(watch);
+      watch.run();
     }
+  }
+  get isQueueEmpty() {
+    return this.queue.size === 0;
+  }
 }
 const effectManager = new EffectManager();
-/**
- * Create a global `Effect` for the given reactive function.
- */
-export function effect(effectFn, options) {
-    return effectManager.create(effectFn, options);
+function effect(effectFn, options) {
+  return effectManager.create(effectFn, options);
 }

package/signals/implementation/errors.js

@@ -1,3 +1,27 @@
+"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.
@@ -6,12 +30,12 @@
  * found in the LICENSE file at https://angular.io/license
  */
 function defaultThrowError() {
-    throw new Error();
+  throw new Error();
 }
 let throwInvalidWriteToSignalErrorFn = defaultThrowError;
-export function throwInvalidWriteToSignalError() {
-    throwInvalidWriteToSignalErrorFn();
+function throwInvalidWriteToSignalError() {
+  throwInvalidWriteToSignalErrorFn();
 }
-export function setThrowInvalidWriteToSignalError(fn) {
-    throwInvalidWriteToSignalErrorFn = fn;
+function setThrowInvalidWriteToSignalError(fn) {
+  throwInvalidWriteToSignalErrorFn = fn;
 }