@stylexjs/babel-plugin 0.0.0-6e16619c

package/lib/utils/helpers.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 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 function removeNulls<T>(
+  arr: Array<null | undefined | T>,
+): Array<T>;

package/lib/utils/helpers.js.flow

@@ -0,0 +1,10 @@
+/**
+ * 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 function removeNulls<T>(arr: Array<?T>): Array<T>;

package/lib/utils/js-to-ast.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ *
+ *
+ */
+
+import type { FlatCompiledStyles } from '../shared/common-types';
+import * as t from '@babel/types';
+type NestedStringObject = Readonly<{
+  [key: string]: string | number | null | boolean | NestedStringObject;
+}>;
+export declare function convertObjectToAST(
+  obj: NestedStringObject,
+): t.ObjectExpression;
+export declare function removeObjectsWithSpreads(obj: {
+  readonly [$$Key$$: string]: FlatCompiledStyles;
+}): { readonly [$$Key$$: string]: FlatCompiledStyles };

package/lib/utils/js-to-ast.js.flow

@@ -0,0 +1,24 @@
+/**
+ * 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 type { FlatCompiledStyles } from '../shared/common-types';
+
+import * as t from '../../flow_modules/@babel/types';
+
+type NestedStringObject = $ReadOnly<{
+  [key: string]: string | number | null | boolean | NestedStringObject,
+}>;
+
+declare export function convertObjectToAST(
+  obj: NestedStringObject,
+): t.ObjectExpression;
+
+declare export function removeObjectsWithSpreads(obj: {
+  +[string]: FlatCompiledStyles,
+}): { +[string]: FlatCompiledStyles };

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

@@ -0,0 +1,203 @@
+/**
+ * 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.
+ *
+ *
+ */
+
+import type { PluginPass } from '@babel/core';
+import type { NodePath } from '@babel/traverse';
+import type {
+  CompiledNamespaces,
+  StyleXOptions as RuntimeOptions,
+} from '../shared';
+import * as t from '@babel/types';
+export type ImportPathResolution =
+  | false
+  | ['themeNameRef' | 'filePath', string];
+type ModuleResolution =
+  | Readonly<{
+      type: 'commonJS';
+      rootDir?: null | undefined | string;
+      themeFileExtension?: null | undefined | string;
+    }>
+  | Readonly<{ type: 'haste'; themeFileExtension?: null | undefined | string }>
+  | Readonly<{
+      type: 'experimental_crossFileParsing';
+      rootDir?: string;
+      themeFileExtension?: null | undefined | string;
+    }>;
+export type StyleXOptions = Readonly<
+  Omit<
+    RuntimeOptions,
+    keyof ({
+      aliases?:
+        | null
+        | undefined
+        | Readonly<{ [$$Key$$: string]: string | ReadonlyArray<string> }>;
+      enableDebugClassNames?: boolean;
+      enableDebugDataProp?: boolean;
+      enableDevClassNames?: boolean;
+      enableInlinedConditionalMerge?: boolean;
+      enableMediaQueryOrder?: boolean;
+      enableLegacyValueFlipping?: boolean;
+      enableLogicalStylesPolyfill?: boolean;
+      enableMinifiedKeys?: boolean;
+      importSources: ReadonlyArray<
+        string | Readonly<{ from: string; as: string }>
+      >;
+      rewriteAliases?: boolean;
+      runtimeInjection:
+        | boolean
+        | (null | undefined | string)
+        | Readonly<{ from: string; as: string }>;
+      treeshakeCompensation?: boolean;
+      unstable_moduleResolution?: null | undefined | ModuleResolution;
+    })
+  > & {
+    aliases?:
+      | null
+      | undefined
+      | Readonly<{ [$$Key$$: string]: string | ReadonlyArray<string> }>;
+    enableDebugClassNames?: boolean;
+    enableDebugDataProp?: boolean;
+    enableDevClassNames?: boolean;
+    enableInlinedConditionalMerge?: boolean;
+    enableMediaQueryOrder?: boolean;
+    enableLegacyValueFlipping?: boolean;
+    enableLogicalStylesPolyfill?: boolean;
+    enableMinifiedKeys?: boolean;
+    importSources: ReadonlyArray<
+      string | Readonly<{ from: string; as: string }>
+    >;
+    rewriteAliases?: boolean;
+    runtimeInjection:
+      | boolean
+      | (null | undefined | string)
+      | Readonly<{ from: string; as: string }>;
+    treeshakeCompensation?: boolean;
+    unstable_moduleResolution?: null | undefined | ModuleResolution;
+  }
+>;
+type StyleXStateOptions = Readonly<
+  Omit<
+    StyleXOptions,
+    keyof ({
+      runtimeInjection:
+        | (null | undefined | string)
+        | Readonly<{ from: string; as: null | undefined | string }>;
+      aliases?:
+        | null
+        | undefined
+        | Readonly<{ [$$Key$$: string]: ReadonlyArray<string> }>;
+      rewriteAliases: boolean;
+    })
+  > & {
+    runtimeInjection:
+      | (null | undefined | string)
+      | Readonly<{ from: string; as: null | undefined | string }>;
+    aliases?:
+      | null
+      | undefined
+      | Readonly<{ [$$Key$$: string]: ReadonlyArray<string> }>;
+    rewriteAliases: boolean;
+  }
+>;
+declare class StateManager {
+  readonly _state: PluginPass;
+  readonly importPaths: Set<string>;
+  readonly stylexImport: Set<string>;
+  readonly stylexPropsImport: Set<string>;
+  readonly stylexAttrsImport: Set<string>;
+  readonly stylexCreateImport: Set<string>;
+  readonly stylexIncludeImport: Set<string>;
+  readonly stylexFirstThatWorksImport: Set<string>;
+  readonly stylexKeyframesImport: Set<string>;
+  readonly stylexPositionTryImport: Set<string>;
+  readonly stylexDefineVarsImport: Set<string>;
+  readonly stylexDefineConstsImport: Set<string>;
+  readonly stylexCreateThemeImport: Set<string>;
+  readonly stylexTypesImport: Set<string>;
+  readonly stylexViewTransitionClassImport: Set<string>;
+  injectImportInserted: null | undefined | t.Identifier;
+  readonly styleMap: Map<string, CompiledNamespaces>;
+  readonly styleVars: Map<string, NodePath>;
+  readonly styleVarsToKeep: Set<[string, true | string, true | Array<string>]>;
+  inStyleXCreate: boolean;
+  readonly options: StyleXStateOptions;
+  constructor(state: PluginPass);
+  setOptions(options: {
+    readonly [$$Key$$: string]: unknown;
+  }): StyleXStateOptions;
+  get importPathString(): string;
+  get importSources(): ReadonlyArray<string>;
+  importAs(source: string): null | string;
+  get canReferenceTheme(): boolean;
+  get metadata(): { [key: string]: any };
+  get runtimeInjection():
+    | null
+    | undefined
+    | Readonly<{ from: string; as?: null | undefined | string }>;
+  get opts(): StyleXStateOptions;
+  get isDebug(): boolean;
+  get isDev(): boolean;
+  get isTest(): boolean;
+  get filename(): string | void;
+  get cssVars(): any;
+  get treeshakeCompensation(): boolean;
+  get fileNameForHashing(): null | string;
+  getPackageNameAndPath(
+    filepath: string,
+  ): null | readonly [packageName: string, packageDir: string];
+  getCanonicalFilePath(filePath: string): string;
+  importPathResolver(importPath: string): ImportPathResolution;
+  addStyle(
+    style: [
+      string,
+      (
+        | { ltr: string; rtl?: string | null }
+        | {
+            constKey: string;
+            constVal: string | number;
+            rtl?: string | null;
+            ltr: string;
+          }
+      ),
+      number,
+    ],
+  ): void;
+  registerStyles(
+    styles: ReadonlyArray<
+      [
+        string,
+        (
+          | { ltr: string; rtl?: string | null }
+          | {
+              constKey: string;
+              constVal: string | number;
+              rtl?: string | null;
+              ltr: string;
+            }
+        ),
+        number,
+      ]
+    >,
+    path?: null | undefined | NodePath,
+  ): void;
+  markComposedNamespace(
+    memberExpression: [string, true | string, true | Array<string>],
+  ): void;
+}
+export default StateManager;
+export declare const filePathResolver: (
+  relativeFilePath: string,
+  sourceFilePath: string,
+  aliases: StyleXStateOptions['aliases'],
+) => null | undefined | string;
+export declare const EXTENSIONS: any;
+export declare const matchesFileSuffix: (
+  $$PARAM_0$$: string,
+) => ($$PARAM_0$$: string) => boolean;
+export declare function getRelativePath(from: string, to: string): string;

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

