@carbon/charts 0.27.0 → 0.29.1

package/styles/vendor/carbon-components/es/globals/js/mixins/evented-state.js

@@ -0,0 +1,245 @@
+function _typeof(obj) {
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread();
+}
+
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance");
+}
+
+function _iterableToArray(iter) {
+  if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter);
+}
+
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) {
+    for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) {
+      arr2[i] = arr[i];
+    }
+
+    return arr2;
+  }
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return _assertThisInitialized(self);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+/**
+ * Copyright IBM Corp. 2016, 2018
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+export default function (ToMix) {
+  /**
+   * Mix-in class to manage events associated with states.
+   * @class EventedState
+   */
+  var EventedState =
+  /*#__PURE__*/
+  function (_ToMix) {
+    _inherits(EventedState, _ToMix);
+
+    function EventedState() {
+      _classCallCheck(this, EventedState);
+
+      return _possibleConstructorReturn(this, _getPrototypeOf(EventedState).apply(this, arguments));
+    }
+
+    _createClass(EventedState, [{
+      key: "_changeState",
+
+      /* eslint-disable jsdoc/check-param-names */
+
+      /**
+       * The internal implementation for {@link EventedState#changeState `.changeState()`}, performing actual change in state.
+       * @param {string} [state] The new state. Can be an omitted, which means toggling.
+       * @param {object} [detail]
+       *   The object that should be put to event details that is fired before/after changing state.
+       *   Can have a `group` property, which specifies what state to be changed.
+       * @param {EventedState~changeStateCallback} callback The callback called once changing state is finished or is canceled.
+       * @private
+       */
+      value: function _changeState() {
+        throw new Error('_changeState() should be overriden to perform actual change in state.');
+      }
+      /**
+       * Changes the state of this component.
+       * @param {string} [state] The new state. Can be an omitted, which means toggling.
+       * @param {object} [detail]
+       *   The object that should be put to event details that is fired before/after changing state.
+       *   Can have a `group` property, which specifies what state to be changed.
+       * @param {EventedState~changeStateCallback} [callback] The callback called once changing state is finished or is canceled.
+       */
+
+    }, {
+      key: "changeState",
+      value: function changeState() {
+        var _this = this;
+
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        var state = typeof args[0] === 'string' ? args.shift() : undefined;
+        var detail = Object(args[0]) === args[0] && typeof args[0] !== 'function' ? args.shift() : undefined;
+        var callback = typeof args[0] === 'function' ? args.shift() : undefined;
+
+        if (typeof this.shouldStateBeChanged === 'function' && !this.shouldStateBeChanged(state, detail)) {
+          if (callback) {
+            callback(null, true);
+          }
+
+          return;
+        }
+
+        var data = {
+          group: detail && detail.group,
+          state: state
+        };
+        var eventNameSuffix = [data.group, state].filter(Boolean).join('-').split('-') // Group or state may contain hyphen
+        .map(function (item) {
+          return item[0].toUpperCase() + item.substr(1);
+        }).join('');
+        var eventStart = new CustomEvent(this.options["eventBefore".concat(eventNameSuffix)], {
+          bubbles: true,
+          cancelable: true,
+          detail: detail
+        });
+        var fireOnNode = detail && detail.delegatorNode || this.element;
+        var canceled = !fireOnNode.dispatchEvent(eventStart);
+
+        if (canceled) {
+          if (callback) {
+            var error = new Error("Changing state (".concat(JSON.stringify(data), ") has been canceled."));
+            error.canceled = true;
+            callback(error);
+          }
+        } else {
+          var changeStateArgs = [state, detail].filter(Boolean);
+
+          this._changeState.apply(this, _toConsumableArray(changeStateArgs).concat([function () {
+            fireOnNode.dispatchEvent(new CustomEvent(_this.options["eventAfter".concat(eventNameSuffix)], {
+              bubbles: true,
+              cancelable: true,
+              detail: detail
+            }));
+
+            if (callback) {
+              callback();
+            }
+          }]));
+        }
+      }
+      /* eslint-enable jsdoc/check-param-names */
+
+      /**
+       * Tests if change in state should happen or not.
+       * Classes inheriting {@link EventedState `EventedState`} should override this function.
+       * @function EventedState#shouldStateBeChanged
+       * @param {string} [state] The new state. Can be an omitted, which means toggling.
+       * @param {Object} [detail]
+       *   The object that should be put to event details that is fired before/after changing state.
+       *   Can have a `group` property, which specifies what state to be changed.
+       * @returns {boolean}
+       *   `false` if change in state shouldn't happen, e.g. when the given new state is the same as the current one.
+       */
+
+    }]);
+
+    return EventedState;
+  }(ToMix);
+  /**
+   * The callback called once changing state is finished or is canceled.
+   * @callback EventedState~changeStateCallback
+   * @param {Error} error
+   *   An error object with `true` in its `canceled` property if changing state is canceled.
+   *   Cancellation happens if the handler of a custom event, that is fired before changing state happens,
+   *   calls `.preventDefault()` against the event.
+   * @param {boolean} keptState
+   *   `true` if the call to {@link EventedState#changeState `.changeState()`} didn't cause actual change in state.
+   */
+
+
+  return EventedState;
+}

