7175

Committed 06 Oct 2023 02:44AM UTC coverage: 60.404% (+0.01%) from 60.393%

Build # 7175

Build Type

push

Azure Pipelines

Committed by

web-flow

Commit Message

Merge pull request #1902 from Karthiccc23/add-pod-update

Add optional podRepoUpdate flag in iosConfig

Run Details

3825 of 7677 branches covered (49.82%)

Branch coverage included in aggregate %.

0 of 3 new or added lines in 1 file covered. (0.0%)

1 existing line in 1 file now uncovered.

9967 of 15156 relevant lines covered (65.76%)

553.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

4.2

/ern-container-gen-ios/src/IosGenerator.ts

import {
  childProcess,
  createTmpDir,
  injectReactNativeVersionKeysInObject,
  iosUtil,
  kax,
  log,
  manifest,
  mustacheUtils,
  NativePlatform,
  PackagePath,
  PluginConfig,
  readPackageJson,
  shell,
  utils,
  writePackageJson,
  yarn,
  config as ernConfig,
} from 'ern-core';
import {
  ContainerGenerator,
  ContainerGeneratorConfig,
  ContainerGenResult,
  generateContainer,
  generatePluginsMustacheViews,
  populateApiImplMustacheView,
} from 'ern-container-gen';

import fs from 'fs-extra';
import path from 'path';
import xcode from 'xcode-ern';
import _ from 'lodash';
import readDir from 'fs-readdir-recursive';
import { Composite } from 'ern-composite-gen';
import semver from 'semver';

const ROOT_DIR = process.cwd();
const PATH_TO_TEMPLATES_DIR = path.join(__dirname, 'templates');
const PATH_TO_HULL_DIR = path.join(__dirname, 'hull');

export default class IosGenerator implements ContainerGenerator {
  get name(): string {
    return 'IosGenerator';
  }

  get platform(): NativePlatform {
    return 'ios';
  }

  public async generate(
    config: ContainerGeneratorConfig,
  ): Promise<ContainerGenResult> {
    return generateContainer(config, {
      fillContainerHull: this.fillContainerHull.bind(this),
      postCopyRnpmAssets: this.addResources.bind(this),
    });
  }

  public async addResources(config: ContainerGeneratorConfig) {
    const containerProjectPath = path.join(
      config.outDir,
      'ElectrodeContainer.xcodeproj',
      'project.pbxproj',
    );
    const containerIosProject = await this.getIosContainerProject(
      containerProjectPath,
    );

    const containerResourcesPath = path.join(
      config.outDir,
      'ElectrodeContainer',
      'Resources',
    );
    // Get all resources files from the 'Resources' directory
    // Some processing is done here to properly handle `.xcassets`
    // files which are directories containing assets.
    // But we don't want to add independent files from this directory
    // to the pbxproj, but only the top level `.xcassets` directory.
    //
    // For example, an  `xcassets` directory might look like this
    //
    // Media.xcassets
    // ├── Contents.json
    // ├── Face-ID.imageset
    // │   ├── Contents.json
    // │   └── faceid.pdf
    // ├── IconUser.imageset
    // │   ├── Contents.json
    // │   └── IconUser.pdf
    //
    // Which will result in recursive readir call returning the
    // following paths
    //
    // Media.xcassets/Contents.json
    // Media.xcassets/Face-ID.imageset/Contents.json
    // Media.xcassets/Face-ID.imageset/faceid.pdf
    // ...
    //
    // Each of these individual files would then wrongly be
    // added to the pbxproj as resources.
    // However we just want top level directory Media.xcassets
    // to be added to the pbxproj, thus the special processing.
    const resourceFiles = _.uniq(
      readDir(containerResourcesPath).map((f) =>
        f.replace(/(\.xcassets)(\/.+)$/, '$1'),
      ),
    );
    resourceFiles.forEach((resourceFile) => {
      containerIosProject.addResourceFile(
        path.join('Resources', resourceFile),
        null,
        containerIosProject.findPBXGroupKey({ name: 'Resources' }),
      );
    });

    fs.writeFileSync(containerProjectPath, containerIosProject.writeSync());
  }

