@ui5/webcomponents-tools 2.15.0 → 2.15.2

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/features/post-processing/resolve-initializers.js

@@ -0,0 +1,52 @@
+import { url } from "../../utils/index.js";
+
+export function resolveInitializersPlugin() {
+  return {
+    name: 'CORE - RESOLVE-INITIALIZERS',
+    /** 
+     * If a class field has a `resolveInitializer` property on it, it means its being assigned a variable. We need to resolve that variable, and get its type and default value 
+     */
+    packageLinkPhase({customElementsManifest}) {
+      customElementsManifest?.modules?.forEach(mod => {
+        mod?.declarations?.forEach(declaration => {
+          declaration?.members
+            ?.filter(({resolveInitializer}) => resolveInitializer)
+            ?.forEach(member => {
+              /** We ignore variables imported from a third party package */
+              if('package' in member.resolveInitializer) {
+                delete member.resolveInitializer;
+                return;
+              };
+
+              /** Find the module */
+              const foundModule = customElementsManifest?.modules?.find(({path}) => {
+                let toResolve = url(member?.resolveInitializer?.module);
+                const modulePath = url(path);
+
+                if(!toResolve.endsWith('.js') && !toResolve.endsWith('.ts')) {
+                  toResolve += '.ts';
+                }
+
+                return toResolve === modulePath;
+              });
+
+              if(foundModule) {
+                /** Find the declaration */
+                const foundReference = foundModule?.declarations?.find(declaration => declaration?.name === member?.default);
+                /** Overwrite the type with the type of the reference we found */
+                if(foundReference?.type && !member?.type) {
+                  member.type = foundReference.type;
+                }
+                
+                if(foundReference?.default) {
+                  member.default = foundReference?.default;
+                }
+              }
+
+              delete member.resolveInitializer;
+            });
+        });
+      });
+    }
+  }
+}

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/utils/ast-helpers.js

