@ng-native/nx 0.2.0 → 0.3.0

package/library/index.cjs

@@ -0,0 +1,239 @@
+/**
+ * `nx g @ng-native/nx:library packages/ui`: a library of native components, tested the way an
+ * Angular Native app is.
+ *
+ * The library itself is the workspace's own kind: `@nx/angular:library` where the workspace has
+ * `@nx/angular`, and `@nx/js:library` in the TypeScript preset, which cannot take `@nx/angular`
+ * because Angular does not support TypeScript project references. Either is run without its
+ * tests, which would be Analog on jsdom or a plain Vitest, neither of which can render a native
+ * component. In their place this writes the app's `vitest.config.mts`, a `test` target that runs
+ * it once, a `tsconfig.spec.json` for the tests, and a native component with a test for the fake
+ * Fabric in place of the one the generator wrote.
+ */
+const { readFileSync } = require('node:fs');
+const nodePath = require('node:path');
+const path = nodePath.posix;
+const {
+  addDependenciesToPackageJson,
+  ensurePackage,
+  formatFiles,
+  getProjects,
+  installPackagesTask,
+  joinPathFragments,
+  names,
+  readNxJson,
+  readJson,
+  updateJson,
+  updateProjectConfiguration,
+} = require('@nx/devkit');
+const native = require('../native-app.cjs');
+const { workspaceNxVersion } = require('../init/index.cjs');
+const { hasPathAliases } = require('../application/index.cjs');
+const { usesWorkspaces } = require('../application/workspaces.cjs');
+const { asSaved } = require('../save-exact.cjs');
+const { writeComponent } = require('../component/index.cjs');
+
+/**
+ * The defaults a generator's schema gives its options, from the copy installed at `root`.
+ *
+ * @param {string} root
+ * @param {string} pkg
+ * @param {string} generator
+ * @returns {Record<string, unknown>}
+ */
+function schemaDefaults(root, pkg, generator) {
+  let manifest;
+  try {
+    manifest = require.resolve(`${pkg}/package.json`, { paths: [root] });
+  } catch {
+    return {};
+  }
+  const read = (file) =>
+    JSON.parse(readFileSync(nodePath.join(nodePath.dirname(manifest), file), 'utf8'));
+  const entry = read(read('package.json').generators).generators[generator];
+  const { properties = {} } = read(entry.schema);
+  return Object.fromEntries(
+    Object.entries(properties)
+      .filter(([, property]) => 'default' in property)
+      .map(([name, property]) => [name, property.default]),
+  );
+}
+
+/**
+ * The options `nx g <pkg>:<generator>` starts from: its schema's defaults, then the workspace's
+ * own in `nx.json`. A generator called from another gets neither, and `@nx/angular:library` called
+ * bare writes a library with strict type checking off.
+ *
+ * @param {import('@nx/devkit').Tree} tree
+ * @param {string} pkg
+ * @param {string} generator
+ */
+function generatorDefaults(tree, pkg, generator, root = tree.root) {
+  const workspace = readNxJson(tree)?.generators ?? {};
+  return {
+    ...schemaDefaults(root, pkg, generator),
+    ...workspace[pkg]?.[generator],
+    ...workspace[`${pkg}:${generator}`],
+  };
+}
+
+/** The library generators this one builds on, at the workspace's Nx. Replaced in tests. */
+const bases = {
+  /** @param {import('@nx/devkit').Tree} tree @param {object} options */
+  async angular(tree, options) {
+    // Only run where the workspace lists `@nx/angular`, whose root export has no generators.
+    const { libraryGenerator } = ensurePackage('@nx/angular/generators', workspaceNxVersion(tree));
+    return libraryGenerator(tree, {
+      ...generatorDefaults(tree, '@nx/angular', 'library'),
+      ...options,
+    });
+  },
+  /** @param {import('@nx/devkit').Tree} tree @param {object} options */
+  async js(tree, options) {
+    const { libraryGenerator } = ensurePackage('@nx/js', workspaceNxVersion(tree));
+    return libraryGenerator(tree, { ...generatorDefaults(tree, '@nx/js', 'library'), ...options });
+  },
+};
+
+/** What the component and its test import. */
+const imports = {
+  dependencies: {
+    '@angular/core': native.dependencies['@angular/core'],
+    '@ng-native/components': native.dependencies['@ng-native/components'],
+  },
+  devDependencies: {
+    '@ng-native/testing': native.devDependencies['@ng-native/testing'],
+    vitest: native.devDependencies.vitest,
+  },
+};
+
+function projectAt(tree, root) {
+  for (const [name, project] of getProjects(tree))
+    if (project.root === root) return { name, project };
+  throw new Error(`No project was generated in ${root}.`);
+}
+
+/**
+ * The native component and its test, where the generator put its own component: in a folder of
+ * its own under `src/lib` from `@nx/angular`, with an external template and stylesheet this
+ * leaves out, or as `src/lib/<name>.ts` from `@nx/js`. `src/index.ts` already exports it.
+ */
+function replaceComponent(tree, project, file) {
+  const lib = joinPathFragments(project.root, 'src', 'lib');
+  const folder = tree.exists(joinPathFragments(lib, file, `${file}.ts`))
+    ? joinPathFragments(lib, file)
+    : lib;
+  for (const extension of ['html', 'css', 'spec.ts']) {
+    const own = joinPathFragments(folder, `${file}.${extension}`);
+    if (tree.exists(own)) tree.delete(own);
+  }
+  writeComponent(tree, folder, file, project.prefix);
+}
+
+/**
+ * A `tsconfig.spec.json` like the one each generator writes with its tests, including the tests
+ * and the Vitest config. The tests import their component as `./ui.ts`, as the template's do.
+ */
+function writeSpecConfig(tree, root, angular) {
+  const include = ['vitest.config.mts', 'src/**/*.test.ts'];
+  const spec = angular
+    ? {
+        extends: './tsconfig.json',
+        compilerOptions: { noEmit: true, allowImportingTsExtensions: true },
+        include,
+      }
+    : {
+        // A project reference of the TypeScript preset's, which emits declarations only.
+        extends: readJson(tree, joinPathFragments(root, 'tsconfig.lib.json')).extends,
+        compilerOptions: { outDir: './out-tsc/vitest', allowImportingTsExtensions: true },
+        include,
+        references: [{ path: './tsconfig.lib.json' }],
+      };
+  tree.write(joinPathFragments(root, 'tsconfig.spec.json'), JSON.stringify(spec, null, 2) + '\n');
+  updateJson(tree, joinPathFragments(root, 'tsconfig.json'), (config) => {
+    const references = config.references ?? [];
+    if (!references.some((reference) => reference.path === './tsconfig.spec.json')) {
+      references.push({ path: './tsconfig.spec.json' });
+    }
+    return { ...config, references };
+  });
+  updateJson(tree, joinPathFragments(root, 'tsconfig.lib.json'), (config) => {
+    const exclude = config.exclude ?? [];
+    if (!exclude.includes('src/**/*.test.ts')) exclude.push('src/**/*.test.ts');
+    return { ...config, exclude };
+  });
+}
+
+/**
+ * The packages the component and its test import: in the library's own `package.json` when it is
+ * a workspace package, which pnpm links from, and at the root otherwise. A version already there
+ * is left alone.
+ */
+async function addImports(tree, root) {
+  const manifest = joinPathFragments(root, 'package.json');
+  const rootManifest = readJson(tree, 'package.json');
+  if (tree.exists(manifest)) {
+    const own = async (wanted) => asSaved(tree, native.reuseRootRanges(wanted, rootManifest));
+    return addDependenciesToPackageJson(
+      tree,
+      await own(imports.dependencies),
+      await own(imports.devDependencies),
+      manifest,
+      true,
+    );
+  }
+  const existing = Object.keys({ ...rootManifest.dependencies, ...rootManifest.devDependencies });
+  return addDependenciesToPackageJson(
+    tree,
+    await asSaved(tree, imports.dependencies, existing),
+    await asSaved(tree, imports.devDependencies, existing),
+    'package.json',
+    true,
+  );
+}
+
+/**
+ * @param {import('@nx/devkit').Tree} tree
+ * @param {{ directory: string, name?: string, tags?: string, skipInstall?: boolean, skipFormat?: boolean }} options
+ */
+async function library(tree, options) {
+  const directory = path.normalize(options.directory).replace(/\/$/, '');
+  const { dependencies, devDependencies } = readJson(tree, 'package.json');
+  const angular = Boolean({ ...dependencies, ...devDependencies }['@nx/angular']);
+  const shared = { directory, name: options.name, tags: options.tags, unitTestRunner: 'none' };
+  if (angular) await bases.angular(tree, { ...shared, skipFormat: true });
+  else await bases.js(tree, { ...shared, bundler: 'none', skipFormat: true });
+
+  const { name, project } = projectAt(tree, directory);
+  const file = names(options.name ?? path.basename(directory)).fileName;
+  replaceComponent(tree, project, file);
+
+  const aliases = hasPathAliases(tree, usesWorkspaces(tree));
+  tree.write(joinPathFragments(directory, 'vitest.config.mts'), native.vitestConfig(aliases));
+  writeSpecConfig(tree, directory, angular);
+  updateProjectConfiguration(tree, name, {
+    ...project,
+    targets: {
+      ...project.targets,
+      test: {
+        executor: 'nx:run-commands',
+        options: { cwd: directory, command: 'vitest run' },
+        cache: true,
+        inputs: ['default', '^production'],
+      },
+    },
+  });
+
+  await addImports(tree, directory);
+  // `nxViteTsPaths()`, which the Vitest config uses to reach the workspace's other libraries.
+  if (aliases) {
+    const vite = { '@nx/vite': workspaceNxVersion(tree) };
+    addDependenciesToPackageJson(tree, {}, vite, 'package.json', true);
+  }
+
+  if (!options.skipFormat) await formatFiles(tree);
+  if (options.skipInstall) return () => {};
+  return () => installPackagesTask(tree, true);
+}
+
+module.exports = { library, bases, generatorDefaults };

