@utrecht/web-component-library-stencil 1.0.0-alpha.243 → 1.0.0-alpha.246

package/dist/collection/node_modules/@storybook/addons/dist/esm/hooks.js

@@ -0,0 +1,494 @@
+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 _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 _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 _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 _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 _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; }
+
+import "core-js/modules/es.weak-map.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.set.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.object.entries.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.symbol.iterator.js";
+import "core-js/modules/es.array.from.js";
+import "core-js/modules/es.array.slice.js";
+
+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 global from 'global';
+import { logger } from '@storybook/client-logger';
+import { FORCE_RE_RENDER, STORY_RENDERED, UPDATE_STORY_ARGS, RESET_STORY_ARGS, UPDATE_GLOBALS } from '@storybook/core-events';
+import { addons } from './index';
+var globalWindow = global.window;
+export var HooksContext = /*#__PURE__*/function () {
+  function HooksContext() {
+    var _this = this;
+
+    _classCallCheck(this, HooksContext);
+
+    this.hookListsMap = void 0;
+    this.mountedDecorators = void 0;
+    this.prevMountedDecorators = void 0;
+    this.currentHooks = void 0;
+    this.nextHookIndex = void 0;
+    this.currentPhase = void 0;
+    this.currentEffects = void 0;
+    this.prevEffects = void 0;
+    this.currentDecoratorName = void 0;
+    this.hasUpdates = void 0;
+    this.currentContext = void 0;
+
+    this.renderListener = function (storyId) {
+      if (storyId !== _this.currentContext.id) return;
+
+      _this.triggerEffects();
+
+      _this.currentContext = null;
+
+      _this.removeRenderListeners();
+    };
+
+    this.init();
+  }
+
+  _createClass(HooksContext, [{
+    key: "init",
+    value: function init() {
+      this.hookListsMap = new WeakMap();
+      this.mountedDecorators = new Set();
+      this.prevMountedDecorators = this.mountedDecorators;
+      this.currentHooks = [];
+      this.nextHookIndex = 0;
+      this.currentPhase = 'NONE';
+      this.currentEffects = [];
+      this.prevEffects = [];
+      this.currentDecoratorName = null;
+      this.hasUpdates = false;
+      this.currentContext = null;
+    }
+  }, {
+    key: "clean",
+    value: function clean() {
+      this.prevEffects.forEach(function (effect) {
+        if (effect.destroy) {
+          effect.destroy();
+        }
+      });
+      this.init();
+      this.removeRenderListeners();
+    }
+  }, {
+    key: "getNextHook",
+    value: function getNextHook() {
+      var hook = this.currentHooks[this.nextHookIndex];
+      this.nextHookIndex += 1;
+      return hook;
+    }
+  }, {
+    key: "triggerEffects",
+    value: function triggerEffects() {
+      var _this2 = this;
+
+      // destroy removed effects
+      this.prevEffects.forEach(function (effect) {
+        if (!_this2.currentEffects.includes(effect) && effect.destroy) {
+          effect.destroy();
+        }
+      }); // trigger added effects
+
+      this.currentEffects.forEach(function (effect) {
+        if (!_this2.prevEffects.includes(effect)) {
+          // eslint-disable-next-line no-param-reassign
+          effect.destroy = effect.create();
+        }
+      });
+      this.prevEffects = this.currentEffects;
+      this.currentEffects = [];
+    }
+  }, {
+    key: "addRenderListeners",
+    value: function addRenderListeners() {
+      this.removeRenderListeners();
+      var channel = addons.getChannel();
+      channel.on(STORY_RENDERED, this.renderListener);
+    }
+  }, {
+    key: "removeRenderListeners",
+    value: function removeRenderListeners() {
+      var channel = addons.getChannel();
+      channel.removeListener(STORY_RENDERED, this.renderListener);
+    }
+  }]);
+
+  return HooksContext;
+}();
+
+function hookify(fn) {
+  return function () {
+    var _ref = typeof (arguments.length <= 0 ? undefined : arguments[0]) === 'function' ? arguments.length <= 1 ? undefined : arguments[1] : arguments.length <= 0 ? undefined : arguments[0],
+        hooks = _ref.hooks;
+
+    var prevPhase = hooks.currentPhase;
+    var prevHooks = hooks.currentHooks;
+    var prevNextHookIndex = hooks.nextHookIndex;
+    var prevDecoratorName = hooks.currentDecoratorName;
+    hooks.currentDecoratorName = fn.name;
+
+    if (hooks.prevMountedDecorators.has(fn)) {
+      hooks.currentPhase = 'UPDATE';
+      hooks.currentHooks = hooks.hookListsMap.get(fn) || [];
+    } else {
+      hooks.currentPhase = 'MOUNT';
+      hooks.currentHooks = [];
+      hooks.hookListsMap.set(fn, hooks.currentHooks);
+      hooks.prevMountedDecorators.add(fn);
+    }
+
+    hooks.nextHookIndex = 0;
+    var prevContext = globalWindow.STORYBOOK_HOOKS_CONTEXT;
+    globalWindow.STORYBOOK_HOOKS_CONTEXT = hooks;
+    var result = fn.apply(void 0, arguments);
+    globalWindow.STORYBOOK_HOOKS_CONTEXT = prevContext;
+
+    if (hooks.currentPhase === 'UPDATE' && hooks.getNextHook() != null) {
+      throw new Error('Rendered fewer hooks than expected. This may be caused by an accidental early return statement.');
+    }
+
+    hooks.currentPhase = prevPhase;
+    hooks.currentHooks = prevHooks;
+    hooks.nextHookIndex = prevNextHookIndex;
+    hooks.currentDecoratorName = prevDecoratorName;
+    return result;
+  };
+} // Counter to prevent infinite loops.
+
+
+var numberOfRenders = 0;
+var RENDER_LIMIT = 25;
+export var applyHooks = function applyHooks(applyDecorators) {
+  return function (storyFn, decorators) {
+    var decorated = applyDecorators(hookify(storyFn), decorators.map(function (decorator) {
+      return hookify(decorator);
+    }));
+    return function (context) {
+      var _ref2 = context,
+          hooks = _ref2.hooks;
+      hooks.prevMountedDecorators = hooks.mountedDecorators;
+      hooks.mountedDecorators = new Set([storyFn].concat(_toConsumableArray(decorators)));
+      hooks.currentContext = context;
+      hooks.hasUpdates = false;
+      var result = decorated(context);
+      numberOfRenders = 1;
+
+      while (hooks.hasUpdates) {
+        hooks.hasUpdates = false;
+        hooks.currentEffects = [];
+        result = decorated(context);
+        numberOfRenders += 1;
+
+        if (numberOfRenders > RENDER_LIMIT) {
+          throw new Error('Too many re-renders. Storybook limits the number of renders to prevent an infinite loop.');
+        }
+      }
+
+      hooks.addRenderListeners();
+      return result;
+    };
+  };
+};
+
+var areDepsEqual = function areDepsEqual(deps, nextDeps) {
+  return deps.length === nextDeps.length && deps.every(function (dep, i) {
+    return dep === nextDeps[i];
+  });
+};
+
+var invalidHooksError = function invalidHooksError() {
+  return new Error('Storybook preview hooks can only be called inside decorators and story functions.');
+};
+
+function getHooksContextOrNull() {
+  return globalWindow.STORYBOOK_HOOKS_CONTEXT || null;
+}
+
+function getHooksContextOrThrow() {
+  var hooks = getHooksContextOrNull();
+
+  if (hooks == null) {
+    throw invalidHooksError();
+  }
+
+  return hooks;
+}
+
+function useHook(name, callback, deps) {
+  var hooks = getHooksContextOrThrow();
+
+  if (hooks.currentPhase === 'MOUNT') {
+    if (deps != null && !Array.isArray(deps)) {
+      logger.warn("".concat(name, " received a final argument that is not an array (instead, received ").concat(deps, "). When specified, the final argument must be an array."));
+    }
+
+    var _hook = {
+      name: name,
+      deps: deps
+    };
+    hooks.currentHooks.push(_hook);
+    callback(_hook);
+    return _hook;
+  }
+
+  if (hooks.currentPhase === 'UPDATE') {
+    var _hook2 = hooks.getNextHook();
+
+    if (_hook2 == null) {
+      throw new Error('Rendered more hooks than during the previous render.');
+    }
+
+    if (_hook2.name !== name) {
+      logger.warn("Storybook has detected a change in the order of Hooks".concat(hooks.currentDecoratorName ? " called by ".concat(hooks.currentDecoratorName) : '', ". This will lead to bugs and errors if not fixed."));
+    }
+
+    if (deps != null && _hook2.deps == null) {
+      logger.warn("".concat(name, " received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders."));
+    }
+
+    if (deps != null && _hook2.deps != null && deps.length !== _hook2.deps.length) {
+      logger.warn("The final argument passed to ".concat(name, " changed size between renders. The order and size of this array must remain constant.\nPrevious: ").concat(_hook2.deps, "\nIncoming: ").concat(deps));
+    }
+
+    if (deps == null || _hook2.deps == null || !areDepsEqual(deps, _hook2.deps)) {
+      callback(_hook2);
+      _hook2.deps = deps;
+    }
+
+    return _hook2;
+  }
+
+  throw invalidHooksError();
+}
+
+function useMemoLike(name, nextCreate, deps) {
+  var _useHook = useHook(name, function (hook) {
+    // eslint-disable-next-line no-param-reassign
+    hook.memoizedState = nextCreate();
+  }, deps),
+      memoizedState = _useHook.memoizedState;
+
+  return memoizedState;
+}
+/* Returns a memoized value, see https://reactjs.org/docs/hooks-reference.html#usememo */
+
+
+export function useMemo(nextCreate, deps) {
+  return useMemoLike('useMemo', nextCreate, deps);
+}
+/* Returns a memoized callback, see https://reactjs.org/docs/hooks-reference.html#usecallback */
+
+export function useCallback(callback, deps) {
+  return useMemoLike('useCallback', function () {
+    return callback;
+  }, deps);
+}
+
+function useRefLike(name, initialValue) {
+  return useMemoLike(name, function () {
+    return {
+      current: initialValue
+    };
+  }, []);
+}
+/* Returns a mutable ref object, see https://reactjs.org/docs/hooks-reference.html#useref */
+
+
+export function useRef(initialValue) {
+  return useRefLike('useRef', initialValue);
+}
+
+function triggerUpdate() {
+  var hooks = getHooksContextOrNull(); // Rerun storyFn if updates were triggered synchronously, force rerender otherwise
+
+  if (hooks != null && hooks.currentPhase !== 'NONE') {
+    hooks.hasUpdates = true;
+  } else {
+    try {
+      addons.getChannel().emit(FORCE_RE_RENDER);
+    } catch (e) {
+      logger.warn('State updates of Storybook preview hooks work only in browser');
+    }
+  }
+}
+
+function useStateLike(name, initialState) {
+  var stateRef = useRefLike(name, // @ts-ignore S type should never be function, but there's no way to tell that to TypeScript
+  typeof initialState === 'function' ? initialState() : initialState);
+
+  var setState = function setState(update) {
+    // @ts-ignore S type should never be function, but there's no way to tell that to TypeScript
+    stateRef.current = typeof update === 'function' ? update(stateRef.current) : update;
+    triggerUpdate();
+  };
+
+  return [stateRef.current, setState];
+}
+/* Returns a stateful value, and a function to update it, see https://reactjs.org/docs/hooks-reference.html#usestate */
+
+
+export function useState(initialState) {
+  return useStateLike('useState', initialState);
+}
+/* A redux-like alternative to useState, see https://reactjs.org/docs/hooks-reference.html#usereducer */
+
+export function useReducer(reducer, initialArg, init) {
+  var initialState = init != null ? function () {
+    return init(initialArg);
+  } : initialArg;
+
+  var _useStateLike = useStateLike('useReducer', initialState),
+      _useStateLike2 = _slicedToArray(_useStateLike, 2),
+      state = _useStateLike2[0],
+      setState = _useStateLike2[1];
+
+  var dispatch = function dispatch(action) {
+    return setState(function (prevState) {
+      return reducer(prevState, action);
+    });
+  };
+
+  return [state, dispatch];
+}
+/*
+  Triggers a side effect, see https://reactjs.org/docs/hooks-reference.html#usestate
+  Effects are triggered synchronously after rendering the story
+*/
+
+export function useEffect(create, deps) {
+  var hooks = getHooksContextOrThrow();
+  var effect = useMemoLike('useEffect', function () {
+    return {
+      create: create
+    };
+  }, deps);
+
+  if (!hooks.currentEffects.includes(effect)) {
+    hooks.currentEffects.push(effect);
+  }
+}
+
+/* Accepts a map of Storybook channel event listeners, returns an emit function */
+export function useChannel(eventMap) {
+  var deps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  var channel = addons.getChannel();
+  useEffect(function () {
+    Object.entries(eventMap).forEach(function (_ref3) {
+      var _ref4 = _slicedToArray(_ref3, 2),
+          type = _ref4[0],
+          listener = _ref4[1];
+
+      return channel.on(type, listener);
+    });
+    return function () {
+      Object.entries(eventMap).forEach(function (_ref5) {
+        var _ref6 = _slicedToArray(_ref5, 2),
+            type = _ref6[0],
+            listener = _ref6[1];
+
+        return channel.removeListener(type, listener);
+      });
+    };
+  }, [].concat(_toConsumableArray(Object.keys(eventMap)), _toConsumableArray(deps)));
+  return useCallback(channel.emit.bind(channel), [channel]);
+}
+/* Returns current story context */
+
+export function useStoryContext() {
+  var _getHooksContextOrThr = getHooksContextOrThrow(),
+      currentContext = _getHooksContextOrThr.currentContext;
+
+  if (currentContext == null) {
+    throw invalidHooksError();
+  }
+
+  return currentContext;
+}
+/* Returns current value of a story parameter */
+
+export function useParameter(parameterKey, defaultValue) {
+  var _useStoryContext = useStoryContext(),
+      parameters = _useStoryContext.parameters;
+
+  if (parameterKey) {
+    var _parameters$parameter;
+
+    return (_parameters$parameter = parameters[parameterKey]) !== null && _parameters$parameter !== void 0 ? _parameters$parameter : defaultValue;
+  }
+
+  return undefined;
+}
+/* Returns current value of story args */
+
+export function useArgs() {
+  var channel = addons.getChannel();
+
+  var _useStoryContext2 = useStoryContext(),
+      storyId = _useStoryContext2.id,
+      args = _useStoryContext2.args;
+
+  var updateArgs = useCallback(function (updatedArgs) {
+    return channel.emit(UPDATE_STORY_ARGS, {
+      storyId: storyId,
+      updatedArgs: updatedArgs
+    });
+  }, [channel, storyId]);
+  var resetArgs = useCallback(function (argNames) {
+    return channel.emit(RESET_STORY_ARGS, {
+      storyId: storyId,
+      argNames: argNames
+    });
+  }, [channel, storyId]);
+  return [args, updateArgs, resetArgs];
+}
+/* Returns current value of global args */
+
+export function useGlobals() {
+  var channel = addons.getChannel();
+
+  var _useStoryContext3 = useStoryContext(),
+      globals = _useStoryContext3.globals;
+
+  var updateGlobals = useCallback(function (newGlobals) {
+    return channel.emit(UPDATE_GLOBALS, {
+      globals: newGlobals
+    });
+  }, [channel]);
+  return [globals, updateGlobals];
+}