  public async fillContainerHull(
    config: ContainerGeneratorConfig,
  ): Promise<void> {
    if (process.platform !== 'darwin' && !config?.iosConfig?.skipInstall) {
      throw new Error(
        `Full iOS Container generation with pod installation is only supported on macOS.
You can set 'iosConfig.skipInstall' in container generator config to skip the installation step.
Or set --skipInstall if using the create-container command.`,
      );
    }

    if (config?.iosConfig?.skipInstall) {
      log.info(
        `skipInstall option is set. 'yarn install' and 'pod install' won't be run after container generation.
Make sure to run these commands before building the container.`,
      );
    }

    const pathSpec = {
      outputDir: config.outDir,
      projectHullDir: path.join(PATH_TO_HULL_DIR, '{.*,*}'),
      rootDir: ROOT_DIR,
    };

    const reactNativePlugin = _.find(
      config.plugins,
      (p) => p.name === 'react-native',
    );
    if (!reactNativePlugin) {
      throw new Error('react-native was not found in plugins list !');
    }
    if (!reactNativePlugin.version) {
      throw new Error('react-native plugin does not have a version !');
    }

    const mustacheView: any = {};
    mustacheView.jsMainModuleName = config.jsMainModuleName || 'index';
    mustacheView.iosDeploymentTarget =
      config.iosConfig?.deploymentTarget ??
      iosUtil.getDefaultIosDeploymentTarget(reactNativePlugin.version);

    injectReactNativeVersionKeysInObject(
      mustacheView,
      reactNativePlugin.version,
    );

    const projectSpec = {
      deploymentTarget: mustacheView.iosDeploymentTarget,
      projectName: 'ElectrodeContainer',
    };

    await kax
      .task('Preparing Native Dependencies Injection')
      .run(this.buildiOSPluginsViews(config.plugins, mustacheView));

    await kax
      .task('Preparing API Implementations Injection')
      .run(
        this.buildApiImplPluginViews(
          config.plugins,
          config.composite,
          mustacheView,
          projectSpec,
        ),
      );

    if (semver.gte(reactNativePlugin.version!, '0.61.0')) {
      shell.pushd(config.outDir);
      try {
        await yarn.init();

        // Add @react-native-community/cli-platform-ios because
        // it contains the scripts needed for native modules pods linking
        // look in composite to match proper version
        const compositeNodeModulesPath = path.join(
          config.composite.path,
          'node_modules',
        );
        const cliPlatformIosPkg = '@react-native-community/cli-platform-ios';
        const cliPlatformIosPkgVersion = (
          await readPackageJson(
            path.join(compositeNodeModulesPath, cliPlatformIosPkg),
          )
        ).version;

        await yarn.add(
          PackagePath.fromString(
            `${cliPlatformIosPkg}@${cliPlatformIosPkgVersion}`,
          ),
        );

        await yarn.add(
          PackagePath.fromString(`react-native@${reactNativePlugin.version}`),
        );

        //
        // Add all native dependencies to package.json dependencies so that
        // !use_native_modules can detect them to add their pod to the Podfile
        const dependencies = await config.composite.getNativeDependencies({});
        const resDependencies = [
          ...dependencies.thirdPartyInManifest,
          ...dependencies.thirdPartyNotInManifest,
        ];

        const addDependencies: any = {};
        resDependencies.forEach((p) => {
          addDependencies[p.name!] = p.version;
        });

        //
        // Create package.json in container directory root
        // so that native modules pods can be resolved
        // by use_native_modules! RN ruby script
        const pjsonObj = {
          dependencies: addDependencies,
          name: 'container',
          private: true,
        };
        await writePackageJson(config.outDir, pjsonObj);

        //
        // Copy all native dependencies from composite node_modules
        // to container node_modules so that pods can be found local
        // to the container directory
        // [only for full iOS container generation]
        if (!config?.iosConfig?.skipInstall) {
          const containerNodeModulesPath = path.join(
            config.outDir,
            'node_modules',
          );
          shell.mkdir('-p', containerNodeModulesPath);
          resDependencies.forEach((p) => {
            const depPath = p.basePath!.match(/node_modules\/(.+)/)![1];
            const targetPath = path.join(containerNodeModulesPath, depPath);
            shell.mkdir('-p', targetPath);
            shell.cp('-rf', path.join(p.basePath!, '{.*,*}'), targetPath);
          });
        } else {
          shell.rm('-rf', 'node_modules');
        }
      } finally {
        shell.popd();
      }
    }

    const { iosProject, projectPath } = await iosUtil.fillProjectHull(
      pathSpec,
      projectSpec,
      config.plugins,
      mustacheView,
      config.composite,
      config.iosConfig,
    );

    await kax
      .task('Adding MiniAppNavigationController Classes')
      .run(this.addMiniAppNavigationControllerClasses(config, iosProject));

    await kax
      .task('Adding Native Dependencies Hooks')
      .run(
        this.addiOSPluginHookClasses(iosProject, config.plugins, config.outDir),
      );

    fs.writeFileSync(projectPath, iosProject.writeSync());

    if (semver.gte(reactNativePlugin.version!, '0.61.0')) {
      // For full iOS container generation, run 'pod install'
      // and also add all essential node_modules (needed for the build)
      // to the container
      if (!config?.iosConfig?.skipInstall) {
        const podVersionArg = ernConfig.get('podVersion')
          ? `_${ernConfig.get('podVersion')}_`
          : '';

        const podRepoUpdateArg = config?.iosConfig?.podRepoUpdate
          ? '--repo-update'
          : '';

        const podCmdArgs = [
          podVersionArg,
          'install',
          podRepoUpdateArg,
          '--verbose',
        ].filter((x: string) => x !== '');

        shell.pushd(config.outDir);

        try {
          await kax
            .task(`Running pod ${podCmdArgs.join(' ')}`)
            .run(childProcess.spawnp('pod', podCmdArgs));
        } finally {
          shell.popd();
        }

        //
        // Clean node_modules by only keeping the directories that are
        // needed for proper container build.
        shell.pushd(config.outDir);
        try {
          //
          // Look in the Pods pbxproj for any references to some files
          // kepts in some node_module subdirectory (basically react-native
          // as well as all native modules)
          const f = fs.readFileSync('Pods/Pods.xcodeproj/project.pbxproj', {
            encoding: 'utf8',
          });

          //
          // Build an array of these directories
          const re = RegExp('"?../node_modules/([^"]+)"?;', 'g');
          const matches = [];
          let match = re.exec(f);
          while (match !== null) {
            matches.push(match[1]);
            match = re.exec(f);
          }
          const res = matches
            .map((r) => r.split('/'))
            .filter((x) => x[0] !== 'react-native')
            .map((x) => x.join('/'))
            .concat('react-native');

          //
          // Copy all retained directories from 'node_modules'
          // to a new directory 'node_modules_light'
          const nodeModulesLightDir = 'node_modules_light';
          const nodeModulesDir = 'node_modules';
          shell.mkdir('-p', nodeModulesLightDir);
          for (const b of res) {
            shell.mkdir('-p', path.join(nodeModulesLightDir, b));
            shell.cp(
              '-Rf',
              path.join(nodeModulesDir, b, '{.*,*}'),
              path.join(nodeModulesLightDir, b),
            );
          }
          //
          // Replace the huge 'node_modules' directory with the skimmed one
          shell.rm('-rf', nodeModulesDir);
          shell.mv(nodeModulesLightDir, nodeModulesDir);
          //
          // Finally get rid of all android directories to further reduce
          // overall 'node_modules' directory size, as they are not needed
          // for iOS container builds.
          shell.rm('-rf', path.join(nodeModulesDir, '**/android'));

          const codegenVersion = iosUtil.getReactNativeCodegenVersion(
            reactNativePlugin.version,
          );
          if (codegenVersion) {
            // Starting with React Native 0.64.0, code generation for Turbo Modules
            // is performed using react-native-codegen package.
            // The package entry point is invoked during Xcode build of FBReactNativeSpec
            // iOS project (run as a build phase script).
            // It therefore needs to be present in the node modules of the Container.
            //
            // TODO : Dig deeper to figure out if we could instead call this script during
            // container generation and get rid of the the build script phase after doing
            // that, so that we don't clutter node_modules of the container pushed to git
            // and that Node does not have to be a requirement to build containers.
            await this.addReactNativeCodegen(config.outDir, codegenVersion);
          }
        } finally {
          shell.popd();
        }
      }
    }
  }

