expo-desktop 0.1.17 → 0.1.19

package/build/cli.js

@@ -23,6 +23,11 @@ const main = defineCommand({
                     description: `The ${kleur.bold("display name")} for the app ${grey("(Examples: 'My App 123', '俺のアプリ')")}`,
                     valueHint: "name",
                 },
+                "local-dev": {
+                    type: "boolean",
+                    description: "An undocumented switch for use during development to skip the questionnaire.",
+                    hidden: true,
+                },
                 rdns: {
                     type: "string",
                     description: `The ${kleur.bold("reverse DNS")} for the app ${grey("(Example: 'com.example.my-app-123')")}`,

package/build/common/apply-windows-cpp-app-template.js

@@ -0,0 +1,369 @@
+import { glob } from "glob";
+import mustache from "mustache";
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import packageJson from "../../package.json" with { type: "json" };
+/**
+ * Mirrors the effective behaviour of `vnext/templates/cpp-app/template.config.js`
+ * from react-native-windows (path renames + Mustache replacements) without
+ * executing that file (it pulls undeclared deps and `../templateUtils`).
+ *
+ * @see https://github.com/microsoft/react-native-windows/blob/main/vnext/templates/cpp-app/template.config.js
+ * @see https://github.com/microsoft/react-native-windows/blob/main/packages/%40react-native-windows/cli/src/generator-common/index.ts
+ */
+export async function applyWindowsCppAppTemplateAsync(projectRoot, name) {
+    const windowsRoot = path.join(projectRoot, "windows");
+    try {
+        await fs.access(windowsRoot);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+            throw error;
+        }
+        return;
+    }
+    if (!(await looksLikeCppAppTemplateAsync(windowsRoot))) {
+        return;
+    }
+    const replacements = await buildReplacementsRecord(projectRoot, name);
+    await renameCppAppPathsAsync(windowsRoot, name.filesafeName);
+    await renderMustacheUnderWindowsAsync(windowsRoot, replacements);
+    await finalizeWindowsCppTemplateArtifacts(projectRoot, windowsRoot);
+}
+async function looksLikeCppAppTemplateAsync(windowsRoot) {
+    try {
+        await fs.access(path.join(windowsRoot, "MyApp"));
+        return true;
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+            throw error;
+        }
+        const entries = await fs.readdir(windowsRoot).catch(() => []);
+        return entries.some((e) => e.includes("MyApp"));
+    }
+}
+/** Same as legacy `react-native init-windows --namespace` (strip `-` and `_` only). */
+function windowsNamespaceFromRdns(rdns) {
+    return rdns.replaceAll(/[-_]/g, "");
+}
+async function tryReadRnwFromNodeModules(projectRoot) {
+    const pkgPath = path.join(projectRoot, "node_modules", "react-native-windows", "package.json");
+    try {
+        const raw = await fs.readFile(pkgPath, "utf8");
+        const version = JSON.parse(raw).version;
+        if (!version) {
+            return null;
+        }
+        const rnwPath = path.dirname(pkgPath);
+        let devMode = false;
+        try {
+            await fs.access(path.join(rnwPath, "src-win"));
+            devMode = true;
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+                throw error;
+            }
+            devMode = false;
+        }
+        return { path: rnwPath, version, devMode };
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+            throw error;
+        }
+        return null;
+    }
+}
+async function reactNativeWindowsVersionFromPackageJson(projectRoot) {
+    const pkgPath = path.join(projectRoot, "package.json");
+    try {
+        const raw = await fs.readFile(pkgPath, "utf8");
+        const parsed = JSON.parse(raw);
+        const v = parsed.dependencies?.["react-native-windows"];
+        return typeof v === "string" ? v : null;
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+            throw error;
+        }
+        return null;
+    }
+}
+async function buildReplacementsRecord(projectRoot, name) {
+    const projectGuid = crypto.randomUUID();
+    const packageGuid = crypto.randomUUID();
+    const namespace = windowsNamespaceFromRdns(name.rdns);
+    const namespaceCpp = namespace.replaceAll(".", "::");
+    const mainComponentName = name.filesafeName;
+    const rnw = await tryReadRnwFromNodeModules(projectRoot);
+    const rnwVersion = rnw?.version ?? (await reactNativeWindowsVersionFromPackageJson(projectRoot)) ?? "0.0.0";
+    const rnwPathFromProjectRoot = rnw
+        ? path.relative(projectRoot, rnw.path).replaceAll("/", "\\")
+        : "node_modules\\react-native-windows";
+    const devMode = rnw?.devMode ?? false;
+    const isCanary = rnwVersion.includes("canary");
+    return {
+        name: name.filesafeName,
+        namespace,
+        namespaceCpp,
+        rnwVersion,
+        rnwPathFromProjectRoot,
+        mainComponentName,
+        projectGuidLower: `{${projectGuid.toLowerCase()}}`,
+        projectGuidUpper: `{${projectGuid.toUpperCase()}}`,
+        packageGuidLower: `{${packageGuid.toLowerCase()}}`,
+        packageGuidUpper: `{${packageGuid.toUpperCase()}}`,
+        currentUser: os.userInfo().username,
+        devMode,
+        useNuGets: !devMode,
+        addReactNativePublicAdoFeed: true || isCanary,
+        cppNugetPackages: [],
+        autolinkPropertiesForProps: "",
+        autolinkProjectReferencesForTargets: "",
+        autolinkCppIncludes: "",
+        autolinkCppPackageProviders: "\n UNREFERENCED_PARAMETER(packageProviders);",
+    };
+}
+function cppAppRelativePathTransform(relativeToWindows, filesafeName) {
+    const parts = relativeToWindows.split(/[/\\]/);
+    const base = parts.at(-1) ?? "";
+    if (base === "_gitignore") {
+        parts[parts.length - 1] = ".gitignore";
+    }
+    else if (base === "NuGet_Config") {
+        parts[parts.length - 1] = "NuGet.config";
+    }
+    return parts.join(path.sep).split("MyApp").join(filesafeName);
+}
+function pathDepth(p) {
+    return p.split(path.sep).filter(Boolean).length;
+}
+async function collectWindowsPathsAsync(windowsRoot) {
+    const out = [];
+    async function walk(current) {
+        let stat;
+        try {
+            stat = await fs.lstat(current);
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+                throw error;
+            }
+            return;
+        }
+        if (stat.isSymbolicLink()) {
+            return;
+        }
+        if (stat.isDirectory()) {
+            out.push(current);
+            for (const ent of await fs.readdir(current, { withFileTypes: true })) {
+                await walk(path.join(current, ent.name));
+            }
+            return;
+        }
+        if (stat.isFile()) {
+            out.push(current);
+        }
+    }
+    await walk(windowsRoot);
+    return out;
+}
+/**
+ * Renames cpp-app paths containing `MyApp` → filesafeName. Uses iterative
+ * shallow-first ordering (directories before files at the same depth). Deeper
+ * fixes caused ENOTEMPTY: files were renamed into `*.Package/Images` before the
+ * directory `MyApp.Package/Images` moved, leaving a non-empty destination.
+ */
+async function renameCppAppPathsAsync(windowsRoot, filesafeName) {
+    for (;;) {
+        const allPaths = await collectWindowsPathsAsync(windowsRoot);
+        const candidates = [];
+        for (const abs of allPaths) {
+            const rel = path.relative(windowsRoot, abs);
+            if (!rel || rel.includes("..")) {
+                continue;
+            }
+            if (!rel.includes("MyApp")) {
+                continue;
+            }
+            let stat;
+            try {
+                stat = await fs.lstat(abs);
+            }
+            catch (error) {
+                if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+                    throw error;
+                }
+                continue;
+            }
+            if (stat.isSymbolicLink()) {
+                continue;
+            }
+            candidates.push({
+                abs,
+                rel,
+                depth: pathDepth(rel),
+                isDir: stat.isDirectory(),
+            });
+        }
+        if (!candidates.length) {
+            break;
+        }
+        candidates.sort((a, b) => {
+            if (a.depth !== b.depth) {
+                return a.depth - b.depth;
+            }
+            if (a.isDir !== b.isDir) {
+                return a.isDir ? -1 : 1;
+            }
+            return a.rel.localeCompare(b.rel);
+        });
+        const chosen = candidates[0];
+        const newRelWin = cppAppRelativePathTransform(chosen.rel, filesafeName);
+        if (newRelWin === chosen.rel) {
+            throw new Error(`Windows cpp-app rename: expected path containing MyApp to change: "${chosen.rel}"`);
+        }
+        const newAbs = path.join(windowsRoot, newRelWin);
+        if (newAbs === chosen.abs) {
+            continue;
+        }
+        await fs.mkdir(path.dirname(newAbs), { recursive: true });
+        try {
+            await fs.rename(chosen.abs, newAbs);
+        }
+        catch (cause) {
+            throw new Error(`Failed to rename "${chosen.abs}" -> "${newAbs}"`, { cause });
+        }
+    }
+}
+const BINARY_EXTENSIONS = new Set([
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".webp",
+    ".jar",
+    ".keystore",
+    ".ico",
+    ".pdb",
+    ".dll",
+    ".exe",
+    ".bin",
+]);
+function isProbablyBinaryFile(filePath) {
+    return BINARY_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+}
+function adjustReplacementStringsForLineEndings(view, useCRLF) {
+    const out = { ...view };
+    for (const [key, value] of Object.entries(out)) {
+        if (typeof value === "string") {
+            out[key] = useCRLF ? value.replaceAll(/(?<!\r)\n/g, "\r\n") : value.replaceAll(/\r\n/g, "\n");
+        }
+    }
+    return out;
+}
+async function collectWindowsFilesAsync(windowsRoot) {
+    const all = await collectWindowsPathsAsync(windowsRoot);
+    const files = new Array();
+    for (const p of all) {
+        try {
+            if ((await fs.lstat(p)).isFile()) {
+                files.push(p);
+            }
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+                throw error;
+            }
+            // skip
+        }
+    }
+    return files;
+}
+async function renderMustacheUnderWindowsAsync(windowsRoot, view) {
+    const filePaths = await collectWindowsFilesAsync(windowsRoot);
+    await Promise.all(filePaths.map(async (absoluteFilePath) => {
+        if (isProbablyBinaryFile(absoluteFilePath)) {
+            return;
+        }
+        let content;
+        try {
+            content = await fs.readFile(absoluteFilePath, "utf8");
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+                throw error;
+            }
+            return;
+        }
+        if (!content.includes("{{")) {
+            return;
+        }
+        const useCRLF = content.includes("\r\n");
+        const adjustedView = adjustReplacementStringsForLineEndings(view, useCRLF);
+        const rendered = mustache.render(content, adjustedView);
+        if (rendered !== content) {
+            await fs.writeFile(absoluteFilePath, rendered, "utf8");
+        }
+    }));
+}
+async function finalizeWindowsCppTemplateArtifacts(projectRoot, windowsRoot) {
+    const gitignoreRelPaths = await glob("**/_gitignore", {
+        cwd: windowsRoot,
+        nodir: true,
+        dot: true,
+    });
+    for (const rel of gitignoreRelPaths.sort().reverse()) {
+        const fromAbs = path.join(windowsRoot, rel);
+        const toAbs = path.join(windowsRoot, path.dirname(rel), ".gitignore");
+        await renameIfExistsPreferDest(fromAbs, toAbs);
+    }
+    await renameIfExistsPreferDest(path.join(projectRoot, "NuGet_Config"), path.join(projectRoot, "NuGet.config"));
+    const version = packageJson.version;
+    const banner = `<!-- This project was created with expo-desktop ${version} -->`;
+    const reactNativeWindowsBanner = /<!--\s*This project was created with react-native-windows[^\n\r]*-->/g;
+    const vcxprojRelPaths = await glob("windows/**/*.vcxproj", {
+        cwd: projectRoot,
+        nodir: true,
+        dot: true,
+    });
+    await Promise.all(vcxprojRelPaths.map(async (relPath) => {
+        const absolutePath = path.join(projectRoot, relPath);
+        let contents;
+        try {
+            contents = await fs.readFile(absolutePath, "utf8");
+        }
+        catch {
+            return;
+        }
+        const replaced = contents.replace(reactNativeWindowsBanner, banner);
+        if (replaced !== contents) {
+            await fs.writeFile(absolutePath, replaced, "utf8");
+        }
+    }));
+}
+async function renameIfExistsPreferDest(from, to) {
+    try {
+        await fs.access(from);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+            throw error;
+        }
+        return;
+    }
+    try {
+        await fs.rename(from, to);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+            await fs.unlink(from);
+            return;
+        }
+        throw error;
+    }
+}

