@omnia/tooling-vue 8.0.322-dev → 8.0.323-dev

package/internal-do-not-import-from-here/config/wctypings.d.ts

@@ -215,7 +215,7 @@ import wc1f31fc580b854d19895c1879120a9891 from '../../../../client/fx/ux/docs/ch
 import wc710dc11b823c4a80b2a031395c206325 from '../../../../client/fx/ux/editorchrome/chrome/EditorChrome';
 import wc72a828731c4e4f1e9753a6a6bfb31e67 from '../../../../client/fx/ux/enterpriseglossary/componentbase/EnterpriseGlossaryTermComponentBase';
 import wcb94ea0908c7f461085de9d21a61e0826 from '../../../../client/fx/ux/enterpriseproperties/picker/EnterprisePropertyPicker';
-import wc80899927961f45298421948c395d7f39 from '../../../../client/fx/ux/enterpriseproperties/renderers/EnterprisePropertyValue';
+import wc80899927961f45298421948c395d7f39 from '../../../../client/fx/ux/enterpriseproperties/renderers/EnterprisePropertyRenderer';
 import wc22666b255eb64f378edf70d5e9859216 from '../../../../client/fx/ux/enterpriseproperties/renderers/EnterprisePropertyConfiguration';
 import wc0619d10d541645aaabbdc17d5b867501 from '../../../../client/fx/ux/enterprisepropertysets/picker/EnterprisePropertySetPicker';
 import wcfaee0b6397494a9abca9c480856e2498 from '../../../../client/fx/ux/flow/editor/FlowEditor';

package/internal-do-not-import-from-here/rspack/bundle.js

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const core_1 = require("@rsbuild/core");
 const core_2 = require("@rspack/core");
 const tooling_1 = require("@omnia/tooling");
+const path_1 = tslib_1.__importDefault(require("path"));
+const shared_1 = require("../shared");
+const fx_models_1 = require("@omnia/fx-models");
+const composers = tslib_1.__importStar(require("@omnia/tooling-composers"));
+const $ = tslib_1.__importStar(require("../variables"));
+const _registeredReferenceManifests = [];
+const vendorProdId = "aaf89b2d-5ea8-4b79-946a-8c1e89f713a3";
 const useRspack = process.argv.find(argv => argv === "--rspack") !== undefined;
