@react-native-windows/codegen 0.0.0-canary.9 → 0.0.1-0

package/src/generators/ReturnTypes.ts

@@ -0,0 +1,70 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NativeModuleReturnTypeAnnotation,
+  Nullable,
+} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap} from './AliasManaging';
+import {CppCodegenOptions, translateFieldOrReturnType} from './ObjectTypes';
+
+function translateReturnType(
+  type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  switch (type.type) {
+    case 'VoidTypeAnnotation':
+    case 'PromiseTypeAnnotation':
+      return 'void';
+    case 'NullableTypeAnnotation':
+      return `std::optional<${translateReturnType(
+        type.typeAnnotation,
+        aliases,
+        baseAliasName,
+        options,
+      )}>`;
+    default:
+      return translateFieldOrReturnType(
+        type,
+        aliases,
+        baseAliasName,
+        'translateReturnType',
+        options,
+      );
+  }
+}
+
+export function translateSpecReturnType(
+  type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+) {
+  return translateReturnType(
+    type,
+    aliases,
+    `${baseAliasName}_returnType`,
+    options,
+  );
+}
+
+export function translateImplReturnType(
+  type: Nullable<NativeModuleReturnTypeAnnotation>,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+) {
+  return translateReturnType(
+    type,
+    aliases,
+    `${baseAliasName}_returnType`,
+    options,
+  );
+}

package/src/generators/ValidateConstants.ts

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {NativeModuleSchema} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap, getAnonymousAliasCppName} from './AliasManaging';
+
+export function generateValidateConstants(
+  nativeModule: NativeModuleSchema,
+  aliases: AliasMap,
+): [string, string] | undefined {
+  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 = 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");`,
+  ];
+}

package/src/generators/ValidateMethods.ts

