matrix-react-sdk/lib/stores/AsyncStore.js

SDK for matrix.org using React

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.UPDATE_EVENT = exports.AsyncStore = void 0;
var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
var _events = require("events");
var _awaitLock = _interopRequireDefault(require("await-lock"));
/*
Copyright 2024 New Vector Ltd.
Copyright 2020 The Matrix.org Foundation C.I.C.

SPDX-License-Identifier: AGPL-3.0-only OR GPL-3.0-only
Please see LICENSE files in the repository root for full details.
*/

/**
 * The event/channel to listen for in an AsyncStore.
 */
const UPDATE_EVENT = exports.UPDATE_EVENT = "update";

/**
 * Represents a minimal store which works similar to Flux stores. Instead
 * of everything needing to happen in a dispatch cycle, everything can
 * happen async to that cycle.
 *
 * The store operates by using Object.assign() to mutate state - it sends the
 * state objects (current and new) through the function onto a new empty
 * object. Because of this, it is recommended to break out your state to be as
 * safe as possible. The state mutations are also locked, preventing concurrent
 * writes.
 *
 * All updates to the store happen on the UPDATE_EVENT event channel with the
 * one argument being the instance of the store.
 *
 * To update the state, use updateState() and preferably await the result to
 * help prevent lock conflicts.
 */
class AsyncStore extends _events.EventEmitter {
  /**
   * Creates a new AsyncStore using the given dispatcher.
   * @param {Dispatcher<ActionPayload>} dispatcher The dispatcher to rely upon.
   * @param {T} initialState The initial state for the store.
   */
  constructor(dispatcher, initialState = {}) {
    super();
    (0, _defineProperty2.default)(this, "storeState", void 0);
    (0, _defineProperty2.default)(this, "lock", new _awaitLock.default());
    (0, _defineProperty2.default)(this, "dispatcherRef", void 0);
    this.dispatcher = dispatcher;
    this.dispatcherRef = dispatcher.register(this.onDispatch.bind(this));
    this.storeState = initialState;
  }

  /**
   * The current state of the store. Cannot be mutated.
   */
  get state() {
    return this.storeState;
  }

  /**
   * Stops the store's listening functions, such as the listener to the dispatcher.
   */
  stop() {
    if (this.dispatcherRef) this.dispatcher.unregister(this.dispatcherRef);
  }

  /**
   * Updates the state of the store.
   * @param {T|*} newState The state to update in the store using Object.assign()
   */
  async updateState(newState) {
    await this.lock.acquireAsync();
    try {
      this.storeState = Object.freeze(Object.assign({}, this.storeState, newState));
      this.emit(UPDATE_EVENT, this);
    } finally {
      await this.lock.release();
    }
  }

  /**
   * Resets the store's to the provided state or an empty object.
   * @param {T|*} newState The new state of the store.
   * @param {boolean} quiet If true, the function will not raise an UPDATE_EVENT.
   */
  async reset(newState = null, quiet = false) {
    await this.lock.acquireAsync();
    try {
      this.storeState = Object.freeze(newState || {});
      if (!quiet) this.emit(UPDATE_EVENT, this);
    } finally {
      await this.lock.release();
    }
  }

  /**
   * Called when the dispatcher broadcasts a dispatch event.
   * @param {ActionPayload} payload The event being dispatched.
   */
}
exports.AsyncStore = AsyncStore;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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