@ui5/webcomponents-tools 0.0.0-bf8366eb6 → 0.0.0-c143e338b

package/lib/cem/custom-elements-manifest.config.mjs

@@ -4,6 +4,7 @@ import path from "path";
 import fs from 'fs';
 import {
 	getDeprecatedStatus,
+	getExperimentalStatus,
 	getSinceStatus,
 	getPrivacyStatus,
 	getReference,
@@ -26,6 +27,7 @@ import { generateCustomData } from "cem-plugin-vs-code-custom-data-generator";
 import { customElementJetBrainsPlugin } from "custom-element-jet-brains-integration";
 
 const packageJSON = JSON.parse(fs.readFileSync("./package.json"));
+const devMode = process.env.UI5_CEM_MODE === "dev";
 
 const extractClassNodeJSDoc = node => {
 	const fileContent = node.getFullText();
@@ -64,12 +66,23 @@ function processClass(ts, classNode, moduleDoc) {
 	currClass.customElement = !!customElementDecorator || className === "UI5Element" || undefined;
 	currClass.kind = "class";
 	currClass.deprecated = getDeprecatedStatus(classParsedJsDoc);
+	currClass._ui5experimental = getExperimentalStatus(classParsedJsDoc);
 	currClass._ui5since = getSinceStatus(classParsedJsDoc);
 	currClass._ui5privacy = getPrivacyStatus(classParsedJsDoc);
 	currClass._ui5abstract = hasTag(classParsedJsDoc, "abstract") ? true : undefined;
 	currClass.description = normalizeDescription(classParsedJsDoc.description || findTag(classParsedJsDoc, "class")?.description);
 	currClass._ui5implements = findAllTags(classParsedJsDoc, "implements")
-		.map(tag => getReference(ts, normalizeTagType(tag.type), classNode, moduleDoc.path))
+		.map(tag => {
+			const correctInterfaceDescription = classNode?.heritageClauses?.some(heritageClause => {
+				return heritageClause?.types?.some(type => type.expression?.text === normalizeTagType(tag.type));
+			});
+
+			if (!correctInterfaceDescription) {
+				logDocumentationError(moduleDoc.path, `@interface {${tag.type}} tag is used, but the class doesn't implement the corresponding interface`)
+			}
+
+			return getReference(ts, normalizeTagType(tag.type), classNode, moduleDoc.path)
+		})
 		.filter(Boolean);
 
 
@@ -77,6 +90,10 @@ function processClass(ts, classNode, moduleDoc) {
 		const superclassTag = findTag(classParsedJsDoc, "extends");
 		currClass.superclass = getReference(ts, superclassTag.name, classNode, moduleDoc.path);
 
+		if (classNode?.heritageClauses?.[0]?.types?.[0]?.expression?.text !== superclassTag.name) {
+			logDocumentationError(moduleDoc.path, `@extends ${superclassTag.name} is used, but the class doesn't extend the corresponding superclass`)
+		}
+
 		if (currClass.superclass?.name === "UI5Element") {
 			currClass.customElement = true;
 		}
@@ -111,9 +128,13 @@ function processClass(ts, classNode, moduleDoc) {
 	}
 
 	// Events
-	currClass.events = findAllDecorators(classNode, "event")
+	currClass.events = findAllDecorators(classNode, ["event", "eventStrict"])
 		?.map(event => processEvent(ts, event, classNode, moduleDoc));
 
+	const filename = classNode.getSourceFile().fileName;
+	const sourceFile = typeProgram.getSourceFile(filename);
+	const tsProgramClassNode = sourceFile.statements.find(statement => ts.isClassDeclaration(statement) && statement.name?.text === classNode.name?.text);
+
 	// Slots (with accessor), methods and fields
 	for (let i = 0; i < (currClass.members?.length || 0); i++) {
 		const member = currClass.members[i];
@@ -168,17 +189,21 @@ function processClass(ts, classNode, moduleDoc) {
 				const propertyDecorator = findDecorator(classNodeMember, "property");
 
 				if (propertyDecorator) {
-					member._ui5validator = propertyDecorator?.expression?.arguments[0]?.properties?.find(property => ["validator", "type"].includes(property.name.text))?.initializer?.text || "String";
 					member._ui5noAttribute = propertyDecorator?.expression?.arguments[0]?.properties?.find(property => property.name.text === "noAttribute")?.initializer?.kind === ts.SyntaxKind.TrueKeyword || undefined;
 				}
 
-				if (currClass.customElement && member.privacy === "public" && !propertyDecorator?.expression?.arguments[0]?.properties?.find(property => property.name.text === "multiple") && !["object"].includes(member._ui5validator?.toLowerCase())) {
-					const filename = classNode.getSourceFile().fileName;
-					const sourceFile = typeProgram.getSourceFile(filename);
-					const tsProgramClassNode = sourceFile.statements.find(statement => ts.isClassDeclaration(statement) && statement.name?.text === classNode.name?.text);
+				if (currClass.customElement && member.privacy === "public") {
 					const tsProgramMember = tsProgramClassNode.members.find(m => ts.isPropertyDeclaration(m) && m.name?.text === member.name);
 					const attributeValue = typeChecker.typeToString(typeChecker.getTypeAtLocation(tsProgramMember), tsProgramMember);
 
+					if (attributeValue === "boolean" && member.default === "true") {
+						logDocumentationError(moduleDoc.path, `Boolean properties must be initialzed to false. [${member.name}] property of class [${className}] is intialized to \`true\``)
+					}
+
+					if (!member.type) {
+						logDocumentationError(moduleDoc.path, `Public properties must have type. The type of [${member.name}] property is not determinated automatically. Please check it.`)
+					}
+
 					currClass.attributes.push({
 						description: member.description,
 						name: toKebabCase(member.name),
@@ -293,6 +318,7 @@ function processInterface(ts, interfaceNode, moduleDoc) {
 		kind: "interface",
 		name: interfaceName,
 		description: normalizeDescription(interfaceParsedJsDoc?.description),
+		_ui5experimental: getExperimentalStatus(interfaceParsedJsDoc),
 		_ui5privacy: getPrivacyStatus(interfaceParsedJsDoc),
 		_ui5since: getSinceStatus(interfaceParsedJsDoc),
 		deprecated: getDeprecatedStatus(interfaceParsedJsDoc),
@@ -313,6 +339,7 @@ function processEnum(ts, enumNode, moduleDoc) {
 		kind: "enum",
 		name: enumName,
 		description: normalizeDescription(enumJSdoc?.comment),
+		_ui5experimental: getExperimentalStatus(enumParsedJsDoc),
 		_ui5privacy: getPrivacyStatus(enumParsedJsDoc),
 		_ui5since: getSinceStatus(enumParsedJsDoc),
 		deprecated: getDeprecatedStatus(enumParsedJsDoc) || undefined,
@@ -425,14 +452,6 @@ export default {
 				}
 			},
 			moduleLinkPhase({ moduleDoc }) {
-				for (let i = 0; i < moduleDoc.declarations.length; i++) {
-					const shouldRemove = processPublicAPI(moduleDoc.declarations[i]) || ["function", "variable"].includes(moduleDoc.declarations[i].kind)
-					if (shouldRemove) {
-						moduleDoc.declarations.splice(i, 1);
-						i--;
-					}
-				}
-
 				moduleDoc.path = moduleDoc.path?.replace(/^src/, "dist").replace(/\.ts$/, ".js");
 
 				moduleDoc.exports = moduleDoc.exports.
@@ -456,41 +475,51 @@ export default {
 						})
 					}
 				})
+			},
+			packageLinkPhase({ customElementsManifest }) {
+				customElementsManifest.modules.forEach(moduleDoc => {
+					for (let i = 0; i < moduleDoc.declarations.length; i++) {
+						const shouldRemove = processPublicAPI(moduleDoc.declarations[i]) || ["function", "variable"].includes(moduleDoc.declarations[i].kind)
+						if (shouldRemove) {
+							moduleDoc.declarations.splice(i, 1);
+							i--;
+						}
+					}
 
-				const typeReferences = new Set();
-				const registerTypeReference = reference => typeReferences.add(JSON.stringify(reference))
-
-				moduleDoc.declarations.forEach(declaration => {
-					["events", "slots", "members"].forEach(memberType => {
-						declaration[memberType]?.forEach(member => {
-							if (member.type?.references) {
-								member.type.references.forEach(registerTypeReference)
-							} else if (member._ui5type?.references) {
-								member._ui5type.references.forEach(registerTypeReference)
-							} else if (member.kind === "method") {
-								member.return?.type?.references?.forEach(registerTypeReference)
-
-								member.parameters?.forEach(parameter => {
-									parameter.type?.references?.forEach(registerTypeReference)
-								})
-							}
+					const typeReferences = new Set();
+					const registerTypeReference = reference => typeReferences.add(JSON.stringify(reference))
+
+					moduleDoc.declarations.forEach(declaration => {
+						["events", "slots", "members"].forEach(memberType => {
+							declaration[memberType]?.forEach(member => {
+								if (member.type?.references) {
+									member.type.references.forEach(registerTypeReference)
+								} else if (member._ui5type?.references) {
+									member._ui5type.references.forEach(registerTypeReference)
+								} else if (member.kind === "method") {
+									member.return?.type?.references?.forEach(registerTypeReference)
+
+									member.parameters?.forEach(parameter => {
+										parameter.type?.references?.forEach(registerTypeReference)
+									})
+								}
+							})
 						})
-					})
-				});
+					});
 
-				typeReferences.forEach(reference => {
-					reference = JSON.parse(reference);
-					if (reference.package === packageJSON?.name && reference.module === moduleDoc.path) {
-						const hasExport = moduleDoc.exports.some(e => e.declaration?.name === reference.name && e.declaration?.module === reference.module)
+					typeReferences.forEach(reference => {
+						reference = JSON.parse(reference);
+						if (reference.package === packageJSON?.name && reference.module === moduleDoc.path) {
+							const hasExport = moduleDoc.exports.some(e => e.declaration?.name === reference.name && e.declaration?.module === reference.module)
 
-						if (!hasExport) {
-							logDocumentationError(moduleDoc.path?.replace(/^dist/, "src").replace(/\.js$/, ".ts"), `Type '${reference.name}' is used to describe a public API but is not exported.`,)
+							if (!hasExport) {
+								logDocumentationError(moduleDoc.path?.replace(/^dist/, "src").replace(/\.js$/, ".ts"), `Type '${reference.name}' is used to describe a public API but is not exported.`,)
+							}
 						}
-					}
-				})
-			},
-			packageLinkPhase({ context }) {
-				if (context.dev) {
+					})
+				});
+
+				if (devMode) {
 					displayDocumentationErrors();
 				}
 			}

package/lib/cem/event.mjs

@@ -16,19 +16,10 @@ import {
 } from "./utils.mjs";
 
 const jsDocRegExp = /\/\*\*(.|\n)+?\s+\*\//;
+const ASTFalseKeywordCode = 94;
 
 const getParams = (ts, eventDetails, commentParams, classNode, moduleDoc) => {
 	return commentParams?.map(commentParam => {
-		const decoratorParam = eventDetails?.find(prop => prop?.name?.text === commentParam?.name);
-
-		if (!decoratorParam || !decoratorParam?.jsDoc?.[0]) {
-			return;
-		}
-
-		const decoratorParamParsedComment = parse(decoratorParam?.jsDoc?.[0]?.getText?.(), { spacing: 'preserve' })[0];
-
-		validateJSDocComment("eventParam", decoratorParamParsedComment, decoratorParam.name?.text, moduleDoc);
-
 		const { typeName, name } = getType(normalizeTagType(commentParam?.type));
 		let type;
 
@@ -47,12 +38,10 @@ const getParams = (ts, eventDetails, commentParams, classNode, moduleDoc) => {
 		return {
 			type,
 			name: commentParam?.name,
-			_ui5privacy: getPrivacyStatus(decoratorParamParsedComment),
+			_ui5privacy: "public",
 			description: normalizeDescription(commentParam?.description),
-			_ui5since: getSinceStatus(decoratorParamParsedComment),
-			deprecated: getDeprecatedStatus(decoratorParamParsedComment),
 		};
-	}).filter(pair => !!pair);
+	});
 };
 
 function processEvent(ts, event, classNode, moduleDoc) {
@@ -77,30 +66,32 @@ function processEvent(ts, event, classNode, moduleDoc) {
 	const privacy = findTag(eventParsedComment, ["public", "private", "protected"])?.tag || "private";
 	const sinceTag = findTag(eventParsedComment, "since");
 	const commentParams = findAllTags(eventParsedComment, "param");
-	const allowPreventDefault = hasTag(eventParsedComment, "allowPreventDefault") || undefined;
 	const description = normalizeDescription(eventParsedComment?.description);
 	const native = hasTag(eventParsedComment, "native");
-	const eventDetails = event?.expression?.arguments?.[1]?.properties?.find(prop => prop?.name?.text === "detail")?.initializer?.properties;
-
-	if (event?.expression?.arguments?.[1] && !event?.expression?.typeArguments) {
-		logDocumentationError(moduleDoc.path, `Event details for event '${name}' must be described using generics. Add type via generics to the decorator: @event<TypeForDetails>("${name}", {details}).`)
-	}
+	const eventArgs = event?.expression?.arguments;
+	let eventBubbles;
+	let eventCancelable;
+	let eventDetails;
+
+	eventArgs && eventArgs.forEach(arg => {
+		arg.properties?.forEach(prop => {
+			if (prop.name?.text === "bubbles") {
+				eventBubbles = prop.initializer.kind === ASTFalseKeywordCode ? false : true;
+			} else if (prop.name?.text === "cancelable") {
+				eventCancelable = prop.initializer.kind === ASTFalseKeywordCode ? false : true;
+			} else if (prop.name?.text === "detail") {
+				eventDetails = prop.initializer?.properties;
+			}
+		});
+	});
 
 	result.description = description;
-	result._ui5allowPreventDefault = allowPreventDefault;
+	result._ui5Cancelable = eventCancelable !== undefined ? eventCancelable : false;
+	result._ui5allowPreventDefault = result._ui5Cancelable;
+	result._ui5Bubbles = eventBubbles !== undefined ? eventBubbles : false;
 
 	if (native) {
 		result.type = { text: "Event" };
-	} else if (event?.expression?.typeArguments) {
-		const typesText = event?.expression?.typeArguments.map(type => type.typeName?.text).filter(Boolean).join(" | ");
-		const typeRefs = (getTypeRefs(ts, event.expression)
-			?.map(e => getReference(ts, e, event, moduleDoc.path)).filter(Boolean)) || [];
-
-		result.type = { text: `CustomEvent<${typesText}>` };
-
-		if (typeRefs.length) {
-			result.type.references = typeRefs;
-		}
 	}
 
 	if (privacy) {
@@ -121,7 +112,53 @@ function processEvent(ts, event, classNode, moduleDoc) {
 			: sinceTag.name;
 	}
 
-	if (commentParams && eventDetails) {
+	const eventDetailType = classNode.members?.find(member => {
+		return ts.isPropertyDeclaration(member) && member.name.text === "eventDetails"
+	})?.type;
+	const eventDetailRef = eventDetailType?.members?.find(member => member.name.text === name) || eventDetailType?.types?.[eventDetailType?.types?.length - 1]?.members?.find(member => member.name.text === name);
+	const hasGeneric = !!event?.expression?.typeArguments
+
+	if (commentParams.length) {
+		if (eventDetailRef && hasGeneric) {
+			logDocumentationError(moduleDoc.path, `Event details for event '${name}' has to be defined either with generic or with eventDetails.`)
+		} else if (eventDetails) {
+			if (hasGeneric) {
+				const typesText = event?.expression?.typeArguments.map(type => type.typeName?.text).filter(Boolean).join(" | ");
+				const typeRefs = (getTypeRefs(ts, event.expression)
+					?.map(e => getReference(ts, e, event, moduleDoc.path)).filter(Boolean)) || [];
+
+				result.type = { text: `CustomEvent<${typesText}>` };
+
+				if (typeRefs.length) {
+					result.type.references = typeRefs;
+				}
+			} else if (eventDetailRef) {
+				const typesText = eventDetailRef?.type?.typeName?.text;
+				const typeRefs = (getTypeRefs(ts, eventDetailRef)
+					?.map(e => getReference(ts, e, event, moduleDoc.path)).filter(Boolean)) || [];
+
+				result.type = { text: `CustomEvent<${typesText}>` };
+
+				if (typeRefs.length) {
+					result.type.references = typeRefs;
+				}
+			} else {
+				logDocumentationError(moduleDoc.path, `Event details for event '${name}' must be described using generics. Add type via generics to the decorator: @event<TypeForDetails>("${name}", {details}).`)
+			}
+		} else if (eventDetailRef) {
+			const typesText = eventDetailRef?.type?.typeName?.text;
+			const typeRefs = (getTypeRefs(ts, eventDetailRef)
+				?.map(e => getReference(ts, e, event, moduleDoc.path)).filter(Boolean)) || [];
+
+			result.type = { text: `CustomEvent<${typesText}>` };
+
+			if (typeRefs.length) {
+				result.type.references = typeRefs;
+			}
+		} else {
+			logDocumentationError(moduleDoc.path, `Event details for event '${name}' must be described.`)
+		}
+
 		result._ui5parameters = getParams(ts, eventDetails, commentParams, classNode, moduleDoc);
 	}
 

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

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+
+import ts from 'typescript';
+import path from 'path';
+// Patch: Custom patch to not merge child parent privacy/type
+// https://github.com/open-wc/custom-elements-manifest/pull/300
+import { globby } from 'globby';
+import fs from 'fs';
+import commandLineArgs from 'command-line-args';
+import chokidar from 'chokidar';
+import debounce from 'debounce';
+
+import { create } from './src/create.js';
+import {
+  getUserConfig,
+  getCliConfig,
+  addFrameworkPlugins,
+  addCustomElementsPropertyToPackageJson,
+  mergeGlobsAndExcludes,
+  timestamp,
+  DEFAULTS,
+  MENU,
+} from './src/utils/cli-helpers.js';
+import { findExternalManifests } from './src/utils/find-external-manifests.js';
+
+/**
+ * @param {{argv:string[]; cwd: string; noWrite:boolean}} [opts]
+ */
+export async function cli({ argv = process.argv, cwd = process.cwd(), noWrite } = {}) {
+  const mainDefinitions = [{ name: 'command', defaultOption: true }];
+  const mainOptions = commandLineArgs(mainDefinitions, { stopAtFirstUnknown: true, argv });
+  const cliArgs = mainOptions._unknown || [];
+
+  if (mainOptions.command === 'analyze') {
+    const { config: configPath, ...cliConfig } = getCliConfig(cliArgs);
+    const userConfig = await getUserConfig(configPath, cwd);
+
+    /**
+     * Merged config options
+     * Command line options override userConfig options
+     */
+    const mergedOptions = { ...DEFAULTS, ...userConfig, ...cliConfig };
+    const merged = mergeGlobsAndExcludes(DEFAULTS, userConfig, cliConfig);
+    async function run() {
+      const globs = await globby(merged, { cwd });
+      const modules = userConfig?.overrideModuleCreation
+        ? userConfig.overrideModuleCreation({ ts, globs })
+        : globs.map((glob) => {
+            const fullPath = path.resolve(cwd, glob);
+            const source = fs.readFileSync(fullPath).toString();
+
+            return ts.createSourceFile(glob, source, ts.ScriptTarget.ES2015, true);
+          });
+
+      let thirdPartyCEMs = [];
+      if (mergedOptions?.dependencies) {
+        try {
+          const fullPathGlobs = globs.map(glob => path.resolve(cwd, glob));
+          thirdPartyCEMs = await findExternalManifests(fullPathGlobs, {basePath: cwd});
+        } catch (e) {
+          if (mergedOptions.dev) console.log(`Failed to add third party CEMs. \n\n${e.stack}`);
+        }
+      }
+
+      let plugins = await addFrameworkPlugins(mergedOptions);
+      plugins = [...plugins, ...(userConfig?.plugins || [])];
+
+      const context = { dev: mergedOptions.dev, thirdPartyCEMs };
+
+      /**
+       * Create the manifest
+       */
+       const customElementsManifest = create({modules, plugins, context});
+
+       if (mergedOptions.dev) {
+        console.log(JSON.stringify(customElementsManifest, null, 2));
+      }
+
+      if(!noWrite) {
+        const outdir = path.join(cwd, mergedOptions.outdir);
+        if (!fs.existsSync(outdir)) {
+          fs.mkdirSync(outdir, { recursive: true });
+        }
+        fs.writeFileSync(
+          path.join(outdir, 'custom-elements.json'),
+          `${JSON.stringify(customElementsManifest, null, 2)}\n`,
+        );
+       }
+
+      if (!mergedOptions.quiet) {
+        console.log(`[${timestamp()}] @custom-elements-manifest/analyzer: Created new manifest.`);
+      }
+
+      return customElementsManifest;
+    }
+    /** The manifest that will be returned for programmatic calls of cli */
+    const manifest = await run();
+
+    /**
+     * Watch mode
+     */
+    if (mergedOptions.watch) {
+      const fileWatcher = chokidar.watch(merged);
+
+      const onChange = debounce(run, 100);
+
+      fileWatcher.addListener('add', onChange);
+      fileWatcher.addListener('change', onChange);
+      fileWatcher.addListener('unlink', onChange);
+    }
+
+    try {
+      if (mergedOptions.packagejson) {
+        addCustomElementsPropertyToPackageJson(mergedOptions.outdir);
+      }
+    } catch {
+      console.log(
+        `Could not add 'customElements' property to ${cwd}${
+          path.sep
+        }package.json. \nAdding this property helps tooling locate your Custom Elements Manifest. Please consider adding it yourself, or file an issue if you think this is a bug.\nhttps://www.github.com/open-wc/custom-elements-manifest`,
+      );
+    }
+
+    return manifest;
+  } else {
+    console.log(MENU);
+  }
+}

package/lib/cem/patch/@custom-elements-manifest/analyzer/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@custom-elements-manifest/analyzer",
+  "version": "0.10.10",
+  "description": "",
+  "license": "MIT",
+  "type": "module",
+  "types": "index.d.ts",
+  "bin": {
+    "custom-elements-manifest": "./cem.js",
+    "cem": "./cem.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/open-wc/custom-elements-manifest.git",
+    "directory": "packages/analyzer"
+  },
+  "author": "open-wc",
+  "homepage": "https://github.com/open-wc/custom-elements-manifest",
+  "bugs": {
+    "url": "https://github.com/open-wc/custom-elements-manifest"
+  },
+  "main": "index.js",
+  "scripts": {
+    "prepublishOnly": "npm test && npm run build:browser",
+    "start": "nodemon --ignore './custom-elements.json' cem.js analyze --dev --fast",
+    "test": "asdgf",
+    "build:browser": "esbuild src/browser-entrypoint.js --bundle --format=esm --outfile=browser/index.js",
+    "test:watch": "watchexec -w src -w test npm test",
+    "update-fixtures": "node scripts/update-version.js --version 1.0.0"
+  },
+  "keywords": [
+    "custom-elements",
+    "custom-elements-json",
+    "custom-elements-manifest",
+    "customelements",
+    "webcomponents",
+    "customelementsjson",
+    "customelementsmanifest"
+  ],
+  "dependencies": {
+    "@custom-elements-manifest/find-dependencies": "^0.0.6",
+    "@github/catalyst": "^1.6.0",
+    "@web/config-loader": "0.1.3",
+    "chokidar": "3.5.2",
+    "command-line-args": "5.1.2",
+    "comment-parser": "1.2.4",
+    "custom-elements-manifest": "1.0.0",
+    "debounce": "1.2.1",
+    "globby": "11.0.4",
+    "typescript": "~5.4.2"
+  },
+  "devDependencies": {},
+  "contributors": [
+    "Pascal Schilp <pascalschilp@gmail.com>",
+    "Benny Powers <web@bennypowers.com>",
+    "Matias Huhta <huhta.matias@gmail.com>"
+  ],
+  "customElements": "custom-elements.json"
+}

package/lib/cem/patch/@custom-elements-manifest/analyzer/src/browser-entrypoint.js

@@ -0,0 +1,23 @@
+/**
+ * This file is the entrypoint for rollup to correctly bundle the analyzer for the browser.
+ * Do not use directly, but import from ./browser/index.js
+ */
+
+import ts from 'typescript';
+
+import { create } from './create.js';
+import { catalystPlugin } from './features/framework-plugins/catalyst/catalyst.js';
+import { catalystPlugin2 } from './features/framework-plugins/catalyst-major-2/catalyst.js';
+import { stencilPlugin } from './features/framework-plugins/stencil/stencil.js';
+import { litPlugin } from './features/framework-plugins/lit/lit.js';
+import { fastPlugin } from './features/framework-plugins/fast/fast.js';
+
+export { 
+  ts,
+  create,
+  catalystPlugin,
+  catalystPlugin2,
+  stencilPlugin,
+  litPlugin,
+  fastPlugin
+};

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

@@ -0,0 +1,117 @@
+import ts from 'typescript';
+import { FEATURES } from './features/index.js';
+import { withErrorHandling } from './utils/index.js';
+
+/**
+ * CORE
+ *
+ * This function is the core of the analyzer. It takes an array of ts sourceFiles, and creates a
+ * custom elements manifest.
+ */
+export function create({modules, plugins = [], context = {dev:false}}) {
+  const customElementsManifest = {
+    schemaVersion: '1.0.0',
+    readme: '',
+    modules: [],
+  };
+
+  const { dev } = context;
+
+  const mergedPlugins = [
+    ...FEATURES,
+    ...plugins,
+  ];
+
+  if(dev) console.log('[INITIALIZE PLUGINS]');
+  mergedPlugins.forEach(({name, initialize}) => {
+    withErrorHandling(name, () => {
+      initialize?.({ts, customElementsManifest, context});
+    });
+  });
+
+  modules.forEach(currModule => {
+    if(dev) console.log('[COLLECT PHASE]: ', currModule.fileName);
+    /**
+     * COLLECT PHASE
+     * First pass through all modules. Can be used to gather imports, exports, types, default values,
+     * which you may need to know the existence of in a later phase.
+     */
+    collect(currModule, context, mergedPlugins);
+  });
+
+  modules.forEach(currModule => {
+    if(dev) console.log('[ANALYZE PHASE]: ', currModule.fileName);
+    const moduleDoc = {
+      kind: "javascript-module",
+      path: currModule.fileName,
+      declarations: [],
+      exports: []
+    };
+
+    /**
+     * ANALYZE PHASE
+     * Go through the AST of every separate module, and gather as much as information as we can
+     * This includes a modules imports, which are not specified in custom-elements.json, but are
+     * required for the LINK PHASE, and deleted when processed
+     */
+    analyze(currModule, moduleDoc, context, mergedPlugins);
+    customElementsManifest.modules.push(moduleDoc);
+
+    if(dev) console.log('[MODULE LINK PHASE]: ', currModule.fileName);
+    /**
+     * LINK PHASE
+     * All information for a module has been gathered, now we can link information together. Like:
+     * - Finding a CustomElement's tagname by finding its customElements.define() call (or 'export')
+     * - Applying inheritance to classes (adding `inheritedFrom` properties/attrs/events/methods)
+     */
+    mergedPlugins.forEach(({name, moduleLinkPhase}) => {
+      withErrorHandling(name, () => {
+        moduleLinkPhase?.({ts, moduleDoc, context});
+      });
+    });
+  });
+
+  if(dev) console.log('[PACKAGE LINK PHASE]');
+  /**
+   * PACKAGE LINK PHASE
+   * All modules have now been parsed, we can now link information from across modules together
+   * - Link classes to their definitions etc
+   * - Match tagNames for classDocs
+   * - Apply inheritance
+   */
+  mergedPlugins.forEach(({name, packageLinkPhase}) => {
+    withErrorHandling(name, () => {
+      packageLinkPhase?.({customElementsManifest, context});
+    });
+  });
+
+  return customElementsManifest;
+}
+
+function collect(source, context, mergedPlugins) {
+  visitNode(source);
+
+  function visitNode(node) {
+    mergedPlugins.forEach(({name, collectPhase}) => {
+      withErrorHandling(name, () => {
+        collectPhase?.({ts, node, context});
+      });
+    });
+
+    ts.forEachChild(node, visitNode);
+  }
+}
+
+function analyze(source, moduleDoc, context, mergedPlugins) {
+  visitNode(source);
+
+  function visitNode(node) {
+    mergedPlugins.forEach(({name, analyzePhase}) => {
+      withErrorHandling(name, () => {
+        analyzePhase?.({ts, node, moduleDoc, context});
+      });
+    });
+
+    ts.forEachChild(node, visitNode);
+  }
+}