@react-native-windows/codegen 0.73.0-preview.1 → 0.74.0-preview.1

package/lib-commonjs/generators/ObjectTypes.js

@@ -1,75 +1,75 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- * @format
- */
-'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateField = exports.translateFieldOrReturnType = void 0;
-const AliasManaging_1 = require("./AliasManaging");
-function translateUnionReturnType(type, options) {
-    const memberType = type.memberType;
-    switch (type.memberType) {
-        case 'StringTypeAnnotation':
-            return options.cppStringType;
-        case 'NumberTypeAnnotation':
-            return 'double';
-        case 'ObjectTypeAnnotation':
-            return '::React::JSValue';
-        default:
-            throw new Error(`Unknown enum/union member type in translateReturnType: ${memberType}`);
-    }
-}
-function translateFieldOrReturnType(type, aliases, baseAliasName, callerName, options) {
-    // avoid: Property 'type' does not exist on type 'never'
-    const returnType = type.type;
-    switch (type.type) {
-        case 'StringTypeAnnotation':
-            return options.cppStringType;
-        case 'NumberTypeAnnotation':
-        case 'FloatTypeAnnotation':
-        case 'DoubleTypeAnnotation':
-            return 'double';
-        case 'Int32TypeAnnotation':
-            return 'int';
-        case 'BooleanTypeAnnotation':
-            return 'bool';
-        case 'ArrayTypeAnnotation':
-            if (type.elementType) {
-                return `std::vector<${translateFieldOrReturnType(type.elementType, aliases, `${baseAliasName}_element`, callerName, options)}>`;
-            }
-            else {
-                return `::React::JSValueArray`;
-            }
-        case 'GenericObjectTypeAnnotation':
-            return '::React::JSValue';
-        case 'ObjectTypeAnnotation':
-            return (0, AliasManaging_1.getAnonymousAliasCppName)(aliases, baseAliasName, type);
-        case 'ReservedTypeAnnotation': {
-            // avoid: Property 'name' does not exist on type 'never'
-            const name = type.name;
-            // (#6597)
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            if (name !== 'RootTag')
-                throw new Error(`Unknown reserved function: ${name} in ${callerName}`);
-            return 'double';
-        }
-        case 'TypeAliasTypeAnnotation':
-            return (0, AliasManaging_1.getAliasCppName)(type.name);
-        case 'NullableTypeAnnotation':
-            return `std::optional<${translateFieldOrReturnType(type.typeAnnotation, aliases, baseAliasName, callerName, options)}>`;
-        case 'MixedTypeAnnotation':
-            return '';
-        case 'EnumDeclaration':
-        case 'UnionTypeAnnotation':
-            return translateUnionReturnType(type, options);
-        default:
-            throw new Error(`Unhandled type in ${callerName}: ${returnType}`);
-    }
-}
-exports.translateFieldOrReturnType = translateFieldOrReturnType;
-function translateField(type, aliases, baseAliasName, options) {
-    return translateFieldOrReturnType(type, aliases, baseAliasName, 'translateField', options);
-}
-exports.translateField = translateField;
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateField = exports.translateFieldOrReturnType = void 0;
+const AliasManaging_1 = require("./AliasManaging");
+function translateUnionReturnType(type, options) {
+    const memberType = type.memberType;
+    switch (type.memberType) {
+        case 'StringTypeAnnotation':
+            return options.cppStringType;
+        case 'NumberTypeAnnotation':
+            return 'double';
+        case 'ObjectTypeAnnotation':
+            return '::React::JSValue';
+        default:
+            throw new Error(`Unknown enum/union member type in translateReturnType: ${memberType}`);
+    }
+}
+function translateFieldOrReturnType(type, aliases, baseAliasName, callerName, options) {
+    // avoid: Property 'type' does not exist on type 'never'
+    const returnType = type.type;
+    switch (type.type) {
+        case 'StringTypeAnnotation':
+            return options.cppStringType;
+        case 'NumberTypeAnnotation':
+        case 'FloatTypeAnnotation':
+        case 'DoubleTypeAnnotation':
+            return 'double';
+        case 'Int32TypeAnnotation':
+            return 'int';
+        case 'BooleanTypeAnnotation':
+            return 'bool';
+        case 'ArrayTypeAnnotation':
+            if (type.elementType) {
+                return `std::vector<${translateFieldOrReturnType(type.elementType, aliases, `${baseAliasName}_element`, callerName, options)}>`;
+            }
+            else {
+                return `::React::JSValueArray`;
+            }
+        case 'GenericObjectTypeAnnotation':
+            return '::React::JSValue';
+        case 'ObjectTypeAnnotation':
+            return (0, AliasManaging_1.getAnonymousAliasCppName)(aliases, baseAliasName, type);
+        case 'ReservedTypeAnnotation': {
+            // avoid: Property 'name' does not exist on type 'never'
+            const name = type.name;
+            // (#6597)
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (name !== 'RootTag')
+                throw new Error(`Unknown reserved function: ${name} in ${callerName}`);
+            return 'double';
+        }
+        case 'TypeAliasTypeAnnotation':
+            return (0, AliasManaging_1.getAliasCppName)(type.name);
+        case 'NullableTypeAnnotation':
+            return `std::optional<${translateFieldOrReturnType(type.typeAnnotation, aliases, baseAliasName, callerName, options)}>`;
+        case 'MixedTypeAnnotation':
+            return '';
+        case 'EnumDeclaration':
+        case 'UnionTypeAnnotation':
+            return translateUnionReturnType(type, options);
+        default:
+            throw new Error(`Unhandled type in ${callerName}: ${returnType}`);
+    }
+}
+exports.translateFieldOrReturnType = translateFieldOrReturnType;
+function translateField(type, aliases, baseAliasName, options) {
+    return translateFieldOrReturnType(type, aliases, baseAliasName, 'translateField', options);
+}
+exports.translateField = translateField;
 //# sourceMappingURL=ObjectTypes.js.map

