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

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/extractDocgenProps.js

@@ -0,0 +1,87 @@
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.object.assign.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.array.filter.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import { parseJsDoc } from '../jsdocParser';
+import { TypeSystem } from './types';
+import { getDocgenSection, isValidDocgenSection, getDocgenDescription } from './utils';
+import { getPropDefFactory } from './createPropDef';
+
+var getTypeSystem = function getTypeSystem(docgenInfo) {
+  if (docgenInfo.type != null) {
+    return TypeSystem.JAVASCRIPT;
+  }
+
+  if (docgenInfo.flowType != null) {
+    return TypeSystem.FLOW;
+  }
+
+  if (docgenInfo.tsType != null) {
+    return TypeSystem.TYPESCRIPT;
+  }
+
+  return TypeSystem.UNKNOWN;
+};
+
+export var extractComponentSectionArray = function extractComponentSectionArray(docgenSection) {
+  var typeSystem = getTypeSystem(docgenSection[0]);
+  var createPropDef = getPropDefFactory(typeSystem);
+  return docgenSection.map(function (item) {
+    var _item$type;
+
+    var sanitizedItem = item;
+
+    if ((_item$type = item.type) !== null && _item$type !== void 0 && _item$type.elements) {
+      sanitizedItem = Object.assign({}, item, {
+        type: Object.assign({}, item.type, {
+          value: item.type.elements
+        })
+      });
+    }
+
+    return extractProp(sanitizedItem.name, sanitizedItem, typeSystem, createPropDef);
+  });
+};
+export var extractComponentSectionObject = function extractComponentSectionObject(docgenSection) {
+  var docgenPropsKeys = Object.keys(docgenSection);
+  var typeSystem = getTypeSystem(docgenSection[docgenPropsKeys[0]]);
+  var createPropDef = getPropDefFactory(typeSystem);
+  return docgenPropsKeys.map(function (propName) {
+    var docgenInfo = docgenSection[propName];
+    return docgenInfo != null ? extractProp(propName, docgenInfo, typeSystem, createPropDef) : null;
+  }).filter(Boolean);
+};
+export var extractComponentProps = function extractComponentProps(component, section) {
+  var docgenSection = getDocgenSection(component, section);
+
+  if (!isValidDocgenSection(docgenSection)) {
+    return [];
+  } // vue-docgen-api has diverged from react-docgen and returns an array
+
+
+  return Array.isArray(docgenSection) ? extractComponentSectionArray(docgenSection) : extractComponentSectionObject(docgenSection);
+};
+
+function extractProp(propName, docgenInfo, typeSystem, createPropDef) {
+  var jsDocParsingResult = parseJsDoc(docgenInfo.description);
+  var isIgnored = jsDocParsingResult.includesJsDoc && jsDocParsingResult.ignore;
+
+  if (!isIgnored) {
+    var propDef = createPropDef(propName, docgenInfo, jsDocParsingResult);
+    return {
+      propDef: propDef,
+      jsDocTags: jsDocParsingResult.extractedTags,
+      docgenInfo: docgenInfo,
+      typeSystem: typeSystem
+    };
+  }
+
+  return null;
+}
+
+export function extractComponentDescription(component) {
+  return component != null && getDocgenDescription(component);
+}

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/flow/createDefaultValue.js

@@ -0,0 +1,14 @@
+import "core-js/modules/es.function.name.js";
+import { createSummaryValue, isTooLongForDefaultValueSummary } from '../../utils';
+import { isDefaultValueBlacklisted } from '../utils/defaultValue';
+export function createDefaultValue(defaultValue, type) {
+  if (defaultValue != null) {
+    var value = defaultValue.value;
+
+    if (!isDefaultValueBlacklisted(value)) {
+      return !isTooLongForDefaultValueSummary(value) ? createSummaryValue(value) : createSummaryValue(type.name, value);
+    }
+  }
+
+  return null;
+}

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/flow/createPropDef.js

