expo-desktop 0.1.16 → 0.1.18

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/rename-template-app-name.js

@@ -1,7 +1,9 @@
-import { MacOSConfig } from "expo-desktop-config-plugins";
 import { glob } from "glob";
 import fs from "node:fs";
+import { createRequire } from "node:module";
 import path from "node:path";
+const require = createRequire(import.meta.url);
+const { MacOSConfig } = require("expo-desktop-config-plugins");
 /**
  * Returns a list of files within a template matched by the resolved rename
  * config.

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

@@ -12,9 +12,9 @@ export async function newExpoDesktopProject(args) {
     if (skip) {
         await createExpoDesktopApp({
             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",
             templates: {

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

@@ -42,6 +42,12 @@ 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 });

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.16",
+  "version": "0.1.18",
   "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.18",
+    "expo-desktop-prebuild-config": "1.0.7"
   },
   "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"