@openremote/util 1.2.0-snapshot.20240512162641

package/cli.js

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+const path = require("path");
+const fs = require("fs");
+const { spawnSync } = require("child_process");
+const { spawn } = require("child_process");
+
+/* THIS IS JUST A WRAPPER THAT LAUNCHES GRADLE TASKS  */
+
+/* Try and get the openremote project dir or custom project dir */
+function getWorkingDirectory() {
+    let dirs = __dirname.split(path.sep);
+    dirs.pop();
+
+    // get CWD as the openremote repo root
+    let cwd = dirs.join(path.sep);
+    cwd = path.join(cwd, "..");
+
+    if (fs.existsSync(path.join(cwd, "..", ".gitmodules"))) {
+        // Assume we're in a custom project
+        cwd = path.join(cwd, "..");
+    }
+
+    return cwd;
+}
+
+if (process.argv.length >= 3 && process.argv[2] =="watch") {
+
+    // Do watch
+    let cwd = getWorkingDirectory();
+    console.log("Watching model for changes...");
+    const child = spawn((process.platform === "win32" ? "gradlew" : "./gradlew"), ["-t", "modelWatch"], {
+        cwd: cwd,
+        shell: true
+    });
+    child.stdout.removeAllListeners("data");
+    child.stderr.removeAllListeners("data");
+    child.stdout.pipe(process.stdout);
+    child.stderr.pipe(process.stderr);
+
+    child.on("exit", function() {
+        console.log("gradlew modelWatch finished! Status = " + child.status);
+        process.exit(child.status);
+    });
+} else {
+
+    // Do build
+    let cwd = getWorkingDirectory();
+    console.log("Running gradlew modelBuild task in " + cwd + " ...");
+    const gradleModelWatch = spawnSync((process.platform === "win32" ? "gradlew" : "./gradlew"), ["modelWatch"], {
+        cwd: cwd,
+        shell: true
+    });
+    console.log("gradlew modelWatch finished! Status = " + gradleModelWatch.status);
+    if (gradleModelWatch.stderr) {
+        console.log(gradleModelWatch.stderr.toString());
+    }
+    process.exit(gradleModelWatch.status);
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@openremote/util",
+  "version": "1.2.0-snapshot.20240512162641",
+  "description": "Build Util",
+  "author": "OpenRemote",
+  "main": "webpack.util.js",
+  "bin": {
+    "orutil": "./cli.js"
+  },
+  "license": "AGPL-3.0-or-later",
+  "devDependencies": {
+    "@babel/core": "^7.16.0",
+    "@babel/plugin-syntax-dynamic-import": "^7.8.3",
+    "@babel/plugin-syntax-object-rest-spread": "^7.8.3",
+    "@babel/plugin-transform-regenerator": "^7.16.0",
+    "@babel/plugin-transform-runtime": "^7.16.4",
+    "@babel/preset-env": "^7.16.4",
+    "@babel/runtime": "^7.16.3",
+    "@typescript-eslint/eslint-plugin": "^5.9.0",
+    "@typescript-eslint/parser": "^5.9.0",
+    "babel-loader": "^8.2.3",
+    "copy-webpack-plugin": "^10.0.0",
+    "cross-env": "^7.0.3",
+    "css-loader": "^6.5.1",
+    "eslint": "^8.6.0",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-config-standard": "^16.0.3",
+    "eslint-plugin-import": "^2.25.4",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.0.0",
+    "fast-async": "^6.3.8",
+    "file-loader": "^6.2.0",
+    "fork-ts-checker-notifier-webpack-plugin": "^9.0.0",
+    "fork-ts-checker-webpack-plugin": "^9.0.2",
+    "html-webpack-plugin": "^5.5.0",
+    "prettier": "^2.5.1",
+    "querystring-es3": "^0.2.1",
+    "shx": "^0.3.3",
+    "source-map-loader": "^3.0.0",
+    "style-loader": "^3.3.1",
+    "ts-loader": "^9.2.6",
+    "typescript": "^5.3.3",
+    "webpack": "^5.90.1",
+    "webpack-cli": "^5.1.4",
+    "webpack-dev-server": "^4.15.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/webpack.util.js

@@ -0,0 +1,300 @@
+const fs = require("fs");
+const path = require("path");
+const webpack = require("webpack");
+const CopyWebpackPlugin = require("copy-webpack-plugin");
+const HtmlWebpackPlugin = require("html-webpack-plugin");
+const ForkTsCheckerNotifierWebpackPlugin = require("fork-ts-checker-notifier-webpack-plugin");
+const ForkTsCheckerWebpackPlugin = require("fork-ts-checker-webpack-plugin");
+
+function getStandardModuleRules() {
+    return {
+        rules: [
+            {
+                test: /(maplibre|mapbox|@material|gridstack|@mdi).*\.css$/, //output css as strings
+                type: "asset/source"
+            },
+            {
+                test: /\.css$/, //
+                exclude: /(maplibre|mapbox|@material|gridstack|@mdi).*\.css$/,
+                use: [
+                    { loader: "css-loader" }
+                ]
+            },
+            {
+                test: /\.(png|jpg|ico|gif|svg|eot|ttf|woff|woff2|mp4)$/,
+                type: "asset",
+                generator: {
+                    filename: 'images/[hash][ext][query]'
+                }
+            },
+            {
+                test: /\.tsx?$/,
+                exclude: /node_modules/,
+                use: {
+                    loader: "ts-loader",
+                    options: {
+                        projectReferences: true
+                    }
+                }
+            }
+        ]
+    };
+}
+
+function getAppConfig(mode, isDevServer, dirname, managerUrl, keycloakUrl, port) {
+    const production = mode === "production";
+    port = port || 9000;
+    managerUrl = managerUrl || (production && !isDevServer ? undefined : "http://localhost:8080");
+    const OUTPUT_PATH = isDevServer ? 'src' : 'dist';
+
+    if (isDevServer) {
+        console.log("");
+        console.log("To customise the URL of the manager and/or keycloak use the managerUrl and/or keycloakUrl");
+        console.log(" environment arguments e.g: ");
+        console.log("");
+        console.log("npm run serve -- --env managerUrl=https://localhost");
+        console.log("npm run serve -- --env keycloakUrl=https://localhost/auth");
+        console.log("");
+        console.log("MANAGER URL: " + managerUrl || "");
+        console.log("KEYCLOAK URL: " + keycloakUrl || (managerUrl + "/auth"));
+        console.log("");
+    }
+
+    const config = {
+        entry: {
+            'bundle': './src/index.ts'
+        },
+        output: {
+            path: dirname + "/dist",
+            publicPath: "/" + dirname.split(path.sep).slice(-1)[0] + "/",
+            filename: "[name].[contenthash].js"
+        },
+        module: {...getStandardModuleRules()},
+        // optimization: {
+        //     minimize: true,
+        //     minimizer: [
+        //         // For webpack@5 you can use the `...` syntax to extend existing minimizers (i.e. `terser-webpack-plugin`), uncomment the next line
+        //         // `...`,
+        //         new CssMinimizerPlugin(),
+        //     ],
+        // },
+        resolve: {
+            extensions: [".ts", ".tsx", "..."],
+            fallback: {
+                "vm": false,
+                "querystring": require.resolve("querystring-es3")
+            }
+        }
+    };
+
+    config.plugins = [
+        // Conditional compilation variables
+        new webpack.DefinePlugin({
+            PRODUCTION: JSON.stringify(production),
+            MANAGER_URL: JSON.stringify(managerUrl),
+            KEYCLOAK_URL: JSON.stringify(keycloakUrl),
+            "process.env":   {
+                BABEL_ENV: JSON.stringify(mode)
+            }
+        }),
+        // Generate our index page
+        new HtmlWebpackPlugin({
+            chunksSortMode: 'none',
+            inject: false,
+            template: 'index.html'
+        })
+    ];
+
+    if (production) {
+        config.plugins = [
+            // new ForkTsCheckerWebpackPlugin({
+            //     async: false,
+            //     typescript: {
+            //         memoryLimit: 4096
+            //     }
+            // }),
+            ...config.plugins
+        ];
+
+        // Only use babel for production otherwise source maps don't work
+        config.module.rules.push(
+            {
+                test: /\.js$/,
+                include: function(modulePath) {
+                    return /(@webcomponents[\/|\\]shadycss|lit-css|styled-lit-element|lit-element|lit-html|@polymer|@lit|pwa-helpers)/.test(modulePath) || !/node_modules/.test(modulePath);
+                },
+                use: [
+                    {
+                        loader: 'babel-loader'
+                    }
+                ]
+            },
+        );
+    } else {
+        config.plugins = [
+            // new ForkTsCheckerWebpackPlugin({
+            //     typescript: {
+            //         memoryLimit: 4096
+            //     }
+            // }),
+            // new ForkTsCheckerNotifierWebpackPlugin({ title: 'TypeScript', excludeWarnings: false }),
+            ...config.plugins
+        ];
+    }
+
+    if (isDevServer) {
+        // Load source maps generated by typescript
+        // config.devtool = 'inline-source-map';
+        config.module.rules.push(
+            {
+                test: /\.js$/,
+                use: ["source-map-loader"],
+                enforce: "pre",
+                exclude: [
+                    /node_modules/
+                ]
+            },
+        );
+    }
+
+    // Build list of resources to copy
+    const patterns = [
+        {
+            from: path.dirname(require.resolve("@webcomponents/webcomponentsjs")),
+            to: "modules/@webcomponents/webcomponentsjs",
+            globOptions: {
+                ignore: ["!*.js"]
+            }
+        },
+    ];
+    // Check if images dir exists
+    if (fs.existsSync(path.join(dirname, "images"))) {
+        patterns.push(
+            {
+                from: "./images",
+                    to: "images"
+            }
+        );
+    }
+    // Check if locales dir exists
+    if (fs.existsSync(path.join(dirname, "locales"))) {
+        patterns.push(
+            {
+                from: "./locales",
+                to: "locales"
+            }
+        );
+    }
+    // Check if htaccess file exists
+    if (fs.existsSync(path.join(dirname, ".htaccess"))) {
+        patterns.push(
+            {
+                from: ".htaccess",
+                to: ".htaccess",
+                toType: 'file'
+            }
+        );
+    }
+    //Check if .appignore file exists
+    if (fs.existsSync(path.join(dirname, ".appignore"))) {
+      patterns.push(
+        {
+          from: ".appignore",
+          to: ".appignore",
+          toType: 'file'
+        }
+      );
+    }
+
+    // Copy unprocessed files
+    config.plugins.push(
+        new CopyWebpackPlugin({
+            patterns: patterns
+        })
+    );
+
+    config.devtool = !isDevServer ? false : "inline-source-map";
+    config.devServer = {
+        historyApiFallback: {
+            index: "/" + dirname.split(path.sep).slice(-1)[0] + "/",
+        },
+        port: port,
+        open: false,
+        hot: false, // HMR doesn't work with webcomponents at present
+        liveReload: true,
+        static: OUTPUT_PATH
+    };
+    config.watchOptions = {
+        ignored: ['node_modules']
+    }
+
+    return config;
+}
+
+function getLibName(componentName) {
+    if (componentName.startsWith("or-")) {
+        componentName = componentName.substr(3);
+    }
+    componentName = componentName.replace(/-([a-z])/g, function (g) { return g[1].toUpperCase(); });
+    return "OR" + componentName.charAt(0).toUpperCase() + componentName.substring(1);
+}
+
+function ORExternals(context, request, callback) {
+    const match = request.match(/^@openremote\/([^\/]*)$/);
+    if (match) {
+        let component = getLibName(match[1]);
+        console.log(request + " => " + component);
+        return callback(null, "umd " + component);
+    }
+    callback();
+}
+
+function generateExternals(bundle) {
+    if (!bundle) {
+        return;
+    }
+
+    const externals = [];
+
+    if (bundle.excludeOr) {
+        externals.push(ORExternals);
+    }
+    if (bundle.vendor) {
+        externals.push(bundle.vendor);
+    }
+
+    return externals;
+}
+
+function generateExports(dirname) {
+
+    let libName = getLibName(dirname.split(path.sep).pop());
+
+    return Object.entries(bundles).map(([name, bundle]) => {
+        const entry = {};
+        entry[name] = "./src/index.ts";
+
+        return {
+            entry: entry,
+            mode: "production",
+            output: {
+                filename: "[name].js",
+                path: path.resolve(dirname, "dist/umd"),
+                library: libName,
+                libraryTarget: "umd"
+            },
+            resolve: {
+                extensions: [".ts", ".tsx", "..."],
+                fallback: { "vm": false }
+            },
+            module: {...getStandardModuleRules()},
+            externals: generateExternals(bundle)
+        };
+    });
+}
+
+module.exports = {
+    getLibName: getLibName,
+    generateExports: generateExports,
+    getAppConfig: getAppConfig
+};