@omnia/tooling-vue 8.0.101-vnext → 8.0.102-dev

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

@@ -14,7 +14,8 @@ const fx_models_1 = require("@omnia/fx-models");
 const $ = tslib_1.__importStar(require("../variables"));
 const shared_1 = require("../shared");
 const tooling_1 = require("@omnia/tooling");
-const core_1 = require("@swc/core");
+const doc_1 = require("./doc");
+const stylexjs_1 = require("../webpack-plugins/stylexjs");
 const MiniCssExtractPlugin = require('mini-css-extract-plugin');
 const ConcatSource = require('webpack-core/lib/ConcatSource');
 const CircularDependencyPlugin = require('circular-dependency-plugin');
@@ -202,11 +203,12 @@ function buildEntries(serve = false) {
             var componentRegistry = $.composers.ComponentRegistry;
             let componentRegistrations = componentRegistry.getRegistrations();
             const serviceInfo = $.composers.ServiceManifestRegistry.getServiceInfo();
-            if (serviceInfo.serviceType === tooling_composers_1.ServiceTypes.WebApp) {
-                await generateComponentTypingsAndDoc(componentRegistrations);
-            }
             startTime = new Date().getTime();
             $.tooling.logTime("Found [" + componentRegistrations.length + "] component registrations", startTime);
+            let componentEntries = createVueEntryFormComponentRegistrations(componentRegistrations);
+            if (serviceInfo.serviceType === tooling_composers_1.ServiceTypes.WebApp) {
+                await (0, doc_1.generateComponentTypingsAndDoc)(componentRegistrations);
+            }
             var resourceRegistry = $.composers.ResourceRegistry;
             let resourceBundlesWithBuildOptions = resourceRegistry.getRegisteredResourceBundles(shared_1.convertManifestPathToEntryPath);
             $.tooling.logTime("Found [" + resourceBundlesWithBuildOptions?.size + "] resource bundles", startTime);
@@ -222,7 +224,6 @@ function buildEntries(serve = false) {
                     console.log("debug " + res[0] + " has build options for paths " + resource.paths + " buildoptions: " + JSON.stringify(resource.buildOptions));
                 }
             }
-            let componentEntries = createVueEntryFormRegistrations(componentRegistrations);
             var entries = $.merge(componentEntries, resourceEntries);
             if (checkDuplicateWebpackEntryPoints(entries)) {
                 $.tooling.log('Build manifests metadata have error that found duplicated resource path', $.tooling.LogTypes.Error);
@@ -257,248 +258,7 @@ function buildEntries(serve = false) {
         }
     });
 }