package/library/schema.json

@@ -0,0 +1,36 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "NgNativeNxLibrary",
+  "title": "Angular Native library",
+  "description": "A library of native components, whose tests render on the fake Fabric as an app's do.",
+  "type": "object",
+  "properties": {
+    "directory": {
+      "type": "string",
+      "description": "Where the library goes, relative to the workspace root: packages/ui.",
+      "$default": { "$source": "argv", "index": 0 },
+      "x-prompt": "Which directory should the library be created in?"
+    },
+    "name": {
+      "type": "string",
+      "description": "The project name. Defaults to the directory's last segment.",
+      "pattern": "^[a-z][a-z0-9-]*$"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Comma-separated tags for the project."
+    },
+    "skipInstall": {
+      "type": "boolean",
+      "description": "Write the files without installing.",
+      "default": false
+    },
+    "skipFormat": {
+      "type": "boolean",
+      "description": "Leave the generated files unformatted.",
+      "default": false,
+      "x-priority": "internal"
+    }
+  },
+  "required": ["directory"]
+}

package/migrations/run.cjs

@@ -0,0 +1,5 @@
+/**
+ * The migrations `nx migrate` runs, from `@ng-native/migrate`, where each one is written once for
+ * `nx migrate`, `ng update` and `npx @ng-native/migrate` alike.
+ */
+module.exports = require('@ng-native/migrate').forNx();