@@ -0,0 +1,159 @@
+/**
+ * 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 type { PluginPass } from '../../flow_modules/@babel/core';
+import type { NodePath } from '../../flow_modules/@babel/traverse';
+import type {
+  CompiledNamespaces,
+  StyleXOptions as RuntimeOptions,
+} from '../shared';
+import * as t from '../../flow_modules/@babel/types';
+export type ImportPathResolution =
+  | false
+  | ['themeNameRef' | 'filePath', string];
+
+type ModuleResolution =
+  | $ReadOnly<{
+      type: 'commonJS',
+      rootDir?: ?string,
+      themeFileExtension?: ?string,
+    }>
+  | $ReadOnly<{
+      type: 'haste',
+      themeFileExtension?: ?string,
+    }>
+  | $ReadOnly<{
+      type: 'experimental_crossFileParsing',
+      rootDir?: string,
+      themeFileExtension?: ?string,
+    }>;
+
+export type StyleXOptions = $ReadOnly<{
+  ...RuntimeOptions,
+  aliases?: ?$ReadOnly<{ [string]: string | $ReadOnlyArray<string> }>,
+  enableDebugClassNames?: boolean,
+  enableDebugDataProp?: boolean,
+  enableDevClassNames?: boolean,
+  enableInlinedConditionalMerge?: boolean,
+  enableMediaQueryOrder?: boolean,
+  enableLegacyValueFlipping?: boolean,
+  enableLogicalStylesPolyfill?: boolean,
+  enableMinifiedKeys?: boolean,
+  importSources: $ReadOnlyArray<
+    string | $ReadOnly<{ from: string, as: string }>,
+  >,
+  rewriteAliases?: boolean,
+  runtimeInjection: boolean | ?string | $ReadOnly<{ from: string, as: string }>,
+  treeshakeCompensation?: boolean,
+  unstable_moduleResolution?: ?ModuleResolution,
+  ...
+}>;
+
+type StyleXStateOptions = $ReadOnly<{
+  ...StyleXOptions,
+  runtimeInjection: ?string | $ReadOnly<{ from: string, as: ?string }>,
+  aliases?: ?$ReadOnly<{ [string]: $ReadOnlyArray<string> }>,
+  rewriteAliases: boolean,
+  ...
+}>;
+
+declare export default class StateManager {
+  +_state: PluginPass;
+  +importPaths: Set<string>;
+  +stylexImport: Set<string>;
+  +stylexPropsImport: Set<string>;
+  +stylexAttrsImport: Set<string>;
+  +stylexCreateImport: Set<string>;
+  +stylexIncludeImport: Set<string>;
+  +stylexFirstThatWorksImport: Set<string>;
+  +stylexKeyframesImport: Set<string>;
+  +stylexPositionTryImport: Set<string>;
+  +stylexDefineVarsImport: Set<string>;
+  +stylexDefineConstsImport: Set<string>;
+  +stylexCreateThemeImport: Set<string>;
+  +stylexTypesImport: Set<string>;
+  +stylexViewTransitionClassImport: Set<string>;
+  injectImportInserted: ?t.Identifier;
+  +styleMap: Map<string, CompiledNamespaces>;
+  +styleVars: Map<string, NodePath<>>;
+  +styleVarsToKeep: Set<[string, true | string, true | Array<string>]>;
+  inStyleXCreate: boolean;
+  +options: StyleXStateOptions;
+  constructor(state: PluginPass): void;
+  setOptions(options: { +[string]: mixed }): StyleXStateOptions;
+  get importPathString(): string;
+  get importSources(): $ReadOnlyArray<string>;
+  importAs(source: string): null | string;
+  get canReferenceTheme(): boolean;
+  get metadata(): { [key: string]: any };
+  get runtimeInjection(): ?$ReadOnly<{ from: string, as?: ?string }>;
+  get opts(): StyleXStateOptions;
+  get isDebug(): boolean;
+  get isDev(): boolean;
+  get isTest(): boolean;
+  get filename(): string | void;
+  get cssVars(): any;
+  get treeshakeCompensation(): boolean;
+  get fileNameForHashing(): null | string;
+  getPackageNameAndPath(
+    filepath: string,
+  ): null | [+packageName: string, +packageDir: string];
+  getCanonicalFilePath(filePath: string): string;
+  importPathResolver(importPath: string): ImportPathResolution;
+  addStyle(
+    style: [
+      string,
+      (
+        | { ltr: string, rtl?: string | null }
+        | {
+            constKey: string,
+            constVal: string | number,
+            rtl?: string | null,
+            ltr: string,
+          }
+      ),
+      number,
+    ],
+  ): void;
+  registerStyles(
+    styles: $ReadOnlyArray<
+      [
+        string,
+        (
+          | { ltr: string, rtl?: string | null }
+          | {
+              constKey: string,
+              constVal: string | number,
+              rtl?: string | null,
+              ltr: string,
+            }
+        ),
+        number,
+      ],
+    >,
+    path?: ?NodePath<>,
+  ): void;
+  markComposedNamespace(
+    memberExpression: [string, true | string, true | Array<string>],
+  ): void;
+}
+
+// a function that resolves the absolute path of a file when given the
+// relative path of the file from the source file
+declare export const filePathResolver: (
+  relativeFilePath: string,
+  sourceFilePath: string,
+  aliases: StyleXStateOptions['aliases'],
+) => ?string;
+
+declare export const EXTENSIONS: $FlowFixMe;
+
+declare export const matchesFileSuffix: (string) => (string) => boolean;
+
+declare export function getRelativePath(from: string, to: string): string;

package/lib/utils/validate.d.ts

@@ -0,0 +1,68 @@
+/**
+ * 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 type Check<T> = (val: unknown, name?: string) => Error | T;
+export type InferCheckType<T> =
+  T extends Check<infer U>
+    ? U
+    : /**
+       * > 11 | export type InferCheckType<T> = T extends Check<infer U> ? U : empty;
+       *      |                                                                ^^^^^ Unsupported feature: Translating "empty type" is currently not supported.
+       **/
+      any;
+type Msg = (value: unknown, name?: string) => string;
+type PrimitiveChecker<T> = (message?: Msg) => Check<T>;
+export declare const string: PrimitiveChecker<string>;
+export declare const nullish: PrimitiveChecker<null | void>;
+export declare const boolean: PrimitiveChecker<boolean>;
+export declare const number: PrimitiveChecker<number>;
+export declare const literal: <T extends string | number | boolean>(
+  $$PARAM_0$$: T,
+  msg?: Msg,
+) => Check<T>;
+export declare const array: <T>(
+  $$PARAM_0$$: Check<T>,
+  msg?: Msg,
+) => Check<ReadonlyArray<T>>;
+type ObjOfChecks<T extends { readonly [$$Key$$: string]: Check<unknown> }> =
+  Readonly<{ [K in keyof T]: InferCheckType<T[K]> }>;
+export declare const object: <
+  T extends { readonly [$$Key$$: string]: Check<unknown> },
+>(
+  $$PARAM_0$$: T,
+  msg?: Msg,
+) => Check<ObjOfChecks<T>>;
+export declare const objectOf: <T>(
+  $$PARAM_0$$: Check<T>,
+  message?: Msg,
+) => Check<{ readonly [$$Key$$: string]: T }>;
+export declare const unionOf: <A, B>(
+  a: Check<A>,
+  b: Check<B>,
+  message: Msg,
+) => Check<A | B>;
+export declare const unionOf3: <A, B, C>(
+  a: Check<A>,
+  b: Check<B>,
+  c: Check<C>,
+  message: Msg,
+) => Check<A | B | C>;
+export declare const unionOf4: <A, B, C, D>(
+  a: Check<A>,
+  b: Check<B>,
+  c: Check<C>,
+  d: Check<D>,
+  message: Msg,
+) => Check<A | B | C | D>;
+export declare const logAndDefault: <T>(
+  check: Check<T>,
+  value: unknown,
+  def: T,
+  name?: string,
+) => T;

