expo-type-information 0.0.0 → 0.0.2

package/src/commands/generateModuleTypesCommand.ts

@@ -0,0 +1,39 @@
+import chalk from 'chalk';
+import commander from 'commander';
+
+import {
+  addCommonOptions,
+  getFileTypeInformationFromArgs,
+  parseCommandArguments,
+  runCommandOnWatch,
+  TypeInformationCommandCommonAllArguments,
+  writeStringToFileOrPrintToConsole,
+} from './commandUtils';
+import { generateModuleTypesFileContent } from '../typescriptGeneration';
+
+export function generateModuleTypesCommand(cli: commander.Command) {
+  return addCommonOptions(cli.command('generate-module-types')).action(
+    async (options: TypeInformationCommandCommonAllArguments) => {
+      const parsedArgs = await parseCommandArguments(options);
+      if (!parsedArgs) {
+        return;
+      }
+      const { realOutputPath } = parsedArgs;
+
+      const command = async () => {
+        const typeInfo = await getFileTypeInformationFromArgs(parsedArgs);
+        if (!typeInfo) {
+          return;
+        }
+
+        const moduleTypesFileContent = await generateModuleTypesFileContent(typeInfo);
+        if (!moduleTypesFileContent) {
+          console.error(chalk.red(`Couldn't generate module types file content!`));
+          return;
+        }
+        writeStringToFileOrPrintToConsole(moduleTypesFileContent, realOutputPath);
+      };
+      runCommandOnWatch(parsedArgs, command);
+    }
+  );
+}

package/src/commands/generateViewTypesCommand.ts

@@ -0,0 +1,39 @@
+import commander from 'commander';
+
+import {
+  addCommonOptions,
+  getFileTypeInformationFromArgs,
+  parseCommandArguments,
+  runCommandOnWatch,
+  TypeInformationCommandCommonAllArguments,
+  writeStringToFileOrPrintToConsole,
+} from './commandUtils';
+import { generateViewTypesFileContent } from '../typescriptGeneration';
+
+export function generateViewTypesCommand(cli: commander.Command) {
+  return addCommonOptions(cli.command('generate-view-types')).action(
+    async (options: TypeInformationCommandCommonAllArguments) => {
+      const parsedArgs = await parseCommandArguments(options);
+      if (!parsedArgs) {
+        return;
+      }
+      const { realOutputPath } = parsedArgs;
+
+      const command = async () => {
+        const typeInfo = await getFileTypeInformationFromArgs(parsedArgs);
+        if (!typeInfo) {
+          return;
+        }
+
+        const viewTypesFileContent = await generateViewTypesFileContent(typeInfo);
+        if (!viewTypesFileContent) {
+          console.error("Couldn't generate view types!");
+          return;
+        }
+        writeStringToFileOrPrintToConsole(viewTypesFileContent, realOutputPath);
+      };
+
+      runCommandOnWatch(parsedArgs, command);
+    }
+  );
+}

package/src/commands/inlineModulesInterfaceCommand.ts

