@omnia/tooling-vue 8.0.79-vnext → 8.0.80-vnext

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

@@ -1 +1,3 @@
-export { registerManifestsReference, registerWebComponentDefinitions } from "./tasks/bundle";
+export { registerManifestsReference } from "./tasks/bundle";
+export { registerOutputInfo } from "./shared";
+export declare function registerWebComponentDefinitions(): void;

package/internal-do-not-import-from-here/index.js

@@ -1,6 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.registerWebComponentDefinitions = exports.registerManifestsReference = void 0;
+exports.registerWebComponentDefinitions = exports.registerOutputInfo = exports.registerManifestsReference = void 0;
 var bundle_1 = require("./tasks/bundle");
 Object.defineProperty(exports, "registerManifestsReference", { enumerable: true, get: function () { return bundle_1.registerManifestsReference; } });
-Object.defineProperty(exports, "registerWebComponentDefinitions", { enumerable: true, get: function () { return bundle_1.registerWebComponentDefinitions; } });
+var shared_1 = require("./shared");
+Object.defineProperty(exports, "registerOutputInfo", { enumerable: true, get: function () { return shared_1.registerOutputInfo; } });
+// will remove legacy function when update all core extension packages
+function registerWebComponentDefinitions() { }
+exports.registerWebComponentDefinitions = registerWebComponentDefinitions;

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

