@utrecht/web-component-library-stencil 1.0.0-alpha.16 → 1.0.0-alpha.160

package/dist/collection/node_modules/@storybook/client-api/dist/cjs/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/collection/node_modules/@storybook/client-api/dist/cjs/typings.d.js

@@ -0,0 +1 @@
+"use strict";

package/dist/collection/node_modules/@storybook/client-api/dist/esm/args.js

@@ -0,0 +1,178 @@
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.object.freeze.js";
+
+var _templateObject, _templateObject2;
+
+function _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
+
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
+
+function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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); }
+
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.number.constructor.js";
+import "core-js/modules/es.array.reduce.js";
+import "core-js/modules/es.object.entries.js";
+import "core-js/modules/es.object.assign.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.array.find-index.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.array.map.js";
+import { once } from '@storybook/client-logger';
+import isPlainObject from 'lodash/isPlainObject';
+import dedent from 'ts-dedent';
+var INCOMPATIBLE = Symbol('incompatible');
+
+var map = function map(arg, type) {
+  if (arg === undefined || arg === null || !type) return arg;
+
+  switch (type.name) {
+    case 'string':
+      return String(arg);
+
+    case 'enum':
+      return arg;
+
+    case 'number':
+      return Number(arg);
+
+    case 'boolean':
+      return arg === 'true';
+
+    case 'array':
+      if (!type.value || !Array.isArray(arg)) return INCOMPATIBLE;
+      return arg.reduce(function (acc, item, index) {
+        var mapped = map(item, type.value);
+        if (mapped !== INCOMPATIBLE) acc[index] = mapped;
+        return acc;
+      }, new Array(arg.length));
+
+    case 'object':
+      if (typeof arg === 'string' || typeof arg === 'number') return arg;
+      if (!type.value || _typeof(arg) !== 'object') return INCOMPATIBLE;
+      return Object.entries(arg).reduce(function (acc, _ref) {
+        var _ref2 = _slicedToArray(_ref, 2),
+            key = _ref2[0],
+            val = _ref2[1];
+
+        var mapped = map(val, type.value[key]);
+        return mapped === INCOMPATIBLE ? acc : Object.assign(acc, _defineProperty({}, key, mapped));
+      }, {});
+
+    default:
+      return INCOMPATIBLE;
+  }
+};
+
+export var mapArgsToTypes = function mapArgsToTypes(args, argTypes) {
+  return Object.entries(args).reduce(function (acc, _ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+        key = _ref4[0],
+        value = _ref4[1];
+
+    if (!argTypes[key]) return acc;
+    var mapped = map(value, argTypes[key].type);
+    return mapped === INCOMPATIBLE ? acc : Object.assign(acc, _defineProperty({}, key, mapped));
+  }, {});
+};
+export var combineArgs = function combineArgs(value, update) {
+  if (Array.isArray(value) && Array.isArray(update)) {
+    return update.reduce(function (acc, upd, index) {
+      acc[index] = combineArgs(value[index], update[index]);
+      return acc;
+    }, _toConsumableArray(value)).filter(function (v) {
+      return v !== undefined;
+    });
+  }
+
+  if (!isPlainObject(value) || !isPlainObject(update)) return update;
+  return Object.keys(Object.assign({}, value, update)).reduce(function (acc, key) {
+    if (key in update) {
+      var combined = combineArgs(value[key], update[key]);
+      if (combined !== undefined) acc[key] = combined;
+    } else {
+      acc[key] = value[key];
+    }
+
+    return acc;
+  }, {});
+};
+export var validateOptions = function validateOptions(args, argTypes) {
+  return Object.entries(argTypes).reduce(function (acc, _ref5) {
+    var _ref6 = _slicedToArray(_ref5, 2),
+        key = _ref6[0],
+        options = _ref6[1].options;
+
+    if (!options) {
+      if (key in args) {
+        acc[key] = args[key];
+      }
+
+      return acc;
+    }
+
+    if (!Array.isArray(options)) {
+      once.error(dedent(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n        Invalid argType: '", ".options' should be an array.\n\n        More info: https://storybook.js.org/docs/react/api/argtypes\n      "])), key));
+      acc[key] = args[key];
+      return acc;
+    }
+
+    if (options.some(function (opt) {
+      return opt && ['object', 'function'].includes(_typeof(opt));
+    })) {
+      once.error(dedent(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n        Invalid argType: '", ".options' should only contain primitives. Use a 'mapping' for complex values.\n\n        More info: https://storybook.js.org/docs/react/writing-stories/args#mapping-to-complex-arg-values\n      "])), key));
+      acc[key] = args[key];
+      return acc;
+    }
+
+    var isArray = Array.isArray(args[key]);
+    var invalidIndex = isArray && args[key].findIndex(function (val) {
+      return !options.includes(val);
+    });
+    var isValidArray = isArray && invalidIndex === -1;
+
+    if (args[key] === undefined || options.includes(args[key]) || isValidArray) {
+      acc[key] = args[key];
+      return acc;
+    }
+
+    var field = isArray ? "".concat(key, "[").concat(invalidIndex, "]") : key;
+    var supportedOptions = options.map(function (opt) {
+      return typeof opt === 'string' ? "'".concat(opt, "'") : String(opt);
+    }).join(', ');
+    once.warn("Received illegal value for '".concat(field, "'. Supported options: ").concat(supportedOptions));
+    return acc;
+  }, {});
+};

package/dist/collection/node_modules/@storybook/client-api/dist/esm/client_api.js

@@ -0,0 +1,308 @@
+import "core-js/modules/es.array.slice.js";
+import "core-js/modules/es.object.freeze.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+
+var _templateObject, _templateObject2;
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+function _typeof(obj) { "@babel/helpers - typeof"; 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 _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
+
+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; }
+
+import "core-js/modules/es.set.js";
+import "core-js/modules/es.object.to-string.js";
+import "core-js/modules/es.string.iterator.js";
+import "core-js/modules/es.array.iterator.js";
+import "core-js/modules/web.dom-collections.iterator.js";
+import "core-js/modules/es.object.assign.js";
+import "core-js/modules/es.object.get-prototype-of.js";
+import "core-js/modules/es.regexp.to-string.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.array.concat.js";
+
+/* eslint no-underscore-dangle: 0 */
+import deprecate from 'util-deprecate';
+import dedent from 'ts-dedent';
+import { logger } from '@storybook/client-logger';
+import { toId } from '@storybook/csf';
+import { applyHooks } from './hooks';
+import { defaultDecorateStory } from './decorators'; // ClientApi (and StoreStore) are really singletons. However they are not created until the
+// relevant framework instanciates them via `start.js`. The good news is this happens right away.
+
+var singleton;
+var addDecoratorDeprecationWarning = deprecate(function () {}, "`addDecorator` is deprecated, and will be removed in Storybook 7.0.\nInstead, use `export const decorators = [];` in your `preview.js`.\nRead more at https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-addparameters-and-adddecorator).");
+export var addDecorator = function addDecorator(decorator) {
+  var deprecationWarning = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (!singleton) throw new Error("Singleton client API not yet initialized, cannot call addDecorator");
+  if (deprecationWarning) addDecoratorDeprecationWarning();
+  singleton.addDecorator(decorator);
+};
+var addParametersDeprecationWarning = deprecate(function () {}, "`addParameters` is deprecated, and will be removed in Storybook 7.0.\nInstead, use `export const parameters = {};` in your `preview.js`.\nRead more at https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-addparameters-and-adddecorator).");
+export var addParameters = function addParameters(parameters) {
+  var deprecationWarning = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (!singleton) throw new Error("Singleton client API not yet initialized, cannot call addParameters");
+  if (deprecationWarning) addParametersDeprecationWarning();
+  singleton.addParameters(parameters);
+};
+var addLoaderDeprecationWarning = deprecate(function () {}, "`addLoader` is deprecated, and will be removed in Storybook 7.0.\nInstead, use `export const loaders = [];` in your `preview.js`.\nRead more at https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-addparameters-and-adddecorator).");
+export var addLoader = function addLoader(loader) {
+  var deprecationWarning = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  if (!singleton) throw new Error("Singleton client API not yet initialized, cannot call addParameters");
+  if (deprecationWarning) addLoaderDeprecationWarning();
+  singleton.addLoader(loader);
+};
+export var addArgsEnhancer = function addArgsEnhancer(enhancer) {
+  if (!singleton) throw new Error("Singleton client API not yet initialized, cannot call addArgsEnhancer");
+  singleton.addArgsEnhancer(enhancer);
+};
+export var addArgTypesEnhancer = function addArgTypesEnhancer(enhancer) {
+  if (!singleton) throw new Error("Singleton client API not yet initialized, cannot call addArgTypesEnhancer");
+  singleton.addArgTypesEnhancer(enhancer);
+};
+export var getGlobalRender = function getGlobalRender() {
+  if (!singleton) throw new Error("Singleton client API not yet initialized, cannot call getGlobalRender");
+  return singleton.globalRender;
+};
+export var setGlobalRender = function setGlobalRender(render) {
+  if (!singleton) throw new Error("Singleton client API not yet initialized, cannot call setGobalRender");
+  singleton.globalRender = render;
+};
+var invalidStoryTypes = new Set(['string', 'number', 'boolean', 'symbol']);
+
+var ClientApi = /*#__PURE__*/function () {
+  // React Native Fast refresh doesn't allow multiple dispose calls
+  function ClientApi(_ref) {
+    var _this = this;
+
+    var storyStore = _ref.storyStore,
+        _ref$decorateStory = _ref.decorateStory,
+        decorateStory = _ref$decorateStory === void 0 ? defaultDecorateStory : _ref$decorateStory,
+        noStoryModuleAddMethodHotDispose = _ref.noStoryModuleAddMethodHotDispose;
+
+    _classCallCheck(this, ClientApi);
+
+    this._storyStore = void 0;
+    this._addons = void 0;
+    this._decorateStory = void 0;
+    this._globalRender = void 0;
+    this._noStoryModuleAddMethodHotDispose = void 0;
+    this.setAddon = deprecate(function (addon) {
+      _this._addons = Object.assign({}, _this._addons, addon);
+    }, dedent(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n      `setAddon` is deprecated and will be removed in Storybook 7.0.\n\n      https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-setaddon\n    "], ["\n      \\`setAddon\\` is deprecated and will be removed in Storybook 7.0.\n\n      https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-setaddon\n    "]))));
+
+    this.addDecorator = function (decorator) {
+      _this._storyStore.addGlobalMetadata({
+        decorators: [decorator]
+      });
+    };
+
+    this.clearDecorators = deprecate(function () {
+      _this._storyStore.clearGlobalDecorators();
+    }, dedent(_templateObject2 || (_templateObject2 = _taggedTemplateLiteral(["\n      `clearDecorators` is deprecated and will be removed in Storybook 7.0.\n\n      https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-cleardecorators\n    "], ["\n      \\`clearDecorators\\` is deprecated and will be removed in Storybook 7.0.\n\n      https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-cleardecorators\n    "]))));
+
+    this.addParameters = function (parameters) {
+      _this._storyStore.addGlobalMetadata({
+        parameters: parameters
+      });
+    };
+
+    this.addLoader = function (loader) {
+      _this._storyStore.addGlobalMetadata({
+        loaders: [loader]
+      });
+    };
+
+    this.addArgsEnhancer = function (enhancer) {
+      _this._storyStore.addArgsEnhancer(enhancer);
+    };
+
+    this.addArgTypesEnhancer = function (enhancer) {
+      _this._storyStore.addArgTypesEnhancer(enhancer);
+    };
+
+    this.storiesOf = function (kind, m) {
+      if (!kind && typeof kind !== 'string') {
+        throw new Error('Invalid or missing kind provided for stories, should be a string');
+      }
+
+      if (!m) {
+        logger.warn("Missing 'module' parameter for story with a kind of '".concat(kind, "'. It will break your HMR"));
+      }
+
+      if (m) {
+        var proto = Object.getPrototypeOf(m);
+
+        if (proto.exports && proto.exports.default) {
+          // FIXME: throw an error in SB6.0
+          logger.error("Illegal mix of CSF default export and storiesOf calls in a single file: ".concat(proto.i));
+        }
+      }
+
+      if (m && m.hot && m.hot.dispose) {
+        m.hot.dispose(function () {
+          var _storyStore = _this._storyStore; // If HMR dispose happens in a story file, we know that HMR will pass up to the configuration file (preview.js)
+          // and be handled by the HMR.allow in config_api, leading to a re-run of configuration.
+          // So configuration is about to happen--we can skip the safety check.
+
+          _storyStore.removeStoryKind(kind, {
+            allowUnsafe: true
+          });
+        });
+      }
+
+      var hasAdded = false;
+      var api = {
+        kind: kind.toString(),
+        add: function add() {
+          return api;
+        },
+        addDecorator: function addDecorator() {
+          return api;
+        },
+        addLoader: function addLoader() {
+          return api;
+        },
+        addParameters: function addParameters() {
+          return api;
+        }
+      }; // apply addons
+
+      Object.keys(_this._addons).forEach(function (name) {
+        var addon = _this._addons[name];
+
+        api[name] = function () {
+          for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+            args[_key] = arguments[_key];
+          }
+
+          addon.apply(api, args);
+          return api;
+        };
+      });
+
+      api.add = function (storyName, storyFn) {
+        var parameters = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+        hasAdded = true;
+        var id = parameters.__id || toId(kind, storyName);
+
+        if (typeof storyName !== 'string') {
+          throw new Error("Invalid or missing storyName provided for a \"".concat(kind, "\" story."));
+        }
+
+        if (!storyFn || Array.isArray(storyFn) || invalidStoryTypes.has(_typeof(storyFn))) {
+          throw new Error("Cannot load story \"".concat(storyName, "\" in \"").concat(kind, "\" due to invalid format. Storybook expected a function/object but received ").concat(_typeof(storyFn), " instead."));
+        }
+
+        if (!_this._noStoryModuleAddMethodHotDispose && m && m.hot && m.hot.dispose) {
+          m.hot.dispose(function () {
+            var _storyStore = _this._storyStore; // See note about allowUnsafe above
+
+            _storyStore.remove(id, {
+              allowUnsafe: true
+            });
+          });
+        }
+
+        var fileName = m && m.id ? "".concat(m.id) : undefined;
+
+        var decorators = parameters.decorators,
+            loaders = parameters.loaders,
+            storyParameters = _objectWithoutProperties(parameters, ["decorators", "loaders"]);
+
+        _this._storyStore.addStory({
+          id: id,
+          kind: kind,
+          name: storyName,
+          storyFn: storyFn,
+          parameters: Object.assign({
+            fileName: fileName
+          }, storyParameters),
+          decorators: decorators,
+          loaders: loaders
+        }, {
+          applyDecorators: applyHooks(_this._decorateStory)
+        });
+
+        return api;
+      };
+
+      api.addDecorator = function (decorator) {
+        if (hasAdded) throw new Error("You cannot add a decorator after the first story for a kind.\nRead more here: https://github.com/storybookjs/storybook/blob/master/MIGRATION.md#can-no-longer-add-decoratorsparameters-after-stories");
+
+        _this._storyStore.addKindMetadata(kind, {
+          decorators: [decorator]
+        });
+
+        return api;
+      };
+
+      api.addLoader = function (loader) {
+        if (hasAdded) throw new Error("You cannot add a loader after the first story for a kind.");
+
+        _this._storyStore.addKindMetadata(kind, {
+          loaders: [loader]
+        });
+
+        return api;
+      };
+
+      api.addParameters = function (parameters) {
+        if (hasAdded) throw new Error("You cannot add parameters after the first story for a kind.\nRead more here: https://github.com/storybookjs/storybook/blob/master/MIGRATION.md#can-no-longer-add-decoratorsparameters-after-stories");
+
+        _this._storyStore.addKindMetadata(kind, {
+          parameters: parameters
+        });
+
+        return api;
+      };
+
+      return api;
+    };
+
+    this.getStorybook = function () {
+      return _this._storyStore.getStorybook();
+    };
+
+    this.raw = function () {
+      return _this._storyStore.raw();
+    };
+
+    this.store = function () {
+      return _this._storyStore;
+    };
+
+    this._storyStore = storyStore;
+    this._addons = {};
+    this._noStoryModuleAddMethodHotDispose = noStoryModuleAddMethodHotDispose || false;
+    this._decorateStory = decorateStory;
+    if (!storyStore) throw new Error('storyStore is required');
+    singleton = this;
+  }
+
+  _createClass(ClientApi, [{
+    key: "globalRender",
+    get: function get() {
+      return this._globalRender;
+    },
+    set: function set(render) {
+      this._globalRender = render;
+    } // what are the occasions that "m" is a boolean vs an obj
+
+  }]);
+
+  return ClientApi;
+}();
+
+export { ClientApi as default };

package/dist/collection/node_modules/@storybook/client-api/dist/esm/config_api.js

@@ -0,0 +1,32 @@
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+/* eslint no-underscore-dangle: 0 */
+var ConfigApi = function ConfigApi(_ref) {
+  var _this = this;
+
+  var storyStore = _ref.storyStore;
+
+  _classCallCheck(this, ConfigApi);
+
+  this._storyStore = void 0;
+
+  this.configure = function (loaders, module) {
+    var showDeprecationWarning = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+
+    _this._storyStore.startConfiguring();
+
+    try {
+      loaders();
+
+      _this._storyStore.clearError();
+    } catch (err) {
+      _this._storyStore.setError(err);
+    }
+
+    _this._storyStore.finishConfiguring();
+  };
+
+  this._storyStore = storyStore;
+};
+
+export { ConfigApi as default };

package/dist/collection/node_modules/@storybook/client-api/dist/esm/decorators.js

@@ -0,0 +1,75 @@
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.object.assign.js";
+import "core-js/modules/es.array.reduce.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.symbol.js";
+
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+
+var defaultContext = {
+  id: 'unspecified',
+  name: 'unspecified',
+  kind: 'unspecified',
+  parameters: {},
+  args: {},
+  argTypes: {},
+  globals: {}
+};
+export var decorateStory = function decorateStory(storyFn, decorator, bindWithContext) {
+  // Bind the partially decorated storyFn so that when it is called it always knows about the story context,
+  // no matter what it is passed directly. This is because we cannot guarantee a decorator will
+  // pass the context down to the next decorated story in the chain.
+  var boundStoryFunction = bindWithContext(storyFn);
+  return function (context) {
+    return decorator(boundStoryFunction, context);
+  };
+};
+export var defaultDecorateStory = function defaultDecorateStory(storyFn, decorators) {
+  // We use a trick to avoid recreating the bound story function inside `decorateStory`.
+  // Instead we pass it a context "getter", which is defined once (at "decoration time")
+  // The getter reads a variable which is scoped to this call of `decorateStory`
+  // (ie to this story), so there is no possibility of overlap.
+  // This will break if you call the same story twice interleaved
+  // (React might do it if you rendered the same story twice in the one ReactDom.render call, for instance)
+  var contextStore = {
+    value: defaultContext
+  };
+  /**
+   * When you call the story function inside a decorator, e.g.:
+   *
+   * ```jsx
+   * <div>{storyFn({ foo: 'bar' })}</div>
+   * ```
+   *
+   * This will override the `foo` property on the `innerContext`, which gets
+   * merged in with the default context
+   */
+
+  var bindWithContext = function bindWithContext(decoratedStoryFn) {
+    return (// (NOTE: You cannot override the parameters key, it is fixed)
+      function () {
+        var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+        var id = _ref.id,
+            name = _ref.name,
+            kind = _ref.kind,
+            parameters = _ref.parameters,
+            contextUpdate = _objectWithoutProperties(_ref, ["id", "name", "kind", "parameters"]);
+
+        contextStore.value = Object.assign({}, contextStore.value, contextUpdate);
+        return decoratedStoryFn(contextStore.value);
+      }
+    );
+  };
+
+  var decoratedWithContextStore = decorators.reduce(function (story, decorator) {
+    return decorateStory(story, decorator, bindWithContext);
+  }, storyFn);
+  return function () {
+    var context = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : defaultContext;
+    contextStore.value = context;
+    return decoratedWithContextStore(context); // Pass the context directly into the first decorator
+  };
+};

package/dist/collection/node_modules/@storybook/client-api/dist/esm/ensureArgTypes.js

@@ -0,0 +1,16 @@
+import mapValues from 'lodash/mapValues';
+import { combineParameters } from './parameters';
+export var ensureArgTypes = function ensureArgTypes(context) {
+  var _context$parameters = context.parameters,
+      _context$parameters$a = _context$parameters.argTypes,
+      userArgTypes = _context$parameters$a === void 0 ? {} : _context$parameters$a,
+      _context$parameters$a2 = _context$parameters.args,
+      args = _context$parameters$a2 === void 0 ? {} : _context$parameters$a2;
+  if (!args) return userArgTypes;
+  var argTypes = mapValues(args, function (_arg, name) {
+    return {
+      name: name
+    };
+  });
+  return combineParameters(argTypes, userArgTypes);
+};

package/dist/collection/node_modules/@storybook/client-api/dist/esm/filterArgTypes.js

@@ -0,0 +1,21 @@
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.string.match.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.function.name.js";
+import pickBy from 'lodash/pickBy';
+
+var matches = function matches(name, descriptor) {
+  return Array.isArray(descriptor) ? descriptor.includes(name) : name.match(descriptor);
+};
+
+export var filterArgTypes = function filterArgTypes(argTypes, include, exclude) {
+  if (!include && !exclude) {
+    return argTypes;
+  }
+
+  return argTypes && pickBy(argTypes, function (argType, key) {
+    var name = argType.name || key;
+    return (!include || matches(name, include)) && (!exclude || !matches(name, exclude));
+  });
+};