@cocreate/cli 1.49.0 → 1.51.0

package/src/commands/fs/webpack.js

@@ -1,191 +1,185 @@
-let cdnUrl = "https://server.cocreate.app/";
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
 
+module.exports = async function generateWebpackConfigs(repos, args) {
+  console.log("Generating webpack configs for specified repositories...");
 
+  if (!Array.isArray(repos) || repos.length === 0) {
+    console.warn("No repositories specified.");
+    return [];
+  }
 
-let glob = require("glob");
-let fs = require('fs');
-const prettier = require("prettier");
-const path = require("path")
-
-function globUpdater(er, files) {
-  if (er)
-    console.log(files, 'glob resolving issue')
-  else
-    files.forEach(filename => update(filename))
-}
-
-
-
-
-function update(webpackPath) {
-
+  const failed = [];
 
+  for (const repo of repos) {
+    if (!repo || typeof repo.path !== "string") {
+      repo.error = "Invalid repository data provided";
+      failed.push(repo);
+      continue;
+    }
 
-  let dir = path.dirname(webpackPath);
+    const result = updateWebpackConfigForModule(repo);
+    if (!result) {
+      repo.error = `${repo.path}/webpack.config.js`;
+      failed.push(repo);
+    } else {
+      console.log(`Generated: ${repo.path}/webpack.config.js`);
+    }
+  }
 
-  // component name
-  let name = path.basename(dir);
-  // component entry
-  
-  
-  let entry;
-  
-  if (fs.existsSync( path.resolve(dir, './src/index.js') ))
-    entry = "./src/index.js";
-  else
-    entry = './src/' + name + '.js';
+  console.log(`\nWebpack config generation process finished.`);
 
-  // get component name in came case "cocreate" less
-  let componentName = toCamelCase(name);
-  if (componentName.startsWith('CoCreate'))
-    componentName = componentName.substring(8);
+  return failed;
+};
 
-  if (componentName === componentName.toUpperCase())
-    componentName = componentName.toLowerCase();
-  else
-    componentName = lowerCaseFirstChar(componentName)
+function updateWebpackConfigForModule(repo) {
+  try {
+    repo.path = path.resolve(process.cwd(), repo.path);
 
+    if (!fs.existsSync(repo.path) || !fs.lstatSync(repo.path).isDirectory()) {
+      repo.error = `The path "${repo.path}" does not exist or is not a directory.`;
+      return false;
+    }
 
-  // has template to inject script and styles on dev compile
-  let hasTemplate = false;
-  if (fs.existsSync(path.resolve(dir, './src/index.html')))
-    hasTemplate = true;
-  let fileContent = `const path = require("path");
-const TerserPlugin = require("terser-webpack-plugin");
-const MiniCssExtractPlugin = require('mini-css-extract-plugin');
-let isProduction = process.env.NODE_ENV === "production";
-const { CleanWebpackPlugin } = require("clean-webpack-plugin");
-${ hasTemplate ? "const HtmlWebpackPlugin = require('html-webpack-plugin');" : ''}
+    const webpackPath = path.resolve(repo.path, "webpack.config.js");
+    let name = path.basename(repo.path);
 
+    if (!fs.existsSync(path.resolve(repo.path, repo.entry))) {
+      repo.error = `Entry file ${repo.entry} does not exist in ${repo.path}`;
+      return false;
+    }
 
+    let componentName = toCamelCase(name);
+    if (componentName === componentName.toUpperCase()) {
+      componentName = componentName.toLowerCase();
+    } else {
+      componentName = lowerCaseFirstChar(componentName);
+    }
 
+    let hasTemplate = false;
+    if (fs.existsSync(path.resolve(repo.path, "./src/index.html"))) {
+      hasTemplate = true;
+    }
+    let fileContent = `
+const path = require("path");
+const MiniCssExtractPlugin = require("mini-css-extract-plugin");
+const { EsbuildPlugin } = require("esbuild-loader");
+const { FileUploader } = require("@cocreate/webpack");
+${
+  hasTemplate ? 'const HtmlWebpackPlugin = require("html-webpack-plugin");' : ""
+}
 
-module.exports = {
-  entry: {
-    '${name}': '${entry}'
-  },
-  output: {
-    path: path.resolve(__dirname, 'dist'),
-    filename: isProduction ? '[name].min.js' : '[name]${hasTemplate ? '[hash]': ''}.js',
-    libraryTarget: 'umd',
-    libraryExport: 'default',
-    library: ${ componentName ? `['CoCreate', '${componentName}']` : 'CoCreate'},
-    globalObject: "this",
-  },
-  
-  
-  plugins: [new CleanWebpackPlugin(),
+module.exports = async (env, argv) => {
+  const isProduction = argv && argv.mode === "production";
+  const config = {
+    entry: {
+      "${name}": "${repo.entry}"
+    },
+    output: {
+      path: path.resolve(__dirname, "dist"),
+      filename: isProduction ? "[name].min.js" : "[name]${
+        hasTemplate ? ".[contenthash]" : ""
+      }.js",
+      libraryExport: "default",
+      library: ["CoCreate", "${componentName}"],
+      clean: true
+    },
+    plugins: [
       new MiniCssExtractPlugin({
-      filename: '[name].css',
-    }),
-    ${ hasTemplate ? `
+        filename: isProduction ? "[name].min.css" : "[name].css",
+      }),
+      new FileUploader(env, argv),
+      ${
+        hasTemplate
+          ? `
       new HtmlWebpackPlugin({
         template: "./src/index.html"
       })
-    ` : ''}
+      `
+          : ""
+      }
     ],
-  // Default mode for Webpack is production.
-  // Depending on mode Webpack will apply different things
-  // on final bundle. For now we don't need production's JavaScript
-  // minifying and other thing so let's set mode to development
-  mode: isProduction ? "production" : "development",
-  module: {
-    rules: [
-      {
-        test: /\.js$/,
-        exclude: /(node_modules)/,
-        use: {
-          loader: "babel-loader",
-          options: {
-            plugins: ["@babel/plugin-transform-modules-commonjs"],
+    mode: isProduction ? "production" : "development",
+    devtool: isProduction ? "source-map" : "eval-source-map",
+    module: {
+      rules: [
+        {
+          test: /\.js$/,
+          exclude: /node_modules/,
+          use: {
+            loader: "esbuild-loader",
+            options: {
+              loader: "js",
+              target: "es2017"
+            }
           },
         },
-      },
-      {
-        test: /\.css$/i,
-        use: [
-          { loader: "style-loader", options: { injectType: "linkTag" } },
-          "file-loader",
-        ],
-      },
-    ],
-  },
-
-
-  // add source map
-  ...(isProduction ? {} : { devtool: 'eval-source-map' }),
-
-optimization: {
-    minimize: true,
-    minimizer: [
-      new TerserPlugin({
-        extractComments: true,
-        // cache: true,
-        parallel: true,
-        // sourceMap: true, // Must be set to true if using source-maps in production
-        terserOptions: {
-          // https://github.com/webpack-contrib/terser-webpack-plugin#terseroptions
-          // extractComments: 'all',
-          compress: {
-            drop_console: true,
-          },
+        {
+          test: /\.css$/i,
+          use: [MiniCssExtractPlugin.loader, "css-loader"]
         },
-      }),
-    ],
+      ],
+    },
+    optimization: {
+      minimize: isProduction,
+      minimizer: [
+        new EsbuildPlugin({
+          target: "es2017",
+          css: true
+        })
+      ],
       splitChunks: {
-        chunks: 'all',
-        minSize: 200,
-        // maxSize: 99999,
-        //minChunks: 1,
-        ${ !hasTemplate ? `    
         cacheGroups: {
           defaultVendors: false
         },
-        ` : ''}
-    
       }
-  },
-}
+    },
+    performance: {
+      hints: isProduction ? "warning" : false
+    }
+  };
+  return config;
+};
 `;
-  let formated = prettier.format(fileContent, { semi: false, parser: "babel" });
-
-  if (fs.existsSync(webpackPath))
-    fs.unlinkSync(webpackPath)
-  fs.writeFileSync(webpackPath, formated)
-  // console.log(fileContent)
-  // process.exit()
-
+    fs.writeFileSync(webpackPath, fileContent);
+    execSync(`npx prettier --write "${webpackPath}"`).toString();
+    return true;
+  } catch (error) {
+    return false;
+  }
 }
 
-
-
-glob("../CoCreate-components/*/webpack.config.js", globUpdater)
-glob("../CoCreate-apps/*/webpack.config.js", globUpdater)
-glob("../CoCreate-plugins/*/webpack.config.js", globUpdater)
-glob("../CoCreateCSS/webpack.config.js", globUpdater)
-
-
-
-
-
 function toCamelCase(str) {
   let index = 0;
+  str = str.replace(/^CoCreate-/, "");
   do {
     index = str.indexOf("-", index);
     if (index !== -1) {
       let t = str.substring(0, index);
-      t += String.fromCharCode(str.charCodeAt(index + 1) - 32);
-      t += str.substring(index + 2);
-      str = t;
-    }
-    else break;
+      if (
+        index + 1 < str.length &&
+        str[index + 1] >= "a" &&
+        str[index + 1] <= "z"
+      ) {
+        t += String.fromCharCode(str.charCodeAt(index + 1) - 32);
+        t += str.substring(index + 2);
+        str = t;
+      } else if (index + 1 < str.length) {
+        t += str.substring(index + 1);
+        str = t;
+      } else {
+        str = t;
+      }
+    } else break;
   } while (true);
   return str;
 }
 
 function lowerCaseFirstChar(str) {
-  return String.fromCharCode(str.charCodeAt(0) + 32) + str.substring(1);
+  if (!str) return str;
+  if (str.charCodeAt(0) >= 65 && str.charCodeAt(0) <= 90) {
+    return String.fromCharCode(str.charCodeAt(0) + 32) + str.substring(1);
+  }
+  return str;
 }
-
-
-//

package/src/commands/install.js

@@ -1,25 +1,21 @@
-const addMeta = require('../addMeta');
+const addMeta = require("../addMeta");
 
-module.exports = async function(repos, args) {
-    let failed = [];
-    try {
-        let cloneFailed = await require('./clone.js')(repos, args)
-        if (cloneFailed)
-            failed.push(cloneFailed)
+module.exports = async function (repos, args) {
+	let failed = [];
+	try {
+		let cloneFailed = await require("./clone.js")(repos, args);
+		if (cloneFailed) failed.push(cloneFailed);
 
-        repos = await addMeta(repos, failed)
+		repos = await addMeta(repos, failed);
 
-        let symlinkFailed = await require('./symlink.js')(repos, args)
-        if (symlinkFailed)
-           failed.push(symlinkFailed)
-        
-        let linkFailed = await require('./link.js')(repos, args)
-        if (linkFailed)
-            failed.push(linkFailed)
-   
-    } catch (err) {
-        console.error(err);
-        failed.push({ name: 'general', des: err.message })
-    }
-    return failed;
-}
+		let symlinkFailed = await require("./symlink.js")(repos, args);
+		if (symlinkFailed) failed.push(symlinkFailed);
+
+		let linkFailed = await require("./link.js")(repos, args);
+		if (linkFailed) failed.push(linkFailed);
+	} catch (err) {
+		console.error(err);
+		failed.push({ name: "general", error: err.message });
+	}
+	return failed;
+};

package/src/commands/link.js

@@ -1,69 +1,82 @@
-const spawn = require('../spawn');
-const path = require("path")
-const fs = require('fs')
-const { color } = require('../fonts');
+const spawn = require("../spawn");
+const path = require("path");
+const fs = require("fs");
+const { color } = require("../fonts");
 
 module.exports = async (repos, args) => {
-    const failed = [], isLinked = {};
+	const failed = [],
+		isLinked = {};
 
-    try {
-        for (let repo of repos) {
-            if (!repo) continue;
-            if (repo.exclude && repo.exclude.includes('link'))
-                continue
+	try {
+		for (let repo of repos) {
+			if (!repo) continue;
+			if (repo.exclude && repo.exclude.includes("link")) continue;
 
-            if (process.cwd() === repo.absolutePath)
-                continue
+			if (process.cwd() === repo.absolutePath) continue;
 
-            if (repo.packageManager === 'npm') {
-                let dir = path.resolve(process.cwd(), 'node_modules');
-                let dest = path.resolve(path.resolve(repo.absolutePath), 'node_modules');
-                if (dir && dest) {
-                    if (fs.existsSync(dest))
-                        await fs.promises.rm(dest, { recursive: true, force: true });
+			if (repo.packageManager === "npm") {
+				let dir = path.resolve(process.cwd(), "node_modules");
+				let dest = path.resolve(
+					path.resolve(repo.absolutePath),
+					"node_modules"
+				);
+				if (dir && dest) {
+					if (fs.existsSync(dest))
+						await fs.promises.rm(dest, {
+							recursive: true,
+							force: true
+						});
 
-                    await fs.promises.symlink(dir, dest, 'dir');
-                    console.log(repo.packageManager, 'link', repo.packageName)
-                }
-            } else {
+					await fs.promises.symlink(dir, dest, "dir");
+					console.log(repo.packageManager, "link", repo.packageName);
+				}
+			} else {
+				let exitCode = await spawn(repo.packageManager, ["link"], {
+					cwd: repo.absolutePath,
+					shell: true,
+					stdio: "inherit"
+				});
 
-                let exitCode = await spawn(repo.packageManager, ['link'], {
-                    cwd: repo.absolutePath,
-                    shell: true,
-                    stdio: 'inherit'
-                });
+				if (exitCode !== 0) {
+					failed.push({
+						name: repo.name,
+						error: `${repo.packageManager} link failed`
+					});
+					console.error(
+						color.red +
+							`${repo.name}: ${repo.packageManager} link failed` +
+							color.reset
+					);
+				} else {
+					console.log(repo.packageManager, "link", repo.packageName);
 
-                if (exitCode !== 0) {
-                    failed.push({
-                        name: repo.name,
-                        des: `${repo.packageManager} link failed`
-                    })
-                    console.error(color.red + `${repo.name}: ${repo.packageManager} link failed` + color.reset)
-                } else {
-                    console.log(repo.packageManager, 'link', repo.packageName)
+					let exitCode = await spawn(
+						repo.packageManager,
+						["link", repo.packageName],
+						{
+							cwd: process.cwd(),
+							shell: true,
+							stdio: "inherit"
+						}
+					);
+					if (exitCode !== 0) {
+						failed.push({
+							name: repo.name,
+							error: `${repo.packageManager} link ${repo.packageName} failed`
+						});
+						console.error(
+							color.red +
+								`${repo.name}: ${repo.packageManager} link ${repo.packageName} failed` +
+								color.reset
+						);
+					}
+				}
+			}
+		}
+	} catch (err) {
+		failed.push({ name: "GENERAL", error: err.message });
+		console.error(color.red + `${err}` + color.reset);
+	}
 
-                    let exitCode = await spawn(repo.packageManager, ['link', repo.packageName], {
-                        cwd: process.cwd(),
-                        shell: true,
-                        stdio: 'inherit'
-                    })
-                    if (exitCode !== 0) {
-                        failed.push({
-                            name: repo.name,
-                            des: `${repo.packageManager} link ${repo.packageName} failed`
-                        });
-                        console.error(color.red + `${repo.name}: ${repo.packageManager} link ${repo.packageName} failed` + color.reset)
-                    }
-                }
-
-            }
-        }
-
-    }
-    catch (err) {
-        failed.push({ name: 'GENERAL', des: err.message })
-        console.error(color.red + `${err}` + color.reset)
-    }
-
-    return failed;
-}
+	return failed;
+};

package/src/commands/nginx.js

@@ -1,25 +1,22 @@
-const { createServer, deleteServer } = require('@cocreate/nginx')
+const { createServer, deleteServer } = require("@cocreate/nginx");
 
 module.exports = async function nginx(repos, args) {
-    let failed = [];
-
-    try {
-        if (args.length) {
-            if (args[0] === 'create') {
-                args.shift()
-                await createServer(args);
-            } else if (args[0] === 'delete') {
-                args.shift()
-                await deleteServer(args);
-            } else
-                await createServer(args);
-        }
-    } catch (err) {
-        failed.push({ name: 'GENERAL', des: err.message });
-        console.error(err.red);
-    } finally {
-        return failed;
-    }
-
-}
+	let failed = [];
 
+	try {
+		if (args.length) {
+			if (args[0] === "create") {
+				args.shift();
+				await createServer(args);
+			} else if (args[0] === "delete") {
+				args.shift();
+				await deleteServer(args);
+			} else await createServer(args);
+		}
+	} catch (err) {
+		failed.push({ name: "GENERAL", error: err.message });
+		console.error(err.red);
+	} finally {
+		return failed;
+	}
+};