@stylexjs/babel-plugin 0.3.0 → 0.4.1

package/README.md

@@ -5,8 +5,6 @@ In addition to transforming JS code, this plugin also produces an Array of CSS r
 generated from all JS files within your project should be concatenated together and converted to a CSS
 file using the `processStyles` function which is also exported from the same module.
 
-(NOTE: StyleX only uses RTL-friendly logical values of `start` and `end` and disallows using `left` and `right` entirely.)
-
 `@stylexjs/babel-plugin` is fairly lightweight. It pre-computes `stylex` related functions like
 `stylex.create` and `stylex.keyframes` by converting the argument AST to a JS object and transforming them
 by passing them to the functions of the corresponding names within `@stylex/shared`
@@ -14,12 +12,12 @@ by passing them to the functions of the corresponding names within `@stylex/shar
 
 ## Babel Metadata
 
-The StyleX Babel plugin does more than transform JavaScript (or Typescript) files. It also returns a list of injected styles. The way that such a value can be returned while transforming a JS file is by using Babel's `metadata` API.
+The StyleX Babel plugin does more than transform JavaScript (or TypeScript) files. It also returns a list of injected styles. The way that such a value can be returned while transforming a JS file is by using Babel's `metadata` API.
 
 An example of this can be seen in some of the tests, but the result of using Babel's `transform(...)` function returns an object contains at least two keys:
 
 1. `code` which is the transformed JS code
-2. `metadata` is an object of metatdata that the plugin may want to return as a side-effect.
+2. `metadata` is an object of metadata that the plugin may want to return as a side-effect.
 
 e.g.
 

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

@@ -301,14 +301,14 @@ export interface TransformOptions {
    *
    * Default: `[]`
    */
-  plugins?: ?Array<PluginItem>;
+  plugins?: ?$ReadOnlyArray<PluginItem>;
 
   /**
    * List of presets (a set of plugins) to load and use
    *
    * Default: `[]`
    */
-  presets?: ?Array<PluginItem>;
+  presets?: ?$ReadOnlyArray<PluginItem>;
 
   /**
    * Retain line numbers. This will lead to wacky code but is handy for scenarios where you can't use source maps. (**NOTE**: This will not retain the columns)
@@ -685,19 +685,19 @@ export interface ConfigItem {
   };
 }
 
-export type PluginOptions = { [string]: mixed } | void | false;
+export type PluginOptions = $ReadOnly<{ [string]: mixed }> | void | false;
 
 export type PluginTarget =
   | string
-  | { [string]: mixed }
+  | $ReadOnly<{ [string]: mixed }>
   | ((...args: any[]) => any);
 
 export type PluginItem =
   | ConfigItem
   | PluginObj<any>
   | PluginTarget
-  | [PluginTarget, PluginOptions]
-  | [PluginTarget, PluginOptions, string | void];
+  | $ReadOnly<[PluginTarget, PluginOptions]>
+  | $ReadOnly<[PluginTarget, PluginOptions, string | void]>;
 
 declare export function resolvePlugin(
   name: string,

package/flow_modules/@babel/helper-module-imports/index.js.flow

@@ -0,0 +1,182 @@
+/**
+ * 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
+ */
+
+import * as t from '../types';
+import type { NodePath } from '@babel/traverse';
+
+export type ImportOptions = $ReadOnly<{
+  /**
+   * The module being referenced.
+   */
+  importedSource: string | null,
+  /**
+   * The type of module being imported:
+   *
+   *  * 'es6'      - An ES6 module.
+   *  * 'commonjs' - A CommonJS module. (Default)
+   */
+  importedType: 'es6' | 'commonjs',
+  /**
+   * The type of interop behavior for namespace/default/named when loading
+   * CommonJS modules.
+   *
+   * ## 'babel' (Default)
+   *
+   * Load using Babel's interop.
+   *
+   * If '.__esModule' is true, treat as 'compiled', else:
+   *
+   * * Namespace: A copy of the module.exports with .default
+   *     populated by the module.exports object.
+   * * Default: The module.exports value.
+   * * Named: The .named property of module.exports.
+   *
+   * The 'ensureLiveReference' has no effect on the liveness of these.
+   *
+   * ## 'compiled'
+   *
+   * Assume the module is ES6 compiled to CommonJS. Useful to avoid injecting
+   * interop logic if you are confident that the module is a certain format.
+   *
+   * * Namespace: The root module.exports object.
+   * * Default: The .default property of the namespace.
+   * * Named: The .named property of the namespace.
+   *
+   * Will return erroneous results if the imported module is _not_ compiled
+   * from ES6 with Babel.
+   *
+   * ## 'uncompiled'
+   *
+   * Assume the module is _not_ ES6 compiled to CommonJS. Used a simplified
+   * access pattern that doesn't require additional function calls.
+   *
+   * Will return erroneous results if the imported module _is_ compiled
+   * from ES6 with Babel.
+   *
+   * * Namespace: The module.exports object.
+   * * Default: The module.exports object.
+   * * Named: The .named property of module.exports.
+   */
+  importedInterop: 'babel' | 'node' | 'compiled' | 'uncompiled',
+  /**
+   * The type of CommonJS interop included in the environment that will be
+   * loading the output code.
+   *
+   *  * 'babel' - CommonJS modules load with Babel's interop. (Default)
+   *  * 'node'  - CommonJS modules load with Node's interop.
+   *
+   * See descriptions in 'importedInterop' for more details.
+   */
+  importingInterop: 'babel' | 'node',
+  /**
+   * Define whether we explicitly care that the import be a live reference.
+   * Only applies when importing default and named imports, not the namespace.
+   *
+   *  * true  - Force imported values to be live references.
+   *  * false - No particular requirements. Keeps the code simplest. (Default)
+   */
+  ensureLiveReference: boolean,
+  /**
+   * Define if we explicitly care that the result not be a property reference.
+   *
+   *  * true  - Force calls to exclude context. Useful if the value is going to
+   *            be used as function callee.
+   *  * false - No particular requirements for context of the access. (Default)
+   */
+  ensureNoContext: boolean,
+  /**
+   * Define whether the import should be loaded before or after the existing imports.
+   * "after" is only allowed inside ECMAScript modules, since it's not possible to
+   * reliably pick the location _after_ require() calls but _before_ other code in CJS.
+   */
+  importPosition: 'before' | 'after',
+
+  nameHint?: string,
+  blockHoist?: number,
+}>;
+
+declare export function addDefault(
+  path: NodePath<>,
+  importedSource: string,
+  opts?: Partial<ImportOptions>,
+): t.Identifier;
+
+/**
+ * add a named import to the program path of given path
+ *
+ * @param path The starting path to find a program path
+ * @param name The name of the generated binding. Babel will prefix it with `_`
+ * @param importedSource The source of the import
+ * @param [opts]
+ * @returns If opts.ensureNoContext is true, returns a SequenceExpression,
+ *   else if opts.ensureLiveReference is true, returns a MemberExpression, else returns an Identifier
+ */
+declare export const addNamed: (
+  path: NodePath<>,
+  name: string,
+  importedSource: string,
+  opts?: Omit<
+    Partial<ImportOptions>,
+    'ensureLiveReference' | 'ensureNoContext',
+  >,
+) => t.Identifier;
+
+// declare export function addNamed(
+//     path: NodePath<>,
+//     name: string,
+//     importedSource: string,
+//     opts?: Omit<Partial<ImportOptions>, "ensureLiveReference"> & {
+//         ensureLiveReference: true;
+//     },
+// ): t.MemberExpression;
+// declare export function addNamed(
+//     path: NodePath,
+//     name: string,
+//     importedSource: string,
+//     opts?: Omit<Partial<ImportOptions>, "ensureNoContext"> & {
+//         ensureNoContext: true;
+//     },
+// ): t.SequenceExpression;
+
+declare export function addNamespace(
+  path: NodePath<>,
+  importedSource: string,
+  opts?: Partial<ImportOptions>,
+): t.Identifier;
+
+// declare export function addSideEffect(
+//   path: NodePath<>,
+//   importedSource: string,
+//   opts?: Partial<ImportOptions>,
+// ): void;
+
+declare export function isModule(path: NodePath<t.Program>): boolean;
+
+// declare export class ImportInjector {
+//   constructor(
+//     path: NodePath<>,
+//     importedSource?: string,
+//     opts?: Partial<ImportOptions>,
+//   ): ImportInjector;
+
+//   addDefault(
+//     importedSourceIn: string,
+//     opts: Partial<ImportOptions>,
+//   ): t.Identifier;
+//   addNamed(
+//     importName: string,
+//     importedSourceIn: string,
+//     opts: Partial<ImportOptions>,
+//   ): t.Identifier;
+//   addNamespace(
+//     importedSourceIn: string,
+//     opts: Partial<ImportOptions>,
+//   ): t.Identifier;
+//   addSideEffect(importedSourceIn: string, opts: Partial<ImportOptions>): void;
+// }

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

@@ -3,6 +3,7 @@
  *
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
+ *
  * @flow strict
  */
 
@@ -307,8 +308,8 @@ declare export class NodePath<+T: Node = Node> {
   type: T extends null | void
     ? void
     : T extends Node
-    ? T['type']
-    : string | void;
+      ? T['type']
+      : string | void;
 
   typeAnnotation: { ... };
 
@@ -996,7 +997,7 @@ export type NodePathResult<T: Node | $ReadOnlyArray<Node>> =
   T extends $ReadOnlyArray<infer TNode>
     ? $ReadOnlyArray<NodePath<TNode>>
     : T extends null | void
-    ? void
-    : T extends Node
-    ? NodePath<T>
-    : T;
+      ? void
+      : T extends Node
+        ? NodePath<T>
+        : T;

package/lib/index.d.ts

@@ -14,12 +14,14 @@ export type Options = StyleXOptions;
  * Entry point for the StyleX babel plugin.
  */
 declare function styleXTransform(): PluginObj;
-export default styleXTransform;
+declare function stylexPluginWithOptions(
+  options: Partial<StyleXOptions>,
+): [typeof styleXTransform, Partial<StyleXOptions>];
 /**
  *
  * @param rules An array of CSS rules that has been generated and collected from all JS files
  * in a project
- * @returns A string that represets the final CSS file.
+ * @returns A string that represents the final CSS file.
  *
  * This function take an Array of CSS rules, de-duplicates them, sorts them priority and generates
  * a final CSS file.
@@ -31,3 +33,14 @@ export default styleXTransform;
  * End-users can choose to not use this function and use their own logic instead.
  */
 export type Rule = [string, { ltr: string; rtl?: null | string }, number];
+declare function processStylexRules(
+  rules: Array<Rule>,
+  useLayers: boolean,
+): string;
+export type StyleXTransformObj = Readonly<{
+  (): PluginObj;
+  withOptions: typeof stylexPluginWithOptions;
+  processStylexRules: typeof processStylexRules;
+}>;
+declare const $$EXPORT_DEFAULT_DECLARATION$$: StyleXTransformObj;
+export default $$EXPORT_DEFAULT_DECLARATION$$;