package/styles/vendor/carbon-components/es/globals/js/mixins/handles.js

@@ -0,0 +1,191 @@
+function _typeof(obj) {
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return _assertThisInitialized(self);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _get(target, property, receiver) {
+  if (typeof Reflect !== "undefined" && Reflect.get) {
+    _get = Reflect.get;
+  } else {
+    _get = function _get(target, property, receiver) {
+      var base = _superPropBase(target, property);
+
+      if (!base) return;
+      var desc = Object.getOwnPropertyDescriptor(base, property);
+
+      if (desc.get) {
+        return desc.get.call(receiver);
+      }
+
+      return desc.value;
+    };
+  }
+
+  return _get(target, property, receiver || target);
+}
+
+function _superPropBase(object, property) {
+  while (!Object.prototype.hasOwnProperty.call(object, property)) {
+    object = _getPrototypeOf(object);
+    if (object === null) break;
+  }
+
+  return object;
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+/**
+ * Copyright IBM Corp. 2016, 2018
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+export default function (ToMix) {
+  /**
+   * Mix-in class to manage handles in component.
+   * Managed handles are automatically released when the component with this class mixed in is released.
+   * @class Handles
+   * @implements Handle
+   */
+  var Handles =
+  /*#__PURE__*/
+  function (_ToMix) {
+    _inherits(Handles, _ToMix);
+
+    function Handles() {
+      var _getPrototypeOf2;
+
+      var _this;
+
+      _classCallCheck(this, Handles);
+
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+
+      _this = _possibleConstructorReturn(this, (_getPrototypeOf2 = _getPrototypeOf(Handles)).call.apply(_getPrototypeOf2, [this].concat(args)));
+      _this.handles = new Set();
+      return _this;
+    }
+
+    _createClass(Handles, [{
+      key: "manage",
+
+      /**
+       * Manages the given handle.
+       * @param {Handle} handle The handle to manage.
+       * @returns {Handle} The given handle.
+       */
+      value: function manage(handle) {
+        this.handles.add(handle);
+        return handle;
+      }
+      /**
+       * Stop managing the given handle.
+       * @param {Handle} handle The handle to stop managing.
+       * @returns {Handle} The given handle.
+       */
+
+    }, {
+      key: "unmanage",
+      value: function unmanage(handle) {
+        this.handles.delete(handle);
+        return handle;
+      }
+    }, {
+      key: "release",
+      value: function release() {
+        var _this2 = this;
+
+        this.handles.forEach(function (handle) {
+          handle.release();
+
+          _this2.handles.delete(handle);
+        });
+        return _get(_getPrototypeOf(Handles.prototype), "release", this).call(this);
+      }
+    }]);
+
+    return Handles;
+  }(ToMix);
+
+  return Handles;
+}

package/styles/vendor/carbon-components/es/globals/js/mixins/init-component-by-event.js

@@ -0,0 +1,174 @@
+function _typeof(obj) {
+  if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
+    _typeof = function _typeof(obj) {
+      return typeof obj;
+    };
+  } else {
+    _typeof = function _typeof(obj) {
+      return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+    };
+  }
+
+  return _typeof(obj);
+}
+
+function _classCallCheck(instance, Constructor) {
+  if (!(instance instanceof Constructor)) {
+    throw new TypeError("Cannot call a class as a function");
+  }
+}
+
+function _defineProperties(target, props) {
+  for (var i = 0; i < props.length; i++) {
+    var descriptor = props[i];
+    descriptor.enumerable = descriptor.enumerable || false;
+    descriptor.configurable = true;
+    if ("value" in descriptor) descriptor.writable = true;
+    Object.defineProperty(target, descriptor.key, descriptor);
+  }
+}
+
+function _createClass(Constructor, protoProps, staticProps) {
+  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+  if (staticProps) _defineProperties(Constructor, staticProps);
+  return Constructor;
+}
+
+function _possibleConstructorReturn(self, call) {
+  if (call && (_typeof(call) === "object" || typeof call === "function")) {
+    return call;
+  }
+
+  return _assertThisInitialized(self);
+}
+
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+
+  return self;
+}
+
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+
+function _inherits(subClass, superClass) {
+  if (typeof superClass !== "function" && superClass !== null) {
+    throw new TypeError("Super expression must either be null or a function");
+  }
+
+  subClass.prototype = Object.create(superClass && superClass.prototype, {
+    constructor: {
+      value: subClass,
+      writable: true,
+      configurable: true
+    }
+  });
+  if (superClass) _setPrototypeOf(subClass, superClass);
+}
+
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+
+  return _setPrototypeOf(o, p);
+}
+/**
+ * Copyright IBM Corp. 2016, 2018
+ *
+ * This source code is licensed under the Apache-2.0 license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+
+import eventMatches from '../misc/event-matches';
+import on from '../misc/on';
+export default function (ToMix) {
+  /**
+   * Mix-in class to instantiate components upon events.
+   * @class InitComponentByEvent
+   */
+  var InitComponentByEvent =
+  /*#__PURE__*/
+  function (_ToMix) {
+    _inherits(InitComponentByEvent, _ToMix);
+
+    function InitComponentByEvent() {
+      _classCallCheck(this, InitComponentByEvent);
+
+      return _possibleConstructorReturn(this, _getPrototypeOf(InitComponentByEvent).apply(this, arguments));
+    }
+
+    _createClass(InitComponentByEvent, null, [{
+      key: "init",
+
+      /**
+       * `true` suggests that this component is lazily initialized upon an action/event, etc.
+       * @type {boolean}
+       */
+
+      /**
+       * Instantiates this component in the given element.
+       * If the given element indicates that it's an component of this class, instantiates it.
+       * Otherwise, instantiates this component by clicking on this component in the given node.
+       * @param {Node} target The DOM node to instantiate this component in. Should be a document or an element.
+       * @param {object} [options] The component options.
+       * @param {string} [options.selectorInit] The CSS selector to find this component.
+       * @returns {Handle} The handle to remove the event listener to handle clicking.
+       */
+      value: function init() {
+        var _this = this;
+
+        var target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document;
+        var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+        var effectiveOptions = Object.assign(Object.create(this.options), options);
+
+        if (!target || target.nodeType !== Node.ELEMENT_NODE && target.nodeType !== Node.DOCUMENT_NODE) {
+          throw new TypeError('DOM document or DOM element should be given to search for and initialize this widget.');
+        }
+
+        if (target.nodeType === Node.ELEMENT_NODE && target.matches(effectiveOptions.selectorInit)) {
+          this.create(target, options);
+        } else {
+          // To work around non-bubbling `focus` event, use `focusin` event instead of it's available, and "capture mode" otherwise
+          var hasFocusin = 'onfocusin' in (target.nodeType === Node.ELEMENT_NODE ? target.ownerDocument : target).defaultView;
+          var handles = effectiveOptions.initEventNames.map(function (name) {
+            var eventName = name === 'focus' && hasFocusin ? 'focusin' : name;
+            return on(target, eventName, function (event) {
+              var element = eventMatches(event, effectiveOptions.selectorInit); // Instantiated components handles events by themselves
+
+              if (element && !_this.components.has(element)) {
+                var component = _this.create(element, options);
+
+                if (typeof component.createdByEvent === 'function') {
+                  component.createdByEvent(event);
+                }
+              }
+            }, name === 'focus' && !hasFocusin);
+          });
+          return {
+            release: function release() {
+              for (var handle = handles.pop(); handle; handle = handles.pop()) {
+                handle.release();
+              }
+            }
+          };
+        }
+
+        return '';
+      }
+    }]);
+
+    InitComponentByEvent.forLazyInit = true;
+    return InitComponentByEvent;
+  }(ToMix);
+
+  return InitComponentByEvent;
+}