package/migrations.json

@@ -0,0 +1,24 @@
+{
+  "generators": {
+    "sync-app-versions": {
+      "version": "0.3.0",
+      "description": "Move the @ng-native packages each project's own package.json lists to the new version.",
+      "implementation": "./migrations/run.cjs#sync-app-versions"
+    },
+    "split-store-and-player": {
+      "version": "0.3.0",
+      "description": "Import Storage, SecureStorage, audioPlayer and videoPlayer from the entry points that now hold them.",
+      "implementation": "./migrations/run.cjs#split-store-and-player"
+    },
+    "tracking-available-getter": {
+      "version": "0.3.0",
+      "description": "Read Tracking's available as a property rather than calling it.",
+      "implementation": "./migrations/run.cjs#tracking-available-getter"
+    },
+    "device-react-native-import": {
+      "version": "0.3.0",
+      "description": "Note each import of reactNative or ReactNative from @ng-native/device, which no longer exports them.",
+      "implementation": "./migrations/run.cjs#device-react-native-import"
+    }
+  }
+}

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');
@@ -226,32 +134,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 +158,15 @@ 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,
   tsconfig,
   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.3.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.3.0",
     "@nx/devkit": "^23.0.0",
     "minimatch": "^10.0.0",
     "semver": "^7.7.0"
@@ -26,9 +46,11 @@
     "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"
@@ -47,6 +69,7 @@
   "files": [
     "*.cjs",
     "generators.json",
+    "migrations.json",
     "*/*.cjs",
     "*/*.json",
     "files"
@@ -56,6 +79,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\""
   }
 }