qcobjects-cli 2.5.143-beta → 2.5.144-beta

package/build-esbuild-esm.js

@@ -0,0 +1,180 @@
+const esbuild = require("esbuild");
+const alias = require("esbuild-plugin-alias");
+const path = require("node:path");
+const { readFileSync, writeFileSync } = require("node:fs");
+const fs = require("node:fs/promises");
+const glob = require("glob");
+
+// Organized external packages into categories
+const externalPackages = {
+  node: [
+    "fs", "path", "os", "util", "events", "stream", "http", "https",
+    "crypto", "zlib", "buffer", "url", "querystring", "child_process",
+    "cluster", "dgram", "dns", "net", "readline", "repl", "tls", "tty",
+    "vm", "worker_threads"
+  ],
+  qcobjects: ["qcobjects", "qcobjects-sdk"]
+};
+
+// Flatten external packages for quick lookup
+const allExternalPackages = [
+  ...externalPackages.node.map(pkg => `node:${pkg}`),
+  ...externalPackages.qcobjects
+];
+
+// Function to detect and add the extension
+const nameToExtension = (name, ext, settings) => {
+  const isPackage = name => !name.startsWith(".") && !name.startsWith("/") && !name.includes("/");
+  const hasExtension = /\.[^/\\]+$/.test(name);
+  const isExternalPackage = allExternalPackages.includes(name);
+
+  if (!hasExtension && !isPackage(name) && !isExternalPackage) {
+    name += ext;
+  }
+
+  return name;
+};
+
+// Function to add extensions to import/export/require statements
+const addExtensions = (filePath, toExt, settings) => {
+  const content = readFileSync(filePath, 'utf8');
+  const patterns = [
+    [/(from\s+['"])(.*?)(['"])/g, '$1$2$3'],
+    [/(import\s+['"])(.*?)(['"])/g, '$1$2$3'],
+    [/(export\s+['"])(.*?)(['"])/g, '$1$2$3'],
+    [/(require\s*\(\s*['"])(.*?)(['"]\s*\))/g, '$1$2$3']
+  ];
+
+  const updatedContent = patterns.reduce((content, [pattern, replacement]) => {
+    return content.replace(pattern, (match, p1, p2, p3) => {
+      return `${p1}${nameToExtension(p2, toExt, settings)}${p3}`;
+    });
+  }, content);
+
+  writeFileSync(filePath, updatedContent, 'utf8');
+};
+
+// Common build settings
+const baseSettings = {
+  entryPoints: glob.sync('src/**/*.ts').map(file => path.resolve(file)),
+  bundle: false,
+  target: ["node22"],
+  tsconfig: "tsconfig.json",
+  globalName: "global",
+  minify: false,
+  keepNames: true,
+  sourcemap: true,
+  splitting: false,
+  chunkNames: "chunks/[name]-[hash]",
+  plugins: [
+    {
+      name: 'transform-qcobjects-imports',
+      setup(build) {
+        build.onResolve({ filter: /^(qcobjects|qcobjects-sdk)$/ }, args => ({
+          path: path.resolve(args.path),
+          namespace: args.kind === 'dynamic-import' ? 'qcobjects-transform' : undefined,
+          external: args.kind !== 'dynamic-import'
+        }));
+
+        build.onResolve({ filter: /.*/, namespace: 'file' }, args => ({
+          external: args.kind === 'dynamic-import',
+          path: path.resolve(args.path)
+        }));
+
+        build.onLoad({ filter: /.*/, namespace: 'qcobjects-transform' }, args => ({
+          contents: `module.exports = __toESM(require("${path.resolve(args.path)}"), true);`,
+          loader: 'js'
+        }));
+      }
+    },
+    alias({
+      "types": path.resolve(__dirname, "src/types/global/index.d.ts")
+    })
+  ]
+};
+
+// Build settings for different formats
+const buildConfigs = {
+  esm: {
+    ...baseSettings,
+    outdir: "public/esm",
+    format: "esm",
+    platform: "browser",
+    outExtension: { ".js": ".mjs" },
+    plugins: [
+      ...baseSettings.plugins,
+      {
+        name: 'transform-requires',
+        setup(build) {
+          build.onEnd(() => {
+            glob.sync('public/esm/**/*.mjs').forEach(file => {
+              let content = readFileSync(file, 'utf8');
+              content = content
+                .replace(/const\s+{([^}]+)}\s*=\s*require\(['"]([^'"]+)['"]\)/g, 'import { $1 } from "$2"')
+                .replace(/const\s+([^=]+)\s*=\s*require\(['"]([^'"]+)['"]\)/g, 'import $1 from "$2"');
+              writeFileSync(file, content, 'utf8');
+            });
+          });
+        }
+      }
+    ]
+  }
+};
+
+// Utility functions
+const logError = (e) => { console.error(e); process.exit(1); };
+const logDebug = (e) => { console.debug(e); };
+
+const copyDir = async (source, dest, exclude = []) => {
+  source = path.resolve(source);
+  dest = path.resolve(dest);
+  const dname = path.basename(source);
+  
+  if (exclude.includes(dname)) return;
+
+  try {
+    const stat = await fs.stat(source);
+    if (!stat.isDirectory()) return;
+
+    await fs.mkdir(dest, { recursive: true });
+    const paths = await fs.readdir(source, { withFileTypes: true });
+
+    await Promise.all(paths.map(async item => {
+      const sourcePath = path.resolve(source, item.name);
+      const destPath = path.resolve(dest, item.name);
+
+      if (item.isFile() && !exclude.includes(item.name)) {
+        logDebug(`[publish:static] Copying ${sourcePath} to ${destPath}`);
+        await fs.copyFile(sourcePath, destPath);
+      } else if (item.isDirectory()) {
+        await copyDir(sourcePath, destPath, exclude);
+      }
+    }));
+  } catch (error) {
+    logError(error);
+  }
+};
+
+// Main execution
+(async () => {
+  try {
+    // Copy templates
+    const templateDirs = [
+      "./build/templates",
+      "./public/cjs/templates",
+      "./public/esm/templates",
+      "./public/browser/templates"
+    ];
+    
+    await Promise.all(templateDirs.map(dir => 
+      copyDir("./src/templates", dir, [])
+    ));
+
+    // Run builds in parallel
+    await Promise.all([
+      esbuild.build(buildConfigs.esm)
+    ]);
+  } catch (error) {
+    logError(error);
+  }
+})();

package/build-esbuild.js

@@ -2,239 +2,213 @@ const esbuild = require("esbuild");
 const alias = require("esbuild-plugin-alias");
 const path = require("node:path");
 const { readFileSync, writeFileSync } = require("node:fs");
-const fs = require("node:fs").promises;
+const fs = require("node:fs/promises");
 const glob = require("glob");
 
-// Function to detect and add the extension
-const nameToExtension = (name, ext) => {
-    function isPackage(name) {
-      // Simple check to determine if the name is a package
-      // This can be enhanced based on your specific needs
-      return !name.startsWith(".") && !name.startsWith("/") && !name.includes("/");
-    }
-  
-    const hasExtension = /\.[^/\\]+$/.test(name);
-    if (!hasExtension && !isPackage(name)) {
-      name += ext;
-    }
-  
-    return name;
-  };
-  
-  // Function to add .cjs and .mjs extensions to import/export/require statements
-  const addExtensions = (filePath, toExt) => {
-    const content = readFileSync(filePath, 'utf8');
-    const updatedContent = content.replace(/(from\s+['"])(.*?)(['"])/g, (match, p1, p2, p3) => {
-      return `${p1}${nameToExtension(p2, toExt)}${p3}`;
-    }).replace(/(import\s+['"])(.*?)(['"])/g, (match, p1, p2, p3) => {
-      return `${p1}${nameToExtension(p2, toExt)}${p3}`;
-    }).replace(/(export\s+['"])(.*?)(['"])/g, (match, p1, p2, p3) => {
-      return `${p1}${nameToExtension(p2, toExt)}${p3}`;
-    }).replace(/(require\s*\(\s*['"])(.*?)(['"]\s*\))/g, (match, p1, p2, p3) => {
-      return `${p1}${nameToExtension(p2, toExt)}${p3}`;
-    });
-    writeFileSync(filePath, updatedContent, 'utf8');
-  };
+// Organized external packages into categories
+const externalPackages = {
+  node: [
+    "fs", "path", "os", "util", "events", "stream", "http", "https",
+    "crypto", "zlib", "buffer", "url", "querystring", "child_process",
+    "cluster", "dgram", "dns", "net", "readline", "repl", "tls", "tty",
+    "vm", "worker_threads"
+  ],
+  qcobjects: ["qcobjects", "qcobjects-sdk"]
+};
 
-// Get all TypeScript entry points
-const entryPoints = glob.sync('src/**/*.ts');
+// Flatten external packages for quick lookup
+const allExternalPackages = [
+  ...externalPackages.node.map(pkg => `node:${pkg}`),
+  ...externalPackages.qcobjects
+];
 
-const logError = (e) => { console.error(e); process.exit(1); };
-const logDebug = (e) => { console.debug(e); }
-
-const copyDir = async (source, dest, exclude) => {
-    source = path.resolve(source);
-    dest = path.resolve(dest);
-    const dname = path.basename(source);
-    const dirExcluded = exclude.includes(dname);
-
-    const isDir = async (d) => {
-        try {
-            const stat = await fs.stat(d);
-            return stat.isDirectory();
-        } catch {
-            return false;
-        }
-    };
-
-    const isFile = async (d) => {
-        try {
-            const stat = await fs.stat(d);
-            return stat.isFile();
-        } catch {
-            return false;
-        }
-    };
-
-    if (await isDir(source) && !dirExcluded) {
-        await fs.mkdir(dest, { recursive: true });
-        const paths = await fs.readdir(source, { withFileTypes: true });
-        const dirs = paths.filter(d => d.isDirectory());
-        const files = paths.filter(f => f.isFile());
-
-        for (const f of files) {
-            const sourceFile = path.resolve(source, f.name);
-            const destFile = path.resolve(dest, f.name);
-            const fileExcluded = exclude.includes(f.name);
-            if (await isFile(sourceFile) && !fileExcluded) {
-                logDebug(`[publish:static] Copying files from ${sourceFile} to ${destFile} excluding ${exclude}...`);
-                await fs.copyFile(sourceFile, destFile);
-                logDebug(`[publish:static] Copying files from ${sourceFile} to ${destFile} excluding ${exclude}...DONE!`);
-            }
-        }
+// Function to detect and add the extension
+const nameToExtension = (name, ext, settings) => {
+  const isPackage = name => !name.startsWith(".") && !name.startsWith("/") && !name.includes("/");
+  const hasExtension = /\.[^/\\]+$/.test(name);
+  const isExternalPackage = allExternalPackages.includes(name);
 
-        for (const d of dirs) {
-            const sourceDir = path.resolve(source, d.name);
-            const destDir = path.resolve(dest, d.name);
-            await copyDir(sourceDir, destDir, exclude);
-        }
-    }
-};
+  if (!hasExtension && !isPackage(name) && !isExternalPackage) {
+    name += ext;
+  }
 
-(async () => {
-    await copyDir("./src/templates", "./build/templates", []);
-    await copyDir("./src/templates", "./public/cjs/templates", []);
-    await copyDir("./src/templates", "./public/esm/templates", []);
-    await copyDir("./src/templates", "./public/browser/templates", []);
-})();
-
-const ignorePlugin = {
-  name: 'transform-qcobjects-imports',
-  setup(build) {
-    // Handle qcobjects and qcobjects-sdk dynamic imports
-    build.onResolve({ filter: /^(qcobjects|qcobjects-sdk)$/ }, args => {
-      if (args.kind === 'dynamic-import') {
-        return { 
-          path: args.path,
-          namespace: 'qcobjects-transform'
-        }
-      }
-      return {
-        external: true,
-        path: args.path
-      }
-    });
+  return name;
+};
 
-    // Handle all other dynamic imports (handlers, commands, dev commands, libs)
-    build.onResolve({ filter: /.*/, namespace: 'file' }, args => {
-      if (args.kind === 'dynamic-import') {
-        return {
-          external: true,
-          path: args.path
-        }
-      }
-      return null;
+// Function to add extensions to import/export/require statements
+const addExtensions = (filePath, toExt, settings) => {
+  const content = readFileSync(filePath, 'utf8');
+  const patterns = [
+    [/(from\s+['"])(.*?)(['"])/g, '$1$2$3'],
+    [/(import\s+['"])(.*?)(['"])/g, '$1$2$3'],
+    [/(export\s+['"])(.*?)(['"])/g, '$1$2$3'],
+    [/(require\s*\(\s*['"])(.*?)(['"]\s*\))/g, '$1$2$3']
+  ];
+
+  const updatedContent = patterns.reduce((content, [pattern, replacement]) => {
+    return content.replace(pattern, (match, p1, p2, p3) => {
+      return `${p1}${nameToExtension(p2, toExt, settings)}${p3}`;
     });
+  }, content);
 
-    build.onLoad({ filter: /.*/, namespace: 'qcobjects-transform' }, args => {
-      return {
-        contents: `
-          module.exports = __toESM(require("${args.path}"), true);
-        `,
-        loader: 'js'
-      }
-    });
-  }
-}
+  writeFileSync(filePath, updatedContent, 'utf8');
+};
 
+// Common build settings
 const baseSettings = {
-    entryPoints: entryPoints,
-    bundle: false,
-    outdir: "public/cjs",
-    format: "cjs",    
-    target: ["node22"],
-    tsconfig: "tsconfig.json",
-    globalName: "global",
-    minify: false,
-    keepNames: true,
-    sourcemap: true,
-    splitting: false,
-    chunkNames: "chunks/[name]-[hash]",
-    plugins: [
-        ignorePlugin,
-        alias({
-            "types": path.join(__dirname, "src/types/global/index.d.ts")
-        })
-    ]
+  entryPoints: glob.sync('src/**/*.ts').map(file => path.resolve(file)),
+  bundle: false,
+  target: ["node22"],
+  tsconfig: "tsconfig.json",
+  globalName: "global",
+  minify: false,
+  keepNames: true,
+  sourcemap: true,
+  splitting: false,
+  chunkNames: "chunks/[name]-[hash]",
+  plugins: [
+    {
+      name: 'transform-qcobjects-imports',
+      setup(build) {
+        build.onResolve({ filter: /^(qcobjects|qcobjects-sdk)$/ }, args => ({
+          path: path.resolve(args.path),
+          namespace: args.kind === 'dynamic-import' ? 'qcobjects-transform' : undefined,
+          external: args.kind !== 'dynamic-import'
+        }));
+
+        build.onResolve({ filter: /.*/, namespace: 'file' }, args => ({
+          external: args.kind === 'dynamic-import',
+          path: path.resolve(args.path)
+        }));
+
+        build.onLoad({ filter: /.*/, namespace: 'qcobjects-transform' }, args => ({
+          contents: `module.exports = __toESM(require("${path.resolve(args.path)}"), true);`,
+          loader: 'js'
+        }));
+      }
+    },
+    alias({
+      "types": path.resolve(__dirname, "src/types/global/index.d.ts")
+    })
+  ]
 };
 
-const cjsSettings = {
+// Build settings for different formats
+const buildConfigs = {
+  cjs: {
     ...baseSettings,
     outdir: "public/cjs",
     format: "cjs",
     platform: "node",
-    outExtension: {
-        ".js": ".cjs"
-    },
+    outExtension: { ".js": ".cjs", ".ts": ".cjs" },
     plugins: [
-        ignorePlugin,
-        {
-            name: 'transform-dynamic-imports',
-            setup(build) {
-                // Transform dynamic imports in the final output
-                build.onEnd(() => {
-                    const files = glob.sync('public/cjs/**/*.cjs');
-                    for (const file of files) {
-                        let content = readFileSync(file, 'utf8');
-                        
-                        // Transform dynamic imports to requires
-                        content = content.replace(
-                            /await\s+import\(['"]([^'"]+)['"]\)/g,
-                            '__toESM(require("$1"), true)'
-                        );
-                        
-                        writeFileSync(file, content, 'utf8');
-                    }
-                });
-            }
-        },
-        {
-            name: 'add-extensions',
-            setup(build) {
-                build.onEnd(() => {
-                    entryPoints.forEach(entry => {
-                        const outputFilePath = path.join('./public/cjs', entry.replace('src/', '').replace('.ts', '.cjs'));
-                        addExtensions(outputFilePath, '.cjs');
-                    });
-                });
-            }
+      ...baseSettings.plugins,
+      {
+        name: 'transform-dynamic-imports',
+        setup(build) {
+          build.onEnd(() => {
+            glob.sync('public/cjs/**/*.cjs').forEach(file => {
+              let content = readFileSync(file, 'utf8');
+              content = content.replace(
+                /await\s+import\(['"]([^'"]+)['"]\)/g,
+                '__toESM(require("$1"), true)'
+              );
+              writeFileSync(file, content, 'utf8');
+            });
+          });
         }
+      }
     ]
-};
-
-const esmSettings = {
+  },
+  esm: {
     ...baseSettings,
-    outdir: "public/esm", // Output dir
-    format: "esm", // or "esm" depending on your module system    
-    platform: "browser", // or "browser" depending on your target environment
-    outExtension: {
-        ".js": ".mjs"
-    },
+    outdir: "public/esm",
+    format: "esm",
+    platform: "browser",
+    outExtension: { ".js": ".mjs" },
     plugins: [
-        {
-            name: 'add-extensions',
-            setup(build) {
-                build.onEnd(() => {
-                    entryPoints.forEach(entry => {
-                        const outputFilePath = path.join('./public/esm', entry.replace('src/', '').replace('.ts', '.mjs'));
-                        addExtensions(outputFilePath, '.mjs');
-                    });
-                });
-            }
+      ...baseSettings.plugins,
+      {
+        name: 'transform-requires',
+        setup(build) {
+          build.onEnd(() => {
+            glob.sync('public/esm/**/*.mjs').forEach(file => {
+              let content = readFileSync(file, 'utf8');
+              content = content
+                .replace(/const\s+{([^}]+)}\s*=\s*require\(['"]([^'"]+)['"]\)/g, 'import { $1 } from "$2"')
+                .replace(/const\s+([^=]+)\s*=\s*require\(['"]([^'"]+)['"]\)/g, 'import $1 from "$2"');
+              writeFileSync(file, content, 'utf8');
+            });
+          });
         }
+      }
     ]
+  },
+  browser: {
+    ...baseSettings,
+    outdir: "public/browser",
+    format: "iife",
+    platform: "browser",
+    outExtension: { ".js": ".js" }
+  }
 };
 
-const browserSettings = {
-    ...baseSettings,
-    outdir: "public/browser", // Output dir
-    format: "iife", // or "esm" depending on your module system    
-    platform: "browser", // or "browser" depending on your target environment
-    outExtension: {
-        ".js": ".js"
-    }
+// Utility functions
+const logError = (e) => { console.error(e); process.exit(1); };
+const logDebug = (e) => { console.debug(e); };
+
+const copyDir = async (source, dest, exclude = []) => {
+  source = path.resolve(source);
+  dest = path.resolve(dest);
+  const dname = path.basename(source);
+  
+  if (exclude.includes(dname)) return;
+
+  try {
+    const stat = await fs.stat(source);
+    if (!stat.isDirectory()) return;
+
+    await fs.mkdir(dest, { recursive: true });
+    const paths = await fs.readdir(source, { withFileTypes: true });
+
+    await Promise.all(paths.map(async item => {
+      const sourcePath = path.resolve(source, item.name);
+      const destPath = path.resolve(dest, item.name);
+
+      if (item.isFile() && !exclude.includes(item.name)) {
+        logDebug(`[publish:static] Copying ${sourcePath} to ${destPath}`);
+        await fs.copyFile(sourcePath, destPath);
+      } else if (item.isDirectory()) {
+        await copyDir(sourcePath, destPath, exclude);
+      }
+    }));
+  } catch (error) {
+    logError(error);
+  }
 };
 
-esbuild.build(cjsSettings).catch(logError);
-esbuild.build(esmSettings).catch(logError);
-esbuild.build(browserSettings).catch(logError);
+// Main execution
+(async () => {
+  try {
+    // Copy templates
+    const templateDirs = [
+      "./build/templates",
+      "./public/cjs/templates",
+      "./public/esm/templates",
+      "./public/browser/templates"
+    ];
+    
+    await Promise.all(templateDirs.map(dir => 
+      copyDir("./src/templates", dir, [])
+    ));
+
+    // Run builds in parallel
+    await Promise.all([
+//      esbuild.build(buildConfigs.cjs),
+      esbuild.build(buildConfigs.esm),
+      esbuild.build(buildConfigs.browser)
+    ]);
+  } catch (error) {
+    logError(error);
+  }
+})();

package/dev-requirements.txt

@@ -0,0 +1,5 @@
+# Dev tools (not used in production)
+# Add language-specific tools here, e.g.:
+# ruff==0.9.6
+# mypy==1.15.0
+pre-commit==4.1.0