  public async addReactNativeCodegen(targetDir: string, version: string) {
    log.debug('Adding react-native-codegen package');
    const tmpDir = createTmpDir();
    shell.pushd(tmpDir);
    try {
      await yarn.init();
      await yarn.add(PackagePath.fromString(`react-native-codegen@${version}`));
      // mkdirp and invariant are also needed
      await yarn.add(PackagePath.fromString('mkdirp'));
      await yarn.add(PackagePath.fromString('invariant'));

      // yargs is needed since this package is missing from generate-specs-cli script. - https://github.com/facebook/react-native/issues/36315
      // Resolved from RN 0.72.0-rc.0 to prevent script failures - https://github.com/facebook/react-native/commit/5093e557efac35632d99cd2094527f9e01cbc519
      await yarn.add(PackagePath.fromString('yargs'));

      shell.rm('-rf', [
        'package.json',
        'yarn.lock',
        'node_modules/.yarn-integrity',
      ]);
      shell.cp('-Rf', path.join(tmpDir, 'node_modules'), targetDir);
    } finally {
      shell.popd();
    }
  }

  // Code to keep backward compatibility
  public switchToOldDirectoryStructure(
    pluginSourcePath: string,
    tail: string,
  ): boolean {
    // This is to check if the api referenced during container generation is created using the old or new directory structure to help keep the backward compatibility.
    const pathToSwaggersAPIs = path.join(
      'IOS',
      'IOS',
      'Classes',
      'SwaggersAPIs',
    );
    if (
      path.dirname(tail) === 'IOS' &&
      fs.pathExistsSync(
        path.join(pluginSourcePath, path.dirname(pathToSwaggersAPIs)),
      )
    ) {
      return true;
    }
    return false;
  }

  public async buildiOSPluginsViews(
    plugins: PackagePath[],
    mustacheView: any,
  ): Promise<any> {
    mustacheView.plugins = await generatePluginsMustacheViews(plugins, 'ios');
  }

  public async addiOSPluginHookClasses(
    containerIosProject: any,
    plugins: PackagePath[],
    outDir: string,
  ): Promise<any> {
    for (const plugin of plugins) {
      if (plugin.name === 'react-native') {
        continue;
      }
      const pluginConfig: PluginConfig<'ios'> | undefined =
        await manifest.getPluginConfig(plugin, 'ios');
      if (!pluginConfig) {
        log.warn(
          `${plugin.name} does not have any injection configuration for ios platform`,
        );
        continue;
      }

      const { pluginHook } = pluginConfig!;

      if (pluginHook?.name) {
        if (!pluginConfig.path) {
          throw new Error('No plugin config path was set. Cannot proceed.');
        }

        const pluginConfigPath = pluginConfig.path;
        const pathToCopyPluginHooksTo = path.join(outDir, 'ElectrodeContainer');

        log.debug(`Adding ${pluginHook.name}.h`);
        const pathToPluginHookHeader = path.join(
          pluginConfigPath,
          `${pluginHook.name}.h`,
        );
        shell.cp(pathToPluginHookHeader, pathToCopyPluginHooksTo);
        containerIosProject.addHeaderFile(
          `${pluginHook.name}.h`,
          { public: true },
          containerIosProject.findPBXGroupKey({ name: 'ElectrodeContainer' }),
        );

        log.debug(`Adding ${pluginHook.name}.m`);
        const pathToPluginHookSource = path.join(
          pluginConfigPath,
          `${pluginHook.name}.m`,
        );
        shell.cp(pathToPluginHookSource, pathToCopyPluginHooksTo);
        containerIosProject.addSourceFile(
          `${pluginHook.name}.m`,
          null,
          containerIosProject.findPBXGroupKey({ name: 'ElectrodeContainer' }),
        );
      }
    }
  }