package/lib/utils/validate.js.flow

@@ -0,0 +1,74 @@
+/**
+ * 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
+ */
+
+export type Check<+T> = (val: mixed, name?: string) => Error | T;
+export type InferCheckType<T> = T extends Check<infer U> ? U : empty;
+
+type Msg = (value: mixed, name?: string) => string;
+type PrimitiveChecker<+T> = (message?: Msg) => Check<T>;
+
+declare export const string: PrimitiveChecker<string>;
+
+declare export const nullish: PrimitiveChecker<null | void>;
+
+declare export const boolean: PrimitiveChecker<boolean>;
+
+declare export const number: PrimitiveChecker<number>;
+
+declare export const literal: <T: string | number | boolean>(
+  T,
+  msg?: Msg,
+) => Check<T>;
+
+declare export const array: <T>(
+  Check<T>,
+  msg?: Msg,
+) => Check<$ReadOnlyArray<T>>;
+
+type ObjOfChecks<T: { +[string]: Check<mixed> }> = $ReadOnly<{
+  [K in keyof T]: InferCheckType<T[K]>,
+}>;
+
+declare export const object: <T: { +[string]: Check<mixed> }>(
+  T,
+  msg?: Msg,
+) => Check<ObjOfChecks<T>>;
+
+declare export const objectOf: <T>(
+  Check<T>,
+  message?: Msg,
+) => Check<{ +[string]: T }>;
+
+declare export const unionOf: <A, B>(
+  a: Check<A>,
+  b: Check<B>,
+  message: Msg,
+) => Check<A | B>;
+
+declare export const unionOf3: <A, B, C>(
+  a: Check<A>,
+  b: Check<B>,
+  c: Check<C>,
+  message: Msg,
+) => Check<A | B | C>;
+
+declare export const unionOf4: <A, B, C, D>(
+  a: Check<A>,
+  b: Check<B>,
+  c: Check<C>,
+  d: Check<D>,
+  message: Msg,
+) => Check<A | B | C | D>;
+
+declare export const logAndDefault: <T>(
+  check: Check<T>,
+  value: mixed,
+  def: T,
+  name?: string,
+) => T;