@@ -0,0 +1,175 @@
+import commander from 'commander';
+import fs from 'fs';
+import path from 'path';
+
+import {
+  debounce,
+  generateConciseTsFiles,
+  parseCommandArguments,
+  TypeInformationCommandCommonAllArguments,
+} from './commandUtils';
+import { TypeInferenceOption } from '../typeInformation';
+import { scanFilesRecursively, taskAll } from '../utils';
+
+async function getResolvedWatchedDirectoriesFromAppJson(
+  appJsonPath: string
+): Promise<string[] | null> {
+  try {
+    const appJson = JSON.parse(await fs.promises.readFile(appJsonPath, 'utf-8'));
+    const watchedDirectories = appJson?.expo?.experiments?.inlineModules?.watchedDirectories;
+
+    if (!Array.isArray(watchedDirectories)) {
+      console.error(`watchedDirectories are not defined!`);
+      return null;
+    }
+
+    const rootDir = path.dirname(path.resolve(appJsonPath));
+    return watchedDirectories.map((relativePath) => path.resolve(rootDir, relativePath));
+  } catch (e) {
+    console.error(`Couldn't read ${appJsonPath}.`, e);
+  }
+  return null;
+}
+
+type GenerateInlineModulesTSFilesOptions = {
+  filePath: string;
+  dirPath: string;
+  typeInference: TypeInferenceOption;
+};
+
+async function generateInlineModuleTSFiles({
+  filePath,
+  dirPath,
+  typeInference,
+}: GenerateInlineModulesTSFilesOptions) {
+  return await generateConciseTsFiles({
+    realInputPaths: [filePath],
+    realOutputPath: dirPath,
+    typeInference,
+    watcher: false,
+  });
+}
+
+type InlineModulesWatcherOptions = {
+  appJsonPath: string;
+  typeInference: TypeInferenceOption;
+};
+
+async function inlineModulesWatcher({ appJsonPath, typeInference }: InlineModulesWatcherOptions) {
+  const debouncedInlineModulesTsGeneration = debounce(generateInlineModuleTSFiles);
+  const watchedDirectoriesWatchers: Map<string, fs.FSWatcher> = new Map<string, fs.FSWatcher>();
+
+  const setupWatchedDirectoriesWatchers = async () => {
+    const watchedDirectories = await getResolvedWatchedDirectoriesFromAppJson(appJsonPath);
+
+    // Merge new watchers with old watchers.
+    // Let's first find and remove the obsolete ones.
+    const watchedDirsSet = new Set(watchedDirectories ?? []);
+    const obsoleteWatchersKeys = [];
+    for (const [key] of watchedDirectoriesWatchers) {
+      if (!watchedDirsSet.has(key)) {
+        obsoleteWatchersKeys.push(key);
+      }
+    }
+
+    for (const key of obsoleteWatchersKeys) {
+      const watcher = watchedDirectoriesWatchers.get(key);
+      watcher?.close();
+      watchedDirectoriesWatchers.delete(key);
+    }
+
+    // Now let's create and add new watchers
+    const createWatcherForDir = (dir: string) => {
+      return fs.watch(dir, { recursive: true, encoding: 'utf-8' }, async (event, fileName) => {
+        if (!fileName) {
+          return;
+        }
+
+        const resolvedFilePath = path.resolve(dir, fileName);
+        if (fs.existsSync(resolvedFilePath)) {
+          debouncedInlineModulesTsGeneration({
+            filePath: resolvedFilePath,
+            dirPath: path.dirname(resolvedFilePath),
+            typeInference,
+          });
+        }
+      });
+    };
+
+    for (const dir of watchedDirectories ?? []) {
+      const watcher = watchedDirectoriesWatchers.get(dir);
+      if (!watcher) {
+        watchedDirectoriesWatchers.set(dir, createWatcherForDir(dir));
+      }
+    }
+  };
+  await setupWatchedDirectoriesWatchers();
+
+  const appJsonWatcher = fs.watch(appJsonPath, 'utf-8', async (event) => {
+    if (event === 'rename' && !fs.existsSync(appJsonPath)) {
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      for (const [_, watcher] of watchedDirectoriesWatchers) {
+        watcher.close();
+      }
+      appJsonWatcher.close();
+      return;
+    }
+
+    await setupWatchedDirectoriesWatchers();
+  });
+}
+
+export async function inlineModulesInterfaceCommand(cli: commander.Command) {
+  return cli
+    .command('inline-modules-interface')
+    .summary('Creates ts interface for every Swift inline module in the project.')
+    .description(
+      'Creates ts interface for every Swift inline module in the project. The ts interface consists of two files Module.generated.ts and Module.tsx, the first one is regenerated with each run of the command and the second one will not be regenerated if user changes it.'
+    )
+    .requiredOption(
+      '-a --app-json <appJsonPathPath>',
+      'A path to the `app.json` where the inline.modules.watchedDirectories are defined.'
+    )
+    .option('-w --watcher', 'Starts a watcher that checks for changes in inline modules files.')
+    .action(async (options: TypeInformationCommandCommonAllArguments) => {
+      const parsedArgs = parseCommandArguments(options);
+      if (!parsedArgs) {
+        return;
+      }
+
+      const { appJsonPath, watcher } = parsedArgs;
+      if (!appJsonPath) {
+        return;
+      }
+
+      const watchedDirectories = await getResolvedWatchedDirectoriesFromAppJson(appJsonPath);
+      if (!watchedDirectories) {
+        return;
+      }
+
+      const dirents = [];
+      for (const dir of watchedDirectories) {
+        for await (const dirent of scanFilesRecursively(dir)) {
+          if (!dirent.name.endsWith('.swift')) {
+            continue;
+          }
+
+          dirents.push(dirent);
+        }
+      }
+
+      await taskAll(
+        dirents,
+        async (dirent) =>
+          await generateInlineModuleTSFiles({
+            filePath: dirent.path,
+            dirPath: dirent.parentPath,
+            typeInference: parsedArgs.typeInference,
+          })
+      );
+
+      if (watcher) {
+        await inlineModulesWatcher({ appJsonPath, typeInference: parsedArgs.typeInference });
+      }
+    });
+}

package/src/commands/moduleInterfaceCommand.ts

