@cocreate/webpack 1.4.3 → 1.6.0

package/.github/workflows/automated.yml

@@ -1,8 +1,10 @@
 name: Automated Workflow
+
 on:
   push:
     branches:
       - master
+
 jobs:
   about:
     runs-on: ubuntu-latest
@@ -18,26 +20,37 @@ jobs:
         with:
           direction: overwrite-github
           githubToken: "${{ secrets.GITHUB }}"
+
   release:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+        with:
+          fetch-depth: 0 # Required so semantic-release can trace git tags/history
+
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: 22 # Required for the latest semantic-release plugins
-      - name: Semantic Release
-        uses: cycjimmy/semantic-release-action@v4 # Update to v4 for better Node 20+ support
-        id: semantic
-        with:
-          extra_plugins: |
-            @semantic-release/changelog
+          node-version: 22
+
+      - name: Install Semantic Release & Plugins
+        # Installs semantic-release and its plugins on the runner
+        run: |
+          npm install -g semantic-release \
+            @semantic-release/changelog \
+            @semantic-release/npm \
+            @semantic-release/github \
             @semantic-release/git
-            @semantic-release/github
+
+      - name: Run Semantic Release (Native)
+        id: semantic
+        # This will automatically pick up your export default config file in the repository root
+        run: npx semantic-release
         env:
-          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}" # Use the built-in token if possible
+          GITHUB_TOKEN: "${{ secrets.GITHUB_TOKEN }}"
           NPM_TOKEN: "${{ secrets.NPM_TOKEN }}"
+
     outputs:
       new_release_published: "${{ steps.semantic.outputs.new_release_published }}"
-      new_release_version: "${{ steps.semantic.outputs.new_release_version }}"
+      new_release_version: "${{ steps.semantic.outputs.new_release_version }}"

package/.github/workflows/manual.yml

@@ -14,8 +14,7 @@ jobs:
         env:
             DRY_RUN: ${{ github.event.inputs.dry_run }}
             GITHUB_TOKEN: "${{ secrets.GITHUB }}"
