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

package/dist/collection/node_modules/@storybook/builder-webpack4/dist/esm/preview/virtualModuleEntry.template.js

@@ -0,0 +1,73 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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; }
+
+/* eslint-disable import/no-unresolved */
+import { addDecorator, addParameters, addLoader, addArgsEnhancer, addArgTypesEnhancer, setGlobalRender } from '{{clientApi}}';
+import { logger } from '{{clientLogger}}';
+import * as config from '{{configFilename}}';
+Object.keys(config).forEach(function (key) {
+  var value = config[key];
+
+  switch (key) {
+    case 'args':
+    case 'argTypes':
+      {
+        return logger.warn('Invalid args/argTypes in config, ignoring.', JSON.stringify(value));
+      }
+
+    case 'decorators':
+      {
+        return value.forEach(function (decorator) {
+          return addDecorator(decorator, false);
+        });
+      }
+
+    case 'loaders':
+      {
+        return value.forEach(function (loader) {
+          return addLoader(loader, false);
+        });
+      }
+
+    case 'parameters':
+      {
+        return addParameters(_objectSpread({}, value), false);
+      }
+
+    case 'argTypesEnhancers':
+      {
+        return value.forEach(function (enhancer) {
+          return addArgTypesEnhancer(enhancer);
+        });
+      }
+
+    case 'argsEnhancers':
+      {
+        return value.forEach(function (enhancer) {
+          return addArgsEnhancer(enhancer);
+        });
+      }
+
+    case 'render':
+      {
+        return setGlobalRender(value);
+      }
+
+    case 'globals':
+    case 'globalTypes':
+      {
+        var v = {};
+        v[key] = value;
+        return addParameters(v, false);
+      }
+
+    default:
+      {
+        // eslint-disable-next-line prefer-template
+        return console.log(key + ' was not supported :( !');
+      }
+  }
+});

package/dist/collection/node_modules/@storybook/builder-webpack4/dist/esm/preview/virtualModuleStory.template.js

@@ -0,0 +1,3 @@
+/* eslint-disable import/no-unresolved */
+import { configure } from '{{frameworkImportPath}}';
+configure(['{{stories}}'], module, false);

package/dist/collection/node_modules/@storybook/builder-webpack4/dist/modern/index.js