package/dist/collection/node_modules/@storybook/addons/dist/esm/index.js

@@ -0,0 +1,133 @@
+import "core-js/modules/es.object.assign.js";
+import "core-js/modules/web.dom-collections.for-each.js";
+import "core-js/modules/es.object.values.js";
+import "core-js/modules/es.promise.js";
+import "core-js/modules/es.object.to-string.js";
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+import global from 'global';
+import { Channel } from '@storybook/channels';
+import { logger } from '@storybook/client-logger';
+import { types } from './types';
+export { Channel };
+export var AddonStore = function AddonStore() {
+  var _this = this;
+
+  _classCallCheck(this, AddonStore);
+
+  this.loaders = {};
+  this.elements = {};
+  this.config = {};
+  this.channel = void 0;
+  this.serverChannel = void 0;
+  this.promise = void 0;
+  this.resolve = void 0;
+
+  this.getChannel = function () {
+    // this.channel should get overwritten by setChannel. If it wasn't called (e.g. in non-browser environment), throw.
+    if (!_this.channel) {
+      throw new Error('Accessing non-existent addons channel, see https://storybook.js.org/basics/faq/#why-is-there-no-addons-channel');
+    }
+
+    return _this.channel;
+  };
+
+  this.getServerChannel = function () {
+    if (!_this.serverChannel) {
+      throw new Error('Accessing non-existent serverChannel');
+    }
+
+    return _this.serverChannel;
+  };
+
+  this.ready = function () {
+    return _this.promise;
+  };
+
+  this.hasChannel = function () {
+    return !!_this.channel;
+  };
+
+  this.hasServerChannel = function () {
+    return !!_this.serverChannel;
+  };
+
+  this.setChannel = function (channel) {
+    _this.channel = channel;
+
+    _this.resolve();
+  };
+
+  this.setServerChannel = function (channel) {
+    _this.serverChannel = channel;
+  };
+
+  this.getElements = function (type) {
+    if (!_this.elements[type]) {
+      _this.elements[type] = {};
+    }
+
+    return _this.elements[type];
+  };
+
+  this.addPanel = function (name, options) {
+    _this.add(name, Object.assign({
+      type: types.PANEL
+    }, options));
+  };
+
+  this.add = function (name, addon) {
+    var type = addon.type;
+
+    var collection = _this.getElements(type);
+
+    collection[name] = Object.assign({
+      id: name
+    }, addon);
+  };
+
+  this.setConfig = function (value) {
+    Object.assign(_this.config, value);
+  };
+
+  this.getConfig = function () {
+    return _this.config;
+  };
+
+  this.register = function (name, registerCallback) {
+    if (_this.loaders[name]) {
+      logger.warn("".concat(name, " was loaded twice, this could have bad side-effects"));
+    }
+
+    _this.loaders[name] = registerCallback;
+  };
+
+  this.loadAddons = function (api) {
+    Object.values(_this.loaders).forEach(function (value) {
+      return value(api);
+    });
+  };
+
+  this.promise = new Promise(function (res) {
+    _this.resolve = function () {
+      return res(_this.getChannel());
+    };
+  });
+}; // Enforce addons store to be a singleton
+
+var KEY = '__STORYBOOK_ADDONS';
+
+function getAddonsStore() {
+  if (!global[KEY]) {
+    global[KEY] = new AddonStore();
+  }
+
+  return global[KEY];
+} // Exporting this twice in order to to be able to import it like { addons } instead of 'addons'
+// prefer import { addons } from '@storybook/addons' over import addons from '@storybook/addons'
+//
+// See public_api.ts
+
+
+export var addons = getAddonsStore();