-            NPM_TOKEN: "${{ secrets.NPM_TOKEN }}"
-
+  
         steps:
             - name: Checkout
               uses: actions/checkout@v3

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+# [1.6.0](https://github.com/CoCreate-app/CoCreate-webpack/compare/v1.5.0...v1.6.0) (2026-07-17)
+
+
+### Features
+
+* update automated workflow and release configuration for improved semantic release handling ([3ba7b27](https://github.com/CoCreate-app/CoCreate-webpack/commit/3ba7b274d241ecebd50e96723b685808b3444cbb))
+
+# [1.5.0](https://github.com/CoCreate-app/CoCreate-webpack/compare/v1.4.3...v1.5.0) (2026-07-11)
+
+
+### Bug Fixes
+
+* remove devDependencies ([c430e68](https://github.com/CoCreate-app/CoCreate-webpack/commit/c430e685803c28b386d8b899348b04f8019e795a))
+* remove postinstall script and ensure dependencies are correctly listed in package.json ([f851cd7](https://github.com/CoCreate-app/CoCreate-webpack/commit/f851cd764023e56f33c7bd251ea97f1afd14b295))
+* removed post install and add add packages to apprved list ([601dda4](https://github.com/CoCreate-app/CoCreate-webpack/commit/601dda4b5a7503262fc8ac35bd8fc0645e18486c))
+* semantic version handling ([2e79c82](https://github.com/CoCreate-app/CoCreate-webpack/commit/2e79c82340d6e87d6b6dda20c781cbafd01a14fb))
+
+
+### Features
+
+* update ModuleGenerator to use pluginOptions and improve error handling ([af6db28](https://github.com/CoCreate-app/CoCreate-webpack/commit/af6db28d6f0dde3906b424dea975726ddfcf2101))
+
 ## [1.4.3](https://github.com/CoCreate-app/CoCreate-webpack/compare/v1.4.2...v1.4.3) (2026-02-04)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cocreate/webpack",
-  "version": "1.4.3",
+  "version": "1.6.0",
   "description": "A Webpack integration tool for CoCreate applications, enabling file watching, automated chunking, lazy loading, and file uploading. It leverages CoCreate.config for streamlined project builds and development workflows.",
   "keywords": [
     "webpack",
@@ -23,8 +23,7 @@
   "scripts": {
     "start": "npx webpack --config webpack.config.js",
     "build": "npx webpack --mode=production --config webpack.config.js",
-    "dev": "npx webpack --config webpack.config.js --watch",
-    "postinstall": "node -e \"const { execSync } = require('child_process'); try { execSync('coc --version', { stdio: 'ignore' }); } catch (error) { try { execSync('npm install -g @cocreate/cli', { stdio: 'inherit' }); console.log('Installed \"@cocreate/cli\" globally.'); } catch (error) { console.error('Failed to install \"@cocreate/cli\" globally:', error); } }\""
+    "dev": "npx webpack --config webpack.config.js --watch"
   },
   "repository": {
     "type": "git",
@@ -40,5 +39,42 @@
     "type": "GitHub Sponsors ❤",
     "url": "https://github.com/sponsors/CoCreate-app"
   },
-  "main": "./src/index.js"
+  "main": "./src/index.js",
+  "dependencies": {
+    "@cocreate/cli": "^1.54.2",
+    "css-loader": "^7.1.3",
+    "esbuild": "^0.25.2",
+    "esbuild-loader": "^4.3.0",
+    "mini-css-extract-plugin": "^1.4.0",
+    "sass": "^1.97.3",
+    "sass-loader": "^16.0.7",
+    "webpack": "^5.39.1",
+    "webpack-bundle-analyzer": "^4.4.0",
+    "webpack-cli": "^4.7.2",
+    "webpack-log": "^3.0.1",
+    "webpack-node-externals": "^3.0.0"
+  },
+  "allowScripts": {
+    "@cocreate/acme@1.3.2": true,
+    "@cocreate/actions@1.21.4": true,
+    "@cocreate/api@1.22.5": true,
+    "@cocreate/config@1.13.4": true,
+    "@cocreate/crud-client@1.34.6": true,
+    "@cocreate/element-prototype@1.31.4": true,
+    "@cocreate/elements@1.42.9": true,
+    "@cocreate/filter@1.33.6": true,
+    "@cocreate/indexeddb@1.23.4": true,
+    "@cocreate/local-storage@1.16.5": true,
+    "@cocreate/nginx@1.4.4": true,
+    "@cocreate/observer@1.19.0": true,
+    "@cocreate/organizations@1.30.1": true,
+    "@cocreate/render@1.46.1": true,
+    "@cocreate/socket-client@1.40.5": true,
+    "@cocreate/utils@1.42.2": true,
+    "@cocreate/uuid@1.12.4": true,
+    "@cocreate/webpack@1.4.3": true,
+    "@parcel/watcher@2.5.6": true,
+    "esbuild@0.25.12": true,
+    "esbuild@0.28.1": true
+  }
 }

package/release.config.js

@@ -10,12 +10,20 @@ module.exports = {
         changelogFile: "CHANGELOG.md",
       },
     ],
-    "@semantic-release/npm",
-    "@semantic-release/github",
+    "@semantic-release/npm", 
     [
-      "@semantic-release/git",
+      "@semantic-release/github", 
       {
+        successComment: false,
+        failTitle: false,
+      },
+    ],
+    [
+      "@semantic-release/git", 
+      {
+        // Only stage and commit the changelog and package.json
         assets: ["CHANGELOG.md", "package.json"],
+        message: "chore(release): ${nextRelease.version} [skip ci]",
       },
     ],
   ],

package/src/index.js

@@ -1,194 +1,224 @@
-// Import 'fs' for file system operations and 'path' for path operations
+/**
+ * @fileoverview Webpack plugins and loaders for the CoCreate ecosystem.
+ * Includes module generation, automated file uploading, and symlink management.
+ */
+
 const fs = require("fs");
 const path = require("path");
 
-// Import 'upload' function from CoCreate CLI to handle uploads
+/**
+ * Import the upload function from CoCreate CLI to handle automated file uploads.
+ * This function synchronizes local changes with the CoCreate cloud environment.
+ */
 const upload = require("@cocreate/cli/src/commands/upload.js");
 
 /**
- * Class representing a Module Generator.
- * Generates module files based on a configuration and applies them to the Webpack compiler.
+ * @class ModuleGenerator
+ * @description A Webpack plugin that dynamically generates a module entry file 
+ * (typically `CoCreate.modules.js`) based on a configuration object. It leverages 
+ * `@cocreate/lazy-loader` for efficient code splitting and dependency management.
  */
 class ModuleGenerator {
-	/**
-	 * Creates an instance of ModuleGenerator.
-	 * @param {Object} modulesConfig - The configuration for the modules.
-	 */
-	constructor(modulesConfig) {
-		this.modulesConfig = modulesConfig;
-	}
-
-	/**
-	 * Apply the module generation process to the Webpack compiler.
-	 * @param {Object} compiler - The Webpack compiler instance.
-	 */
-	apply(compiler) {
-		let CoCreateConfig;
-
-		if (typeof this.modulesConfig === "object") {
-			CoCreateConfig = this.modulesConfig.config;
-		} else {
-			try {
-				CoCreateConfig = require(this.modulesConfig.configPath);
-			} catch (error) {
-				console.error("Error loading CoCreate.config.js:", error);
-				throw error; // Stop the compilation process if configuration is critical
-			}
-		}
-
-		let modulesGenerated = false;
-
-		compiler.hooks.beforeCompile.tapAsync(
-			"CoCreateLazyloader",
-			(params, callback) => {
-				if (modulesGenerated) callback();
-				else {
-					let outputPath =
-						this.modulesConfig.outputPath || "./modules.js"; // Default path for generated module.js
-
-					// Generate module content based on CoCreateConfig
-					let moduleContent = `import { dependency, lazyLoad } from '@cocreate/lazy-loader';\n\n`;
-					Object.entries(this.modulesConfig).forEach(
-						([moduleName, moduleInfo]) => {
-							if (
-								moduleName === "outputPath" ||
-								typeof moduleInfo !== "object"
-							)
-								return;
-
-							if (moduleInfo.selector) {
-								// Generate lazyLoad statements for modules with selectors
-								moduleInfo.selector =
-									moduleInfo.selector.replaceAll("'", '"');
-								moduleContent += `lazyLoad('${moduleName}', '${moduleInfo.selector}', () => import(/*webpackChunkName: "${moduleName}-chunk"*/ '${moduleInfo.import}'));\n`;
-							} else {
-								// Generate dependency statements for other modules
-								moduleContent += `dependency('${moduleName}', import(/*webpackChunkName: "${moduleName}-chunk"*/ '${moduleInfo.import}'));\n`;
-							}
-						}
-					);
-
-					// Write the module content to the specified outputPath
-					fs.writeFile(outputPath, moduleContent, (err) => {
-						if (err) {
-							console.error(`Error writing ${outputPath}:`, err);
-							callback(err); // Handle errors in async hook
-						} else {
-							modulesGenerated = true;
-							console.log(
-								`${outputPath} generated successfully.`
-							);
-							callback(); // Proceed with compilation
-						}
-					});
-				}
-			}
-		);
-	}
+    /**
+     * @constructor
+     * @param {Object} pluginOptions - The configuration for the plugin.
+     * @param {Object} [pluginOptions.config] - Direct CoCreate configuration object.
+     * @param {string} [pluginOptions.configPath] - Path to a CoCreate config file.
+     */
+    constructor(pluginOptions) {
+        /** @type {Object} */
+        this.pluginOptions = pluginOptions;
+    }
+
+    /**
+     * @method apply
+     * @description Entry point for the Webpack plugin. Taps into the `beforeCompile` hook.
+     * @param {import('webpack').Compiler} compiler - The Webpack compiler instance.
+     */
+    apply(compiler) {
+        let CoCreateConfig;
+
+        // Resolve configuration source
+        if (typeof this.pluginOptions === "object") {
+            CoCreateConfig = this.pluginOptions;
+        } else if (this.pluginOptions && this.pluginOptions.configPath) {
+            try {
+                CoCreateConfig = require(this.pluginOptions.configPath);
+            } catch (error) {
+                console.error("Error loading CoCreate config file:", error);
+                throw error;
+            }
+        } else {
+            console.error("ModuleGenerator requires either a 'config' object or 'configPath' string.");
+            return;
+        }
+
+        /** @type {boolean} Track if modules have already been generated to avoid redundant writes. */
+        let modulesGenerated = false;
+
+        compiler.hooks.beforeCompile.tapAsync(
+            "CoCreateLazyloader",
+            (params, callback) => {
+                if (modulesGenerated) {
+                    callback();
+                } else {
+                    // Fetch the output path from the root of the config, with a fallback
+                    const outputPath = this.pluginOptions.moduleOutputPath || "./CoCreate.modules.js";
+                    let moduleContent = `import { dependency, lazyLoad } from '@cocreate/lazy-loader';\n\n`;
+
+                    // Ensure we are explicitly targeting the 'modules' namespace
+                    const modulesObj = CoCreateConfig.modules || {};
+
+                    // Generate import statements based on module metadata
+                    Object.entries(modulesObj).forEach(
+                        ([moduleName, moduleInfo]) => {
+                            // Skip non-objects
+                            if (typeof moduleInfo !== "object" || moduleInfo === null) return;
+                            
+                            // Skip items that do not have an import defined (acts as 'continue' in forEach)
+                            if (!moduleInfo.import) return;
+
+                            if (moduleInfo.selector) {
+                                // Logic for lazy-loading based on DOM selectors
+                                const sanitizedSelector = moduleInfo.selector.replaceAll("'", '"');
+                                moduleContent += `lazyLoad('${moduleName}', '${sanitizedSelector}', () => import(/*webpackChunkName: "${moduleName}-chunk"*/ '${moduleInfo.import}'));\n`;
+                            } else {
+                                // Logic for standard dependencies
+                                moduleContent += `dependency('${moduleName}', import(/*webpackChunkName: "${moduleName}-chunk"*/ '${moduleInfo.import}'));\n`;
+                            }
+                        }
+                    );
+
+                    // Persist the generated module file to disk
+                    fs.writeFile(outputPath, moduleContent, (err) => {
+                        if (err) {
+                            console.error(`Error writing ${outputPath}:`, err);
+                            callback(err);
+                        } else {
+                            modulesGenerated = true;
+                            console.log(`${outputPath} generated successfully.`);
+                            callback();
+                        }
+                    });
+                }
+            }
+        );
+    }
 }
 
 /**
- * Class to handle file uploads, particularly useful during watch mode.
+ * @class FileUploader
+ * @description Handles automated file uploads to the CoCreate platform, 
+ * primarily intended for use during Webpack's 'watch' mode to sync local changes.
  */
 class FileUploader {
-	/**
-	 * Creates an instance of FileUploader.
-	 * @param {Object} env - The environment variables.
-	 * @param {Object} argv - The arguments provided.
-	 */
-	constructor(env, argv) {
-		this.env = env;
-		this.isWatching = false;
-		this.isWatch = argv.watch === true;
-	}
-
-	/**
-	 * Apply the file uploader process to the Webpack compiler.
-	 * @param {Object} compiler - The Webpack compiler instance.
-	 */
-	apply(compiler) {
-		if (this.isWatch) {
-			if (this.env.beforeCompilation) {
-				// Directly perform upload here
-				upload(process.cwd(), ["../", "-w"]);
-			}
-
-			if (this.env.afterCompilation) {
-				compiler.hooks.emit.tapAsync(
-					"watchFiles",
-					(compilation, callback) => {
-						if (!this.isWatching) {
-							this.isWatching = true;
-							upload(process.cwd(), ["../", "-w"]);
-						}
-						callback();
-					}
-				);
-			}
-		}
-	}
+    /**
+     * @constructor
+     * @param {Object} env - Environment variables passed from the Webpack CLI.
+     * @param {Object} argv - Command line arguments (used to detect --watch).
+     */
+    constructor(env, argv) {
+        /** @type {Object} */
+        this.env = env;
+        /** @type {boolean} Internal state to prevent multiple upload triggers. */
+        this.isWatching = false;
+        /** @type {boolean} Flag indicating if Webpack is in watch mode. */
+        this.isWatch = argv.watch === true;
+    }
+
+    /**
+     * @method apply
+     * @description Hooks into the compilation process to trigger uploads.
+     * @param {import('webpack').Compiler} compiler - The Webpack compiler instance.
+     */
+    apply(compiler) {
+        if (this.isWatch) {
+            // Optional: Upload files before the first compilation starts
+            if (this.env.beforeCompilation) {
+                upload(process.cwd(), ["../", "-w"]);
+            }
+
+            // Upload files after assets are emitted to the output directory
+            if (this.env.afterCompilation) {
+                compiler.hooks.emit.tapAsync(
+                    "watchFiles",
+                    (compilation, callback) => {
+                        if (!this.isWatching) {
+                            this.isWatching = true;
+                            upload(process.cwd(), ["../", "-w"]);
+                        }
+                        callback();
+                    }
+                );
+            }
+        }
+    }
 }
 
 /**
- * Class responsible for creating symbolic links after the build process.
+ * @class SymlinkCreator
+ * @description A utility plugin that creates symbolic links after the build process.
+ * This is used to map PWA assets and distribution folders to the project root.
  */
 class SymlinkCreator {
-	/**
-	 * Creates an instance of SymlinkCreator.
-	 * @param {Object} [options] - Optional configurations for symlink creation.
-	 */
-	constructor(options) {
-		// Store options if necessary, or just hard-code paths
-	}
-
-	/**
-	 * Apply the symlink creation process to the Webpack compiler.
-	 * @param {Object} compiler - The Webpack compiler instance.
-	 */
-	apply(compiler) {
-		// Use compiler.hooks to tap into the Webpack build process
-		compiler.hooks.afterEmit.tap("SymlinkPlugin", (compilation) => {
-			// Perform symlink operations here
-			symlink("./dist", "../dist", "dir");
-			symlink(
-				"./node_modules/@cocreate/pwa/src/service-worker.js",
-				"../service-worker.js",
-				"file"
-			);
-			symlink(
-				"./node_modules/@cocreate/pwa/src/manifest.webmanifest",
-				"../manifest.webmanifest",
-				"file"
-			);
-			symlink(
-				"./node_modules/@cocreate/pwa/src/offline.html",
-				"../offline.html",
-				"file"
-			);
-		});
-
-		/**
-		 * Function to create a symlink if the target exists and the destination does not.
-		 * @param {string} target - Path to the target.
-		 * @param {string} destination - Path to the destination.
-		 * @param {string} option - Type of symlink ('file' or 'dir').
-		 */
-		function symlink(target, destination, option) {
-			if (fs.existsSync(target)) {
-				target = path.resolve(target);
-
-				if (!fs.existsSync(destination)) {
-					destination = path.resolve(destination);
-
-					fs.symlink(target, destination, option, (err) => {
-						if (err) console.log(err);
-						else console.log("symlink added: ", target);
-					});
-				}
-			}
-		}
-	}
+    /**
+     * @constructor
+     * @param {Object} [options] - Configuration options for symlink behavior.
+     */
+    constructor(options) {
+        /** @type {Object|undefined} */
+        this.options = options;
+    }
+
+    /**
+     * @method apply
+     * @description Taps into the `afterEmit` hook to create symlinks once files are generated.
+     * @param {import('webpack').Compiler} compiler - The Webpack compiler instance.
+     */
+    apply(compiler) {
+        compiler.hooks.afterEmit.tap("SymlinkPlugin", (compilation) => {
+            // Standard symlink mappings for CoCreate PWA structure
+            // this.createSymlink("./dist", "../dist", "dir");
+            // this.createSymlink("./node_modules/@cocreate/pwa/src/service-worker.js", "../service-worker.js", "file");
+            // this.createSymlink("./node_modules/@cocreate/pwa/src/manifest.webmanifest", "../manifest.webmanifest", "file");
+            // this.createSymlink("./node_modules/@cocreate/pwa/src/offline.html", "../offline.html", "file");
+        });
+    }
+
+    /**
+     * @method createSymlink
+     * @description Helper method to safely create a symlink if the target exists and the destination is free.
+     * @param {string} target - The source path (relative or absolute).
+     * @param {string} destination - The target link path (relative or absolute).
+     * @param {string} type - The type of symlink ('file', 'dir', or 'junction').
+     */
+    createSymlink(target, destination, type) {
+        if (fs.existsSync(target)) {
+            const absoluteTarget = path.resolve(target);
+            if (!fs.existsSync(destination)) {
+                const absoluteDestination = path.resolve(destination);
+                fs.symlink(absoluteTarget, absoluteDestination, type, (err) => {
+                    if (err) {
+                        console.error(`Failed to create symlink at ${destination}:`, err);
+                    } else {
+                        console.log(`Symlink created: ${target} -> ${destination}`);
+                    }
+                });
+            }
+        }
+    }
 }
 
-// Export the defined classes so they can be used in other modules or configurations
-module.exports = { ModuleGenerator, FileUploader, SymlinkCreator };
+/**
+ * @exports
+ * @property {ModuleGenerator} ModuleGenerator - Dynamic module builder plugin.
+ * @property {FileUploader} FileUploader - CLI upload integration plugin.
+ * @property {SymlinkCreator} SymlinkCreator - PWA/dist symlink management plugin.
+ * @property {string} UnicodeLoader - Absolute path to the unicode replacement loader.
+ */
+module.exports = { 
+    ModuleGenerator, 
+    FileUploader, 
+    SymlinkCreator, 
+    UnicodeLoader: path.resolve(__dirname, 'replace-unicode.js') 
+};

package/src/replace-unicode.js

@@ -1,6 +1,9 @@
 module.exports = function (source) {
-    return source.replace(/\$'/g, '\\u0024\'');
+    let modifiedSource = source.replace(/\$'/g, '\\u0024\'');
+    // console.log("Modified source code:", modifiedSource);
+    return modifiedSource;
 
+    
     // const specialChars = /[\0\x08\x09\x1a\n\r"'\\\%\$]/g; // Add or remove characters based on your needs
     // const replacements = {
     //     // "\0": "\\0",