@@ -0,0 +1,192 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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; }
+
+import "core-js/modules/es.promise.js";
+import webpackReal, { ProgressPlugin } from 'webpack'; // @ts-ignore
+
+import webpackDevMiddleware from 'webpack-dev-middleware';
+import webpackHotMiddleware from 'webpack-hot-middleware';
+import { logger } from '@storybook/node-logger';
+import { useProgressReporting, checkWebpackVersion } from '@storybook/core-common';
+var compilation;
+var reject;
+export var executor = {
+  get: async function (options) {
+    var _await$options$preset;
+
+    var version = (await options.presets.apply('webpackVersion')) || '4';
+    var webpackInstance = ((_await$options$preset = await options.presets.apply('webpackInstance')) === null || _await$options$preset === void 0 ? void 0 : _await$options$preset.default) || webpackReal;
+    checkWebpackVersion({
+      version: version
+    }, '4', 'builder-webpack4');
+    return webpackInstance;
+  }
+};
+export var getConfig = async function (options) {
+  var presets = options.presets;
+  var typescriptOptions = await presets.apply('typescript', {}, options);
+  var babelOptions = await presets.apply('babel', {}, _objectSpread(_objectSpread({}, options), {}, {
+    typescriptOptions: typescriptOptions
+  }));
+  var entries = await presets.apply('entries', [], options);
+  var stories = await presets.apply('stories', [], options);
+  var frameworkOptions = await presets.apply(`${options.framework}Options`, {}, options);
+  return presets.apply('webpack', {}, _objectSpread(_objectSpread({}, options), {}, {
+    babelOptions: babelOptions,
+    entries: entries,
+    stories: stories,
+    typescriptOptions: typescriptOptions,
+    [`${options.framework}Options`]: frameworkOptions
+  }));
+};
+export var makeStatsFromError = function (err) {
+  return {
+    hasErrors: function () {
+      return true;
+    },
+    hasWarnings: function () {
+      return false;
+    },
+    toJson: function () {
+      return {
+        warnings: [],
+        errors: [err]
+      };
+    }
+  };
+};
+export var start = async function ({
+  startTime: startTime,
+  options: options,
+  router: router
+}) {
+  var _config$output;
+
+  var webpackInstance = await executor.get(options);
+  var config = await getConfig(options);
+  var compiler = webpackInstance(config);
+
+  if (!compiler) {
+    var _err = `${config.name}: missing webpack compiler at runtime!`;
+    logger.error(_err);
+    return {
+      bail: bail,
+      totalTime: process.hrtime(startTime),
+      stats: makeStatsFromError(_err)
+    };
+  }
+
+  var _await$useProgressRep = await useProgressReporting(router, startTime, options),
+      handler = _await$useProgressRep.handler,
+      modulesCount = _await$useProgressRep.modulesCount;
+
+  new ProgressPlugin({
+    handler: handler,
+    modulesCount: modulesCount
+  }).apply(compiler);
+  var middlewareOptions = {
+    publicPath: (_config$output = config.output) === null || _config$output === void 0 ? void 0 : _config$output.publicPath,
+    writeToDisk: true,
+    logLevel: 'error',
+    watchOptions: config.watchOptions || {}
+  };
+  compilation = webpackDevMiddleware(compiler, middlewareOptions);
+  router.use(compilation);
+  router.use(webpackHotMiddleware(compiler));
+  var waitUntilValid = compilation.waitUntilValid.bind(compilation);
+  var stats = await new Promise(function (ready, stop) {
+    waitUntilValid(ready);
+    reject = stop;
+  });
+
+  if (!stats) {
+    throw new Error('no stats after building preview');
+  }
+
+  if (stats.hasErrors()) {
+    throw stats;
+  }
+
+  return {
+    bail: bail,
+    stats: stats,
+    totalTime: process.hrtime(startTime)
+  };
+};
+export var bail = function (e) {
+  if (reject) {
+    reject();
+  }
+
+  if (process) {
+    try {
+      compilation.close();
+      logger.warn('Force closed preview build');
+    } catch (err) {
+      logger.warn('Unable to close preview build!');
+    }
+  }
+
+  throw e;
+};
+export var build = async function ({
+  options: options,
+  startTime: startTime
+}) {
+  var webpackInstance = await executor.get(options);
+  logger.info('=> Compiling preview..');
+  var config = await getConfig(options);
+  var compiler = webpackInstance(config);
+
+  if (!compiler) {
+    var _err2 = `${config.name}: missing webpack compiler at runtime!`;
+    logger.error(_err2);
+    return Promise.resolve(makeStatsFromError(_err2));
+  }
+
+  return new Promise(function (succeed, fail) {
+    compiler.run(function (error, stats) {
+      if (error || !stats || stats.hasErrors()) {
+        logger.error('=> Failed to build the preview');
+        process.exitCode = 1;
+
+        if (error) {
+          logger.error(error.message);
+          return fail(error);
+        }
+
+        if (stats && (stats.hasErrors() || stats.hasWarnings())) {
+          var _stats$toJson = stats.toJson(config.stats),
+              warnings = _stats$toJson.warnings,
+              errors = _stats$toJson.errors;
+
+          errors.forEach(function (e) {
+            return logger.error(e);
+          });
+          warnings.forEach(function (e) {
+            return logger.error(e);
+          });
+          return fail(stats);
+        }
+      }
+
+      logger.trace({
+        message: '=> Preview built',
+        time: process.hrtime(startTime)
+      });
+
+      if (stats) {
+        stats.toJson(config.stats).warnings.forEach(function (e) {
+          return logger.warn(e);
+        });
+      }
+
+      return succeed(stats);
+    });
+  });
+};
+export var corePresets = [require.resolve('./presets/preview-preset.js')];
+export var overridePresets = [require.resolve('./presets/custom-webpack-preset.js')];

