@aws/nx-plugin 0.0.0

package/src/ts/cjs-to-esm/generator.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    cjsToEsm: function() {
+        return cjsToEsm;
+    },
+    cjsToEsmGenerator: function() {
+        return cjsToEsmGenerator;
+    },
+    default: function() {
+        return _default;
+    }
+});
+const _interop_require_wildcard = require("@swc/helpers/_/_interop_require_wildcard");
+const _devkit = require("@nx/devkit");
+const _tsquery = require("@phenomnomnominal/tsquery");
+const _typescript = /*#__PURE__*/ _interop_require_wildcard._(require("typescript"));
+const _minimatch = require("minimatch");
+// Replaces "module.exports = value" with "export default value"
+const replaceModuleExportsWithExportDefault = (sourceFile)=>{
+    const transformer = (context)=>(rootNode)=>{
+            function visit(node) {
+                if (_typescript.isExpressionStatement(node)) {
+                    const expr = node.expression;
+                    if (_typescript.isBinaryExpression(expr) && _typescript.isPropertyAccessExpression(expr.left) && _typescript.isIdentifier(expr.left.expression) && expr.left.expression.text === 'module' && _typescript.isIdentifier(expr.left.name) && expr.left.name.text === 'exports' && expr.operatorToken.kind === _typescript.SyntaxKind.EqualsToken) {
+                        // Create an export default statement
+                        return context.factory.createExportAssignment(undefined, undefined, expr.right);
+                    }
+                }
+                return _typescript.visitEachChild(node, visit, context);
+            }
+            return _typescript.visitNode(rootNode, visit);
+        };
+    const result = _typescript.transform(sourceFile, [
+        transformer
+    ]);
+    return result.transformed[0];
+};
+// Replaces "const x = require('y')" with "import x from 'y'"
+const replaceRequires = (sourceFile)=>{
+    const transformer = (context)=>(rootNode)=>{
+            function visit(node) {
+                if (_typescript.isVariableStatement(node)) {
+                    const declaration = node.declarationList.declarations[0];
+                    if (declaration && _typescript.isVariableDeclaration(declaration)) {
+                        const initializer = declaration.initializer;
+                        if (initializer && _typescript.isCallExpression(initializer) && _typescript.isIdentifier(initializer.expression) && initializer.expression.text === 'require' && initializer.arguments.length === 1) {
+                            const modulePath = initializer.arguments[0];
+                            if (_typescript.isStringLiteral(modulePath)) {
+                                // Handle destructuring pattern
+                                if (_typescript.isObjectBindingPattern(declaration.name)) {
+                                    const importSpecifiers = declaration.name.elements.map((element)=>{
+                                        if (_typescript.isBindingElement(element) && _typescript.isIdentifier(element.name)) {
+                                            return context.factory.createImportSpecifier(false, undefined, element.name);
+                                        }
+                                        return undefined;
+                                    }).filter((spec)=>spec !== undefined);
+                                    return context.factory.createImportDeclaration(undefined, context.factory.createImportClause(false, undefined, context.factory.createNamedImports(importSpecifiers)), modulePath, undefined);
+                                }
+                                // Handle simple require
+                                if (_typescript.isIdentifier(declaration.name)) {
+                                    return context.factory.createImportDeclaration(undefined, context.factory.createImportClause(false, declaration.name, undefined), modulePath, undefined);
+                                }
+                            }
+                        }
+                    }
+                }
+                return _typescript.visitEachChild(node, visit, context);
+            }
+            return _typescript.visitNode(rootNode, visit);
+        };
+    const result = _typescript.transform(sourceFile, [
+        transformer
+    ]);
+    return result.transformed[0];
+};
+// Replaces requires not directly assigned to variables eg
+// "const x = require('y').foo()" with
+// import _import0 from 'y'
+// const x = _import0.foo()
+const replaceInlineRequires = (sourceFile)=>{
+    let importCounter = 0;
+    const imports = [];
+    const importMap = new Map();
+    const transformer = (context)=>(rootNode)=>{
+            function visit(node) {
+                if (_typescript.isCallExpression(node) && _typescript.isIdentifier(node.expression) && node.expression.text === 'require' && node.arguments.length === 1 && _typescript.isStringLiteral(node.arguments[0])) {
+                    const modulePath = node.arguments[0];
+                    const modulePathText = modulePath.text;
+                    // Check if we already have an import for this module
+                    if (!importMap.has(modulePathText)) {
+                        const importName = `_import${importCounter++}`;
+                        importMap.set(modulePathText, importName);
+                        // Create import declaration
+                        imports.push(context.factory.createImportDeclaration(undefined, context.factory.createImportClause(false, context.factory.createIdentifier(importName), undefined), modulePath, undefined));
+                    }
+                    // Replace require() with the import reference
+                    return context.factory.createIdentifier(importMap.get(modulePathText));
+                }
+                return _typescript.visitEachChild(node, visit, context);
+            }
+            // First pass to collect all requires and create imports
+            const visited = _typescript.visitNode(rootNode, visit);
+            // If we found any inline requires, prepend the imports to the source file
+            if (imports.length > 0 && _typescript.isSourceFile(visited)) {
+                return context.factory.updateSourceFile(visited, [
+                    ...imports,
+                    ...visited.statements
+                ]);
+            }
+            return visited;
+        };
+    const result = _typescript.transform(sourceFile, [
+        transformer
+    ]);
+    return result.transformed[0];
+};
+function cjsToEsm(tree, relativePathInTree, options) {
+    var _options_include;
+    const includePatterns = (_options_include = options == null ? void 0 : options.include) != null ? _options_include : [
+        '**/*.{js,ts}'
+    ];
+    var _options_exclude;
+    const excludePatterns = (_options_exclude = options == null ? void 0 : options.exclude) != null ? _options_exclude : [
+        'node_modules',
+        'dist',
+        'build',
+        'tmp',
+        '.nx'
+    ].flatMap((p)=>[
+            p,
+            `**/${p}/**/*`,
+            `${p}/**/*`
+        ]);
+    // Process each TypeScript/JavaScript file in the project
+    const processFile = (filePath)=>{
+        const content = tree.read(filePath, 'utf-8');
+        if (!content) return;
+        // Parse the source file
+        const originalSourceFile = _tsquery.tsquery.ast(content);
+        let sourceFile = originalSourceFile;
+        sourceFile = replaceModuleExportsWithExportDefault(sourceFile);
+        sourceFile = replaceRequires(sourceFile);
+        sourceFile = replaceInlineRequires(sourceFile);
+        const printer = _typescript.createPrinter({
+            removeComments: false,
+            newLine: _typescript.NewLineKind.LineFeed
+        });
+        tree.write(filePath, printer.printNode(_typescript.EmitHint.Unspecified, sourceFile, originalSourceFile));
+    };
+    // Process all files in the given directory (recursively)
+    const processDirectory = (dirPath)=>{
+        const entries = tree.children(dirPath);
+        entries.forEach((entry)=>{
+            const fullPath = `${dirPath}/${entry}`;
+            const relativePath = fullPath.replace(`${relativePathInTree}/`, '');
+            // Return early for exclude to ensure we don't traverse node_modules etc!
+            const shouldExclude = excludePatterns.some((pattern)=>(0, _minimatch.minimatch)(relativePath, pattern));
+            if (shouldExclude) {
+                return;
+            }
+            if (tree.isFile(fullPath)) {
+                const shouldInclude = includePatterns.some((pattern)=>(0, _minimatch.minimatch)(relativePath, pattern));
+                if (shouldInclude) {
+                    processFile(fullPath);
+                }
+            } else {
+                processDirectory(fullPath);
+            }
+        });
+    };
+    // Start processing from the given directories
+    processDirectory(relativePathInTree);
+}
+async function cjsToEsmGenerator(tree, options) {
+    // Get the project configuration
+    const projects = (0, _devkit.getProjects)(tree);
+    const project = projects.get(options.project);
+    if (!project) {
+        throw new Error(`Project ${options.project} not found`);
+    }
+    cjsToEsm(tree, project.root, {
+        include: options.include ? [
+            options.include
+        ] : undefined,
+        exclude: options.exclude ? [
+            options.exclude
+        ] : undefined
+    });
+}
+const _default = cjsToEsmGenerator;
+
+//# sourceMappingURL=generator.js.map