@@ -0,0 +1,17 @@
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import { createType } from './createType';
+import { createDefaultValue } from './createDefaultValue';
+export var createFlowPropDef = function createFlowPropDef(propName, docgenInfo) {
+  var flowType = docgenInfo.flowType,
+      description = docgenInfo.description,
+      required = docgenInfo.required,
+      defaultValue = docgenInfo.defaultValue;
+  return {
+    name: propName,
+    type: createType(flowType),
+    required: required,
+    description: description,
+    defaultValue: createDefaultValue(defaultValue, flowType)
+  };
+};

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/flow/createType.js

@@ -0,0 +1,106 @@
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.array.join.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.regexp.exec.js";
+import { createSummaryValue, isTooLongForTypeSummary } from '../../utils';
+var FlowTypesType;
+
+(function (FlowTypesType) {
+  FlowTypesType["UNION"] = "union";
+  FlowTypesType["SIGNATURE"] = "signature";
+})(FlowTypesType || (FlowTypesType = {}));
+
+function generateUnionElement(_ref) {
+  var name = _ref.name,
+      value = _ref.value,
+      elements = _ref.elements,
+      raw = _ref.raw;
+
+  if (value != null) {
+    return value;
+  }
+
+  if (elements != null) {
+    return elements.map(generateUnionElement).join(' | ');
+  }
+
+  if (raw != null) {
+    return raw;
+  }
+
+  return name;
+}
+
+function generateUnion(_ref2) {
+  var name = _ref2.name,
+      raw = _ref2.raw,
+      elements = _ref2.elements;
+
+  if (elements != null) {
+    return createSummaryValue(elements.map(generateUnionElement).join(' | '));
+  }
+
+  if (raw != null) {
+    // Flow Unions can be defined with or without a leading `|` character, so try to remove it.
+    return createSummaryValue(raw.replace(/^\|\s*/, ''));
+  }
+
+  return createSummaryValue(name);
+}
+
+function generateFuncSignature(_ref3) {
+  var type = _ref3.type,
+      raw = _ref3.raw;
+
+  if (raw != null) {
+    return createSummaryValue(raw);
+  }
+
+  return createSummaryValue(type);
+}
+
+function generateObjectSignature(_ref4) {
+  var type = _ref4.type,
+      raw = _ref4.raw;
+
+  if (raw != null) {
+    return !isTooLongForTypeSummary(raw) ? createSummaryValue(raw) : createSummaryValue(type, raw);
+  }
+
+  return createSummaryValue(type);
+}
+
+function generateSignature(flowType) {
+  var type = flowType.type;
+  return type === 'object' ? generateObjectSignature(flowType) : generateFuncSignature(flowType);
+}
+
+function generateDefault(_ref5) {
+  var name = _ref5.name,
+      raw = _ref5.raw;
+
+  if (raw != null) {
+    return !isTooLongForTypeSummary(raw) ? createSummaryValue(raw) : createSummaryValue(name, raw);
+  }
+
+  return createSummaryValue(name);
+}
+
+export function createType(type) {
+  // A type could be null if a defaultProp has been provided without a type definition.
+  if (type == null) {
+    return null;
+  }
+
+  switch (type.name) {
+    case FlowTypesType.UNION:
+      return generateUnion(type);
+
+    case FlowTypesType.SIGNATURE:
+      return generateSignature(type);
+
+    default:
+      return generateDefault(type);
+  }
+}

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/index.js

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './utils';
+export * from './extractDocgenProps';

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/typeScript/createDefaultValue.js

@@ -0,0 +1,15 @@
+import { createSummaryValue } from '../../utils';
+import { isDefaultValueBlacklisted } from '../utils/defaultValue';
+export function createDefaultValue(_ref) {
+  var defaultValue = _ref.defaultValue;
+
+  if (defaultValue != null) {
+    var value = defaultValue.value;
+
+    if (!isDefaultValueBlacklisted(value)) {
+      return createSummaryValue(value);
+    }
+  }
+
+  return null;
+}

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/typeScript/createPropDef.js

