create-expo-boilerplate 0.0.0-stage → 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 EndLess728
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,143 @@
-# Temporary Holding Version
+# create-expo-boilerplate
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Scaffold a new Expo app from [React-Native-Expo-Boilterplate](https://github.com/EndLess728/React-Native-Expo-Boilterplate) — no cloning, no deleting example code by hand.
+
+```bash
+npx create-expo-boilerplate my-app
+# or
+yarn create expo-boilerplate my-app
+pnpm create expo-boilerplate my-app
+bun create expo-boilerplate my-app
+```
+
+It asks a few questions, writes the project, installs dependencies, sets up git (and Husky), and makes the first commit.
+
+## Options
+
+| Prompt | Choices | Default | Flag |
+|---|---|---|---|
+| State management | Zustand · Redux Toolkit | Zustand | `--state zustand\|redux` |
+| Redux side effects (Redux only) | Thunk · Saga | Thunk | `--redux-middleware thunk\|saga` |
+| Navigation | Expo Router · React Navigation | Expo Router | `--navigation expo-router\|react-navigation` |
+| Styling | Unistyles · StyleSheet · Tailwind (Uniwind) | Unistyles | `--styling unistyles\|stylesheet\|tailwind` |
+| Language | TypeScript · JavaScript | TypeScript | `--language ts\|js` (or `--js`) |
+| ESLint | yes · no | yes | `--eslint` / `--no-eslint` |
+| Husky git hooks | yes · no | yes | `--husky` / `--no-husky` |
+| App display name | — | from the folder name | `--name "My App"` |
+| Bundle id / Android package | — | `com.<name>` | `--bundle-id com.company.app` |
+| Package manager | yarn · npm · pnpm · bun | whatever ran the CLI | `--pm` |
+
+Other flags: `--yes` (take defaults for anything not passed), `--no-install`, `--no-git`.
+
+```bash
+# Fully non-interactive
+npx create-expo-boilerplate my-app --yes \
+  --state redux --redux-middleware saga \
+  --navigation react-navigation --styling tailwind --js --no-husky
+```
+
+### Styling
+
+| Option | Styles are written with | Extra packages |
+|---|---|---|
+| Unistyles (default) | `StyleSheet.create((theme, rt) => …)` from `react-native-unistyles` | `react-native-unistyles` |
+| StyleSheet | React Native's `StyleSheet`; `makeStyles((theme) => …)` from `@/theme` for theme-aware styles | none |
+| Tailwind | `className` via [Uniwind](https://uniwind.dev/) (Tailwind v4); theme colors, fonts and text roles in `global.css`, plus `metro.config.js` | `uniwind`, `tailwindcss` |
+
+Every option has the same screens and the same light/dark theme tokens (`src/styles/themes.ts`), and exposes `useAppTheme()` from `@/theme` for colors that must be passed as props (icon colors, tab bar tints, `placeholderTextColor`). The project's `.skills/ui-creation.md` and the `rnfu` VS Code snippet are rewritten for the option you pick.
+
+Every combination uses the same feature-based layout (`src/features/<feature>`, `src/shared`, …). Screens only talk to state through the auth feature's hooks (`useIsLoggedIn`, `useLogin`, …), which is why switching the state library or the navigator doesn't touch a single screen.
+
+## How it works
+
+The repo root **is** the template: the Expo Router + Zustand + TypeScript app with ESLint and Husky. Nobody maintains a second copy.
+
+```
+cli/
+├── src/
+│   ├── index.ts              # prompts + flags (commander, @clack/prompts)
+│   ├── generate.ts           # runs the steps below in order
+│   ├── template.ts           # copies the repo root (or the packaged template/)
+│   └── steps/
+│       ├── navigation.ts     # React Navigation: drop src/app, add the overlay, edit app.config + deps
+│       ├── styling.ts        # StyleSheet / Tailwind: strip Unistyles, add the styling overlay, swap docs
+│       ├── state.ts          # Redux: drop the Zustand store, add redux/common + thunk|saga overlays
+│       ├── tooling.ts        # remove ESLint / Husky (+ lint-staged, Commitlint)
+│       ├── identity.ts       # name, slug, scheme, bundle id
+│       ├── packageManager.ts # lockfile, `yarn …` mentions, eas.json, .npmrc
+│       ├── javascript.ts     # TS → JS with the TypeScript compiler, last
+│       ├── readme.ts         # README for the exact stack chosen
+│       └── format.ts         # Prettier with the project's .prettierrc
+├── overlays/                 # files that differ per option, written in TypeScript
+│   ├── react-navigation/
+│   ├── redux/{common,thunk,saga}/
+│   └── styling/{stylesheet,tailwind}/
+│       ├── common/           #   styled components, screens, theme hooks (+ global.css, metro.config.js)
+│       ├── expo-router/      #   route files that only exist with Expo Router
+│       └── docs/             #   replacement sections for .skills/ui-creation.md and the screen snippet
+└── scripts/
+    ├── sync-template.mjs     # copies the repo root into template/ when packing
+    └── test-matrix.mjs       # generates + checks every combination
+```
+
+- **Overlays are TypeScript only.** The JavaScript option transpiles the finished project with the TypeScript compiler (types erased, JSX untouched, blank lines kept), deletes files that only held types, and Prettier formats the result. There's no separate JS template to maintain.
+- **Edits fail loudly.** Every string edit throws if its target text is missing, so if the boilerplate changes in a way a step depends on, generation (and CI) fails instead of shipping a half-converted project.
+- **Region markers.** Option-specific blocks in the template are wrapped in `// @cli:<name>-start` … `// @cli:<name>-end` (or `<!-- @cli:… -->` in Markdown). The CLI either strips the markers and keeps the block, or replaces it:
+  - `zustand` — the Zustand-only lint rule in `eslint.config.js`, swapped for the typed-Redux-hooks rule.
+  - `unistyles` — Unistyles-only lines in `index.ts`, `babel.config.js`, `eslint.config.js` and `src/styles/themes.ts`, removed for StyleSheet / Tailwind.
+  - `ui-*` and `snippet-screen` — styling sections of `.skills/ui-creation.md` and `.vscode/project.code-snippets`, replaced from `overlays/styling/<option>/docs/`.
+
+  The test matrix fails if a marker survives into a generated project.
+
+## Developing
+
+```bash
+cd cli
+npm install
+npm run build
+node dist/index.js ../../my-test-app          # generates from the current repo root
+```
+
+Run from a checkout, the CLI copies the boilerplate straight from the repo root, so changes there show up in generated apps right away.
+
+### Test every combination
+
+```bash
+npm run test:matrix            # 26 core combinations
+npm run test:matrix -- --all   # all 144
+npm run test:matrix -- --export   # also bundle each with `expo export` (slow)
+npm run test:matrix -- --only redux-saga.react-navigation.tailwind
+```
+
+The script generates each project into your temp dir, installs **one** shared superset of dependencies, and checks each project for leftovers (stray markers, Zustand imports in Redux apps, Unistyles in StyleSheet / Tailwind apps, …), circular imports (madge), `tsc`, ESLint (or Prettier when ESLint is off), Jest, and `expo config`. CI runs the core set on every PR that touches the app or the CLI.
+
+### Adding an option
+
+1. Add the choice to `options.ts`, a prompt + flag in `index.ts`, and a step in `steps/` (or extend one).
+2. Put files that differ in `overlays/<option>/`, in TypeScript, mirroring project paths.
+3. Pin any new packages in `versions.ts`.
+4. Add the dimension to `scripts/test-matrix.mjs` and run it.
+
+### Upgrading the Expo SDK
+
+Upgrade the boilerplate at the repo root as usual, then bump the overlay-only packages in `src/versions.ts` (React Navigation, Redux, Uniwind / Tailwind), and run `npm run test:matrix -- --all --export`.
+
+## Publishing
+
+Publishing is automatic: `.github/workflows/publish-cli.yml` publishes to npm on every push to `main`. It needs an `NPM_TOKEN` repository secret (an npm automation token, or a granular token with publish rights to this package).
+
+- **The version comes from the commits**, the same way the GitHub release is versioned: git-cliff reads the Conventional Commits since the last `v*` tag (`feat` → minor, `fix` / `perf` → patch, `!` or `BREAKING CHANGE` → major), and `v1.1.0` is published as `1.1.0`. The `version` in `package.json` is set on the CI runner only, so don't bump it by hand.
+- **A push with nothing releasable** (only `chore` / `docs` / `ci` commits) resolves to a version that is already on npm, so the run skips the publish with a notice instead of failing.
+- Packages are published with [npm provenance](https://docs.npmjs.com/generating-provenance-statements), linking each version to the workflow run that built it.
+
+To publish by hand instead (for example, to test a release):
+
+```bash
+cd cli
+npm version 1.2.3 --no-git-tag-version
+npm publish              # prepack builds dist/ and syncs template/
+```
+
+`prepack` compiles the CLI and copies the boilerplate into `template/`. npm drops `.gitignore` from tarballs, so it's stored as `_gitignore` and renamed back on generate. Check what ships with `npm pack --dry-run`.
+
+To keep it private to the team, publish under a scope (`@your-org/create-expo-boilerplate`, run as `npm create @your-org/expo-boilerplate`) with restricted access.

package/dist/generate.js

@@ -0,0 +1,47 @@
+import { STYLING_LABEL } from './options.js';
+import { applyIdentity } from './steps/identity.js';
+import { convertToJavaScript } from './steps/javascript.js';
+import { applyNavigation } from './steps/navigation.js';
+import { applyPackageManager } from './steps/packageManager.js';
+import { writeReadme } from './steps/readme.js';
+import { applyState } from './steps/state.js';
+import { applyStyling } from './steps/styling.js';
+import { applyTooling } from './steps/tooling.js';
+import { formatProject } from './steps/format.js';
+import { copyBaseTemplate } from './template.js';
+import { ProjectFiles } from './utils/files.js';
+import { PackageJsonEditor } from './utils/packageJson.js';
+/**
+ * Writes the project to `options.targetDir`. Pure file generation — no
+ * installs, no git — so it is fast and easy to test.
+ *
+ * Order matters: every overlay is written in TypeScript, so the TS → JS pass
+ * runs after all of them, and formatting runs last.
+ */
+export async function generateProject(options, onStep = () => { }) {
+    const files = new ProjectFiles(options.targetDir);
+    onStep('Copying the boilerplate');
+    await copyBaseTemplate(options.targetDir);
+    const pkg = await PackageJsonEditor.load(files);
+    onStep(`Setting up ${options.navigation === 'expo-router' ? 'Expo Router' : 'React Navigation'}`);
+    await applyNavigation(files, pkg, options);
+    onStep(`Setting up ${STYLING_LABEL[options.styling]}`);
+    await applyStyling(files, pkg, options);
+    onStep(options.state === 'zustand'
+        ? 'Setting up Zustand'
+        : `Setting up Redux Toolkit + ${options.reduxMiddleware === 'saga' ? 'Redux-Saga' : 'thunks'}`);
+    await applyState(files, pkg, options);
+    onStep('Configuring tooling');
+    await applyTooling(files, pkg, options);
+    onStep('Naming your app');
+    await applyIdentity(files, pkg, options);
+    await applyPackageManager(files, pkg, options);
+    if (options.language === 'js') {
+        onStep('Converting to JavaScript');
+        await convertToJavaScript(files, pkg, options);
+    }
+    await pkg.save();
+    await writeReadme(files, options);
+    onStep('Formatting');
+    await formatProject(files);
+}

package/dist/index.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { basename, join, relative, resolve } from 'node:path';
+import * as p from '@clack/prompts';
+import { Command, InvalidArgumentError } from 'commander';
+import pc from 'picocolors';
+import { generateProject } from './generate.js';
+import { CHOICES, defaultBundleId, DEFAULTS, STYLING_LABEL, toDisplayName, toPackageName, validateBundleId, validateProjectName, } from './options.js';
+import { detectPackageManager, PM } from './steps/packageManager.js';
+import { PACKAGE_ROOT } from './template.js';
+import { commandExists, run } from './utils/exec.js';
+const { version } = JSON.parse(readFileSync(join(PACKAGE_ROOT, 'package.json'), 'utf8'));
+const oneOf = (choices) => (value) => {
+    if (!choices.includes(value)) {
+        throw new InvalidArgumentError(`Expected one of: ${choices.join(', ')}.`);
+    }
+    return value;
+};
+const program = new Command()
+    .name('create-expo-boilerplate')
+    .description('Scaffold an Expo app from the React-Native-Expo-Boilterplate.')
+    .version(version)
+    .argument('[directory]', 'where to create the project')
+    .option('--state <library>', 'zustand | redux', oneOf(CHOICES.state))
+    .option('--redux-middleware <type>', 'thunk | saga (with --state redux)', oneOf(CHOICES.reduxMiddleware))
+    .option('--navigation <library>', 'expo-router | react-navigation', oneOf(CHOICES.navigation))
+    .option('--styling <library>', 'unistyles | stylesheet | tailwind', oneOf(CHOICES.styling))
+    .option('--language <lang>', 'ts | js', oneOf(CHOICES.language))
+    .option('--js', 'shorthand for --language js')
+    .option('--eslint', 'include ESLint')
+    .option('--no-eslint', 'skip ESLint')
+    .option('--husky', 'include Husky git hooks')
+    .option('--no-husky', 'skip Husky git hooks')
+    .option('--name <displayName>', 'app display name')
+    .option('--bundle-id <id>', 'iOS bundle identifier / Android package')
+    .option('--pm <manager>', 'yarn | npm | pnpm | bun', oneOf(CHOICES.packageManager))
+    .option('--no-install', 'skip installing dependencies')
+    .option('--no-git', 'skip git init and the initial commit')
+    .option('-y, --yes', 'accept defaults for every option not passed as a flag')
+    .addHelpText('after', `
+Examples:
+  $ npx create-expo-boilerplate my-app
+  $ npx create-expo-boilerplate my-app --state redux --redux-middleware saga --navigation react-navigation
+  $ npx create-expo-boilerplate my-app --styling tailwind
+  $ npx create-expo-boilerplate my-app --yes --js --no-husky`);
+function bail(value) {
+    if (p.isCancel(value)) {
+        p.cancel('Cancelled — nothing was created.');
+        process.exit(0);
+    }
+}
+async function ask(given, useDefault, fallback, prompt) {
+    if (given !== undefined)
+        return given;
+    if (useDefault)
+        return fallback;
+    const answer = await prompt();
+    bail(answer);
+    return answer;
+}
+async function isEmptyDir(dir) {
+    try {
+        const entries = await readdir(dir);
+        return entries.filter((e) => e !== '.DS_Store' && e !== '.git').length === 0;
+    }
+    catch {
+        return true; // doesn't exist yet
+    }
+}
+async function main() {
+    program.parse();
+    const [dirArg] = program.args;
+    const flags = program.opts();
+    const defaults = Boolean(flags.yes) || !process.stdout.isTTY;
+    console.log();
+    p.intro(pc.bgCyan(pc.black(' create-expo-boilerplate ')));
+    // ── Where ────────────────────────────────────────────────
+    const directory = await ask(dirArg, defaults, 'my-app', () => p.text({
+        message: 'Project name',
+        placeholder: 'my-app',
+        defaultValue: 'my-app',
+        validate: (v) => (v ? validateProjectName(v) : undefined),
+    }));
+    const targetDir = resolve(process.cwd(), directory);
+    const projectName = basename(targetDir);
+    if (validateProjectName(projectName)) {
+        p.cancel(validateProjectName(projectName));
+        process.exit(1);
+    }
+    if (!(await isEmptyDir(targetDir))) {
+        p.cancel(`${pc.bold(relative(process.cwd(), targetDir) || '.')} is not empty. Pick a new directory.`);
+        process.exit(1);
+    }
+    // ── Identity ─────────────────────────────────────────────
+    const displayName = await ask(flags.name, defaults, toDisplayName(projectName), () => p.text({
+        message: 'App display name',
+        initialValue: toDisplayName(projectName),
+        validate: (v) => (v?.trim() ? undefined : 'Display name is required.'),
+    }));
+    if (flags.bundleId && validateBundleId(flags.bundleId)) {
+        p.cancel(`--bundle-id: ${validateBundleId(flags.bundleId)}`);
+        process.exit(1);
+    }
+    const bundleId = await ask(flags.bundleId, defaults, defaultBundleId(projectName), () => p.text({
+        message: 'Bundle identifier / Android package',
+        initialValue: defaultBundleId(projectName),
+        validate: (v) => validateBundleId(v ?? ''),
+    }));
+    // ── Stack ────────────────────────────────────────────────
+    const state = await ask(flags.state, defaults, DEFAULTS.state, () => p.select({
+        message: 'State management',
+        initialValue: DEFAULTS.state,
+        options: [
+            { value: 'zustand', label: 'Zustand', hint: 'default — atomic stores, MMKV-persisted' },
+            { value: 'redux', label: 'Redux Toolkit', hint: 'slices + redux-persist on MMKV' },
+        ],
+    }));
+    let reduxMiddleware = null;
+    if (state === 'redux') {
+        reduxMiddleware = await ask(flags.reduxMiddleware, defaults, DEFAULTS.reduxMiddleware, () => p.select({
+            message: 'Redux side effects',
+            initialValue: DEFAULTS.reduxMiddleware,
+            options: [
+                { value: 'thunk', label: 'Thunk', hint: 'default — createAsyncThunk, built into RTK' },
+                { value: 'saga', label: 'Saga', hint: 'redux-saga generators' },
+            ],
+        }));
+    }
+    else if (flags.reduxMiddleware) {
+        p.log.warn('--redux-middleware is ignored without --state redux.');
+    }
+    const navigation = await ask(flags.navigation, defaults, DEFAULTS.navigation, () => p.select({
+        message: 'Navigation',
+        initialValue: DEFAULTS.navigation,
+        options: [
+            { value: 'expo-router', label: 'Expo Router', hint: 'default — file-based routing' },
+            { value: 'react-navigation', label: 'React Navigation', hint: 'navigators in code' },
+        ],
+    }));
+    const styling = await ask(flags.styling, defaults, DEFAULTS.styling, () => p.select({
+        message: 'Styling',
+        initialValue: DEFAULTS.styling,
+        options: [
+            { value: 'unistyles', label: 'Unistyles', hint: 'default — themed StyleSheet, light/dark' },
+            { value: 'stylesheet', label: 'StyleSheet', hint: 'plain React Native, no extra deps' },
+            { value: 'tailwind', label: 'Tailwind', hint: 'className via Uniwind (Tailwind v4)' },
+        ],
+    }));
+    const language = await ask(flags.js ? 'js' : flags.language, defaults, DEFAULTS.language, () => p.select({
+        message: 'Language',
+        initialValue: DEFAULTS.language,
+        options: [
+            { value: 'ts', label: 'TypeScript', hint: 'default' },
+            { value: 'js', label: 'JavaScript' },
+        ],
+    }));
+    const eslint = await ask(flags.eslint, defaults, DEFAULTS.eslint, () => p.confirm({ message: 'Include ESLint?', initialValue: DEFAULTS.eslint }));
+    const husky = await ask(flags.husky, defaults, DEFAULTS.husky, () => p.confirm({
+        message: 'Include Husky git hooks? (lint-staged + Commitlint)',
+        initialValue: DEFAULTS.husky,
+    }));
+    const detectedPm = detectPackageManager() ?? 'yarn';
+    const packageManager = await ask(flags.pm, defaults, detectedPm, () => p.select({
+        message: 'Package manager',
+        initialValue: detectedPm,
+        options: CHOICES.packageManager.map((pm) => ({ value: pm, label: pm })),
+    }));
+    const options = {
+        projectName,
+        targetDir,
+        displayName: displayName.trim(),
+        bundleId,
+        state,
+        reduxMiddleware,
+        navigation,
+        styling,
+        language,
+        eslint,
+        husky,
+        packageManager,
+        install: flags.install,
+        git: flags.git,
+    };
+    // ── Generate ─────────────────────────────────────────────
+    const s = p.spinner();
+    s.start('Generating project');
+    try {
+        await generateProject(options, (msg) => s.message(msg));
+    }
+    catch (error) {
+        s.error('Generation failed');
+        throw error;
+    }
+    s.stop(`Created ${pc.bold(toPackageName(projectName))}`);
+    const hasGit = options.git && (await commandExists('git'));
+    if (hasGit) {
+        // Before install, so Husky's `prepare` script can install the hooks.
+        await run('git', ['init', '-q', '-b', 'main'], targetDir).catch(() => run('git', ['init', '-q'], targetDir));
+    }
+    let installed = false;
+    if (options.install) {
+        if (await commandExists(packageManager)) {
+            s.start(`Installing dependencies with ${packageManager} — this takes a few minutes`);
+            try {
+                await run(packageManager, ['install'], targetDir);
+                installed = true;
+                s.stop('Dependencies installed');
+            }
+            catch (error) {
+                s.error(`${packageManager} install failed — run it yourself to see why`);
+                if (process.env.DEBUG)
+                    console.error(error);
+            }
+        }
+        else {
+            p.log.warn(`${packageManager} isn't installed — skipping dependency install.`);
+        }
+    }
+    if (hasGit) {
+        try {
+            await run('git', ['add', '-A'], targetDir);
+            // --no-verify: the pre-commit hook blocks commits to main by design.
+            await run('git', ['commit', '-q', '--no-verify', '-m', 'chore: initial commit from create-expo-boilerplate'], targetDir);
+        }
+        catch {
+            p.log.warn('Skipped the initial commit (is git user.name / user.email set?).');
+        }
+    }
+    // ── Next steps ───────────────────────────────────────────
+    const cmd = PM[packageManager];
+    const rel = relative(process.cwd(), targetDir) || '.';
+    const steps = [
+        rel !== '.' ? `cd ${rel}` : null,
+        installed ? null : cmd.install,
+        '$EDITOR .env.development   # add your API URLs',
+        `${cmd.run} android:development   # or ios:development`,
+    ].filter(Boolean);
+    p.note(steps.join('\n'), 'Next steps');
+    p.outro(`${pc.dim('Stack:')} ${[
+        state === 'redux' ? `Redux Toolkit + ${reduxMiddleware}` : 'Zustand',
+        navigation === 'expo-router' ? 'Expo Router' : 'React Navigation',
+        STYLING_LABEL[styling],
+        language === 'ts' ? 'TypeScript' : 'JavaScript',
+        eslint ? 'ESLint' : null,
+        husky ? 'Husky' : null,
+    ]
+        .filter(Boolean)
+        .join(' · ')}`);
+}
+main().catch((error) => {
+    p.log.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+});

package/dist/options.js

@@ -0,0 +1,66 @@
+export const STYLING_LABEL = {
+    unistyles: 'Unistyles',
+    stylesheet: 'StyleSheet',
+    tailwind: 'Tailwind (Uniwind)',
+};
+export const DEFAULTS = {
+    state: 'zustand',
+    reduxMiddleware: 'thunk',
+    navigation: 'expo-router',
+    styling: 'unistyles',
+    language: 'ts',
+    eslint: true,
+    husky: true,
+};
+export const CHOICES = {
+    state: ['zustand', 'redux'],
+    reduxMiddleware: ['thunk', 'saga'],
+    navigation: ['expo-router', 'react-navigation'],
+    styling: ['unistyles', 'stylesheet', 'tailwind'],
+    language: ['ts', 'js'],
+    packageManager: ['yarn', 'npm', 'pnpm', 'bun'],
+};
+// ─────────────────────────────────────────────────────────────
+//  Name helpers
+// ─────────────────────────────────────────────────────────────
+/** `My Cool App` / `my_cool.app` → `my-cool-app` (valid npm name and Expo slug). */
+export function toPackageName(input) {
+    return input
+        .trim()
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .replace(/-{2,}/g, '-');
+}
+/** `my-cool-app` → `My Cool App`. */
+export function toDisplayName(input) {
+    return toPackageName(input)
+        .split('-')
+        .filter(Boolean)
+        .map((word) => word[0].toUpperCase() + word.slice(1))
+        .join(' ');
+}
+/** `my-cool-app` → `mycoolapp` (deep-link scheme, last bundle-id segment). */
+export function toScheme(input) {
+    const scheme = toPackageName(input).replace(/-/g, '');
+    // A scheme / Java package segment must start with a letter.
+    return /^[a-z]/.test(scheme) ? scheme : `app${scheme}`;
+}
+export function defaultBundleId(projectName) {
+    return `com.${toScheme(projectName)}`;
+}
+const BUNDLE_ID_RE = /^[a-zA-Z][a-zA-Z0-9_]*(\.[a-zA-Z][a-zA-Z0-9_]*)+$/;
+export function validateBundleId(value) {
+    if (!BUNDLE_ID_RE.test(value)) {
+        return 'Use reverse-DNS form with at least two segments, e.g. com.company.app (letters, digits, underscores).';
+    }
+    return undefined;
+}
+export function validateProjectName(value) {
+    if (!value.trim())
+        return 'Project name is required.';
+    if (!toPackageName(value))
+        return 'Project name needs at least one letter or digit.';
+    return undefined;
+}

package/dist/steps/format.js

@@ -0,0 +1,19 @@
+import * as prettier from 'prettier';
+const CODE_RE = /\.(jsx?|tsx?|mjs|cjs)$/;
+const JSON_FILES = ['package.json', 'eas.json', 'jsconfig.json', 'tsconfig.json'];
+/**
+ * Runs Prettier with the project's own .prettierrc over code and the JSON
+ * files the CLI rewrote, so overlays, transpiled JS and edited configs match
+ * the house style. The base template is already formatted, so this is a no-op
+ * for files nobody touched.
+ */
+export async function formatProject(files) {
+    const config = (await prettier.resolveConfig(files.abs('.prettierrc'))) ?? {};
+    const targets = (await files.list()).filter((rel) => (CODE_RE.test(rel) && !rel.startsWith('scripts/')) || JSON_FILES.includes(rel));
+    for (const rel of targets) {
+        const source = await files.read(rel);
+        const formatted = await prettier.format(source, { ...config, filepath: files.abs(rel) });
+        if (formatted !== source)
+            await files.write(rel, formatted);
+    }
+}

package/dist/steps/identity.js

@@ -0,0 +1,27 @@
+import { toPackageName, toScheme } from '../options.js';
+// Placeholder identity baked into the boilerplate.
+const TEMPLATE = {
+    displayName: 'ExpoTemplate',
+    slug: 'ExpoTemplate',
+    scheme: 'expotemplate',
+    bundleId: 'com.expo.template',
+};
+/** Renames the app: package name, display names, slug, scheme and bundle id. */
+export async function applyIdentity(files, pkg, options) {
+    const packageName = toPackageName(options.projectName);
+    const { displayName, bundleId } = options;
+    pkg.data.name = packageName;
+    await files.replace('app.config.ts', `slug: '${TEMPLATE.slug}'`, `slug: '${packageName}'`);
+    await files.replace('app.config.ts', `scheme: '${TEMPLATE.scheme}'`, `scheme: '${toScheme(options.projectName)}'`);
+    // env.ts — per-environment app names and the bundle id (incl. the
+    // commented multi-package example).
+    await files.replace('env.ts', `'${TEMPLATE.displayName} (Dev)'`, `'${displayName} (Dev)'`);
+    await files.replace('env.ts', `'${TEMPLATE.displayName} (Staging)'`, `'${displayName} (Staging)'`);
+    await files.replace('env.ts', `production: '${TEMPLATE.displayName}'`, `production: '${displayName}'`);
+    await files.replace('env.ts', TEMPLATE.bundleId, bundleId);
+    await files.replace('__mocks__/@env.ts', `'${TEMPLATE.displayName} (Dev)'`, `'${displayName} (Dev)'`);
+    await files.replace('__mocks__/@env.ts', `'${TEMPLATE.bundleId}'`, `'${bundleId}'`);
+    await files.replace('.env.example', '# reactnativetemplateapp env template', `# ${packageName} env template`, {
+        optional: true,
+    });
+}