@@ -0,0 +1,177 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ * @format
+ */
+
+'use strict';
+
+import type {
+  NativeModuleFunctionTypeAnnotation,
+  NativeModulePropertyShape,
+  NativeModuleSchema,
+} from '@react-native/codegen/lib/CodegenSchema';
+import {AliasMap} from './AliasManaging';
+import type {CppCodegenOptions} from './ObjectTypes';
+import {translateArgs, translateSpecArgs} from './ParamTypes';
+import {translateImplReturnType, translateSpecReturnType} from './ReturnTypes';
+
+function isMethodSync(funcType: NativeModuleFunctionTypeAnnotation) {
+  return (
+    funcType.returnTypeAnnotation.type !== 'VoidTypeAnnotation' &&
+    funcType.returnTypeAnnotation.type !== 'PromiseTypeAnnotation'
+  );
+}
+
+function getPossibleMethodSignatures(
+  prop: NativeModulePropertyShape,
+  funcType: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string[] {
+  const args = translateArgs(funcType.params, aliases, baseAliasName, options);
+  if (funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
+    if (funcType.returnTypeAnnotation.elementType) {
+      args.push(
+        `::React::ReactPromise<${translateImplReturnType(
+          funcType.returnTypeAnnotation.elementType,
+          aliases,
+          baseAliasName,
+          options,
+        )}> &&result`,
+      );
+    } else {
+      args.push('::React::ReactPromise<::React::JSValue> &&result');
+    }
+  }
+
+  // TODO: be much more exhaustive on the possible method signatures that can be used..
+  const sig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
+    prop.name
+  }) ${translateImplReturnType(
+    funcType.returnTypeAnnotation,
+    aliases,
+    baseAliasName,
+    options,
+  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }`;
+
+  const staticsig = `REACT_${isMethodSync(funcType) ? 'SYNC_' : ''}METHOD(${
+    prop.name
+  }) static ${translateImplReturnType(
+    funcType.returnTypeAnnotation,
+    aliases,
+    baseAliasName,
+    options,
+  )} ${prop.name}(${args.join(', ')}) noexcept { /* implementation */ }`;
+
+  return [sig, staticsig];
+}
+
+function translatePossibleMethodSignatures(
+  prop: NativeModulePropertyShape,
+  funcType: NativeModuleFunctionTypeAnnotation,
+  aliases: AliasMap,
+  baseAliasName: string,
+  options: CppCodegenOptions,
+): string {
+  return getPossibleMethodSignatures(
+    prop,
+    funcType,
+    aliases,
+    baseAliasName,
+    options,
+  )
+    .map(sig => `"    ${sig}\\n"`)
+    .join('\n          ');
+}
+
+function renderProperties(
+  properties: ReadonlyArray<NativeModulePropertyShape>,
+  aliases: AliasMap,
+  tuple: boolean,
+  options: CppCodegenOptions,
+): string {
+  // TODO: generate code for constants
+  return properties
+    .filter(prop => prop.name !== 'getConstants')
+    .map((prop, index) => {
+      // TODO: prop.optional === true
+      // TODO: prop.typeAnnotation.type === 'NullableTypeAnnotation'
+      const propAliasName = prop.name;
+      const funcType =
+        prop.typeAnnotation.type === 'NullableTypeAnnotation'
+          ? prop.typeAnnotation.typeAnnotation
+          : prop.typeAnnotation;
+
+      const traversedArgs = translateSpecArgs(
+        funcType.params,
+        aliases,
+        propAliasName,
+        options,
+      );
+
+      const translatedReturnParam = translateSpecReturnType(
+        funcType.returnTypeAnnotation,
+        aliases,
+        propAliasName,
+        options,
+      );
+
+      if (funcType.returnTypeAnnotation.type === 'PromiseTypeAnnotation') {
+        if (funcType.returnTypeAnnotation.elementType) {
+          traversedArgs.push(
+            `Promise<${translateSpecReturnType(
+              funcType.returnTypeAnnotation.elementType,
+              aliases,
+              propAliasName,
+              options,
+            )}>`,
+          );
+        } else {
+          traversedArgs.push('Promise<::React::JSValue>');
+        }
+      }
+
+      if (tuple) {
+        return `      ${
+          isMethodSync(funcType) ? 'Sync' : ''
+        }Method<${translatedReturnParam}(${traversedArgs.join(
+          ', ',
+        )}) noexcept>{${index}, L"${prop.name}"},`;
+      } else {
+        return `    REACT_SHOW_METHOD_SPEC_ERRORS(
+          ${index},
+          "${prop.name}",
+          ${translatePossibleMethodSignatures(
+            prop,
+            funcType,
+            aliases,
+            propAliasName,
+            options,
+          )});`;
+      }
+    })
+    .join('\n');
+}
+
+export function generateValidateMethods(
+  nativeModule: NativeModuleSchema,
+  aliases: AliasMap,
+  options: CppCodegenOptions,
+): [string, string] {
+  const properties = nativeModule.spec.properties;
+  const traversedProperties = renderProperties(
+    properties,
+    aliases,
+    false,
+    options,
+  );
+  const traversedPropertyTuples = renderProperties(
+    properties,
+    aliases,
+    true,
+    options,
+  );
+  return [traversedPropertyTuples, traversedProperties];
+}

package/src/index.ts

@@ -0,0 +1,393 @@
+/**
+ * Copyright (c) Microsoft Corporation.
+ * Licensed under the MIT License.
+ *
+ * @format
+ */
+
+import path from 'path';
+import fs from '@react-native-windows/fs';
+import globby from 'globby';
+import type {CppStringTypes} from './generators/GenerateNM2';
+import {createNM2Generator} from './generators/GenerateNM2';
+import {
+  generateTypeScript,
+  setOptionalTurboModule,
+} from './generators/GenerateTypeScript';
+import type {SchemaType} from '@react-native/codegen/lib/CodegenSchema';
+import type {Parser} from '@react-native/codegen/lib/parsers/parser';
+
+export type {CppStringTypes} from './generators/GenerateNM2';
+
+// Load @react-native/codegen from react-native
+const rnPath = path.dirname(require.resolve('react-native/package.json'));
+const rncodegenPath = path.dirname(
+  require.resolve('@react-native/codegen/package.json', {paths: [rnPath]}),
+);
+
+function getParser(isTypeScript: boolean): Parser {
+  if (isTypeScript) {
+    const fp = require(path.resolve(
+      rncodegenPath,
+      'lib/parsers/typescript/parser',
+    ));
+    return new fp.TypeScriptParser();
+  } else {
+    const fp = require(path.resolve(rncodegenPath, 'lib/parsers/flow/parser'));
+    return new fp.FlowParser();
+  }
+}
+
+const schemaValidator = require(path.resolve(
+  rncodegenPath,
+  'lib/SchemaValidator',
+));
+
+export interface SharedOptions {
+  libraryName: string;
+  methodOnly: boolean;
+  modulesCxx: boolean;
+  modulesTypeScriptTypes: boolean;
+  modulesWindows: boolean;
+  namespace: string;
+  outputDirectory: string;
+  cppStringType: CppStringTypes;
+  separateDataTypes: boolean;
+}
+
+interface Options extends SharedOptions {
+  moduleSpecName: string;
+  schema: SchemaType;
+}
+
+interface Config {
+  generators: any[] /*Generators[]*/;
+  test?: boolean;
+}
+
+function normalizeFileMap(
+  map: Map<string, string>,
+  outputDir: string,
+  outMap: Map<string, string>,
+): void {
+  for (const [fileName, contents] of map) {
+    const location = path.join(outputDir, fileName);
+    outMap.set(path.normalize(location), contents);
+  }
+}
+
+function checkFilesForChanges(
+  map: Map<string, string>,
+  outputDir: string,
+): boolean {
+  let hasChanges = false;
+
+  outputDir = path.resolve(outputDir);
+  const globbyDir = outputDir.replace(/\\/g, '/');
+  const allExistingFiles = globby
+    .sync([`${globbyDir}/**`, `${globbyDir}/**/.*`], {absolute: true})
+    .map(_ => path.normalize(_));
+  const allGeneratedFiles = [...map.keys()].map(_ => path.normalize(_)).sort();
+
+  if (
+    allExistingFiles.length !== allGeneratedFiles.length ||
+    !allGeneratedFiles.every(filepath =>
+      allExistingFiles.includes(
+        path.normalize(path.resolve(process.cwd(), filepath)),
+      ),
+    )
+  )
+    return true;
+
+  for (const [fileName, contents] of map) {
+    if (!fs.existsSync(fileName)) {
+      hasChanges = true;
+      continue;
+    }
+
+    const currentContents = fs.readFileSync(fileName, 'utf8');
+    if (currentContents !== contents) {
+      console.log(`- ${fileName} has changed`);
+      hasChanges = true;
+      continue;
+    }
+  }
+
+  return hasChanges;
+}
+
+function writeMapToFiles(map: Map<string, string>, outputDir: string) {
+  let success = true;
+
+  outputDir = path.resolve(outputDir);
+  const globbyDir = outputDir.replace(/\\/g, '/');
+
+  // This ensures that we delete any generated files from modules that have been deleted
+  const allExistingFiles = globby.sync(
+    [`${globbyDir}/**`, `${globbyDir}/**/.*`],
+    {absolute: true},
+  );
+
+  const allGeneratedFiles = [...map.keys()].map(_ => path.normalize(_)).sort();
+  allExistingFiles.forEach(existingFile => {
+    if (!allGeneratedFiles.includes(path.normalize(existingFile))) {
+      console.log('Deleting ', existingFile);
+      fs.unlinkSync(existingFile);
+    }
+  });
+
+  for (const [fileName, contents] of map) {
+    try {
+      fs.mkdirSync(path.dirname(fileName), {recursive: true});
+
+      if (fs.existsSync(fileName)) {
+        const currentContents = fs.readFileSync(fileName, 'utf8');
+        // Don't update the files if there are no changes as this breaks incremental builds
+        if (currentContents === contents) {
+          continue;
+        }
+      }
+
+      console.log('Writing ', fileName);
+      fs.writeFileSync(fileName, contents);
+    } catch (error) {
+      success = false;
+      console.error(`Failed to write ${fileName} to ${fileName}`, error);
+    }
+  }
+
+  return success;
+}
+
+export function parseFile(filename: string): SchemaType {
+  try {
+    const isTypeScript =
+      path.extname(filename) === '.ts' || path.extname(filename) === '.tsx';
+    const contents = fs.readFileSync(filename, 'utf8');
+    const schema = getParser(isTypeScript).parseString(contents, filename);
+    // there will be at most one turbo module per file
+    const moduleName = Object.keys(schema.modules)[0];
+    if (moduleName) {
+      const spec = schema.modules[moduleName];
+      if (spec.type === 'NativeModule') {
+        if (contents) {
+          // This is a temporary implementation until such information is added to the schema in facebook/react-native
+          if (contents.includes('TurboModuleRegistry.get<')) {
+            setOptionalTurboModule(spec, true);
+          } else if (contents.includes('TurboModuleRegistry.getEnforcing<')) {
+            setOptionalTurboModule(spec, false);
+          }
+        }
+      }
+    }
+    return schema;
+  } catch (e) {
+    if (e instanceof Error) {
+      e.message = `(${filename}): ${e.message}`;
+    }
+    throw e;
+  }
+}
+
+export function combineSchemas(files: string[]): SchemaType {
+  return files.reduce(
+    (merged, filename) => {
+      const contents = fs.readFileSync(filename, 'utf8');
+      if (
+        contents &&
+        (/export\s+default\s+\(?codegenNativeComponent</.test(contents) ||
+          contents.includes('extends TurboModule'))
+      ) {
+        const schema = parseFile(filename);
+        merged.modules = {...merged.modules, ...schema.modules};
+      }
+      return merged;
+    },
+    {modules: {}},
+  );
+}
+
+export function generate(
+  {
+    libraryName,
+    methodOnly,
+    modulesCxx,
+    modulesTypeScriptTypes,
+    modulesWindows,
+    namespace,
+    outputDirectory,
+    cppStringType,
+    separateDataTypes,
+    moduleSpecName,
+    schema,
+  }: Options,
+  {/*generators,*/ test}: Config,
+): boolean {
+  schemaValidator.validate(schema);
+
+  const componentOutputdir = path.join(
+    outputDirectory,
+    'react/components',
+    libraryName,
+  );
+
+  const generatedFiles = new Map<string, string>();
+
+  generatedFiles.set(
+    path.join(outputDirectory, '.clang-format'),
+    'DisableFormat: true\nSortIncludes: false',
+  );
+
+  const generateNM2 = createNM2Generator({
+    methodOnly,
+    namespace,
+    cppStringType,
+    separateDataTypes,
+  });
+
+  const generateJsiModuleH = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/modules/GenerateModuleH',
+  )).generate;
+  const generateJsiModuleCpp = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/modules/GenerateModuleCpp',
+  )).generate;
+  const generatorPropsH = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GeneratePropsH',
+  )).generate;
+  const generatorPropsCPP = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GeneratePropsCpp',
+  )).generate;
+  const generatorShadowNodeH = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GenerateShadowNodeH',
+  )).generate;
+  const generatorShadowNodeCPP = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GenerateShadowNodeCpp',
+  )).generate;
+  const generatorComponentDescriptorH = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GenerateComponentDescriptorH',
+  )).generate;
+  const generatorEventEmitterH = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GenerateEventEmitterH',
+  )).generate;
+  const generatorEventEmitterCPP = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GenerateEventEmitterCpp',
+  )).generate;
+  const generatorStateCPP = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GenerateStateCpp',
+  )).generate;
+  const generatorStateH = require(path.resolve(
+    rncodegenPath,
+    'lib/generators/components/GenerateStateH',
+  )).generate;
+
+  const moduleGenerators = [];
+
+  if (modulesWindows) {
+    moduleGenerators.push(generateNM2);
+  }
+
+  if (modulesCxx) {
+    moduleGenerators.push(generateJsiModuleH);
+    moduleGenerators.push(generateJsiModuleCpp);
+  }
+
+  if (modulesTypeScriptTypes) {
+    moduleGenerators.push(generateTypeScript);
+  }
+
+  moduleGenerators.forEach(generator => {
+    const generated: Map<string, string> = generator(
+      libraryName,
+      schema,
+      moduleSpecName,
+    );
+    normalizeFileMap(generated, outputDirectory, generatedFiles);
+  });
+
+  if (
+    Object.keys(schema.modules).some(
+      moduleName => schema.modules[moduleName].type === 'Component',
+    )
+  ) {
+    const componentGenerators = [
+      generatorComponentDescriptorH,
+      generatorEventEmitterCPP,
+      generatorEventEmitterH,
+      generatorPropsCPP,
+      generatorPropsH,
+      generatorShadowNodeCPP,
+      generatorShadowNodeH,
+      generatorStateCPP,
+      generatorStateH,
+    ];
+
+    componentGenerators.forEach(generator => {
+      const generated: Map<string, string> = generator(
+        libraryName,
+        schema,
+        moduleSpecName,
+      );
+      normalizeFileMap(generated, componentOutputdir, generatedFiles);
+    });
+  }
+
+  if (test === true) {
+    return checkFilesForChanges(generatedFiles, outputDirectory);
+  }
+
+  return writeMapToFiles(generatedFiles, outputDirectory);
+}
+
+export interface CodeGenOptions extends SharedOptions {
+  file?: string;
+  files?: string[];
+  test: boolean;
+}
+
+export function runCodeGen(options: CodeGenOptions): boolean {
+  if (!options.file && !options.files)
+    throw new Error('Must specify file or files option');
+
+  const schema = options.file
+    ? parseFile(options.file)
+    : combineSchemas(globby.sync(options.files!));
+
+  const libraryName = options.libraryName;
+  const moduleSpecName = 'moduleSpecName';
+  const {
+    methodOnly,
+    modulesCxx,
+    modulesTypeScriptTypes,
+    modulesWindows,
+    namespace,
+    outputDirectory,
+    cppStringType,
+    separateDataTypes,
+  } = options;
+  return generate(
+    {
+      libraryName,
+      methodOnly,
+      modulesCxx,
+      modulesTypeScriptTypes,
+      modulesWindows,
+      namespace,
+      outputDirectory,
+      cppStringType,
+      separateDataTypes,
+      moduleSpecName,
+      schema,
+    },
+    {generators: [], test: options.test},
+  );
+}

package/.eslintrc.js

@@ -1,4 +0,0 @@
-module.exports = {
-  extends: ['@rnw-scripts'],
-  parserOptions: {tsconfigRootDir : __dirname},
-};