@@ -0,0 +1,15 @@
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import { createType } from './createType';
+import { createDefaultValue } from './createDefaultValue';
+export var createTsPropDef = function createTsPropDef(propName, docgenInfo) {
+  var description = docgenInfo.description,
+      required = docgenInfo.required;
+  return {
+    name: propName,
+    type: createType(docgenInfo),
+    required: required,
+    description: description,
+    defaultValue: createDefaultValue(docgenInfo)
+  };
+};

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/typeScript/createType.js

@@ -0,0 +1,19 @@
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.function.name.js";
+import { createSummaryValue } from '../../utils';
+export function createType(_ref) {
+  var tsType = _ref.tsType,
+      required = _ref.required;
+
+  // A type could be null if a defaultProp has been provided without a type definition.
+  if (tsType == null) {
+    return null;
+  }
+
+  if (!required) {
+    return createSummaryValue(tsType.name.replace(' | undefined', ''));
+  }
+
+  return createSummaryValue(tsType.name);
+}

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/types.js

@@ -0,0 +1,10 @@
+// eslint-disable-next-line @typescript-eslint/no-empty-interface
+// export type DocgenType = DocgenPropType | DocgenFlowType | DocgenTypeScriptType;
+export var TypeSystem;
+
+(function (TypeSystem) {
+  TypeSystem["JAVASCRIPT"] = "JavaScript";
+  TypeSystem["FLOW"] = "Flow";
+  TypeSystem["TYPESCRIPT"] = "TypeScript";
+  TypeSystem["UNKNOWN"] = "Unknown";
+})(TypeSystem || (TypeSystem = {}));

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/utils/defaultValue.js

@@ -0,0 +1,6 @@
+var BLACKLIST = ['null', 'undefined'];
+export function isDefaultValueBlacklisted(value) {
+  return BLACKLIST.some(function (x) {
+    return x === value;
+  });
+}

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/utils/docgenInfo.js

@@ -0,0 +1,18 @@
+import "core-js/modules/es.object.keys.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+
+/* eslint-disable no-underscore-dangle */
+import { str } from './string';
+export function hasDocgen(component) {
+  return !!component.__docgenInfo;
+}
+export function isValidDocgenSection(docgenSection) {
+  return docgenSection != null && Object.keys(docgenSection).length > 0;
+}
+export function getDocgenSection(component, section) {
+  return hasDocgen(component) ? component.__docgenInfo[section] : null;
+}
+export function getDocgenDescription(component) {
+  return hasDocgen(component) && str(component.__docgenInfo.description);
+}

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/utils/index.js

@@ -0,0 +1,3 @@
+export * from './defaultValue';
+export * from './string';
+export * from './docgenInfo';

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/docgen/utils/string.js

@@ -0,0 +1,11 @@
+export var str = function str(obj) {
+  if (!obj) {
+    return '';
+  }
+
+  if (typeof obj === 'string') {
+    return obj;
+  }
+
+  throw new Error("Description: expected string, got: ".concat(JSON.stringify(obj)));
+};

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/index.js

@@ -0,0 +1 @@
+export * from './utils';

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/jsdocParser.js