  public async getIosContainerProject(
    containerProjectPath: string,
  ): Promise<any> {
    const containerProject = xcode.project(containerProjectPath);
    return new Promise((resolve, reject) => {
      containerProject.parse((err: any) => {
        if (err) {
          reject(err);
        }
        resolve(containerProject);
      });
    });
  }

  public async buildApiImplPluginViews(
    plugins: PackagePath[],
    composite: Composite,
    mustacheView: any,
    projectSpec: any,
  ) {
    for (const plugin of plugins) {
      const pluginConfig = await manifest.getPluginConfig(
        plugin,
        'ios',
        projectSpec.projectName,
      );
      if (!pluginConfig) {
        continue;
      }

      if (await utils.isDependencyPathNativeApiImpl(plugin.basePath)) {
        populateApiImplMustacheView(plugin.basePath, mustacheView, true);
      }
    }

    if (mustacheView.apiImplementations) {
      mustacheView.hasApiImpl = true;
      for (const api of mustacheView.apiImplementations) {
        if (api.hasConfig) {
          mustacheView.hasAtleastOneApiImplConfig = true;
          break;
        }
      }
    }
  }

  public async addMiniAppNavigationControllerClasses(
    config: ContainerGeneratorConfig,
    containerIosProject: any,
  ) {
    const partialProxy = (name: string) => {
      return fs.readFileSync(
        path.join(PATH_TO_TEMPLATES_DIR, `${name}.mustache`),
        'utf8',
      );
    };

    log.debug('Creating miniapps config');
    const configFileName = `MiniAppsConfig.swift`;
    const pathToMiniAppsConfigMustacheTemplate = path.join(
      PATH_TO_TEMPLATES_DIR,
      'MiniAppsConfig.mustache',
    );
    const pathToOutputConfigFile = path.join(
      config.outDir,
      'ElectrodeContainer',
      'MiniAppNavigationControllers',
      configFileName,
    );
    const mustacheView: any = {};
    mustacheView.miniApps = await config.composite.getMiniApps();
    await mustacheUtils.mustacheRenderToOutputFileUsingTemplateFile(
      pathToMiniAppsConfigMustacheTemplate,
      mustacheView,
      pathToOutputConfigFile,
      partialProxy,
    );
    const relativePathToConfigFile = path.join(
      'MiniAppNavigationControllers',
      configFileName,
    );
    containerIosProject.addFile(
      relativePathToConfigFile,
      containerIosProject.findPBXGroupKey({
        name: 'MiniAppNavigationControllers',
      }),
    );
    containerIosProject.addSourceFile(
      relativePathToConfigFile,
      null,
      containerIosProject.findPBXGroupKey({
        name: 'MiniAppNavigationControllers',
      }),
    );

    log.debug('Creating miniapp nav controllers');
    const compositeMiniApps = await config.composite.getMiniApps();
    for (const miniApp of compositeMiniApps) {
      const navControllerFileName = `${miniApp.pascalCaseName}NavigationController.swift`;

      log.debug(`Creating ${navControllerFileName}`);
      const pathToMiniAppNavControllerMustacheTemplate = path.join(
        PATH_TO_TEMPLATES_DIR,
        'MiniAppNavigationController.mustache',
      );
      const pathToOutputNavControllerFile = path.join(
        config.outDir,
        'ElectrodeContainer',
        'MiniAppNavigationControllers',
        navControllerFileName,
      );
      await mustacheUtils.mustacheRenderToOutputFileUsingTemplateFile(
        pathToMiniAppNavControllerMustacheTemplate,
        miniApp,
        pathToOutputNavControllerFile,
        partialProxy,
      );
      const relativePathToNavControllerFile = path.join(
        'MiniAppNavigationControllers',
        navControllerFileName,
      );
      containerIosProject.addFile(
        relativePathToNavControllerFile,
        containerIosProject.findPBXGroupKey({
          name: 'MiniAppNavigationControllers',
        }),
      );
      containerIosProject.addSourceFile(
        relativePathToNavControllerFile,
        null,
        containerIosProject.findPBXGroupKey({
          name: 'MiniAppNavigationControllers',
        }),
      );
    }
  }
}