package/lib-commonjs/generators/ParamTypes.d.ts

@@ -1,12 +1,12 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- * @format
- */
-import type { NamedShape, NativeModuleParamTypeAnnotation, Nullable } from '@react-native/codegen/lib/CodegenSchema';
-import { AliasMap } from './AliasManaging';
-import type { CppCodegenOptions } from './ObjectTypes';
-type NativeModuleParamShape = NamedShape<Nullable<NativeModuleParamTypeAnnotation>>;
-export declare function translateSpecArgs(params: ReadonlyArray<NativeModuleParamShape>, aliases: AliasMap, baseAliasName: string, options: CppCodegenOptions): string[];
-export declare function translateArgs(params: ReadonlyArray<NativeModuleParamShape>, aliases: AliasMap, baseAliasName: string, options: CppCodegenOptions): string[];
-export {};
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+import type { NamedShape, NativeModuleParamTypeAnnotation, Nullable } from '@react-native/codegen/lib/CodegenSchema';
+import { AliasMap } from './AliasManaging';
+import type { CppCodegenOptions } from './ObjectTypes';
+type NativeModuleParamShape = NamedShape<Nullable<NativeModuleParamTypeAnnotation>>;
+export declare function translateSpecArgs(params: ReadonlyArray<NativeModuleParamShape>, aliases: AliasMap, baseAliasName: string, options: CppCodegenOptions): string[];
+export declare function translateArgs(params: ReadonlyArray<NativeModuleParamShape>, aliases: AliasMap, baseAliasName: string, options: CppCodegenOptions): string[];
+export {};

package/lib-commonjs/generators/ParamTypes.js