package/src/ts/cjs-to-esm/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/ts/cjs-to-esm/generator.ts"],"sourcesContent":["import {\n  Tree,\n  getProjects,\n} from '@nx/devkit';\nimport { CjsToEsmGeneratorSchema } from './schema';\nimport { tsquery } from '@phenomnomnominal/tsquery';\nimport * as ts from 'typescript';\nimport { minimatch } from 'minimatch';\n\n// Replaces \"module.exports = value\" with \"export default value\"\nconst replaceModuleExportsWithExportDefault = (sourceFile: ts.SourceFile): ts.SourceFile => {\n  const transformer = <T extends ts.Node>(context: ts.TransformationContext) => (rootNode: T) => {\n    function visit(node: ts.Node): ts.Node {\n      if (ts.isExpressionStatement(node)) {\n        const expr = node.expression;\n        if (ts.isBinaryExpression(expr) &&\n            ts.isPropertyAccessExpression(expr.left) &&\n            ts.isIdentifier(expr.left.expression) &&\n            expr.left.expression.text === 'module' &&\n            ts.isIdentifier(expr.left.name) &&\n            expr.left.name.text === 'exports' &&\n            expr.operatorToken.kind === ts.SyntaxKind.EqualsToken) {\n\n          // Create an export default statement\n          return context.factory.createExportAssignment(\n            undefined,\n            undefined,\n            expr.right\n          );\n        }\n      }\n      return ts.visitEachChild(node, visit, context);\n    }\n    return ts.visitNode(rootNode, visit);\n  };\n\n  const result = ts.transform(sourceFile, [transformer]);\n  return result.transformed[0] as ts.SourceFile;\n};\n\n// Replaces \"const x = require('y')\" with \"import x from 'y'\"\nconst replaceRequires = (sourceFile: ts.SourceFile): ts.SourceFile => {\n  const transformer = <T extends ts.Node>(context: ts.TransformationContext) => (rootNode: T) => {\n    function visit(node: ts.Node): ts.Node {\n      if (ts.isVariableStatement(node)) {\n        const declaration = node.declarationList.declarations[0];\n        if (declaration && ts.isVariableDeclaration(declaration)) {\n          const initializer = declaration.initializer;\n          if (initializer && ts.isCallExpression(initializer) &&\n              ts.isIdentifier(initializer.expression) &&\n              initializer.expression.text === 'require' &&\n              initializer.arguments.length === 1) {\n\n            const modulePath = initializer.arguments[0];\n            if (ts.isStringLiteral(modulePath)) {\n              // Handle destructuring pattern\n              if (ts.isObjectBindingPattern(declaration.name)) {\n                const importSpecifiers = declaration.name.elements.map(element => {\n                  if (ts.isBindingElement(element) && ts.isIdentifier(element.name)) {\n                    return context.factory.createImportSpecifier(\n                      false,\n                      undefined,\n                      element.name\n                    );\n                  }\n                  return undefined;\n                }).filter((spec): spec is ts.ImportSpecifier => spec !== undefined);\n\n                return context.factory.createImportDeclaration(\n                  undefined,\n                  context.factory.createImportClause(\n                    false,\n                    undefined,\n                    context.factory.createNamedImports(importSpecifiers)\n                  ),\n                  modulePath,\n                  undefined\n                );\n              }\n\n              // Handle simple require\n              if (ts.isIdentifier(declaration.name)) {\n                return context.factory.createImportDeclaration(\n                  undefined,\n                  context.factory.createImportClause(\n                    false,\n                    declaration.name,\n                    undefined\n                  ),\n                  modulePath,\n                  undefined\n                );\n              }\n            }\n          }\n        }\n      }\n      return ts.visitEachChild(node, visit, context);\n    }\n    return ts.visitNode(rootNode, visit);\n  };\n\n  const result = ts.transform(sourceFile, [transformer]);\n  return result.transformed[0] as ts.SourceFile;\n};\n\n// Replaces requires not directly assigned to variables eg\n// \"const x = require('y').foo()\" with\n// import _import0 from 'y'\n// const x = _import0.foo()\nconst replaceInlineRequires = (sourceFile: ts.SourceFile): ts.SourceFile => {\n  let importCounter = 0;\n  const imports: ts.ImportDeclaration[] = [];\n  const importMap = new Map<string, string>();\n\n  const transformer = <T extends ts.Node>(context: ts.TransformationContext) => (rootNode: T) => {\n    function visit(node: ts.Node): ts.Node {\n      if (ts.isCallExpression(node) &&\n          ts.isIdentifier(node.expression) &&\n          node.expression.text === 'require' &&\n          node.arguments.length === 1 &&\n          ts.isStringLiteral(node.arguments[0])) {\n\n        const modulePath = node.arguments[0];\n        const modulePathText = modulePath.text;\n\n        // Check if we already have an import for this module\n        if (!importMap.has(modulePathText)) {\n          const importName = `_import${importCounter++}`;\n          importMap.set(modulePathText, importName);\n\n          // Create import declaration\n          imports.push(context.factory.createImportDeclaration(\n            undefined,\n            context.factory.createImportClause(\n              false,\n              context.factory.createIdentifier(importName),\n              undefined\n            ),\n            modulePath,\n            undefined\n          ));\n        }\n\n        // Replace require() with the import reference\n        return context.factory.createIdentifier(importMap.get(modulePathText)!);\n      }\n\n      return ts.visitEachChild(node, visit, context);\n    }\n\n    // First pass to collect all requires and create imports\n    const visited = ts.visitNode(rootNode, visit);\n\n    // If we found any inline requires, prepend the imports to the source file\n    if (imports.length > 0 && ts.isSourceFile(visited)) {\n      return context.factory.updateSourceFile(\n        visited,\n        [...imports, ...visited.statements]\n      );\n    }\n\n    return visited;\n  };\n\n  const result = ts.transform(sourceFile, [transformer]);\n  return result.transformed[0] as ts.SourceFile;\n};\n\nexport function cjsToEsm(tree: Tree, relativePathInTree: string, options?: { include?: string[]; exclude?: string[] }) {\n  const includePatterns = options?.include ?? ['**/*.{js,ts}'];\n  const excludePatterns = options?.exclude ?? ['node_modules', 'dist', 'build', 'tmp', '.nx'].flatMap(p => [p, `**/${p}/**/*`, `${p}/**/*`]);\n\n  // Process each TypeScript/JavaScript file in the project\n  const processFile = (filePath: string) => {\n    const content = tree.read(filePath, 'utf-8');\n    if (!content) return;\n\n    // Parse the source file\n    const originalSourceFile = tsquery.ast(content);\n    let sourceFile = originalSourceFile;\n\n    sourceFile = replaceModuleExportsWithExportDefault(sourceFile);\n    sourceFile = replaceRequires(sourceFile);\n    sourceFile = replaceInlineRequires(sourceFile);\n\n    const printer = ts.createPrinter({ removeComments: false, newLine: ts.NewLineKind.LineFeed });\n    tree.write(filePath, printer.printNode(ts.EmitHint.Unspecified, sourceFile, originalSourceFile));\n  };\n\n  // Process all files in the given directory (recursively)\n  const processDirectory = (dirPath: string) => {\n    const entries = tree.children(dirPath);\n    entries.forEach(entry => {\n      const fullPath = `${dirPath}/${entry}`;\n      const relativePath = fullPath.replace(`${relativePathInTree}/`, '');\n\n      // Return early for exclude to ensure we don't traverse node_modules etc!\n      const shouldExclude = excludePatterns.some(pattern => minimatch(relativePath, pattern));\n      if (shouldExclude) {\n        return;\n      }\n\n      if (tree.isFile(fullPath)) {\n        const shouldInclude = includePatterns.some(pattern => minimatch(relativePath, pattern));\n        if (shouldInclude) {\n          processFile(fullPath);\n        }\n      } else {\n        processDirectory(fullPath);\n      }\n    });\n  };\n\n  // Start processing from the given directories\n  processDirectory(relativePathInTree);\n}\n\nexport async function cjsToEsmGenerator(\n  tree: Tree,\n  options: CjsToEsmGeneratorSchema\n) {\n  // Get the project configuration\n  const projects = getProjects(tree);\n  const project = projects.get(options.project);\n\n  if (!project) {\n    throw new Error(`Project ${options.project} not found`);\n  }\n\n  cjsToEsm(tree, project.root, {\n    include: options.include ? [options.include] : undefined,\n    exclude: options.exclude ? [options.exclude] : undefined,\n  });\n}\n\nexport default cjsToEsmGenerator;\n"],"names":["cjsToEsm","cjsToEsmGenerator","replaceModuleExportsWithExportDefault","sourceFile","transformer","context","rootNode","visit","node","ts","isExpressionStatement","expr","expression","isBinaryExpression","isPropertyAccessExpression","left","isIdentifier","text","name","operatorToken","kind","SyntaxKind","EqualsToken","factory","createExportAssignment","undefined","right","visitEachChild","visitNode","result","transform","transformed","replaceRequires","isVariableStatement","declaration","declarationList","declarations","isVariableDeclaration","initializer","isCallExpression","arguments","length","modulePath","isStringLiteral","isObjectBindingPattern","importSpecifiers","elements","map","element","isBindingElement","createImportSpecifier","filter","spec","createImportDeclaration","createImportClause","createNamedImports","replaceInlineRequires","importCounter","imports","importMap","Map","modulePathText","has","importName","set","push","createIdentifier","get","visited","isSourceFile","updateSourceFile","statements","tree","relativePathInTree","options","includePatterns","include","excludePatterns","exclude","flatMap","p","processFile","filePath","content","read","originalSourceFile","tsquery","ast","printer","createPrinter","removeComments","newLine","NewLineKind","LineFeed","write","printNode","EmitHint","Unspecified","processDirectory","dirPath","entries","children","forEach","entry","fullPath","relativePath","replace","shouldExclude","some","pattern","minimatch","isFile","shouldInclude","projects","getProjects","project","Error","root"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

