@fluidframework/counter 1.2.7 → 2.0.0-dev.1.3.0.96595

package/.mocharc.js

@@ -0,0 +1,12 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+const getFluidTestMochaConfig = require('@fluidframework/mocha-test-setup/mocharc-common');
+
+const packageDir = __dirname;
+const config = getFluidTestMochaConfig(packageDir);
+module.exports = config;

package/README.md

@@ -1,3 +1,161 @@
 # @fluidframework/counter
 
-Documentation available at https://fluidframework.com/docs/apis/counter/.
+## Introduction
+
+The `SharedCounter` distributed data structure (DDS) is used to store an integer counter value that can be modified by multiple clients simultaneously.
+The data structure affords incrementing and decrementing the shared value via its `increment` method. Decrements are done by providing a negative value.
+
+The `SharedCounter` is a specialized [Optimistic DDS][].
+It operates on communicated _deltas_ (amounts by which the shared value should be incremented or decremented), rather than direct changes to the shared value.
+In this way, it avoids the pitfalls of DDSes with simpler merge strategies, in which one user's edit may clobber another's (see [below](#why-a-specialized-dds)).
+
+Note that the `SharedCounter` only operates on integer values.
+
+### Why a specialized DDS?
+
+You may be asking yourself, why not just store the shared integer value directly in another DDS like a [SharedMap][]?
+Why incur the overhead of another runtime type?
+
+The key to the answer here is that DDSes with simpler merge strategies (like `SharedMap`) take a somewhat brute-force approach to merging concurrent edits.
+For a semantic data type like a counter, this can result in undesirable behavior.
+
+#### SharedMap Example
+
+Let's illustrate the issue with an example.
+
+Consider a polling widget.
+The widget displays a list of options and allows users to click a checkbox to vote for a given option.
+Next to each option in the list, a live counter is displayed that shows the number of votes for that item.
+
+Whenever a user checks an option, all users should see the counter corresponding to that option increment by 1.
+
+In this example, the application is storing its vote counts in a [SharedMap][], where the map keys are `strings` representing the IDs of the options, and the values are `numbers` representing the associated vote counts.
+
+For simplicity, we will look at a scenario in which 2 users vote for the same option at around the same time.
+
+Specifically, **User A** clicks the checkbox for option **Foo**, which currently has **0** votes.
+The application then optimistically updates the vote count for that object by writing the updated counter value of **1** for option **Foo** to its `SharedMap`.
+
+The value change operation (op) is then transmitted to the service to be sequenced and eventually sent to other users in the collaborative session.
+
+At around the same time, **User B** clicks the checkbox for option **Foo**, which in their view currently has **0** votes.
+Similarly to before, the application optimistically updates the associated counter value to **1**, and transmits its own update op.
+
+The service receives the op from **User A** first, and sequences their op updating **Foo** to **1** as **op 0**. **User B**'s op is received second, and is sequenced as **op 1**.
+
+Both users then receive acknowledgement of their update, and receive **op 0** and **op 1** to be applied in order.
+Both clients apply **op 0** by setting **Foo** to **1**.
+Then both clients apply **op 1** by setting **Foo** to **1**.
+
+But this isn't right.
+Two different users voted for option **Foo**, but the counter now displays **1**.
+
+`SharedCounter` solves this problem by expressing its operations in terms of *increments* and *decrements* rather than as direct value updates.
+
+So for the scenario above, if the system was using `SharedCounter`s to represent the vote counts, **User A** would submit an op *incrementing* **Foo** by **+1**, rather than updating the value of **Foo** from **0** to **1**.
+At around the same time, **User B** would submit their own **+1** op for **Foo**.
+
+Assuming the same sequencing, both users first apply **op 0** and increment their counter for **Foo** by **+1** (from **0** to **1**).
+Next, they both apply **op 1** and increment their counter for **Foo** by **+1** a second time (from **1** to **2**).
+
+Now both users see the right vote count for `Foo`!
+
+## Usage
+
+The `SharedCounter` object provides a simple API surface for managing a shared integer whose value may be incremented and decremented by collaborators.
+
+A new `SharedCounter` value will be initialized with its value set to `0`.
+If you wish to initialize the counter to a different value, you may [modify the value](#incrementing--decrementing-the-value) before attaching the container, or before storing it in another shared object like a `SharedMap`.
+
+## Installation
+
+The package containing the `SharedCounter` library is [@fluidframework/shared-counter](https://www.npmjs.com/package/@fluidframework/counter).
+
+To get started, run the following from a terminal in your repository:
+
+```bash
+npm install @fluidframework/shared-counter
+```
+
+### Creation
+
+The workflow for creating a `SharedCounter` is effectively the same as many of our other DDSes.
+For an example of how to create one, please see our workflow examples for [SharedMap creation][].
+
+### Incrementing / decrementing the value
+
+Once you have created your `SharedCounter`, you can change its value using the [increment][] method.
+This method accepts a positive or negative *integer* to be applied to the shared value.
+
+
+```javascript
+sharedCounter.increment(3); // Adds 3 to the current value
+sharedCounter.increment(-5); // Subtracts 5 from the current value
+```
+
+### `incremented` event
+
+The [incremented][] event is sent when a client in the collaborative session changes the counter value via the `increment` method.
+
+Signature:
+
+```javascript
+(event: "incremented", listener: (incrementAmount: number, newValue: number) => void)
+```
+
+By listening to this event, you can receive and apply the changes coming from other collaborators.
+Consider the following code example for configuring a Counter widget:
+
+```javascript
+const sharedCounter = container.initialObjects.sharedCounter;
+let counterValue = sharedCounter.value;
+
+const incrementButton = document.createElement('button');
+button.textContent = "Increment";
+const decrementButton = document.createElement('button');
+button.textContent = "Decrement";
+
+// Increment / decrement shared counter value when the corresponding button is clicked
+incrementButton.addEventListener('click', () => sharedCounter.increment(1));
+decrementButton.addEventListener('click', () => sharedCounter.increment(-1));
+
+const counterValueLabel = document.createElement('label');
+counterValueLabel.textContent = `${counterValue}`;
+
+// This function will be called each time the shared counter value is incremented
+// (including increments from this client).
+// Update the local counter value and the corresponding label being displayed in the widget.
+const updateCounterValueLabel = (delta) => {
+    counterValue += delta;
+    counterValueLabel.textContent = `${counterValue}`;
+};
+
+// Register to be notified when the counter is incremented
+sharedCounter.on("incremented", updateCounterValueLabel);
+```
+
+In the code above, whenever a user presses either the Increment or Decrement button, the `sharedCounter.increment` is called with +/- 1.
+This causes the `incremented` event to be sent to all of the clients who have this container open.
+
+Since `updateCounterValueLabel` is listening for all `incremented` events, the view will always refresh with the appropriate updated value any time a collaborator increments or decrements the counter value.
+
+<!-- AUTO-GENERATED-CONTENT:START (README_API_DOCS_SECTION:includeHeading=TRUE) -->
+## API Documentation
+
+API documentation for **@fluidframework/counter** is available at <https://fluidframework.com/docs/apis/counter>.
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+<!-- AUTO-GENERATED-CONTENT:START (README_TRADEMARK_SECTION:includeHeading=TRUE) -->
+## Trademark
+
+This project may contain Microsoft trademarks or logos for Microsoft projects, products, or services.
+Use of these trademarks or logos must follow Microsoft's [Trademark & Brand Guidelines](https://www.microsoft.com/en-us/legal/intellectualproperty/trademarks/usage/general).
+Use of Microsoft trademarks or logos in modified versions of this project must not cause confusion or imply Microsoft sponsorship.
+<!-- AUTO-GENERATED-CONTENT:END -->
+
+<!-- Links -->
+[increment]: https://fluidframework.com/docs/apis/counter/isharedcounter-interface#increment-methodsignature
+[incremented]: https://fluidframework.com/docs/apis/counter/isharedcounterevents-interface#_call_-callsignature
+[Optimistic DDS]: https://fluidframework.com/docs/build/dds/#optimistic-data-structures
+[SharedMap]: https://fluidframework.com/docs/data-structures/map
+[SharedMap creation]: https://fluidframework.com/docs/data-structures/map/#creation

package/api-extractor.json

@@ -1,4 +1,4 @@
 {
   "$schema": "https://developer.microsoft.com/json-schemas/api-extractor/v7/api-extractor.schema.json",
-  "extends": "@fluidframework/build-common/api-extractor-common-report.json"
+  "extends": "@fluidframework/build-common/api-extractor-common-strict.json"
 }

package/dist/counter.d.ts

@@ -8,48 +8,58 @@ import { ISummaryTreeWithStats } from "@fluidframework/runtime-definitions";
 import { IFluidSerializer, SharedObject } from "@fluidframework/shared-object-base";
 import { ISharedCounter, ISharedCounterEvents } from "./interfaces";
 /**
- * A `SharedCounter` is a shared object which holds a number that can be incremented or decremented.
- * @public
+ * A shared object that holds a number that can be incremented or decremented.
+ *
+ * @remarks Note that `SharedCounter` only operates on integer values. This is validated at runtime.
  *
- * @remarks
- * ### Creation
+ * @example Creating a `SharedCounter`:
  *
- * To create a `SharedCounter`, get the factory and call create with a runtime and string ID:
+ * First, get the factory and call {@link @fluidframework/datastore-definitions#IChannelFactory.create}
+ * with a runtime and string ID:
  *
  * ```typescript
  * const factory = SharedCounter.getFactory();
  * const counter = factory.create(this.runtime, id) as SharedCounter;
  * ```
  *
- * ### Usage
+ * The initial value of a new `SharedCounter` is 0.
+ * If you wish to initialize the counter to a different value, you may call {@link SharedCounter.increment} before
+ * attaching the Container, or before inserting it into an existing shared object.
+ *
+ * @example Using the `SharedCounter`:
  *
- * Once created, you can call `increment` to modify the value with either a positive or negative number:
+ * Once created, you can call {@link SharedCounter.increment} to modify the value with either a positive or
+ * negative number:
  *
  * ```typescript
  * counter.increment(10); // add 10 to the counter value
  * counter.increment(-5); // subtract 5 from the counter value
  * ```
  *
- * To observe changes to the value (including those from remote clients), register for the `"incremented"` event:
+ * To observe changes to the value (including those from remote clients), register for the
+ * {@link ISharedCounterEvents | incremented} event:
  *
  * ```typescript
  * counter.on("incremented", (incrementAmount, newValue) => {
  *     console.log(`The counter incremented by ${incrementAmount} and now has a value of ${newValue}`);
  * });
  * ```
+ *
+ * @public
  */
 export declare class SharedCounter extends SharedObject<ISharedCounterEvents> implements ISharedCounter {
     /**
-     * Create a new shared counter
+     * Create a new {@link SharedCounter}.
+     *
+     * @param runtime - The data store runtime to which the new `SharedCounter` will belong.
+     * @param id - Optional name of the `SharedCounter`. If not provided, one will be generated.
      *
-     * @param runtime - data store runtime the new shared counter belongs to
-     * @param id - optional name of the shared counter
      * @returns newly create shared counter (but not attached yet)
      */
     static create(runtime: IFluidDataStoreRuntime, id?: string): SharedCounter;
     constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes);
     /**
-     * Get a factory for SharedCounter to register with the data store.
+     * Get a factory for {@link SharedCounter} to register with the data store.
      *
      * @returns a factory that creates and load SharedCounter
      */
@@ -65,34 +75,39 @@ export declare class SharedCounter extends SharedObject<ISharedCounterEvents> im
     increment(incrementAmount: number): void;
     private incrementCore;
     /**
-     * Create a summary for the counter
+     * Create a summary for the counter.
+     *
+     * @returns The summary of the current state of the counter.
      *
-     * @returns the summary of the current state of the counter
      * @internal
      */
     protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats;
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     *
      * @internal
      */
     protected loadCore(storage: IChannelStorageService): Promise<void>;
     /**
      * Called when the object has disconnected from the delta stream.
+     *
      * @internal
      */
     protected onDisconnect(): void;
     /**
-     * Process a counter operation
+     * Process a counter operation (op).
      *
-     * @param message - the message to prepare
-     * @param local - whether the message was sent by the local client
+     * @param message - The message to prepare.
+     * @param local - Whether or not the message was sent by the local client.
      * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
-     * For messages from a remote client, this will be undefined.
+     * For messages from a remote client, this will be `undefined`.
+     *
      * @internal
      */
     protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void;
     /**
      * Not implemented.
+     *
      * @internal
      */
     protected applyStashedOp(): void;

package/dist/counter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"counter.d.ts","sourceRoot":"","sources":["../src/counter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,yBAAyB,EAAe,MAAM,sCAAsC,CAAC;AAC9F,OAAO,EACH,sBAAsB,EACtB,sBAAsB,EACtB,eAAe,EACf,kBAAkB,EACrB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAA2B,gBAAgB,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAE7G,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAoBpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,qBAAa,aAAc,SAAQ,YAAY,CAAC,oBAAoB,CAAE,YAAW,cAAc;IAC3F;;;;;;OAMG;WACW,MAAM,CAAC,OAAO,EAAE,sBAAsB,EAAE,EAAE,CAAC,EAAE,MAAM;gBAIrD,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,EAAE,UAAU,EAAE,kBAAkB;IAIvF;;;;OAIG;WACW,UAAU,IAAI,eAAe;IAI3C,OAAO,CAAC,MAAM,CAAa;IAE3B;;OAEG;IACH,IAAW,KAAK,WAEf;IAED;;OAEG;IACI,SAAS,CAAC,eAAe,EAAE,MAAM;IAgBxC,OAAO,CAAC,aAAa;IAKrB;;;;;OAKG;IACH,SAAS,CAAC,aAAa,CAAC,UAAU,EAAE,gBAAgB,GAAG,qBAAqB;IAU5E;;;OAGG;cACa,QAAQ,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAMxE;;;OAGG;IACH,SAAS,CAAC,YAAY;IAEtB;;;;;;;;OAQG;IACH,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,yBAAyB,EAAE,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO;IAelG;;;OAGG;IACH,SAAS,CAAC,cAAc;CAG3B"}
+{"version":3,"file":"counter.d.ts","sourceRoot":"","sources":["../src/counter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,yBAAyB,EAAe,MAAM,sCAAsC,CAAC;AAC9F,OAAO,EACH,sBAAsB,EACtB,sBAAsB,EACtB,eAAe,EACf,kBAAkB,EACrB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,qBAAqB,EAAE,MAAM,qCAAqC,CAAC;AAC5E,OAAO,EAA2B,gBAAgB,EAAE,YAAY,EAAE,MAAM,oCAAoC,CAAC;AAE7G,OAAO,EAAE,cAAc,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAsBpE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,qBAAa,aAAc,SAAQ,YAAY,CAAC,oBAAoB,CAAE,YAAW,cAAc;IAC3F;;;;;;;OAOG;WACW,MAAM,CAAC,OAAO,EAAE,sBAAsB,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,aAAa;gBAIrE,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,sBAAsB,EAAE,UAAU,EAAE,kBAAkB;IAIvF;;;;OAIG;WACW,UAAU,IAAI,eAAe;IAI3C,OAAO,CAAC,MAAM,CAAa;IAE3B;;OAEG;IACH,IAAW,KAAK,IAAI,MAAM,CAEzB;IAED;;OAEG;IACI,SAAS,CAAC,eAAe,EAAE,MAAM,GAAG,IAAI;IAgB/C,OAAO,CAAC,aAAa;IAKrB;;;;;;OAMG;IACH,SAAS,CAAC,aAAa,CAAC,UAAU,EAAE,gBAAgB,GAAG,qBAAqB;IAU5E;;;;OAIG;cACa,QAAQ,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAMxE;;;;OAIG;IACH,SAAS,CAAC,YAAY,IAAI,IAAI;IAE9B;;;;;;;;;OASG;IACH,SAAS,CAAC,WAAW,CAAC,OAAO,EAAE,yBAAyB,EAAE,KAAK,EAAE,OAAO,EAAE,eAAe,EAAE,OAAO,GAAG,IAAI;IAezG;;;;OAIG;IACH,SAAS,CAAC,cAAc;CAG3B"}

package/dist/counter.js

@@ -11,35 +11,44 @@ const shared_object_base_1 = require("@fluidframework/shared-object-base");
 const counterFactory_1 = require("./counterFactory");
 const snapshotFileName = "header";
 /**
- * A `SharedCounter` is a shared object which holds a number that can be incremented or decremented.
- * @public
+ * A shared object that holds a number that can be incremented or decremented.
+ *
+ * @remarks Note that `SharedCounter` only operates on integer values. This is validated at runtime.
  *
- * @remarks
- * ### Creation
+ * @example Creating a `SharedCounter`:
  *
- * To create a `SharedCounter`, get the factory and call create with a runtime and string ID:
+ * First, get the factory and call {@link @fluidframework/datastore-definitions#IChannelFactory.create}
+ * with a runtime and string ID:
  *
  * ```typescript
  * const factory = SharedCounter.getFactory();
  * const counter = factory.create(this.runtime, id) as SharedCounter;
  * ```
  *
- * ### Usage
+ * The initial value of a new `SharedCounter` is 0.
+ * If you wish to initialize the counter to a different value, you may call {@link SharedCounter.increment} before
+ * attaching the Container, or before inserting it into an existing shared object.
+ *
+ * @example Using the `SharedCounter`:
  *
- * Once created, you can call `increment` to modify the value with either a positive or negative number:
+ * Once created, you can call {@link SharedCounter.increment} to modify the value with either a positive or
+ * negative number:
  *
  * ```typescript
  * counter.increment(10); // add 10 to the counter value
  * counter.increment(-5); // subtract 5 from the counter value
  * ```
  *
- * To observe changes to the value (including those from remote clients), register for the `"incremented"` event:
+ * To observe changes to the value (including those from remote clients), register for the
+ * {@link ISharedCounterEvents | incremented} event:
  *
  * ```typescript
  * counter.on("incremented", (incrementAmount, newValue) => {
  *     console.log(`The counter incremented by ${incrementAmount} and now has a value of ${newValue}`);
  * });
  * ```
+ *
+ * @public
  */
 class SharedCounter extends shared_object_base_1.SharedObject {
     constructor(id, runtime, attributes) {
@@ -47,17 +56,18 @@ class SharedCounter extends shared_object_base_1.SharedObject {
         this._value = 0;
     }
     /**
-     * Create a new shared counter
+     * Create a new {@link SharedCounter}.
+     *
+     * @param runtime - The data store runtime to which the new `SharedCounter` will belong.
+     * @param id - Optional name of the `SharedCounter`. If not provided, one will be generated.
      *
-     * @param runtime - data store runtime the new shared counter belongs to
-     * @param id - optional name of the shared counter
      * @returns newly create shared counter (but not attached yet)
      */
     static create(runtime, id) {
         return runtime.createChannel(id, counterFactory_1.CounterFactory.Type);
     }
     /**
-     * Get a factory for SharedCounter to register with the data store.
+     * Get a factory for {@link SharedCounter} to register with the data store.
      *
      * @returns a factory that creates and load SharedCounter
      */
@@ -91,9 +101,10 @@ class SharedCounter extends shared_object_base_1.SharedObject {
         this.emit("incremented", incrementAmount, this._value);
     }
     /**
-     * Create a summary for the counter
+     * Create a summary for the counter.
+     *
+     * @returns The summary of the current state of the counter.
      *
-     * @returns the summary of the current state of the counter
      * @internal
      */
     summarizeCore(serializer) {
@@ -106,6 +117,7 @@ class SharedCounter extends shared_object_base_1.SharedObject {
     }
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}
+     *
      * @internal
      */
     async loadCore(storage) {
@@ -114,16 +126,18 @@ class SharedCounter extends shared_object_base_1.SharedObject {
     }
     /**
      * Called when the object has disconnected from the delta stream.
+     *
      * @internal
      */
     onDisconnect() { }
     /**
-     * Process a counter operation
+     * Process a counter operation (op).
      *
-     * @param message - the message to prepare
-     * @param local - whether the message was sent by the local client
+     * @param message - The message to prepare.
+     * @param local - Whether or not the message was sent by the local client.
      * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
-     * For messages from a remote client, this will be undefined.
+     * For messages from a remote client, this will be `undefined`.
+     *
      * @internal
      */
     processCore(message, local, localOpMetadata) {
@@ -140,10 +154,11 @@ class SharedCounter extends shared_object_base_1.SharedObject {
     }
     /**
      * Not implemented.
+     *
      * @internal
      */
     applyStashedOp() {
-        throw new Error("not implemented");
+        throw new Error("Not implemented");
     }
 }
 exports.SharedCounter = SharedCounter;

package/dist/counter.js.map

@@ -1 +1 @@
-{"version":3,"file":"counter.js","sourceRoot":"","sources":["../src/counter.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+EAA8F;AAO9F,+DAA4D;AAE5D,2EAA6G;AAC7G,qDAAkD;AAmBlD,MAAM,gBAAgB,GAAG,QAAQ,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAa,aAAc,SAAQ,iCAAkC;IAYjE,YAAY,EAAU,EAAE,OAA+B,EAAE,UAA8B;QACnF,KAAK,CAAC,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;QAY7C,WAAM,GAAW,CAAC,CAAC;IAX3B,CAAC;IAbD;;;;;;OAMG;IACI,MAAM,CAAC,MAAM,CAAC,OAA+B,EAAE,EAAW;QAC7D,OAAO,OAAO,CAAC,aAAa,CAAC,EAAE,EAAE,+BAAc,CAAC,IAAI,CAAkB,CAAC;IAC3E,CAAC;IAMD;;;;OAIG;IACI,MAAM,CAAC,UAAU;QACpB,OAAO,IAAI,+BAAc,EAAE,CAAC;IAChC,CAAC;IAID;;OAEG;IACH,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACI,SAAS,CAAC,eAAuB;QACpC,uGAAuG;QACvG,wGAAwG;QACxG,IAAI,eAAe,GAAG,CAAC,KAAK,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;SACvD;QAED,MAAM,EAAE,GAAwB;YAC5B,IAAI,EAAE,WAAW;YACjB,eAAe;SAClB,CAAC;QAEF,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;QACpC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;IAChC,CAAC;IAEO,aAAa,CAAC,eAAuB;QACzC,IAAI,CAAC,MAAM,IAAI,eAAe,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,eAAe,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;OAKG;IACO,aAAa,CAAC,UAA4B;QAChD,kCAAkC;QAClC,MAAM,OAAO,GAA2B;YACpC,KAAK,EAAE,IAAI,CAAC,KAAK;SACpB,CAAC;QAEF,wCAAwC;QACxC,OAAO,IAAA,4CAAuB,EAAC,gBAAgB,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED;;;OAGG;IACO,KAAK,CAAC,QAAQ,CAAC,OAA+B;QACpD,MAAM,OAAO,GAAG,MAAM,IAAA,2BAAY,EAAyB,OAAO,EAAE,gBAAgB,CAAC,CAAC;QAEtF,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAChC,CAAC;IAED;;;OAGG;IACO,YAAY,KAAK,CAAC;IAE5B;;;;;;;;OAQG;IACO,WAAW,CAAC,OAAkC,EAAE,KAAc,EAAE,eAAwB;QAC9F,IAAI,OAAO,CAAC,IAAI,KAAK,kCAAW,CAAC,SAAS,IAAI,CAAC,KAAK,EAAE;YAClD,MAAM,EAAE,GAAG,OAAO,CAAC,QAA+B,CAAC;YAEnD,QAAQ,EAAE,CAAC,IAAI,EAAE;gBACb,KAAK,WAAW;oBACZ,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC;oBACvC,MAAM;gBAEV;oBACI,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;aAC5C;SACJ;IACL,CAAC;IAED;;;OAGG;IACO,cAAc;QACpB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACvC,CAAC;CACJ;AAzHD,sCAyHC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ISequencedDocumentMessage, MessageType } from \"@fluidframework/protocol-definitions\";\nimport {\n    IFluidDataStoreRuntime,\n    IChannelStorageService,\n    IChannelFactory,\n    IChannelAttributes,\n} from \"@fluidframework/datastore-definitions\";\nimport { readAndParse } from \"@fluidframework/driver-utils\";\nimport { ISummaryTreeWithStats } from \"@fluidframework/runtime-definitions\";\nimport { createSingleBlobSummary, IFluidSerializer, SharedObject } from \"@fluidframework/shared-object-base\";\nimport { CounterFactory } from \"./counterFactory\";\nimport { ISharedCounter, ISharedCounterEvents } from \"./interfaces\";\n\n/**\n * Describes the op format for incrementing the counter\n */\ninterface IIncrementOperation {\n    type: \"increment\";\n    incrementAmount: number;\n}\n\n/**\n * Used in snapshotting.\n */\ninterface ICounterSnapshotFormat {\n    // The value of the counter\n    value: number;\n}\n\nconst snapshotFileName = \"header\";\n\n/**\n * A `SharedCounter` is a shared object which holds a number that can be incremented or decremented.\n * @public\n *\n * @remarks\n * ### Creation\n *\n * To create a `SharedCounter`, get the factory and call create with a runtime and string ID:\n *\n * ```typescript\n * const factory = SharedCounter.getFactory();\n * const counter = factory.create(this.runtime, id) as SharedCounter;\n * ```\n *\n * ### Usage\n *\n * Once created, you can call `increment` to modify the value with either a positive or negative number:\n *\n * ```typescript\n * counter.increment(10); // add 10 to the counter value\n * counter.increment(-5); // subtract 5 from the counter value\n * ```\n *\n * To observe changes to the value (including those from remote clients), register for the `\"incremented\"` event:\n *\n * ```typescript\n * counter.on(\"incremented\", (incrementAmount, newValue) => {\n *     console.log(`The counter incremented by ${incrementAmount} and now has a value of ${newValue}`);\n * });\n * ```\n */\nexport class SharedCounter extends SharedObject<ISharedCounterEvents> implements ISharedCounter {\n    /**\n     * Create a new shared counter\n     *\n     * @param runtime - data store runtime the new shared counter belongs to\n     * @param id - optional name of the shared counter\n     * @returns newly create shared counter (but not attached yet)\n     */\n    public static create(runtime: IFluidDataStoreRuntime, id?: string) {\n        return runtime.createChannel(id, CounterFactory.Type) as SharedCounter;\n    }\n\n    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes) {\n        super(id, runtime, attributes, \"fluid_counter_\");\n    }\n\n    /**\n     * Get a factory for SharedCounter to register with the data store.\n     *\n     * @returns a factory that creates and load SharedCounter\n     */\n    public static getFactory(): IChannelFactory {\n        return new CounterFactory();\n    }\n\n    private _value: number = 0;\n\n    /**\n     * {@inheritDoc ISharedCounter.value}\n     */\n    public get value() {\n        return this._value;\n    }\n\n    /**\n     * {@inheritDoc ISharedCounter.increment}\n     */\n    public increment(incrementAmount: number) {\n        // Incrementing by floating point numbers will be eventually inconsistent, since the order in which the\n        // increments are applied affects the result.  A more-robust solution would be required to support this.\n        if (incrementAmount % 1 !== 0) {\n            throw new Error(\"Must increment by a whole number\");\n        }\n\n        const op: IIncrementOperation = {\n            type: \"increment\",\n            incrementAmount,\n        };\n\n        this.incrementCore(incrementAmount);\n        this.submitLocalMessage(op);\n    }\n\n    private incrementCore(incrementAmount: number) {\n        this._value += incrementAmount;\n        this.emit(\"incremented\", incrementAmount, this._value);\n    }\n\n    /**\n     * Create a summary for the counter\n     *\n     * @returns the summary of the current state of the counter\n     * @internal\n     */\n    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats {\n        // Get a serializable form of data\n        const content: ICounterSnapshotFormat = {\n            value: this.value,\n        };\n\n        // And then construct the summary for it\n        return createSingleBlobSummary(snapshotFileName, JSON.stringify(content));\n    }\n\n    /**\n     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}\n     * @internal\n     */\n    protected async loadCore(storage: IChannelStorageService): Promise<void> {\n        const content = await readAndParse<ICounterSnapshotFormat>(storage, snapshotFileName);\n\n        this._value = content.value;\n    }\n\n    /**\n     * Called when the object has disconnected from the delta stream.\n     * @internal\n     */\n    protected onDisconnect() { }\n\n    /**\n     * Process a counter operation\n     *\n     * @param message - the message to prepare\n     * @param local - whether the message was sent by the local client\n     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.\n     * For messages from a remote client, this will be undefined.\n     * @internal\n     */\n    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown) {\n        if (message.type === MessageType.Operation && !local) {\n            const op = message.contents as IIncrementOperation;\n\n            switch (op.type) {\n                case \"increment\":\n                    this.incrementCore(op.incrementAmount);\n                    break;\n\n                default:\n                    throw new Error(\"Unknown operation\");\n            }\n        }\n    }\n\n    /**\n     * Not implemented.\n     * @internal\n     */\n    protected applyStashedOp() {\n        throw new Error(\"not implemented\");\n    }\n}\n"]}
+{"version":3,"file":"counter.js","sourceRoot":"","sources":["../src/counter.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH,+EAA8F;AAO9F,+DAA4D;AAE5D,2EAA6G;AAC7G,qDAAkD;AAqBlD,MAAM,gBAAgB,GAAG,QAAQ,CAAC;AAElC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,MAAa,aAAc,SAAQ,iCAAkC;IAajE,YAAY,EAAU,EAAE,OAA+B,EAAE,UAA8B;QACnF,KAAK,CAAC,EAAE,EAAE,OAAO,EAAE,UAAU,EAAE,gBAAgB,CAAC,CAAC;QAY7C,WAAM,GAAW,CAAC,CAAC;IAX3B,CAAC;IAdD;;;;;;;OAOG;IACI,MAAM,CAAC,MAAM,CAAC,OAA+B,EAAE,EAAW;QAC7D,OAAO,OAAO,CAAC,aAAa,CAAC,EAAE,EAAE,+BAAc,CAAC,IAAI,CAAkB,CAAC;IAC3E,CAAC;IAMD;;;;OAIG;IACI,MAAM,CAAC,UAAU;QACpB,OAAO,IAAI,+BAAc,EAAE,CAAC;IAChC,CAAC;IAID;;OAEG;IACH,IAAW,KAAK;QACZ,OAAO,IAAI,CAAC,MAAM,CAAC;IACvB,CAAC;IAED;;OAEG;IACI,SAAS,CAAC,eAAuB;QACpC,uGAAuG;QACvG,wGAAwG;QACxG,IAAI,eAAe,GAAG,CAAC,KAAK,CAAC,EAAE;YAC3B,MAAM,IAAI,KAAK,CAAC,kCAAkC,CAAC,CAAC;SACvD;QAED,MAAM,EAAE,GAAwB;YAC5B,IAAI,EAAE,WAAW;YACjB,eAAe;SAClB,CAAC;QAEF,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,CAAC;QACpC,IAAI,CAAC,kBAAkB,CAAC,EAAE,CAAC,CAAC;IAChC,CAAC;IAEO,aAAa,CAAC,eAAuB;QACzC,IAAI,CAAC,MAAM,IAAI,eAAe,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,eAAe,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;OAMG;IACO,aAAa,CAAC,UAA4B;QAChD,kCAAkC;QAClC,MAAM,OAAO,GAA2B;YACpC,KAAK,EAAE,IAAI,CAAC,KAAK;SACpB,CAAC;QAEF,wCAAwC;QACxC,OAAO,IAAA,4CAAuB,EAAC,gBAAgB,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;IAC9E,CAAC;IAED;;;;OAIG;IACO,KAAK,CAAC,QAAQ,CAAC,OAA+B;QACpD,MAAM,OAAO,GAAG,MAAM,IAAA,2BAAY,EAAyB,OAAO,EAAE,gBAAgB,CAAC,CAAC;QAEtF,IAAI,CAAC,MAAM,GAAG,OAAO,CAAC,KAAK,CAAC;IAChC,CAAC;IAED;;;;OAIG;IACO,YAAY,KAAW,CAAC;IAElC;;;;;;;;;OASG;IACO,WAAW,CAAC,OAAkC,EAAE,KAAc,EAAE,eAAwB;QAC9F,IAAI,OAAO,CAAC,IAAI,KAAK,kCAAW,CAAC,SAAS,IAAI,CAAC,KAAK,EAAE;YAClD,MAAM,EAAE,GAAG,OAAO,CAAC,QAA+B,CAAC;YAEnD,QAAQ,EAAE,CAAC,IAAI,EAAE;gBACb,KAAK,WAAW;oBACZ,IAAI,CAAC,aAAa,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC;oBACvC,MAAM;gBAEV;oBACI,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;aAC5C;SACJ;IACL,CAAC;IAED;;;;OAIG;IACO,cAAc;QACpB,MAAM,IAAI,KAAK,CAAC,iBAAiB,CAAC,CAAC;IACvC,CAAC;CACJ;AA/HD,sCA+HC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport { ISequencedDocumentMessage, MessageType } from \"@fluidframework/protocol-definitions\";\nimport {\n    IFluidDataStoreRuntime,\n    IChannelStorageService,\n    IChannelFactory,\n    IChannelAttributes,\n} from \"@fluidframework/datastore-definitions\";\nimport { readAndParse } from \"@fluidframework/driver-utils\";\nimport { ISummaryTreeWithStats } from \"@fluidframework/runtime-definitions\";\nimport { createSingleBlobSummary, IFluidSerializer, SharedObject } from \"@fluidframework/shared-object-base\";\nimport { CounterFactory } from \"./counterFactory\";\nimport { ISharedCounter, ISharedCounterEvents } from \"./interfaces\";\n\n/**\n * Describes the operation (op) format for incrementing the {@link SharedCounter}.\n */\ninterface IIncrementOperation {\n    type: \"increment\";\n    incrementAmount: number;\n}\n\n/**\n * @remarks Used in snapshotting.\n */\ninterface ICounterSnapshotFormat {\n    /**\n     * The value of the counter.\n     */\n    value: number;\n}\n\nconst snapshotFileName = \"header\";\n\n/**\n * A shared object that holds a number that can be incremented or decremented.\n *\n * @remarks Note that `SharedCounter` only operates on integer values. This is validated at runtime.\n *\n * @example Creating a `SharedCounter`:\n *\n * First, get the factory and call {@link @fluidframework/datastore-definitions#IChannelFactory.create}\n * with a runtime and string ID:\n *\n * ```typescript\n * const factory = SharedCounter.getFactory();\n * const counter = factory.create(this.runtime, id) as SharedCounter;\n * ```\n *\n * The initial value of a new `SharedCounter` is 0.\n * If you wish to initialize the counter to a different value, you may call {@link SharedCounter.increment} before\n * attaching the Container, or before inserting it into an existing shared object.\n *\n * @example Using the `SharedCounter`:\n *\n * Once created, you can call {@link SharedCounter.increment} to modify the value with either a positive or\n * negative number:\n *\n * ```typescript\n * counter.increment(10); // add 10 to the counter value\n * counter.increment(-5); // subtract 5 from the counter value\n * ```\n *\n * To observe changes to the value (including those from remote clients), register for the\n * {@link ISharedCounterEvents | incremented} event:\n *\n * ```typescript\n * counter.on(\"incremented\", (incrementAmount, newValue) => {\n *     console.log(`The counter incremented by ${incrementAmount} and now has a value of ${newValue}`);\n * });\n * ```\n *\n * @public\n */\nexport class SharedCounter extends SharedObject<ISharedCounterEvents> implements ISharedCounter {\n    /**\n     * Create a new {@link SharedCounter}.\n     *\n     * @param runtime - The data store runtime to which the new `SharedCounter` will belong.\n     * @param id - Optional name of the `SharedCounter`. If not provided, one will be generated.\n     *\n     * @returns newly create shared counter (but not attached yet)\n     */\n    public static create(runtime: IFluidDataStoreRuntime, id?: string): SharedCounter {\n        return runtime.createChannel(id, CounterFactory.Type) as SharedCounter;\n    }\n\n    constructor(id: string, runtime: IFluidDataStoreRuntime, attributes: IChannelAttributes) {\n        super(id, runtime, attributes, \"fluid_counter_\");\n    }\n\n    /**\n     * Get a factory for {@link SharedCounter} to register with the data store.\n     *\n     * @returns a factory that creates and load SharedCounter\n     */\n    public static getFactory(): IChannelFactory {\n        return new CounterFactory();\n    }\n\n    private _value: number = 0;\n\n    /**\n     * {@inheritDoc ISharedCounter.value}\n     */\n    public get value(): number {\n        return this._value;\n    }\n\n    /**\n     * {@inheritDoc ISharedCounter.increment}\n     */\n    public increment(incrementAmount: number): void {\n        // Incrementing by floating point numbers will be eventually inconsistent, since the order in which the\n        // increments are applied affects the result.  A more-robust solution would be required to support this.\n        if (incrementAmount % 1 !== 0) {\n            throw new Error(\"Must increment by a whole number\");\n        }\n\n        const op: IIncrementOperation = {\n            type: \"increment\",\n            incrementAmount,\n        };\n\n        this.incrementCore(incrementAmount);\n        this.submitLocalMessage(op);\n    }\n\n    private incrementCore(incrementAmount: number): void {\n        this._value += incrementAmount;\n        this.emit(\"incremented\", incrementAmount, this._value);\n    }\n\n    /**\n     * Create a summary for the counter.\n     *\n     * @returns The summary of the current state of the counter.\n     *\n     * @internal\n     */\n    protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats {\n        // Get a serializable form of data\n        const content: ICounterSnapshotFormat = {\n            value: this.value,\n        };\n\n        // And then construct the summary for it\n        return createSingleBlobSummary(snapshotFileName, JSON.stringify(content));\n    }\n\n    /**\n     * {@inheritDoc @fluidframework/shared-object-base#SharedObject.loadCore}\n     *\n     * @internal\n     */\n    protected async loadCore(storage: IChannelStorageService): Promise<void> {\n        const content = await readAndParse<ICounterSnapshotFormat>(storage, snapshotFileName);\n\n        this._value = content.value;\n    }\n\n    /**\n     * Called when the object has disconnected from the delta stream.\n     *\n     * @internal\n     */\n    protected onDisconnect(): void { }\n\n    /**\n     * Process a counter operation (op).\n     *\n     * @param message - The message to prepare.\n     * @param local - Whether or not the message was sent by the local client.\n     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.\n     * For messages from a remote client, this will be `undefined`.\n     *\n     * @internal\n     */\n    protected processCore(message: ISequencedDocumentMessage, local: boolean, localOpMetadata: unknown): void {\n        if (message.type === MessageType.Operation && !local) {\n            const op = message.contents as IIncrementOperation;\n\n            switch (op.type) {\n                case \"increment\":\n                    this.incrementCore(op.incrementAmount);\n                    break;\n\n                default:\n                    throw new Error(\"Unknown operation\");\n            }\n        }\n    }\n\n    /**\n     * Not implemented.\n     *\n     * @internal\n     */\n    protected applyStashedOp() {\n        throw new Error(\"Not implemented\");\n    }\n}\n"]}

package/dist/counterFactory.d.ts

@@ -5,17 +5,34 @@
 import { IChannelAttributes, IFluidDataStoreRuntime, IChannelServices, IChannelFactory } from "@fluidframework/datastore-definitions";
 import { ISharedCounter } from "./interfaces";
 /**
- * The factory that defines the counter
+ * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedCounter}.
+ *
+ * @sealed
  */
 export declare class CounterFactory implements IChannelFactory {
+    /**
+     * Static value for {@link CounterFactory."type"}.
+     */
     static readonly Type = "https://graph.microsoft.com/types/counter";
+    /**
+     * Static value for {@link CounterFactory.attributes}.
+     */
     static readonly Attributes: IChannelAttributes;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory."type"}
+     */
     get type(): string;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.attributes}
+     */
     get attributes(): IChannelAttributes;
     /**
      * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}
      */
     load(runtime: IFluidDataStoreRuntime, id: string, services: IChannelServices, attributes: IChannelAttributes): Promise<ISharedCounter>;
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.create}
+     */
     create(document: IFluidDataStoreRuntime, id: string): ISharedCounter;
 }
 //# sourceMappingURL=counterFactory.d.ts.map

package/dist/counterFactory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"counterFactory.d.ts","sourceRoot":"","sources":["../src/counterFactory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACH,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EAClB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAG9C;;GAEG;AACH,qBAAa,cAAe,YAAW,eAAe;IAClD,gBAAuB,IAAI,+CAA+C;IAE1E,gBAAuB,UAAU,EAAE,kBAAkB,CAInD;IAEF,IAAW,IAAI,WAEd;IAED,IAAW,UAAU,uBAEpB;IAED;;OAEG;IACU,IAAI,CACb,OAAO,EAAE,sBAAsB,EAC/B,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;IAMrD,MAAM,CAAC,QAAQ,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM,GAAG,cAAc;CAK9E"}
+{"version":3,"file":"counterFactory.d.ts","sourceRoot":"","sources":["../src/counterFactory.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EACH,kBAAkB,EAClB,sBAAsB,EACtB,gBAAgB,EAChB,eAAe,EAClB,MAAM,uCAAuC,CAAC;AAE/C,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAG9C;;;;GAIG;AACH,qBAAa,cAAe,YAAW,eAAe;IAClD;;OAEG;IACH,gBAAuB,IAAI,+CAA+C;IAE1E;;OAEG;IACH,gBAAuB,UAAU,EAAE,kBAAkB,CAInD;IAEF;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACH,IAAW,UAAU,IAAI,kBAAkB,CAE1C;IAED;;OAEG;IACU,IAAI,CACb,OAAO,EAAE,sBAAsB,EAC/B,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,kBAAkB,GAAG,OAAO,CAAC,cAAc,CAAC;IAM5D;;OAEG;IACI,MAAM,CAAC,QAAQ,EAAE,sBAAsB,EAAE,EAAE,EAAE,MAAM,GAAG,cAAc;CAK9E"}

package/dist/counterFactory.js

@@ -8,12 +8,20 @@ exports.CounterFactory = void 0;
 const counter_1 = require("./counter");
 const packageVersion_1 = require("./packageVersion");
 /**
- * The factory that defines the counter
+ * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedCounter}.
+ *
+ * @sealed
  */
 class CounterFactory {
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory."type"}
+     */
     get type() {
         return CounterFactory.Type;
     }
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.attributes}
+     */
     get attributes() {
         return CounterFactory.Attributes;
     }
@@ -25,6 +33,9 @@ class CounterFactory {
         await counter.load(services);
         return counter;
     }
+    /**
+     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.create}
+     */
     create(document, id) {
         const counter = new counter_1.SharedCounter(id, document, this.attributes);
         counter.initializeLocal();
@@ -32,7 +43,13 @@ class CounterFactory {
     }
 }
 exports.CounterFactory = CounterFactory;
+/**
+ * Static value for {@link CounterFactory."type"}.
+ */
 CounterFactory.Type = "https://graph.microsoft.com/types/counter";
+/**
+ * Static value for {@link CounterFactory.attributes}.
+ */
 CounterFactory.Attributes = {
     type: CounterFactory.Type,
     snapshotFormatVersion: "0.1",

package/dist/counterFactory.js.map

@@ -1 +1 @@
-{"version":3,"file":"counterFactory.js","sourceRoot":"","sources":["../src/counterFactory.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAQH,uCAA0C;AAE1C,qDAA8C;AAE9C;;GAEG;AACH,MAAa,cAAc;IASvB,IAAW,IAAI;QACX,OAAO,cAAc,CAAC,IAAI,CAAC;IAC/B,CAAC;IAED,IAAW,UAAU;QACjB,OAAO,cAAc,CAAC,UAAU,CAAC;IACrC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,IAAI,CACb,OAA+B,EAC/B,EAAU,EACV,QAA0B,EAC1B,UAA8B;QAC9B,MAAM,OAAO,GAAG,IAAI,uBAAa,CAAC,EAAE,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC3D,MAAM,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC7B,OAAO,OAAO,CAAC;IACnB,CAAC;IAEM,MAAM,CAAC,QAAgC,EAAE,EAAU;QACtD,MAAM,OAAO,GAAG,IAAI,uBAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACjE,OAAO,CAAC,eAAe,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC;IACnB,CAAC;;AAlCL,wCAmCC;AAlC0B,mBAAI,GAAG,2CAA2C,CAAC;AAEnD,yBAAU,GAAuB;IACpD,IAAI,EAAE,cAAc,CAAC,IAAI;IACzB,qBAAqB,EAAE,KAAK;IAC5B,cAAc,EAAE,2BAAU;CAC7B,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n    IChannelAttributes,\n    IFluidDataStoreRuntime,\n    IChannelServices,\n    IChannelFactory,\n} from \"@fluidframework/datastore-definitions\";\nimport { SharedCounter } from \"./counter\";\nimport { ISharedCounter } from \"./interfaces\";\nimport { pkgVersion } from \"./packageVersion\";\n\n/**\n * The factory that defines the counter\n */\nexport class CounterFactory implements IChannelFactory {\n    public static readonly Type = \"https://graph.microsoft.com/types/counter\";\n\n    public static readonly Attributes: IChannelAttributes = {\n        type: CounterFactory.Type,\n        snapshotFormatVersion: \"0.1\",\n        packageVersion: pkgVersion,\n    };\n\n    public get type() {\n        return CounterFactory.Type;\n    }\n\n    public get attributes() {\n        return CounterFactory.Attributes;\n    }\n\n    /**\n     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}\n     */\n    public async load(\n        runtime: IFluidDataStoreRuntime,\n        id: string,\n        services: IChannelServices,\n        attributes: IChannelAttributes): Promise<ISharedCounter> {\n        const counter = new SharedCounter(id, runtime, attributes);\n        await counter.load(services);\n        return counter;\n    }\n\n    public create(document: IFluidDataStoreRuntime, id: string): ISharedCounter {\n        const counter = new SharedCounter(id, document, this.attributes);\n        counter.initializeLocal();\n        return counter;\n    }\n}\n"]}
+{"version":3,"file":"counterFactory.js","sourceRoot":"","sources":["../src/counterFactory.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAQH,uCAA0C;AAE1C,qDAA8C;AAE9C;;;;GAIG;AACH,MAAa,cAAc;IAevB;;OAEG;IACH,IAAW,IAAI;QACX,OAAO,cAAc,CAAC,IAAI,CAAC;IAC/B,CAAC;IAED;;OAEG;IACH,IAAW,UAAU;QACjB,OAAO,cAAc,CAAC,UAAU,CAAC;IACrC,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,IAAI,CACb,OAA+B,EAC/B,EAAU,EACV,QAA0B,EAC1B,UAA8B;QAC9B,MAAM,OAAO,GAAG,IAAI,uBAAa,CAAC,EAAE,EAAE,OAAO,EAAE,UAAU,CAAC,CAAC;QAC3D,MAAM,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC7B,OAAO,OAAO,CAAC;IACnB,CAAC;IAED;;OAEG;IACI,MAAM,CAAC,QAAgC,EAAE,EAAU;QACtD,MAAM,OAAO,GAAG,IAAI,uBAAa,CAAC,EAAE,EAAE,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;QACjE,OAAO,CAAC,eAAe,EAAE,CAAC;QAC1B,OAAO,OAAO,CAAC;IACnB,CAAC;;AAjDL,wCAkDC;AAjDG;;GAEG;AACoB,mBAAI,GAAG,2CAA2C,CAAC;AAE1E;;GAEG;AACoB,yBAAU,GAAuB;IACpD,IAAI,EAAE,cAAc,CAAC,IAAI;IACzB,qBAAqB,EAAE,KAAK;IAC5B,cAAc,EAAE,2BAAU;CAC7B,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\nimport {\n    IChannelAttributes,\n    IFluidDataStoreRuntime,\n    IChannelServices,\n    IChannelFactory,\n} from \"@fluidframework/datastore-definitions\";\nimport { SharedCounter } from \"./counter\";\nimport { ISharedCounter } from \"./interfaces\";\nimport { pkgVersion } from \"./packageVersion\";\n\n/**\n * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedCounter}.\n *\n * @sealed\n */\nexport class CounterFactory implements IChannelFactory {\n    /**\n     * Static value for {@link CounterFactory.\"type\"}.\n     */\n    public static readonly Type = \"https://graph.microsoft.com/types/counter\";\n\n    /**\n     * Static value for {@link CounterFactory.attributes}.\n     */\n    public static readonly Attributes: IChannelAttributes = {\n        type: CounterFactory.Type,\n        snapshotFormatVersion: \"0.1\",\n        packageVersion: pkgVersion,\n    };\n\n    /**\n     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.\"type\"}\n     */\n    public get type(): string {\n        return CounterFactory.Type;\n    }\n\n    /**\n     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.attributes}\n     */\n    public get attributes(): IChannelAttributes {\n        return CounterFactory.Attributes;\n    }\n\n    /**\n     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.load}\n     */\n    public async load(\n        runtime: IFluidDataStoreRuntime,\n        id: string,\n        services: IChannelServices,\n        attributes: IChannelAttributes): Promise<ISharedCounter> {\n        const counter = new SharedCounter(id, runtime, attributes);\n        await counter.load(services);\n        return counter;\n    }\n\n    /**\n     * {@inheritDoc @fluidframework/datastore-definitions#IChannelFactory.create}\n     */\n    public create(document: IFluidDataStoreRuntime, id: string): ISharedCounter {\n        const counter = new SharedCounter(id, document, this.attributes);\n        counter.initializeLocal();\n        return counter;\n    }\n}\n"]}

package/dist/index.d.ts

@@ -3,8 +3,8 @@
  * Licensed under the MIT License.
  */
 /**
- * This package contains the SharedCounter distributed data structure. A SharedCounter is a shared object
- * which holds a number that can be incremented or decremented.
+ * This library contains the {@link SharedCounter} distributed data structure.
+ * A `SharedCounter` is a shared object which holds a whole number that can be incremented or decremented.
  *
  * @packageDocumentation
  */

package/dist/index.js

@@ -15,8 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
- * This package contains the SharedCounter distributed data structure. A SharedCounter is a shared object
- * which holds a number that can be incremented or decremented.
+ * This library contains the {@link SharedCounter} distributed data structure.
+ * A `SharedCounter` is a shared object which holds a whole number that can be incremented or decremented.
  *
  * @packageDocumentation
  */

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;AAEH;;;;;GAKG;AAEH,4CAA0B;AAC1B,+CAA6B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * This package contains the SharedCounter distributed data structure. A SharedCounter is a shared object\n * which holds a number that can be incremented or decremented.\n *\n * @packageDocumentation\n */\n\nexport * from \"./counter\";\nexport * from \"./interfaces\";\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;AAEH;;;;;GAKG;AAEH,4CAA0B;AAC1B,+CAA6B","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n/**\n * This library contains the {@link SharedCounter} distributed data structure.\n * A `SharedCounter` is a shared object which holds a whole number that can be incremented or decremented.\n *\n * @packageDocumentation\n */\n\nexport * from \"./counter\";\nexport * from \"./interfaces\";\n"]}