package/dist/collection/node_modules/@storybook/builder-webpack4/dist/modern/presets/custom-webpack-preset.js

@@ -0,0 +1,45 @@
+import "core-js/modules/es.promise.js";
+import * as webpackReal from 'webpack';
+import { logger } from '@storybook/node-logger';
+import { loadCustomWebpackConfig } from '@storybook/core-common';
+import { createDefaultWebpackConfig } from '../preview/base-webpack.config';
+export async function webpack(config, options) {
+  // @ts-ignore
+  var configDir = options.configDir,
+      configType = options.configType,
+      presets = options.presets,
+      webpackConfig = options.webpackConfig;
+  var coreOptions = await presets.apply('core');
+  var defaultConfig = config;
+
+  if (!(coreOptions !== null && coreOptions !== void 0 && coreOptions.disableWebpackDefaults)) {
+    defaultConfig = await createDefaultWebpackConfig(config, options);
+  }
+
+  var finalDefaultConfig = await presets.apply('webpackFinal', defaultConfig, options); // through standalone webpackConfig option
+
+  if (webpackConfig) {
+    return webpackConfig(finalDefaultConfig);
+  } // Check whether user has a custom webpack config file and
+  // return the (extended) base configuration if it's not available.
+
+
+  var customConfig = loadCustomWebpackConfig(configDir);
+
+  if (typeof customConfig === 'function') {
+    logger.info('=> Loading custom Webpack config (full-control mode).');
+    return customConfig({
+      config: finalDefaultConfig,
+      mode: configType
+    });
+  }
+
+  logger.info('=> Using default Webpack4 setup');
+  return finalDefaultConfig;
+}
+export var webpackInstance = async function () {
+  return webpackReal;
+};
+export var webpackVersion = async function () {
+  return '4';
+};

package/dist/collection/node_modules/@storybook/builder-webpack4/dist/modern/presets/preview-preset.js

@@ -0,0 +1,18 @@
+import "core-js/modules/es.promise.js";
+import webpackConfig from '../preview/iframe-webpack.config';
+import { createPreviewEntry } from '../preview/entries';
+export var webpack = async function (_, options) {
+  return webpackConfig(options);
+};
+export var entries = async function (_, options) {
+  var result = [];
+  result = result.concat(await createPreviewEntry(options));
+
+  if (options.configType === 'DEVELOPMENT') {
+    // Suppress informational messages when --quiet is specified. webpack-hot-middleware's quiet
+    // parameter would also suppress warnings.
+    result = result.concat(`${require.resolve('webpack-hot-middleware/client')}?reload=true&quiet=false&noInfo=${options.quiet}`);
+  }
+
+  return result;
+};

package/dist/collection/node_modules/@storybook/builder-webpack4/dist/modern/preview/babel-loader-preview.js

@@ -0,0 +1,13 @@
+import { getProjectRoot } from '@storybook/core-common';
+import { useBaseTsSupport } from './useBaseTsSupport';
+export var createBabelLoader = function (options, framework) {
+  return {
+    test: useBaseTsSupport(framework) ? /\.(mjs|tsx?|jsx?)$/ : /\.(mjs|jsx?)$/,
+    use: [{
+      loader: require.resolve('babel-loader'),
+      options: options
+    }],
+    include: [getProjectRoot()],
+    exclude: /node_modules/
+  };
+};

package/dist/collection/node_modules/@storybook/builder-webpack4/dist/modern/preview/base-webpack.config.js