-async function generateComponentTypingsAndDoc(componentRegistrations) {
-    tooling_1.utils.log("Generate components typings and documentation running...");
-    var startTime = new Date().getTime();
-    let DefineVueType;
-    (function (DefineVueType) {
-        DefineVueType[DefineVueType["Prop"] = 0] = "Prop";
-        DefineVueType[DefineVueType["Model"] = 1] = "Model";
-        DefineVueType[DefineVueType["Slot"] = 2] = "Slot";
-        DefineVueType[DefineVueType["Emit"] = 4] = "Emit";
-    })(DefineVueType || (DefineVueType = {}));
-    const docResult = {};
-    function getPropertyFunctionTypeAsString(type) {
-        let params = "";
-        if (type.params?.length > 0) {
-            type.params.forEach(p => {
-                params += `${p.value}:${getPropertyType(p.typeAnnotation)}, `;
-            });
-            params = params.replace(/,\s*$/, "");
-        }
-        return `(${params}) => ${getPropertyType(type.typeAnnotation)}`;
-    }
-    function getPropertyType(tsType) {
-        let result = "";
-        if (tsType.type === "TsTypeAnnotation") {
-            return getPropertyType(tsType.typeAnnotation);
-        }
-        switch (tsType.type) {
-            case "TsLiteralType":
-                result = tsType.literal.value;
-                break;
-            case "TsKeywordType":
-                result = tsType.kind;
-                break;
-            case "TsTypeReference":
-                result = tsType.typeName.value;
-                break;
-            case "TsFunctionType":
-                result = getPropertyFunctionTypeAsString(tsType);
-                break;
-            default:
-                break;
-        }
-        return result;
-    }
-    function getNameProperty(ce, result) {
-        const identifier = ce.callee?.property?.value;
-        if (identifier) {
-            switch (identifier) {
-                case "name":
-                    result.name = ce.arguments[0].expression.value;
-                    getNameProperty(ce.callee.object, result);
-                    break;
-                case "vModel":
-                    result.type = DefineVueType.Model;
-                    result.propertyTypeAsString = getPropertyType(ce.typeArguments.params[0]);
-                    result.name = result.name ? `v-model:${result.name}` : result.name;
-                    break;
-                case "slots":
-                    result.type = DefineVueType.Slot;
-                    result.propertyTypeAsObject = {};
-                    ce.typeArguments.params[0].members
-                        .forEach(m => {
-                        result.propertyTypeAsObject[m.key.value] = getPropertyType(m.typeAnnotation);
-                    });
-                    break;
-                case "prop":
-                    result.type = DefineVueType.Prop;
-                    result.propertyTypeAsString = getPropertyType(ce.typeArguments.params[0]);
-                    break;
-                case "emit":
-                    result.type = DefineVueType.Emit;
-                    result.propertyTypeAsString = getPropertyType(ce.typeArguments.params[0]);
-                    break;
-                default:
-                    getNameProperty(ce.callee.object, result);
-            }
-        }
-    }
-    async function buildDoc(wc) {
-        try {
-            const wcPath = (0, shared_1.convertManifestPathToEntryPath)(wc.manifestPath, [wc.componentOptions.entryPoint])[0];
-            const wcParseResult = await (0, core_1.parseFile)(wcPath, {
-                syntax: 'typescript',
-                target: 'es2020',
-                tsx: true,
-                decorators: true,
-                dynamicImport: true
-            });
-            wcParseResult.body.forEach(b => {
-                if (b.type === 'ExportDefaultExpression'
-                    && b.expression.callee?.value === "defineVueWebComponent") {
-                    b.expression.arguments[0].expression
-                        .properties?.filter(p => p.key.value === "props"
-                        || p.key.value === "emits")
-                        ?.forEach(propsIdentifier => {
-                        if (propsIdentifier) {
-                            propsIdentifier.value
-                                .properties?.forEach(p => {
-                                const em = p.arguments;
-                                if (em?.callee?.property?.value === "doc$") {
-                                    const PropertyResult = {
-                                        type: null,
-                                        propertyTypeAsString: "",
-                                        name: ""
-                                    };
-                                    getNameProperty(em, PropertyResult);
-                                    if (!docResult[wc.componentOptions.elementName]) {
-                                        docResult[wc.componentOptions.elementName] = {
-                                            emits: {},
-                                            models: {},
-                                            props: {},
-                                            slots: {}
-                                        };
-                                    }
-                                    switch (PropertyResult.type) {
-                                        case DefineVueType.Prop:
-                                            docResult[wc.componentOptions.elementName].props[PropertyResult.name] = {
-                                                type: PropertyResult.propertyTypeAsString,
-                                                description: em.arguments[0].expression.value
-                                            };
-                                            break;
-                                        case DefineVueType.Model:
-                                            docResult[wc.componentOptions.elementName].models[PropertyResult.name] = {
-                                                type: PropertyResult.propertyTypeAsString,
-                                                description: em.arguments[0].expression.value
-                                            };
-                                            break;
-                                        case DefineVueType.Emit:
-                                            docResult[wc.componentOptions.elementName].emits[PropertyResult.name] = {
-                                                type: PropertyResult.propertyTypeAsString,
-                                                description: em.arguments[0].expression.value
-                                            };
-                                            break;
-                                        case DefineVueType.Slot:
-                                            em.arguments[0].expression
-                                                .properties
-                                                .forEach(p => {
-                                                const slotName = p.key.value;
-                                                docResult[wc.componentOptions.elementName].slots[slotName] = {
-                                                    type: PropertyResult.propertyTypeAsObject[slotName],
-                                                    description: p.value.value
-                                                };
-                                            });
-                                            break;
-                                        default:
-                                            break;
-                                    }
-                                }
-                            });
-                        }
-                    });
-                }
-            });
-        }
-        catch (ex) {
-            tooling_1.utils.log(`Have a exception when extract doc$ for web component manifest -> ${wc.manifestPath}`, tooling_1.utils.LogTypes.Error);
-            console.error(ex);
-            throw new Error("Exit, have an exception.");
-        }
-    }
-    let docPath = $.path.resolve(__dirname, "ComponentDocRegistrations.ts");
-    ;
-    const wcNamespace = getBuildOption()?.webComponentNamespace;
-    const info = shared_1.ConfigurationManager.outputInfo.get();
-    info.wc = {
-        namespace: wcNamespace,
-        mappings: {}
-    };
-    let wcTypings = wcNamespace ? `
-//{{importWC}}
-declare global {
-    namespace JSX {
-        interface Element { }
-        interface ElementClass { }
-
-        interface IntrinsicElements {
-            //{{elementName}}
-        }
-    }
-}
-
-declare global {
-    let ${wcNamespace}: {
-        //{{nselementName}}
-    };
-}
-`
-        : `
-//{{importWC}}
-    declare global {
-    namespace JSX {
-        interface Element { }
-        interface ElementClass { }
-
-        interface IntrinsicElements {
-            //{{elementName}}
-        }
-    }
-}`;
-    if ($.isExtensionEnv) {
-        wcTypings = `import { VueComponentBaseProps } from "@omnia/fx/ux";
-        ${wcTypings}`;
-    }
-    else {
-        wcTypings = `import { VueComponentBaseProps } from "../../../../client/fx/ux/index";
-        ${wcTypings}`;
-    }
-    await tooling_1.utils.asyncForEach(componentRegistrations, async (wc) => {
-        wcTypings = generateWebComponentTypings(wc, wcTypings, info);
-        await buildDoc(wc);
-    });
-    if (Object.keys(docResult).length > 0) {
-        fsExtra.outputFileSync(docPath, `
-import { extendApi } from "@omnia/fx";
-import { ComponentDoc } from "@omnia/fx-models";
-
-extendApi(api => api.fx.docs.registrations, api => {
-
-    const registrations: { [elementName: string]: ComponentDoc } = ${JSON.stringify(docResult)}
-
-    Object.keys(registrations).forEach(elementName => {
-        api.register(elementName, registrations[elementName]);
-    });
-});
-    `);
-        // create dynamic doc manifest
-        $.composers.ManifestRegistry.setCurrentManifestPath(`${path_1.default.relative(tooling_1.utils.root(""), path_1.default.resolve(__dirname))}/`);
-        $.composers
-            .Composer
-            .registerManifest(getBuildOption().docResourceManifestId || new fx_models_1.Guid(`${tooling_1.utils.generateGuid()}`), "omnia.fx.docs.components.registraions")
-            .registerResources({
-            resourcePaths: ["./ComponentDocRegistrations.ts"]
-        })
-            .withTarget(fx_models_1.ClientManifestTargetTypes.Docs)
-            .extendApi(api => api.fx.docs.registrations);
-        $.composers.ManifestRegistry.setCurrentManifestPath();
-    }
-    shared_1.ConfigurationManager.webComponentTypings.update(wcTypings);
-    shared_1.ConfigurationManager.outputInfo.update(info);
-    tooling_1.utils.logTime('Done - Generate components typings and documentation', startTime);
-}
-function buildManifestMetadatas(entries) {
+function buildManifestMetadata(entries) {
     return new Promise(function (resolve, reject) {
         try {
             var startTime = new Date().getTime();
@@ -585,7 +345,7 @@ function beforeBundleManifest(entries) {
             //         isRunBuildMetadata = !isEqual(entries, cachedEntries);
             //     }
             // }
-            if ($.fs.existsSync(cachedEntriesPath)) {
+            if (!isBuildWebpackManifestOnly() && $.fs.existsSync(cachedEntriesPath)) {
                 let cachedEntries = require(cachedEntriesPath);
                 isRunBuildMetadata = !isEqual(entries, cachedEntries);
             }
@@ -617,9 +377,15 @@ function beforeBundleManifest(entries) {
                         fsExtra.writeJsonSync(manifestPath, content);
                     }
                 });
-                buildManifestMetadatas(entriesToBuild).then(() => {
+                buildManifestMetadata(entriesToBuild).then(() => {
                     fsExtra.ensureFileSync(cachedEntriesPath);
                     fsExtra.writeJsonSync(cachedEntriesPath, entries);
+                    if (isBuildWebpackManifestOnly()) {
+                        fsExtra.copyFileSync(`${outDirManifestMetadata}/omnia.fx.core_a2892051-fd9f-4056-ae8d-30d16d48417d.manifest.json`, "client/tooling/vue/config/omnia.fx.core_a2892051-fd9f-4056-ae8d-30d16d48417d.manifest.json");
+                        fsExtra.copyFileSync(`${outDirManifestMetadata}/omnia.fx_a5a89056-b5f5-475d-8518-a1f55090379d.manifest.json`, "client/tooling/vue/config/omnia.fx_a5a89056-b5f5-475d-8518-a1f55090379d.manifest.json");
+                        fsExtra.copyFileSync(`${outDirManifestMetadata}/omnia.fx.ux_dee030cc-4ab3-4158-bb06-8049f5c67542.manifest.json`, "client/tooling/vue/config/omnia.fx.ux_dee030cc-4ab3-4158-bb06-8049f5c67542.manifest.json");
+                        fsExtra.copyFileSync(`${outDirManifestMetadata}/omnia.fx.ux.libs_0fe5c5f2-8d89-485b-afd4-36fe3ff5943a.manifest.json`, "client/tooling/vue/config/omnia.fx.ux.libs_0fe5c5f2-8d89-485b-afd4-36fe3ff5943a.manifest.json");
+                    }
                     resolve(entries);
                 });
             }
@@ -759,12 +525,15 @@ function afterGenerateManifestsMetadata() {
             .then(resolve, reject);
     });
 }
+function isBuildWebpackManifestOnly() {
+    return process.argv?.find(argv => argv === "--webpackManifest") !== undefined;
+}
 function minifyBundles() {
     return new Promise(function (resolve, reject) {
         if (process.argv.length > 0 && process.argv.find(argv => argv === "--minify") !== undefined) {
             let startTime = new Date().getTime();
             $.tooling.log('Minify bundles running...');
-            const jsPaths = (0, globby_1.globbySync)([`${$.tooling.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath)}/*.js`]);
+            const jsPaths = (0, globby_1.globbySync)([`${$.tooling.utils.root($.tooling.composer.OmniaOutput.OutputBundlePath).replace(/\\/g, "/")}/*.js`]);
             let promises = [];
             jsPaths.forEach(filePath => {
                 promises.push(new Promise(async (resolve, reject) => {
@@ -821,6 +590,25 @@ function createVueWebpackConfig(currentEntry, entries, bundleOutputDir, viteHmrO
         ...referenceManifests,
         extractCss,
         new $.omniaWebpackPlugins.NamedModulesPlugin(buildModuleName()),
+        new stylexjs_1.StylexPlugin({
+            // filename: 'styles.[contenthash].css',
+            filename: `${Object.keys(entry)[0]}.css`,
+            // get webpack mode and set value for dev
+            dev: false,
+            // Use statically generated CSS files and not runtime injected CSS.
+            // Even in development.
+            runtimeInjection: false,
+            // optional. default: 'x'
+            classNamePrefix: 'o',
+            // Required for CSS variable support
+            unstable_moduleResolution: {
+                // type: 'commonJS' | 'haste'
+                // default: 'commonJS'
+                type: 'commonJS',
+                // The absolute path to the root directory of your project
+                rootDir: __dirname,
+            },
+        }),
     ];
     if (!buildOption.detectCircularDependencyOptions || buildOption.detectCircularDependencyOptions.disable !== true) {
         plugins.unshift(new CircularDependencyPlugin({
@@ -893,10 +681,10 @@ function createVueWebpackConfig(currentEntry, entries, bundleOutputDir, viteHmrO
     plugins.push(new $.omniaWebpackPlugins.ChunkAssets(function (compilation, fileName) {
         chunkAsset(entries, compilation, fileName, viteHmrOption);
     }));
-    let webpackEntries = {};
-    Object.keys(entry).forEach(name => {
-        webpackEntries[name] = { import: entry[name] };
-    });
+    // let webpackEntries = {};
+    // Object.keys(entry).forEach(name => {
+    //     webpackEntries[name] = { import: entry[name] }
+    // })
     return {
         mode: 'production',
         devtool: false,
@@ -924,7 +712,7 @@ function createVueWebpackConfig(currentEntry, entries, bundleOutputDir, viteHmrO
                 '@microsoft/signalr$': '@microsoft/signalr/dist/webworker/signalr.js',
             }),
         },
-        target: ['web', 'es2022'],
+        target: ['web', 'es2022'], // Will change ES6 when stop support IE11
         output: {
             //library: {
             //    type: "umd"
@@ -959,8 +747,8 @@ function createVueWebpackConfig(currentEntry, entries, bundleOutputDir, viteHmrO
                         }
                         return false;
                     },
-                    // use: 'null-loader',
                     use: [
+                        // 'null-loader',
                         {
                             loader: path_1.default.resolve(__dirname, $.isExtensionEnv ? '../webpack-loaders/ingore-vuetify-locale.js' : '../webpack-loaders/ingore-vuetify-locale.ts'),
                         }
@@ -1074,7 +862,7 @@ function createWebpackConfigForManifestMetadata(entry, metadataOutputDir) {
     var entensionId = getServiceId();
     return Object.assign({}, getBaseWebpackConfigForManifestMetadata(entry, metadataOutputDir), {
         plugins: [
-            ...buildReferenceManifestFromConfig(),
+            ...buildReferenceManifestFromConfig(Object.keys(entry)[0]),
             new $.omniaWebpackPlugins.NamedModulesPlugin(buildModuleName()),
             new $.webpack.DllPlugin({
                 entryOnly: false,
@@ -1302,9 +1090,10 @@ function createCombinedManfest(omniaServiceId, manifestIds, targetManifestId, ta
         if (manifestIds &&
             targetManifestId &&
             manifestIds.length > 0) {
-            let manifestIdToFileNameMap = {};
-            let targetFileName = `${targetManifestName ? targetManifestName + "_" : ""}${targetManifestId}.js`;
-            manifestIdToFileNameMap[targetManifestId] = targetFileName;
+            const manifestIdToFileNameMap = {};
+            const targetJsFileName = `${targetManifestName ? targetManifestName + "_" : ""}${targetManifestId}.js`;
+            const targetCssFileName = `${targetManifestName ? targetManifestName + "_" : ""}${targetManifestId}.css`;
+            manifestIdToFileNameMap[targetManifestId] = targetJsFileName;
             $.tooling.log("Creating manifest group bundle [" + targetManifestId + "]", $.tooling.LogTypes.HeadLine);
             let omniaServiceId = getServiceId();
             manifestIds.sort((manifestId1, manifestId2) => {
@@ -1321,18 +1110,32 @@ function createCombinedManfest(omniaServiceId, manifestIds, targetManifestId, ta
                 }
                 return result;
             });
-            let bundleNames = [];
+            const jsBundleNames = [];
+            const cssBundleNames = [];
             for (let i = 0; i < manifestIds.length; i++) {
                 let manifest = $.composers.LoadableManifestRegistry.getRegisteredManifest(manifestIds[i]);
-                bundleNames[i] = outputDir + `/${manifest.resourceName ? manifest.resourceName + "_" : ""}${manifest.resourceId}.js`;
-                if (!$.fs.existsSync(bundleNames[i])) {
-                    throw new Error("Error, can't create combined bundle: " + targetFileName + " can't find bundle to include: " + bundleNames[i]);
+                jsBundleNames[i] = outputDir + `/${manifest.resourceName ? manifest.resourceName + "_" : ""}${manifest.resourceId}.js`;
+                const cssFilePath = outputDir + `/${manifest.resourceName ? manifest.resourceName + "_" : ""}${manifest.resourceId}.css`;
+                if (!fsExtra.existsSync(jsBundleNames[i])) {
+                    throw new Error("Error, can't create combined bundle: " + targetJsFileName + " can't find bundle to include: " + jsBundleNames[i]);
+                }
+                if (fsExtra.existsSync(cssFilePath)) {
+                    cssBundleNames.push(cssFilePath);
                 }
-                manifestIdToFileNameMap[manifestIds[i]] = bundleNames[i];
+                manifestIdToFileNameMap[manifestIds[i]] = jsBundleNames[i];
                 $.tooling.log("Adding manifest bundle [" + manifestIds[i] + "] to group", $.tooling.LogTypes.Info);
             }
-            let mergedContent = "";
-            bundleNames.forEach(filePath => {
+            let mergedCssContent = "";
+            cssBundleNames.forEach(filePath => {
+                mergedCssContent = `${mergedCssContent}
+                ${fsExtra.readFileSync(filePath, 'utf8')}
+                `;
+            });
+            if (mergedCssContent) {
+                fsExtra.writeFileSync(`${outputDir}/${targetCssFileName}`, mergedCssContent);
+            }
+            let mergedJsContent = "";
+            jsBundleNames.forEach(filePath => {
                 let manifestId = "";
                 let currentFilename = $.path.basename(filePath);
                 for (let id in manifestIdToFileNameMap) {
@@ -1345,13 +1148,13 @@ function createCombinedManfest(omniaServiceId, manifestIds, targetManifestId, ta
                     throw Error("Couldn't extract manifest id from filename: " + currentFilename);
                 }
                 let content = fsExtra.readFileSync(filePath, 'utf8');
-                mergedContent = `
-${mergedContent}
+                mergedJsContent = `
+${mergedJsContent}
 /* Start of resource:${manifestId} */omniaWebpackJsonp["bb000000-0000-bbbb-0000-0000000000bb"]["${fx_models_1.OmniaResourceManifests.FxCore.toString()}"]("06e712d2-9897-4891-9353-148547efe61c").ManifestResourceLoader.registerWebComponentFromGroupBundle("${omniaServiceId}", "${manifestId}", "${targetManifestId}", function(){
 ${content}
 })//End of resource:${manifestId} `;
             });
-            fsExtra.writeFileSync(`${outputDir}/${targetFileName}`, `/******/  if (typeof omniaLoader === 'undefined') {
+            fsExtra.writeFileSync(`${outputDir}/${targetJsFileName}`, `/******/  if (typeof omniaLoader === 'undefined') {
 /******/        globalThis['omniaLoader'] = {};
 /******/    }
 /******/    omniaLoader['${omniaServiceId}'] = omniaLoader['${omniaServiceId}'] || {};
@@ -1360,7 +1163,7 @@ ${content}
                 /******/
 }
 /******/    omniaLoader['${omniaServiceId}']['${targetManifestId}'] = function () {
-${mergedContent}
+${mergedJsContent}
 }
 ${$.composers.LoadableManifestRegistry.isDefineWithNoDependency(targetManifestId) ? `omniaLoader['${omniaServiceId}']['${targetManifestId}']()` : ''}`, 'utf8');
             $.tooling.log("Done - Creating manifest group bundle for manifest id: " + targetManifestId, $.tooling.LogTypes.HeadLine);
@@ -1444,12 +1247,17 @@ function buildReferenceManifest(currentEntry, entries) {
     var manifests = [];
     var dynamicReferenceManifests = [];
     let buildOptions = getBuildOption();
-    if (buildOptions && buildOptions.bundleOptions && buildOptions.bundleOptions.commonsChunk)
-        return dynamicReferenceManifests.concat(buildReferenceManifestFromConfig());
     var currentEntryName = Object.keys(currentEntry)[0];
-    // exclude omnia vendor
-    if (currentEntryName.indexOf(fx_models_1.OmniaResourceManifests.Vendor.toString()) === -1
-        && currentEntryName.indexOf(vendorProdId) === -1) {
+    if (buildOptions && buildOptions.bundleOptions && buildOptions.bundleOptions.commonsChunk)
+        return dynamicReferenceManifests.concat(buildReferenceManifestFromConfig(currentEntryName));
+    // exclude pre-built webpack manifest
+    if ($.isExtensionEnv
+        || (currentEntryName.indexOf(fx_models_1.OmniaResourceManifests.Vendor.toString()) === -1
+            && currentEntryName.indexOf(vendorProdId) === -1
+        // && currentEntryName.indexOf(OmniaResourceManifests.FxCore.toString()) === -1
+        // && currentEntryName.indexOf(OmniaResourceManifests.Fx.toString()) === -1
+        // && currentEntryName.indexOf(OmniaResourceManifests.FxUx.toString()) === -1
+        )) {
         Object.keys(entries).forEach((entryName) => {
             if (entryName !== currentEntryName) {
                 if ($.fs.existsSync($.tooling.utils.root(outDirManifestMetadata + "/" + entryName + ".manifest.json"))) {
@@ -1463,14 +1271,14 @@ function buildReferenceManifest(currentEntry, entries) {
             }
         });
     }
-    manifests = buildReferenceManifestFromConfig().concat(dynamicReferenceManifests).concat(manifests);
+    manifests = buildReferenceManifestFromConfig(currentEntryName).concat(dynamicReferenceManifests).concat(manifests);
     return manifests;
 }
 function cleanUpComposer() {
     $.composers.ManifestRegistry.clearState();
 }
 exports.cleanUpComposer = cleanUpComposer;
-function buildReferenceManifestFromConfig() {
+function buildReferenceManifestFromConfig(entryName) {
     var manifests = [];
     let buildOptions = getBuildOption();
     if (buildOptions.reference) {
@@ -1482,6 +1290,17 @@ function buildReferenceManifestFromConfig() {
             }));
         }
     }
+    if (!isBuildWebpackManifestOnly() && buildOptions.webpackManifests) {
+        for (let manifestPath of buildOptions.webpackManifests) {
+            if (manifestPath.indexOf(entryName) === -1) {
+                manifests.push(new $.omniaWebpackPlugins.DllReferencePlugin({
+                    context: $.tooling.utils.root(""),
+                    manifest: $.tooling.utils.root(manifestPath),
+                    // name: `md${++trackingModuleRefId}` //require('md5')(manifestPath)
+                }));
+            }
+        }
+    }
     if ($.isExtensionEnv) {
         _registeredReferenceManifests.forEach(manifest => {
             manifests.push(new $.omniaWebpackPlugins.DllReferencePlugin({
@@ -1561,89 +1380,18 @@ function getServiceId() {
     return serviceId;
 }
 exports.getServiceId = getServiceId;
-function extractTypingsForComponents(componentRegistrations) {
-    let foundTypes = {};
-    componentRegistrations.forEach((comp) => {
-        let defPaths = comp.componentOptions.typings;
-        if (defPaths) {
-            let isChildSpec = false;
-            defPaths.forEach((defPath) => {
-                let entryPointPath = (0, shared_1.convertManifestPathToEntryPath)(comp.manifestPath, [defPath])[0];
-                let contents = $.fs.readFileSync(entryPointPath, 'utf8');
-                let wcEl = getWcElement(contents, isChildSpec);
-                if (wcEl) {
-                    //Now lets find the interface mapped to element
-                    //example /*@WebComponentInterface("omfx-dialog")*/
-                    let interfaceToken = `/*@WebComponentInterface("${wcEl}")*/`;
-                    let interfaceIndex = contents.indexOf(interfaceToken);
-                    if (interfaceIndex > -1) {
-                        let wcProps = [];
-                        let intf = contents.substring(interfaceIndex);
-                        let nextIsDomProp = false;
-                        intf = intf
-                            .substring(intf.indexOf("{") + 1, intf.indexOf("}"))
-                            .replace(/\?/g, '')
-                            .trim()
-                            .split(/\r\n|\r|\n/g).forEach((group) => {
-                            /*@DomProperty*/
-                            let sub = group.trim();
-                            if (sub.indexOf("/*@DomProperty*/") > -1) {
-                                nextIsDomProp = true;
-                                return;
-                            }
-                            if (nextIsDomProp) {
-                                if (sub.indexOf(':')) {
-                                    sub = sub.split(':')[0];
-                                }
-                                if (sub) {
-                                    if (!foundTypes[wcEl]) {
-                                        foundTypes[wcEl] = [];
-                                    }
-                                    foundTypes[wcEl].push(sub);
-                                }
-                                nextIsDomProp = false;
-                            }
-                        });
-                    }
-                }
-                isChildSpec = true;
-            });
-        }
-    });
-    return foundTypes;
-}
-var lastWcElement = "";
-function getWcElement(contents, isChildSpec) {
-    if (isChildSpec) {
-        if (lastWcElement === "") {
-            new Error("Cant find the /*@DomProperty*/ on the parent interface for the WebComponent definition");
-        }
-        return lastWcElement;
-    }
-    else {
-        lastWcElement = "";
-    }
-    let wcElToken = "/*@WebComponent*/";
-    let wcElIndex = contents.indexOf(wcElToken);
-    let wcEl = "";
-    if (wcElIndex > -1) {
-        wcEl = contents.substring(wcElIndex);
-        wcEl = wcEl.substring(wcEl.indexOf('"') + 1);
-        wcEl = wcEl.substring(0, wcEl.indexOf('"'));
-        lastWcElement = wcEl;
-    }
-    return lastWcElement;
-}
-function createVueEntryFormRegistrations(registrations) {
+function createVueEntryFormComponentRegistrations(registrations) {
     let entryPaths = {};
     for (let r of registrations) {
-        if (r.componentOptions.entryPoint.endsWith('.jsx') || r.componentOptions.entryPoint.endsWith('.vue') || r.componentOptions.entryPoint.endsWith('.tsx') || r.componentOptions.entryPoint.endsWith('.ts')) {
+        if (r.componentOptions.entryPoint.endsWith('.tsx')
+            || r.componentOptions.entryPoint.endsWith('.vue')) {
             let entryPointPath = (0, shared_1.convertManifestPathToEntryPath)(r.manifestPath, [r.componentOptions.entryPoint]);
             let entryId = r.manifest.resourceId;
             if (r.manifest.resourceName) {
                 entryId = `${r.manifest.resourceName}_${entryId}`;
             }
-            entryPaths[entryId] = entryPointPath;
+            r.componentOptions.entryPointPath = entryPointPath[0];
+            entryPaths[entryId.toString()] = entryPointPath;
         }
         else {
             $.tooling.log('The OmniaFx build system only supports  .jsx, .vue and .tsx based components at the moment ', $.tooling.LogTypes.Error);
@@ -1963,35 +1711,3 @@ function sortString(a, b) {
     }
     return -1;
 }
-function generateWebComponentTypings(wc, template, info) {
-    // export default defineVueWebComponent
-    let wcPath = (0, shared_1.convertManifestPathToEntryPath)(wc.manifestPath, [wc.componentOptions.entryPoint])[0];
-    let content = fsExtra.readFileSync(wcPath, 'utf8');
-    if (content.indexOf("defineVueWebComponent") > -1) {
-        if (!new RegExp('export\\s+default\\s+').test(content)) {
-            throw new Error(`Missing statement 'export default a vue web component' in ${wcPath}`);
-        }
-        let friendlyManifestId = `wc${wc.manifest.resourceId.toString().replace(/-/g, '').toLowerCase()}`;
-        let importPath = wcPath.substring(0, wcPath.lastIndexOf('.tsx'));
-        if (importPath.indexOf("./") === 0) {
-            importPath = importPath.replace("./", "");
-        }
-        if ($.isExtensionEnv) {
-            importPath = `../../../../${importPath}`;
-        }
-        else {
-            importPath = `../../../../${importPath}`;
-        }
-        let elementNamePascalCase = wc.componentOptions.elementName.replace("omfx-", "").replace(/-([a-z])/g, function (g) { return g[1].toUpperCase(); });
-        elementNamePascalCase = elementNamePascalCase[0].toUpperCase() + elementNamePascalCase.substring(1, elementNamePascalCase.length);
-        info.wc.mappings[elementNamePascalCase] = wc.componentOptions.elementName;
-        return template
-            .replace(/\/\/{{importWC}}/, `import ${friendlyManifestId} from '${importPath}';
-//{{importWC}}`)
-            .replace(/\/\/{{elementName}}/, `"${wc.componentOptions.elementName}": typeof ${friendlyManifestId}.propsDefinition & Omit<VueComponentBaseProps, keyof typeof ${friendlyManifestId}.propsDefinition>
-//{{elementName}}`)
-            .replace(/\/\/{{nselementName}}/, `"${elementNamePascalCase}": { new(...args: any[]): { $props: typeof ${friendlyManifestId}.propsDefinition & Omit<VueComponentBaseProps, keyof typeof ${friendlyManifestId}.propsDefinition> } }
-            //{{nselementName}}`);
-    }
-    return template;
-}

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

@@ -1 +1,3 @@
-export {};
+import { ComponentRegistration } from "@omnia/tooling-composers";
+export declare function generateComponentTypingsAndDoc(componentRegistrations: ComponentRegistration[]): Promise<void>;
+export declare function importSnippetCode(content: string, filePath: string): string;