@stylexjs/babel-plugin 0.10.0-beta.1 → 0.10.0

package/lib/index.js

@@ -3,8 +3,9 @@
 var t = require('@babel/types');
 var path = require('path');
 var fs = require('fs');
+var url = require('url');
 var require$$0 = require('assert');
-var esmResolve = require('esm-resolve');
+var importMetaResolve = require('@dual-bundle/import-meta-resolve');
 var shared = require('@stylexjs/shared');
 var core = require('@babel/core');
 var traverse = require('@babel/traverse');
@@ -798,7 +799,7 @@ function isReferencedIdentifier(path, props) {
 
 const CheckModuleResolution = unionOf3(object({
   type: literal('commonJS'),
-  rootDir: string(),
+  rootDir: unionOf(nullish(), string()),
   themeFileExtension: unionOf(nullish(), string())
 }), object({
   type: literal('haste'),
@@ -1130,42 +1131,21 @@ function possibleAliasedPaths(importPath, aliases) {
   return result;
 }
 const filePathResolver = (relativeFilePath, sourceFilePath, aliases) => {
-  const esmResolve$1 = esmResolve.buildResolver(sourceFilePath);
   for (const ext of ['', ...EXTENSIONS]) {
     const importPathStr = relativeFilePath + ext;
     if (importPathStr.startsWith('.')) {
       try {
-        return require.resolve(importPathStr, {
-          paths: [path.dirname(sourceFilePath)]
-        });
+        return importMetaResolve.moduleResolve(importPathStr, url.pathToFileURL(sourceFilePath)).pathname;
       } catch {
-        const resolved = esmResolve$1(importPathStr, {
-          allowImportingExtraExtensions: true
-        });
-        if (resolved) {
-          if (resolved.startsWith('.')) {
-            return path.resolve(path.dirname(sourceFilePath), resolved);
-          }
-          return resolved;
-        }
+        continue;
       }
     }
     const allAliases = possibleAliasedPaths(importPathStr, aliases);
     for (const possiblePath of allAliases) {
       try {
-        return require.resolve(possiblePath, {
-          paths: [path.dirname(sourceFilePath)]
-        });
+        return importMetaResolve.moduleResolve(possiblePath, url.pathToFileURL(sourceFilePath)).pathname;
       } catch {
-        const resolved = esmResolve$1(importPathStr, {
-          allowImportingExtraExtensions: true
-        });
-        if (resolved) {
-          if (resolved.startsWith('.')) {
-            return path.resolve(path.dirname(sourceFilePath), resolved);
-          }
-          return resolved;
-        }
+        continue;
       }
     }
   }
@@ -1355,6 +1335,32 @@ function canBeIdentifier(str) {
   return str.match(/^[a-zA-Z_$][a-zA-Z0-9_$]*$/) != null;
 }
 
+const IMPORT_FILE_PARSING_ERROR = `There was error when attempting to parse the imported file.
+Please ensure that the 'babelrc' file is configured to be able to parse this file.
+`;
+const IMPORT_FILE_EVAL_ERROR = `There was an error when attempting to evaluate the imported file.
+Please ensure that the imported file is self-contained and does not rely on dynamic behavior.
+`;
+const PATH_WITHOUT_NODE = `Unexpected error:
+Could not resolve the code being evaluated.
+`;
+const UNEXPECTED_MEMBER_LOOKUP = `Unexpected error:
+Could not determine the property being accessed.
+`;
+const IMPORT_PATH_RESOLUTION_ERROR = `Could not resolve the path to the imported file.
+Please ensure that the theme file has a .stylex.js or .stylex.ts file extension and follows the
+rules for defining variariables: 
+
+https://stylexjs.com/docs/learn/theming/defining-variables/#rules-when-defining-variables
+`;
+const NON_CONSTANT = 'Referenced value is not a constant.\n\n';
+const USED_BEFORE_DECLARATION = 'Referenced value is used before declaration.\n\n';
+const UNINITIALIZED_CONST = 'Referenced constant is not initialized.\n\n';
+const UNDEFINED_CONST = 'Referenced constant is not defined.';
+const UNSUPPORTED_OPERATOR = op => `Unsupported operator: ${op}\n\n`;
+const OBJECT_METHOD = 'Unsupported object method.\n\n';
+const UNSUPPORTED_EXPRESSION = type => `Unsupported expression: ${type}\n\n`;
+
 const VALID_CALLEES = ['String', 'Number', 'Math', 'Object', 'Array'];
 const INVALID_METHODS = ['random', 'assign', 'defineProperties', 'defineProperty', 'freeze', 'seal', 'splice'];
 function isValidCallee(val) {
@@ -1363,19 +1369,20 @@ function isValidCallee(val) {
 function isInvalidMethod(val) {
   return INVALID_METHODS.includes(val);
 }
-function deopt(path, state) {
+function deopt(path, state, reason) {
   if (!state.confident) return;
   state.deoptPath = path;
   state.confident = false;
+  state.deoptReason = reason;
 }
-function evaluateImportedFile(filePath, namedExport, state) {
+function evaluateImportedFile(filePath, namedExport, state, bindingPath) {
   const fs = require('fs');
   const fileContents = fs.readFileSync(filePath, 'utf8');
   const ast = core.parseSync(fileContents, {
     babelrc: true
   });
   if (!ast || ast.errors || !t__namespace.isNode(ast)) {
-    state.confident = false;
+    deopt(bindingPath, state, IMPORT_FILE_PARSING_ERROR);
     return;
   }
   const astNode = ast;
@@ -1405,7 +1412,7 @@ function evaluateImportedFile(filePath, namedExport, state) {
   if (state.confident) {
     return result;
   } else {
-    state.confident = false;
+    deopt(bindingPath, state, IMPORT_FILE_EVAL_ERROR);
     return;
   }
 }
@@ -1422,7 +1429,8 @@ function evaluateThemeRef(fileName, exportName, state) {
       exportName,
       key
     });
-    const varName = state.traversalState.options.classNamePrefix + shared.utils.hash(strToHash);
+    const debug = state.traversalState.options.debug;
+    const varName = debug === true ? key + '-' + state.traversalState.options.classNamePrefix + shared.utils.hash(strToHash) : state.traversalState.options.classNamePrefix + shared.utils.hash(strToHash);
     if (key === '__themeName__') {
       return varName;
     }
@@ -1450,22 +1458,25 @@ function evaluateCached(path, state) {
     if (existing.resolved) {
       return existing.value;
     } else {
-      deopt(path, state);
+      deopt(path, state, existing.reason);
       return;
     }
   } else {
     const item = {
-      resolved: false
+      resolved: false,
+      reason: 'Currently evaluating'
     };
     seen.set(node, item);
     if (node == null) {
-      deopt(path, state);
+      deopt(path, state, PATH_WITHOUT_NODE);
       return;
     }
     const val = _evaluate(path, state);
     if (state.confident) {
-      item.resolved = true;
-      item.value = val;
+      seen.set(node, {
+        resolved: true,
+        value: val
+      });
     }
     return val;
   }
@@ -1565,7 +1576,7 @@ function _evaluate(path, state) {
     } else if (isStringLiteral(propPath)) {
       property = propPath.node.value;
     } else {
-      return deopt(propPath, state);
+      return deopt(propPath, state, UNEXPECTED_MEMBER_LOOKUP);
     }
     return object[property];
   }
@@ -1581,10 +1592,10 @@ function _evaluate(path, state) {
       if (importPath && isImportDeclaration(importPath)) {
         const absPath = state.traversalState.importPathResolver(importPath.node.source.value);
         if (!absPath) {
-          return deopt(binding.path, state);
+          return deopt(binding.path, state, IMPORT_PATH_RESOLUTION_ERROR);
         }
         const [type, value] = absPath;
-        const returnValue = type === 'themeNameRef' ? evaluateThemeRef(value, importedName, state) : evaluateImportedFile(value, importedName, state);
+        const returnValue = type === 'themeNameRef' ? evaluateThemeRef(value, importedName, state) : evaluateImportedFile(value, importedName, state, bindingPath);
         if (state.confident) {
           if (!state.addedImports.has(importPath.node.source.value) && state.traversalState.treeshakeCompensation) {
             importPath.insertBefore(t__namespace.importDeclaration([], importPath.node.source));
@@ -1592,29 +1603,32 @@ function _evaluate(path, state) {
           }
           return returnValue;
         } else {
-          deopt(binding.path, state);
+          deopt(binding.path, state, IMPORT_FILE_EVAL_ERROR);
         }
       }
     }
+    if (binding && bindingPath && isImportDefaultSpecifier(bindingPath)) {
+      deopt(binding.path, state, IMPORT_FILE_EVAL_ERROR);
+    }
     if (binding && binding.constantViolations.length > 0) {
-      return deopt(binding.path, state);
+      return deopt(binding.path, state, NON_CONSTANT);
     }
     if (binding && path.node.start < binding.path.node.end) {
-      return deopt(binding.path, state);
+      return deopt(binding.path, state, USED_BEFORE_DECLARATION);
     }
     if (binding && binding.hasValue) {
       return binding.value;
     } else {
       if (path.node.name === 'undefined') {
-        return binding ? deopt(binding.path, state) : undefined;
+        return binding ? deopt(binding.path, state, UNINITIALIZED_CONST) : undefined;
       } else if (path.node.name === 'Infinity') {
-        return binding ? deopt(binding.path, state) : Infinity;
+        return binding ? deopt(binding.path, state, UNINITIALIZED_CONST) : Infinity;
       } else if (path.node.name === 'NaN') {
-        return binding ? deopt(binding.path, state) : NaN;
+        return binding ? deopt(binding.path, state, UNINITIALIZED_CONST) : NaN;
       }
       const resolved = path.resolve();
       if (resolved === path) {
-        return deopt(path, state);
+        return deopt(path, state, UNDEFINED_CONST);
       } else {
         return evaluateCached(resolved, state);
       }
@@ -1646,7 +1660,7 @@ function _evaluate(path, state) {
       case 'void':
         return undefined;
       default:
-        return deopt(path, state);
+        return deopt(path, state, UNSUPPORTED_OPERATOR(path.node.operator));
     }
   }
   if (isArrayExpression(path)) {
@@ -1658,7 +1672,7 @@ function _evaluate(path, state) {
       if (elemValue.confident) {
         arr.push(elemValue.value);
       } else {
-        elemValue.deopt && deopt(elemValue.deopt, state);
+        elemValue.deopt && deopt(elemValue.deopt, state, elemValue.reason ?? 'unknown error');
         return;
       }
     }
@@ -1669,12 +1683,12 @@ function _evaluate(path, state) {
     const props = path.get('properties');
     for (const prop of props) {
       if (isObjectMethod(prop)) {
-        return deopt(prop, state);
+        return deopt(prop, state, OBJECT_METHOD);
       }
       if (isSpreadElement(prop)) {
         const spreadExpression = evaluateCached(prop.get('argument'), state);
         if (!state.confident) {
-          return deopt(prop, state);
+          return deopt(prop, state, state.deoptReason ?? 'unknown error');
         }
         Object.assign(obj, spreadExpression);
         continue;
@@ -1686,10 +1700,11 @@ function _evaluate(path, state) {
           const {
             confident,
             deopt: resultDeopt,
+            reason: deoptReason,
             value
           } = evaluate(keyPath, state.traversalState, state.functions);
           if (!confident) {
-            resultDeopt && deopt(resultDeopt, state);
+            resultDeopt && deopt(resultDeopt, state, deoptReason ?? 'unknown error');
             return;
           }
           key = value;
@@ -1701,7 +1716,7 @@ function _evaluate(path, state) {
         const valuePath = prop.get('value');
         let value = evaluate(valuePath, state.traversalState, state.functions);
         if (!value.confident) {
-          value.deopt && deopt(value.deopt, state);
+          value.deopt && deopt(value.deopt, state, value.reason ?? 'unknown error');
           return;
         }
         value = value.value;
@@ -1711,25 +1726,71 @@ function _evaluate(path, state) {
     return obj;
   }
   if (isLogicalExpression(path)) {
-    const wasConfident = state.confident;
-    const left = evaluateCached(path.get('left'), state);
-    const leftConfident = state.confident;
-    state.confident = wasConfident;
-    const right = evaluateCached(path.get('right'), state);
-    const rightConfident = state.confident;
+    const stateForLeft = {
+      ...state,
+      deoptPath: null,
+      confident: true
+    };
+    const leftPath = path.get('left');
+    const left = evaluateCached(leftPath, stateForLeft);
+    const leftConfident = stateForLeft.confident;
+    const stateForRight = {
+      ...state,
+      deoptPath: null,
+      confident: true
+    };
+    const rightPath = path.get('right');
+    const right = evaluateCached(rightPath, stateForRight);
+    const rightConfident = stateForRight.confident;
     switch (path.node.operator) {
       case '||':
-        state.confident = leftConfident && (!!left || rightConfident);
-        if (!state.confident) return;
-        return left || right;
+        {
+          if (leftConfident && (!!left || rightConfident)) {
+            return left || right;
+          }
+          if (!leftConfident) {
+            deopt(leftPath, state, stateForLeft.deoptReason ?? 'unknown error');
+            return;
+          }
+          if (!rightConfident) {
+            deopt(rightPath, state, stateForRight.deoptReason ?? 'unknown error');
+            return;
+          }
+          deopt(path, state, 'unknown error');
+          return;
+        }
       case '&&':
-        state.confident = leftConfident && (!left || rightConfident);
-        if (!state.confident) return;
-        return left && right;
+        {
+          if (leftConfident && (!left || rightConfident)) {
+            return left && right;
+          }
+          if (!leftConfident) {
+            deopt(leftPath, state, stateForLeft.deoptReason ?? 'unknown error');
+            return;
+          }
+          if (!rightConfident) {
+            deopt(rightPath, state, stateForRight.deoptReason ?? 'unknown error');
+            return;
+          }
+          deopt(path, state, 'unknown error');
+          return;
+        }
       case '??':
-        state.confident = leftConfident && !!(left ?? rightConfident);
-        if (!state.confident) return;
-        return left ?? right;
+        {
+          if (leftConfident && !!(left ?? rightConfident)) {
+            return left ?? right;
+          }
+          if (!leftConfident) {
+            deopt(leftPath, state, stateForLeft.deoptReason ?? 'unknown error');
+            return;
+          }
+          if (!rightConfident) {
+            deopt(rightPath, state, stateForRight.deoptReason ?? 'unknown error');
+            return;
+          }
+          deopt(path, state, 'unknown error');
+          return;
+        }
       default:
         path.node.operator;
     }
@@ -1796,6 +1857,13 @@ function _evaluate(path, state) {
       func = global[callee.node.name];
     } else if (isIdentifier(callee) && state.functions.identifiers[callee.node.name]) {
       func = state.functions.identifiers[callee.node.name];
+    } else if (isIdentifier(callee)) {
+      const maybeFunction = evaluateCached(callee, state);
+      if (state.confident) {
+        func = maybeFunction;
+      } else {
+        deopt(callee, state, NON_CONSTANT);
+      }
     }
     if (isMemberExpression(callee)) {
       const object = callee.get('object');
@@ -1847,7 +1915,7 @@ function _evaluate(path, state) {
       }
     }
   }
-  deopt(path, state);
+  deopt(path, state, UNSUPPORTED_EXPRESSION(path.node.type));
 }
 function evaluateQuasis(path, quasis, state) {
   let raw = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
@@ -1884,6 +1952,7 @@ function evaluate(path, traversalState) {
   return {
     confident: state.confident,
     deopt: state.deoptPath,
+    reason: state.deoptReason,
     value: value
   };
 }
@@ -2889,12 +2958,15 @@ function requireTransformValue () {
 	  const value = typeof rawValue === 'number' ? String(Math.round(rawValue * 10000) / 10000) + getNumberSuffix(key) : rawValue;
 	  if ((key === 'content' || key === 'hyphenateCharacter' || key === 'hyphenate-character') && typeof value === 'string') {
 	    const val = value.trim();
-	    if (val.match(/^attr\([a-zA-Z0-9-]+\)$/)) {
+	    const cssContentFunctions = ['attr(', 'counter(', 'counters(', 'url(', 'linear-gradient(', 'image-set('];
+	    const cssContentKeywords = new Set(['normal', 'none', 'open-quote', 'close-quote', 'no-open-quote', 'no-close-quote', 'inherit', 'initial', 'revert', 'revert-layer', 'unset']);
+	    const isCssFunction = cssContentFunctions.some(func => val.includes(func));
+	    const isKeyword = cssContentKeywords.has(val);
+	    const hasMatchingQuotes = (val.match(/"/g)?.length ?? 0) >= 2 || (val.match(/'/g)?.length ?? 0) >= 2;
+	    if (isCssFunction || isKeyword || hasMatchingQuotes) {
 	      return val;
 	    }
-	    if (!(val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'"))) {
-	      return `"${val}"`;
-	    }
+	    return `"${val}"`;
 	  }
 	  return (0, _normalizeValue.default)(value, key, options);
 	}
@@ -3711,19 +3783,33 @@ function transformStyleXCreate(path, state) {
     const {
       confident,
       value,
-      fns
+      fns,
+      reason,
+      deopt
     } = evaluateStyleXCreateArg(firstArg, state, {
       identifiers,
       memberExpressions
     });
     if (!confident) {
-      throw path.buildCodeFrameError(shared.messages.NON_STATIC_VALUE, SyntaxError);
+      throw (deopt ?? path).buildCodeFrameError(reason ?? shared.messages.NON_STATIC_VALUE, SyntaxError);
     }
     const plainObject = value;
+    const injectedInheritStyles = {};
+    if (fns != null) {
+      const dynamicFnsNames = Object.values(fns)?.map(entry => Object.keys(entry[1])).flat();
+      dynamicFnsNames.forEach(fnsName => {
+        injectedInheritStyles[fnsName] = {
+          priority: 0,
+          ltr: `@property ${fnsName} { syntax: "*"; inherits: false; initial-value: "*";}`,
+          rtl: null
+        };
+      });
+    }
     let [compiledStyles, injectedStylesSansKeyframes, classPathsPerNamespace] = shared.create(plainObject, state.options);
     const injectedStyles = {
       ...injectedKeyframes,
-      ...injectedStylesSansKeyframes
+      ...injectedStylesSansKeyframes,
+      ...injectedInheritStyles
     };
     let varName = null;
     if (isVariableDeclarator(path.parentPath)) {
@@ -4899,18 +4985,42 @@ function styleXTransform() {
               }
             }
           }
+        },
+        exit: path => {
           path.traverse({
-            CallExpression(path) {
-              if (isVariableDeclarator(path.parentPath)) {
-                transformStyleXKeyframes(path.parentPath, state);
+            Identifier(path) {
+              if (isReferencedIdentifier(path)) {
+                const {
+                  name
+                } = path.node;
+                if (state.styleMap.has(name)) {
+                  const parentPath = path.parentPath;
+                  if (isMemberExpression(parentPath)) {
+                    const {
+                      property,
+                      computed
+                    } = parentPath.node;
+                    if (property.type === 'Identifier' && !computed) {
+                      state.markComposedNamespace([name, property.name, true]);
+                    } else if (property.type === 'StringLiteral' && computed) {
+                      state.markComposedNamespace([name, property.value, true]);
+                    } else if (property.type === 'NumericLiteral' && computed) {
+                      state.markComposedNamespace([name, String(property.value), true]);
+                    } else {
+                      state.markComposedNamespace([name, true, true]);
+                    }
+                  } else {
+                    state.markComposedNamespace([name, true, true]);
+                  }
+                }
               }
-              transformStyleXDefineVars(path, state);
-              transformStyleXCreateTheme(path, state);
-              transformStyleXCreate(path, state);
+            },
+            CallExpression(path) {
+              skipStylexMergeChildren(path, state);
+              skipStylexPropsChildren(path, state);
+              skipStylexAttrsChildren(path, state);
             }
           });
-        },
-        exit: path => {
           path.traverse({
             CallExpression(path) {
               transformStyleXMerge(path, state);
@@ -4995,36 +5105,12 @@ function styleXTransform() {
         }
       },
       CallExpression(path) {
-        skipStylexMergeChildren(path, state);
-        skipStylexPropsChildren(path, state);
-        skipStylexAttrsChildren(path, state);
-      },
-      Identifier(path) {
-        if (isReferencedIdentifier(path)) {
-          const {
-            name
-          } = path.node;
-          if (state.styleMap.has(name)) {
-            const parentPath = path.parentPath;
-            if (isMemberExpression(parentPath)) {
-              const {
-                property,
-                computed
-              } = parentPath.node;
-              if (property.type === 'Identifier' && !computed) {
-                state.markComposedNamespace([name, property.name, true]);
-              } else if (property.type === 'StringLiteral' && computed) {
-                state.markComposedNamespace([name, property.value, true]);
-              } else if (property.type === 'NumericLiteral' && computed) {
-                state.markComposedNamespace([name, String(property.value), true]);
-              } else {
-                state.markComposedNamespace([name, true, true]);
-              }
-            } else {
-              state.markComposedNamespace([name, true, true]);
-            }
-          }
+        if (isVariableDeclarator(path.parentPath)) {
+          transformStyleXKeyframes(path.parentPath, state);
         }
+        transformStyleXDefineVars(path, state);
+        transformStyleXCreateTheme(path, state);
+        transformStyleXCreate(path, state);
       }
     }
   };

package/lib/utils/evaluate-path.d.ts

@@ -24,4 +24,9 @@ export declare function evaluate(
   path: NodePath,
   traversalState: StateManager,
   functions: FunctionConfig,
-): Readonly<{ confident: boolean; value: any; deopt?: null | NodePath }>;
+): Readonly<{
+  confident: boolean;
+  value: any;
+  deopt?: null | NodePath;
+  reason?: string;
+}>;

package/lib/utils/evaluate-path.js.flow

@@ -31,4 +31,5 @@ declare export function evaluate(
   confident: boolean,
   value: any,
   deopt?: null | NodePath<>,
+  reason?: string,
 }>;

package/lib/utils/evaluation-errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * 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 declare const IMPORT_FILE_PARSING_ERROR: any;
+export declare const IMPORT_FILE_EVAL_ERROR: any;
+export declare const DEFAULT_IMPORT: any;
+export declare const PATH_WITHOUT_NODE: any;
+export declare const UNEXPECTED_MEMBER_LOOKUP: any;
+export declare const IMPORT_PATH_RESOLUTION_ERROR: any;
+export declare const NON_CONSTANT: 'Referenced value is not a constant.\n\n';
+export declare const USED_BEFORE_DECLARATION: 'Referenced value is used before declaration.\n\n';
+export declare const UNINITIALIZED_CONST: 'Referenced constant is not initialized.\n\n';
+export declare const UNDEFINED_CONST: 'Referenced constant is not defined.';
+export declare const UNSUPPORTED_OPERATOR: (op: string) => string;
+export declare const OBJECT_METHOD: 'Unsupported object method.\n\n';
+export declare const UNSUPPORTED_EXPRESSION: (type: string) => string;

package/lib/utils/evaluation-errors.js.flow

@@ -0,0 +1,35 @@
+/**
+ * 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.
+ *
+ * @flow strict
+ */
+
+declare export const IMPORT_FILE_PARSING_ERROR: $FlowFixMe;
+
+// export const
+declare export const IMPORT_FILE_EVAL_ERROR: $FlowFixMe;
+
+declare export const DEFAULT_IMPORT: $FlowFixMe;
+
+declare export const PATH_WITHOUT_NODE: $FlowFixMe;
+
+declare export const UNEXPECTED_MEMBER_LOOKUP: $FlowFixMe;
+
+declare export const IMPORT_PATH_RESOLUTION_ERROR: $FlowFixMe;
+
+declare export const NON_CONSTANT: 'Referenced value is not a constant.\n\n';
+
+declare export const USED_BEFORE_DECLARATION: 'Referenced value is used before declaration.\n\n';
+
+declare export const UNINITIALIZED_CONST: 'Referenced constant is not initialized.\n\n';
+
+declare export const UNDEFINED_CONST: 'Referenced constant is not defined.';
+
+declare export const UNSUPPORTED_OPERATOR: (op: string) => string;
+
+declare export const OBJECT_METHOD: 'Unsupported object method.\n\n';
+
+declare export const UNSUPPORTED_EXPRESSION: (type: string) => string;

package/lib/utils/state-manager.d.ts

@@ -25,7 +25,7 @@ export type ImportPathResolution =
 type ModuleResolution =
   | Readonly<{
       type: 'commonJS';
-      rootDir?: string;
+      rootDir?: null | undefined | string;
       themeFileExtension?: null | undefined | string;
     }>
   | Readonly<{ type: 'haste'; themeFileExtension?: null | undefined | string }>
@@ -47,7 +47,7 @@ export type StyleXOptions = Readonly<
         | Readonly<{ from: string; as: string }>;
       treeshakeCompensation?: boolean;
       genConditionalClasses: boolean;
-      unstable_moduleResolution: null | undefined | ModuleResolution;
+      unstable_moduleResolution?: null | undefined | ModuleResolution;
       aliases?:
         | null
         | undefined
@@ -63,7 +63,7 @@ export type StyleXOptions = Readonly<
       | Readonly<{ from: string; as: string }>;
     treeshakeCompensation?: boolean;
     genConditionalClasses: boolean;
-    unstable_moduleResolution: null | undefined | ModuleResolution;
+    unstable_moduleResolution?: null | undefined | ModuleResolution;
     aliases?:
       | null
       | undefined

package/lib/utils/state-manager.js.flow

@@ -27,7 +27,7 @@ export type ImportPathResolution =
 type ModuleResolution =
   | $ReadOnly<{
       type: 'commonJS',
-      rootDir?: string,
+      rootDir?: ?string,
       themeFileExtension?: ?string,
     }>
   | $ReadOnly<{
@@ -48,7 +48,7 @@ export type StyleXOptions = $ReadOnly<{
   runtimeInjection: boolean | ?string | $ReadOnly<{ from: string, as: string }>,
   treeshakeCompensation?: boolean,
   genConditionalClasses: boolean,
-  unstable_moduleResolution: ?ModuleResolution,
+  unstable_moduleResolution?: ?ModuleResolution,
   aliases?: ?$ReadOnly<{ [string]: string | $ReadOnlyArray<string> }>,
   ...
 }>;

package/lib/visitors/stylex-create/parse-stylex-create-arg.d.ts

@@ -32,5 +32,6 @@ export declare function evaluateStyleXCreateArg(
   confident: boolean;
   value: any;
   deopt?: null | NodePath;
+  reason?: string;
   fns?: DynamicFns;
 }>;

package/lib/visitors/stylex-create/parse-stylex-create-arg.js.flow

@@ -36,5 +36,6 @@ declare export function evaluateStyleXCreateArg(
   confident: boolean,
   value: any,
   deopt?: null | NodePath<>,
+  reason?: string,
   fns?: DynamicFns,
 }>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stylexjs/babel-plugin",
-  "version": "0.10.0-beta.1",
+  "version": "0.10.0",
   "description": "StyleX babel plugin.",
   "main": "lib/index.js",
   "repository": "https://github.com/facebook/stylex",
@@ -14,12 +14,12 @@
   },
   "dependencies": {
     "@babel/helper-module-imports": "^7.22.15",
-    "@stylexjs/shared": "0.10.0-beta.1",
-    "@stylexjs/stylex": "0.10.0-beta.1",
+    "@stylexjs/shared": "0.10.0",
+    "@stylexjs/stylex": "0.10.0",
     "@babel/core": "^7.25.8",
     "@babel/traverse": "^7.25.7",
     "@babel/types": "^7.25.8",
-    "esm-resolve": "^1.0.11"
+    "@dual-bundle/import-meta-resolve": "^4.1.0"
   },
   "jest": {
     "verbose": true,