@react-native/codegen 0.72.1 → 0.72.3

package/lib/CodegenSchema.d.ts

@@ -0,0 +1,348 @@
+/**
+ * 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 PlatformType =
+  | 'iOS'
+  | 'android';
+
+export interface SchemaType {
+  readonly modules: {
+    [hasteModuleName: string]: ComponentSchema | NativeModuleSchema;
+  };
+}
+
+export interface DoubleTypeAnnotation {
+  readonly type: 'DoubleTypeAnnotation';
+}
+
+export interface FloatTypeAnnotation {
+  readonly type: 'FloatTypeAnnotation';
+}
+
+export interface BooleanTypeAnnotation {
+  readonly type: 'BooleanTypeAnnotation';
+}
+
+export interface Int32TypeAnnotation {
+  readonly type: 'Int32TypeAnnotation';
+}
+
+export interface StringTypeAnnotation {
+  readonly type: 'StringTypeAnnotation';
+}
+
+export interface StringEnumTypeAnnotation {
+  readonly type: 'StringEnumTypeAnnotation';
+  readonly options: readonly string[];
+}
+
+export interface VoidTypeAnnotation {
+  readonly type: 'VoidTypeAnnotation';
+}
+
+export interface ObjectTypeAnnotation<T> {
+  readonly type: 'ObjectTypeAnnotation';
+  readonly properties: readonly NamedShape<T>[];
+  readonly baseTypes?: readonly string[];
+}
+
+export interface FunctionTypeAnnotation<P, R> {
+  readonly type: 'FunctionTypeAnnotation';
+  readonly params: readonly NamedShape<P>[];
+  readonly returnTypeAnnotation: R;
+}
+
+export interface NamedShape<T> {
+  readonly name: string;
+  readonly optional: boolean;
+  readonly typeAnnotation: T;
+}
+
+export interface ComponentSchema {
+  readonly type: 'Component';
+  readonly components: {
+    [componentName: string]: ComponentShape;
+  };
+}
+
+export interface ComponentShape extends OptionsShape {
+  readonly extendsProps: readonly ExtendsPropsShape[];
+  readonly events: readonly EventTypeShape[];
+  readonly props: readonly NamedShape<PropTypeAnnotation>[];
+  readonly commands: readonly NamedShape<CommandTypeAnnotation>[];
+}
+
+export interface OptionsShape {
+  readonly interfaceOnly?: boolean;
+  readonly paperComponentName?: string;
+  readonly excludedPlatforms?: readonly PlatformType[];
+  readonly paperComponentNameDeprecated?: string;
+}
+
+export interface ExtendsPropsShape {
+  readonly type: 'ReactNativeBuiltInType';
+  readonly knownTypeName: 'ReactNativeCoreViewProps';
+}
+
+export interface EventTypeShape {
+  readonly name: string;
+  readonly bubblingType:
+    | 'direct'
+    | 'bubble';
+  readonly optional: boolean;
+  readonly paperTopLevelNameDeprecated?: string;
+  readonly typeAnnotation: {
+    readonly type: 'EventTypeAnnotation';
+    readonly argument?: ObjectTypeAnnotation<EventTypeAnnotation>;
+  };
+}
+
+export type EventTypeAnnotation =
+  | BooleanTypeAnnotation
+  | StringTypeAnnotation
+  | DoubleTypeAnnotation
+  | FloatTypeAnnotation
+  | Int32TypeAnnotation
+  | StringEnumTypeAnnotation
+  | ObjectTypeAnnotation<EventTypeAnnotation>;
+
+export type PropTypeAnnotation =
+  | {
+      readonly type: 'BooleanTypeAnnotation';
+      readonly default:
+        | boolean
+        | null;
+    }
+  | {
+      readonly type: 'StringTypeAnnotation';
+      readonly default:
+        | string
+        | null;
+    }
+  | {
+      readonly type: 'DoubleTypeAnnotation';
+      readonly default: number;
+    }
+  | {
+      readonly type: 'FloatTypeAnnotation';
+      readonly default:
+        | number
+        | null;
+    }
+  | {
+      readonly type: 'Int32TypeAnnotation';
+      readonly default: number;
+    }
+  | {
+      readonly type: 'StringEnumTypeAnnotation';
+      readonly default: string;
+      readonly options: readonly string[];
+    }
+  | {
+      readonly type: 'Int32EnumTypeAnnotation';
+      readonly default: number;
+      readonly options: readonly number[];
+    }
+  | ReservedPropTypeAnnotation
+  | ObjectTypeAnnotation<PropTypeAnnotation>
+  | {
+      readonly type: 'ArrayTypeAnnotation';
+      readonly elementType:
+        | BooleanTypeAnnotation
+        | StringTypeAnnotation
+        | DoubleTypeAnnotation
+        | FloatTypeAnnotation
+        | Int32TypeAnnotation
+        | {
+            readonly type: 'StringEnumTypeAnnotation';
+            readonly default: string;
+            readonly options: readonly string[];
+          }
+        | ObjectTypeAnnotation<PropTypeAnnotation>
+        | ReservedPropTypeAnnotation
+        | {
+            readonly type: 'ArrayTypeAnnotation';
+            readonly elementType: ObjectTypeAnnotation<PropTypeAnnotation>;
+          };
+    };
+
+export interface ReservedPropTypeAnnotation {
+  readonly type: 'ReservedPropTypeAnnotation';
+  readonly name:
+    | 'ColorPrimitive'
+    | 'ImageSourcePrimitive'
+    | 'PointPrimitive'
+    | 'EdgeInsetsPrimitive'
+    | 'ImageRequestPrimitive'
+    | 'DimensionPrimitive';
+}
+
+export type CommandTypeAnnotation = FunctionTypeAnnotation<CommandParamTypeAnnotation, VoidTypeAnnotation>;
+
+export type CommandParamTypeAnnotation =
+  | ReservedTypeAnnotation
+  | BooleanTypeAnnotation
+  | Int32TypeAnnotation
+  | DoubleTypeAnnotation
+  | FloatTypeAnnotation
+  | StringTypeAnnotation;
+
+export interface ReservedTypeAnnotation {
+  readonly type: 'ReservedTypeAnnotation';
+  readonly name: 'RootTag';
+}
+
+export type Nullable<T extends NativeModuleTypeAnnotation> =
+  | NullableTypeAnnotation<T>
+  | T;
+
+export interface NullableTypeAnnotation<T extends NativeModuleTypeAnnotation> {
+  readonly type: 'NullableTypeAnnotation';
+  readonly typeAnnotation: T;
+}
+
+export interface NativeModuleSchema {
+  readonly type: 'NativeModule';
+  readonly aliasMap: NativeModuleAliasMap;
+  readonly enumMap: NativeModuleEnumMap;
+  readonly spec: NativeModuleSpec;
+  readonly moduleName: string;
+  readonly excludedPlatforms?: readonly PlatformType[];
+}
+
+export interface NativeModuleSpec {
+  readonly properties: readonly NativeModulePropertyShape[];
+}
+
+export type NativeModulePropertyShape = NamedShape<Nullable<NativeModuleFunctionTypeAnnotation>>;
+
+export interface NativeModuleEnumMap {
+  readonly [enumName: string]: NativeModuleEnumDeclarationWithMembers;
+}
+
+export interface NativeModuleAliasMap {
+  readonly [aliasName: string]: NativeModuleObjectTypeAnnotation;
+}
+
+export type NativeModuleFunctionTypeAnnotation = FunctionTypeAnnotation<Nullable<NativeModuleParamTypeAnnotation>, Nullable<NativeModuleReturnTypeAnnotation>>;
+
+export type NativeModuleObjectTypeAnnotation = ObjectTypeAnnotation<Nullable<NativeModuleBaseTypeAnnotation>>;
+
+export interface NativeModuleArrayTypeAnnotation<T extends Nullable<NativeModuleBaseTypeAnnotation>> {
+  readonly type: 'ArrayTypeAnnotation';
+  readonly elementType?: T;
+}
+
+export interface NativeModuleStringTypeAnnotation {
+  readonly type: 'StringTypeAnnotation';
+}
+
+export interface NativeModuleNumberTypeAnnotation {
+  readonly type: 'NumberTypeAnnotation';
+}
+
+export interface NativeModuleInt32TypeAnnotation {
+  readonly type: 'Int32TypeAnnotation';
+}
+
+export interface NativeModuleDoubleTypeAnnotation {
+  readonly type: 'DoubleTypeAnnotation';
+}
+
+export interface NativeModuleFloatTypeAnnotation {
+  readonly type: 'FloatTypeAnnotation';
+}
+
+export interface NativeModuleBooleanTypeAnnotation {
+  readonly type: 'BooleanTypeAnnotation';
+}
+
+export type NativeModuleEnumMembers = readonly {
+  readonly name: string;
+  readonly value: string;
+}[];
+
+export type NativeModuleEnumMemberType =
+  | 'NumberTypeAnnotation'
+  | 'StringTypeAnnotation';
+
+export interface NativeModuleEnumDeclaration {
+  readonly name: string;
+  readonly type: 'EnumDeclaration';
+  readonly memberType: NativeModuleEnumMemberType;
+}
+
+export interface NativeModuleEnumDeclarationWithMembers {
+  name: string;
+  type: 'EnumDeclarationWithMembers';
+  memberType: NativeModuleEnumMemberType;
+  members: NativeModuleEnumMembers;
+}
+
+export interface NativeModuleGenericObjectTypeAnnotation {
+  readonly type: 'GenericObjectTypeAnnotation';
+}
+
+export interface NativeModuleTypeAliasTypeAnnotation {
+  readonly type: 'TypeAliasTypeAnnotation';
+  readonly name: string;
+}
+
+export interface NativeModulePromiseTypeAnnotation {
+  readonly type: 'PromiseTypeAnnotation';
+  readonly elementType?: Nullable<NativeModuleBaseTypeAnnotation>;
+}
+
+export type UnionTypeAnnotationMemberType =
+  | 'NumberTypeAnnotation'
+  | 'ObjectTypeAnnotation'
+  | 'StringTypeAnnotation';
+
+export interface NativeModuleUnionTypeAnnotation {
+  readonly type: 'UnionTypeAnnotation';
+  readonly memberType: UnionTypeAnnotationMemberType;
+}
+
+export interface NativeModuleMixedTypeAnnotation {
+  readonly type: 'MixedTypeAnnotation';
+}
+
+export type NativeModuleBaseTypeAnnotation =
+  | NativeModuleStringTypeAnnotation
+  | NativeModuleNumberTypeAnnotation
+  | NativeModuleInt32TypeAnnotation
+  | NativeModuleDoubleTypeAnnotation
+  | NativeModuleFloatTypeAnnotation
+  | NativeModuleBooleanTypeAnnotation
+  | NativeModuleEnumDeclaration
+  | NativeModuleGenericObjectTypeAnnotation
+  | ReservedTypeAnnotation
+  | NativeModuleTypeAliasTypeAnnotation
+  | NativeModuleArrayTypeAnnotation<Nullable<NativeModuleBaseTypeAnnotation>>
+  | NativeModuleObjectTypeAnnotation
+  | NativeModuleUnionTypeAnnotation
+  | NativeModuleMixedTypeAnnotation;
+
+export type NativeModuleParamTypeAnnotation =
+  | NativeModuleBaseTypeAnnotation
+  | NativeModuleParamOnlyTypeAnnotation;
+
+export type NativeModuleReturnTypeAnnotation =
+  | NativeModuleBaseTypeAnnotation
+  | NativeModuleReturnOnlyTypeAnnotation;
+
+export type NativeModuleTypeAnnotation =
+  | NativeModuleBaseTypeAnnotation
+  | NativeModuleParamOnlyTypeAnnotation
+  | NativeModuleReturnOnlyTypeAnnotation;
+
+export type NativeModuleParamOnlyTypeAnnotation = NativeModuleFunctionTypeAnnotation;
+
+export type NativeModuleReturnOnlyTypeAnnotation =
+  | NativeModulePromiseTypeAnnotation
+  | VoidTypeAnnotation;
+

package/lib/CodegenSchema.js.flow

@@ -53,6 +53,9 @@ export type VoidTypeAnnotation = $ReadOnly<{
 export type ObjectTypeAnnotation<+T> = $ReadOnly<{
   type: 'ObjectTypeAnnotation',
   properties: $ReadOnlyArray<NamedShape<T>>,
+
+  // metadata for objects that generated from interfaces
+  baseTypes?: $ReadOnlyArray<string>,
 }>;
 
 type FunctionTypeAnnotation<+P, +R> = $ReadOnly<{
@@ -183,7 +186,8 @@ export type ReservedPropTypeAnnotation = $ReadOnly<{
     | 'ImageSourcePrimitive'
     | 'PointPrimitive'
     | 'EdgeInsetsPrimitive'
-    | 'ImageRequestPrimitive',
+    | 'ImageRequestPrimitive'
+    | 'DimensionPrimitive',
 }>;
 
 export type CommandTypeAnnotation = FunctionTypeAnnotation<
@@ -218,7 +222,8 @@ export type NullableTypeAnnotation<+T: NativeModuleTypeAnnotation> = $ReadOnly<{
 
 export type NativeModuleSchema = $ReadOnly<{
   type: 'NativeModule',
-  aliases: NativeModuleAliasMap,
+  aliasMap: NativeModuleAliasMap,
+  enumMap: NativeModuleEnumMap,
   spec: NativeModuleSpec,
   moduleName: string,
   // Use for modules that are not used on other platforms.
@@ -235,6 +240,10 @@ export type NativeModulePropertyShape = NamedShape<
   Nullable<NativeModuleFunctionTypeAnnotation>,
 >;
 
+export type NativeModuleEnumMap = $ReadOnly<{
+  [enumName: string]: NativeModuleEnumDeclarationWithMembers,
+}>;
+
 export type NativeModuleAliasMap = $ReadOnly<{
   [aliasName: string]: NativeModuleObjectTypeAnnotation,
 }>;
@@ -283,11 +292,30 @@ export type NativeModuleBooleanTypeAnnotation = $ReadOnly<{
   type: 'BooleanTypeAnnotation',
 }>;
 
+export type NativeModuleEnumMembers = $ReadOnlyArray<
+  $ReadOnly<{
+    name: string,
+    value: string,
+  }>,
+>;
+
+export type NativeModuleEnumMemberType =
+  | 'NumberTypeAnnotation'
+  | 'StringTypeAnnotation';
+
 export type NativeModuleEnumDeclaration = $ReadOnly<{
+  name: string,
   type: 'EnumDeclaration',
-  memberType: 'NumberTypeAnnotation' | 'StringTypeAnnotation',
+  memberType: NativeModuleEnumMemberType,
 }>;
 
+export type NativeModuleEnumDeclarationWithMembers = {
+  name: string,
+  type: 'EnumDeclarationWithMembers',
+  memberType: NativeModuleEnumMemberType,
+  members: NativeModuleEnumMembers,
+};
+
 export type NativeModuleGenericObjectTypeAnnotation = $ReadOnly<{
   type: 'GenericObjectTypeAnnotation',
 }>;

package/lib/SchemaValidator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 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 { SchemaType } from "./CodegenSchema";
+
+export declare function getErrors(schema: SchemaType): readonly string[];
+export declare function validate(schema: SchemaType): void;

package/lib/cli/combine/combine-js-to-schema.js

@@ -72,12 +72,14 @@ function _toPrimitive(input, hint) {
   }
   return (hint === 'string' ? String : Number)(input);
 }
-const _require = require('../../parsers/utils'),
-  parseFile = _require.parseFile;
-const FlowParser = require('../../parsers/flow');
-const TypeScriptParser = require('../../parsers/typescript');
+const _require = require('../../parsers/flow/parser'),
+  FlowParser = _require.FlowParser;
+const _require2 = require('../../parsers/typescript/parser'),
+  TypeScriptParser = _require2.TypeScriptParser;
 const fs = require('fs');
 const path = require('path');
+const flowParser = new FlowParser();
+const typescriptParser = new TypeScriptParser();
 function combineSchemas(files) {
   return files.reduce(
     (merged, filename) => {
@@ -89,10 +91,8 @@ function combineSchemas(files) {
       ) {
         const isTypeScript =
           path.extname(filename) === '.ts' || path.extname(filename) === '.tsx';
-        const schema = parseFile(
-          filename,
-          isTypeScript ? TypeScriptParser.buildSchema : FlowParser.buildSchema,
-        );
+        const parser = isTypeScript ? typescriptParser : flowParser;
+        const schema = parser.parseFile(filename);
         if (schema && schema.modules) {
           merged.modules = _objectSpread(
             _objectSpread({}, merged.modules),

package/lib/cli/combine/combine-js-to-schema.js.flow

@@ -11,12 +11,14 @@
 'use strict';
 import type {SchemaType} from '../../CodegenSchema.js';
 
-const {parseFile} = require('../../parsers/utils');
-const FlowParser = require('../../parsers/flow');
-const TypeScriptParser = require('../../parsers/typescript');
+const {FlowParser} = require('../../parsers/flow/parser');
+const {TypeScriptParser} = require('../../parsers/typescript/parser');
 const fs = require('fs');
 const path = require('path');
 
+const flowParser = new FlowParser();
+const typescriptParser = new TypeScriptParser();
+
 function combineSchemas(files: Array<string>): SchemaType {
   return files.reduce(
     (merged, filename) => {
@@ -30,10 +32,9 @@ function combineSchemas(files: Array<string>): SchemaType {
         const isTypeScript =
           path.extname(filename) === '.ts' || path.extname(filename) === '.tsx';
 
-        const schema = parseFile(
-          filename,
-          isTypeScript ? TypeScriptParser.buildSchema : FlowParser.buildSchema,
-        );
+        const parser = isTypeScript ? typescriptParser : flowParser;
+
+        const schema = parser.parseFile(filename);
 
         if (schema && schema.modules) {
           merged.modules = {...merged.modules, ...schema.modules};

package/lib/cli/parser/parser.js

@@ -11,25 +11,18 @@
 'use strict';
 
 const path = require('path');
-const _require = require('../../parsers/utils'),
-  parseFile = _require.parseFile;
-const FlowParser = require('../../parsers/flow');
-const TypeScriptParser = require('../../parsers/typescript');
+const _require = require('../../parsers/flow/parser'),
+  FlowParser = _require.FlowParser;
+const _require2 = require('../../parsers/typescript/parser'),
+  TypeScriptParser = _require2.TypeScriptParser;
+const flowParser = new FlowParser();
+const typescriptParser = new TypeScriptParser();
 function parseFiles(files) {
   files.forEach(filename => {
     const isTypeScript =
       path.extname(filename) === '.ts' || path.extname(filename) === '.tsx';
-    console.log(
-      filename,
-      JSON.stringify(
-        parseFile(
-          filename,
-          isTypeScript ? TypeScriptParser.buildSchema : FlowParser.buildSchema,
-        ),
-        null,
-        2,
-      ),
-    );
+    const parser = isTypeScript ? typescriptParser : flowParser;
+    console.log(filename, JSON.stringify(parser.parseFile(filename), null, 2));
   });
 }
 module.exports = parseFiles;

package/lib/cli/parser/parser.js.flow

@@ -11,26 +11,20 @@
 'use strict';
 
 const path = require('path');
-const {parseFile} = require('../../parsers/utils');
-const FlowParser = require('../../parsers/flow');
-const TypeScriptParser = require('../../parsers/typescript');
+const {FlowParser} = require('../../parsers/flow/parser');
+const {TypeScriptParser} = require('../../parsers/typescript/parser');
+
+const flowParser = new FlowParser();
+const typescriptParser = new TypeScriptParser();
 
 function parseFiles(files: Array<string>) {
   files.forEach(filename => {
     const isTypeScript =
       path.extname(filename) === '.ts' || path.extname(filename) === '.tsx';
 
-    console.log(
-      filename,
-      JSON.stringify(
-        parseFile(
-          filename,
-          isTypeScript ? TypeScriptParser.buildSchema : FlowParser.buildSchema,
-        ),
-        null,
-        2,
-      ),
-    );
+    const parser = isTypeScript ? typescriptParser : flowParser;
+
+    console.log(filename, JSON.stringify(parser.parseFile(filename), null, 2));
   });
 }
 

package/lib/generators/Utils.js

@@ -25,7 +25,23 @@ function indent(nice, spaces) {
     })
     .join('\n');
 }
+function toPascalCase(inString) {
+  if (inString.length === 0) {
+    return inString;
+  }
+  return inString[0].toUpperCase() + inString.slice(1);
+}
+function toSafeCppString(input) {
+  return input.split('-').map(toPascalCase).join('');
+}
+function getEnumName(moduleName, origEnumName) {
+  const uppercasedPropName = toSafeCppString(origEnumName);
+  return `${moduleName}${uppercasedPropName}`;
+}
 module.exports = {
   capitalize,
   indent,
+  toPascalCase,
+  toSafeCppString,
+  getEnumName,
 };

package/lib/generators/Utils.js.flow

@@ -27,7 +27,27 @@ function indent(nice: string, spaces: number): string {
     .join('\n');
 }
 
+function toPascalCase(inString: string): string {
+  if (inString.length === 0) {
+    return inString;
+  }
+
+  return inString[0].toUpperCase() + inString.slice(1);
+}
+
+function toSafeCppString(input: string): string {
+  return input.split('-').map(toPascalCase).join('');
+}
+
+function getEnumName(moduleName: string, origEnumName: string): string {
+  const uppercasedPropName = toSafeCppString(origEnumName);
+  return `${moduleName}${uppercasedPropName}`;
+}
+
 module.exports = {
   capitalize,
   indent,
+  toPascalCase,
+  toSafeCppString,
+  getEnumName,
 };

package/lib/generators/__test_fixtures__/fixtures.js

@@ -39,7 +39,8 @@ const SCHEMA_WITH_TM_AND_FC = {
     },
     NativeCalculator: {
       type: 'NativeModule',
-      aliases: {},
+      aliasMap: {},
+      enumMap: {},
       spec: {
         properties: [
           {

package/lib/generators/__test_fixtures__/fixtures.js.flow

@@ -41,7 +41,8 @@ const SCHEMA_WITH_TM_AND_FC: SchemaType = {
     },
     NativeCalculator: {
       type: 'NativeModule',
-      aliases: {},
+      aliasMap: {},
+      enumMap: {},
       spec: {
         properties: [
           {

package/lib/generators/components/ComponentsGeneratorUtils.js

@@ -13,9 +13,10 @@
 const _require = require('./CppHelpers.js'),
   getCppTypeForAnnotation = _require.getCppTypeForAnnotation,
   getEnumMaskName = _require.getEnumMaskName,
-  getEnumName = _require.getEnumName,
   generateStructName = _require.generateStructName,
   getImports = _require.getImports;
+const _require2 = require('../Utils'),
+  getEnumName = _require2.getEnumName;
 function getNativeTypeFromAnnotation(componentName, prop, nameParts) {
   const typeAnnotation = prop.typeAnnotation;
   switch (typeAnnotation.type) {
@@ -37,6 +38,8 @@ function getNativeTypeFromAnnotation(componentName, prop, nameParts) {
           return 'Point';
         case 'EdgeInsetsPrimitive':
           return 'EdgeInsets';
+        case 'DimensionPrimitive':
+          return 'YGValue';
         default:
           typeAnnotation.name;
           throw new Error('Received unknown ReservedPropTypeAnnotation');
@@ -160,6 +163,9 @@ function getLocalImports(properties) {
       case 'EdgeInsetsPrimitive':
         imports.add('#include <react/renderer/graphics/RectangleEdges.h>');
         return;
+      case 'DimensionPrimitive':
+        imports.add('#include <yoga/Yoga.h>');
+        return;
       default:
         name;
         throw new Error(`Invalid ReservedPropTypeAnnotation name, got ${name}`);
@@ -186,8 +192,11 @@ function getLocalImports(properties) {
       typeAnnotation.type === 'ArrayTypeAnnotation' &&
       typeAnnotation.elementType.type === 'ObjectTypeAnnotation'
     ) {
+      imports.add('#include <react/renderer/core/propsConversions.h>');
       const objectProps = typeAnnotation.elementType.properties;
+      // $FlowFixMe[incompatible-call] the type is guaranteed to be ObjectTypeAnnotation<PropTypeAnnotation>
       const objectImports = getImports(objectProps);
+      // $FlowFixMe[incompatible-call] the type is guaranteed to be ObjectTypeAnnotation<PropTypeAnnotation>
       const localImports = getLocalImports(objectProps);
       // $FlowFixMe[method-unbinding] added when improving typing for this parameters
       objectImports.forEach(imports.add, imports);