babel-plugin-react-compiler 0.0.0-experimental-afa1d5a-20250319 → 0.0.0-experimental-3cea1f4-20250324

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';
@@ -177,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">>>;
@@ -336,6 +397,7 @@ declare const EnvironmentConfigSchema: z.ZodObject<{
     validateNoSetStateInRender: boolean;
     validateNoSetStateInPassiveEffects: boolean;
     validateNoJSXInTryStatements: boolean;
+    validateStaticComponents: boolean;
     validateMemoizedEffectDependencies: boolean;
     validateNoCapitalizedCalls: string[] | null;
     validateBlocklistedImports: string[] | null;
@@ -419,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;
@@ -479,14 +542,16 @@ declare class Environment {
     config: EnvironmentConfig;
     fnType: ReactFunctionType;
     compilerMode: CompilerMode;
-    useMemoCacheIdentifier: string;
-    hasLoweredContextAccess: boolean;
+    programContext: ProgramContext;
     hasFireRewrite: boolean;
-    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, logger: Logger | null, filename: string | null, code: string | null, useMemoCacheIdentifier: string);
+    hasInferredEffect: boolean;
+    constructor(scope: Scope, fnType: ReactFunctionType, compilerMode: CompilerMode, config: EnvironmentConfig, contextIdentifiers: Set<t.Identifier>, logger: Logger | null, filename: string | null, code: string | null, programContext: ProgramContext);
     get isInferredMemoEnabled(): boolean;
     get nextIdentifierId(): IdentifierId;
     get nextBlockId(): BlockId;
     get nextScopeId(): ScopeId;
+    get scope(): Scope;
+    logErrors(errors: Result<void, CompilerError>): void;
     isContextIdentifier(node: t.Identifier): boolean;
     isHoistedIdentifier(node: t.Identifier): boolean;
     generateGloballyUniqueIdentifierName(name: string | null): ValidatedIdentifier;
@@ -1010,6 +1075,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;
@@ -1050,12 +1121,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;
@@ -1239,6 +1305,12 @@ type MutableRange = {
     start: InstructionId;
     end: InstructionId;
 };
+type NonLocalImportSpecifier = {
+    kind: 'ImportSpecifier';
+    name: string;
+    module: string;
+    imported: string;
+};
 type NonLocalBinding = {
     kind: 'ImportDefault';
     name: string;
@@ -1247,12 +1319,7 @@ type NonLocalBinding = {
     kind: 'ImportNamespace';
     name: string;
     module: string;
-} | {
-    kind: 'ImportSpecifier';
-    name: string;
-    module: string;
-    imported: string;
-} | {
+} | NonLocalImportSpecifier | {
     kind: 'ModuleLocal';
     name: string;
 } | {
@@ -1304,6 +1371,7 @@ declare enum Effect {
     Freeze = "freeze",
     Read = "read",
     Capture = "capture",
+    ConditionallyMutateIterator = "mutate-iterator?",
     ConditionallyMutate = "mutate?",
     Mutate = "mutate",
     Store = "store"
@@ -1423,6 +1491,7 @@ declare class CompilerError extends Error {
     push(options: CompilerErrorDetailOptions): CompilerErrorDetail;
     pushErrorDetail(detail: CompilerErrorDetail): CompilerErrorDetail;
     hasErrors(): boolean;
+    asResult(): Result<void, CompilerError>;
     isCritical(): boolean;
 }
 
@@ -1443,7 +1512,7 @@ type CodegenFunction = {
         fn: CodegenFunction;
         type: ReactFunctionType | null;
     }>;
-    hasLoweredContextAccess: boolean;
+    hasInferredEffect: boolean;
     hasFireRewrite: boolean;
 };
 
@@ -1466,7 +1535,7 @@ type CompilerPipelineValue = {
     name: string;
     value: string;
 };
-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 function compileFn(func: NodePath<t.FunctionDeclaration | t.ArrowFunctionExpression | t.FunctionExpression>, config: EnvironmentConfig, fnType: ReactFunctionType, mode: CompilerMode, programContext: ProgramContext, 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>;
@@ -1539,6 +1608,22 @@ type Logger = {
 };
 declare function parsePluginOptions(obj: unknown): PluginOptions;
 
+declare class ProgramContext {
+    scope: Scope;
+    reactRuntimeModule: string;
+    hookPattern: string | null;
+    knownReferencedNames: Set<string>;
+    imports: Map<string, Map<string, NonLocalImportSpecifier>>;
+    constructor(program: NodePath$1<t.Program>, reactRuntimeModule: CompilerReactTarget, hookPattern: string | null);
+    isHookName(name: string): boolean;
+    hasReference(name: string): boolean;
+    newUid(name: string): string;
+    addMemoCacheImport(): NonLocalImportSpecifier;
+    addImportSpecifier({ source: module, importSpecifierName: specifier }: ExternalFunction, nameHint?: string): NonLocalImportSpecifier;
+    addNewReference(name: string): void;
+    assertGlobalBinding(name: string, localScope?: Scope): Result<void, CompilerError>;
+}
+
 type CompilerPass = {
     opts: PluginOptions;
     filename: string | null;
@@ -1566,4 +1651,4 @@ declare global {
     let __DEV__: boolean | null | undefined;
 }
 
-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 };
+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, ProgramContext, type SourceLocation, ValueKind, compileFn as compile, compileProgram, BabelPluginReactCompiler as default, findDirectiveDisablingMemoization, findDirectiveEnablingMemoization, parseConfigPragmaForTests, parsePluginOptions, printHIR, printReactiveFunction, runBabelPluginReactCompiler, validateEnvironmentConfig };