@webex/webex-core 2.59.3-next.1 → 2.59.4

package/src/lib/stateless-webex-plugin.js

@@ -1,98 +1,98 @@
-import {readonly} from 'core-decorators';
-import AmpEvents from 'ampersand-events';
-
-// hold onto weak references to parent' Webexs to help avoid retain cycles
-const webexs = new WeakMap();
-
-/**
- * Base plugin class. Doesn't depend on Ampersand State
- */
-export default class StatelessWebexPlugin {
-  /**
-   * The config for this plugin's namespace. If no namespace has been set
-   * returns all of webex's config.
-   * @type {Object}
-   */
-  get config() {
-    let namespace = this.getNamespace ? this.getNamespace() : this.namespace;
-
-    if (namespace) {
-      namespace = namespace.toLowerCase();
-
-      return this.webex.config[namespace];
-    }
-
-    return this.webex.config;
-  }
-
-  /**
-   * A reference to the webex logger.
-   * @type {Logger}
-   */
-  get logger() {
-    return this.webex.logger;
-  }
-
-  /**
-   * A reference to the main sdk instance
-   * @type {WebexCore}
-   */
-  get webex() {
-    return webexs.get(this);
-  }
-
-  @readonly
-  /**
-   * Mostly here for compatibility with legacy WebexPlugins.
-   * StatelessWebexPlugins will never have a state other than ready, however, if
-   * we implement stateful WebexPlugins as es6 classes, they may have the option
-   * to have ready be false
-   * @private
-   * @type {boolean}
-   */
-  ready = true;
-
-  /**
-   * Constructor. One of attrs.webex or options.parent is required
-   * @param {Object} attrs
-   * @param {WebexCore} [attrs.webex]
-   * @param {Object} options
-   * @param {WebexCore} [options.parent]
-   */
-  constructor(attrs = {}, options = {}) {
-    let webex = attrs.webex || options.parent;
-
-    if (!webex) {
-      throw new Error(
-        'One of `attrs.webex` or `options.parent` must be supplied when initializing a StatelessWebexPlugin'
-      );
-    }
-
-    while (webex.parent || webex.collection) {
-      webex = webex.parent || webex.collection;
-    }
-    webexs.set(this, webex);
-  }
-
-  /**
-   * Proxies to {@link WebexPlugin#webex}'s `request()` method.
-   * @see WebexCore#request
-   * @param {Array<mixed>} args
-   * @returns {Promise}
-   */
-  request(...args) {
-    return this.webex.request(...args);
-  }
-
-  /**
-   * Proxies to {@link WebexPlugin#webex}'s `upload()` method.
-   * @see WebexCore#upload
-   * @param {Array<mixed>} args
-   * @returns {Promise}
-   */
-  upload(...args) {
-    return this.webex.upload(...args);
-  }
-}
-
-Object.assign(StatelessWebexPlugin.prototype, AmpEvents);
+import {readonly} from 'core-decorators';
+import AmpEvents from 'ampersand-events';
+
+// hold onto weak references to parent' Webexs to help avoid retain cycles
+const webexs = new WeakMap();
+
+/**
+ * Base plugin class. Doesn't depend on Ampersand State
+ */
+export default class StatelessWebexPlugin {
+  /**
+   * The config for this plugin's namespace. If no namespace has been set
+   * returns all of webex's config.
+   * @type {Object}
+   */
+  get config() {
+    let namespace = this.getNamespace ? this.getNamespace() : this.namespace;
+
+    if (namespace) {
+      namespace = namespace.toLowerCase();
+
+      return this.webex.config[namespace];
+    }
+
+    return this.webex.config;
+  }
+
+  /**
+   * A reference to the webex logger.
+   * @type {Logger}
+   */
+  get logger() {
+    return this.webex.logger;
+  }
+
+  /**
+   * A reference to the main sdk instance
+   * @type {WebexCore}
+   */
+  get webex() {
+    return webexs.get(this);
+  }
+
+  @readonly
+  /**
+   * Mostly here for compatibility with legacy WebexPlugins.
+   * StatelessWebexPlugins will never have a state other than ready, however, if
+   * we implement stateful WebexPlugins as es6 classes, they may have the option
+   * to have ready be false
+   * @private
+   * @type {boolean}
+   */
+  ready = true;
+
+  /**
+   * Constructor. One of attrs.webex or options.parent is required
+   * @param {Object} attrs
+   * @param {WebexCore} [attrs.webex]
+   * @param {Object} options
+   * @param {WebexCore} [options.parent]
+   */
+  constructor(attrs = {}, options = {}) {
+    let webex = attrs.webex || options.parent;
+
+    if (!webex) {
+      throw new Error(
+        'One of `attrs.webex` or `options.parent` must be supplied when initializing a StatelessWebexPlugin'
+      );
+    }
+
+    while (webex.parent || webex.collection) {
+      webex = webex.parent || webex.collection;
+    }
+    webexs.set(this, webex);
+  }
+
+  /**
+   * Proxies to {@link WebexPlugin#webex}'s `request()` method.
+   * @see WebexCore#request
+   * @param {Array<mixed>} args
+   * @returns {Promise}
+   */
+  request(...args) {
+    return this.webex.request(...args);
+  }
+
+  /**
+   * Proxies to {@link WebexPlugin#webex}'s `upload()` method.
+   * @see WebexCore#upload
+   * @param {Array<mixed>} args
+   * @returns {Promise}
+   */
+  upload(...args) {
+    return this.webex.upload(...args);
+  }
+}
+
+Object.assign(StatelessWebexPlugin.prototype, AmpEvents);