package/build/common/preserve-file.js

@@ -0,0 +1,13 @@
+import fs from "node:fs/promises";
+/**
+ * Read the state of a file on first call of the generator, then run the
+ * generator again to restore it back to that value that was read.
+ */
+export async function* preserveFile({ filePath, enable, }) {
+    if (!enable) {
+        return;
+    }
+    const fileBefore = await fs.readFile(filePath, "utf-8");
+    yield;
+    await fs.writeFile(filePath, fileBefore, "utf-8");
+}

package/build/common/template.js

@@ -11,9 +11,10 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { applyWindowsCppAppTemplateAsync } from "./apply-windows-cpp-app-template.js";
 import { promisifiedSpawnTask } from "./child-process.js";
 import { getTemplateFilesToRenameAsync, renameTemplateAppNameAsync, } from "./rename-template-app-name.js";
-export async function applySelectedTemplatesAsync({ projectRoot, selection, enabledPlatforms, name, }) {
+export async function applySelectedTemplatesAsync({ projectRoot, selection, enabledPlatforms, name, respectTemplateConfig, }) {
     const descriptors = getOrderedTemplateDescriptors(selection, enabledPlatforms);
     if (!descriptors.length) {
         return;
@@ -29,17 +30,20 @@ export async function applySelectedTemplatesAsync({ projectRoot, selection, enab
     // 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) {
+    for (const [index, descriptor] of Object.entries(descriptors)) {
         const source = parseTemplateSource(descriptor.value);
-        const extracted = await prepareTemplateSourceAsync(source);
+        const extracted = await prepareTemplateSourceAsync(`Extracting template ${parseInt(index) + 1}/${descriptors.length} (--template ${descriptor.key})`, source);
         try {
             const templateRoot = await resolveTemplateRootAsync(extracted, source);
-            const templateConfig = await loadTemplateConfigAsync(templateRoot);
+            const templateConfig = respectTemplateConfig
+                ? await loadTemplateConfigAsync(templateRoot)
+                : undefined;
             await copyTemplateFilesAsync({
                 sourceRoot: templateRoot,
                 projectRoot,
                 name,
                 templateConfig,
+                forPlatform: descriptor.forPlatform,
             });
         }
         finally {
@@ -107,7 +111,7 @@ function parseTemplateSource(template) {
     }
     return { type: "npm", spec: template };
 }
-async function prepareTemplateSourceAsync(source) {
+async function prepareTemplateSourceAsync(taskTitle, source) {
     const tempRoot = await fs.mkdtemp(path.join(os.tmpdir(), "expo-desktop-template-"));
     const archivePath = path.join(tempRoot, "template.tgz");
     switch (source.type) {
@@ -144,7 +148,7 @@ async function prepareTemplateSourceAsync(source) {
     }
     await tasks([
         promisifiedSpawnTask({
-            title: "extracting template",
+            title: taskTitle,
             command: "tar",
             args: ["-xzf", archivePath, "-C", tempRoot],
         }),
@@ -172,12 +176,12 @@ async function loadTemplateConfigAsync(templateRoot) {
         await fs.access(configPath);
     }
     catch {
-        return null;
+        return;
     }
     const imported = (await import(__rewriteRelativeImportExtension(pathToFileURL(configPath).href)));
     return imported.default ?? imported;
 }
-async function copyTemplateFilesAsync({ sourceRoot, projectRoot, name, templateConfig, }) {
+async function copyTemplateFilesAsync({ sourceRoot, projectRoot, name, templateConfig, forPlatform, }) {
     const mappings = templateConfig?.files?.length
         ? templateConfig.files.map((mapping) => ({
             from: path.join(sourceRoot, mapping.from),
@@ -213,6 +217,12 @@ async function copyTemplateFilesAsync({ sourceRoot, projectRoot, name, templateC
         filesafeName: name.filesafeName,
         files: filesToRename,
     });
+    if (forPlatform === "macos") {
+        await renameMacosUnderscoreGitignore(projectRoot);
+    }
+    if (forPlatform === "windows") {
+        await applyWindowsCppAppTemplateAsync(projectRoot, name);
+    }
 }
 async function discoverAllFilesAsync(sourceRoot) {
     const out = new Array();
@@ -263,3 +273,26 @@ async function applyExtraReplacementsAsync({ cwd, files, replacements, }) {
 function normalizeToPosixPath(input) {
     return input.replaceAll(path.sep, "/");
 }
+async function renameMacosUnderscoreGitignore(projectRoot) {
+    const from = path.join(projectRoot, "macos", "_gitignore");
+    const to = path.join(projectRoot, "macos", ".gitignore");
+    try {
+        await fs.access(from);
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+            throw error;
+        }
+        return;
+    }
+    try {
+        await fs.rename(from, to);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "EEXIST") {
+            await fs.unlink(from);
+            return;
+        }
+        throw error;
+    }
+}

package/build/create-app/command.js

@@ -3,20 +3,21 @@ import { default as kleur } from "kleur";
 import { green, grey } from "kleur/colors";
 import { platform } from "node:process";
 import { title } from "../common/clack.js";
-import { createExpoDesktopApp, localDev } from "./create-expo-desktop-app.js";
+import { createExpoDesktopApp } from "./create-expo-desktop-app.js";
 import { previewFileTree } from "./preview-file-tree.js";
 import { promptForVersion } from "./prompt-for-version.js";
 export async function newExpoDesktopProject(args) {
-    // A dev-time switch for skipping the questions
-    const skip = localDev;
-    if (skip) {
+    // A switch for skipping the questions
+    const localDev = args["local-dev"];
+    if (localDev) {
         await createExpoDesktopApp({
+            localDev,
             name: {
-                displayName: "My App Display Name",
-                filesafeName: "MyApp6",
-                rdns: "com.example.my-app-123",
+                displayName: "Your App Display Name",
+                filesafeName: "YourApp456",
+                rdns: "uk.co.birchlabs.your-app-456",
             },
-            packageManager: "bun",
+            packageManager: "pnpm",
             templates: {
                 template: args.template,
                 "template-ios": args["template-ios"],
@@ -57,6 +58,7 @@ export async function newExpoDesktopProject(args) {
         process.exit(0);
     }
     await createExpoDesktopApp({
+        localDev,
         name,
         packageManager,
         versions,

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

@@ -11,18 +11,10 @@ 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 { preserveFile } from "../common/preserve-file.js";
 import { applySelectedTemplatesAsync } from "../common/template.js";
-/**
- * A crude switch to use to help with local development.
- *
- * - Skips the questionnaire at the start.
- * - Installs the local copy of expo-desktop-config-plugins rather than pinning
- *   to a published release.
- * - Adds the apply-config-plugins.mjs script.
- */
-export const localDev = false;
-export async function createExpoDesktopApp({ name, packageManager, templates, versions, }) {
-    const { projectPath } = await createExpoApp({ name, packageManager, versions });
+export async function createExpoDesktopApp({ localDev, name, packageManager, templates, versions, }) {
+    const { projectPath } = await createExpoApp({ localDev, name, packageManager, versions });
     await appendRootGitignoreSpawnDebugLogs(projectPath);
     const templateSelection = {
         // https://github.com/expo/expo/blob/sdk-54/templates/expo-template-blank-typescript
@@ -42,19 +34,26 @@ export async function createExpoDesktopApp({ name, packageManager, templates, ve
         selection: templateSelection,
         enabledPlatforms: ["ios", "android", "macos", "windows"],
         name,
+        // I had originally hoped to consume the template.config.js file provided by
+        // the template, but the prototype in cpp-app imports dependencies like
+        // "chalk", "lodash", "username", and "../templateUtils" that it doesn't
+        // declare in any package.json, so we can't reliably support it. Will
+        // revisit the idea in future.
+        respectTemplateConfig: false,
     });
     console.log(`${green("◆")}  Applied templates.\n`);
     title("Altering app.json…", { spacing: 1 });
     await updateAppJson({ name, projectPath });
     title("Altering package.json…", { spacing: 1 });
     const { name: packageJsonName } = await updatePackageJson({
+        localDev,
         name,
         projectPath,
         versions,
         task: { type: "create" },
     });
     title("Installing dependencies…", { spacing: 1 });
-    await npmInstall({ cwd: projectPath, packageManager });
+    await npmInstall({ asNewWorkspace: true, cwd: projectPath, packageManager });
     await updatePackageJson({
         name,
         projectPath,
@@ -94,7 +93,22 @@ export async function createExpoDesktopApp({ name, packageManager, templates, ve
     await writeBabelConfig({ projectPath });
     // TODO: Set up Windows app.cpp entrypoint
 }
-async function createExpoApp({ name, packageManager, versions, }) {
+async function createExpoApp({ localDev, name, packageManager, versions, }) {
+    // `create-expo-app` aggravatingly reconfigures your workspace to use
+    // `nodeLinker: hoisted`, which sucks when creating sample projects inside
+    // this monorepo during local dev (even with `--no-install`). So we fight
+    // back.
+    //
+    // For non-local dev, it sounds like we can use `nodeLinker: isolated` as of
+    // Expo SDK 54, so I'm tempted to enforce that in created templates, too. But
+    // one thing at a time.
+    // - https://docs.expo.dev/more/create-expo/#pnpm
+    // - https://github.com/expo/expo/blob/222b3b12610d69784bab6c5a188a46ea388f866a/packages/create-expo/src/resolvePackageManager.ts#L109
+    const gen = preserveFile({
+        enable: localDev,
+        filePath: localDev ? path.resolve(import.meta.dirname, "../../../../pnpm-workspace.yaml") : "",
+    });
+    await gen.next();
     // `npm create` drops flags meant for create-expo-app unless you add `--`; use
     // `npx --yes` instead to forward args correctly and skip prompts.
     const command = packageManager === "npm" ? "npx" : packageManager;
@@ -127,6 +141,9 @@ async function createExpoApp({ name, packageManager, versions, }) {
         log.error(`Error running ${yellow("create expo-app")}${error instanceof Error ? `: ${error.message}` : "."}`);
         process.exit(1);
     }
+    finally {
+        await gen.next();
+    }
     return { projectPath };
 }
 async function appendRootGitignoreSpawnDebugLogs(projectPath) {
@@ -203,7 +220,7 @@ async function updateAppJson({ name, projectPath, }) {
     }
     console.log(`${green("◆")}  Altered app.json.\n`);
 }
-async function updatePackageJson({ name, projectPath, task, versions, }) {
+async function updatePackageJson({ localDev, name, projectPath, task, versions, }) {
     const packageJsonPath = path.resolve(projectPath, "package.json");
     let packageJson;
     try {
@@ -275,10 +292,41 @@ async function updatePackageJson({ name, projectPath, task, versions, }) {
     console.log(`${green("◆")}  Altered package.json.\n`);
     return { name: nameBefore };
 }
-async function npmInstall({ cwd, packageManager, }) {
+async function npmInstall({ asNewWorkspace, cwd, packageManager, }) {
     const command = packageManager;
     const args = ["install"];
     console.log(`${cyan("◆")}  Running: ${yellow(`${command} ${args.join(" ")}`)}\n`);
+    // Unlike npm and bun, pnpm climbs up to install dependencies in the closest
+    // ancestor directory if there is one. This is particularly inconvenient
+    // during local dev when we're creating samples inside the monorepo.
+    if (asNewWorkspace && packageManager === "pnpm") {
+        // (1) Ensure a file name pnpm-workspace.yaml exists.
+        //
+        // (2) Also ensure that it uses nodeLinker: hoisted, as otherwise
+        // `:path => "#{config[:reactNativePath]}-macos"` predicts that there will
+        // be a react-native-macos directory right beside the react-native
+        // directory by just optimistically appending "-macos" on the end, like so:
+        // "../node_modules/.pnpm/react-native@0.81.5_@babel+core@7.29.0_@react-native-community+cli@20.1.3_typescript@5._941d99d35895d1a3626e14fd9f3b3666/node_modules/react-native" + "-macos"
+        //
+        //     As this is not true with pnpm's default `nodeLinker: isolated`, we
+        //     need to stick to `nodeLinker: hoisted` until we can rewrite the
+        //     Podfile script to resolve it properly.
+        //
+        //     This is consistent with what the Expo team do for pnpm and yarn:
+        //     - https://docs.expo.dev/more/create-expo/#pnpm
+        //     - https://github.com/expo/expo/blob/222b3b12610d69784bab6c5a188a46ea388f866a/packages/create-expo/src/resolvePackageManager.ts#L109
+        try {
+            await fs.writeFile(path.resolve(cwd, "pnpm-workspace.yaml"), "nodeLinker: hoisted\n", {
+                flag: "wx",
+                encoding: "utf-8",
+            });
+        }
+        catch (error) {
+            if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
+                throw error;
+            }
+        }
+    }
     try {
         await tasks([
             promisifiedSpawnTask({

package/build/prebuild/command.js

@@ -52,6 +52,7 @@ export async function prebuild({ clean, "no-install": noInstall, npm, yarn, bun,
             selection: templateSelection,
             enabledPlatforms: platforms,
             name: appName,
+            respectTemplateConfig: false,
         });
         log.info("Applied project templates for clean prebuild.", { withGuide: false });
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "expo-desktop",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Best-effort desktop support for Expo",
   "keywords": [
     "android",
@@ -39,14 +39,16 @@
     "citty": "^0.2.2",
     "glob": "^10.5.0",
     "kleur": "^4.1.5",
+    "mustache": "^4.2.0",
     "toml": "^4.1.1",
-    "expo-desktop-config-plugins": "1.1.17",
-    "expo-desktop-prebuild-config": "1.0.6"
+    "expo-desktop-config-plugins": "1.1.19",
+    "expo-desktop-prebuild-config": "1.0.8"
   },
   "devDependencies": {
     "@expo/config": "^12.0.13",
     "@expo/config-plugins": "^54.0.4",
     "@tsconfig/node24": "^24.0.4",
+    "@types/mustache": "^4.2.6",
     "@types/node": "^24.12.2",
     "@typescript/native-preview": "^7.0.0-dev.20260425.1",
     "vitest": "^3.2.4"