@@ -1,137 +1,137 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- * @format
- */
-'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateArgs = exports.translateSpecArgs = void 0;
-const AliasManaging_1 = require("./AliasManaging");
-function decorateType(type, target) {
-    switch (target) {
-        case 'method-arg':
-            return `${type} &&`;
-        case 'callback-arg':
-            return `${type} const &`;
-        default:
-            return type;
-    }
-}
-function translateUnionReturnType(type, target, options) {
-    const memberType = type.memberType;
-    switch (type.memberType) {
-        case 'StringTypeAnnotation':
-            return options.cppStringType;
-        case 'NumberTypeAnnotation':
-            return 'double';
-        case 'ObjectTypeAnnotation':
-            return decorateType('::React::JSValue', target);
-        default:
-            throw new Error(`Unknown enum/union member type in translateReturnType: ${memberType}`);
-    }
-}
-function translateFunction(param, aliases, baseAliasName, target, options) {
-    // TODO: type.returnTypeAnnotation
-    switch (target) {
-        case 'spec':
-            return `Callback<${param.params
-                .map((p) => translateSpecFunctionParam(p, aliases, `${baseAliasName}_${p.name}`, options))
-                .join(', ')}>`;
-        case 'template':
-            return `std::function<void(${param.params
-                .map((p) => translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`, options))
-                .join(', ')})>`;
-        default:
-            return `std::function<void(${param.params
-                .map((p) => translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`, options))
-                .join(', ')})> const &`;
-    }
-}
-function translateArray(param, aliases, baseAliasName, target, options) {
-    if (param.elementType) {
-        switch (target) {
-            case 'spec':
-            case 'template':
-                return `std::vector<${translateNullableParamType(param.elementType, aliases, `${baseAliasName}_element`, 'template', 'template', options)}>`;
-            default:
-                return `std::vector<${translateNullableParamType(param.elementType, aliases, `${baseAliasName}_element`, 'template', 'template', options)}> const &`;
-        }
-    }
-    else {
-        return decorateType('::React::JSValueArray', target);
-    }
-}
-function translateParam(param, aliases, baseAliasName, target, options) {
-    // avoid: Property 'type' does not exist on type 'never'
-    const paramType = param.type;
-    switch (param.type) {
-        case 'StringTypeAnnotation':
-            return options.cppStringType;
-        case 'NumberTypeAnnotation':
-        case 'FloatTypeAnnotation':
-        case 'DoubleTypeAnnotation':
-            return 'double';
-        case 'Int32TypeAnnotation':
-            return 'int';
-        case 'BooleanTypeAnnotation':
-            return 'bool';
-        case 'FunctionTypeAnnotation':
-            return translateFunction(param, aliases, baseAliasName, target, options);
-        case 'ArrayTypeAnnotation':
-            return translateArray(param, aliases, baseAliasName, target, options);
-        case 'GenericObjectTypeAnnotation':
-            return decorateType('::React::JSValue', target);
-        case 'ObjectTypeAnnotation':
-            return decorateType((0, AliasManaging_1.getAnonymousAliasCppName)(aliases, baseAliasName, param), target);
-        case 'ReservedTypeAnnotation': {
-            // avoid: Property 'name' does not exist on type 'never'
-            const name = param.name;
-            // (#6597)
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            if (name !== 'RootTag')
-                throw new Error(`Unknown reserved function: ${name} in translateParam`);
-            return 'double';
-        }
-        case 'TypeAliasTypeAnnotation':
-            return decorateType((0, AliasManaging_1.getAliasCppName)(param.name), target);
-        case 'MixedTypeAnnotation':
-            return '';
-        case 'EnumDeclaration':
-        case 'UnionTypeAnnotation':
-            return translateUnionReturnType(param, target, options);
-        default:
-            throw new Error(`Unhandled type in translateParam: ${paramType}`);
-    }
-}
-function translateNullableParamType(paramType, aliases, baseAliasName, nullableTarget, target, options) {
-    switch (paramType.type) {
-        case 'NullableTypeAnnotation':
-            return `std::optional<${translateParam(paramType.typeAnnotation, aliases, baseAliasName, nullableTarget, options)}>`;
-        default:
-            return translateParam(paramType, aliases, baseAliasName, target, options);
-    }
-}
-function translateSpecFunctionParam(param, aliases, baseAliasName, options) {
-    return translateNullableParamType(param.typeAnnotation, aliases, baseAliasName, 'spec', 'spec', options);
-}
-function translateCallbackParam(param, aliases, baseAliasName, options) {
-    return translateNullableParamType(param.typeAnnotation, aliases, baseAliasName, 'template', 'callback-arg', options);
-}
-function translateFunctionParam(param, aliases, baseAliasName, options) {
-    return translateNullableParamType(param.typeAnnotation, aliases, baseAliasName, 'template', 'method-arg', options);
-}
-function translateSpecArgs(params, aliases, baseAliasName, options) {
-    return params.map(param => {
-        const translatedParam = translateSpecFunctionParam(param, aliases, `${baseAliasName}_${param.name}`, options);
-        return `${translatedParam}`;
-    });
-}
-exports.translateSpecArgs = translateSpecArgs;
-function translateArgs(params, aliases, baseAliasName, options) {
-    return params.map(param => {
-        const translatedParam = translateFunctionParam(param, aliases, `${baseAliasName}_${param.name}`, options);
-        return `${translatedParam} ${param.name}`;
-    });
-}
-exports.translateArgs = translateArgs;
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateArgs = exports.translateSpecArgs = void 0;
+const AliasManaging_1 = require("./AliasManaging");
+function decorateType(type, target) {
+    switch (target) {
+        case 'method-arg':
+            return `${type} &&`;
+        case 'callback-arg':
+            return `${type} const &`;
+        default:
+            return type;
+    }
+}
+function translateUnionReturnType(type, target, options) {
+    const memberType = type.memberType;
+    switch (type.memberType) {
+        case 'StringTypeAnnotation':
+            return options.cppStringType;
+        case 'NumberTypeAnnotation':
+            return 'double';
+        case 'ObjectTypeAnnotation':
+            return decorateType('::React::JSValue', target);
+        default:
+            throw new Error(`Unknown enum/union member type in translateReturnType: ${memberType}`);
+    }
+}
+function translateFunction(param, aliases, baseAliasName, target, options) {
+    // TODO: type.returnTypeAnnotation
+    switch (target) {
+        case 'spec':
+            return `Callback<${param.params
+                .map((p) => translateSpecFunctionParam(p, aliases, `${baseAliasName}_${p.name}`, options))
+                .join(', ')}>`;
+        case 'template':
+            return `std::function<void(${param.params
+                .map((p) => translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`, options))
+                .join(', ')})>`;
+        default:
+            return `std::function<void(${param.params
+                .map((p) => translateCallbackParam(p, aliases, `${baseAliasName}_${p.name}`, options))
+                .join(', ')})> const &`;
+    }
+}
+function translateArray(param, aliases, baseAliasName, target, options) {
+    if (param.elementType) {
+        switch (target) {
+            case 'spec':
+            case 'template':
+                return `std::vector<${translateNullableParamType(param.elementType, aliases, `${baseAliasName}_element`, 'template', 'template', options)}>`;
+            default:
+                return `std::vector<${translateNullableParamType(param.elementType, aliases, `${baseAliasName}_element`, 'template', 'template', options)}> const &`;
+        }
+    }
+    else {
+        return decorateType('::React::JSValueArray', target);
+    }
+}
+function translateParam(param, aliases, baseAliasName, target, options) {
+    // avoid: Property 'type' does not exist on type 'never'
+    const paramType = param.type;
+    switch (param.type) {
+        case 'StringTypeAnnotation':
+            return options.cppStringType;
+        case 'NumberTypeAnnotation':
+        case 'FloatTypeAnnotation':
+        case 'DoubleTypeAnnotation':
+            return 'double';
+        case 'Int32TypeAnnotation':
+            return 'int';
+        case 'BooleanTypeAnnotation':
+            return 'bool';
+        case 'FunctionTypeAnnotation':
+            return translateFunction(param, aliases, baseAliasName, target, options);
+        case 'ArrayTypeAnnotation':
+            return translateArray(param, aliases, baseAliasName, target, options);
+        case 'GenericObjectTypeAnnotation':
+            return decorateType('::React::JSValue', target);
+        case 'ObjectTypeAnnotation':
+            return decorateType((0, AliasManaging_1.getAnonymousAliasCppName)(aliases, baseAliasName, param), target);
+        case 'ReservedTypeAnnotation': {
+            // avoid: Property 'name' does not exist on type 'never'
+            const name = param.name;
+            // (#6597)
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            if (name !== 'RootTag')
+                throw new Error(`Unknown reserved function: ${name} in translateParam`);
+            return 'double';
+        }
+        case 'TypeAliasTypeAnnotation':
+            return decorateType((0, AliasManaging_1.getAliasCppName)(param.name), target);
+        case 'MixedTypeAnnotation':
+            return '';
+        case 'EnumDeclaration':
+        case 'UnionTypeAnnotation':
+            return translateUnionReturnType(param, target, options);
+        default:
+            throw new Error(`Unhandled type in translateParam: ${paramType}`);
+    }
+}
+function translateNullableParamType(paramType, aliases, baseAliasName, nullableTarget, target, options) {
+    switch (paramType.type) {
+        case 'NullableTypeAnnotation':
+            return `std::optional<${translateParam(paramType.typeAnnotation, aliases, baseAliasName, nullableTarget, options)}>`;
+        default:
+            return translateParam(paramType, aliases, baseAliasName, target, options);
+    }
+}
+function translateSpecFunctionParam(param, aliases, baseAliasName, options) {
+    return translateNullableParamType(param.typeAnnotation, aliases, baseAliasName, 'spec', 'spec', options);
+}
+function translateCallbackParam(param, aliases, baseAliasName, options) {
+    return translateNullableParamType(param.typeAnnotation, aliases, baseAliasName, 'template', 'callback-arg', options);
+}
+function translateFunctionParam(param, aliases, baseAliasName, options) {
+    return translateNullableParamType(param.typeAnnotation, aliases, baseAliasName, 'template', 'method-arg', options);
+}
+function translateSpecArgs(params, aliases, baseAliasName, options) {
+    return params.map(param => {
+        const translatedParam = translateSpecFunctionParam(param, aliases, `${baseAliasName}_${param.name}`, options);
+        return `${translatedParam}`;
+    });
+}
+exports.translateSpecArgs = translateSpecArgs;
+function translateArgs(params, aliases, baseAliasName, options) {
+    return params.map(param => {
+        const translatedParam = translateFunctionParam(param, aliases, `${baseAliasName}_${param.name}`, options);
+        return `${translatedParam} ${param.name}`;
+    });
+}
+exports.translateArgs = translateArgs;
 //# sourceMappingURL=ParamTypes.js.map

package/lib-commonjs/generators/ReturnTypes.d.ts

@@ -1,10 +1,10 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- * @format
- */
-import type { NativeModuleReturnTypeAnnotation, Nullable } from '@react-native/codegen/lib/CodegenSchema';
-import { AliasMap } from './AliasManaging';
-import { CppCodegenOptions } from './ObjectTypes';
-export declare function translateSpecReturnType(type: Nullable<NativeModuleReturnTypeAnnotation>, aliases: AliasMap, baseAliasName: string, options: CppCodegenOptions): string;
-export declare function translateImplReturnType(type: Nullable<NativeModuleReturnTypeAnnotation>, aliases: AliasMap, baseAliasName: string, options: CppCodegenOptions): string;
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+import type { NativeModuleReturnTypeAnnotation, Nullable } from '@react-native/codegen/lib/CodegenSchema';
+import { AliasMap } from './AliasManaging';
+import { CppCodegenOptions } from './ObjectTypes';
+export declare function translateSpecReturnType(type: Nullable<NativeModuleReturnTypeAnnotation>, aliases: AliasMap, baseAliasName: string, options: CppCodegenOptions): string;
+export declare function translateImplReturnType(type: Nullable<NativeModuleReturnTypeAnnotation>, aliases: AliasMap, baseAliasName: string, options: CppCodegenOptions): string;

package/lib-commonjs/generators/ReturnTypes.js

@@ -1,29 +1,29 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- * @format
- */
-'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.translateImplReturnType = exports.translateSpecReturnType = void 0;
-const ObjectTypes_1 = require("./ObjectTypes");
-function translateReturnType(type, aliases, baseAliasName, options) {
-    switch (type.type) {
-        case 'VoidTypeAnnotation':
-        case 'PromiseTypeAnnotation':
-            return 'void';
-        case 'NullableTypeAnnotation':
-            return `std::optional<${translateReturnType(type.typeAnnotation, aliases, baseAliasName, options)}>`;
-        default:
-            return (0, ObjectTypes_1.translateFieldOrReturnType)(type, aliases, baseAliasName, 'translateReturnType', options);
-    }
-}
-function translateSpecReturnType(type, aliases, baseAliasName, options) {
-    return translateReturnType(type, aliases, `${baseAliasName}_returnType`, options);
-}
-exports.translateSpecReturnType = translateSpecReturnType;
-function translateImplReturnType(type, aliases, baseAliasName, options) {
-    return translateReturnType(type, aliases, `${baseAliasName}_returnType`, options);
-}
-exports.translateImplReturnType = translateImplReturnType;
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.translateImplReturnType = exports.translateSpecReturnType = void 0;
+const ObjectTypes_1 = require("./ObjectTypes");
+function translateReturnType(type, aliases, baseAliasName, options) {
+    switch (type.type) {
+        case 'VoidTypeAnnotation':
+        case 'PromiseTypeAnnotation':
+            return 'void';
+        case 'NullableTypeAnnotation':
+            return `std::optional<${translateReturnType(type.typeAnnotation, aliases, baseAliasName, options)}>`;
+        default:
+            return (0, ObjectTypes_1.translateFieldOrReturnType)(type, aliases, baseAliasName, 'translateReturnType', options);
+    }
+}
+function translateSpecReturnType(type, aliases, baseAliasName, options) {
+    return translateReturnType(type, aliases, `${baseAliasName}_returnType`, options);
+}
+exports.translateSpecReturnType = translateSpecReturnType;
+function translateImplReturnType(type, aliases, baseAliasName, options) {
+    return translateReturnType(type, aliases, `${baseAliasName}_returnType`, options);
+}
+exports.translateImplReturnType = translateImplReturnType;
 //# sourceMappingURL=ReturnTypes.js.map

package/lib-commonjs/generators/ValidateConstants.d.ts

@@ -1,8 +1,8 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- * @format
- */
-import type { NativeModuleSchema } from '@react-native/codegen/lib/CodegenSchema';
-import { AliasMap } from './AliasManaging';
-export declare function generateValidateConstants(nativeModule: NativeModuleSchema, aliases: AliasMap): [string, string] | undefined;
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+import type { NativeModuleSchema } from '@react-native/codegen/lib/CodegenSchema';
+import { AliasMap } from './AliasManaging';
+export declare function generateValidateConstants(nativeModule: NativeModuleSchema, aliases: AliasMap): [string, string] | undefined;

package/lib-commonjs/generators/ValidateConstants.js

@@ -1,38 +1,38 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- * @format
- */
-'use strict';
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateValidateConstants = void 0;
-const AliasManaging_1 = require("./AliasManaging");
-function generateValidateConstants(nativeModule, aliases) {
-    const candidates = nativeModule.spec.properties.filter(prop => prop.name === 'getConstants');
-    if (candidates.length === 0) {
-        return undefined;
-    }
-    const getConstant = candidates[0];
-    const funcType = getConstant.typeAnnotation.type === 'NullableTypeAnnotation'
-        ? getConstant.typeAnnotation.typeAnnotation
-        : getConstant.typeAnnotation;
-    if (funcType.params.length > 0 ||
-        funcType.returnTypeAnnotation.type !== 'ObjectTypeAnnotation') {
-        return undefined;
-    }
-    const constantType = funcType.returnTypeAnnotation;
-    if (constantType.properties.length === 0) {
-        return undefined;
-    }
-    const cppName = (0, AliasManaging_1.getAnonymousAliasCppName)(aliases, 'Constants', constantType);
-    return [
-        `      TypedConstant<${cppName}>{0},`,
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValidateConstants = void 0;
+const AliasManaging_1 = require("./AliasManaging");
+function generateValidateConstants(nativeModule, aliases) {
+    const candidates = nativeModule.spec.properties.filter(prop => prop.name === 'getConstants');
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const getConstant = candidates[0];
+    const funcType = getConstant.typeAnnotation.type === 'NullableTypeAnnotation'
+        ? getConstant.typeAnnotation.typeAnnotation
+        : getConstant.typeAnnotation;
+    if (funcType.params.length > 0 ||
+        funcType.returnTypeAnnotation.type !== 'ObjectTypeAnnotation') {
+        return undefined;
+    }
+    const constantType = funcType.returnTypeAnnotation;
+    if (constantType.properties.length === 0) {
+        return undefined;
+    }
+    const cppName = (0, AliasManaging_1.getAnonymousAliasCppName)(aliases, 'Constants', constantType);
+    return [
+        `      TypedConstant<${cppName}>{0},`,
         `    REACT_SHOW_CONSTANT_SPEC_ERRORS(
           0,
           "${cppName}",
           "    REACT_GET_CONSTANTS(GetConstants) ${cppName} GetConstants() noexcept {/*implementation*/}\\n"
-          "    REACT_GET_CONSTANTS(GetConstants) static ${cppName} GetConstants() noexcept {/*implementation*/}\\n");`,
-    ];
-}
-exports.generateValidateConstants = generateValidateConstants;
+          "    REACT_GET_CONSTANTS(GetConstants) static ${cppName} GetConstants() noexcept {/*implementation*/}\\n");`,
+    ];
+}
+exports.generateValidateConstants = generateValidateConstants;
 //# sourceMappingURL=ValidateConstants.js.map

package/lib-commonjs/generators/ValidateMethods.d.ts

@@ -1,9 +1,9 @@
-/**
- * Copyright (c) Microsoft Corporation.
- * Licensed under the MIT License.
- * @format
- */
-import type { NativeModuleSchema } from '@react-native/codegen/lib/CodegenSchema';
-import { AliasMap } from './AliasManaging';
-import type { CppCodegenOptions } from './ObjectTypes';
-export declare function generateValidateMethods(nativeModule: NativeModuleSchema, aliases: AliasMap, options: CppCodegenOptions): [string, string];
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+import type { NativeModuleSchema } from '@react-native/codegen/lib/CodegenSchema';
+import { AliasMap } from './AliasManaging';
+import type { CppCodegenOptions } from './ObjectTypes';
+export declare function generateValidateMethods(nativeModule: NativeModuleSchema, aliases: AliasMap, options: CppCodegenOptions): [string, string];