package/src/ts/cjs-to-esm/schema.d.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=schema.d.js.map

package/src/ts/cjs-to-esm/schema.d.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../packages/nx-plugin/src/ts/cjs-to-esm/schema.d.ts"],"names":[],"rangeMappings":"","mappings":""}

package/src/ts/cjs-to-esm/schema.d.ts

@@ -0,0 +1,5 @@
+export interface CjsToEsmGeneratorSchema {
+  project: string;
+  include?: string;
+  exclude?: string;
+}

package/src/ts/cjs-to-esm/schema.json

@@ -0,0 +1,28 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "cli": "nx",
+  "$id": "ts-cjs-to-esm",
+  "title": "Convert CommonJS to ESM",
+  "type": "object",
+  "properties": {
+    "project": {
+      "type": "string",
+      "description": "The name of the project to convert",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-dropdown": "projects"
+    },
+    "include": {
+      "type": "string",
+      "description": "Glob pattern for files to include in the conversion",
+      "default": "**/*.{js,ts}"
+    },
+    "exclude": {
+      "type": "string",
+      "description": "Glob pattern for files to exclude from the conversion. If not provided, patterns from .gitignore will be used"
+    }
+  },
+  "required": ["project"]
+}

package/src/ts/lib/README.md

@@ -0,0 +1,149 @@
+# TypeScript Library Generator
+
+## Overview
+This generator creates a new TypeScript library with modern configuration and best practices. It sets up a complete TypeScript project with ESM modules, proper build configuration, and optional linting and testing support. The generator is designed to create reusable TypeScript packages that can be shared across your organization's projects.
+
+## Usage
+
+You can generate a new TypeScript library in two ways:
+
+### 1. Using VSCode IDE
+
+First, install the NX Console extension for VSCode:
+1. Open VSCode
+2. Go to Extensions (Ctrl+Shift+X / Cmd+Shift+X)
+3. Search for "Nx Console"
+4. Install [Nx Console](https://marketplace.visualstudio.com/items?itemName=nrwl.angular-console)
+
+Then generate your library:
+1. Open the NX Console in VSCode
+2. Click on "Generate"
+3. Search for "ts#lib"
+4. Fill in the required parameters in the form
+5. Click "Run"
+
+### 2. Using CLI
+
+Generate the library:
+```bash
+nx g @aws/nx-plugin:ts#lib my-lib --directory=packages
+```
+
+You can also perform a dry-run to see what files would be generated without actually creating them:
+```bash
+nx g @aws/nx-plugin:ts#lib my-lib --directory=packages --dry-run
+```
+
+Both methods will create a new TypeScript library in the specified directory with all the necessary configuration.
+
+## Input Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| name* | string | - | Library name (required). Used to generate package name and file paths. |
+| directory | string | "packages" | Parent directory where the library is placed. |
+| linter | string | "eslint" | The tool to use for running lint checks. Options: eslint, none |
+| unitTestRunner | string | "none" | Test runner to use for unit tests. Options: jest, vitest, none |
+| scope | string | - | Scope for your package (e.g., @my-company). If omitted, this will be inferred from your project configuration. Must be in format @scope or @scope/subscope. |
+| subDirectory | string | library name | The sub directory the lib is placed in. By default, this is the library name. |
+
+*Required parameter
+
+## Expected Output
+
+The generator creates a TypeScript library with the following structure:
+
+```
+<directory>/<sub-directory>/
+├── src/
+│   └── index.ts          # Main entry point for your library
+├── tsconfig.json        # TypeScript configuration
+├── tsconfig.lib.json    # TypeScript build configuration
+├── project.json        # Project configuration and build targets
+└── .eslintrc.json     # ESLint configuration (if enabled)
+```
+
+Additionally, it:
+1. Configures the project for ESM (ECMAScript Modules)
+2. Sets up proper TypeScript configuration for library development
+3. Configures build settings for production deployment
+4. Sets up linting with ESLint (if enabled)
+5. Configures test runner (if enabled)
+6. Installs required dependencies
+
+## Best Practices
+
+### 1. Export Patterns
+
+Use explicit exports in your index.ts:
+
+```typescript
+// Good
+export { MyClass } from './my-class';
+export type { MyType } from './types';
+
+// Avoid
+export * from './everything';
+```
+
+### 2. TypeScript Configuration
+
+The generator sets up optimal TypeScript configuration, but you can customize it.
+
+### 3. Testing Setup
+
+If you enable testing, follow these practices:
+
+```typescript
+// my-feature.test.ts
+describe('MyFeature', () => {
+  it('should handle basic case', () => {
+    // Arrange
+    const input = 'test';
+    
+    // Act
+    const result = processInput(input);
+    
+    // Assert
+    expect(result).toBe('TEST');
+  });
+});
+```
+
+### 4. Documentation
+
+Add JSDoc comments to your public APIs:
+
+```typescript
+/**
+ * Processes the input string according to business rules.
+ * 
+ * @param input - The string to process
+ * @returns The processed string
+ * @throws {ValidationError} If input is invalid
+ * 
+ * @example
+ * ```ts
+ * const result = processInput('test');
+ * console.log(result); // 'TEST'
+ * ```
+ */
+export function processInput(input: string): string {
+  // Implementation
+}
+```
+
+### 5. Build Process
+
+The generator configures a build process that:
+- Compiles TypeScript to JavaScript
+- Generates type definitions
+- Creates source maps
+- Handles ESM modules properly
+
+You can build your library using:
+```bash
+nx build my-lib
+```
+
+This will create a `dist` directory in the root of your monorepo with your compiled library ready for distribution.