package/dist/collection/node_modules/@storybook/addons/dist/esm/make-decorator.js

@@ -0,0 +1,53 @@
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.array.concat.js";
+export var makeDecorator = function makeDecorator(_ref) {
+  var name = _ref.name,
+      parameterName = _ref.parameterName,
+      wrapper = _ref.wrapper,
+      _ref$skipIfNoParamete = _ref.skipIfNoParametersOrOptions,
+      skipIfNoParametersOrOptions = _ref$skipIfNoParamete === void 0 ? false : _ref$skipIfNoParamete;
+
+  var decorator = function decorator(options) {
+    return function (storyFn, context) {
+      var parameters = context.parameters && context.parameters[parameterName];
+
+      if (parameters && parameters.disable) {
+        return storyFn(context);
+      }
+
+      if (skipIfNoParametersOrOptions && !options && !parameters) {
+        return storyFn(context);
+      }
+
+      return wrapper(storyFn, context, {
+        options: options,
+        parameters: parameters
+      });
+    };
+  };
+
+  return function () {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    // Used without options as .addDecorator(decorator)
+    if (typeof args[0] === 'function') {
+      return decorator().apply(void 0, args);
+    }
+
+    return function () {
+      // Used as [.]addDecorator(decorator(options))
+      if (arguments.length > 1) {
+        // Used as [.]addDecorator(decorator(option1, option2))
+        if (args.length > 1) {
+          return decorator(args).apply(void 0, arguments);
+        }
+
+        return decorator.apply(void 0, args).apply(void 0, arguments);
+      }
+
+      throw new Error("Passing stories directly into ".concat(name, "() is not allowed,\n        instead use addDecorator(").concat(name, ") and pass options with the '").concat(parameterName, "' parameter"));
+    };
+  };
+};

package/dist/collection/node_modules/@storybook/addons/dist/esm/public_api.js

@@ -0,0 +1,12 @@
+// There can only be 1 default export per entry point and it has to be directly from public_api
+// Exporting this twice in order to to be able to import it like { addons } instead of 'addons'
+// prefer import { addons } from '@storybook/addons' over import addons from '@storybook/addons'
+//
+// See index.ts
+import { addons } from './index';
+export * from './make-decorator';
+export * from './index';
+export * from './types';
+export * from './storybook-channel-mock';
+export * from './hooks';
+export default addons;

package/dist/collection/node_modules/@storybook/addons/dist/esm/storybook-channel-mock.js

@@ -0,0 +1,10 @@
+import Channel from '@storybook/channels';
+export function mockChannel() {
+  var transport = {
+    setHandler: function setHandler() {},
+    send: function send() {}
+  };
+  return new Channel({
+    transport: transport
+  });
+}