package/src/lib/storage/decorators.js

@@ -1,220 +1,220 @@
-/*!
- * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
- */
-
-/* eslint no-invalid-this: [0] */
-
-import {curry, debounce, identity, result, wrap} from 'lodash';
-import {make} from '@webex/common';
-
-import {NotFoundError} from './errors';
-
-/**
- * Stores the result of fn before returning it
- * @param  {string} key
- * @private
- * @returns {Promise} resolves with the result of fn
- */
-export function persist(...args) {
-  if (args.length === 3) {
-    return persist('@')(...args);
-  }
-
-  const [key, decider] = args;
-
-  return function persistDecorator(target, prop, descriptor) {
-    if (prop !== 'initialize') {
-      // Once we have class-based alternative to AmpersandState, it should be
-      // detected here.
-      throw new TypeError(
-        '@persist can only currently be applied to AmpersandState objects or their derivatives and must be applied to the initialize method'
-      );
-    }
-
-    descriptor.value = wrap(descriptor.value, function persistExecutor(fn, ...initializeArgs) {
-      const ret = Reflect.apply(fn, this, initializeArgs);
-      const changeEvent = key === '@' ? 'change' : `change:${key}`;
-
-      // Some scenarios will lead to lots of change events on a single tick; we
-      // really only care about writing once things have stopped changing. with
-      // a debounce of zero, we're effectively coalescing all the changes
-      // triggered by a single call to set() and commiting them on the next tick
-      // eslint-disable-next-line no-invalid-this
-      this.on(
-        changeEvent,
-        debounce(() => {
-          const shouldPersist = !decider || Reflect.apply(decider, this, ...initializeArgs);
-
-          if (!shouldPersist) {
-            return Promise.resolve();
-          }
-          if (key === '@') {
-            // eslint-disable-next-line no-invalid-this
-            return this.boundedStorage.put(key, this);
-          }
-
-          // eslint-disable-next-line no-invalid-this
-          return this.boundedStorage.put(key, this[key]);
-        }, 0)
-      );
-
-      return ret;
-    });
-
-    prepareInitialize(target, prop);
-  };
-}
-
-const M = Map;
-const S = Set;
-const BlockingKeyMap = make(M, M, S);
-const blockingKeys = new BlockingKeyMap();
-
-/**
- * Prevents fn from executing until key has been (attempted to be) loaded
- * @param {string} key
- * @param {Function} fn
- * @private
- * @returns {Promise} result of fn
- */
-export function waitForValue(key) {
-  if (!key) {
-    throw new Error('`key` is required');
-  }
-
-  return function waitForValueDecorator(target, prop, descriptor) {
-    blockingKeys.add(target, prop, key);
-    descriptor.value = wrap(descriptor.value, function waitForValueExecutor(fn, ...args) {
-      const keys = blockingKeys.get(target, prop);
-
-      return Promise.all([...keys].map((k) => this.boundedStorage.waitFor(k))).then(() =>
-        Reflect.apply(fn, this, args)
-      );
-    });
-
-    // This *should* make decorators compatible with AmpersandState class
-    // definitions
-    if (typeof target === 'object' && !target.prototype) {
-      target[prop] = descriptor.value;
-    }
-
-    prepareInitialize(target, prop);
-
-    return descriptor;
-  };
-}
-
-const inited = new Set();
-
-/**
- * finds a means of identitying the `target` param passed to
- * `prepareInitialize()`. When possible, avoids duplicate `init()` calls if
- * namespaces collide
- *
- * @param {Object|Constructor} target
- * @private
- * @returns {String|Constructor}
- */
-function identifyTarget(target) {
-  if (target.namespace) {
-    return target.namespace;
-  }
-
-  return target;
-}
-
-const stack = new Set();
-
-/**
- * @param {Function} target
- * @param {string} prop
- * @private
- * @returns {undefined}
- */
-function prepareInitialize(target, prop) {
-  const id = identifyTarget(target);
-
-  if (!inited.has(id)) {
-    inited.add(id);
-    if (target.initialize) {
-      target.initialize = wrap(target.initialize, function applyInit(fn, ...args) {
-        const ret = Reflect.apply(fn, this, args);
-
-        Reflect.apply(init, this, args);
-
-        return ret;
-      });
-
-      return;
-    }
-
-    target.initialize = init;
-  }
-
-  /**
-   * @private
-   * @returns {undefined}
-   */
-  function init() {
-    const self = this;
-    const namespace = this.getNamespace();
-
-    this.webex.initialize = wrap(
-      this.webex.initialize || identity,
-      function applyInit(fn, ...args) {
-        // Call webex's initalize method first
-        // Reminder: in order for MockWebex to accept initial storage data, the
-        // wrapped initialize() must be invoked before attempting to load data.
-        // Reminder: context here is `webex`, not `self`.
-        stack.add(namespace);
-        Reflect.apply(fn, this, args);
-
-        // Then prepare a function for setting values retrieved from storage
-        const set = curry((key, value) => {
-          this.logger.debug(`storage:(${namespace}): got \`${key}\` for first time`);
-          if (key === '@') {
-            self.parent.set({
-              [namespace.toLowerCase()]: value,
-            });
-          } else if (result(self[key], 'isState')) {
-            self[key].set(value);
-          } else {
-            self.set(key, value);
-          }
-          this.logger.debug(`storage:(${namespace}): set \`${key}\` for first time`);
-        });
-
-        // And prepare an error handler for when those keys can't be found
-        const handle = curry((key, reason) => {
-          if (
-            reason instanceof NotFoundError ||
-            (process.env.NODE_ENV !== 'production' &&
-              reason.toString().includes('MockNotFoundError'))
-          ) {
-            this.logger.debug(`storage(${namespace}): no data for \`${key}\`, continuing`);
-
-            return Promise.resolve();
-          }
-          this.logger.error(`storage(${namespace}): failed to init \`${key}\``, reason);
-
-          return Promise.reject(reason);
-        });
-
-        // Iterate over the list of keys marked as blocking via `@waitForValue`
-        const keys = blockingKeys.get(target, prop);
-        const promises = [];
-
-        keys.forEach((key) => {
-          promises.push(this.boundedStorage.get(namespace, key).then(set(key)).catch(handle(key)));
-        });
-
-        Promise.all(promises).then(() => {
-          stack.delete(namespace);
-          if (stack.size === 0) {
-            this.loaded = true;
-          }
-        });
-      }
-    );
-  }
-}
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+/* eslint no-invalid-this: [0] */
+
+import {curry, debounce, identity, result, wrap} from 'lodash';
+import {make} from '@webex/common';
+
+import {NotFoundError} from './errors';
+
+/**
+ * Stores the result of fn before returning it
+ * @param  {string} key
+ * @private
+ * @returns {Promise} resolves with the result of fn
+ */
+export function persist(...args) {
+  if (args.length === 3) {
+    return persist('@')(...args);
+  }
+
+  const [key, decider] = args;
+
+  return function persistDecorator(target, prop, descriptor) {
+    if (prop !== 'initialize') {
+      // Once we have class-based alternative to AmpersandState, it should be
+      // detected here.
+      throw new TypeError(
+        '@persist can only currently be applied to AmpersandState objects or their derivatives and must be applied to the initialize method'
+      );
+    }
+
+    descriptor.value = wrap(descriptor.value, function persistExecutor(fn, ...initializeArgs) {
+      const ret = Reflect.apply(fn, this, initializeArgs);
+      const changeEvent = key === '@' ? 'change' : `change:${key}`;
+
+      // Some scenarios will lead to lots of change events on a single tick; we
+      // really only care about writing once things have stopped changing. with
+      // a debounce of zero, we're effectively coalescing all the changes
+      // triggered by a single call to set() and commiting them on the next tick
+      // eslint-disable-next-line no-invalid-this
+      this.on(
+        changeEvent,
+        debounce(() => {
+          const shouldPersist = !decider || Reflect.apply(decider, this, ...initializeArgs);
+
+          if (!shouldPersist) {
+            return Promise.resolve();
+          }
+          if (key === '@') {
+            // eslint-disable-next-line no-invalid-this
+            return this.boundedStorage.put(key, this);
+          }
+
+          // eslint-disable-next-line no-invalid-this
+          return this.boundedStorage.put(key, this[key]);
+        }, 0)
+      );
+
+      return ret;
+    });
+
+    prepareInitialize(target, prop);
+  };
+}
+
+const M = Map;
+const S = Set;
+const BlockingKeyMap = make(M, M, S);
+const blockingKeys = new BlockingKeyMap();
+
+/**
+ * Prevents fn from executing until key has been (attempted to be) loaded
+ * @param {string} key
+ * @param {Function} fn
+ * @private
+ * @returns {Promise} result of fn
+ */
+export function waitForValue(key) {
+  if (!key) {
+    throw new Error('`key` is required');
+  }
+
+  return function waitForValueDecorator(target, prop, descriptor) {
+    blockingKeys.add(target, prop, key);
+    descriptor.value = wrap(descriptor.value, function waitForValueExecutor(fn, ...args) {
+      const keys = blockingKeys.get(target, prop);
+
+      return Promise.all([...keys].map((k) => this.boundedStorage.waitFor(k))).then(() =>
+        Reflect.apply(fn, this, args)
+      );
+    });
+
+    // This *should* make decorators compatible with AmpersandState class
+    // definitions
+    if (typeof target === 'object' && !target.prototype) {
+      target[prop] = descriptor.value;
+    }
+
+    prepareInitialize(target, prop);
+
+    return descriptor;
+  };
+}
+
+const inited = new Set();
+
+/**
+ * finds a means of identitying the `target` param passed to
+ * `prepareInitialize()`. When possible, avoids duplicate `init()` calls if
+ * namespaces collide
+ *
+ * @param {Object|Constructor} target
+ * @private
+ * @returns {String|Constructor}
+ */
+function identifyTarget(target) {
+  if (target.namespace) {
+    return target.namespace;
+  }
+
+  return target;
+}
+
+const stack = new Set();
+
+/**
+ * @param {Function} target
+ * @param {string} prop
+ * @private
+ * @returns {undefined}
+ */
+function prepareInitialize(target, prop) {
+  const id = identifyTarget(target);
+
+  if (!inited.has(id)) {
+    inited.add(id);
+    if (target.initialize) {
+      target.initialize = wrap(target.initialize, function applyInit(fn, ...args) {
+        const ret = Reflect.apply(fn, this, args);
+
+        Reflect.apply(init, this, args);
+
+        return ret;
+      });
+
+      return;
+    }
+
+    target.initialize = init;
+  }
+
+  /**
+   * @private
+   * @returns {undefined}
+   */
+  function init() {
+    const self = this;
+    const namespace = this.getNamespace();
+
+    this.webex.initialize = wrap(
+      this.webex.initialize || identity,
+      function applyInit(fn, ...args) {
+        // Call webex's initalize method first
+        // Reminder: in order for MockWebex to accept initial storage data, the
+        // wrapped initialize() must be invoked before attempting to load data.
+        // Reminder: context here is `webex`, not `self`.
+        stack.add(namespace);
+        Reflect.apply(fn, this, args);
+
+        // Then prepare a function for setting values retrieved from storage
+        const set = curry((key, value) => {
+          this.logger.debug(`storage:(${namespace}): got \`${key}\` for first time`);
+          if (key === '@') {
+            self.parent.set({
+              [namespace.toLowerCase()]: value,
+            });
+          } else if (result(self[key], 'isState')) {
+            self[key].set(value);
+          } else {
+            self.set(key, value);
+          }
+          this.logger.debug(`storage:(${namespace}): set \`${key}\` for first time`);
+        });
+
+        // And prepare an error handler for when those keys can't be found
+        const handle = curry((key, reason) => {
+          if (
+            reason instanceof NotFoundError ||
+            (process.env.NODE_ENV !== 'production' &&
+              reason.toString().includes('MockNotFoundError'))
+          ) {
+            this.logger.debug(`storage(${namespace}): no data for \`${key}\`, continuing`);
+
+            return Promise.resolve();
+          }
+          this.logger.error(`storage(${namespace}): failed to init \`${key}\``, reason);
+
+          return Promise.reject(reason);
+        });
+
+        // Iterate over the list of keys marked as blocking via `@waitForValue`
+        const keys = blockingKeys.get(target, prop);
+        const promises = [];
+
+        keys.forEach((key) => {
+          promises.push(this.boundedStorage.get(namespace, key).then(set(key)).catch(handle(key)));
+        });
+
+        Promise.all(promises).then(() => {
+          stack.delete(namespace);
+          if (stack.size === 0) {
+            this.loaded = true;
+          }
+        });
+      }
+    );
+  }
+}

package/src/lib/storage/errors.js

@@ -1,15 +1,15 @@
-/*!
- * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
- */
-
-import {Exception} from '@webex/common';
-
-/**
- * General storage layer error
- */
-export class StorageError extends Exception {}
-
-/**
- * StorageError thrown when the storage layer does not contain the request key
- */
-export class NotFoundError extends StorageError {}
+/*!
+ * Copyright (c) 2015-2020 Cisco Systems, Inc. See LICENSE file.
+ */
+
+import {Exception} from '@webex/common';
+
+/**
+ * General storage layer error
+ */
+export class StorageError extends Exception {}
+
+/**
+ * StorageError thrown when the storage layer does not contain the request key
+ */
+export class NotFoundError extends StorageError {}