@@ -0,0 +1,186 @@
+import ts from 'typescript';
+import { safe } from './index.js';
+
+/**
+ * AST HELPERS
+ */
+
+export const isProperty = node => ts.isPropertyDeclaration(node) || ts.isGetAccessor(node) || ts.isSetAccessor(node);
+
+/**
+ * @example this.dispatchEvent(new Event('foo'));
+ */
+export const isDispatchEvent = node => node.expression?.name?.getText() === 'dispatchEvent' && node?.expression?.expression?.kind === ts.SyntaxKind.ThisKeyword
+
+export const isReturnStatement = statement => statement?.kind === ts.SyntaxKind.ReturnStatement;
+
+/**
+ * @example customElements.define('my-el', MyEl);
+ * @example window.customElements.define('my-el', MyEl);
+ */
+export const isCustomElementsDefineCall = node => (node?.expression?.getText() === 'customElements' || node?.expression?.getText() === 'window.customElements' || node?.expression?.getText() === 'globalThis.customElements') && node?.name?.getText() === 'define' && node?.parent?.kind === ts.SyntaxKind.CallExpression;
+
+/**
+ * @example @attr
+ * @example @attribute
+ */
+export function hasAttrAnnotation(member) {
+  return member?.jsDoc?.some(jsDoc => jsDoc?.tags?.some(tag => safe(() => ["attribute", "attr"].includes(tag?.tagName?.getText()))));
+}
+
+
+/**
+ * Whether or not node is:
+ * - Number
+ * - String
+ * - Boolean
+ * - Null
+ */
+export function isPrimitive(node) {
+  return node && (ts.isNumericLiteral(node) ||
+  ts.isStringLiteral(node) ||
+  node?.kind === ts.SyntaxKind.NullKeyword ||
+  node?.kind === ts.SyntaxKind.TrueKeyword ||
+  node?.kind === ts.SyntaxKind.FalseKeyword) ||
+  // Handle only empty arrays for now
+  (node?.kind === ts.SyntaxKind.ArrayLiteralExpression && node?.elements?.length === 0)
+}
+
+/**
+ * Checks if a VariableStatement has an initializer
+ * @example `let foo;` will return false
+ * @example `let foo = '';` will return true
+ */
+export function hasInitializer(node) {
+  return node?.declarationList?.declarations?.some(declaration => declaration?.initializer);
+}
+
+export function getElementNameFromDecorator(decorator) {
+  const argument = decorator.expression.arguments[0];
+
+  /**
+   * @example @customElement('my-el')
+   */
+  if(argument.kind === ts.SyntaxKind.StringLiteral) {
+    return argument.text;
+  }
+
+  /**
+   * @example @customElement({
+   *   name: 'my-el',
+   *   template
+   * })
+   */
+  if(argument.kind === ts.SyntaxKind.ObjectLiteralExpression) {
+    let result;
+    argument?.properties?.forEach(property => {
+      if(property?.name?.getText() === 'name') {
+        result = property?.initializer?.text;
+      }
+    });
+    return result;
+  }
+}
+
+
+/**
+ * Gets the name of an attr from a decorators callExpression
+ * @example @attr({attribute: 'my-el'})
+ */
+export const getOptionsObject = decorator => decorator?.expression?.arguments?.find(arg => arg.kind === ts.SyntaxKind.ObjectLiteralExpression);
+
+/**
+ * Get the return value expression of a return statement, omitting the type assertion
+ */
+export const getReturnValue = returnStatement => {
+  let value = returnStatement.expression?.kind === ts.SyntaxKind.AsExpression
+    ? returnStatement.expression.expression.getText()
+    : returnStatement.expression?.getText()
+
+  return value?.split?.(' ')?.[0];
+}
+
+/**
+ * Is this class member a static member?
+ */
+export const isStaticMember = member =>
+  member?.modifiers?.some?.(x => x.kind === ts.SyntaxKind.StaticKeyword);
+
+/**
+ * @param  {import('typescript').Expression}  initializer
+ * @return {initializer is import('typescript').AsExpression & { type: import("typescript").TypeReference }}
+ */
+function isAsConst(initializer) {
+  return (
+    initializer &&
+    initializer.kind &&
+    ts.isAsExpression(initializer) &&
+    ts.isTypeReferenceNode(initializer.type) &&
+    initializer.type.typeName.getText() === 'const'
+  );
+}
+
+
+/**
+ * Does the name have an initializer with `as const`?
+ * @param  {import('typescript').Node}  node
+ * @return {Boolean}
+ */
+export function isWellKnownType(node) {
+  return (
+    node?.initializer && (
+      isAsConst(node?.initializer)
+    )
+  );
+}
+
+/**
+ * Whether or not a node has an `@ignore` jsdoc annotation
+ */
+export const hasIgnoreJSDoc = node => node?.jsDoc?.some(doc => doc?.tags?.some(tag => safe(() => tag?.tagName?.getText()) === 'ignore' || safe(() => tag?.tagName?.getText()) === 'internal'));
+
+
+/**
+ * @example this.__onClick = this.__onClick.bind(this);
+ */
+export function isBindCall(statement) {
+  const { expression } = statement;
+  if(expression) {
+    const leftName = expression?.left?.name?.getText();
+    const rightName = expression?.right?.expression?.expression?.name?.getText();
+    const isBind = expression?.right?.expression?.name?.getText() === 'bind';
+
+    if(leftName === undefined || rightName === undefined) return false;
+
+    if(leftName === rightName && isBind) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Does the variable have an `@ignore` or `@internal` JSDoc tag?
+ * @param  {import('typescript').Node|string} nodeOrName
+ * @param  {import('typescript').SourceFile}  sourceFile
+ * @return {import('typescript').Node}
+ */
+export function getDeclarationInFile(nodeOrName, sourceFile) {
+  let name = nodeOrName;
+  if (typeof nodeOrName === 'string') {
+    if (!sourceFile)
+      throw new Error('must provide sourceFile when first argument is a string');
+  } else {
+    sourceFile = nodeOrName?.getSourceFile();
+    name = nodeOrName?.name?.getText();
+  }
+  if (!name)
+    return undefined;
+  const sourceFileStatements = sourceFile.statements ?? [];
+  return sourceFileStatements.find(statement => {
+    if (ts.isVariableStatement(statement))
+      return statement.declarationList.declarations.find(declaration => declaration.name.getText() === name)
+    else if (statement.name?.getText)
+      return statement.name.getText() === name;
+  });
+}

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/utils/cli-helpers.js

@@ -0,0 +1,164 @@
+import { readConfig, ConfigLoaderError } from '@web/config-loader';
+import fs from 'fs';
+import path from 'path';
+import commandLineArgs from 'command-line-args';
+import { has } from './index.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { version } = require('../../package.json');
+
+const IGNORE = [
+  '!node_modules/**/*.*',
+  '!bower_components/**/*.*',
+  '!**/*.test.{js,ts}',
+  '!**/*.suite.{js,ts}',
+  '!**/*.config.{js,ts}',
+  '!**/*.d.ts',
+];
+
+export function mergeGlobsAndExcludes(defaults, userConfig, cliConfig) {
+  const hasProvidedCliGlobs = has(cliConfig?.globs) || has(userConfig?.globs);
+
+  if(hasProvidedCliGlobs) {
+    defaults.globs = defaults.globs.filter(glob => glob !== '**/*.{js,ts,tsx}');
+  }
+
+  const merged = [
+    ...defaults.globs,
+    ...(userConfig?.globs || []),
+    ...(cliConfig?.globs || []),
+    ...(userConfig?.exclude?.map((i) => `!${i}`) || []),
+    ...(cliConfig?.exclude?.map((i) => `!${i}`) || []),
+    ...IGNORE,
+  ];
+
+  return merged;
+}
+
+export async function getUserConfig(configPath, cwd) {
+  let userConfig = {};
+  try {
+    userConfig = await readConfig('custom-elements-manifest.config', configPath, cwd);
+  } catch (error) {
+    if (error instanceof ConfigLoaderError) {
+      console.error(error.message);
+      return;
+    }
+    console.error(error);
+    return;
+  }
+  return userConfig || {};
+}
+
+export const DEFAULTS = {
+  outdir: '',
+  globs: ['**/*.{js,ts,tsx}'],
+  dev: false,
+  quiet: false,
+  packagejson: true,
+  watch: false,
+  litelement: false,
+  stencil: false,
+  fast: false,
+  catalyst: false,
+  'catalyst-major-2': false,
+}
+
+export function getCliConfig(argv) {
+  const optionDefinitions = [
+    { name: 'config', type: String},
+    { name: 'globs', type: String, multiple: true },
+    { name: 'exclude', type: String, multiple: true },
+    { name: 'outdir', type: String },
+    { name: 'dev', type: Boolean },
+    { name: 'quiet', type: Boolean },
+    { name: 'dependencies', type: Boolean },
+    { name: 'packagejson', type: Boolean },
+    { name: 'watch', type: Boolean },
+    { name: 'litelement', type: Boolean },
+    { name: 'stencil', type: Boolean },
+    { name: 'fast', type: Boolean },
+    { name: 'catalyst', type: Boolean },
+    { name: 'catalyst-major-2', type: Boolean },
+  ];
+
+  return commandLineArgs(optionDefinitions, { argv });
+}
+
+export async function addFrameworkPlugins(mergedOptions) {
+  let plugins = [];
+  if(mergedOptions?.litelement) {
+    const { litPlugin } = await import('../features/framework-plugins/lit/lit.js');
+    plugins = [...(litPlugin() || [])]
+  }
+
+  if(mergedOptions?.fast) {
+    const { fastPlugin } = await import('../features/framework-plugins/fast/fast.js');
+    plugins = [...(fastPlugin() || [])]
+  }
+
+  if(mergedOptions?.stencil) {
+    const { stencilPlugin } = await import('../features/framework-plugins/stencil/stencil.js');
+    plugins.push(stencilPlugin());
+  }
+
+  if(mergedOptions?.catalyst) {
+    const { catalystPlugin } = await import('../features/framework-plugins/catalyst/catalyst.js');
+    plugins = [...(catalystPlugin() || [])]
+  }
+
+  if(mergedOptions?.['catalyst-major-2']) {
+    const { catalystPlugin2 } = await import('../features/framework-plugins/catalyst-major-2/catalyst.js');
+    plugins = [...(catalystPlugin2() || [])]
+  }
+
+  return plugins;
+}
+
+export function timestamp() {
+  const date = new Date();
+  return date.toLocaleTimeString();
+}
+
+export function addCustomElementsPropertyToPackageJson(outdir) {
+  const packageJsonPath = `${process.cwd()}${path.sep}package.json`;
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString());
+  const manifestPath = path.posix.join(outdir, 'custom-elements.json');
+  if(packageJson?.customElements) {
+    if(packageJson?.customElements !== manifestPath) {
+      packageJson.customElements = manifestPath;
+      fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+    }
+    return;
+  } else {
+    packageJson.customElements = manifestPath;
+    fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`);
+  }
+}
+
+export const MENU = `
+@custom-elements-manifest/analyzer (${version})
+
+Available commands:
+    | Command/option     | Type       | Description                                                 | Example                                                 |
+    | ------------------ | ---------- | ----------------------------------------------------------- | ------------------------------------------------------- |
+    | analyze            |            | Analyze your components                                     |                                                         |
+    | --config           | string     | Path to custom config location                              | \`--config "../custom-elements-manifest.config.js"\`    |
+    | --globs            | string[]   | Globs to analyze                                            | \`--globs "foo.js"\`                                    |
+    | --exclude          | string[]   | Globs to exclude                                            | \`--exclude "foo.js"\`                                  |
+    | --outdir           | string     | Directory to output the Manifest to                         | \`--outdir dist\`                                       |
+    | --dependencies     | boolean    | Include third party custom elements manifests               | \`--dependencies\`                                      |
+    | --packagejson      | boolean    | Output CEM path to \`package.json\`, defaults to true       | \`--packagejson\`                                       |
+    | --watch            | boolean    | Enables watch mode, generates a new manifest on file change | \`--watch\`                                             |
+    | --dev              | boolean    | Enables extra logging for debugging                         | \`--dev\`                                               |
+    | --quiet            | boolean    | Hides all logging                                           | \`--quiet\`                                             |
+    | --litelement       | boolean    | Enable special handling for LitElement syntax               | \`--litelement\`                                        |
+    | --fast             | boolean    | Enable special handling for FASTElement syntax              | \`--fast\`                                              |
+    | --stencil          | boolean    | Enable special handling for Stencil syntax                  | \`--stencil\`                                           |
+    | --catalyst         | boolean    | Enable special handling for Catalyst syntax                 | \`--catalyst\`                                          |
+    | --catalyst-major-2 | boolean    | Enable special handling for Catalyst syntax ^2.0.0          | \`--catalyst-major-2\`                                  |
+
+Examples:
+    custom-elements-manifest analyze --litelement --globs "**/*.js" --exclude "foo.js" "bar.js"
+`

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/utils/exports.js

@@ -0,0 +1,44 @@
+import ts from 'typescript';
+import { has } from './index.js';
+
+/**
+ * UTILITIES RELATED TO MODULE EXPORTS
+ */
+
+export function hasExportModifier(node) {
+  if (has(node?.modifiers)) {
+    if (node.modifiers.some(mod => mod.kind === ts.SyntaxKind.ExportKeyword)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function hasDefaultModifier(node) {
+  if (has(node?.modifiers)) {
+    if (node.modifiers.some(mod => mod.kind === ts.SyntaxKind.DefaultKeyword)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * @example export { var1, var2 };
+ */
+export function hasNamedExports(node) {
+  if (has(node?.exportClause?.elements)) {
+    return true;
+  }
+  return false;
+}
+
+/**
+ * @example export { var1, var2 } from 'foo';
+ */
+export function isReexport(node) {
+  if (node?.moduleSpecifier !== undefined) {
+    return true;
+  }
+  return false;
+}

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/utils/find-external-manifests.js

@@ -0,0 +1,67 @@
+import fs from 'fs';
+import path from 'path';
+import { findDependencies, splitPath } from '@custom-elements-manifest/find-dependencies';
+
+/**
+ * @typedef {import('custom-elements-manifest/schema').Package} Package
+ */
+
+/**
+ * @param {string[]} paths
+ * @param {{
+ *  nodeModulesDepth?: number,
+ *  basePath?: string,
+ * }} [options]
+ */
+export async function findExternalManifests(paths, {basePath = process.cwd(), nodeModulesDepth}) {
+  /** @type {Package[]} */
+  const cemsToMerge = [];
+  const visited = new Set();
+
+  const dependencies = await findDependencies(paths, {basePath, nodeModulesDepth});
+
+  dependencies?.forEach((dependencyPath) => {
+    const isCurrentPackageRegex = new RegExp(`^${basePath}\\${path.sep}(?!.*node_modules).*`);
+    if (isCurrentPackageRegex.test(dependencyPath)) {
+      // Make sure that we do not look for custom-elements.json in our own package
+      return;
+    }
+
+    const { packageRoot, packageName } = splitPath(dependencyPath);
+
+    if(visited.has(packageName)) return;
+    visited.add(packageName);
+
+    const packageJsonPath = `${packageRoot}${path.sep}package.json`;
+    const cemPath = `${packageRoot}${path.sep}custom-elements.json`;
+
+    /** Try to find `custom-elements.json` at `node_modules/specifier/custom-elements.json` */
+    if(fs.existsSync(cemPath)) {
+      try {
+        const cem = JSON.parse(fs.readFileSync(cemPath).toString());
+        cemsToMerge.push(cem);
+        return;
+      } catch(e) {
+        throw new Error(`Failed to read custom-elements.json at path "${cemPath}". \n\n${e.stack}`);
+      }
+    }
+
+    /** See if the `package.json` has a `customElements` field or if it has listed `./customElements` in its export map */
+    if(fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString());
+      const cemLocation = packageJson?.customElements || packageJson?.exports?.['./customElements'];
+
+      if(cemLocation) {
+        try {
+          const cemPath = path.resolve(packageRoot, cemLocation);
+          const cem = JSON.parse(fs.readFileSync(cemPath).toString());
+          cemsToMerge.push(cem);
+        } catch(e) {
+          throw new Error(`Failed to read custom-elements.json at path "${cemPath}". \n\n${e.stack}`);
+        }
+      }
+    }
+  });
+
+  return cemsToMerge;
+}

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/utils/imports.js

@@ -0,0 +1,25 @@
+import { has } from './index.js';
+
+/**
+ * UTILITIES RELATED TO MODULE IMPORTS
+ */
+
+/** @example import defaultExport from 'foo'; */
+export function hasDefaultImport(node) {
+  return !!node?.importClause?.name;
+}
+
+/** @example import {namedA, namedB} from 'foo'; */
+export function hasNamedImport(node) {
+  return has(node?.importClause?.namedBindings?.elements);
+}
+
+/** @example import * as name from './my-module.js'; */
+export function hasAggregatingImport(node) {
+  return !!node?.importClause?.namedBindings?.name && !hasNamedImport(node);
+}
+
+/** @example import './my-module.js'; */
+export function hasSideEffectImport(node) {
+  return 'importClause' in node && node.importClause == null;
+}

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/utils/index.js

@@ -0,0 +1,71 @@
+import ts from 'typescript';
+
+/**
+ * GENERAL UTILITIES
+ */
+
+export const has = arr => Array.isArray(arr) && arr.length > 0;
+
+/**
+ * @example node?.modifiers?.find(decorator('Component'))
+ */
+export const decorator = type => decorator => ts.isDecorator(decorator) && decorator?.expression?.expression?.getText() === type || decorator?.expression?.getText() === type;
+
+export function isBareModuleSpecifier(specifier) {
+  return !!specifier?.replace(/'/g, '')[0].match(/[@a-zA-Z]/g);
+}
+
+export const url = path => new URL('', `file:///${path}`)?.pathname;
+
+export function resolveModuleOrPackageSpecifier(moduleDoc, context, name) {
+  const foundImport = context?.imports?.find(_import => _import.name === name);
+
+  /* item is imported from another file */
+  if(foundImport) {
+    if(foundImport.isBareModuleSpecifier) {
+      /* import is from 3rd party package */
+      return { package: foundImport.importPath }
+    } else {
+      /* import is imported from a local module */
+      return { module: new URL(foundImport.importPath, `file:///${moduleDoc.path}`).pathname }
+    }
+  } else {
+    /* item is in current module */
+    return { module: moduleDoc.path }
+  }
+}
+
+export const toKebabCase = str => {
+  return str.split('').map((letter, idx) => {
+    return letter.toUpperCase() === letter
+     ? `${idx !== 0 ? '-' : ''}${letter.toLowerCase()}`
+     : letter;
+  }).join('');
+}
+
+/**
+ * TS seems to struggle sometimes with the `.getText()` method on JSDoc annotations, like `@deprecated` in ts v4.0.0 and `@override` in ts v4.3.2
+ * This is a bug in TS, but still annoying, so we add some safety rails here
+ */
+export const safe = (cb, returnType = '') => {
+  try {
+    return cb();
+  } catch {
+    return returnType;
+  }
+}
+
+export function withErrorHandling(name, cb) {
+  try {
+    cb()
+  } catch(e) {
+    let errorMessage = '';
+    const externalError = `Looks like you've hit an error in third party plugin: ${name}. Please try to create a minimal reproduction and inform the author of the ${name} plugin.`;
+    const coreError = `Looks like you've hit an error in the core library. Please try to create a minimal reproduction at https://custom-elements-manifest.netlify.com and create an issue at: https://github.com/open-wc/custom-elements-manifest/issues`;
+    if(name) {
+      errorMessage = name.startsWith('CORE') ? coreError : externalError;
+    }
+
+    throw new Error(`\n\n[${name ?? 'unnamed-plugin'}]: ${errorMessage}\n\n ${e.stack}\n`);
+  }
+}

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/utils/jsdoc.js

@@ -0,0 +1,19 @@
+/**
+ * UTILITIES RELATED TO JSDOC
+ */
+
+export function handleJsDocType(type) {
+  return type?.replace(/(import\(.+?\).)/g, '') || '';
+}
+
+export function normalizeDescription(desc) {
+  if (Array.isArray(desc)) {
+    desc = desc.reduce((prev, curr) => prev += curr.getText(), '');
+  }
+
+  if (typeof desc === 'string' && desc?.startsWith('- ')) {
+    desc = desc.slice(2);
+  }
+
+  return desc;
+}