@@ -0,0 +1,207 @@
+import "core-js/modules/es.array.includes.js";
+import "core-js/modules/es.string.includes.js";
+import "core-js/modules/es.symbol.js";
+import "core-js/modules/es.symbol.description.js";
+import "core-js/modules/es.function.name.js";
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.regexp.exec.js";
+import "core-js/modules/es.array.map.js";
+import "core-js/modules/es.array.concat.js";
+import "core-js/modules/es.array.join.js";
+import doctrine from 'doctrine';
+
+function containsJsDoc(value) {
+  return value != null && value.includes('@');
+}
+
+function parse(content, tags) {
+  var ast;
+
+  try {
+    ast = doctrine.parse(content, {
+      tags: tags,
+      sloppy: true
+    });
+  } catch (e) {
+    // eslint-disable-next-line no-console
+    console.error(e);
+    throw new Error('Cannot parse JSDoc tags.');
+  }
+
+  return ast;
+}
+
+var DEFAULT_OPTIONS = {
+  tags: ['param', 'arg', 'argument', 'returns', 'ignore']
+};
+export var parseJsDoc = function parseJsDoc(value) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : DEFAULT_OPTIONS;
+
+  if (!containsJsDoc(value)) {
+    return {
+      includesJsDoc: false,
+      ignore: false
+    };
+  }
+
+  var jsDocAst = parse(value, options.tags);
+  var extractedTags = extractJsDocTags(jsDocAst);
+
+  if (extractedTags.ignore) {
+    // There is no point in doing other stuff since this prop will not be rendered.
+    return {
+      includesJsDoc: true,
+      ignore: true
+    };
+  }
+
+  return {
+    includesJsDoc: true,
+    ignore: false,
+    // Always use the parsed description to ensure JSDoc is removed from the description.
+    description: jsDocAst.description,
+    extractedTags: extractedTags
+  };
+};
+
+function extractJsDocTags(ast) {
+  var extractedTags = {
+    params: null,
+    returns: null,
+    ignore: false
+  };
+
+  for (var i = 0; i < ast.tags.length; i += 1) {
+    var tag = ast.tags[i];
+
+    if (tag.title === 'ignore') {
+      extractedTags.ignore = true; // Once we reach an @ignore tag, there is no point in parsing the other tags since we will not render the prop.
+
+      break;
+    } else {
+      switch (tag.title) {
+        // arg & argument are aliases for param.
+        case 'param':
+        case 'arg':
+        case 'argument':
+          {
+            var paramTag = extractParam(tag);
+
+            if (paramTag != null) {
+              if (extractedTags.params == null) {
+                extractedTags.params = [];
+              }
+
+              extractedTags.params.push(paramTag);
+            }
+
+            break;
+          }
+
+        case 'returns':
+          {
+            var returnsTag = extractReturns(tag);
+
+            if (returnsTag != null) {
+              extractedTags.returns = returnsTag;
+            }
+
+            break;
+          }
+
+        default:
+          break;
+      }
+    }
+  }
+
+  return extractedTags;
+}
+
+function extractParam(tag) {
+  var paramName = tag.name; // When the @param doesn't have a name but have a type and a description, "null-null" is returned.
+
+  if (paramName != null && paramName !== 'null-null') {
+    return {
+      name: tag.name,
+      type: tag.type,
+      description: tag.description,
+      getPrettyName: function getPrettyName() {
+        if (paramName.includes('null')) {
+          // There is a few cases in which the returned param name contains "null".
+          // - @param {SyntheticEvent} event- Original SyntheticEvent
+          // - @param {SyntheticEvent} event.\n@returns {string}
+          return paramName.replace('-null', '').replace('.null', '');
+        }
+
+        return tag.name;
+      },
+      getTypeName: function getTypeName() {
+        return tag.type != null ? extractTypeName(tag.type) : null;
+      }
+    };
+  }
+
+  return null;
+}
+
+function extractReturns(tag) {
+  if (tag.type != null) {
+    return {
+      type: tag.type,
+      description: tag.description,
+      getTypeName: function getTypeName() {
+        return extractTypeName(tag.type);
+      }
+    };
+  }
+
+  return null;
+}
+
+function extractTypeName(type) {
+  if (type.type === 'NameExpression') {
+    return type.name;
+  }
+
+  if (type.type === 'RecordType') {
+    var recordFields = type.fields.map(function (field) {
+      if (field.value != null) {
+        var valueTypeName = extractTypeName(field.value);
+        return "".concat(field.key, ": ").concat(valueTypeName);
+      }
+
+      return field.key;
+    });
+    return "({".concat(recordFields.join(', '), "})");
+  }
+
+  if (type.type === 'UnionType') {
+    var unionElements = type.elements.map(extractTypeName);
+    return "(".concat(unionElements.join('|'), ")");
+  } // Only support untyped array: []. Might add more support later if required.
+
+
+  if (type.type === 'ArrayType') {
+    return '[]';
+  }
+
+  if (type.type === 'TypeApplication') {
+    if (type.expression != null) {
+      if (type.expression.name === 'Array') {
+        var arrayType = extractTypeName(type.applications[0]);
+        return "".concat(arrayType, "[]");
+      }
+    }
+  }
+
+  if (type.type === 'NullableType' || type.type === 'NonNullableType' || type.type === 'OptionalType') {
+    return extractTypeName(type.expression);
+  }
+
+  if (type.type === 'AllLiteral') {
+    return 'any';
+  }
+
+  return null;
+}

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/lib/utils.js

