@stencil/core 2.15.0 → 2.15.1

package/compiler/stencil.js

@@ -1,5 +1,5 @@
 /*!
- Stencil Compiler v2.15.0 | MIT Licensed | https://stenciljs.com
+ Stencil Compiler v2.15.1 | MIT Licensed | https://stenciljs.com
  */
 (function(exports) {
 'use strict';
@@ -872,7 +872,7 @@ const normalizeDiagnostic = (compilerCtx, diagnostic) => {
       diagnostic.messageText = diagnostic.messageText.message;
     }
     else if (typeof diagnostic.messageText === 'string' && diagnostic.messageText.indexOf('Error: ') === 0) {
-      diagnostic.messageText = diagnostic.messageText.substr(7);
+      diagnostic.messageText = diagnostic.messageText.slice(7);
     }
   }
   if (diagnostic.messageText) {
@@ -1161,7 +1161,7 @@ const loadRollupDiagnostics = (config, compilerCtx, buildCtx, rollupError) => {
             };
             diagnostic.lineNumber = errorLine.lineNumber;
             diagnostic.columnNumber = errorLine.errorCharStart;
-            const highlightLine = errorLine.text.substr(loc.column);
+            const highlightLine = errorLine.text.slice(loc.column);
             for (let i = 0; i < highlightLine.length; i++) {
               if (charBreak.has(highlightLine.charAt(i))) {
                 break;
@@ -1588,7 +1588,7 @@ const createJsVarName = (fileName) => {
     fileName = fileName.replace(/[|;$%@"<>()+,.{}_\!\/\\]/g, '-');
     fileName = dashToPascalCase$1(fileName);
     if (fileName.length > 1) {
-      fileName = fileName[0].toLowerCase() + fileName.substr(1);
+      fileName = fileName[0].toLowerCase() + fileName.slice(1);
     }
     else {
       fileName = fileName.toLowerCase();
@@ -1711,15 +1711,16 @@ const SKIP_DEPS = ['@stencil/core'];
  * @returns an error message if the tag has an invalid name, undefined if the tag name passes all checks
  */
 const validateComponentTag = (tag) => {
+  // we want to check this first since we call some String.prototype methods below
+  if (typeof tag !== 'string') {
+    return `Tag "${tag}" must be a string type`;
+  }
   if (tag !== tag.trim()) {
     return `Tag can not contain white spaces`;
   }
   if (tag !== tag.toLowerCase()) {
     return `Tag can not contain upper case characters`;
   }
-  if (typeof tag !== 'string') {
-    return `Tag "${tag}" must be a string type`;
-  }
   if (tag.length === 0) {
     return `Received empty tag value`;
   }
@@ -3973,7 +3974,7 @@ const createCustomResolverAsync = (sys, inMemoryFs, exts) => {
   };
 };
 
-const buildId = '20220328165835';
+const buildId = '20220418164701';
 const minfyJsId = 'terser5.6.1_7';
 const optimizeCssId = 'autoprefixer10.2.5_postcss8.2.8_7';
 const parse5Version = '6.0.1';
@@ -3981,8 +3982,8 @@ const rollupVersion = '2.42.3';
 const sizzleVersion = '2.42.3';
 const terserVersion = '5.6.1';
 const typescriptVersion = '4.5.4';
-const vermoji = '⛷';
-const version$3 = '2.15.0';
+const vermoji = '🐼';
+const version$3 = '2.15.1';
 const versions = {
   stencil: version$3,
   parse5: parse5Version,
@@ -4442,7 +4443,7 @@ const createSystem = (c) => {
     const hashArray = Array.from(new Uint8Array(arrayBuffer)); // convert buffer to byte array
     let hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join(''); // convert bytes to hex string
     if (typeof hashLength === 'number') {
-      hashHex = hashHex.substr(0, hashLength);
+      hashHex = hashHex.slice(0, hashLength);
     }
     return hashHex;
   };
@@ -5067,13 +5068,13 @@ const getCssSelectors = (sel) => {
     if (items[i].length === 0)
       continue;
     if (items[i].charAt(0) === '.') {
-      SELECTORS.classNames.push(items[i].substr(1));
+      SELECTORS.classNames.push(items[i].slice(1));
     }
     else if (items[i].charAt(0) === '#') {
-      SELECTORS.ids.push(items[i].substr(1));
+      SELECTORS.ids.push(items[i].slice(1));
     }
     else if (items[i].charAt(0) === '[') {
-      items[i] = items[i].substr(1).split('=')[0].split(']')[0].trim();
+      items[i] = items[i].slice(1).split('=')[0].split(']')[0].trim();
       SELECTORS.attrs.push(items[i].toLowerCase());
     }
     else if (/[a-z]/g.test(items[i].charAt(0))) {
@@ -8662,7 +8663,7 @@ const loadMinifyJsDiagnostics = (sourceText, diagnostics, error) => {
     };
     d.lineNumber = errorLine.lineNumber;
     d.columnNumber = errorLine.errorCharStart;
-    const highlightLine = errorLine.text.substr(d.columnNumber);
+    const highlightLine = errorLine.text.slice(d.columnNumber);
     for (let i = 0; i < highlightLine.length; i++) {
       if (MINIFY_CHAR_BREAK.has(highlightLine.charAt(i))) {
         break;
@@ -9516,7 +9517,7 @@ const standardNormalizeHref = (prerenderConfig, diagnostics, url) => {
         // url should NOT have a trailing slash
         if (href.endsWith('/') && url.pathname !== '/') {
           // this has a trailing slash and it's not the root path
-          href = href.substr(0, href.length - 1);
+          href = href.slice(0, -1);
         }
       }
       return href;
@@ -14367,7 +14368,7 @@ function toDataAttribute(str) {
       .toLowerCase());
 }
 function dashToPascalCase(str) {
-  str = String(str).substr(5);
+  str = String(str).slice(5);
   return str
     .split('-')
     .map((segment, index) => {
@@ -14571,7 +14572,7 @@ function cssCaseToJsCase(str) {
       .split('-')
       .map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1))
       .join('');
-    str = str.substr(0, 1).toLowerCase() + str.substr(1);
+    str = str.slice(0, 1).toLowerCase() + str.slice(1);
   }
   return str;
 }
@@ -16924,6 +16925,17 @@ MockElement.prototype.cloneNode = function (deep) {
   return cloned;
 };
 
+let sharedDocument;
+function parseHtmlToDocument(html, ownerDocument = null) {
+  if (ownerDocument == null) {
+    if (sharedDocument == null) {
+      sharedDocument = new MockDocument();
+    }
+    ownerDocument = sharedDocument;
+  }
+  return parseDocumentUtil(ownerDocument, html);
+}
+
 class MockHeaders {
   constructor(init) {
     this._values = [];
@@ -17131,6 +17143,15 @@ class MockResponse {
   }
 }
 
+class MockDOMParser {
+  parseFromString(htmlToParse, mimeType) {
+    if (mimeType !== 'text/html') {
+      console.error('XML parsing not implemented yet, continuing as html');
+    }
+    return parseHtmlToDocument(htmlToParse);
+  }
+}
+
 function addGlobalsToWindowPrototype(mockWinPrototype) {
   GLOBAL_CONSTRUCTORS.forEach(([cstrName, Cstr]) => {
     Object.defineProperty(mockWinPrototype, cstrName, {
@@ -17153,6 +17174,7 @@ const GLOBAL_CONSTRUCTORS = [
   ['MouseEvent', MockMouseEvent],
   ['Request', MockRequest],
   ['Response', MockResponse],
+  ['DOMParser', MockDOMParser],
   ['HTMLAnchorElement', MockAnchorElement],
   ['HTMLBaseElement', MockBaseElement],
   ['HTMLButtonElement', MockButtonElement],
@@ -54300,31 +54322,55 @@ const getTextOfPropertyName = (propName) => {
   }
   return undefined;
 };
+/**
+ * Generate a series of type references for a given AST node
+ * @param baseNode the AST node to pull type references from
+ * @param sourceFile the source file in which the provided `baseNode` exists
+ * @returns the generated series of type references
+ */
 const getAttributeTypeInfo = (baseNode, sourceFile) => {
   const allReferences = {};
-  getAllTypeReferences(baseNode).forEach((rt) => {
-    allReferences[rt] = getTypeReferenceLocation(rt, sourceFile);
+  getAllTypeReferences(baseNode).forEach((typeName) => {
+    allReferences[typeName] = getTypeReferenceLocation(typeName, sourceFile);
   });
   return allReferences;
 };
+/**
+ * Get the text-based name from a TypeScript `EntityName`, which is an identifier of some form
+ * @param entity a TypeScript `EntityName` to retrieve the name of an entity from
+ * @returns the entity's name
+ */
 const getEntityName = (entity) => {
   if (t.isIdentifier(entity)) {
     return entity.escapedText.toString();
   }
   else {
+    // We have qualified name - e.g. const x: Foo.Bar.Baz;
+    // Recurse until we find the 'base' of the qualified name
     return getEntityName(entity.left);
   }
 };
+/**
+ * Recursively walks the provided AST to collect all TypeScript type references that are found
+ * @param node the node to walk to retrieve type information
+ * @returns the collected type references
+ */
 const getAllTypeReferences = (node) => {
   const referencedTypes = [];
   const visit = (node) => {
+    /**
+     * A type reference node will refer to some type T.
+     * e.g: In `const foo: Bar = {...}` the reference node will contain semantic information about `Bar`.
+     * In TypeScript, types that are also keywords (e.g. `number` in `const foo: number`) are not `TypeReferenceNode`s.
+     */
     if (t.isTypeReferenceNode(node)) {
       referencedTypes.push(getEntityName(node.typeName));
       if (node.typeArguments) {
+        // a type may contain types itself (e.g. generics - Foo<Bar>)
         node.typeArguments
-          .filter((ta) => t.isTypeReferenceNode(ta))
-          .forEach((tr) => {
-          const typeName = tr.typeName;
+          .filter((typeArg) => t.isTypeReferenceNode(typeArg))
+          .forEach((typeRef) => {
+          const typeName = typeRef.typeName;
           if (typeName && typeName.escapedText) {
             referencedTypes.push(typeName.escapedText.toString());
           }
@@ -54345,6 +54391,22 @@ const validateReferences = (diagnostics, references, node) => {
     }
   });
 };
+/**
+ * Determine where a TypeScript type reference originates from. This is accomplished by interrogating the AST node in
+ * which the type's name appears
+ *
+ * A type may originate:
+ * - from the same file where it is used (a type is declared in some file, `foo.ts`, and later used in the same file)
+ * - from another file (I.E. it is imported and should have an import statement somewhere in the file)
+ * - from a global context
+ * - etc.
+ *
+ * The type may be declared using the `type` or `interface` keywords.
+ *
+ * @param typeName the name of the type to find the origination of
+ * @param tsNode the TypeScript AST node being searched for the provided `typeName`
+ * @returns the context stating where the type originates from
+ */
 const getTypeReferenceLocation = (typeName, tsNode) => {
   const sourceFileObj = tsNode.getSourceFile();
   // Loop through all top level imports to find any reference to the type for 'import' reference location
@@ -58871,7 +58933,7 @@ const updateStencilTypesImports = (typesDir, dtsFilePath, dtsContent) => {
  * Writes Stencil core typings file to disk for a dist-* output target
  * @param config the Stencil configuration associated with the project being compiled
  * @param compilerCtx the current compiler context
- * @returns
+ * @returns the results of writing one or more type declaration files to disk
  */
 const copyStencilCoreDts = async (config, compilerCtx) => {
   const typesOutputTargets = config.outputTargets.filter(isOutputTargetDistTypes).filter((o) => o.typesDir);
@@ -58905,8 +58967,13 @@ const sortImportNames = (a, b) => {
   return 0;
 };
 
-const generateEventTypes = (cmpEvents) => {
-  return cmpEvents.map((cmpEvent) => {
+/**
+ * Generates the individual event types for all @Event() decorated events in a component
+ * @param cmpMeta component runtime metadata for a single component
+ * @returns the generated type metadata
+ */
+const generateEventTypes = (cmpMeta) => {
+  return cmpMeta.events.map((cmpEvent) => {
     const name = `on${toTitleCase(cmpEvent.name)}`;
     const type = cmpEvent.complexType.original
       ? `(event: CustomEvent<${cmpEvent.complexType.original}>) => void`
@@ -58922,8 +58989,13 @@ const generateEventTypes = (cmpEvents) => {
   });
 };
 
-const generateMethodTypes = (cmpMethods) => {
-  return cmpMethods.map((cmpMethod) => ({
+/**
+ * Generates the individual event types for all @Method() decorated events in a component
+ * @param cmpMeta component runtime metadata for a single component
+ * @returns the generated type metadata
+ */
+const generateMethodTypes = (cmpMeta) => {
+  return cmpMeta.methods.map((cmpMethod) => ({
     name: cmpMethod.name,
     type: cmpMethod.complexType.signature,
     optional: false,
@@ -58933,6 +59005,11 @@ const generateMethodTypes = (cmpMethods) => {
   }));
 };
 
+/**
+ * Generates the individual event types for all @Prop() decorated events in a component
+ * @param cmpMeta component runtime metadata for a single component
+ * @returns the generated type metadata
+ */
 const generatePropTypes = (cmpMeta) => {
   return [
     ...cmpMeta.properties.map((cmpProp) => ({
@@ -58965,8 +59042,8 @@ const generateComponentTypes = (cmp, areTypesInternal) => {
   const tagNameAsPascal = dashToPascalCase$1(tagName);
   const htmlElementName = `HTML${tagNameAsPascal}Element`;
   const propAttributes = generatePropTypes(cmp);
-  const methodAttributes = generateMethodTypes(cmp.methods);
-  const eventAttributes = generateEventTypes(cmp.events);
+  const methodAttributes = generateMethodTypes(cmp);
+  const eventAttributes = generateEventTypes(cmp);
   const componentAttributes = attributesToMultiLineString([...propAttributes, ...methodAttributes], false, areTypesInternal);
   const isDep = cmp.isCollectionDependency;
   const jsxAttributes = attributesToMultiLineString([...propAttributes, ...eventAttributes], true, areTypesInternal);
@@ -62066,7 +62143,7 @@ const validateManifestJsonIcon = async (compilerCtx, buildCtx, manifestFilePath,
     return;
   }
   if (iconSrc.startsWith('/')) {
-    iconSrc = iconSrc.substr(1);
+    iconSrc = iconSrc.slice(1);
   }
   const manifestDir = dirname(manifestFilePath);
   const iconPath = join(manifestDir, iconSrc);
@@ -64063,7 +64140,7 @@ const getComponentPathContent = (componentGraph, outputTarget) => {
 const dependencies = [
 	{
 		name: "@stencil/core",
-		version: "2.15.0",
+		version: "2.15.1",
 		main: "compiler/stencil.js",
 		resources: [
 			"package.json",