babel-plugin-react-compiler 19.0.0-beta-bafa41b-20250307 → 19.0.0-beta-aeaed83-20250323

package/dist/index.d.ts

@@ -4,6 +4,65 @@ import * as t from '@babel/types';
 import { z } from 'zod';
 import { Scope, NodePath } from '@babel/traverse';
 
+interface Result<T, E> {
+    map<U>(fn: (val: T) => U): Result<U, E>;
+    mapErr<F>(fn: (val: E) => F): Result<T, F>;
+    mapOr<U>(fallback: U, fn: (val: T) => U): U;
+    mapOrElse<U>(fallback: () => U, fn: (val: T) => U): U;
+    andThen<U>(fn: (val: T) => Result<U, E>): Result<U, E>;
+    and<U>(res: Result<U, E>): Result<U, E>;
+    or(res: Result<T, E>): Result<T, E>;
+    orElse<F>(fn: (val: E) => Result<T, F>): Result<T, F>;
+    isOk(): this is OkImpl<T>;
+    isErr(): this is ErrImpl<E>;
+    expect(msg: string): T;
+    expectErr(msg: string): E;
+    unwrap(): T;
+    unwrapOr(fallback: T): T;
+    unwrapOrElse(fallback: (val: E) => T): T;
+    unwrapErr(): E;
+}
+declare class OkImpl<T> implements Result<T, never> {
+    private val;
+    constructor(val: T);
+    map<U>(fn: (val: T) => U): Result<U, never>;
+    mapErr<F>(_fn: (val: never) => F): Result<T, F>;
+    mapOr<U>(_fallback: U, fn: (val: T) => U): U;
+    mapOrElse<U>(_fallback: () => U, fn: (val: T) => U): U;
+    andThen<U>(fn: (val: T) => Result<U, never>): Result<U, never>;
+    and<U>(res: Result<U, never>): Result<U, never>;
+    or(_res: Result<T, never>): Result<T, never>;
+    orElse<F>(_fn: (val: never) => Result<T, F>): Result<T, F>;
+    isOk(): this is OkImpl<T>;
+    isErr(): this is ErrImpl<never>;
+    expect(_msg: string): T;
+    expectErr(msg: string): never;
+    unwrap(): T;
+    unwrapOr(_fallback: T): T;
+    unwrapOrElse(_fallback: (val: never) => T): T;
+    unwrapErr(): never;
+}
+declare class ErrImpl<E> implements Result<never, E> {
+    private val;
+    constructor(val: E);
+    map<U>(_fn: (val: never) => U): Result<U, E>;
+    mapErr<F>(fn: (val: E) => F): Result<never, F>;
+    mapOr<U>(fallback: U, _fn: (val: never) => U): U;
+    mapOrElse<U>(fallback: () => U, _fn: (val: never) => U): U;
+    andThen<U>(_fn: (val: never) => Result<U, E>): Result<U, E>;
+    and<U>(_res: Result<U, E>): Result<U, E>;
+    or(res: Result<never, E>): Result<never, E>;
+    orElse<F>(fn: (val: E) => ErrImpl<F>): Result<never, F>;
+    isOk(): this is OkImpl<never>;
+    isErr(): this is ErrImpl<E>;
+    expect(msg: string): never;
+    expectErr(_msg: string): E;
+    unwrap(): never;
+    unwrapOr<T>(fallback: T): T;
+    unwrapOrElse<T>(fallback: (val: E) => T): T;
+    unwrapErr(): E;
+}
+
 type BuiltInType = PrimitiveType | FunctionType | ObjectType;
 type Type = BuiltInType | PhiType | TypeVar | PolyType | PropType | ObjectMethod$1;
 type PrimitiveType = {
@@ -13,6 +72,7 @@ type FunctionType = {
     kind: 'Function';
     shapeId: string | null;
     return: Type;
+    isConstructor: boolean;
 };
 type ObjectType = {
     kind: 'Object';
@@ -33,7 +93,13 @@ type PropType = {
     kind: 'Property';
     objectType: Type;
     objectName: string;
-    propertyName: PropertyLiteral;
+    propertyName: {
+        kind: 'literal';
+        value: PropertyLiteral;
+    } | {
+        kind: 'computed';
+        value: Type;
+    };
 };
 type ObjectMethod$1 = {
     kind: 'ObjectMethod';
@@ -71,6 +137,7 @@ declare const ExternalFunctionSchema: z.ZodObject<{
     importSpecifierName: string;
 }>;
 type ExternalFunction = z.infer<typeof ExternalFunctionSchema>;
+type CompilerMode = 'all_features' | 'no_inferred_memo';
 declare const HookSchema: z.ZodObject<{
     effectKind: z.ZodNativeEnum<typeof Effect>;
     valueKind: z.ZodNativeEnum<typeof ValueKind>;
@@ -170,6 +237,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoSetStateInRender: z.ZodDefault<z.ZodBoolean>;
     validateNoSetStateInPassiveEffects: z.ZodDefault<z.ZodBoolean>;
     validateNoJSXInTryStatements: z.ZodDefault<z.ZodBoolean>;
+    validateStaticComponents: z.ZodDefault<z.ZodBoolean>;
     validateMemoizedEffectDependencies: z.ZodDefault<z.ZodBoolean>;
     validateNoCapitalizedCalls: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
     validateBlocklistedImports: z.ZodDefault<z.ZodNullable<z.ZodArray<z.ZodString, "many">>>;
@@ -268,7 +336,6 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     throwUnknownException__testonly: z.ZodDefault<z.ZodBoolean>;
     enableTreatFunctionDepsAsConditional: z.ZodDefault<z.ZodBoolean>;
     disableMemoizationForDebugging: z.ZodDefault<z.ZodBoolean>;
-    enableMinimalTransformsForRetry: z.ZodDefault<z.ZodBoolean>;
     enableChangeDetectionForDebugging: z.ZodDefault<z.ZodNullable<z.ZodObject<{
         source: z.ZodString;
         importSpecifierName: z.ZodString;
@@ -330,6 +397,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoSetStateInRender: boolean;
     validateNoSetStateInPassiveEffects: boolean;
     validateNoJSXInTryStatements: boolean;
+    validateStaticComponents: boolean;
     validateMemoizedEffectDependencies: boolean;
     validateNoCapitalizedCalls: string[] | null;
     validateBlocklistedImports: string[] | null;
@@ -364,7 +432,6 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     throwUnknownException__testonly: boolean;
     enableTreatFunctionDepsAsConditional: boolean;
     disableMemoizationForDebugging: boolean;
-    enableMinimalTransformsForRetry: boolean;
     enableChangeDetectionForDebugging: {
         source: string;
         importSpecifierName: string;
@@ -414,6 +481,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoSetStateInRender?: boolean | undefined;
     validateNoSetStateInPassiveEffects?: boolean | undefined;
     validateNoJSXInTryStatements?: boolean | undefined;
+    validateStaticComponents?: boolean | undefined;
     validateMemoizedEffectDependencies?: boolean | undefined;
     validateNoCapitalizedCalls?: string[] | null | undefined;
     validateBlocklistedImports?: string[] | null | undefined;
@@ -448,7 +516,6 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     throwUnknownException__testonly?: boolean | undefined;
     enableTreatFunctionDepsAsConditional?: boolean | undefined;
     disableMemoizationForDebugging?: boolean | undefined;
-    enableMinimalTransformsForRetry?: boolean | undefined;
     enableChangeDetectionForDebugging?: {
         source: string;
         importSpecifierName: string;
@@ -474,13 +541,16 @@ declare class Environment {
     code: string | null;
     config: EnvironmentConfig;
     fnType: ReactFunctionType;
+    compilerMode: CompilerMode;
     useMemoCacheIdentifier: string;
     hasLoweredContextAccess: boolean;
     hasFireRewrite: boolean;
-    constructor(scope: Scope, fnType: ReactFunctionType, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, logger: Logger | null, filename: string | null, code: string | null, useMemoCacheIdentifier: string);
+    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, logger: Logger | null, filename: string | null, code: string | null, useMemoCacheIdentifier: string);
+    get isInferredMemoEnabled(): boolean;
     get nextIdentifierId(): IdentifierId;
     get nextBlockId(): BlockId;
     get nextScopeId(): ScopeId;
+    logErrors(errors: Result<void, CompilerError>): void;
     isContextIdentifier(node: t.Identifier): boolean;
     isHoistedIdentifier(node: t.Identifier): boolean;
     generateGloballyUniqueIdentifierName(name: string | null): ValidatedIdentifier;
@@ -490,7 +560,9 @@ declare class Environment {
         type: ReactFunctionType | null;
     }>;
     getGlobalDeclaration(binding: NonLocalBinding, loc: SourceLocation): Global | null;
-    getPropertyType(receiver: Type, property: string): BuiltInType | PolyType | null;
+    static knownReactModules: ReadonlyArray<string>;
+    getFallthroughPropertyType(receiver: Type, _property: Type): BuiltInType | PolyType | null;
+    getPropertyType(receiver: Type, property: string | number): BuiltInType | PolyType | null;
     getFunctionSignature(type: FunctionType): FunctionSignature | null;
     addHoistedIdentifier(node: t.Identifier): void;
 }
@@ -932,6 +1004,9 @@ type ObjectPropertyKey = {
 } | {
     kind: 'computed';
     name: Place;
+} | {
+    kind: 'number';
+    name: number;
 };
 type ObjectProperty = {
     kind: 'ObjectProperty';
@@ -999,6 +1074,12 @@ type CallExpression = {
     loc: SourceLocation;
     typeArguments?: Array<t.FlowType>;
 };
+type NewExpression = {
+    kind: 'NewExpression';
+    callee: Place;
+    args: Array<Place | SpreadPattern>;
+    loc: SourceLocation;
+};
 type LoadLocal = {
     kind: 'LoadLocal';
     place: Place;
@@ -1039,12 +1120,7 @@ type InstructionValue = LoadLocal | LoadContext | {
     left: Place;
     right: Place;
     loc: SourceLocation;
-} | {
-    kind: 'NewExpression';
-    callee: Place;
-    args: Array<Place | SpreadPattern>;
-    loc: SourceLocation;
-} | CallExpression | MethodCall | {
+} | NewExpression | CallExpression | MethodCall | {
     kind: 'UnaryExpression';
     operator: Exclude<t.UnaryExpression['operator'], 'throw' | 'delete'>;
     value: Place;
@@ -1293,6 +1369,7 @@ declare enum Effect {
     Freeze = "freeze",
     Read = "read",
     Capture = "capture",
+    ConditionallyMutateIterator = "mutate-iterator?",
     ConditionallyMutate = "mutate?",
     Mutate = "mutate",
     Store = "store"
@@ -1412,6 +1489,7 @@ declare class CompilerError extends Error {
     push(options: CompilerErrorDetailOptions): CompilerErrorDetail;
     pushErrorDetail(detail: CompilerErrorDetail): CompilerErrorDetail;
     hasErrors(): boolean;
+    asResult(): Result<void, CompilerError>;
     isCritical(): boolean;
 }
 
@@ -1455,7 +1533,7 @@ type CompilerPipelineValue = {
     name: string;
     value: string;
 };
-declare function compileFn(func: NodePath<t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression>, config: EnvironmentConfig, fnType: ReactFunctionType, useMemoCacheIdentifier: string, logger: Logger | null, filename: string | null, code: string | null): CodegenFunction;
+declare function compileFn(func: NodePath<t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression>, config: EnvironmentConfig, fnType: ReactFunctionType, mode: CompilerMode, useMemoCacheIdentifier: string, logger: Logger | null, filename: string | null, code: string | null): CodegenFunction;
 
 declare const PanicThresholdOptionsSchema: z.ZodEnum<["all_errors", "critical_errors", "none"]>;
 type PanicThresholdOptions = z.infer<typeof PanicThresholdOptionsSchema>;
@@ -1538,7 +1616,14 @@ declare const OPT_IN_DIRECTIVES: Set<string>;
 declare const OPT_OUT_DIRECTIVES: Set<string>;
 declare function findDirectiveEnablingMemoization(directives: Array<t.Directive>): Array<t.Directive>;
 declare function findDirectiveDisablingMemoization(directives: Array<t.Directive>): Array<t.Directive>;
-declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): void;
+type BabelFn = NodePath$1<t.FunctionDeclaration> | NodePath$1<t.FunctionExpression> | NodePath$1<t.ArrowFunctionExpression>;
+type CompileProgramResult = {
+    retryErrors: Array<{
+        fn: BabelFn;
+        error: CompilerError;
+    }>;
+};
+declare function compileProgram(program: NodePath$1<t.Program>, pass: CompilerPass): CompileProgramResult | null;
 
 declare function runBabelPluginReactCompiler(text: string, file: string, language: 'flow' | 'typescript', options: Partial<PluginOptions> | null, includeAst?: boolean): BabelCore.BabelFileResult;
 
@@ -1548,4 +1633,4 @@ declare global {
     let __DEV__: boolean | null | undefined;
 }
 
-export { CompilerError, CompilerErrorDetail, type CompilerErrorDetailOptions, type CompilerPipelineValue, CompilerSuggestionOperation, Effect, type EnvironmentConfig, ErrorSeverity, type ExternalFunction, type Hook, OPT_IN_DIRECTIVES, OPT_OUT_DIRECTIVES, type PluginOptions, type SourceLocation, ValueKind, compileFn as compile, compileProgram, BabelPluginReactCompiler as default, findDirectiveDisablingMemoization, findDirectiveEnablingMemoization, parseConfigPragmaForTests, parsePluginOptions, printHIR, printReactiveFunction, runBabelPluginReactCompiler, validateEnvironmentConfig };
+export { CompilerError, CompilerErrorDetail, type CompilerErrorDetailOptions, type CompilerPipelineValue, CompilerSuggestionOperation, Effect, type EnvironmentConfig, ErrorSeverity, type ExternalFunction, type Hook, type Logger, type LoggerEvent, OPT_IN_DIRECTIVES, OPT_OUT_DIRECTIVES, type PluginOptions, type SourceLocation, ValueKind, compileFn as compile, compileProgram, BabelPluginReactCompiler as default, findDirectiveDisablingMemoization, findDirectiveEnablingMemoization, parseConfigPragmaForTests, parsePluginOptions, printHIR, printReactiveFunction, runBabelPluginReactCompiler, validateEnvironmentConfig };