@omnia/tooling-vue 8.0.99-dev → 8.0.100-dev

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

@@ -25,20 +25,25 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
         let params = "";
         if (type.params?.length > 0) {
             type.params.forEach(p => {
-                params += `${p.value}:${extractTypeToString(p.typeAnnotation)}, `;
+                params += `${p.value}:${extractTypeValue(p.typeAnnotation)}, `;
             });
             params = params.replace(/,\s*$/, "");
         }
-        return `(${params}) => ${extractTypeToString(type.typeAnnotation)}`;
+        return `(${params}) => ${extractTypeValue(type.typeAnnotation)}`;
     }
-    function extractTypeToString(tsType) {
+    function extractTypeValue(tsType, rawValue = false) {
         let result = "";
         if (tsType.type === "TsTypeAnnotation") {
-            return extractTypeToString(tsType.typeAnnotation);
+            return extractTypeValue(tsType.typeAnnotation);
         }
         switch (tsType.type) {
             case "TsLiteralType":
-                result = tsType.literal.value;
+                if (rawValue && tsType.literal.type === "StringLiteral") {
+                    result = tsType.literal.raw;
+                }
+                else {
+                    result = tsType.literal.value;
+                }
                 break;
             case "TsKeywordType":
                 result = tsType.kind;
@@ -46,6 +51,9 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
             case "TsTypeReference":
                 result = tsType.typeName.value;
                 break;
+            case "TsTypeQuery":
+                result = tsType.exprName.value;
+                break;
             case "TsFunctionType":
                 result = getPropertyFunctionTypeAsString(tsType);
                 break;
@@ -64,7 +72,7 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
                     break;
                 case "vModel":
                     result.type = DefineVueType.Model;
-                    result.propertyTypeAsString = extractTypeToString(ce.typeArguments.params[0]);
+                    result.propertyTypeAsString = extractTypeValue(ce.typeArguments.params[0]);
                     result.name = result.name ? `v-model:${result.name}` : result.name;
                     break;
                 case "slots":
@@ -72,16 +80,16 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
                     result.propertyTypeAsObject = {};
                     ce.typeArguments.params[0].members
                         .forEach(m => {
-                        result.propertyTypeAsObject[m.key.value] = extractTypeToString(m.typeAnnotation);
+                        result.propertyTypeAsObject[m.key.value] = extractTypeValue(m.typeAnnotation);
                     });
                     break;
                 case "prop":
                     result.type = DefineVueType.Prop;
-                    result.propertyTypeAsString = extractTypeToString(ce.typeArguments.params[0]);
+                    result.propertyTypeAsString = extractTypeValue(ce.typeArguments.params[0]);
                     break;
                 case "emit":
                     result.type = DefineVueType.Emit;
-                    result.propertyTypeAsString = extractTypeToString(ce.typeArguments.params[0]);
+                    result.propertyTypeAsString = extractTypeValue(ce.typeArguments.params[0]);
                     break;
                 default:
                     getPropertyInfo(ce.callee.object, result);
@@ -91,6 +99,7 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
     async function buildDoc(wc) {
         try {
             const wcPath = (0, shared_1.convertManifestPathToEntryPath)(wc.manifestPath, [wc.componentOptions.entryPoint])[0];
+            const elementName = wc.componentOptions.elementName;
             const wcParseResult = await (0, core_1.parseFile)(wcPath, {
                 syntax: 'typescript',
                 target: 'es2020',
@@ -101,6 +110,14 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
             wcParseResult.body.forEach(b => {
                 if (b.type === 'ExportDefaultExpression'
                     && b.expression.callee?.value === "defineVueComponent") {
+                    if (!docResult[elementName]) {
+                        docResult[elementName] = {
+                            emits: {},
+                            models: {},
+                            props: {},
+                            slots: {}
+                        };
+                    }
                     if (b.expression.arguments[0].expression.type === "ArrowFunctionExpression") {
                         const params = b.expression.arguments[0].expression.params;
                         const typeParams = params[0].typeAnnotation.typeAnnotation.typeParams.params;
@@ -108,56 +125,62 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
                         props.types.forEach((t) => {
                             const typeName = t.typeName.value;
                             if (typeName === "DefineProp"
-                                || typeName === "DefineVModel"
-                                || typeName === "DefineSlot"
-                                || typeName === "DefineEmit") {
+                                || typeName === "DefineVModel") {
                                 // const isDefineVModel = (t.typeName as Identifier).value === "DefineVModel$";
-                                if (!docResult[wc.componentOptions.elementName]) {
-                                    docResult[wc.componentOptions.elementName] = {
-                                        emits: {},
-                                        models: {},
-                                        props: {},
-                                        slots: {}
-                                    };
-                                }
                                 const params = t.typeParams.params;
-                                const name = extractTypeToString(params[0]);
-                                const type = extractTypeToString(params[1]);
-                                if (typeName === "DefineProp" || typeName === "DefineVModel") { // props or vmodel
-                                    const required = params.length > 2 ? extractTypeToString(params[2]) : false;
-                                    const description = params.length > 3 ? extractTypeToString(params[3]) : "";
-                                    if (typeName === "DefineVModel") {
-                                        docResult[wc.componentOptions.elementName].models[name] = {
-                                            type: type,
-                                            description: description,
-                                            required: required.toString().toLowerCase() === "true" ? true : false
-                                        };
-                                    }
-                                    else { // props
-                                        docResult[wc.componentOptions.elementName].props[name] = {
-                                            type: type,
-                                            description: description,
-                                            required: required.toString().toLowerCase() === "true" ? true : false
-                                        };
-                                    }
+                                const name = extractTypeValue(params[0]) || "modelValue";
+                                const type = extractTypeValue(params[1]);
+                                const required = params.length > 2 ? extractTypeValue(params[2]) : false;
+                                const defaultValue = params.length > 3 ? extractTypeValue(params[3], true) : undefined;
+                                const description = params.length > 4 ? extractTypeValue(params[4]) : "";
+                                const info = {
+                                    type: type,
+                                    description: description,
+                                    required: required.toString().toLowerCase() === "true" ? true : false
+                                };
+                                if (defaultValue !== undefined) {
+                                    info.defaultValue = defaultValue;
                                 }
-                                else { // slots or emits
-                                    const description = params.length > 2 ? extractTypeToString(params[2]) : "";
-                                    if (typeName === "DefineEmit") {
-                                        docResult[wc.componentOptions.elementName].emits[name] = {
-                                            type: type,
-                                            description: description,
-                                        };
-                                    }
-                                    else { // slots
-                                        docResult[wc.componentOptions.elementName].slots[name] = {
-                                            type: type,
-                                            description: description,
-                                        };
-                                    }
+                                if (typeName === "DefineVModel") {
+                                    docResult[wc.componentOptions.elementName].models[name] = info;
+                                }
+                                else { // props
+                                    docResult[wc.componentOptions.elementName].props[name] = info;
                                 }
                             }
                         });
+                        if (typeParams.length > 1) {
+                            const emits = typeParams[1];
+                            emits.types.forEach((t) => {
+                                const typeName = t.typeName.value;
+                                if (typeName === "DefineEmit") {
+                                    const params = t.typeParams.params;
+                                    const name = extractTypeValue(params[0]);
+                                    const type = extractTypeValue(params[1]);
+                                    const description = params.length > 2 ? extractTypeValue(params[2]) : "";
+                                    docResult[elementName].emits[name] = {
+                                        type: type,
+                                        description: description,
+                                    };
+                                }
+                            });
+                        }
+                        if (typeParams.length > 2) {
+                            const slots = typeParams[2];
+                            slots.types.forEach((t) => {
+                                const typeName = t.typeName.value;
+                                if (typeName === "DefineSlot") {
+                                    const params = t.typeParams.params;
+                                    const name = extractTypeValue(params[0]);
+                                    const type = extractTypeValue(params[1]);
+                                    const description = params.length > 2 ? extractTypeValue(params[2]) : "";
+                                    docResult[elementName].slots[name] = {
+                                        type: type,
+                                        description: description,
+                                    };
+                                }
+                            });
+                        }
                     }
                     else {
                         b.expression.arguments[0].expression
@@ -175,29 +198,21 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
                                             name: ""
                                         };
                                         getPropertyInfo(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] = {
+                                                docResult[elementName].props[PropertyResult.name] = {
                                                     type: PropertyResult.propertyTypeAsString,
                                                     description: em.arguments[0].expression.value
                                                 };
                                                 break;
                                             case DefineVueType.Model:
-                                                docResult[wc.componentOptions.elementName].models[PropertyResult.name] = {
+                                                docResult[elementName].models[PropertyResult.name] = {
                                                     type: PropertyResult.propertyTypeAsString,
                                                     description: em.arguments[0].expression.value
                                                 };
                                                 break;
                                             case DefineVueType.Emit:
-                                                docResult[wc.componentOptions.elementName].emits[PropertyResult.name] = {
+                                                docResult[elementName].emits[PropertyResult.name] = {
                                                     type: PropertyResult.propertyTypeAsString,
                                                     description: em.arguments[0].expression.value
                                                 };
@@ -207,7 +222,7 @@ async function generateComponentTypingsAndDoc(componentRegistrations) {
                                                     .properties
                                                     .forEach(p => {
                                                     const slotName = p.key.value;
-                                                    docResult[wc.componentOptions.elementName].slots[slotName] = {
+                                                    docResult[elementName].slots[slotName] = {
                                                         type: PropertyResult.propertyTypeAsObject[slotName],
                                                         description: p.value.value
                                                     };

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

@@ -173,9 +173,9 @@ $.webpack({
     },
     entry: {
         vendor: [
-            // "@stylexjs/stylex",
+            "@stylexjs/stylex",
             // "tslib",
-            "./client/fx/vue/VueBundler",
+            "./client/fx/vue/VueBundler.ts",
             "lodash.isequal",
             "typestyle",
             "csx",
@@ -329,9 +329,9 @@ $.webpack({
     },
     entry: {
         vendor: [
-            // "@stylexjs/stylex",
+            "@stylexjs/stylex",
             // "tslib",
-            "./client/fx/vue/VueBundler",
+            "./client/fx/vue/VueBundler.ts",
             "lodash.isequal",
             "typestyle",
             "csx",

package/internal-do-not-import-from-here/vite/hmr/graph.js

@@ -153,7 +153,7 @@ async function buildFileGraph(unknownId, code) {
         return { fileGraph, code };
     }
     fileGraph.js.scanned = true;
-    code = (0, shared_1.modifyComponent)(code, fileGraph.id);
+    code = (0, shared_1.transformVueComponent)(code, fileGraph.id);
     const esbuildTransformResult = await (0, vite_1.transformWithEsbuild)(code, id, esbuildTransformOptions);
     code = esbuildTransformResult.code;
     // d.ts or interface only

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

@@ -5,7 +5,6 @@ const tslib_1 = require("tslib");
 const node_crypto_1 = require("node:crypto");
 const core_1 = require("@babel/core");
 const $ = tslib_1.__importStar(require("../../variables"));
-const babel_plugin_1 = tslib_1.__importDefault(require("@stylexjs/babel-plugin"));
 function transformVueJsx(code, id) {
     const result = (0, core_1.transformSync)(code, {
         ast: true,
@@ -17,25 +16,7 @@ function transformVueJsx(code, id) {
                     : './client/tooling/vue/babel/preset-jsx.ts'
             ],
         ],
-        plugins: [
-            [
-                babel_plugin_1.default,
-                {
-                    dev: true,
-                    // Set this to true for snapshot testing
-                    // default: false
-                    test: false,
-                    // 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,
-                    },
-                },
-            ],
-        ]
+        plugins: []
     });
     // check for hmr injection
     const declaredComponents = [];

package/internal-do-not-import-from-here/webpack-loaders/wc-loader.js

@@ -5,7 +5,7 @@ const path_1 = tslib_1.__importDefault(require("path"));
 const shared_1 = require("../shared");
 function default_1(content, context) {
     const filePath = "./" + path_1.default.relative(process.cwd(), this.resourcePath).replace(/\\/g, "/");
-    content = (0, shared_1.modifyComponent)(content, filePath);
+    content = (0, shared_1.transformVueComponent)(content, filePath);
     return content;
 }
 exports.default = default_1;

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

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ */
+type PluginOptions = {
+    dev?: boolean;
+    stylexImports?: string[];
+    babelConfig?: {
+        plugins?: any;
+        presets?: any;
+        babelrc?: boolean;
+    };
+    filename?: string;
+    appendTo?: string;
+    useCSSLayers?: boolean;
+    runtimeInjection?: boolean;
+    classNamePrefix?: string;
+    unstable_moduleResolution?: any;
+};
+export declare class StylexPlugin {
+    stylexRules: {};
+    filesInLastRun: any;
+    dev: boolean;
+    appendTo: any;
+    filename: string;
+    stylexImports: string[];
+    unstable_moduleResolution: {
+        type: string;
+        rootDir: string;
+    };
+    babelConfig: {
+        plugins: any[];
+        presets: any[];
+        babelrc: boolean;
+    };
+    useCSSLayers: boolean;
+    defaultOptions: PluginOptions;
+    babelPlugin: any;
+    constructor(options?: PluginOptions);
+    apply(compiler: any): void;
+    transformCode(inputCode: string, filename: any, logger: any): Promise<{
+        code: any;
+        map: any;
+    } | {
+        code: string;
+        map?: undefined;
+    }>;
+}
+export {};

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

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StylexPlugin = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("@babel/core");
+const path_1 = tslib_1.__importDefault(require("path"));
+const babel_plugin_1 = tslib_1.__importDefault(require("@stylexjs/babel-plugin"));
+const webpack_1 = tslib_1.__importDefault(require("webpack"));
+// import * as flowSyntaxPlugin from '@babel/plugin-syntax-flow';
+// import * as jsxSyntaxPlugin from '@babel/plugin-syntax-jsx';
+// import * as typescriptSyntaxPlugin from '@babel/plugin-syntax-typescript';
+const promises_1 = tslib_1.__importDefault(require("fs/promises"));
+const $ = tslib_1.__importStar(require("../../variables"));
+const { NormalModule, Compilation } = webpack_1.default;
+const PLUGIN_NAME = 'stylex';
+const IS_DEV_ENV = process.env.NODE_ENV === 'development' ||
+    process.env.BABEL_ENV === 'development';
+const { RawSource, ConcatSource } = webpack_1.default.sources;
+class StylexPlugin {
+    constructor(options = {}) {
+        this.stylexRules = {};
+        this.filesInLastRun = null;
+        this.dev = IS_DEV_ENV;
+        this.appendTo = null;
+        this.filename = "stylex.css";
+        this.stylexImports = ['stylex', '@stylexjs/stylex'];
+        this.unstable_moduleResolution = { type: 'commonJS', rootDir: process.cwd() };
+        this.babelConfig = { plugins: [], presets: [], babelrc: false };
+        this.useCSSLayers = false;
+        this.defaultOptions = {
+            dev: IS_DEV_ENV,
+            appendTo: null,
+            filename: "stylex.css",
+            stylexImports: ['stylex', '@stylexjs/stylex'],
+            unstable_moduleResolution: { type: 'commonJS', rootDir: process.cwd() },
+            babelConfig: { plugins: [], presets: [], babelrc: false },
+            useCSSLayers: false
+        };
+        Object.assign(this, this.defaultOptions, options);
+        this.babelPlugin = [
+            babel_plugin_1.default,
+            {
+                dev: this.dev,
+                unstable_moduleResolution: this.unstable_moduleResolution,
+                importSources: this.stylexImports,
+                ...options,
+            },
+        ];
+    }
+    apply(compiler) {
+        compiler.hooks.make.tap(PLUGIN_NAME, (compilation) => {
+            // Apply loader to JS modules.
+            NormalModule.getCompilationHooks(compilation).loader.tap(PLUGIN_NAME, (loaderContext, module) => {
+                if (
+                // .js, .jsx, .mjs, .cjs, .ts, .tsx, .mts, .cts
+                /\.ts[x]?$/.test(path_1.default.extname(module.resource))) {
+                    // It might make sense to use .push() here instead of .unshift()
+                    // Webpack usually runs loaders in reverse order and we want to ideally run
+                    // our loader before anything else.
+                    module.loaders.unshift({
+                        loader: path_1.default.resolve(__dirname, $.isExtensionEnv ? 'loader.js' : 'loader.ts'),
+                        options: { stylexPlugin: this },
+                    });
+                }
+            });
+            // Make a list of all modules that were included in the last compilation.
+            // This might need to be tweaked if not all files are included after a change
+            compilation.hooks.finishModules.tap(PLUGIN_NAME, (modules) => {
+                this.filesInLastRun = [...modules.values()].map((m) => m.resource);
+            });
+            const getStyleXRules = () => {
+                const { stylexRules } = this;
+                if (Object.keys(stylexRules).length === 0) {
+                    return null;
+                }
+                // Take styles for the modules that were included in the last compilation.
+                const allRules = Object.keys(stylexRules)
+                    .filter((filename) => this.filesInLastRun == null
+                    ? true
+                    : this.filesInLastRun.includes(filename))
+                    .map((filename) => stylexRules[filename])
+                    .flat();
+                return babel_plugin_1.default.processStylexRules(allRules, this.useCSSLayers);
+            };
+            if (this.appendTo) {
+                compilation.hooks.processAssets.tap({
+                    name: PLUGIN_NAME,
+                    stage: Compilation.PROCESS_ASSETS_STAGE_PRE_PROCESS, // see below for more stages
+                }, (assets) => {
+                    const cssFileName = Object.keys(assets).find(typeof this.appendTo === 'function'
+                        ? this.appendTo
+                        : (filename) => filename.endsWith(this.appendTo));
+                    if (cssFileName) {
+                        const cssAsset = assets[cssFileName];
+                        const stylexCSS = getStyleXRules();
+                        if (stylexCSS != null) {
+                            assets[cssFileName] = new ConcatSource(cssAsset, new RawSource(stylexCSS));
+                        }
+                    }
+                });
+            }
+            else {
+                // We'll emit an asset ourselves. This comes with some complications in from Webpack.
+                // If the filename contains replacement tokens, like [contenthash], we need to
+                // process those tokens ourselves. Webpack does provide a way to reuse the configured
+                // hashing functions. We'll take advantage of that to process tokens.
+                const getContentHash = (source) => {
+                    const { outputOptions } = compilation;
+                    const { hashDigest, hashDigestLength, hashFunction, hashSalt } = outputOptions;
+                    const hash = compiler.webpack.util.createHash(hashFunction);
+                    if (hashSalt) {
+                        hash.update(hashSalt);
+                    }
+                    hash.update(source);
+                    const fullContentHash = hash.digest(hashDigest);
+                    return fullContentHash.toString().slice(0, hashDigestLength);
+                };
+                // Consume collected rules and emit the stylex CSS asset
+                compilation.hooks.processAssets.tap({
+                    name: PLUGIN_NAME,
+                    stage: Compilation.PROCESS_ASSETS_STAGE_ADDITIONAL,
+                }, () => {
+                    try {
+                        const collectedCSS = getStyleXRules();
+                        if (collectedCSS) {
+                            // build up a content hash for the rules using webpack's configured hashing functions
+                            const contentHash = getContentHash(collectedCSS);
+                            // pretend to be a chunk so we can reuse the webpack routine to process the filename and do token replacement
+                            // see https://github.com/webpack/webpack/blob/main/lib/Compilation.js#L4733
+                            // see https://github.com/webpack/webpack/blob/main/lib/TemplatedPathPlugin.js#L102
+                            const data = {
+                                filename: this.filename,
+                                contentHash: contentHash,
+                                chunk: {
+                                    id: this.filename,
+                                    name: path_1.default.parse(this.filename).name,
+                                    hash: contentHash,
+                                },
+                            };
+                            const { path: hashedPath, info: assetsInfo } = compilation.getPathWithInfo(data.filename, data);
+                            compilation.emitAsset(hashedPath, new RawSource(collectedCSS), assetsInfo);
+                        }
+                    }
+                    catch (e) {
+                        compilation.errors.push(e);
+                    }
+                });
+            }
+        });
+    }
+    // This function is not called by Webpack directly.
+    // Instead, `NormalModule.getCompilationHooks` is used to inject a loader
+    // for JS modules. The loader than calls this function.
+    async transformCode(inputCode, filename, logger) {
+        if (this.stylexImports.some((importName) => inputCode.includes(importName))) {
+            const originalSource = this.babelConfig.babelrc
+                ? await promises_1.default.readFile(filename, 'utf8')
+                : inputCode;
+            const { code, map, metadata } = await (0, core_1.transformAsync)(originalSource, {
+                babelrc: this.babelConfig.babelrc,
+                filename,
+                // Use TypeScript syntax plugin if the filename ends with `.ts` or `.tsx`
+                // and use the Flow syntax plugin otherwise.
+                plugins: [
+                    // ...this.babelConfig.plugins,
+                    // path.extname(filename) === '.ts'
+                    //   ? typescriptSyntaxPlugin
+                    //   : path.extname(filename) === '.tsx'
+                    //     ? [typescriptSyntaxPlugin, { isTSX: true }]
+                    //     : flowSyntaxPlugin,
+                    // jsxSyntaxPlugin,
+                    this.babelPlugin,
+                ],
+                presets: this.babelConfig.presets,
+            });
+            if (metadata.stylex != null && metadata.stylex.length > 0) {
+                this.stylexRules[filename] = metadata.stylex;
+            }
+            if (!this.babelConfig.babelrc) {
+                return { code, map };
+            }
+        }
+        return { code: inputCode };
+    }
+}
+exports.StylexPlugin = StylexPlugin;

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

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ */
+export default function stylexLoader(inputCode: any): void;

package/internal-do-not-import-from-here/webpack-plugins/stylexjs/loader.js

@@ -0,0 +1,23 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const PLUGIN_NAME = 'stylex';
+function stylexLoader(inputCode) {
+    const callback = this.async();
+    const { stylexPlugin } = this.getOptions();
+    const logger = this._compiler.getInfrastructureLogger(PLUGIN_NAME);
+    stylexPlugin.transformCode(inputCode, this.resourcePath, logger).then(({ code, map }) => {
+        callback(null, code, map);
+    }, (error) => {
+        callback(error);
+    });
+}
+exports.default = stylexLoader;
+;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omnia/tooling-vue",
   "license": "MIT",
-  "version": "8.0.99-dev",
+  "version": "8.0.100-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,12 +19,12 @@
   ],
   "author": "Precio Fishbone",
   "dependencies": {
-    "@omnia/fx-models": "8.0.99-dev",
-    "@omnia/tooling-composers": "8.0.99-dev",
+    "@omnia/fx-models": "8.0.100-dev",
+    "@omnia/tooling-composers": "8.0.100-dev",
     "@types/mousetrap": "1.5.34",
     "@types/quill": "1.3.6",
     "@types/zepto": "1.0.29",
-    "@babel/core": "7.16.5",
+    "@babel/core": "7.23.7",
     "babel-loader": "8.3.0",
     "@vue/babel-plugin-jsx": "1.1.1",
     "circular-dependency-plugin": "5.2.2",
@@ -60,7 +60,6 @@
     "vite-plugin-inspect": "0.8.1",
     "appdata-path": "1.0.0",
     "url": "0.11.0",
-    "@stylexjs/webpack-plugin": "0.4.1",
     "@stylexjs/babel-plugin": "0.4.1"
   },
   "bugs": {