1	import {	15✔
2	childProcess,
3	createTmpDir,
4	injectReactNativeVersionKeysInObject,
5	iosUtil,
6	kax,
7	log,
8	manifest,
9	mustacheUtils,
10	NativePlatform,
11	PackagePath,
12	PluginConfig,
13	readPackageJson,
14	shell,
15	utils,
16	writePackageJson,
17	yarn,
18	config as ernConfig,
19	} from 'ern-core';
20	import {	15✔
21	ContainerGenerator,
22	ContainerGeneratorConfig,
23	ContainerGenResult,
24	generateContainer,
25	generatePluginsMustacheViews,
26	populateApiImplMustacheView,
27	} from 'ern-container-gen';
28
29	import fs from 'fs-extra';	15✔
30	import path from 'path';	15✔
31	import xcode from 'xcode-ern';	15✔
32	import _ from 'lodash';	15✔
33	import readDir from 'fs-readdir-recursive';	15✔
34	import { Composite } from 'ern-composite-gen';
35	import semver from 'semver';	15✔
36
37	const ROOT_DIR = process.cwd();	15✔
38	const PATH_TO_TEMPLATES_DIR = path.join(__dirname, 'templates');	15✔
39	const PATH_TO_HULL_DIR = path.join(__dirname, 'hull');	15✔
40
41	export default class IosGenerator implements ContainerGenerator {	15✔
42	get name(): string {
43	return 'IosGenerator';	×
44	}
45
46	get platform(): NativePlatform {
47	return 'ios';	×
48	}
49
50	public async generate(
51	config: ContainerGeneratorConfig,
52	): Promise<ContainerGenResult> {
53	return generateContainer(config, {	×
54	fillContainerHull: this.fillContainerHull.bind(this),
55	postCopyRnpmAssets: this.addResources.bind(this),
56	});
57	}
58
59	public async addResources(config: ContainerGeneratorConfig) {
60	const containerProjectPath = path.join(	×
61	config.outDir,
62	'ElectrodeContainer.xcodeproj',
63	'project.pbxproj',
64	);
65	const containerIosProject = await this.getIosContainerProject(	×
66	containerProjectPath,
67	);
68
69	const containerResourcesPath = path.join(	×
70	config.outDir,
71	'ElectrodeContainer',
72	'Resources',
73	);
74	// Get all resources files from the 'Resources' directory
75	// Some processing is done here to properly handle `.xcassets`
76	// files which are directories containing assets.
77	// But we don't want to add independent files from this directory
78	// to the pbxproj, but only the top level `.xcassets` directory.
79	//
80	// For example, an `xcassets` directory might look like this
81	//
82	// Media.xcassets
83	// ├── Contents.json
84	// ├── Face-ID.imageset
85	// │ ├── Contents.json
86	// │ └── faceid.pdf
87	// ├── IconUser.imageset
88	// │ ├── Contents.json
89	// │ └── IconUser.pdf
90	//
91	// Which will result in recursive readir call returning the
92	// following paths
93	//
94	// Media.xcassets/Contents.json
95	// Media.xcassets/Face-ID.imageset/Contents.json
96	// Media.xcassets/Face-ID.imageset/faceid.pdf
97	// ...
98	//
99	// Each of these individual files would then wrongly be
100	// added to the pbxproj as resources.
101	// However we just want top level directory Media.xcassets
102	// to be added to the pbxproj, thus the special processing.
103	const resourceFiles = _.uniq(	×
104	readDir(containerResourcesPath).map((f) =>
105	f.replace(/(\.xcassets)(\/.+)$/, '$1'),	×
106	),
107	);
108	resourceFiles.forEach((resourceFile) => {	×
109	containerIosProject.addResourceFile(	×
110	path.join('Resources', resourceFile),
111	null,
112	containerIosProject.findPBXGroupKey({ name: 'Resources' }),
113	);
114	});
115
116	fs.writeFileSync(containerProjectPath, containerIosProject.writeSync());	×
117	}
118
119	public async fillContainerHull(
120	config: ContainerGeneratorConfig,
121	): Promise<void> {
122	if (process.platform !== 'darwin' && !config?.iosConfig?.skipInstall) {	×
123	throw new Error(	×
124	`Full iOS Container generation with pod installation is only supported on macOS.
125	You can set 'iosConfig.skipInstall' in container generator config to skip the installation step.
126	Or set --skipInstall if using the create-container command.`,
127	);
128	}
129
130	if (config?.iosConfig?.skipInstall) {	×
131	log.info(	×
132	`skipInstall option is set. 'yarn install' and 'pod install' won't be run after container generation.
133	Make sure to run these commands before building the container.`,
134	);
135	}
136
137	const pathSpec = {	×
138	outputDir: config.outDir,
139	projectHullDir: path.join(PATH_TO_HULL_DIR, '{.,}'),
140	rootDir: ROOT_DIR,
141	};
142
143	const reactNativePlugin = _.find(	×
144	config.plugins,
145	(p) => p.name === 'react-native',	×
146	);
147	if (!reactNativePlugin) {	×
148	throw new Error('react-native was not found in plugins list !');	×
149	}
150	if (!reactNativePlugin.version) {	×
151	throw new Error('react-native plugin does not have a version !');	×
152	}
153
154	const mustacheView: any = {};	×
155	mustacheView.jsMainModuleName = config.jsMainModuleName \|\| 'index';	×
156	mustacheView.iosDeploymentTarget =	×
157	config.iosConfig?.deploymentTarget ??	×
158	iosUtil.getDefaultIosDeploymentTarget(reactNativePlugin.version);
159
160	injectReactNativeVersionKeysInObject(	×
161	mustacheView,
162	reactNativePlugin.version,
163	);
164
165	const projectSpec = {	×
166	deploymentTarget: mustacheView.iosDeploymentTarget,
167	projectName: 'ElectrodeContainer',
168	};
169
170	await kax	×
171	.task('Preparing Native Dependencies Injection')
172	.run(this.buildiOSPluginsViews(config.plugins, mustacheView));
173
174	await kax	×
175	.task('Preparing API Implementations Injection')
176	.run(
177	this.buildApiImplPluginViews(
178	config.plugins,
179	config.composite,
180	mustacheView,
181	projectSpec,
182	),
183	);
184
185	if (semver.gte(reactNativePlugin.version!, '0.61.0')) {	×
186	shell.pushd(config.outDir);	×
187	try {	×
188	await yarn.init();	×
189
190	// Add @react-native-community/cli-platform-ios because
191	// it contains the scripts needed for native modules pods linking
192	// look in composite to match proper version
193	const compositeNodeModulesPath = path.join(	×
194	config.composite.path,
195	'node_modules',
196	);
197	const cliPlatformIosPkg = '@react-native-community/cli-platform-ios';	×
198	const cliPlatformIosPkgVersion = (	×
199	await readPackageJson(
200	path.join(compositeNodeModulesPath, cliPlatformIosPkg),
201	)
202	).version;
203
204	await yarn.add(	×
205	PackagePath.fromString(
206	`${cliPlatformIosPkg}@${cliPlatformIosPkgVersion}`,
207	),
208	);
209
210	await yarn.add(	×
211	PackagePath.fromString(`react-native@${reactNativePlugin.version}`),
212	);
213
214	//
215	// Add all native dependencies to package.json dependencies so that
216	// !use_native_modules can detect them to add their pod to the Podfile
217	const dependencies = await config.composite.getNativeDependencies({});	×
218	const resDependencies = [	×
219	...dependencies.thirdPartyInManifest,
220	...dependencies.thirdPartyNotInManifest,
221	];
222
223	const addDependencies: any = {};	×
224	resDependencies.forEach((p) => {	×
225	addDependencies[p.name!] = p.version;	×
226	});
227
228	//
229	// Create package.json in container directory root
230	// so that native modules pods can be resolved
231	// by use_native_modules! RN ruby script
232	const pjsonObj = {	×
233	dependencies: addDependencies,
234	name: 'container',
235	private: true,
236	};
237	await writePackageJson(config.outDir, pjsonObj);	×
238
239	//
240	// Copy all native dependencies from composite node_modules
241	// to container node_modules so that pods can be found local
242	// to the container directory
243	// [only for full iOS container generation]
244	if (!config?.iosConfig?.skipInstall) {	×
245	const containerNodeModulesPath = path.join(	×
246	config.outDir,
247	'node_modules',
248	);
249	shell.mkdir('-p', containerNodeModulesPath);	×
250	resDependencies.forEach((p) => {	×
251	const depPath = p.basePath!.match(/node_modules\/(.+)/)![1];	×
252	const targetPath = path.join(containerNodeModulesPath, depPath);	×
253	shell.mkdir('-p', targetPath);	×
254	shell.cp('-rf', path.join(p.basePath!, '{.,}'), targetPath);	×
255	});
256	} else {
257	shell.rm('-rf', 'node_modules');	×
258	}
259	} finally {
260	shell.popd();	×
261	}
262	}
263
264	const { iosProject, projectPath } = await iosUtil.fillProjectHull(	×
265	pathSpec,
266	projectSpec,
267	config.plugins,
268	mustacheView,
269	config.composite,
270	config.iosConfig,
271	);
272
273	await kax	×
274	.task('Adding MiniAppNavigationController Classes')
275	.run(this.addMiniAppNavigationControllerClasses(config, iosProject));
276
277	await kax	×
278	.task('Adding Native Dependencies Hooks')
279	.run(
280	this.addiOSPluginHookClasses(iosProject, config.plugins, config.outDir),
281	);
282
283	fs.writeFileSync(projectPath, iosProject.writeSync());	×
284
285	if (semver.gte(reactNativePlugin.version!, '0.61.0')) {	×
286	// For full iOS container generation, run 'pod install'
287	// and also add all essential node_modules (needed for the build)
288	// to the container
289	if (!config?.iosConfig?.skipInstall) {	×
290	const podVersionArg = ernConfig.get('podVersion')	×
291	? `_${ernConfig.get('podVersion')}_`	×
292	: '';
293
NEW 294	const podRepoUpdateArg = config?.iosConfig?.podRepoUpdate	×
295	? '--repo-update'	×
296	: '';
297
NEW 298	const podCmdArgs = [	×
299	podVersionArg,
300	'install',
301	podRepoUpdateArg,
302	'--verbose',
NEW 303	].filter((x: string) => x !== '');	×
304
305	shell.pushd(config.outDir);	×
306
307	try {	×
308	await kax	×
309	.task(`Running pod ${podCmdArgs.join(' ')}`)
310	.run(childProcess.spawnp('pod', podCmdArgs));
311	} finally {
312	shell.popd();	×
313	}
314
315	//
316	// Clean node_modules by only keeping the directories that are
317	// needed for proper container build.
318	shell.pushd(config.outDir);	×
319	try {	×
320	//
321	// Look in the Pods pbxproj for any references to some files
322	// kepts in some node_module subdirectory (basically react-native
323	// as well as all native modules)
324	const f = fs.readFileSync('Pods/Pods.xcodeproj/project.pbxproj', {	×
325	encoding: 'utf8',
326	});
327
328	//
329	// Build an array of these directories
330	const re = RegExp('"?../node_modules/([^"]+)"?;', 'g');	×
331	const matches = [];	×
332	let match = re.exec(f);	×
333	while (match !== null) {	×
334	matches.push(match[1]);	×
335	match = re.exec(f);	×
336	}
337	const res = matches	×
338	.map((r) => r.split('/'))	×
339	.filter((x) => x[0] !== 'react-native')	×
340	.map((x) => x.join('/'))	×
341	.concat('react-native');
342
343	//
344	// Copy all retained directories from 'node_modules'
345	// to a new directory 'node_modules_light'
346	const nodeModulesLightDir = 'node_modules_light';	×
347	const nodeModulesDir = 'node_modules';	×
348	shell.mkdir('-p', nodeModulesLightDir);	×
349	for (const b of res) {	×
350	shell.mkdir('-p', path.join(nodeModulesLightDir, b));	×
351	shell.cp(	×
352	'-Rf',
353	path.join(nodeModulesDir, b, '{.,}'),
354	path.join(nodeModulesLightDir, b),
355	);
356	}
357	//
358	// Replace the huge 'node_modules' directory with the skimmed one
359	shell.rm('-rf', nodeModulesDir);	×
360	shell.mv(nodeModulesLightDir, nodeModulesDir);	×
361	//
362	// Finally get rid of all android directories to further reduce
363	// overall 'node_modules' directory size, as they are not needed
364	// for iOS container builds.
365	shell.rm('-rf', path.join(nodeModulesDir, '**/android'));	×
366
367	const codegenVersion = iosUtil.getReactNativeCodegenVersion(	×
368	reactNativePlugin.version,
369	);
370	if (codegenVersion) {	×
371	// Starting with React Native 0.64.0, code generation for Turbo Modules
372	// is performed using react-native-codegen package.
373	// The package entry point is invoked during Xcode build of FBReactNativeSpec
374	// iOS project (run as a build phase script).
375	// It therefore needs to be present in the node modules of the Container.
376	//
377	// TODO : Dig deeper to figure out if we could instead call this script during
378	// container generation and get rid of the the build script phase after doing
379	// that, so that we don't clutter node_modules of the container pushed to git
380	// and that Node does not have to be a requirement to build containers.
381	await this.addReactNativeCodegen(config.outDir, codegenVersion);	×
382	}
383	} finally {
384	shell.popd();	×
385	}
386	}
387	}
388	}
389
390	public async addReactNativeCodegen(targetDir: string, version: string) {
391	log.debug('Adding react-native-codegen package');	×
392	const tmpDir = createTmpDir();	×
393	shell.pushd(tmpDir);	×
394	try {	×
395	await yarn.init();	×
396	await yarn.add(PackagePath.fromString(`react-native-codegen@${version}`));	×
397	// mkdirp and invariant are also needed
398	await yarn.add(PackagePath.fromString('mkdirp'));	×
399	await yarn.add(PackagePath.fromString('invariant'));	×
400
401	// yargs is needed since this package is missing from generate-specs-cli script. - https://github.com/facebook/react-native/issues/36315
402	// Resolved from RN 0.72.0-rc.0 to prevent script failures - https://github.com/facebook/react-native/commit/5093e557efac35632d99cd2094527f9e01cbc519
403	await yarn.add(PackagePath.fromString('yargs'));	×
404
405	shell.rm('-rf', [	×
406	'package.json',
407	'yarn.lock',
408	'node_modules/.yarn-integrity',
409	]);
410	shell.cp('-Rf', path.join(tmpDir, 'node_modules'), targetDir);	×
411	} finally {
412	shell.popd();	×
413	}
414	}
415
416	// Code to keep backward compatibility
417	public switchToOldDirectoryStructure(
418	pluginSourcePath: string,
419	tail: string,
420	): boolean {
421	// This is to check if the api referenced during container generation is created using the old or new directory structure to help keep the backward compatibility.
422	const pathToSwaggersAPIs = path.join(	×
423	'IOS',
424	'IOS',
425	'Classes',
426	'SwaggersAPIs',
427	);
428	if (	×
429	path.dirname(tail) === 'IOS' &&	×
430	fs.pathExistsSync(
431	path.join(pluginSourcePath, path.dirname(pathToSwaggersAPIs)),
432	)
433	) {
434	return true;	×
435	}
436	return false;	×
437	}
438
439	public async buildiOSPluginsViews(
440	plugins: PackagePath[],
441	mustacheView: any,
442	): Promise<any> {
443	mustacheView.plugins = await generatePluginsMustacheViews(plugins, 'ios');	×
444	}
445
446	public async addiOSPluginHookClasses(
447	containerIosProject: any,
448	plugins: PackagePath[],
449	outDir: string,
450	): Promise<any> {
451	for (const plugin of plugins) {	×
452	if (plugin.name === 'react-native') {	×
453	continue;	×
454	}
455	const pluginConfig: PluginConfig<'ios'> \| undefined =
456	await manifest.getPluginConfig(plugin, 'ios');	×
457	if (!pluginConfig) {	×
458	log.warn(	×
459	`${plugin.name} does not have any injection configuration for ios platform`,
460	);
461	continue;	×
462	}
463
464	const { pluginHook } = pluginConfig!;	×
465
466	if (pluginHook?.name) {	×
467	if (!pluginConfig.path) {	×
468	throw new Error('No plugin config path was set. Cannot proceed.');	×
469	}
470
471	const pluginConfigPath = pluginConfig.path;	×
472	const pathToCopyPluginHooksTo = path.join(outDir, 'ElectrodeContainer');	×
473
474	log.debug(`Adding ${pluginHook.name}.h`);	×
475	const pathToPluginHookHeader = path.join(	×
476	pluginConfigPath,
477	`${pluginHook.name}.h`,
478	);
479	shell.cp(pathToPluginHookHeader, pathToCopyPluginHooksTo);	×
480	containerIosProject.addHeaderFile(	×
481	`${pluginHook.name}.h`,
482	{ public: true },
483	containerIosProject.findPBXGroupKey({ name: 'ElectrodeContainer' }),
484	);
485
486	log.debug(`Adding ${pluginHook.name}.m`);	×
487	const pathToPluginHookSource = path.join(	×
488	pluginConfigPath,
489	`${pluginHook.name}.m`,
490	);
491	shell.cp(pathToPluginHookSource, pathToCopyPluginHooksTo);	×
492	containerIosProject.addSourceFile(	×
493	`${pluginHook.name}.m`,
494	null,
495	containerIosProject.findPBXGroupKey({ name: 'ElectrodeContainer' }),
496	);
497	}
498	}
499	}
500
501	public async getIosContainerProject(
502	containerProjectPath: string,
503	): Promise<any> {
504	const containerProject = xcode.project(containerProjectPath);	×
505	return new Promise((resolve, reject) => {	×
506	containerProject.parse((err: any) => {	×
507	if (err) {	×
508	reject(err);	×
509	}
510	resolve(containerProject);	×
511	});
512	});
513	}
514
515	public async buildApiImplPluginViews(
516	plugins: PackagePath[],
517	composite: Composite,
518	mustacheView: any,
519	projectSpec: any,
520	) {
521	for (const plugin of plugins) {	×
522	const pluginConfig = await manifest.getPluginConfig(	×
523	plugin,
524	'ios',
525	projectSpec.projectName,
526	);
527	if (!pluginConfig) {	×
528	continue;	×
529	}
530
531	if (await utils.isDependencyPathNativeApiImpl(plugin.basePath)) {	×
532	populateApiImplMustacheView(plugin.basePath, mustacheView, true);	×
533	}
534	}
535
536	if (mustacheView.apiImplementations) {	×
537	mustacheView.hasApiImpl = true;	×
538	for (const api of mustacheView.apiImplementations) {	×
539	if (api.hasConfig) {	×
540	mustacheView.hasAtleastOneApiImplConfig = true;	×
541	break;	×
542	}
543	}
544	}
545	}
546
547	public async addMiniAppNavigationControllerClasses(
548	config: ContainerGeneratorConfig,
549	containerIosProject: any,
550	) {
551	const partialProxy = (name: string) => {	×
552	return fs.readFileSync(	×
553	path.join(PATH_TO_TEMPLATES_DIR, `${name}.mustache`),
554	'utf8',
555	);
556	};
557
558	log.debug('Creating miniapps config');	×
559	const configFileName = `MiniAppsConfig.swift`;	×
560	const pathToMiniAppsConfigMustacheTemplate = path.join(	×
561	PATH_TO_TEMPLATES_DIR,
562	'MiniAppsConfig.mustache',
563	);
564	const pathToOutputConfigFile = path.join(	×
565	config.outDir,
566	'ElectrodeContainer',
567	'MiniAppNavigationControllers',
568	configFileName,
569	);
570	const mustacheView: any = {};	×
571	mustacheView.miniApps = await config.composite.getMiniApps();	×
572	await mustacheUtils.mustacheRenderToOutputFileUsingTemplateFile(	×
573	pathToMiniAppsConfigMustacheTemplate,
574	mustacheView,
575	pathToOutputConfigFile,
576	partialProxy,
577	);
578	const relativePathToConfigFile = path.join(	×
579	'MiniAppNavigationControllers',
580	configFileName,
581	);
582	containerIosProject.addFile(	×
583	relativePathToConfigFile,
584	containerIosProject.findPBXGroupKey({
585	name: 'MiniAppNavigationControllers',
586	}),
587	);
588	containerIosProject.addSourceFile(	×
589	relativePathToConfigFile,
590	null,
591	containerIosProject.findPBXGroupKey({
592	name: 'MiniAppNavigationControllers',
593	}),
594	);
595
596	log.debug('Creating miniapp nav controllers');	×
597	const compositeMiniApps = await config.composite.getMiniApps();	×
598	for (const miniApp of compositeMiniApps) {	×
599	const navControllerFileName = `${miniApp.pascalCaseName}NavigationController.swift`;	×
600
601	log.debug(`Creating ${navControllerFileName}`);	×
602	const pathToMiniAppNavControllerMustacheTemplate = path.join(	×
603	PATH_TO_TEMPLATES_DIR,
604	'MiniAppNavigationController.mustache',
605	);
606	const pathToOutputNavControllerFile = path.join(	×
607	config.outDir,
608	'ElectrodeContainer',
609	'MiniAppNavigationControllers',
610	navControllerFileName,
611	);
612	await mustacheUtils.mustacheRenderToOutputFileUsingTemplateFile(	×
613	pathToMiniAppNavControllerMustacheTemplate,
614	miniApp,
615	pathToOutputNavControllerFile,
616	partialProxy,
617	);
618	const relativePathToNavControllerFile = path.join(	×
619	'MiniAppNavigationControllers',
620	navControllerFileName,
621	);
622	containerIosProject.addFile(	×
623	relativePathToNavControllerFile,
624	containerIosProject.findPBXGroupKey({
625	name: 'MiniAppNavigationControllers',
626	}),
627	);
628	containerIosProject.addSourceFile(	×
629	relativePathToNavControllerFile,
630	null,
631	containerIosProject.findPBXGroupKey({
632	name: 'MiniAppNavigationControllers',
633	}),
634	);
635	}
636	}
637	}

electrode-io / electrode-native / 7175

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous