@ng-native/nx 0.2.0 → 0.4.0

package/native-app.cjs

@@ -2,9 +2,9 @@
  * What an Angular Native app is made of, in an Nx workspace.
  *
  * The source of truth is `template/`, the starter `create-expo-app` uses and the setup this project
- * verifies before every release. `files/` holds verbatim copies of the template's source files and
- * the versions below are the template's own, and `native-app.test.ts` fails the moment either
- * drifts from it.
+ * verifies before every release. `files/` holds verbatim copies of the template's source files,
+ * the versions are the template's own, and `native-app.test.ts` fails the moment either drifts
+ * from it.
  *
  * Three files differ from the template's, each because of something Nx does:
  *
@@ -16,59 +16,35 @@
  * - `vitest.config.mts` adds `nxViteTsPaths` when the workspace has `@nx/vite`, for the same
  *   aliases, which Vitest does not read from tsconfig either.
  *
- * The `@ng-native/*` packages are pinned to this package's own version, because every one of them
- * is released in lockstep with it.
+ * What does not depend on Nx, the dependencies, `app.json` and bundle identifier among them, is
+ * `@ng-native/migrate/native-app.cjs`, which `@ng-native/schematics` builds its apps from too.
  */
 const { readFileSync } = require('node:fs');
 const path = require('node:path');
 const semver = require('semver');
+const shared = require('@ng-native/migrate/native-app.cjs');
 
-const { version } = require('./package.json');
-
-const FRAMEWORK = [
-  '@ng-native/components',
-  '@ng-native/device',
-  '@ng-native/fabric',
-  '@ng-native/metro',
-  '@ng-native/platform',
-];
-
-/** @type {Record<string, string>} */
-const dependencies = {
-  ...Object.fromEntries(FRAMEWORK.map((name) => [name, version])),
-  '@angular/common': '^22.0.0',
-  '@angular/core': '^22.0.0',
-  expo: '~57.0.26',
-  'expo-status-bar': '~57.0.1',
-  'expo-system-ui': '~57.0.4',
-  react: '19.2.3',
-  'react-native': '0.86.3',
-  'react-native-safe-area-context': '~5.7.0',
-};
+const { dependencies, devDependencies, accepted } = shared;
 
 /**
  * What `nx add` puts beside `@nx/expo`, in place of the `@nx/expo:init` it does not run: see
- * `init/index.cjs`. `@expo/cli` and `@babel/runtime` are the ranges the template's `expo` depends
- * on.
+ * `init/index.cjs`. `@expo/cli`, `@babel/runtime` and `@expo/metro` are the ranges the template's
+ * `expo` depends on, and `@babel/core` is the app's own, which every plugin in Expo's Babel preset peers on.
  */
 const expoCompanions = {
   'react-dom': dependencies.react,
   '@expo/cli': '^57.0.27',
   '@babel/runtime': '^7.20.0',
+  '@babel/core': devDependencies['@babel/core'],
+  '@expo/metro': '~56.0.2',
 };
 
-/** @type {Record<string, string>} */
-const devDependencies = {
-  // An Angular workspace already has Babel 8 through @angular/compiler-cli, and React Native's
-  // Babel peer would otherwise take the newest copy there is.
-  // The typecheck script compiles the templates too, which only the Angular compiler can.
-  '@angular/compiler-cli': '^22.0.0',
-  '@babel/core': '^7.29.7',
-  '@ng-native/testing': version,
-  '@types/react': '~19.2.2',
-  typescript: '~6.0.3',
-  vitest: '^5.0.0',
-};
+/**
+ * The template's `typecheck` script. It loads the Metro config first, which builds the sheet
+ * `@ng-native/tailwind` generates into `.angular-native/` once and exits: `src/main.ts` imports it
+ * once Tailwind is added, and a fresh checkout has none until Metro has run.
+ */
+const TYPECHECK = 'node metro.config.js && ngc -p tsconfig.json --noEmit';
 
 /** The template's files, copied verbatim into the new app. */
 const SOURCE_FILES = ['src/app/app.ts', 'src/main.ts', 'src/app/app.test.ts'];
@@ -91,74 +67,6 @@ function agentsFile(commands) {
   );
 }
 