package/lib/visitors/imports.d.ts

@@ -0,0 +1,20 @@
+/**
+ * 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.
+ *
+ *
+ */
+
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import StateManager from '../utils/state-manager';
+export declare function readImportDeclarations(
+  path: NodePath<t.ImportDeclaration>,
+  state: StateManager,
+): void;
+export declare function readRequires(
+  path: NodePath<t.VariableDeclarator>,
+  state: StateManager,
+): void;

package/lib/visitors/imports.js.flow

@@ -0,0 +1,25 @@
+/**
+ * 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 type { NodePath } from '../../flow_modules/@babel/traverse';
+
+import * as t from '../../flow_modules/@babel/types';
+import StateManager from '../utils/state-manager';
+
+// Read imports of react and remember the name of the local variables for later
+declare export function readImportDeclarations(
+  path: NodePath<t.ImportDeclaration>,
+  state: StateManager,
+): void;
+
+// Read require calls and remember the names of the variables for later
+declare export function readRequires(
+  path: NodePath<t.VariableDeclarator>,
+  state: StateManager,
+): void;

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

@@ -0,0 +1,37 @@
+/**
+ * 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.
+ *
+ *
+ */
+
+import type { NodePath } from '@babel/traverse';
+import type { FunctionConfig } from '../utils/evaluate-path';
+import * as t from '@babel/types';
+import StateManager from '../utils/state-manager';
+type TInlineStyles = {
+  [$$Key$$: string]: {
+    readonly path: ReadonlyArray<string>;
+    readonly originalExpression: t.Expression;
+    readonly expression: t.Expression | t.PatternLike;
+  };
+};
+type DynamicFns = {
+  [$$Key$$: string]: readonly [
+    params: Array<t.Identifier>,
+    inlineStyles: Readonly<TInlineStyles>,
+  ];
+};
+export declare function evaluateStyleXCreateArg(
+  path: NodePath,
+  traversalState: StateManager,
+  functions: FunctionConfig,
+): Readonly<{
+  confident: boolean;
+  value: any;
+  deopt?: null | NodePath;
+  reason?: string;
+  fns?: DynamicFns;
+}>;