@@ -0,0 +1,113 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+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; }
+
+import "core-js/modules/es.promise.js";
+import autoprefixer from 'autoprefixer';
+import findUp from 'find-up';
+import path from 'path';
+import { logger } from '@storybook/node-logger';
+import deprecate from 'util-deprecate';
+import dedent from 'ts-dedent';
+var warnImplicitPostcssPlugins = deprecate(function () {
+  return {
+    // Additional config is merged with config, so we have it disabled currently
+    config: false,
+    plugins: [require('postcss-flexbugs-fixes'), // eslint-disable-line global-require
+    autoprefixer({
+      flexbox: 'no-2009'
+    })]
+  };
+}, dedent`
+    Default PostCSS plugins are deprecated. When switching to '@storybook/addon-postcss',
+    you will need to add your own plugins, such as 'postcss-flexbugs-fixes' and 'autoprefixer'.
+
+    See https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-default-postcss-plugins for details.
+  `);
+var warnGetPostcssOptions = deprecate(function () {}, dedent`
+    Relying on the implicit PostCSS loader is deprecated and will be removed in Storybook 7.0.
+    If you need PostCSS, include '@storybook/addon-postcss' in your '.storybook/main.js' file.
+
+    See https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#deprecated-implicit-postcss-loader for details.
+    `);
+
+var getPostcssOptions = async function () {
+  var postcssConfigFiles = ['.postcssrc', '.postcssrc.json', '.postcssrc.yml', '.postcssrc.js', 'postcss.config.js']; // This is done naturally by newer postcss-loader (through cosmiconfig)
+
+  var customPostcssConfig = await findUp(postcssConfigFiles);
+
+  if (customPostcssConfig) {
+    logger.info(`=> Using custom ${path.basename(customPostcssConfig)}`);
+    warnGetPostcssOptions();
+    return {
+      config: customPostcssConfig
+    };
+  }
+
+  return warnImplicitPostcssPlugins();
+};
+
+var presetName = function (preset) {
+  return typeof preset === 'string' ? preset : preset.name;
+};
+
+export async function createDefaultWebpackConfig(storybookBaseConfig, options) {
+  if (options.presetsList.some(function (preset) {
+    return /@storybook(\/|\\)preset-create-react-app/.test(presetName(preset));
+  })) {
+    return storybookBaseConfig;
+  }
+
+  var hasPostcssAddon = options.presetsList.some(function (preset) {
+    return /@storybook(\/|\\)addon-postcss/.test(presetName(preset));
+  });
+  var features = await options.presets.apply('features');
+  var cssLoaders = {};
+
+  if (!hasPostcssAddon) {
+    logger.info(`=> Using implicit CSS loaders`);
+    var use = [// TODO(blaine): Decide if we want to keep style-loader & css-loader in core
+    // Trying to apply style-loader or css-loader to files that already have been
+    // processed by them causes webpack to crash, so no one else can add similar
+    // loader configurations to the `.css` extension.
+    require.resolve('style-loader'), {
+      loader: require.resolve('css-loader'),
+      options: {
+        importLoaders: 1
+      }
+    }, (features === null || features === void 0 ? void 0 : features.postcss) !== false ? {
+      loader: require.resolve('postcss-loader'),
+      options: {
+        postcssOptions: await getPostcssOptions()
+      }
+    } : null];
+    cssLoaders = {
+      test: /\.css$/,
+      sideEffects: true,
+      use: use.filter(Boolean)
+    };
+  }
+
+  var isProd = storybookBaseConfig.mode !== 'development';
+  return _objectSpread(_objectSpread({}, storybookBaseConfig), {}, {
+    module: _objectSpread(_objectSpread({}, storybookBaseConfig.module), {}, {
+      rules: [...storybookBaseConfig.module.rules, cssLoaders, {
+        test: /\.(svg|ico|jpg|jpeg|png|apng|gif|eot|otf|webp|ttf|woff|woff2|cur|ani|pdf)(\?.*)?$/,
+        loader: require.resolve('file-loader'),
+        options: {
+          esModule: false,
+          name: isProd ? 'static/media/[name].[contenthash:8].[ext]' : 'static/media/[path][name].[ext]'
+        }
+      }, {
+        test: /\.(mp4|webm|wav|mp3|m4a|aac|oga)(\?.*)?$/,
+        loader: require.resolve('url-loader'),
+        options: {
+          limit: 10000,
+          name: isProd ? 'static/media/[name].[contenthash:8].[ext]' : 'static/media/[path][name].[ext]'
+        }
+      }]
+    })
+  });
+}

