dctc 1.0.5 → 1.1.1

package/README.md

@@ -19,8 +19,9 @@ dctc [options] <file>
 
 ## Options
 ```
--h, --help      display help for command
--v, --version   output the version number
+-h, --help                    display help for command
+-v, --version                 output the version number
+-c, --compiler <name>         specify compiler: es, rollup, rolldown (default: es)
 ```
 
 ## Installation
@@ -114,6 +115,13 @@ work()
 dctc generate-html.tsx
 ```
 
+Or specify a compiler:
+
+```shell
+dctc --compiler rollup generate-html.tsx
+dctc -c rolldown generate-html.tsx
+```
+
 #### The `page.html` file has been generated, and it looks like this
 
 ```html

package/bin/index.js

@@ -14,6 +14,11 @@ function isHelp(param) {
   return lowerParam === "--help" || lowerParam === "-h"
 }
 
+function isCompilerOption(param) {
+  const lowerParam = param.toLowerCase();
+  return lowerParam === "--compiler" || lowerParam === "-c"
+}
+
 function isFilePath(param) {
   try {
     if (!fs.existsSync(param)) {
@@ -26,20 +31,43 @@ function isFilePath(param) {
   }
 }
 
-function work(param) {
-  if (isVersion(param)) {
-    applyVersion();
-  } else if (isHelp(param)) {
-    applyHelp()
-  } else if (isFilePath(param)) {
-    applyDctc(param);
+function work() {
+  const args = process.argv.slice(2);
+  let compiler = 'es'; // default compiler
+  let filePath = null;
+
+  // Parse arguments
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    
+    if (isVersion(arg)) {
+      applyVersion();
+      return;
+    } else if (isHelp(arg)) {
+      applyHelp();
+      return;
+    } else if (isCompilerOption(arg)) {
+      // Get compiler value from next argument
+      if (i + 1 < args.length) {
+        compiler = args[i + 1].toLowerCase();
+        i++; // Skip next argument as it's the compiler value
+      } else {
+        logErr('Please provide a compiler name after --compiler/-c');
+        applyHelp();
+        process.exit(1);
+      }
+    } else if (isFilePath(arg)) {
+      filePath = arg;
+    }
+  }
+
+  if (filePath) {
+    applyDctc(filePath, compiler);
   } else {
     logErr('Please provide a file path as an argument');
-    applyHelp()
+    applyHelp();
     process.exit(1);
   }
 }
 
-const param = process.argv[2];
-
-work(param)
+work()

package/lib/actions/index.js

@@ -1,5 +1,6 @@
-// const complie_vite = require("../complie_vite");
 const complie_es = require("../complie_es");
+const complie_rollup = require("../complie_rollup");
+const complie_rolldown = require("../complie_rolldown");
 const execute = require("../execute");
 const chalk = require("chalk");
 const log = content => console.log(chalk.green(content));
@@ -13,16 +14,36 @@ function applyHelp() {
   logInfo("dctc is a tool for running TypeScript and JSX files in the browser.");
   logInfo("Usage: dctc [options] <file>");
   logInfo("Options:");
-  logInfo(`  -v, --version  Print the version number`);
-  logInfo(`  -h, --help     Print this help message`);
+  logInfo(`  -v, --version        Print the version number`);
+  logInfo(`  -h, --help           Print this help message`);
+  logInfo(`  -c, --compiler <name> Specify compiler: es, rollup, rolldown (default: es)`);
   logInfo("Examples:");
   logInfo(`  dctc src/index.tsx`);
   logInfo(`  dctc src/index.ts`);
+  logInfo(`  dctc --compiler rollup src/index.tsx`);
+  logInfo(`  dctc -c rolldown src/index.ts`);
 }
 
-async function applyDctc(inputFile) {
-  // const code = await complie_vite(inputFile);
-  const code = await complie_es(inputFile);
+async function applyDctc(inputFile, compiler = 'es') {
+  let code;
+  
+  switch (compiler.toLowerCase()) {
+    case 'es':
+    case 'esbuild':
+      code = await complie_es(inputFile);
+      break;
+    case 'rollup':
+      code = await complie_rollup(inputFile);
+      break;
+    case 'rolldown':
+      code = await complie_rolldown(inputFile);
+      break;
+    default:
+      log(`Unknown compiler: ${compiler}, using default 'es'`);
+      code = await complie_es(inputFile);
+      break;
+  }
+  
   execute(code, inputFile);
   process.exit(0);
 }

package/lib/complie_es.js

@@ -80,6 +80,8 @@ module.exports = async function (filePath) {
     const code = result.outputFiles[0].text;
     return code;
   } catch (error) {
-    logErr('Build failed:', error); // Log build failure
+    logErr('Build failed:');
+    console.error(error);
+    throw error;
   }
 }

package/lib/complie_rolldown.js

@@ -0,0 +1,50 @@
+/**
+ * Compile a given file to CommonJS format using Rolldown.
+ * This function takes a file path, compiles it to CommonJS format,
+ * and returns the compiled code.
+ * @param {string} filePath - The path to the file to be compiled.
+ * @returns {Promise<string>} - The compiled code.
+ * @author pipi
+ */
+const fs = require('fs'); // Import the file system module
+const path = require('path'); // Import the path module
+const chalk = require("chalk");
+const { rolldown } = require('rolldown');
+const logErr = content => console.log(chalk.red(content)); // Function to log error messages in red color
+
+module.exports = async function (filePath) {
+  // Ensure the file exists
+  if (!fs.existsSync(filePath)) {
+    console.error(`File does not exist: ${filePath}`);
+    process.exit(1);
+  }
+
+  // Get the absolute path of the file
+  const absoluteFilePath = path.resolve(filePath);
+
+  try {
+    // Create a rolldown build
+    const build = await rolldown({
+      input: absoluteFilePath,
+      external: ['react', 'react-dom'],
+      resolve: {
+        extensions: ['.ts', '.tsx', '.js', '.jsx', '.json'],
+      },
+      platform: 'node',
+    });
+
+    // Generate output without writing to file
+    const output = await build.generate({
+      format: 'cjs',
+    });
+
+    // Get the compiled code from output
+    const code = output.output[0].code;
+    
+    return code;
+  } catch (error) {
+    logErr('Build failed:');
+    console.error(error);
+    throw error;
+  }
+}

package/lib/complie_rollup.js

@@ -0,0 +1,167 @@
+/**
+ * Compile a given file to CommonJS format using Rollup.
+ * This function takes a file path, compiles it to CommonJS format,
+ * and returns the compiled code.
+ * @param {string} filePath - The path to the file to be compiled.
+ * @returns {Promise<string>} - The compiled code.
+ * @author pipi
+ */
+const fs = require('fs'); // Import the file system module
+const path = require('path'); // Import the path module
+const chalk = require("chalk");
+const rollup = require('rollup');
+const { nodeResolve } = require('@rollup/plugin-node-resolve');
+const commonjs = require('@rollup/plugin-commonjs');
+const typescript = require('@rollup/plugin-typescript');
+const logErr = content => console.log(chalk.red(content)); // Function to log error messages in red color
+
+// Custom plugin to ensure correct file resolution
+function resolveTsFiles() {
+  return {
+    name: 'resolve-ts-files',
+    resolveId(source, importer) {
+      // Only handle relative imports
+      if (!importer || !source.startsWith('.')) {
+        return null;
+      }
+      
+      const resolveDir = importer ? path.dirname(importer) : process.cwd();
+      const resolvedPath = path.resolve(resolveDir, source);
+      
+      // Check for .tsx first, then .ts
+      if (fs.existsSync(resolvedPath + '.tsx')) {
+        return resolvedPath + '.tsx';
+      } else if (fs.existsSync(resolvedPath + '.ts')) {
+        return resolvedPath + '.ts';
+      }
+      
+      return null;
+    },
+  };
+}
+
+// Custom plugin to ensure entry file is correctly resolved
+function ensureEntryFile(entryFile) {
+  const normalizedEntryFile = path.resolve(entryFile);
+  
+  return {
+    name: 'ensure-entry-file',
+    buildStart(options) {
+      // Verify the entry file exists and is correct
+      if (!fs.existsSync(entryFile)) {
+        throw new Error(`Entry file does not exist: ${entryFile}`);
+      }
+    },
+    resolveId(id, importer) {
+      // Handle entry file resolution with highest priority
+      // This runs before other plugins to ensure correct file is used
+      const normalizedId = path.resolve(id);
+      
+      // If this is the entry file (exact match), return it
+      if (normalizedId === normalizedEntryFile) {
+        return entryFile;
+      }
+      
+      // If id matches entry file without extension, return the actual entry file
+      // This prevents rollup from trying .ts when we want .tsx
+      const idWithoutExt = normalizedId.replace(/\.(tsx?|jsx?)$/, '');
+      const entryWithoutExt = normalizedEntryFile.replace(/\.(tsx?|jsx?)$/, '');
+      if (idWithoutExt === entryWithoutExt && idWithoutExt !== normalizedId) {
+        // Only return entry file if id doesn't have extension but entry does
+        return entryFile;
+      }
+      
+      return null;
+    },
+  };
+}
+
+module.exports = async function (filePath) {
+  // Ensure the file exists
+  if (!fs.existsSync(filePath)) {
+    console.error(`File does not exist: ${filePath}`);
+    process.exit(1);
+  }
+
+  // Get the absolute path of the file
+  const absoluteFilePath = path.resolve(filePath);
+
+  try {
+    // Create a rollup bundle
+    const bundle = await rollup.rollup({
+      input: absoluteFilePath,
+      plugins: [
+        // Custom plugin to intercept and fix entry file resolution
+        {
+          name: 'fix-entry-file',
+          resolveId(id) {
+            // If this is the entry file, ensure it's returned as-is
+            const normalizedId = path.resolve(id);
+            const normalizedEntry = path.resolve(absoluteFilePath);
+            
+            // Exact match
+            if (normalizedId === normalizedEntry) {
+              return absoluteFilePath;
+            }
+            
+            // Match without extension (rollup might try this)
+            const idWithoutExt = normalizedId.replace(/\.(tsx?|jsx?)$/, '');
+            const entryWithoutExt = normalizedEntry.replace(/\.(tsx?|jsx?)$/, '');
+            if (idWithoutExt === entryWithoutExt && idWithoutExt !== normalizedEntry) {
+              // If rollup is trying to resolve without extension, return the actual entry file
+              return absoluteFilePath;
+            }
+            
+            return null;
+          },
+        },
+        // Ensure entry file is resolved correctly before TypeScript plugin
+        ensureEntryFile(absoluteFilePath),
+        // TypeScript plugin must come before nodeResolve to handle TS/TSX files
+        typescript({
+          tsconfig: false,
+          compilerOptions: {
+            target: 'es2015',
+            module: 'esnext',
+            moduleResolution: 'node',
+            strict: true,
+            esModuleInterop: true,
+            skipLibCheck: true,
+            allowSyntheticDefaultImports: true,
+            jsx: 'react',
+            lib: ['ESNext', 'DOM'],
+            resolveJsonModule: true,
+          },
+          include: [absoluteFilePath, '**/*.ts', '**/*.tsx'],
+          // Explicitly exclude files that might be incorrectly resolved
+          exclude: [],
+        }),
+        resolveTsFiles(),
+        nodeResolve({
+          preferBuiltins: false,
+          extensions: ['.tsx', '.ts', '.jsx', '.js', '.json'],
+        }),
+        commonjs(),
+      ],
+      external: ['react', 'react-dom'],
+    });
+
+    // Generate the output
+    const { output } = await bundle.generate({
+      format: 'cjs',
+      exports: 'auto',
+    });
+
+    // Get the compiled code
+    const code = output[0].code;
+    
+    // Close the bundle
+    await bundle.close();
+    
+    return code;
+  } catch (error) {
+    logErr('Build failed:');
+    console.error(error);
+    throw error;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dctc",
-  "version": "1.0.5",
+  "version": "1.1.1",
   "description": "Dynamically compile TSX/TS files and execute them.",
   "main": "./lib/index.js",
   "bin": {
@@ -14,7 +14,7 @@
     "LICENSE"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "node bin/index.js test/test.ts"
   },
   "repository": {
     "type": "git",
@@ -41,11 +41,17 @@
   },
   "homepage": "https://github.com/SteamedBread2333/dynamic-compile-tsx-commond#readme",
   "dependencies": {
+    "@rollup/plugin-commonjs": "^28.0.1",
+    "@rollup/plugin-node-resolve": "^15.3.0",
+    "@rollup/plugin-typescript": "^12.1.0",
     "chalk": "^4.1.2",
     "commander": "^13.1.0",
     "esbuild": "^0.24.2",
     "react": "^18.0.0",
     "react-dom": "^18.0.0",
+    "rolldown": "^0.12.0",
+    "rollup": "^4.21.0",
+    "tslib": "^2.8.1",
     "typescript": "^5.7.3"
   }
 }

package/lib/complie_vite.js

@@ -1,66 +0,0 @@
-/**
- * Compile a given file to CommonJS format using Vite.
- * This function takes a file path, compiles it to CommonJS format,
- * and runs the compiled code in the current Node.js context.
- * @param {string} filePath - The path to the file to be compiled.
- * @returns {string} code - The compiled code.
- * @author pipi
- */
-const { build } = require('vite'); // Import the build function from Vite
-const fs = require('fs'); // Import the file system module
-const path = require('path'); // Import the path module
-const chalk = require("chalk");
-const logErr = content => console.log(chalk.red(content));
-
-const { defineConfig } = require('vite');
-
-module.exports = async function (filePath) {
-  // Ensure the file exists
-  if (!fs.existsSync(filePath)) {
-    console.error(`File does not exist: ${filePath}`);
-    process.exit(1);
-  }
-
-  // Get the absolute path of the file
-  const absoluteFilePath = path.resolve(filePath);
-
-  // Configure Vite build options
-  const viteConfig = defineConfig({
-    overrides: {
-      fs: 'browserify-fs', // Use browserify-fs for file system access
-      path: 'path-browserify', // Use path-browserify for path manipulation
-      // Add other overrides as needed
-    },
-    build: {
-      target: 'node18',
-      format: 'cjs',
-      lib: {
-        entry: absoluteFilePath, // Specify the entry file
-        formats: ['cjs'], // Specify the output format
-      },
-      outDir: 'dist-dctc',
-      rollupOptions: {
-        output: {
-          entryFileNames: 'bundle.js',
-        },
-      },
-    },
-  });
-
-  try {
-    // Use Vite to build the file
-    const bundle = await build(viteConfig);
-
-    // Get the compiled file content
-    const output = bundle[0].output[0];
-    if (!output) {
-      logErr('No output file generated');
-      process.exit(1);
-    }
-
-    return output.code;
-  } catch (error) {
-    logErr('Compilation failed:', error);
-    process.exit(1);
-  }
-}