ember-source 7.2.0-beta.1 → 7.3.0-alpha.2

package/types/stable/@ember/renderer/index.d.ts

@@ -59,7 +59,7 @@ declare module '@ember/renderer' {
       @returns {Promise<void>} a promise which fulfills when rendering has completed
       @public
     */
-    export { renderSettled } from "@ember/-internals/glimmer/lib/renderer";
+    export { renderSettled } from "@ember/-internals/glimmer/lib/base-renderer";
     /**
      * Render a component into a DOM element.
      *
@@ -76,5 +76,5 @@ declare module '@ember/renderer' {
      * @param {Object} [options.args] Optionally pass args in to the component. These may be reactive as long as it is an object or object-like
      * @public
      */
-    export { renderComponent } from "@ember/-internals/glimmer/lib/renderer";
+    export { renderComponent } from "@ember/-internals/glimmer/lib/base-renderer";
 }

package/types/stable/@glimmer/tracking/index.d.ts

@@ -1,6 +1,7 @@
 declare module '@glimmer/tracking' {
     export { tracked } from "@ember/-internals/metal/lib/tracked";
     export { cached } from "@ember/-internals/metal/lib/cached";
+    export type { Reactive, ReadOnlyReactive, TrackedValue, } from "@glimmer/validator/lib/tracked-value";
     /**
       In order to tell Ember a value might change, we need to mark it as trackable.
       Trackable values are values that:
@@ -36,7 +37,7 @@ declare module '@glimmer/tracking' {
         plusOne() {
           this.count += 1;
         }
-        
+
         <template>
           <div>Count: {{this.count}}</div>
           <div>Times Ten: {{this.timesTen}}</div>
@@ -141,6 +142,74 @@ declare module '@glimmer/tracking' {
       });
       ```
 
+      Calling `tracked` with an initial value creates a standalone reactive
+      value, usable outside of classes:
+
+      ```js
+      import { tracked } from '@glimmer/tracking';
+
+      const count = tracked(0);
+
+      count.value;                // read the value, entangling with any tracking context
+      count.value = 1;            // write the value, notifying consumers
+      count.get();                // function shorthand for reading
+      count.set(2);               // function shorthand for writing
+      count.update((n) => n + 1); // write based on the current value, without entangling
+      count.freeze();             // prevent all future writes
+      ```
+
+      Reading `value` in a template (or in a getter used by a template) will
+      rerender just like a `@tracked` property:
+
+      ```gjs
+      import { tracked } from '@glimmer/tracking';
+      import { on } from '@ember/modifier';
+
+      const count = tracked(0);
+      const increment = () => count.value++;
+
+      <template>
+        Count is: {{count.value}}
+
+        <button {{on "click" increment}}>add one</button>
+      </template>
+      ```
+
+      This form accepts an options object containing an `equals` function, which
+      decides whether a written value should notify consumers (it defaults to
+      `Object.is`), and a `description` used for debugging:
+
+      ```js
+      const count = tracked(0, { equals: (a, b) => a === b });
+
+      count.value = 0; // does not notify consumers, the value did not change
+      ```
+
+      Note: when `tracked` is called with a single plain object whose keys are all
+      drawn from `value`, `initializer`, `equals`, and `description`, it is treated
+      as the configuration object for a decorator (or classic-class field), not as a
+      standalone value wrapping that object. To create a standalone reactive value
+      around such an object, pass it as an initial value and include a (possibly
+      empty) options argument: `tracked({ value: 5 }, {})`.
+
+      The `@tracked` decorator accepts the same options. By default, setting a
+      `@tracked` property always notifies consumers, even when setting the
+      property to the same value; passing `equals` opts in to equality-based
+      notification instead:
+
+      ```js
+      import { tracked } from '@glimmer/tracking';
+
+      class Counter {
+        @tracked({ equals: (a, b) => a === b }) count = 0;
+
+        noop = () => {
+          // does not notify consumers, the value did not change
+          this.count = this.count;
+        };
+      }
+      ```
+
       @method tracked
       @static
       @for @glimmer/tracking

package/types/stable/@glimmer/validator/index.d.ts

@@ -8,6 +8,7 @@ declare module '@glimmer/validator' {
     export { debug } from "@glimmer/validator/lib/debug";
     export { dirtyTagFor, tagFor, type TagMeta, tagMetaFor } from "@glimmer/validator/lib/meta";
     export { trackedData } from "@glimmer/validator/lib/tracked-data";
+    export { type Reactive, type ReadOnlyReactive, TrackedValue, trackedValue, } from "@glimmer/validator/lib/tracked-value";
     export { beginTrackFrame, beginUntrackFrame, type Cache, consumeTag, createCache, endTrackFrame, endUntrackFrame, getValue, isConst, isTracking, resetTracking, track, untrack, } from "@glimmer/validator/lib/tracking";
     export { ALLOW_CYCLES, bump, combine, COMPUTE, CONSTANT, CONSTANT_TAG, createTag, createUpdatableTag, CURRENT_TAG, CurrentTag, DIRTY_TAG as dirtyTag, INITIAL, isConstTag, type Revision, UPDATE_TAG as updateTag, validateTag, valueForTag, VOLATILE, VOLATILE_TAG, VolatileTag, } from "@glimmer/validator/lib/validators";
     export type { CombinatorTag, ConstantTag, DirtyableTag, Tag, UpdatableTag, } from "@glimmer/interfaces";

package/types/stable/@glimmer/validator/lib/tracked-value.d.ts

@@ -0,0 +1,58 @@
+declare module '@glimmer/validator/lib/tracked-value' {
+    import type { ReactiveOptions } from "@glimmer/validator/lib/collections/types";
+    /**
+     * A mutable reactive value.
+     *
+     * Reading `value` consumes the underlying tag (entangling with any active
+     * tracking frame), and writing `value` dirties it.
+     */
+    export interface Reactive<Value> {
+        value: Value;
+    }
+    /**
+     * A reactive value that can only be read.
+     */
+    export interface ReadOnlyReactive<Value> extends Reactive<Value> {
+        readonly value: Value;
+    }
+    export class TrackedValue<Value = unknown> implements Reactive<Value> {
+        #private;
+        constructor(value: Value, options: ReactiveOptions<Value>);
+        /**
+         * The underlying value.
+         *
+         * Reading entangles with the current tracking frame, and writing notifies
+         * consumers (unless the configured `equals` deems the new value equal to
+         * the current one).
+         */
+        get value(): Value;
+        set value(value: Value);
+        /**
+         * Function short-hand for reading `value`.
+         */
+        get: () => Value;
+        /**
+         * Function short-hand for assigning `value`.
+         *
+         * Returns `true` if the value changed (and consumers were notified),
+         * `false` if the new value was equal to the current one.
+         */
+        set: (value: Value) => boolean;
+        /**
+         * Update the value based on the current value, without consuming it.
+         */
+        update: (updater: (value: Value) => Value) => void;
+        /**
+         * Prevents further updates, making the TrackedValue behave as a
+         * ReadOnlyReactive.
+         */
+        freeze: () => void;
+    }
+    export function trackedValue<Value>(
+     value: Value,
+     options?: {
+         equals?: (a: Value, b: Value) => boolean;
+         description?: string;
+     }
+    ): TrackedValue<Value>;
+}