package/dist/collection/node_modules/@storybook/builder-webpack4/dist/modern/preview/entries.js

@@ -0,0 +1,86 @@
+import "core-js/modules/es.promise.js";
+import path from 'path';
+import { logger } from '@storybook/node-logger';
+import stable from 'stable';
+import dedent from 'ts-dedent';
+import glob from 'glob-promise';
+import { loadPreviewOrConfigFile } from '@storybook/core-common';
+export var sortEntries = function (entries) {
+  var isGenerated = /generated-(config|other)-entry/;
+  var isGeneratedConfig = /(?:preview|config)\..+-generated-config-entry/;
+  return stable(entries.slice(0), function (a, b) {
+    // We need to ensure that all parameters and decorators that are added by preview entry-points added by addons happen before any configure() calls executed by the user's preview.js (or config.js), or by main.js:stories.
+    // As those addons will create generated entries, this means we need to ensure all generated entries come before all other entries (generated or otherwise).
+    switch (true) {
+      case !!a.match(isGeneratedConfig) && !!b.match(isGenerated):
+        {
+          return 1;
+        }
+
+      case !!b.match(isGeneratedConfig) && !!a.match(isGenerated):
+        {
+          return -1;
+        }
+
+      default:
+        {
+          return 0;
+        }
+    }
+  });
+};
+
+var getMainConfigs = function (options) {
+  var previewPath = loadPreviewOrConfigFile(options);
+  return previewPath ? [previewPath] : [];
+};
+
+export async function createPreviewEntry(options) {
+  var configDir = options.configDir,
+      presets = options.presets;
+  var entries = [...(await presets.apply('previewEntries', [], options)), path.resolve(path.join(configDir, 'storybook-init-framework-entry.js'))];
+  var configs = getMainConfigs(options);
+  var other = await presets.apply('config', [], options);
+  var stories = await presets.apply('stories', [], options);
+
+  if (configs.length > 0) {
+    var noun = configs.length === 1 ? 'file' : 'files';
+    logger.info(`=> Loading ${configs.length} config ${noun} in "${configDir}"`);
+    entries.push(...configs.map(function (filename) {
+      return `${filename}-generated-config-entry.js`;
+    }));
+  }
+
+  if (other && other.length > 0) {
+    var _noun = other.length === 1 ? 'file' : 'files';
+
+    logger.info(`=> Loading ${other.length} other ${_noun} in "${configDir}"`);
+    entries.push(...other.map(function (filename) {
+      return `${filename}-generated-other-entry.js`;
+    }));
+  }
+
+  if (stories && stories.length) {
+    entries.push(path.resolve(path.join(configDir, `generated-stories-entry.js`)));
+    var files = (await Promise.all(stories.map(function (g) {
+      return glob(path.isAbsolute(g) ? g : path.join(configDir, g));
+    }))).reduce(function (a, b) {
+      return a.concat(b);
+    });
+
+    if (files.length === 0) {
+      logger.warn(dedent`
+        We found no files matching any of the following globs:
+        
+        ${stories.join('\n')}
+
+        Maybe your glob was invalid?
+        see: https://github.com/storybookjs/storybook/blob/next/MIGRATION.md#correct-globs-in-mainjs
+      `);
+    } else {
+      logger.info(`=> Adding stories defined in "${path.join(configDir, 'main.js')}"`);
+    }
+  }
+
+  return sortEntries(entries);
+}