+const rootPath = tooling_1.utils.root("");
+const outDirManifestMetadata = shared_1.isExtensionEnv ? "node_modules/@omnia/tooling-vue/internal-do-not-import-from-here/output_manifests" : "client/tooling/vue/output_manifests";
 if (useRspack) {
     tooling_1.core.registerBuildTask({
         stage: tooling_1.core.TaskStage.BeforeBundleManifest,
@@ -52,32 +62,50 @@ async function beforeBundleManifest(entries) {
     return new Promise(async function (resolve, reject) {
         const startTime = new Date().getTime();
         tooling_1.utils.log('Build manifests metadata running...', tooling_1.utils.LogTypes.HeadLine);
-        const rsbuild = await (0, core_1.createRsbuild)({
-            rsbuildConfig: {
-                source: {},
-                plugins: []
-            },
-        });
-        rsbuild.build({
-            watch: false,
-            // compiler: {
-            //     compilers: []
-            // }
-        });
+        const serviceId = getServiceId();
+        // const rsbuild = await createRsbuild({
+        //     rsbuildConfig: {
+        //         source: {
+        //         },
+        //         plugins: [
+        //         ]
+        //     },
+        // });
+        // rsbuild.build({
+        //     watch: false,
+        //     // compiler: {
+        //     //     compilers: []
+        //     // }
+        // })
         const compilers = [];
         Object.keys(entries).forEach((id) => {
             const entry = {};
             entry[id] = entries[id];
-            const config = createConfig(entry);
+            const config = createConfig(entry, entries);
             compilers.push((0, core_1.rspack)(config));
         });
         const multiCompiler = new core_2.MultiCompiler(compilers, {
-            parallelism: 1, // the maximum number of parallel compilers
+        // parallelism: 8, // the maximum number of parallel compilers
         });
         multiCompiler.run((err, stats) => {
-            if (stats.hasErrors) {
+            if (err) {
                 tooling_1.utils.log('Bundle manifest error : \r\n', tooling_1.utils.LogTypes.Error);
-                tooling_1.utils.log(err.stack || err, tooling_1.utils.LogTypes.Error);
+                tooling_1.utils.log(err?.stack || err, tooling_1.utils.LogTypes.Error);
+                reject();
+                return;
+            }
+            if (stats.hasErrors()) {
+                tooling_1.utils.logTime(`Build manifests metadata have an exception`, startTime);
+                tooling_1.utils.log(stats.toString({
+                    assets: false,
+                    hash: true
+                }), tooling_1.utils.LogTypes.Error);
+                for (let stateError of stats.toJson({
+                    assets: false,
+                    hash: true
+                }).errors) {
+                    tooling_1.utils.log(stateError.stack || stateError.message, tooling_1.utils.LogTypes.Error);
+                }
                 reject();
                 return;
             }
@@ -102,11 +130,12 @@ function bundleManifest(entries) {
         }
     });
 }
-function createConfig(entry) {
+function createConfig(entry, entries) {
     return {
+        watch: false,
         mode: "production",
         devtool: false,
-        context: tooling_1.utils.root(""),
+        context: rootPath,
         entry: entry,
         target: ["web", "es2022"],
         optimization: {
@@ -115,7 +144,212 @@ function createConfig(entry) {
             providedExports: true,
             removeAvailableModules: false,
             mangleExports: false,
-            concatenateModules: true
-        }
+            concatenateModules: true,
+            removeEmptyChunks: false,
+            splitChunks: false,
+        },
+        resolve: {
+            modules: tooling_1.core.getWebpackResolveModules(),
+            extensions: ['.ts', '.tsx', '.mjs', '.js', '.jsx', '.html', '.vue', '.less', '.styl'],
+            symlinks: false,
+            descriptionFiles: ['package.json'],
+            alias: Object.assign({}, $.tooling.core.getWebpackResolveAlias(), (getBuildOption()?.moduleOptions?.alias || {}), {
+                'axios$': 'axios/dist/axios.js',
+                'typestyle$': 'typestyle/lib.es2015/index.js',
+                'vue$': 'vue/dist/vue.runtime.esm-bundler.js',
+                '@microsoft/signalr$': '@microsoft/signalr/dist/webworker/signalr.js',
+                "@stylexjs/stylex$": $.tooling.utils.root("node_modules/@stylexjs/stylex/lib/es/stylex.mjs")
+            }),
+        },
+        output: {
+            pathinfo: false,
+            path: tooling_1.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath),
+            filename: '[name].js',
+            chunkLoadingGlobal: "omniaWebpackJsonp['" + getServiceId() + "']['__register_module__']",
+        },
+        externals: [
+            function ({ context, request }, callback) {
+                if (request.indexOf("node_modules") > -1 || (/\.(sass|scss|styl|less|css)$/i).test(request)) {
+                    return callback(null, 'commonjs ' + request);
+                }
+                callback();
+            }
+        ],
+        module: {
+            noParse: /wwwroot(.*)/,
+            rules: [
+                {
+                    test: /\.m?js/,
+                    resolve: {
+                        fullySpecified: false
+                    }
+                },
+                {
+                    test: /\.ts$/,
+                    use: {
+                        loader: 'builtin:swc-loader',
+                        options: {
+                            sourceMaps: false,
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    decorators: true
+                                },
+                                target: "es2022",
+                                transform: {
+                                    useDefineForClassFields: false,
+                                    legacyDecorator: true,
+                                    decoratorMetadata: true,
+                                },
+                            }
+                        },
+                    },
+                },
+                {
+                    test: /\.tsx$/,
+                    exclude: /(node_modules|bower_components)/,
+                    use: [
+                        {
+                            loader: 'babel-loader',
+                            options: {
+                                plugins: ['@vue/babel-plugin-jsx'],
+                            },
+                        },
+                        {
+                            loader: 'builtin:swc-loader',
+                            options: {
+                                sourceMaps: false,
+                                jsc: {
+                                    parser: {
+                                        syntax: 'typescript',
+                                        tsx: true,
+                                        decorators: true
+                                    },
+                                    target: "es2022",
+                                    transform: {
+                                        useDefineForClassFields: false,
+                                        legacyDecorator: true,
+                                        decoratorMetadata: true,
+                                        // react: {
+                                        //     pragma: 'React.createElement',
+                                        //     pragmaFrag: 'React.Fragment',
+                                        //     throwIfNamespace: true,
+                                        //     development: false,
+                                        //     useBuiltins: false,
+                                        // },
+                                    },
+                                }
+                            },
+                        },
+                    ],
+                },
+                {
+                    test: /\.css$/i,
+                    use: [core_2.CssExtractRspackPlugin.loader, 'css-loader'],
+                    type: 'javascript/auto',
+                },
+            ],
+        },
+        plugins: [
+        //...buildReferenceManifest(entry, entries)
+        ].concat([
+            new core_2.DllPlugin({
+                path: path_1.default.join(rootPath, outDirManifestMetadata, '[name].manifest.json'),
+                name: `omniaWebpackJsonp['${getServiceId()}']['${tooling_1.utils.getguid(Object.keys(entry)[0])}']`
+            }),
+            new core_2.CssExtractRspackPlugin({})
+            // pluginVueJsx()
+        ])
     };
 }
+function getServiceId() {
+    const serviceInfo = composers.ServiceManifestRegistry.getServiceInfo();
+    let result;
+    if (serviceInfo === null) {
+        throw new Error("A service has not been registered, please use Composer.registerManifest(serviceId,serviceName).asWorker or .asWebApp)");
+    }
+    else {
+        result = (0, fx_models_1.maybeGuid)(serviceInfo.id.toLowerCase());
+    }
+    return result;
+}
+function buildReferenceManifest(currentEntry, entries) {
+    var manifests = [];
+    var dynamicReferenceManifests = [];
+    let buildOptions = getBuildOption();
+    var currentEntryName = Object.keys(currentEntry)[0];
+    if (buildOptions && buildOptions.bundleOptions && buildOptions.bundleOptions.commonsChunk)
+        return dynamicReferenceManifests.concat(buildReferenceManifestFromConfig(currentEntryName));
+    // exclude pre-built webpack manifest
+    if ($.isExtensionEnv
+        || (currentEntryName.indexOf(o$.enums.omniaResourceManifests.Vendor.toString()) === -1
+            && currentEntryName.indexOf(vendorProdId) === -1
+        // && currentEntryName.indexOf(o$.enums.omniaResourceManifests.FxCore.toString()) === -1
+        // && currentEntryName.indexOf(o$.enums.omniaResourceManifests.Fx.toString()) === -1
+        // && currentEntryName.indexOf(o$.enums.omniaResourceManifests.FxUx.toString()) === -1
+        )) {
+        Object.keys(entries).forEach((entryName) => {
+            if (entryName !== currentEntryName) {
+                if ($.fs.existsSync($.tooling.utils.root(outDirManifestMetadata + "/" + entryName + ".manifest.json"))) {
+                    manifests.push(new core_2.DllReferencePlugin({
+                        context: $.tooling.utils.root(""),
+                        manifest: $.tooling.utils.root(outDirManifestMetadata + "/" + entryName + ".manifest.json"),
+                        //name: `md${++trackingModuleRefId}` //utils.getguid(entryName)
+                        //manifest: require($.tooling.utils.root(outDirManifestMetadata + "/" + entryName + ".manifest.json"))
+                    }));
+                }
+            }
+        });
+    }
+    manifests = buildReferenceManifestFromConfig(currentEntryName).concat(dynamicReferenceManifests).concat(manifests);
+    return manifests;
+}
+function getBuildOption() {
+    return $.composers.BuildConfigurationRegistry.getBuildOptions();
+}
+function buildReferenceManifestFromConfig(entryName) {
+    var manifests = [];
+    let buildOptions = getBuildOption();
+    if (buildOptions.reference) {
+        for (let manifestPath of buildOptions.reference) {
+            manifests.push(new core_2.DllReferencePlugin({
+                context: $.tooling.utils.root(""),
+                manifest: $.tooling.utils.root(manifestPath),
+                // name: `md${++trackingModuleRefId}` //require('md5')(manifestPath)
+            }));
+        }
+    }
+    if (!isBuildWebpackManifestOnly() && buildOptions.webpackManifests) {
+        for (let manifestPath of buildOptions.webpackManifests) {
+            if (manifestPath.indexOf(entryName) === -1) {
+                manifests.push(new core_2.DllReferencePlugin({
+                    context: $.tooling.utils.root(""),
+                    manifest: $.tooling.utils.root(manifestPath),
+                    // name: `md${++trackingModuleRefId}` //require('md5')(manifestPath)
+                }));
+            }
+        }
+    }
+    if ($.isExtensionEnv) {
+        _registeredReferenceManifests.forEach(manifest => {
+            manifests.push(new core_2.DllReferencePlugin({
+                context: $.tooling.utils.root(""),
+                manifest: $.tooling.utils.root(manifest.path),
+                //name: `md${++trackingModuleRefId}` //require('md5')(manifest.path)
+            }));
+        });
+    }
+    return manifests;
+}
+function isBuildWebpackManifestOnly() {
+    return process.argv?.find(argv => argv === "--webpackManifest") !== undefined;
+}
+function registerManifestsReference(manifests) {
+    manifests.forEach(manifest => {
+        if (_registeredReferenceManifests.find(m => m.path === manifest.path) === undefined)
+            _registeredReferenceManifests.push(manifest);
+    });
+}
+function getRegisteredReferenceManifests() {
+    return _registeredReferenceManifests;
+}

package/internal-do-not-import-from-here/rspack/plugins/TsxPlugin.d.ts

@@ -2,7 +2,15 @@ declare const _default: {
     module: {
         rules: {
             test: RegExp;
-            use: {
+            exclude: RegExp;
+            use: ({
+                loader: string;
+                options: {
+                    plugins: string[];
+                    sourceMaps?: undefined;
+                    jsc?: undefined;
+                };
+            } | {
                 loader: string;
                 options: {
                     sourceMaps: false;
@@ -19,8 +27,9 @@ declare const _default: {
                             decoratorMetadata: true;
                         };
                     };
+                    plugins?: undefined;
                 };
-            };
+            })[];
         }[];
     };
 };

package/internal-do-not-import-from-here/rspack/plugins/TsxPlugin.js

@@ -5,32 +5,41 @@ exports.default = {
         rules: [
             {
                 test: /\.tsx$/,
-                use: {
-                    loader: 'builtin:swc-loader',
-                    options: {
-                        sourceMaps: false,
-                        jsc: {
-                            parser: {
-                                syntax: 'typescript',
-                                tsx: true,
-                                decorators: true
-                            },
-                            target: "es2022",
-                            transform: {
-                                useDefineForClassFields: false,
-                                legacyDecorator: true,
-                                decoratorMetadata: true,
-                                // react: {
-                                //     pragma: 'React.createElement',
-                                //     pragmaFrag: 'React.Fragment',
-                                //     throwIfNamespace: true,
-                                //     development: false,
-                                //     useBuiltins: false,
-                                // },
-                            },
-                        }
+                exclude: /(node_modules|bower_components)/,
+                use: [
+                    {
+                        loader: 'babel-loader',
+                        options: {
+                            plugins: ['@vue/babel-plugin-jsx'],
+                        },
                     },
-                },
+                    {
+                        loader: 'builtin:swc-loader',
+                        options: {
+                            sourceMaps: false,
+                            jsc: {
+                                parser: {
+                                    syntax: 'typescript',
+                                    tsx: true,
+                                    decorators: true
+                                },
+                                target: "es2022",
+                                transform: {
+                                    useDefineForClassFields: false,
+                                    legacyDecorator: true,
+                                    decoratorMetadata: true,
+                                    // react: {
+                                    //     pragma: 'React.createElement',
+                                    //     pragmaFrag: 'React.Fragment',
+                                    //     throwIfNamespace: true,
+                                    //     development: false,
+                                    //     useBuiltins: false,
+                                    // },
+                                },
+                            }
+                        },
+                    },
+                ],
             },
         ],
     },

package/internal-do-not-import-from-here/tasks/bundle.js

@@ -53,8 +53,8 @@ $.tooling.core.registerBuildTask({
         return new Promise(function (resolve, reject) {
             buildEntries()
                 .then((result) => {
-                if (process.argv.length > 0 &&
-                    (process.argv.find(argv => argv === "--package") !== undefined || process.argv.find(argv => argv === "--skipTypeCheck"))) {
+                if (!useWebpack || (process.argv.length > 0 &&
+                    (process.argv.find(argv => argv === "--package") !== undefined || process.argv.find(argv => argv === "--skipTypeCheck")))) {
                     tooling_1.utils.log("Skip Typescript check types.");
                     resolve(result);
                 }

package/internal-do-not-import-from-here/vite/hmr/vueJsx.d.ts

@@ -1,12 +1,4 @@
 export declare function transformVueJsx(code: string, id: string): {
-    code: string;
-    map: {
-        version: number;
-        sources: string[];
-        names: string[];
-        sourceRoot?: string | undefined;
-        sourcesContent?: string[] | undefined;
-        mappings: string;
-        file: string;
-    };
+    code: any;
+    map: any;
 };

package/internal-do-not-import-from-here/webpack-plugins/stylexjs/index.d.ts

@@ -43,16 +43,8 @@ export declare class StylexPlugin {
     constructor(options?: PluginOptions);
     apply(compiler: any): void;
     transformCode(inputCode: string, filename: any, logger: any): Promise<{
-        code: string;
-        map: {
-            version: number;
-            sources: string[];
-            names: string[];
-            sourceRoot?: string | undefined;
-            sourcesContent?: string[] | undefined;
-            mappings: string;
-            file: string;
-        };
+        code: any;
+        map: any;
     } | {
         code: string;
         map?: undefined;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/tooling-vue",
   "license": "MIT",
-  "version": "8.0.322-dev",
+  "version": "8.0.323-dev",
   "description": "Used to bundle and serve manifests web component that build on Vue framework.",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -19,8 +19,8 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx-models": "8.0.322-dev",
-    "@omnia/tooling-composers": "8.0.322-dev",
+    "@omnia/fx-models": "8.0.323-dev",
+    "@omnia/tooling-composers": "8.0.323-dev",
     "@types/mousetrap": "1.5.34",
     "@types/quill": "1.3.6",
     "@types/zepto": "1.0.29",