@@ -1,124 +1,14 @@
-export declare function getBaseWebpackConfigForManifestMetadata(entry: any, bundleOutputDir: any): {
-    devtool: boolean;
-    mode: string;
-    context: any;
-    entry: any;
-    optimization: any;
-    resolve: {
-        modules: string[];
-        extensions: string[];
-        symlinks: boolean;
-        cacheWithContext: boolean;
-        descriptionFiles: string[];
-        alias: Object & {
-            [name: string]: string;
-        } & {
-            axios$: string;
-            typestyle$: string;
-            vue$: string;
-            '@microsoft/signalr': string;
+export type OutputInfo = {
+    wc: {
+        namespace: string;
+        mappings: {
+            [element: string]: string;
         };
     };
-    output: {
-        pathinfo: boolean;
-        path: any;
-        filename: string;
-    };
-    externals: (({ context, request }: {
-        context: any;
-        request: any;
-    }, callback: any) => any)[];
-    module: {
-        noParse: RegExp;
-        rules: ({
-            test: RegExp;
-            use: ({
-                loader: any;
-                options?: undefined;
-            } | {
-                loader: string;
-                options: {
-                    loader: string;
-                    target: string;
-                    tsconfigRaw: {
-                        compilerOptions: {
-                            jsx: string;
-                            target: string;
-                            useDefineForClassFields: boolean;
-                        };
-                    };
-                };
-            })[];
-        } | {
-            test: RegExp;
-            exclude: RegExp;
-            use: ({
-                loader: string;
-                options: {
-                    cacheDirectory: boolean;
-                    plugins: any[];
-                    presets: string[][];
-                };
-            } | {
-                loader: string;
-                options: {
-                    loader: string;
-                    target: string;
-                    jsx: string;
-                    tsconfigRaw: {
-                        compilerOptions: {
-                            jsx: string;
-                            target: string;
-                            useDefineForClassFields: boolean;
-                        };
-                    };
-                };
-            })[];
-        } | {
-            test: RegExp;
-            resolve: {
-                fullySpecified: boolean;
-            };
-            use?: undefined;
-            loader?: undefined;
-        } | {
-            test: RegExp;
-            use: string[];
-            resolve?: undefined;
-            loader?: undefined;
-        } | {
-            test: RegExp;
-            use: {
-                loader: string;
-                options: {
-                    implementation: any;
-                    sassOptions: {
-                        indentedSyntax: boolean;
-                    };
-                };
-            }[];
-            resolve?: undefined;
-            loader?: undefined;
-        } | {
-            test: RegExp;
-            loader: string;
-            resolve?: undefined;
-            use?: undefined;
-        } | {
-            test: RegExp;
-            use: {
-                loader: string;
-                options: {
-                    name: string;
-                    outputPath: string;
-                    publicPath: string;
-                };
-            }[];
-            resolve?: undefined;
-            loader?: undefined;
-        })[];
-    };
 };
+export declare const isExtensionEnv: boolean;
+export declare function registerOutputInfo(info: OutputInfo): void;
+export declare function replaceWebComponentNamespaceMapping(content: string): string;
 export declare function convertManifestPathToEntryPath(pathToManifest: any, pathsInManifest: Array<string>): string[];
 export declare const buildContext: {
     isManifestsChanged: boolean;
@@ -126,3 +16,21 @@ export declare const buildContext: {
 export declare var cacheKeys: {
     bundleManifests: string;
 };
+export declare class ConfigurationManager {
+    private static _webComponentTypings;
+    private static _outputInfoManagaer;
+    static get webComponentTypings(): WebComponentTypingsManagaer;
+    static get outputInfo(): OutputInfoManagaer;
+}
+declare class OutputInfoManagaer {
+    private filePath;
+    private _value;
+    update(value: OutputInfo): void;
+    get(): OutputInfo;
+}
+declare class WebComponentTypingsManagaer {
+    private filePath;
+    update(value: string): void;
+    delete(): void;
+}
+export {};

package/internal-do-not-import-from-here/shared.js

@@ -1,167 +1,41 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cacheKeys = exports.buildContext = exports.convertManifestPathToEntryPath = exports.getBaseWebpackConfigForManifestMetadata = void 0;
+exports.ConfigurationManager = exports.cacheKeys = exports.buildContext = exports.convertManifestPathToEntryPath = exports.replaceWebComponentNamespaceMapping = exports.registerOutputInfo = exports.isExtensionEnv = void 0;
 const tslib_1 = require("tslib");
 const globby_1 = require("globby");
-const $ = tslib_1.__importStar(require("./variables"));
-const ts_loader_1 = tslib_1.__importDefault(require("./webpack-loaders/ts-loader"));
-const tsx_loader_1 = tslib_1.__importDefault(require("./webpack-loaders/tsx-loader"));
-function getBaseWebpackConfigForManifestMetadata(entry, bundleOutputDir) {
-    return {
-        devtool: false,
-        mode: 'development',
-        context: $.tooling.utils.root(""),
-        entry: entry,
-        //cache: {
-        //    type: "filesystem"
-        //},  
-        //performance: {
-        //    hints: 'error',
-        //    maxEntrypointSize: 10000000,
-        //    maxAssetSize: 10000000 // ~ 10Mb
-        //},
-        //stats: 'errors-only',
-        //stats: {
-        //    //all: false,
-        //    ////modules: true,
-        //    //maxModules: 0,
-        //    //errors: true,
-        //    warnings: false,
-        //    //moduleTrace: true,
-        //    //errorDetails: true
-        //},
-        //ignoreWarnings: [
-        //    {
-        //        module: /DEP_WEBPACK_MODULE_ID/ // A RegExp
-        //    },
-        //    {
-        //        module: /[DEP_WEBPACK_COMPILATION_OPTIMIZE_CHUNK_ASSETS]/ // A RegExp
-        //    },
-        //    (warning) => { console.log('marning', warning); return true;}
-        //],
-        optimization: Object.assign({
-            removeAvailableModules: false,
-            removeEmptyChunks: false,
-            splitChunks: false,
-        }),
-        resolve: {
-            modules: $.tooling.core.getWebpackResolveModules(),
-            extensions: ['.ts', '.tsx', '.mjs', '.js', '.jsx'],
-            //extensions: ['.js', '.jsx', '.ts', '.tsx', '.html', '.vue', '.less', '.styl'],
-            symlinks: false,
-            cacheWithContext: true,
-            descriptionFiles: ['package.json'],
-            alias: Object.assign({}, $.tooling.core.getWebpackResolveAlias(), ($.composers.BuildConfigurationRegistry.getBuildOptions()?.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',
-            }),
-            //mainFields: ['main', 'browser', 'module']
-        },
-        output: {
-            pathinfo: false,
-            path: $.tooling.utils.root(bundleOutputDir),
-            filename: '[name].js'
-        },
-        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();
-            }
-        ],
-        //optimization: {
-        //    removeAvailableModules: false,
-        //    removeEmptyChunks: false,
-        //    splitChunks: false,
-        //},
-        module: {
-            noParse: /wwwroot(.*)/,
-            rules: [
-                //{
-                //    parser: {
-                //        amd: false,
-                //        harmony: false
-                //    }
-                //},
-                {
-                    test: /\.m?js$/,
-                    resolve: {
-                        fullySpecified: false, // disable the behaviour
-                    },
-                },
-                ...(0, ts_loader_1.default)(),
-                ...(0, tsx_loader_1.default)(),
-                {
-                    test: /\.styl$/,
-                    use: [
-                        //'style-loader',
-                        //'css-loader',
-                        'stylus-loader'
-                    ]
-                },
-                ...($.isExtensionEnv ? [] : [{
-                        test: /\.s(c|a)ss$/,
-                        use: [
-                            {
-                                loader: 'sass-loader',
-                                options: {
-                                    implementation: require('sass'),
-                                    sassOptions: {
-                                        //fiber: require('fibers'),
-                                        indentedSyntax: true
-                                    }
-                                    //fiber: require('fibers')
-                                }
-                            }
-                        ]
-                    }]),
-                {
-                    test: /\.less$/,
-                    use: [
-                        //'style-loader',
-                        //'css-loader',
-                        'less-loader'
-                    ]
-                },
-                {
-                    test: /\.css$/,
-                    use: [
-                        //'style-loader',
-                        {
-                            loader: 'css-loader'
-                        }
-                    ]
-                },
-                {
-                    test: /\.(woff2?|eot|ttf|otf)(\?.*)?$/,
-                    loader: 'url-loader'
-                },
-                {
-                    test: /\.(ico|gif|png|jpe?g|svg)$/i,
-                    use: [{
-                            loader: 'file-loader',
-                            options: {
-                                name: '[name].[ext]',
-                                outputPath: "../images/",
-                                publicPath: '/omnia/images/'
-                            }
-                        }]
-                    //loader: 'url-loader'
-                }
-            ]
+const path_1 = tslib_1.__importDefault(require("path"));
+const fsExtra = tslib_1.__importStar(require("fs-extra"));
+const del_1 = tslib_1.__importDefault(require("del"));
+const fs_1 = tslib_1.__importDefault(require("fs"));
+const _outputInfos = [];
+const basePathProcess = process.cwd();
+exports.isExtensionEnv = fs_1.default.existsSync(basePathProcess + "/node_modules/@omnia/tooling/package.json");
+function registerOutputInfo(info) {
+    _outputInfos.push(info);
+}
+exports.registerOutputInfo = registerOutputInfo;
+function replaceWebComponentNamespaceMapping(content) {
+    const infos = _outputInfos.concat(ConfigurationManager.outputInfo.get());
+    infos.forEach(info => {
+        if (info.wc?.namespace) {
+            content = content.replace(new RegExp(`(<|<\/|\\s)${info.wc.namespace}\\..*?(>|\\s)`, 'g'), function (match) {
+                return match.replace(new RegExp(`(${info.wc.namespace}.*)(?=(>|\\s))`), function (token) {
+                    return token.replace(/(\S+)/g, function (tag) {
+                        return info.wc.mappings[tag.replace(`${info.wc.namespace}.`, "")] || tag;
+                    });
+                });
+            });
         }
-    };
+    });
+    return content;
 }
-exports.getBaseWebpackConfigForManifestMetadata = getBaseWebpackConfigForManifestMetadata;
+exports.replaceWebComponentNamespaceMapping = replaceWebComponentNamespaceMapping;
 function convertManifestPathToEntryPath(pathToManifest, pathsInManifest) {
     if (!pathsInManifest)
         return [];
     let pathsToSearch = [];
     pathsInManifest.forEach(p => {
-        pathsToSearch.push((p[0] === '!' ? '!./' : './') + (p.indexOf("./") > -1 || p.indexOf(".\\") > -1 ? $.path.join(pathToManifest.substring(0, pathToManifest.lastIndexOf('/')), p.replace(/^!/, '')).replace(/\\/g, "/")
+        pathsToSearch.push((p[0] === '!' ? '!./' : './') + (p.indexOf("./") > -1 || p.indexOf(".\\") > -1 ? path_1.default.join(pathToManifest.substring(0, pathToManifest.lastIndexOf('/')), p.replace(/^!/, '')).replace(/\\/g, "/")
             : p.replace(/^!/, '').replace(/\\/g, "/")));
     });
     let result = (0, globby_1.globbySync)(pathsToSearch.concat(["!./**/*.manifest.+(js|ts)"]));
@@ -178,3 +52,54 @@ exports.cacheKeys = {
     //buildManifestMetadatas: "buildManifestMetadatas",
     bundleManifests: "bundleManifests"
 };
+class ConfigurationManager {
+    static get webComponentTypings() {
+        if (!this._webComponentTypings) {
+            this._webComponentTypings = new WebComponentTypingsManagaer();
+        }
+        return this._webComponentTypings;
+    }
+    static get outputInfo() {
+        if (!this._outputInfoManagaer) {
+            this._outputInfoManagaer = new OutputInfoManagaer();
+        }
+        return this._outputInfoManagaer;
+    }
+}
+ConfigurationManager._webComponentTypings = null;
+ConfigurationManager._outputInfoManagaer = null;
+exports.ConfigurationManager = ConfigurationManager;
+class OutputInfoManagaer {
+    constructor() {
+        this.filePath = exports.isExtensionEnv ? path_1.default.resolve(__dirname, "tooling.output.json") : path_1.default.resolve(__dirname, "config/tooling.output.json");
+        this._value = null;
+    }
+    update(value) {
+        fsExtra.ensureFileSync(this.filePath);
+        fsExtra.writeJsonSync(this.filePath, value);
+    }
+    get() {
+        if (this._value === null) {
+            fsExtra.ensureFileSync(this.filePath);
+            const content = fsExtra.readFileSync(this.filePath).toString();
+            this._value = content ? JSON.parse(content) : {};
+        }
+        return this._value;
+    }
+}
+class WebComponentTypingsManagaer {
+    constructor() {
+        this.filePath = path_1.default.resolve(__dirname, "config/wctypings.ts");
+    }
+    update(value) {
+        fsExtra.outputFileSync(this.filePath, value);
+    }
+    delete() {
+        del_1.default.sync(this.filePath);
+    }
+}
+// initial
+if (exports.isExtensionEnv) {
+    //auto register output info from omnia
+    registerOutputInfo(fsExtra.readJSONSync(path_1.default.resolve(__dirname, "config/tooling.output.json")));
+}

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

@@ -16,5 +16,4 @@ declare function registerManifestsReference(manifests: Array<{
     serviceId?: string;
     resourceId?: string;
 }>): void;
-declare function registerWebComponentDefinitions(definitions: Object): void;
-export { ensureManifestDependencyInRuntime, bundleManifest, getServiceId, getBuildOption, cleanUpComposer, createVueWebpackConfig, createCombinedManfest, registerManifestsReference, registerWebComponentDefinitions, checkDuplicateBundle, processManifestGenerated, addDependency };
+export { ensureManifestDependencyInRuntime, bundleManifest, getServiceId, getBuildOption, cleanUpComposer, createVueWebpackConfig, createCombinedManfest, registerManifestsReference, checkDuplicateBundle, processManifestGenerated, addDependency };