@@ -0,0 +1,56 @@
+import commander from 'commander';
+import path from 'path';
+
+import {
+  addCommonOptions,
+  getFileTypeInformationFromArgs,
+  parseCommandArguments,
+  runCommandOnWatch,
+  TypeInformationCommandCommonAllArguments,
+  writeToStableFile,
+} from './commandUtils';
+import { generateFullTsInterface } from '../typescriptGeneration';
+
+export function moduleInterfaceCommand(cli: commander.Command) {
+  return addCommonOptions(cli.command('module-interface'))
+    .summary('Generates a full ts interface for a Swift module.')
+    .description(
+      'Generates a full ts interface for a Swift module. It consists of types.ts file with all types defined in the module, module.ts with the native module definition, and view.tsx for each view defined in the module, and an index.ts file which reexports some functions.'
+    )
+    .action(async (options: TypeInformationCommandCommonAllArguments) => {
+      const parsedArgs = await parseCommandArguments(options, false);
+      if (!parsedArgs) {
+        return;
+      }
+      const { realInputPaths, realOutputPath } = parsedArgs;
+
+      const command = async () => {
+        const typeInfo = await getFileTypeInformationFromArgs(parsedArgs);
+        if (!typeInfo) {
+          return;
+        }
+        const generatedFiles = await generateFullTsInterface(typeInfo);
+        if (!generatedFiles) {
+          return;
+        }
+        const { moduleTypesFile, moduleViewsFiles, moduleNativeFile, indexFile } = generatedFiles;
+
+        const dirName = realOutputPath ?? path.dirname(realInputPaths[0] as string);
+        const writeFilePromises = [];
+        for (const outputFile of [
+          moduleTypesFile,
+          ...moduleViewsFiles,
+          moduleNativeFile,
+          indexFile,
+        ]) {
+          const outputFilePath = path.resolve(dirName, outputFile.name);
+          writeFilePromises.push(
+            writeToStableFile({ filePath: outputFilePath, content: outputFile.content })
+          );
+        }
+        await Promise.all(writeFilePromises);
+      };
+
+      runCommandOnWatch(parsedArgs, command);
+    });
+}

package/src/commands/shortModuleInterfaceCommand.ts

@@ -0,0 +1,26 @@
+import commander from 'commander';
+
+import {
+  addCommonOptions,
+  generateConciseTsFiles,
+  parseCommandArguments,
+  runCommandOnWatch,
+  TypeInformationCommandCommonAllArguments,
+} from './commandUtils';
+
+export function shortModuleInterfaceCommand(cli: commander.Command) {
+  addCommonOptions(
+    cli
+      .command('short-module-interface')
+      .summary('Creates a short ts interface, great with inline-modules.')
+      .description(
+        'Creates a short ts interface for an expo module. Overrites `ModuleName.generated.ts` and creates `ModuleName.ts` if not present. Can be used with inline-modules.'
+      )
+  ).action(async (options: TypeInformationCommandCommonAllArguments) => {
+    const parsedArgs = await parseCommandArguments(options, false);
+    if (!parsedArgs) return;
+
+    const command = () => generateConciseTsFiles(parsedArgs);
+    runCommandOnWatch(parsedArgs, command);
+  });
+}

package/src/commands/typeInformationCommand.ts

@@ -0,0 +1,35 @@
+import commander from 'commander';
+
+import {
+  addCommonOptions,
+  getFileTypeInformationFromArgs,
+  parseCommandArguments,
+  runCommandOnWatch,
+  TypeInformationCommandCommonAllArguments,
+  writeStringToFileOrPrintToConsole,
+} from './commandUtils';
+import { serializeTypeInformation } from '../typeInformation';
+
+export function typeInformationCommand(cli: commander.Command) {
+  return addCommonOptions(cli.command('type-information')).action(
+    async (options: TypeInformationCommandCommonAllArguments) => {
+      const parsedArgs = await parseCommandArguments(options);
+      if (!parsedArgs) {
+        return;
+      }
+
+      const command = async () => {
+        const typeInfo = await getFileTypeInformationFromArgs(parsedArgs);
+        if (!typeInfo) {
+          return;
+        }
+
+        const typeInfoSerialized = serializeTypeInformation(typeInfo);
+        const typeInfoSerializedString = JSON.stringify(typeInfoSerialized, null, 2);
+        writeStringToFileOrPrintToConsole(typeInfoSerializedString, parsedArgs.realOutputPath);
+      };
+
+      runCommandOnWatch(parsedArgs, command);
+    }
+  );
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './typeInformation';
+export { generateMocks, getAllExpoModulesInWorkingDirectory } from './mockgen';
+export {
+  generateConciseTsInterface,
+  generateFullTsInterface,
+  generateModuleTypesFileContent,
+  generateViewTypesFileContent,
+  generateJSXIntrinsicsFileContent,
+} from './typescriptGeneration';