-/** Java's reserved words, which Android refuses as a segment of a package name. */
-const JAVA_KEYWORDS = new Set(
-  (
-    'abstract assert boolean break byte case catch char class const continue default do double ' +
-    'else enum extends false final finally float for goto if implements import instanceof int ' +
-    'interface long native new null package private protected public return short static ' +
-    'strictfp super switch synchronized this throw throws transient true try void volatile while'
-  ).split(' '),
-);
-
-/**
- * Whether iOS takes `id` as a bundle identifier and Android as a package name: two or more
- * segments, each a letter and then letters or digits (iOS refuses `_`, Android `-`), none of them
- * a Java keyword.
- *
- * @param {string} id
- */
-function isBundleIdentifier(id) {
-  const segments = id.split('.');
-  return (
-    segments.length > 1 &&
-    segments.every((s) => /^[a-z][a-z0-9]*$/i.test(s) && !JAVA_KEYWORDS.has(s))
-  );
-}
-
-/**
- * `com.<scope>.<name>`, for an app given no `--bundleIdentifier`, where prebuild would otherwise
- * make it `com.anonymous.<name>`. The scope is left out when it cannot be made a segment.
- *
- * @param {string} name the app's name, without a scope
- * @param {string | undefined} scope the workspace's npm scope, `@acme`
- */
-function bundleIdentifier(name, scope) {
-  const clean = (text) => text.toLowerCase().replace(/[^a-z0-9]/g, '');
-  const valid = (segment) => /^[a-z]/.test(segment) && !JAVA_KEYWORDS.has(segment);
-  const org = clean(scope ?? '');
-  const app = clean(name);
-  return ['com', ...(valid(org) ? [org] : []), valid(app) ? app : `app${app}`].join('.');
-}
-
-/**
- * The template's `app.json`, named for this app, without the template's icons: they are the
- * template's branding, and Expo draws its own default until `icon` is set.
- *
- * @param {string} name the project name, which is also the Expo slug
- * @param {string} [id] the iOS bundle identifier and Android package, by default one from `name`
- */
-function appJson(name, id) {
-  const slug = name.replace(/^@[^/]+\//, '');
-  const bundle = id ?? bundleIdentifier(slug, name.match(/^@[^/]+/)?.[0]);
-  const expo = {
-    name: slug,
-    slug,
-    version: '1.0.0',
-    // Not left to Expo, which adds `web` whenever `react-dom` resolves, and @nx/react puts one there.
-    platforms: ['ios', 'android'],
-    orientation: 'portrait',
-    userInterfaceStyle: 'dark',
-    ios: { supportsTablet: true, bundleIdentifier: bundle },
-    android: { package: bundle, predictiveBackGestureEnabled: false },
-    scheme: slug.replace(/[^a-z0-9]/gi, '').toLowerCase(),
-    // The template's: Expo otherwise guesses a router root from src/app and says so on every start.
-    extra: { router: { root: 'src/app' } },
-    plugins: ['@ng-native/metro'],
-  };
-  return JSON.stringify({ expo }, null, 2) + '\n';
-}
-
 const METRO_CONFIG = `const { withNxMetro } = require('@nx/expo');
 const { getDefaultConfig } = require('expo/metro-config');
 const { withAngularNative } = require('@ng-native/metro/config.cjs');
@@ -213,6 +121,31 @@ function tsconfig(workspaceBase, conditions = []) {
   };
 }
 
+/** The `@ng-native` packages with entry points beside their main one, each published in `dist`. */
+const WITH_ENTRY_POINTS = ['components', 'expo', 'platform', 'web'];
+
+/** `nx typecheck` in a workspace whose libraries are the package manager's links. */
+const TYPECHECK_ONE_COPY = TYPECHECK.replace('tsconfig.json', 'tsconfig.typecheck.json');
+
+/**
+ * The tsconfig `nx typecheck` reads where libraries are the package manager's links: the app's,
+ * with every `@ng-native` package resolved to the app's own copy.
+ *
+ * pnpm gives a library a copy of its own of a package whose peers it does not share with the app,
+ * the gesture and animation packages an app adds among them. `ngc` then finds a component a
+ * library imports in one copy and the app's import of it in the other, and stops at `NG3004`
+ * before it checks a template. The Metro preset and the Vitest plugin make the same choice where
+ * they resolve. It is a file of its own because Metro reads the `paths` of `tsconfig.json`, and
+ * these skip the `exports` of each package, its `browser` condition included.
+ */
+function typecheckTsconfig() {
+  const paths = { '@ng-native/*': ['./node_modules/@ng-native/*'] };
+  for (const name of WITH_ENTRY_POINTS) {
+    paths[`@ng-native/${name}/*`] = [`./node_modules/@ng-native/${name}/dist/*`];
+  }
+  return { extends: './tsconfig.json', compilerOptions: { paths } };
+}
+
 /** @param {boolean} withPaths whether to resolve the workspace's tsconfig path aliases */
 function vitestConfig(withPaths) {
   const template = readFileSync(path.join(__dirname, 'files', 'vitest.config.mts'), 'utf8');
@@ -226,32 +159,6 @@ function vitestConfig(withPaths) {
     .replace('plugins: [ngNative()],', 'plugins: [nxViteTsPaths(), ngNative()],');
 }
 
-/**
- * The dependencies an integrated workspace's app lists in its own `package.json`, at the ranges
- * the root installs, though nothing installs from it.
- *
- * All of them, because Expo's autolinking links the native modules the app's `package.json` names
- * and no others: without `react-native-safe-area-context` here, Android crashed on RNCSafeAreaView.
- * And `expo prebuild`, which `expo run:ios` starts with, adds `expo`, `react` or `react-native` if
- * it does not find them and then offers to install them into the app's directory, which would put a
- * second copy of React Native beside the root's.
- *
- * @param {{ dependencies?: Record<string, string>, devDependencies?: Record<string, string> }} root
- */
-function prebuildPins(root) {
-  const installed = { ...root.devDependencies, ...root.dependencies };
-  return Object.fromEntries(
-    Object.keys(dependencies).map((pkg) => [pkg, installed[pkg] ?? dependencies[pkg]]),
-  );
-}
-
-/**
- * Where what a workspace already has can be older than what a new app is given: `@ng-native/testing`
- * installs Vitest 5 but its plugin runs on 4, which `ng new` 22.1 and the Nx preset still start on.
- * The range here is that package's `vitest` peer, and a test holds the two together.
- */
-const accepted = { vitest: '^4.0.8 || ^5.0.0' };
-
 /**
  * The ranges a workspace package's `package.json` lists: the root's own where everything it can
  * resolve to is a version Angular Native accepts, so that pnpm does not install a second Vitest
@@ -276,49 +183,18 @@ function reuseRootRanges(wanted, root) {
   );
 }
 
-/**
- * Why an existing dependency would stop this app installing or running, as a sentence each.
- *
- * Only ranges already in the manifest are judged, and only a range that cannot overlap the one
- * wanted is a conflict: `~6.0.2` and `~6.0.3` resolve to the same TypeScript. A missing package is
- * added at the version above. Nothing is rewritten, because moving a workspace's Angular or Vitest
- * is an upgrade of every project in it, and that belongs to `nx migrate`, not to a generator.
- *
- * @param {{ dependencies?: Record<string, string>, devDependencies?: Record<string, string> }} manifest
- * @returns {string[]}
- */
-function conflicts(manifest) {
-  const existing = { ...manifest.dependencies, ...manifest.devDependencies };
-  const problems = [];
-  for (const [name, installed] of Object.entries({ ...dependencies, ...devDependencies })) {
-    const range = existing[name];
-    const wanted = accepted[name] ?? installed;
-    if (!range || name.startsWith('@ng-native/')) continue;
-    if (semver.validRange(range) && !semver.intersects(range, wanted)) {
-      problems.push(
-        `${name} is ${range} here, and Angular Native needs ${wanted}. ` +
-          `npm will refuse the install until it is moved.`,
-      );
-    }
-  }
-  return problems;
-}
-
 module.exports = {
-  dependencies,
-  devDependencies,
+  ...shared,
   SOURCE_FILES,
   sourceFile,
   agentsFile,
-  appJson,
-  bundleIdentifier,
-  isBundleIdentifier,
   METRO_CONFIG,
+  TYPECHECK,
+  TYPECHECK_ONE_COPY,
+  WITH_ENTRY_POINTS,
   tsconfig,
+  typecheckTsconfig,
   vitestConfig,
-  prebuildPins,
   reuseRootRanges,
   expoCompanions,
-  conflicts,
-  accepted,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ng-native/nx",
-  "version": "0.2.0",
-  "description": "Nx generators for Angular Native: nx add, and an Expo app project whose targets run it.",
+  "version": "0.4.0",
+  "description": "Nx generators for Angular Native: nx add, an Expo app project whose targets run it, and native libraries and components.",
   "keywords": [
     "angular",
     "react-native",
@@ -17,7 +17,27 @@
   ],
   "type": "module",
   "generators": "./generators.json",
+  "nx-migrations": {
+    "migrations": "./migrations.json",
+    "packageGroup": [
+      "@ng-native/components",
+      "@ng-native/device",
+      "@ng-native/expo",
+      "@ng-native/fabric",
+      "@ng-native/icons",
+      "@ng-native/metro",
+      "@ng-native/migrate",
+      "@ng-native/nx",
+      "@ng-native/platform",
+      "@ng-native/router",
+      "@ng-native/schematics",
+      "@ng-native/tailwind",
+      "@ng-native/testing",
+      "@ng-native/web"
+    ]
+  },
   "dependencies": {
+    "@ng-native/migrate": "0.4.0",
     "@nx/devkit": "^23.0.0",
     "minimatch": "^10.0.0",
     "semver": "^7.7.0"
@@ -26,12 +46,17 @@
     "nx": "^23.0.0"
   },
   "devDependencies": {
-    "@types/semver": "^7.7.0"
+    "@types/semver": "^7.7.0",
+    "typescript": "~6.0.3"
   },
   "nx": {
+    "projectType": "library",
     "tags": [
       "scope:nx",
       "layer:build"
+    ],
+    "implicitDependencies": [
+      "@ng-native/template"
     ]
   },
   "license": "MIT",
@@ -47,6 +72,7 @@
   "files": [
     "*.cjs",
     "generators.json",
+    "migrations.json",
     "*/*.cjs",
     "*/*.json",
     "files"
@@ -56,6 +82,6 @@
   },
   "scripts": {
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node --test \"*.test.ts\" \"{init,application}/*.test.ts\""
+    "test": "node --test \"*.test.ts\" \"{init,application,sync,library,component,migrations,tailwind}/*.test.ts\""
   }
 }

package/sync/index.cjs

@@ -0,0 +1,233 @@
+/**
+ * `@ng-native/nx:sync-native-modules`: lists in each Angular Native app's `package.json` the native
+ * modules the workspace libraries it uses import, and adds their config plugins to its `app.json`.
+ *
+ * Expo links only the native modules an app's own `package.json` names. Expo Go contains every
+ * module in the SDK, so an app whose library imports one the app does not list works there and
+ * fails in a development or release build. A library cannot declare what it needs of an app, but
+ * Nx's project graph records what each one imports, so this reads it from there.
+ *
+ * It is a sync generator: the app generator registers it on the app's `start`, `export` and
+ * `prebuild` targets, so Nx runs it before them, and `nx sync:check` fails a CI run it would
+ * change. It only adds. A module the app lists stays listed when no library imports it any more,
+ * since the app may use it itself.
+ *
+ * A native module is a package with an Expo module config or a native project of its own, as
+ * Expo's autolinking finds them. It counts when a library imports it, and when a package a
+ * library imports peers on it without marking the peer optional, as `@ng-native/icons` does on
+ * `react-native-svg`.
+ */
+const { existsSync, readdirSync, readFileSync } = require('node:fs');
+const nodePath = require('node:path');
+const {
+  createProjectGraphAsync,
+  formatFiles,
+  getProjects,
+  joinPathFragments,
+  readJson,
+  readProjectConfiguration,
+  updateJson,
+  updateProjectConfiguration,
+} = require('@nx/devkit');
+
+const SYNC_GENERATOR = '@ng-native/nx:sync-native-modules';
+
+/** Whether the package in `dir` has native code Expo's autolinking links. */
+function isNativeModule(dir) {
+  if (existsSync(nodePath.join(dir, 'expo-module.config.json'))) return true;
+  if (readdirSync(dir).some((file) => file.endsWith('.podspec'))) return true;
+  return ['build.gradle', 'build.gradle.kts'].some((file) =>
+    existsSync(nodePath.join(dir, 'android', file)),
+  );
+}
+
+/** The directory `pkg` is installed in, as Node resolves it from `from`. */
+function packageDir(pkg, from) {
+  try {
+    return nodePath.dirname(require.resolve(`${pkg}/package.json`, { paths: [from] }));
+  } catch {
+    // A package whose exports leave out its package.json: up from its entry point.
+  }
+  let dir;
+  try {
+    dir = nodePath.dirname(require.resolve(pkg, { paths: [from] }));
+  } catch {
+    return undefined;
+  }
+  for (; dir !== nodePath.dirname(dir); dir = nodePath.dirname(dir)) {
+    const manifest = nodePath.join(dir, 'package.json');
+    if (existsSync(manifest) && JSON.parse(readFileSync(manifest, 'utf8')).name === pkg) return dir;
+  }
+  return undefined;
+}
+
+/** The workspace beyond the tree: its project graph and its installed packages. Replaced in tests. */
+const workspace = {
+  graph: () => createProjectGraphAsync(),
+
+  /**
+   * What `pkg`, resolved from the directory `from`, is to an app, or undefined when it is not
+   * installed.
+   *
+   * @param {string} pkg
+   * @param {string} from
+   * @returns {{ version: string, native: boolean, plugin: boolean, peers: string[], dir: string } | undefined}
+   */
+  installed(pkg, from) {
+    const dir = packageDir(pkg, from);
+    if (!dir) return undefined;
+    const manifest = JSON.parse(readFileSync(nodePath.join(dir, 'package.json'), 'utf8'));
+    const meta = manifest.peerDependenciesMeta ?? {};
+    return {
+      version: manifest.version,
+      native: isNativeModule(dir),
+      plugin: existsSync(nodePath.join(dir, 'app.plugin.js')),
+      peers: Object.keys(manifest.peerDependencies ?? {}).filter((peer) => !meta[peer]?.optional),
+      dir,
+    };
+  },
+
+  /** The config plugins Expo applies whether an app lists them or not, as `expo install` skips. */
+  autoPlugins(from) {
+    try {
+      const expo = packageDir('expo', from);
+      const config = require(require.resolve('@expo/prebuild-config', { paths: [expo ?? from] }));
+      return config.getAutoPlugins();
+    } catch {
+      return [];
+    }
+  },
+};
+
+/** The projects the app `name` depends on, directly or through another, in the graph. */
+function librariesOf(graph, name) {
+  const found = new Set();
+  const visit = (project) => {
+    for (const { target } of graph.dependencies[project] ?? []) {
+      if (!graph.nodes[target] || found.has(target) || target === name) continue;
+      found.add(target);
+      visit(target);
+    }
+  };
+  visit(name);
+  return [...found];
+}
+
+/** The packages a project imports, by name. */
+function importsOf(graph, project) {
+  return (graph.dependencies[project] ?? [])
+    .map(({ target }) => graph.externalNodes?.[target]?.data?.packageName)
+    .filter(Boolean);
+}
+
+/** Whether the project is an Angular Native app: an Expo app that runs on `@ng-native/platform`. */
+function isNativeApp(tree, root) {
+  const manifest = joinPathFragments(root, 'package.json');
+  if (!tree.exists(joinPathFragments(root, 'app.json')) || !tree.exists(manifest)) return false;
+  const { dependencies, devDependencies } = readJson(tree, manifest);
+  return Boolean({ ...dependencies, ...devDependencies }['@ng-native/platform']);
+}
+
+function listed(manifest) {
+  return { ...manifest.devDependencies, ...manifest.dependencies };
+}
+
+/**
+ * The native modules the app `name` needs for its libraries, each with the library that brings it
+ * in, the range to list and whether it has a config plugin.
+ */
+function needed(tree, graph, name) {
+  const root = listed(readJson(tree, 'package.json'));
+  const modules = new Map();
+  for (const library of librariesOf(graph, name)) {
+    const libraryRoot = graph.nodes[library].data.root;
+    const from = nodePath.join(tree.root, libraryRoot);
+    const manifest = joinPathFragments(libraryRoot, 'package.json');
+    const own = tree.exists(manifest) ? listed(readJson(tree, manifest)) : {};
+    const add = (pkg, info, via) => {
+      if (!info?.native || modules.has(pkg)) return;
+      const range = root[pkg] ?? own[pkg] ?? info.version;
+      modules.set(pkg, { library: libraryRoot, via, range, plugin: info.plugin });
+    };
+    for (const pkg of importsOf(graph, library)) {
+      const info = workspace.installed(pkg, from);
+      add(pkg, info);
+      for (const peer of info?.peers ?? []) add(peer, workspace.installed(peer, info.dir), pkg);
+    }
+  }
+  return modules;
+}
+
+/** The names in an `app.json`'s `plugins`, each a name or a `[name, options]` pair. */
+function pluginNames(plugins) {
+  return (plugins ?? []).map((plugin) => (Array.isArray(plugin) ? plugin[0] : plugin));
+}
+
+/**
+ * @param {import('@nx/devkit').Tree} tree
+ * @returns {Promise<{ outOfSyncMessage?: string, outOfSyncDetails?: string[] }>}
+ */
+async function syncNativeModules(tree) {
+  const graph = await workspace.graph();
+  const details = [];
+  for (const [name, project] of getProjects(tree)) {
+    if (!isNativeApp(tree, project.root) || !graph.nodes[name]) continue;
+    const manifestPath = joinPathFragments(project.root, 'package.json');
+    const has = listed(readJson(tree, manifestPath));
+    const all = [...needed(tree, graph, name)];
+    const modules = all.filter(([pkg]) => !(pkg in has));
+    if (modules.length > 0) {
+      updateJson(tree, manifestPath, (manifest) => {
+        manifest.dependencies ??= {};
+        for (const [pkg, { range }] of modules) manifest.dependencies[pkg] = range;
+        return manifest;
+      });
+    }
+    for (const [pkg, { library, via }] of modules) {
+      const reason = via ? `${library} imports ${via}, which needs it` : `${library} imports it`;
+      details.push(`${project.root}/package.json needs ${pkg}: ${reason}.`);
+    }
+
+    const appJson = joinPathFragments(project.root, 'app.json');
+    const auto = new Set(workspace.autoPlugins(nodePath.join(tree.root, project.root)));
+    const plugins = all.filter(([pkg, { plugin }]) => plugin && !auto.has(pkg)).map(([pkg]) => pkg);
+    const present = pluginNames(readJson(tree, appJson).expo?.plugins);
+    const missing = plugins.filter((pkg) => !present.includes(pkg));
+    if (missing.length > 0) {
+      updateJson(tree, appJson, (config) => {
+        config.expo ??= {};
+        config.expo.plugins = [...(config.expo.plugins ?? []), ...missing];
+        return config;
+      });
+      for (const pkg of missing) details.push(`${appJson} needs the config plugin of ${pkg}.`);
+    }
+  }
+  if (details.length === 0) return {};
+  // As the app generator wrote them, rather than as JSON.stringify does.
+  await formatFiles(tree);
+  return {
+    outOfSyncMessage:
+      'An app does not list a native module its libraries import, so a development build would not link it.',
+    outOfSyncDetails: details,
+  };
+}
+
+/**
+ * Registers the sync generator on the app's `start`, `export` and `prebuild` targets. `export` and
+ * `prebuild` are `@nx/expo`'s, inferred, and take the option from `project.json` beside the rest.
+ *
+ * @param {import('@nx/devkit').Tree} tree
+ * @param {string} projectName
+ */
+function registerSyncGenerator(tree, projectName) {
+  const project = readProjectConfiguration(tree, projectName);
+  const targets = { ...project.targets };
+  for (const target of ['start', 'export', 'prebuild']) {
+    const syncGenerators = targets[target]?.syncGenerators ?? [];
+    if (syncGenerators.includes(SYNC_GENERATOR)) continue;
+    targets[target] = { ...targets[target], syncGenerators: [...syncGenerators, SYNC_GENERATOR] };
+  }
+  updateProjectConfiguration(tree, projectName, { ...project, targets });
+}
+
+module.exports = { syncNativeModules, registerSyncGenerator, workspace, SYNC_GENERATOR };

package/sync/schema.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NgNativeNxSyncNativeModules",
+  "title": "Sync an app's native modules",
+  "description": "Lists the native modules an app's libraries import in the app's package.json, with their config plugins in app.json. A sync generator.",
+  "type": "object",
+  "properties": {}
+}