@@ -0,0 +1,25 @@
+import "core-js/modules/es.string.replace.js";
+import "core-js/modules/es.regexp.exec.js";
+export var MAX_TYPE_SUMMARY_LENGTH = 90;
+export var MAX_DEFAULT_VALUE_SUMMARY_LENGTH = 50;
+export function isTooLongForTypeSummary(value) {
+  return value.length > MAX_TYPE_SUMMARY_LENGTH;
+}
+export function isTooLongForDefaultValueSummary(value) {
+  return value.length > MAX_DEFAULT_VALUE_SUMMARY_LENGTH;
+}
+export function createSummaryValue(summary, detail) {
+  if (summary === detail) {
+    return {
+      summary: summary
+    };
+  }
+
+  return {
+    summary: summary,
+    detail: detail
+  };
+}
+export var normalizeNewlines = function normalizeNewlines(string) {
+  return string.replace(/\\r\\n/g, '\\n');
+};

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/register.js

@@ -0,0 +1,21 @@
+import "core-js/modules/es.array.concat.js";
+import { addons, types } from '@storybook/addons';
+import { ADDON_ID, PANEL_ID } from './shared';
+addons.register(ADDON_ID, function () {
+  addons.add(PANEL_ID, {
+    type: types.TAB,
+    title: 'Docs',
+    route: function route(_ref) {
+      var storyId = _ref.storyId,
+          refId = _ref.refId;
+      return refId ? "/docs/".concat(refId, "_").concat(storyId) : "/docs/".concat(storyId);
+    },
+    match: function match(_ref2) {
+      var viewMode = _ref2.viewMode;
+      return viewMode === 'docs';
+    },
+    render: function render() {
+      return null;
+    }
+  });
+});

package/dist/collection/node_modules/@storybook/addon-docs/dist/esm/shared.js

@@ -0,0 +1,11 @@
+export var ADDON_ID = 'storybook/docs';
+export var PANEL_ID = "".concat(ADDON_ID, "/panel");
+export var PARAM_KEY = "docs";
+export var SNIPPET_RENDERED = "".concat(ADDON_ID, "/snippet-rendered");
+export var SourceType;
+
+(function (SourceType) {
+  SourceType["AUTO"] = "auto";
+  SourceType["CODE"] = "code";
+  SourceType["DYNAMIC"] = "dynamic";
+})(SourceType || (SourceType = {}));

package/dist/collection/node_modules/@storybook/addon-docs/dist/modern/blocks/Anchor.js

@@ -0,0 +1,8 @@
+import React from 'react';
+export const anchorBlockIdFromId = storyId => `anchor--${storyId}`;
+export const Anchor = ({
+  storyId,
+  children
+}) => /*#__PURE__*/React.createElement("div", {
+  id: anchorBlockIdFromId(storyId)
+}, children);