expo-desktop 0.1.13 → 0.1.15

package/build/cli.js

@@ -33,6 +33,31 @@ const main = defineCommand({
                     description: `The ${kleur.bold("minor version")} of React Native to align on ${grey("(Examples: '0.80', 'latest')")}`,
                     valueHint: "version",
                 },
+                template: {
+                    type: "string",
+                    description: "Base template source (tarball, npm spec, or GitHub owner/repo#ref:subpath)",
+                    valueHint: "template",
+                },
+                "template-ios": {
+                    type: "string",
+                    description: "iOS-specific template source",
+                    valueHint: "template",
+                },
+                "template-android": {
+                    type: "string",
+                    description: "Android-specific template source",
+                    valueHint: "template",
+                },
+                "template-macos": {
+                    type: "string",
+                    description: "macOS-specific template source",
+                    valueHint: "template",
+                },
+                "template-windows": {
+                    type: "string",
+                    description: "Windows-specific template source",
+                    valueHint: "template",
+                },
             },
             async run({ args }) {
                 (await import("./create-app/command.js")).newExpoDesktopProject(args);
@@ -70,6 +95,26 @@ const main = defineCommand({
                     description: "Project template to clone from. File path pointing to a local tar file, npm package or a github repo",
                     valueHint: "template",
                 },
+                "template-ios": {
+                    type: "string",
+                    description: "iOS-specific template source",
+                    valueHint: "template",
+                },
+                "template-android": {
+                    type: "string",
+                    description: "Android-specific template source",
+                    valueHint: "template",
+                },
+                "template-macos": {
+                    type: "string",
+                    description: "macOS-specific template source",
+                    valueHint: "template",
+                },
+                "template-windows": {
+                    type: "string",
+                    description: "Windows-specific template source",
+                    valueHint: "template",
+                },
                 platform: {
                     type: "string",
                     description: `Platforms to sync: macos, windows, desktop ${dim("(Default: desktop)")}`,

package/build/common/rename-template-app-name.js

@@ -0,0 +1,141 @@
+import { glob } from "glob";
+import fs from "node:fs";
+import path from "node:path";
+const { MacOSConfig: { XcodeUtils }, } = require("expo-desktop-config-plugins");
+/**
+ * Returns a list of files within a template matched by the resolved rename
+ * config.
+ *
+ * The rename config is resolved in the order of preference:
+ * Config provided as function param > defaultRenameConfig
+ */
+export async function getTemplateFilesToRenameAsync(cwd, { renameConfig: userConfig, } = {}) {
+    let config = userConfig ?? [...defaultRenameConfig];
+    // Strip comments, trim whitespace, and remove empty lines.
+    config = config
+        .map((line) => line.split(/(?<!\\)#/, 2)[0]?.trim() ?? "")
+        .filter((line) => line !== "");
+    return await glob(config, {
+        cwd,
+        // `true` is consistent with .gitignore. Allows `*.xml` to match .xml files
+        // in all subdirs.
+        matchBase: true,
+        dot: true,
+        // Prevent climbing out of the template directory in case a template
+        // includes a symlink to an external directory.
+        follow: false,
+    });
+}
+/**
+ * # Background
+ *
+ * `@expo/cli` and `create-expo` extract a template from a tarball (whether from
+ * a local npm project or a GitHub repository), but these templates have a
+ * static name that needs to be updated to match whatever app name the user
+ * specified.
+ *
+ * By convention, the app name of all templates is "HelloWorld". During
+ * extraction, filepaths are transformed via `createEntryResolver()` in
+ * `createFileTransform.ts`, but the contents of files are left untouched.
+ * Technically, the contents used to be transformed during extraction as well,
+ * but due to poor configurability, we've moved to a post-extraction approach.
+ *
+ * # The new approach: Renaming the app post-extraction
+ *
+ * In this new approach, we take a list of file patterns, otherwise known as the
+ * "rename config" to determine explicitly which files – relative to the root of
+ * the template – to perform find-and-replace on, to update the app name.
+ *
+ * ## The rename config
+ *
+ * The rename config can be passed directly as a string array to
+ * `getTemplateFilesToRenameAsync()`.
+ *
+ * The file patterns are formatted as glob expressions to be interpreted by
+ * [glob](https://github.com/isaacs/node-glob). Comments are supported with
+ * the `#` symbol, both in the plain-text file and string array formats.
+ * Whitespace is trimmed and whitespace-only lines are ignored.
+ *
+ * If no rename config has been passed directly to
+ * `getTemplateFilesToRenameAsync()` then this default rename config will be
+ * used instead.
+ *
+ * @see https://github.com/expo/expo/pull/27212
+ * @see https://github.com/expo/expo/blob/main/packages/%40expo/cli/src/prebuild/renameTemplateAppName.ts
+ */
+export const defaultRenameConfig = [
+    // Common
+    "!**/node_modules",
+    "app.json",
+    // Android
+    "android/**/*.gradle",
+    "android/app/BUCK",
+    "android/app/src/**/*.java",
+    "android/app/src/**/*.kt",
+    "android/app/src/**/*.xml",
+    // iOS
+    "ios/Podfile",
+    "ios/**/*.xcodeproj/project.pbxproj",
+    "ios/**/*.xcodeproj/xcshareddata/xcschemes/*.xcscheme",
+    "ios/**/*.xcworkspace/contents.xcworkspacedata",
+    // macOS
+    "macos/Podfile",
+    "macos/**/*.xcodeproj/project.pbxproj",
+    "macos/**/*.xcodeproj/xcshareddata/xcschemes/*.xcscheme",
+    "macos/**/*.xcworkspace/contents.xcworkspacedata",
+    // Windows
+    "windows/**/*.sln",
+    "windows/**/*.vcxproj",
+    "windows/**/*.vcxproj.filters",
+    "windows/**/*.vcxitems",
+    "windows/**/*.vcxitems.filters",
+    "windows/**/*.props",
+    "windows/**/*.targets",
+    "windows/**/*.h",
+    "windows/**/*.hpp",
+    "windows/**/*.c",
+    "windows/**/*.cpp",
+    "windows/**/*.idl",
+    "windows/**/*.rc",
+    "windows/**/*.xml",
+    "windows/**/*.xaml",
+    "windows/**/*.appxmanifest",
+];
+export async function renameTemplateAppNameAsync(cwd, { filesafeName, files, }) {
+    if (!files.length) {
+        return;
+    }
+    await Promise.all(files.map(async (file) => {
+        const absoluteFilePath = path.resolve(cwd, file);
+        let contents;
+        try {
+            contents = await fs.promises.readFile(absoluteFilePath, { encoding: "utf-8" });
+        }
+        catch (cause) {
+            throw new Error(`Failed to read template file: "${absoluteFilePath}". Was it removed mid-operation?`, { cause });
+        }
+        const safeName = [".xml", ".plist", ".xaml", ".appxmanifest"].includes(path.extname(file))
+            ? escapeXMLCharacters(filesafeName)
+            : filesafeName;
+        try {
+            const replacement = contents
+                .replace(/Hello App Display Name/g, safeName)
+                .replace(/HelloWorld/g, XcodeUtils.sanitizedName(safeName))
+                .replace(/helloworld/g, XcodeUtils.sanitizedName(safeName.toLowerCase()));
+            if (replacement === contents) {
+                return;
+            }
+            await fs.promises.writeFile(absoluteFilePath, replacement);
+        }
+        catch (cause) {
+            throw new Error(`Failed to overwrite template file: "${absoluteFilePath}". Was it removed mid-operation?`, { cause });
+        }
+    }));
+}
+function escapeXMLCharacters(original) {
+    const noAmps = original.replace("&", "&amp;");
+    const noLt = noAmps.replace("<", "<");
+    const noGt = noLt.replace(">", ">");
+    const noApos = noGt.replace('"', '\\"');
+    return noApos.replace("'", "\\'");
+}

package/build/common/template.js

@@ -0,0 +1,265 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { tasks } from "@clack/prompts";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { promisifiedSpawnTask } from "./child-process.js";
+import { getTemplateFilesToRenameAsync, renameTemplateAppNameAsync, } from "./rename-template-app-name.js";
+export async function applySelectedTemplatesAsync({ projectRoot, selection, enabledPlatforms, name, }) {
+    const descriptors = getOrderedTemplateDescriptors(selection, enabledPlatforms);
+    if (!descriptors.length) {
+        return;
+    }
+    // Post-process the templates just like the `react-native-macos-init` and
+    // `react-native init-windows` commands do:
+    //
+    // macos:
+    // - https://github.com/microsoft/react-native-macos/blob/eb3bccb6e738650d617945770ec1319d5880084b/packages/react-native-macos-init/src/cli.ts#L398
+    // - https://github.com/microsoft/react-native-macos/blob/eb3bccb6e738650d617945770ec1319d5880084b/packages/react-native/local-cli/generate-macos.js#L18
+    // - https://github.com/microsoft/react-native-macos/tree/main/packages/react-native/local-cli/generator-macos/templates/macos
+    //
+    // windows:
+    // - https://github.com/microsoft/react-native-windows/blob/3d64f71ed8495da6a0dcfc1f97bcb8f761986594/packages/%40react-native-windows/cli/src/generator-windows/index.ts#L57
+    // - https://github.com/microsoft/react-native-windows/tree/main/vnext/templates/cpp-app
+    for (const descriptor of descriptors) {
+        const source = parseTemplateSource(descriptor.value);
+        const extracted = await prepareTemplateSourceAsync(source);
+        try {
+            const templateRoot = await resolveTemplateRootAsync(extracted, source);
+            const templateConfig = await loadTemplateConfigAsync(templateRoot);
+            await copyTemplateFilesAsync({
+                sourceRoot: templateRoot,
+                projectRoot,
+                name,
+                templateConfig,
+            });
+        }
+        finally {
+            await fs.rm(extracted, { recursive: true, force: true });
+        }
+    }
+}
+function getOrderedTemplateDescriptors(selection, enabledPlatforms) {
+    const platformSet = new Set(enabledPlatforms);
+    const descriptors = new Array();
+    if (selection.template) {
+        descriptors.push({ key: "template", value: selection.template });
+    }
+    if (selection["template-ios"] && platformSet.has("ios")) {
+        descriptors.push({
+            key: "template-ios",
+            value: selection["template-ios"],
+            forPlatform: "ios",
+        });
+    }
+    if (selection["template-android"] && platformSet.has("android")) {
+        descriptors.push({
+            key: "template-android",
+            value: selection["template-android"],
+            forPlatform: "android",
+        });
+    }
+    if (selection["template-macos"] && platformSet.has("macos")) {
+        descriptors.push({
+            key: "template-macos",
+            value: selection["template-macos"],
+            forPlatform: "macos",
+        });
+    }
+    if (selection["template-windows"] && platformSet.has("windows")) {
+        descriptors.push({
+            key: "template-windows",
+            value: selection["template-windows"],
+            forPlatform: "windows",
+        });
+    }
+    return descriptors;
+}
+function parseTemplateSource(template) {
+    const localPath = path.resolve(process.cwd(), template);
+    if (/\.(?:tar|tgz|tar\.gz)$/i.test(template)) {
+        return { type: "local-tarball", path: localPath };
+    }
+    const githubUrlMatch = template.match(/^https:\/\/github\.com\/([^/]+)\/([^/#]+?)(?:\/(?:tree|blob)\/([^/]+)(?:\/(.+))?)?$/);
+    if (githubUrlMatch) {
+        const [, owner, repo, ref = "HEAD", subpath] = githubUrlMatch;
+        return { type: "github", owner, repo, ref, subpath: subpath ?? null };
+    }
+    const githubShorthandMatch = template.match(/^([^/\s#]+)\/([^/\s#]+)(?:#(.+))?$/);
+    if (githubShorthandMatch) {
+        const [, owner, repo, rawRef] = githubShorthandMatch;
+        const [ref, ...subpathParts] = (rawRef ?? "HEAD").split(":");
+        return {
+            type: "github",
+            owner,
+            repo,
+            ref,
+            subpath: subpathParts.length ? subpathParts.join(":") : null,
+        };
+    }
+    return { type: "npm", spec: template };
+}
+async function prepareTemplateSourceAsync(source) {
+    const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "expo-desktop-template-"));
+    const archivePath = path.join(tempRoot, "template.tgz");
+    switch (source.type) {
+        case "local-tarball":
+            await fs.copyFile(source.path, archivePath);
+            break;
+        case "github": {
+            const tarballUrl = `https://codeload.github.com/${source.owner}/${source.repo}/tar.gz/${source.ref}`;
+            const response = await fetch(tarballUrl);
+            if (!response.ok || !response.body) {
+                throw new Error(`Failed to download template tarball from ${tarballUrl}`);
+            }
+            const bytes = new Uint8Array(await response.arrayBuffer());
+            await fs.writeFile(archivePath, bytes);
+            break;
+        }
+        case "npm": {
+            await tasks([
+                promisifiedSpawnTask({
+                    title: `npm pack (${source.spec})`,
+                    command: "npm",
+                    args: ["pack", source.spec, "--silent"],
+                    options: { cwd: tempRoot },
+                }),
+            ]);
+            const entries = await fs.readdir(tempRoot);
+            const packed = entries.find((entry) => entry.endsWith(".tgz"));
+            if (!packed) {
+                throw new Error(`Could not pack template "${source.spec}".`);
+            }
+            await fs.rename(path.join(tempRoot, packed), archivePath);
+            break;
+        }
+    }
+    await tasks([
+        promisifiedSpawnTask({
+            title: "extracting template",
+            command: "tar",
+            args: ["-xzf", archivePath, "-C", tempRoot],
+        }),
+    ]);
+    return tempRoot;
+}
+async function resolveTemplateRootAsync(extractedRoot, source) {
+    const entries = await fs.readdir(extractedRoot, { withFileTypes: true });
+    const firstDir = entries.find((entry) => entry.isDirectory() && entry.name !== ".git");
+    if (!firstDir) {
+        throw new Error("Extracted template archive did not contain a root directory.");
+    }
+    let templateRoot = path.join(extractedRoot, firstDir.name);
+    if (source.type === "npm") {
+        templateRoot = path.join(templateRoot, "package");
+    }
+    if (source.type === "github" && source.subpath) {
+        templateRoot = path.join(templateRoot, source.subpath);
+    }
+    return templateRoot;
+}
+async function loadTemplateConfigAsync(templateRoot) {
+    const configPath = path.join(templateRoot, "template.config.js");
+    try {
+        await fs.access(configPath);
+    }
+    catch {
+        return null;
+    }
+    const imported = (await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href)));
+    return imported.default ?? imported;
+}
+async function copyTemplateFilesAsync({ sourceRoot, projectRoot, name, templateConfig, }) {
+    const mappings = templateConfig?.files?.length
+        ? templateConfig.files.map((mapping) => ({
+            from: path.join(sourceRoot, mapping.from),
+            to: mapping.to ?? mapping.from,
+        }))
+        : await discoverAllFilesAsync(sourceRoot);
+    const pathReplacements = {
+        HelloWorld: name.filesafeName,
+        helloworld: name.filesafeName.toLowerCase(),
+        ...(templateConfig?.pathReplacements ?? {}),
+    };
+    const copiedRelativePaths = new Array();
+    for (const mapping of mappings) {
+        const relativePath = replaceTokens(mapping.to, pathReplacements);
+        const targetPath = path.join(projectRoot, relativePath);
+        await fs.mkdir(path.dirname(targetPath), { recursive: true });
+        await fs.copyFile(mapping.from, targetPath);
+        copiedRelativePaths.push(relativePath);
+    }
+    if (templateConfig?.replacements && Object.keys(templateConfig.replacements).length > 0) {
+        await applyExtraReplacementsAsync({
+            cwd: projectRoot,
+            files: copiedRelativePaths,
+            replacements: templateConfig.replacements,
+        });
+    }
+    const filesFromRenameConfig = await getTemplateFilesToRenameAsync(projectRoot, {
+        renameConfig: templateConfig?.renameConfig,
+    });
+    const copiedSet = new Set(copiedRelativePaths.map(normalizeToPosixPath));
+    const filesToRename = filesFromRenameConfig.filter((file) => copiedSet.has(normalizeToPosixPath(file)));
+    await renameTemplateAppNameAsync(projectRoot, {
+        filesafeName: name.filesafeName,
+        files: filesToRename,
+    });
+}
+async function discoverAllFilesAsync(sourceRoot) {
+    const out = new Array();
+    await walkFilesAsync(sourceRoot, sourceRoot, out);
+    return out.filter((entry) => path.basename(entry.to) !== "template.config.js");
+}
+async function walkFilesAsync(currentDir, sourceRoot, output) {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const absolute = path.join(currentDir, entry.name);
+        if (entry.isDirectory()) {
+            await walkFilesAsync(absolute, sourceRoot, output);
+            continue;
+        }
+        if (!entry.isFile()) {
+            continue;
+        }
+        output.push({ from: absolute, to: path.relative(sourceRoot, absolute) });
+    }
+}
+function replaceTokens(input, replacements) {
+    let output = input;
+    for (const [from, to] of Object.entries(replacements)) {
+        output = output.split(from).join(to);
+    }
+    return output;
+}
+async function applyExtraReplacementsAsync({ cwd, files, replacements, }) {
+    for (const file of files) {
+        const absolute = path.join(cwd, file);
+        let contents;
+        try {
+            contents = await fs.readFile(absolute, "utf8");
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+                throw error;
+            }
+            continue;
+        }
+        const replacement = replaceTokens(contents, replacements);
+        if (replacement === contents) {
+            continue;
+        }
+        await fs.writeFile(absolute, replacement, "utf8");
+    }
+}
+function normalizeToPosixPath(input) {
+    return input.replaceAll(path.sep, "/");
+}

package/build/create-app/command.js

@@ -17,6 +17,13 @@ export async function newExpoDesktopProject(args) {
                 rdns: "com.example.my-app-123",
             },
             packageManager: "bun",
+            templates: {
+                template: args.template,
+                "template-ios": args["template-ios"],
+                "template-android": args["template-android"],
+                "template-macos": args["template-macos"],
+                "template-windows": args["template-windows"],
+            },
             versions: {
                 expoMajor: 54,
                 expoBlankTypeScript: "54.0.45",
@@ -49,7 +56,18 @@ export async function newExpoDesktopProject(args) {
     if (isCancel(packageManager)) {
         process.exit(0);
     }
-    await createExpoDesktopApp({ name, packageManager, versions });
+    await createExpoDesktopApp({
+        name,
+        packageManager,
+        versions,
+        templates: {
+            template: args.template,
+            "template-ios": args["template-ios"],
+            "template-android": args["template-android"],
+            "template-macos": args["template-macos"],
+            "template-windows": args["template-windows"],
+        },
+    });
 }
 async function configureAppName(args) {
     const { initialFilesafeName, initialDisplayName, initialRdns } = args;

package/build/create-app/create-expo-desktop-app.js

@@ -11,6 +11,7 @@ import { makePrettySummary } from "../common/arktype.js";
 import { promisifiedSpawnTask, SPAWN_DEBUG_LOG_GLOB } from "../common/child-process.js";
 import { title } from "../common/clack.js";
 import { packageManagerExec } from "../common/npm.js";
+import { applySelectedTemplatesAsync } from "../common/template.js";
 /**
  * A crude switch to use to help with local development.
  *
@@ -20,9 +21,29 @@ import { packageManagerExec } from "../common/npm.js";
  * - Adds the apply-config-plugins.mjs script.
  */
 export const localDev = false;
-export async function createExpoDesktopApp({ name, packageManager, versions, }) {
+export async function createExpoDesktopApp({ name, packageManager, templates, versions, }) {
     const { projectPath } = await createExpoApp({ name, packageManager, versions });
     await appendRootGitignoreSpawnDebugLogs(projectPath);
+    const templateSelection = {
+        // https://github.com/expo/expo/blob/sdk-54/templates/expo-template-blank-typescript
+        template: templates.template,
+        "template-ios": templates["template-ios"],
+        "template-android": templates["template-android"],
+        // https://github.com/microsoft/react-native-macos/tree/main/packages/react-native/local-cli/generator-macos/templates/macos
+        "template-macos": templates["template-macos"] ??
+            "microsoft/react-native-macos#main:packages/react-native/local-cli/generator-macos/templates",
+        // https://github.com/microsoft/react-native-windows/tree/main/vnext/templates/cpp-app
+        "template-windows": templates["template-windows"] ??
+            "microsoft/react-native-windows#main:vnext/templates/cpp-app",
+    };
+    title("Applying templates…", { spacing: 1 });
+    await applySelectedTemplatesAsync({
+        projectRoot: projectPath,
+        selection: templateSelection,
+        enabledPlatforms: ["ios", "android", "macos", "windows"],
+        name,
+    });
+    console.log(`${green("◆")}  Applied templates.\n`);
     title("Altering app.json…", { spacing: 1 });
     await updateAppJson({ name, projectPath });
     title("Altering package.json…", { spacing: 1 });
@@ -34,11 +55,6 @@ export async function createExpoDesktopApp({ name, packageManager, versions, })
     });
     title("Installing dependencies…", { spacing: 1 });
     await npmInstall({ cwd: projectPath, packageManager });
-    title("Adding the Windows app…", { spacing: 1 });
-    await addDesktopApp({ cwd: projectPath, name, packageManager, type: "windows", versions });
-    title("Adding the macOS app…", { spacing: 1 });
-    await updatePackageJson({ name, projectPath, versions, task: { type: "pre-init-macos" } });
-    await addDesktopApp({ cwd: projectPath, name, packageManager, type: "macos", versions });
     await updatePackageJson({
         name,
         projectPath,
@@ -201,23 +217,7 @@ async function updatePackageJson({ name, projectPath, task, versions, }) {
         throw new Error(`Invalid config:\n${makePrettySummary(packageJson).join("\n")}`);
     }
     const nameBefore = packageJson.name;
-    if (task.type === "pre-init-macos") {
-        // create-expo-app shifts this to lowercase as per package.json rules, and
-        // then react-native-macos-init maddeningly uses it in preference over the
-        // app.json "name" value.
-        // https://github.com/microsoft/react-native-macos/blob/eb3bccb6e738650d617945770ec1319d5880084b/packages/react-native-macos-init/src/cli.ts#L74-L75
-        //
-        // If only the underlying generateMacOS() / copyProjectTemplateAndReplace()
-        // were exposed, we could just pass the name needed.
-        // https://github.com/microsoft/react-native-macos/blob/eb3bccb6e738650d617945770ec1319d5880084b/packages/react-native-macos-init/src/cli.ts#L398
-        // https://github.com/microsoft/react-native-macos/blob/eb3bccb6e738650d617945770ec1319d5880084b/packages/react-native/local-cli/generate-macos.js#L18
-        //
-        // But as it's not, our best option is to just write an invalid name into
-        // the package.json temporarily (or remove it altogether). We'll set it
-        // back to lower case later in the "restore-name" task.
-        packageJson.name = name.filesafeName;
-    }
-    else if (task.type === "post-init-macos") {
+    if (task.type === "post-init-macos") {
         if (task.name) {
             packageJson.name = task.name;
         }
@@ -295,36 +295,6 @@ async function npmInstall({ cwd, packageManager, }) {
     }
     console.log(`\n${green("◆")}  Installed dependencies.\n`);
 }
-async function addDesktopApp({ name, packageManager, versions, type, cwd, }) {
-    const { args, command } = packageManagerExec(packageManager);
-    switch (type) {
-        case "macos":
-            args.push("react-native-macos-init", "--version", versions.macos);
-            break;
-        case "windows":
-            args.push("react-native", "init-windows", "--template", "cpp-app", "--namespace", name.rdns.replaceAll(/[-_]/g, ""), "--name", name.filesafeName);
-            break;
-    }
-    const printedCommand = `${command} ${args.join(" ")}`;
-    console.log(`${cyan("◆")}  Running: ${yellow(printedCommand)}\n`);
-    try {
-        await tasks([
-            promisifiedSpawnTask({
-                title: type === "macos"
-                    ? "react-native-macos-init"
-                    : `react-native init-windows (${name.filesafeName})`,
-                command,
-                args,
-                options: { cwd, stdio: "inherit" },
-            }),
-        ]);
-    }
-    catch (error) {
-        log.error(`Error running ${yellow(printedCommand)}${error instanceof Error ? `: ${error.message}` : "."}`);
-        process.exit(1);
-    }
-    console.log(`${green("◆")}  Added ${yellow(type)} app.\n`);
-}
 async function runPrebuildMobile({ packageManager, projectPath, }) {
     const { args, command } = packageManagerExec(packageManager);
     args.push("expo", "prebuild", "--no-install");

package/build/prebuild/command.js

@@ -1,6 +1,11 @@
 import { log } from "@clack/prompts";
+import { type } from "arktype";
 import { default as kleur } from "kleur";
+import fs from "node:fs/promises";
+import path from "node:path";
 import { exit } from "node:process";
+import { AppJson } from "../common/app-json.js";
+import { applySelectedTemplatesAsync } from "../common/template.js";
 import { resolvePackageManagerOptions } from "./resolve-options.js";
 /**
  * The entrypoint for `npx expo prebuild` is here:
@@ -12,21 +17,10 @@ import { resolvePackageManagerOptions } from "./resolve-options.js";
  * @see https://github.com/expo/expo/blob/15d35298c9a397c23bcbf6b20e2b9761564acbc4/packages/%40expo/cli/src/prebuild/index.ts#L7
  * @see https://github.com/expo/expo/blob/15d35298c9a397c23bcbf6b20e2b9761564acbc4/packages/%40expo/cli/src/prebuild/configureProjectAsync.ts#L37
  */
-export async function prebuild({ clean, "no-install": noInstall, npm, yarn, bun, pnpm, template, platform, }) {
+export async function prebuild({ clean, "no-install": noInstall, npm, yarn, bun, pnpm, template, "template-ios": templateIos, "template-android": templateAndroid, "template-macos": templateMacos, "template-windows": templateWindows, platform, }) {
     log.info(`🏎️  Running ${kleur.yellow("expo-desktop prebuild")}.`, { withGuide: false });
     // TODO: if packageManager undefined, infer from lockfiles
     const _packageManager = resolvePackageManagerOptions({ noInstall, npm, yarn, bun, pnpm });
-    if (template) {
-        // macos:
-        // - https://github.com/microsoft/react-native-macos/blob/eb3bccb6e738650d617945770ec1319d5880084b/packages/react-native-macos-init/src/cli.ts#L398
-        // - https://github.com/microsoft/react-native-macos/blob/eb3bccb6e738650d617945770ec1319d5880084b/packages/react-native/local-cli/generate-macos.js#L18
-        // - https://github.com/microsoft/react-native-macos/tree/main/packages/react-native/local-cli/generator-macos/templates/macos
-        //
-        // windows:
-        // - https://github.com/microsoft/react-native-windows/blob/3d64f71ed8495da6a0dcfc1f97bcb8f761986594/packages/%40react-native-windows/cli/src/generator-windows/index.ts#L57
-        // - https://github.com/microsoft/react-native-windows/tree/main/vnext/templates/cpp-app
-        throw new Error("--template arg not yet implemented.");
-    }
     if (platform !== "macos" &&
         platform !== "windows" &&
         platform !== "desktop" &&
@@ -43,6 +37,24 @@ export async function prebuild({ clean, "no-install": noInstall, npm, yarn, bun,
     if (!platforms.length) {
         throw new Error("At least one platform must be enabled when syncing");
     }
+    const templateSelection = {
+        template,
+        "template-ios": templateIos,
+        "template-android": templateAndroid,
+        "template-macos": templateMacos,
+        "template-windows": templateWindows,
+    };
+    if (clean && hasTemplateSelection(templateSelection)) {
+        const projectRoot = process.cwd();
+        const appName = await readAppNameFromConfigAsync(projectRoot);
+        await applySelectedTemplatesAsync({
+            projectRoot,
+            selection: templateSelection,
+            enabledPlatforms: platforms,
+            name: appName,
+        });
+        log.info("Applied project templates for clean prebuild.", { withGuide: false });
+    }
     // TODO:
     // - prebuildAsync()
     //   - https://github.com/expo/expo/blob/8dd645080f52927e2a8bf406167da7241a1d46d8/packages/%40expo/cli/src/prebuild/prebuildAsync.ts#L49
@@ -67,3 +79,26 @@ export async function prebuild({ clean, "no-install": noInstall, npm, yarn, bun,
     log.error(`${kleur.yellow("expo-desktop prebuild")} not yet implemented.`);
     return exit(1);
 }
+function hasTemplateSelection(selection) {
+    return Boolean(selection.template ||
+        selection["template-ios"] ||
+        selection["template-android"] ||
+        selection["template-macos"] ||
+        selection["template-windows"]);
+}
+async function readAppNameFromConfigAsync(projectRoot) {
+    const appJsonPath = path.join(projectRoot, "app.json");
+    const contents = await fs.readFile(appJsonPath, "utf8");
+    const parsed = AppJson(JSON.parse(contents));
+    if (parsed instanceof type.errors) {
+        throw new Error("Invalid app.json while resolving template replacements.");
+    }
+    const filesafeName = parsed.expo?.name ?? "HelloWorld";
+    const displayName = parsed.expo?.name ?? filesafeName;
+    const rdns = parsed.expo?.ios?.bundleIdentifier ?? parsed.expo?.android?.package ?? "com.helloworld";
+    return {
+        filesafeName,
+        displayName,
+        rdns,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-desktop",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "Best-effort desktop support for Expo",
   "keywords": [
     "android",
@@ -37,10 +37,11 @@
     "@clack/prompts": "^1.2.0",
     "arktype": "^2.2.0",
     "citty": "^0.2.2",
+    "glob": "^10.5.0",
     "kleur": "^4.1.5",
     "toml": "^4.1.1",
-    "expo-desktop-config-plugins": "1.1.16",
-    "expo-desktop-prebuild-config": "1.0.5"
+    "expo-desktop-config-plugins": "1.1.17",
+    "expo-desktop-prebuild-config": "1.0.6"
   },
   "devDependencies": {
     "@expo/config": "^12.0.13",