@stylexjs/babel-plugin 0.10.0-beta.2 → 0.10.1

package/flow_modules/@babel/traverse/index.js.flow

@@ -236,7 +236,7 @@ declare export class Binding {
 type _VisitorNodeKeys<S: object> = {
   +[K in keyof t._NodeMap]: ?VisitNode<S, t._NodeMap[K]>,
 };
-type _VistorAliases<S: object> = {
+type _VisitorAliases<S: object> = {
   +[K in keyof t.Aliases]: ?VisitNode<S, t.Aliases[K]>,
 };
 
@@ -244,7 +244,7 @@ export type Visitor<S: object = object> = $ReadOnly<
   Partial<{
     ...VisitNodeObject<S, Node>,
     ..._VisitorNodeKeys<S>,
-    ..._VistorAliases<S>,
+    ..._VisitorAliases<S>,
   }>,
 >;
 

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'),
@@ -1129,43 +1130,27 @@ function possibleAliasedPaths(importPath, aliases) {
   }
   return result;
 }
+const getPossibleFilePaths = filePath => {
+  const extension = path.extname(filePath);
+  const filePathHasCodeExtension = EXTENSIONS.includes(extension);
+  const filePathNoCodeExtension = filePathHasCodeExtension ? filePath.slice(0, -extension.length) : filePath;
+  return [filePath, ...EXTENSIONS.map(ext => filePathNoCodeExtension + ext)];
+};
 const filePathResolver = (relativeFilePath, sourceFilePath, aliases) => {
-  const esmResolve$1 = esmResolve.buildResolver(sourceFilePath);
-  for (const ext of ['', ...EXTENSIONS]) {
-    const importPathStr = relativeFilePath + ext;
+  for (const importPathStr of getPossibleFilePaths(relativeFilePath)) {
     if (importPathStr.startsWith('.')) {
       try {
-        return require.resolve(importPathStr, {
-          paths: [path.dirname(sourceFilePath)]
-        });
+        return url.fileURLToPath(importMetaResolve.moduleResolve(importPathStr, url.pathToFileURL(sourceFilePath)));
       } 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 url.fileURLToPath(importMetaResolve.moduleResolve(possiblePath, url.pathToFileURL(sourceFilePath)));
       } catch {
-        const resolved = esmResolve$1(importPathStr, {
-          allowImportingExtraExtensions: true
-        });
-        if (resolved) {
-          if (resolved.startsWith('.')) {
-            return path.resolve(path.dirname(sourceFilePath), resolved);
-          }
-          return resolved;
-        }
+        continue;
       }
     }
   }
@@ -1179,7 +1164,7 @@ const addFileExtension = (importedFilePath, sourceFile) => {
   const fileExtension = path.extname(sourceFile);
   return importedFilePath + fileExtension;
 };
-const matchesFileSuffix = allowedSuffix => filename => filename.endsWith(`${allowedSuffix}.js`) || filename.endsWith(`${allowedSuffix}.ts`) || filename.endsWith(`${allowedSuffix}.tsx`) || filename.endsWith(`${allowedSuffix}.jsx`) || filename.endsWith(`${allowedSuffix}.mjs`) || filename.endsWith(`${allowedSuffix}.cjs`) || filename.endsWith(allowedSuffix);
+const matchesFileSuffix = allowedSuffix => filename => ['', ...EXTENSIONS].some(extension => filename.endsWith(`${allowedSuffix}${extension}`));
 const getProgramPath = path => {
   let programPath = path;
   while (programPath != null && !isProgram(programPath)) {
@@ -1355,6 +1340,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 +1374,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 +1417,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 +1434,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 +1463,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 +1581,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 +1597,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 +1608,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 +1665,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 +1677,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 +1688,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 +1705,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 +1721,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 +1731,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 +1862,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 +1920,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 +1957,7 @@ function evaluate(path, traversalState) {
   return {
     confident: state.confident,
     deopt: state.deoptPath,
+    reason: state.deoptReason,
     value: value
   };
 }
@@ -3714,19 +3788,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;}`,
+          rtl: null
+        };
+      });
+    }
     let [compiledStyles, injectedStylesSansKeyframes, classPathsPerNamespace] = shared.create(plainObject, state.options);
     const injectedStyles = {
       ...injectedKeyframes,
-      ...injectedStylesSansKeyframes
+      ...injectedStylesSansKeyframes,
+      ...injectedInheritStyles
     };
     let varName = null;
     if (isVariableDeclarator(path.parentPath)) {
@@ -4902,18 +4990,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);
@@ -4998,36 +5110,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/imports.js.flow

@@ -11,7 +11,7 @@ import * as t from '../../flow_modules/@babel/types';
 import type { NodePath } from '../../flow_modules/@babel/traverse';
 import StateManager from '../utils/state-manager';
 
-// Read imports of react and remember the name of the local varsiables for later
+// Read imports of react and remember the name of the local variables for later
 declare export function readImportDeclarations(
   path: NodePath<t.ImportDeclaration>,
   state: StateManager,

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.2",
+  "version": "0.10.1",
   "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.2",
-    "@stylexjs/stylex": "0.10.0-beta.2",
+    "@stylexjs/shared": "0.10.1",
+    "@stylexjs/stylex": "0.10.1",
     "@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,