@jay-framework/compiler-analyze-exported-types 0.5.0

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { JayType } from '@jay-framework/compiler-shared';
+
+interface ResolveTsConfigOptions {
+    relativePath?: string;
+}
+declare function resolveTsConfig(options: ResolveTsConfigOptions): string;
+
+declare function analyzeExportedTypes(filename: string, options?: ResolveTsConfigOptions): JayType[];
+
+export { type ResolveTsConfigOptions, analyzeExportedTypes, resolveTsConfig };

package/dist/index.js

@@ -0,0 +1,180 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+const ts = require("typescript");
+const compilerShared = require("@jay-framework/compiler-shared");
+function resolveTsConfig(options) {
+  const tsConfigPath = path.resolve(process.cwd(), options.relativePath || "tsconfig.json");
+  if (!ts.sys.fileExists(tsConfigPath)) {
+    if (options.relativePath) {
+      throw new Error(`Could not find specified tsconfig.json at ${tsConfigPath}`);
+    } else {
+      return null;
+    }
+  }
+  return tsConfigPath;
+}
+function getTypeName(typeName) {
+  if (ts.isIdentifier(typeName))
+    return typeName.text;
+  else if (ts.isQualifiedName(typeName))
+    return `${getTypeName(typeName.left)}.${typeName.right.text}`;
+}
+function getJayType(typeNode, types) {
+  let propType = compilerShared.resolvePrimitiveType(typeNode.getText());
+  if (propType === compilerShared.JayUnknown && ts.isTypeReferenceNode(typeNode)) {
+    const typeName = getTypeName(typeNode.typeName);
+    if (typeName === "Array" && typeNode.typeArguments.length > 0)
+      propType = new compilerShared.JayArrayType(getJayType(typeNode.typeArguments[0], types));
+    else
+      propType = types.find((_) => _.name === getTypeName(typeNode.typeName)) ?? compilerShared.JayUnknown;
+  }
+  return propType;
+}
+function getInterfaceJayType(interfaceDeclaration, types) {
+  let props = {};
+  const jayObjectType = new compilerShared.JayObjectType(interfaceDeclaration.name.text, props);
+  interfaceDeclaration.members.filter((member) => ts.isPropertySignature(member) && ts.isIdentifier(member.name)).forEach((member) => {
+    let property = member;
+    let name = member.name;
+    let propKey = name.text;
+    props[propKey] = getJayType(property.type, [...types, jayObjectType]);
+  });
+  return jayObjectType;
+}
+function getElementConstructorType(name, typeName) {
+  return new compilerShared.JayElementConstructorType(name, typeName);
+}
+function getComponentType(tsTypeChecker, name, componentType) {
+  let properties = componentType.getProperties();
+  let componentAPIs = [];
+  for (let property of properties) {
+    let type = tsTypeChecker.getTypeAtLocation(property.getDeclarations()[0]);
+    if (JayComponentProperties[property.getName()])
+      ;
+    else {
+      if (type.getSymbol().getName() === "EventEmitter")
+        componentAPIs.push(new compilerShared.JayComponentApiMember(property.getName(), true));
+      else
+        componentAPIs.push(new compilerShared.JayComponentApiMember(property.getName(), false));
+    }
+  }
+  return new compilerShared.JayComponentType(name, componentAPIs);
+}
+function autoAddExtension(filename) {
+  if (fs.existsSync(filename + ".ts"))
+    return filename + ".ts";
+  else if (fs.existsSync(filename + ".tsx"))
+    return filename + ".tsx";
+  else if (fs.existsSync(filename + ".d.ts"))
+    return filename + ".d.ts";
+  else if (fs.existsSync(filename))
+    return filename;
+  else
+    throw new Error(`File not found. Tried ${filename}, ${filename}.ts and ${filename}.d.ts`);
+}
+function isOrSubclassOf(type, ofClass) {
+  if (type.symbol?.name === ofClass)
+    return true;
+  for (let baseType of type.getBaseTypes() || [])
+    if (baseType.symbol?.name === ofClass)
+      return true;
+  return false;
+}
+const JayComponentProperties = {
+  element: true,
+  update: true,
+  mount: true,
+  unmount: true,
+  addEventListener: true,
+  removeEventListener: true
+};
+function loadTSCompilerOptions(options = {}) {
+  let tsConfigPath = resolveTsConfig(options);
+  let loadedTSConfig = fs.readFileSync(tsConfigPath, "utf8");
+  let tsConfig = ts.parseConfigFileTextToJson("tsconfig.json", loadedTSConfig);
+  return ts.convertCompilerOptionsFromJson(tsConfig.config.compilerOptions, tsConfigPath).options;
+}
+function isExportedStatement(statement) {
+  return Boolean(
+    statement.modifiers && statement.modifiers.find(
+      (_) => _.kind === ts.SyntaxKind.ExportKeyword
+    )
+  );
+}
+const SYMBOLS = {
+  MAKE_JAY_COMPONENT: { module: compilerShared.JAY_COMPONENT, namedImport: compilerShared.MAKE_JAY_COMPONENT }
+};
+function findImportedSymbol(module2, namedImport) {
+  return Object.values(SYMBOLS).find(
+    (importedSymbol) => importedSymbol.module === module2 && importedSymbol.namedImport == namedImport
+  );
+}
+function mapImportedSymbols(statements, tsTypeChecker) {
+  statements.filter(ts.isImportDeclaration).forEach((importDeclaration) => {
+    if (ts.isStringLiteral(importDeclaration.moduleSpecifier) && importDeclaration.importClause?.namedBindings) {
+      const module2 = importDeclaration.moduleSpecifier.text;
+      if (ts.isNamedImports(importDeclaration.importClause.namedBindings)) {
+        importDeclaration.importClause.namedBindings.elements.forEach((namedImport) => {
+          const name = namedImport.name.text;
+          const importedSymbol = findImportedSymbol(module2, name);
+          if (importedSymbol)
+            importedSymbol.symbol = tsTypeChecker.getTypeAtLocation(namedImport).symbol;
+        });
+      }
+    }
+  });
+  return SYMBOLS;
+}
+function analyzeExportedTypes(filename, options = {}) {
+  let compilerOptions = loadTSCompilerOptions(options);
+  filename = autoAddExtension(filename);
+  const program = ts.createProgram([filename], compilerOptions);
+  const sourceFile = program.getSourceFile(filename);
+  const tsTypeChecker = program.getTypeChecker();
+  const types = [];
+  const { MAKE_JAY_COMPONENT: MAKE_JAY_COMPONENT2 } = mapImportedSymbols(sourceFile.statements, tsTypeChecker);
+  for (const statement of sourceFile.statements.filter(isExportedStatement)) {
+    if (ts.isInterfaceDeclaration(statement)) {
+      types.push(getInterfaceJayType(statement, types));
+    } else if (ts.isFunctionDeclaration(statement)) {
+      const functionType = tsTypeChecker.getTypeAtLocation(statement.type);
+      if (functionType.symbol || functionType.aliasSymbol) {
+        const typeName = functionType.symbol?.name;
+        const functionName = statement?.name.text;
+        const aliasName = functionType.aliasSymbol ? functionType.aliasSymbol.name : typeName;
+        if (functionName && isOrSubclassOf(functionType, "JayElement")) {
+          types.push(getElementConstructorType(functionName, aliasName));
+        } else if (isOrSubclassOf(functionType, "JayComponent")) {
+          types.push(getComponentType(tsTypeChecker, functionName, functionType));
+        } else
+          types.push(compilerShared.JayUnknown);
+      }
+    } else if (ts.isTypeAliasDeclaration(statement)) {
+      if (ts.isTypeReferenceNode(statement.type) && ts.isIdentifier(statement.type.typeName) && statement.type.typeName.text === "JayElement")
+        types.push(new compilerShared.JayElementType(statement.name.text));
+    } else if (ts.isVariableStatement(statement)) {
+      statement.declarationList.declarations.forEach((declaration) => {
+        if (ts.isCallExpression(declaration.initializer) && ts.isIdentifier(declaration.name)) {
+          const functionType = tsTypeChecker.getTypeAtLocation(
+            declaration.initializer.expression
+          );
+          const name = declaration.name.text;
+          if (functionType.symbol === MAKE_JAY_COMPONENT2.symbol) {
+            const callMakeJayComponentSignature = tsTypeChecker.getResolvedSignature(
+              declaration.initializer
+            );
+            const componentConstructorSignature = callMakeJayComponentSignature.getReturnType().getCallSignatures();
+            let componentType = componentConstructorSignature[0].getReturnType();
+            types.push(getComponentType(tsTypeChecker, name, componentType));
+          }
+        }
+      });
+    } else
+      types.push(compilerShared.JayUnknown);
+  }
+  return types;
+}
+exports.analyzeExportedTypes = analyzeExportedTypes;
+exports.resolveTsConfig = resolveTsConfig;

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@jay-framework/compiler-analyze-exported-types",
+  "version": "0.5.0",
+  "description": "",
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "directories": {
+    "lib": "lib"
+  },
+  "files": [
+    "dist",
+    "readme.md"
+  ],
+  "scripts": {
+    "build": "npm run build:js && npm run build:types",
+    "build:watch": "npm run build:js -- --watch & npm run build:types -- --watch",
+    "build:js": "vite build",
+    "build:types": "tsup lib/index.ts --dts-only --format cjs",
+    "build:check-types": "tsc",
+    "clean": "rimraf dist",
+    "confirm": "npm run clean && npm run build && npm run build:check-types && npm run test",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "author": "",
+  "dependencies": {
+    "@jay-framework/compiler-shared": "workspace:^",
+    "@jay-framework/component": "workspace:^",
+    "@jay-framework/runtime": "workspace:^",
+    "@jay-framework/secure": "workspace:^",
+    "@types/js-yaml": "^4.0.9",
+    "change-case": "^4.1.2",
+    "js-yaml": "^4.1.0",
+    "node-html-parser": "^6.1.12",
+    "pluralize": "^8.0.0",
+    "typescript": "^5.3.3"
+  },
+  "devDependencies": {
+    "@caiogondim/strip-margin": "^1.0.0",
+    "@jay-framework/dev-environment": "workspace:^",
+    "@testing-library/jest-dom": "^6.2.0",
+    "@types/js-beautify": "^1",
+    "@types/node": "^20.11.5",
+    "jest-diff": "^29.7.0",
+    "jest-matcher-utils": "^29.7.0",
+    "js-beautify": "^1.14.11",
+    "rimraf": "^5.0.5",
+    "tsup": "^8.0.1",
+    "vite": "^5.0.11",
+    "vitest": "^1.2.1"
+  }
+}