expo-desktop 0.1.37 → 1.0.0-beta.0

package/build/cli.js

@@ -13,21 +13,34 @@ const main = defineCommand({
         "create-app": defineCommand({
             meta: { name: "create-app", description: "Create a new Expo Desktop project" },
             args: {
-                "filesafe-name": {
-                    type: "string",
-                    description: `The ${kleur.bold("filesafe name")} for the app in alphanumeric format ${grey("(Example: 'MyApp123')")}`,
-                    valueHint: "name",
+                "project-root": {
+                    type: "positional",
+                    required: false,
+                    description: `The ${kleur.bold("project root")} for the app in alphanumeric format ${grey("(Example: 'MyApp123')")}`,
                 },
                 "display-name": {
                     type: "string",
                     description: `The ${kleur.bold("display name")} for the app ${grey("(Examples: 'My App 123', '俺のアプリ')")}`,
                     valueHint: "name",
                 },
+                yes: {
+                    type: "boolean",
+                    description: "Use the default options for creating a project",
+                    alias: "y",
+                },
                 "local-dev": {
                     type: "boolean",
                     description: "An undocumented switch for use during development to skip the questionnaire.",
                     hidden: true,
                 },
+                "no-agents-md": {
+                    type: "boolean",
+                    description: "Skip generating AGENTS.md, CLAUDE.md, and .claude/settings.json",
+                },
+                "no-install": {
+                    type: "boolean",
+                    description: "Skip installing npm packages or CocoaPods",
+                },
                 rdns: {
                     type: "string",
                     description: `The ${kleur.bold("reverse DNS")} for the app ${grey("(Example: 'com.example.my-app-123')")}`,
@@ -43,28 +56,10 @@ const main = defineCommand({
                     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 }) {
+                parseNoArg(args, "no-agents-md");
+                parseNoArg(args, "no-install");
                 (await import("./create-app/command.js")).newExpoDesktopProject(args);
             },
         }),
@@ -100,37 +95,38 @@ 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)")}`,
-                    valueHint: "desktop|macos|windows",
+                    description: `Platforms to sync: ios, android, mobile, macos, windows, desktop, or all ${dim("(Default: desktop)")}`,
+                    valueHint: "ios|android|mobile|macos|windows|desktop|all",
                     alias: "p",
                 },
+                "skip-dependency-update": {
+                    type: "boolean",
+                    valueHint: "dependencies",
+                    description: "Preserves versions of listed packages in package.json (comma separated list)",
+                },
             },
             async run({ args }) {
+                parseNoArg(args, "no-install");
                 (await import("./prebuild/command.js")).prebuild(args);
             },
         }),
     },
 });
 await runMain(main);
+function parseNoArg(args, noKey, defaultValue = true) {
+    const [, yesKey] = noKey.split("no-");
+    // Assuming the noArg has no default value:
+    //
+    // When `--no-install` is passed, it parses as:
+    // { install: false, "no-install": undefined }
+    //
+    // When `--no-install` is omitted, it parses as:
+    // { install: undefined, "no-install": undefined }
+    if (args[yesKey] === undefined) {
+        args[yesKey] = defaultValue;
+    }
+    args[noKey] = !args[yesKey];
+    return noKey;
+}

package/build/common/expo/cmd.js

@@ -0,0 +1,2 @@
+import packageJson from "../../../package.json" with { type: "json" };
+export const CLI_NAME = packageJson.name;

package/build/common/expo/cocoapods.js

@@ -0,0 +1,159 @@
+import { getPackageJson } from "@expo/config";
+import * as PackageManager from "@expo/package-manager";
+import chalk from "chalk";
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { hashForDependencyMap } from "../../prebuild/expo/update-package-json.js";
+import { ensureDirectoryAsync } from "./dir.js";
+import { env } from "./env.js";
+import { AbortCommandError } from "./error.js";
+import * as Log from "./log.js";
+import { logNewSection } from "./ora.js";
+const require = createRequire(import.meta.url);
+const JsonFile = require("@expo/json-file").default;
+const PROJECT_PREBUILD_SETTINGS = ".expo/prebuild";
+const CACHED_PACKAGE_JSON = "cached-packages.json";
+function getTempPrebuildFolder(projectRoot) {
+    return path.join(projectRoot, PROJECT_PREBUILD_SETTINGS);
+}
+function hasNewDependenciesSinceLastBuild(projectRoot, packageChecksums) {
+    // TODO: Maybe comparing lock files would be better...
+    const templateDirectory = getTempPrebuildFolder(projectRoot);
+    const tempPkgJsonPath = path.join(templateDirectory, CACHED_PACKAGE_JSON);
+    if (!fs.existsSync(tempPkgJsonPath)) {
+        return true;
+    }
+    const { dependencies, devDependencies } = JsonFile.read(tempPkgJsonPath);
+    // Only change the dependencies if the normalized hash changes, this helps to reduce meaningless changes.
+    const hasNewDependencies = packageChecksums.dependencies !== dependencies;
+    const hasNewDevDependencies = packageChecksums.devDependencies !== devDependencies;
+    return hasNewDependencies || hasNewDevDependencies;
+}
+function createPackageChecksums(pkg) {
+    return {
+        dependencies: hashForDependencyMap(pkg.dependencies || {}),
+        devDependencies: hashForDependencyMap(pkg.devDependencies || {}),
+    };
+}
+/** @returns `true` if the package.json dependency hash does not match the cached hash from the last run. */
+export async function hasPackageJsonDependencyListChangedAsync(projectRoot) {
+    const pkg = getPackageJson(projectRoot);
+    const packages = createPackageChecksums(pkg);
+    const hasNewDependencies = hasNewDependenciesSinceLastBuild(projectRoot, packages);
+    // Cache package.json
+    await ensureDirectoryAsync(getTempPrebuildFolder(projectRoot));
+    const templateDirectory = path.join(getTempPrebuildFolder(projectRoot), CACHED_PACKAGE_JSON);
+    await JsonFile.writeAsync(templateDirectory, packages);
+    return hasNewDependencies;
+}
+export async function installCocoaPodsAsync(projectRoot, platform) {
+    let step = logNewSection(`Installing CocoaPods for ${platform}…`);
+    if (process.platform !== "darwin") {
+        step.succeed("Skipped installing CocoaPods because operating system is not on macOS.");
+        return false;
+    }
+    const packageManager = new PackageManager.CocoaPodsPackageManager({
+        cwd: path.join(projectRoot, platform),
+        silent: !(env.EXPO_DEBUG || env.CI),
+    });
+    if (!(await packageManager.isCLIInstalledAsync())) {
+        try {
+            // prompt user -- do you want to install cocoapods right now?
+            step.text = "CocoaPods CLI not found in your PATH, installing it now.";
+            step.stopAndPersist();
+            await PackageManager.CocoaPodsPackageManager.installCLIAsync({
+                nonInteractive: true,
+                spawnOptions: {
+                    ...packageManager.options,
+                    // Don't silence this part
+                    stdio: ["inherit", "inherit", "pipe"],
+                },
+            });
+            step.succeed("Installed CocoaPods CLI.");
+            step = logNewSection("Running `pod install` in the `ios` directory.");
+        }
+        catch (error) {
+            step.stopAndPersist({
+                symbol: "⚠️ ",
+                text: chalk.red("Unable to install the CocoaPods CLI."),
+            });
+            if (error instanceof PackageManager.CocoaPodsError) {
+                Log.log(error.message);
+            }
+            else {
+                Log.log(`Unknown error: ${error.message}`);
+            }
+            return false;
+        }
+    }
+    try {
+        await packageManager.installAsync({ spinner: step });
+        // Create cached list for later
+        await hasPackageJsonDependencyListChangedAsync(projectRoot).catch(() => null);
+        step.succeed(`Installed CocoaPods for ${platform}.`);
+        return true;
+    }
+    catch (error) {
+        step.stopAndPersist({
+            symbol: "⚠️ ",
+            text: chalk.red(`Something went wrong running \`pod install\` in the \`${platform}\` directory.`),
+        });
+        if (error instanceof PackageManager.CocoaPodsError) {
+            Log.log(error.message);
+        }
+        else {
+            Log.log(`Unknown error: ${error.message}`);
+        }
+        return false;
+    }
+}
+function doesProjectUseCocoaPods(projectRoot, platform) {
+    return fs.existsSync(path.join(projectRoot, platform, "Podfile"));
+}
+function isLockfileCreated(projectRoot, platform) {
+    const podfileLockPath = path.join(projectRoot, platform, "Podfile.lock");
+    return fs.existsSync(podfileLockPath);
+}
+function isPodFolderCreated(projectRoot, platform) {
+    const podFolderPath = path.join(projectRoot, platform, "Pods");
+    return fs.existsSync(podFolderPath);
+}
+// TODO: Same process but with app.config changes + default plugins.
+// This will ensure the user is prompted for extra setup.
+export async function maybePromptToSyncPodsAsync(projectRoot, platform) {
+    if (!doesProjectUseCocoaPods(projectRoot, platform)) {
+        // Project does not use CocoaPods
+        return;
+    }
+    if (!isLockfileCreated(projectRoot, platform) || !isPodFolderCreated(projectRoot, platform)) {
+        if (!(await installCocoaPodsAsync(projectRoot, platform))) {
+            throw new AbortCommandError();
+        }
+        return;
+    }
+    // Getting autolinked packages can be heavy, optimize around checking every time.
+    if (!(await hasPackageJsonDependencyListChangedAsync(projectRoot))) {
+        return;
+    }
+    await promptToInstallPodsAsync(projectRoot, platform, []);
+}
+async function promptToInstallPodsAsync(projectRoot, platform, missingPods) {
+    if (missingPods?.length) {
+        Log.log(`Could not find the following native modules: ${missingPods
+            .map((pod) => chalk.bold(pod))
+            .join(", ")}. Did you forget to run "${chalk.bold("pod install")}" ?`);
+    }
+    try {
+        if (!(await installCocoaPodsAsync(projectRoot, platform))) {
+            throw new AbortCommandError();
+        }
+    }
+    catch (error) {
+        await fs.promises.rm(path.join(getTempPrebuildFolder(projectRoot), CACHED_PACKAGE_JSON), {
+            recursive: true,
+            force: true,
+        });
+        throw error;
+    }
+}

package/build/common/expo/create-async-utils.js

@@ -0,0 +1,108 @@
+import Debug from "debug";
+import fs from "node:fs";
+import path from "node:path";
+import { Log } from "./log.js";
+import { configurePackageManager, installDependenciesAsync, resolvePackageManager, } from "./resolve-package-manager.js";
+import { installPodsAsync, logProjectReady } from "./template.js";
+const debug = Debug("expo-desktop:create-app:createAsyncUtils");
+/**
+ * @see https://github.com/expo/expo/blob/6e418b5947dd8806ac97c19eb959ded3a1b14ea2/packages/create-expo/src/createAsync.ts#L255
+ */
+export async function configureNodeDependenciesAsync(projectRoot, packageManager) {
+    try {
+        await configurePackageManager(projectRoot, packageManager, { silent: false });
+    }
+    catch (error) {
+        debug(`Error configuring package manager: %O`, error);
+        Log.error(`Something went wrong configuring the package manager. Check your ${packageManager} logs. Continuing to create the app.`);
+        Log.exception(error);
+    }
+}
+/**
+ * @see https://github.com/expo/expo/blob/6e418b5947dd8806ac97c19eb959ded3a1b14ea2/packages/create-expo/src/createAsync.ts#L247-L253
+ */
+export function getChangeDirectoryPath(projectRoot) {
+    const cdPath = path.relative(process.cwd(), projectRoot);
+    if (cdPath.length <= projectRoot.length) {
+        return cdPath;
+    }
+    return projectRoot;
+}
+/**
+ * @see https://github.com/expo/expo/blob/6e418b5947dd8806ac97c19eb959ded3a1b14ea2/packages/create-expo/src/createAsync.ts#L285
+ */
+export async function installCocoaPodsAsync(projectRoot, platform) {
+    let podsInstalled = false;
+    try {
+        podsInstalled = await installPodsAsync(projectRoot, platform);
+    }
+    catch (error) {
+        debug(`Error installing CocoaPods for ${platform === "ios" ? "iOS" : "macOS"}: %O`, error);
+    }
+    return podsInstalled;
+}
+/**
+ * @see https://github.com/expo/expo/blob/6e418b5947dd8806ac97c19eb959ded3a1b14ea2/packages/create-expo/src/createAsync.ts#L270
+ */
+export async function installNodeDependenciesAsync(projectRoot, packageManager) {
+    try {
+        await installDependenciesAsync(projectRoot, packageManager, { silent: false });
+    }
+    catch (error) {
+        debug(`Error installing node modules: %O`, error);
+        Log.error(`Something went wrong installing JavaScript dependencies. Check your ${packageManager} logs. Continuing to create the app.`);
+        Log.exception(error);
+    }
+}
+/**
+ * @see https://github.com/expo/expo/blob/6e418b5947dd8806ac97c19eb959ded3a1b14ea2/packages/create-expo/src/createAsync.ts#L296
+ */
+export function logNodeInstallWarning(cdPath, packageManager, needsPods) {
+    console.log(`\n⚠️  Before running your app, make sure you have modules installed:\n`);
+    console.log(`  cd ${cdPath || "."}${path.sep}`);
+    console.log(`  ${packageManager} install`);
+    if (needsPods && process.platform === "darwin") {
+        console.log(`  pod install --project-directory=ios && pod install --project-directory=macos`);
+    }
+    console.log();
+}
+/**
+ *
+ * @param projectRoot
+ * @param props
+ * @see https://github.com/expo/expo/blob/6e418b5947dd8806ac97c19eb959ded3a1b14ea2/packages/create-expo/src/createAsync.ts#L60
+ */
+export async function setupDependenciesAsync(projectRoot, props) {
+    const shouldInstall = props.install;
+    const packageManager = resolvePackageManager();
+    // Configure package manager, which is unrelated to installing or not
+    await configureNodeDependenciesAsync(projectRoot, packageManager);
+    // Install dependencies
+    let podsInstalledIos = false;
+    const needsPodsInstalledIos = fs.existsSync(path.join(projectRoot, "ios"));
+    let podsInstalledMacos = false;
+    const needsPodsInstalledMacos = fs.existsSync(path.join(projectRoot, "macos"));
+    if (shouldInstall) {
+        // Yarn refuses to install if it finds an ancestor directory with a
+        // package.json or yarn.lock. I'd rather it install as a separate workspace
+        // and that users merge it into their monorepo manually as needed, so we
+        // populate an empty yarn.lock file as they suggest.
+        if (packageManager === "yarn") {
+            await fs.promises.appendFile(path.join(projectRoot, "yarn.lock"), "", "utf-8");
+        }
+        await installNodeDependenciesAsync(projectRoot, packageManager);
+        if (needsPodsInstalledIos) {
+            podsInstalledIos = await installCocoaPodsAsync(projectRoot, "ios");
+        }
+        if (needsPodsInstalledMacos) {
+            podsInstalledMacos = await installCocoaPodsAsync(projectRoot, "macos");
+        }
+    }
+    const cdPath = getChangeDirectoryPath(projectRoot);
+    console.log();
+    logProjectReady({ cdPath, packageManager });
+    if (!shouldInstall) {
+        logNodeInstallWarning(cdPath, packageManager, (needsPodsInstalledIos && !podsInstalledIos) ||
+            (needsPodsInstalledMacos && !podsInstalledMacos));
+    }
+}

package/build/common/expo/create-file-transform.js

@@ -0,0 +1,70 @@
+// https://github.com/expo/expo/blob/main/packages/create-expo/src/createFileTransform.ts
+import Debug from "debug";
+import { TarTypeFlag } from "multitars";
+import path from "node:path";
+import picomatch from "picomatch";
+const debug = Debug("expo-desktop:create-app:fileTransform");
+export function sanitizedName(name) {
+    return name
+        .replace(/[\W_]+/g, "")
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "");
+}
+// Directories that can be added to the template with an underscore instead of a dot, e.g. `.vscode` and be added with `_vscode`.
+const SUPPORTED_DIRECTORIES = ["eas", "vscode", "github", "cursor"];
+const SUPPORTED_DIRECTORIES_PATTERN = new RegExp(`(^|/|\\\\)_(${SUPPORTED_DIRECTORIES.join("|")})(/|\\\\|$)`);
+function renameDirectories(input, typeflag) {
+    if (typeflag === TarTypeFlag.FILE || typeflag === TarTypeFlag.DIRECTORY) {
+        // Detect if the file contains one of the supported directories
+        // and rename it to the correct format.
+        // For example, if the file is `_vscode`, we want to rename it to `.vscode`.
+        input = input.replace(SUPPORTED_DIRECTORIES_PATTERN, (match, p1, p2, p3) => `${p1}.${p2}${p3}`);
+    }
+    return input;
+}
+function renameConfigs(input, typeflag) {
+    if (typeflag === TarTypeFlag.FILE && /_?gitignore$/.test(path.basename(input))) {
+        // Rename `gitignore` and `_gitignore`, because npm ignores files named
+        // `.gitignore` when publishing.
+        // See: https://github.com/npm/npm/issues/1862
+        input = input.replace(/_?gitignore$/, ".gitignore");
+    }
+    if (typeflag === TarTypeFlag.FILE && path.basename(input) === "NuGet_Config") {
+        // Rename `NuGet_Config` to `NuGet.config`.
+        input = input.replace(/NuGet_Config$/, "NuGet.config");
+    }
+    return input;
+}
+export function createEntryRenamer(name) {
+    return (input, typeflag) => {
+        if (name) {
+            // Rewrite paths for bare workflow
+            input = input
+                .replace(/HelloWorld/g, input.includes("android") ? sanitizedName(name.toLowerCase()) : sanitizedName(name))
+                /*
+                 * The Windows template placeholder name is "MyApp" rather than
+                 * "HelloWorld". The React Native Windows CLI renames files like
+                 * MyApp.cpp to `${filesafeName}.cpp`, which we used to do too (via the
+                 * commented-out code below).
+                 *
+                 * However, I've decided to fix it to "MyApp", because by keeping the
+                 * names stable as MyApp, we can avoid desyncs between dirty
+                 * prebuilds (which don't rename files) and clean prebuilds (which do).
+                 */
+                // .replace(/MyApp/g, sanitizedName(name))
+                .replace(/helloworld/g, sanitizedName(name).toLowerCase());
+        }
+        input = renameConfigs(input, typeflag);
+        input = renameDirectories(input, typeflag);
+        return input;
+    };
+}
+export function createGlobFilter(globPattern, options) {
+    const matcher = picomatch(globPattern, options);
+    debug("filter: created for pattern %s (%s)", globPattern);
+    return (path) => {
+        const included = matcher(path);
+        debug("filter: %s - %s", included ? "include" : "exclude", path);
+        return included;
+    };
+}

package/build/common/expo/dir.js

@@ -0,0 +1,89 @@
+import fs from "node:fs";
+import path from "node:path";
+export function fileExistsSync(file) {
+    return !!fs
+        .statSync(file, {
+        throwIfNoEntry: false,
+    })
+        ?.isFile();
+}
+export function directoryExistsSync(file) {
+    return !!fs
+        .statSync(file, {
+        throwIfNoEntry: false,
+    })
+        ?.isDirectory();
+}
+export async function directoryExistsAsync(file) {
+    return (await fs.promises.stat(file).catch(() => null))?.isDirectory() ?? false;
+}
+export async function fileExistsAsync(file) {
+    return (await fs.promises.stat(file).catch(() => null))?.isFile() ?? false;
+}
+export const ensureDirectoryAsync = (path) => fs.promises.mkdir(path, { recursive: true });
+export const ensureDirectory = (path) => {
+    fs.mkdirSync(path, {
+        recursive: true,
+    });
+};
+export const copySync = (src, dest) => {
+    const destParent = path.dirname(dest);
+    if (!fs.existsSync(destParent))
+        ensureDirectory(destParent);
+    fs.cpSync(src, dest, {
+        recursive: true,
+        force: true,
+    });
+};
+export const copyAsync = async (src, dest) => {
+    const destParent = path.dirname(dest);
+    if (!fs.existsSync(destParent)) {
+        await fs.promises.mkdir(destParent, { recursive: true });
+    }
+    await fs.promises.cp(src, dest, {
+        recursive: true,
+        force: true,
+    });
+};
+export const removeAsync = (path) => {
+    return fs.promises.rm(path, {
+        recursive: true,
+        force: true,
+    });
+};
+export function maybeRealpathSync(target) {
+    try {
+        return fs.realpathSync(target);
+    }
+    catch {
+        return null;
+    }
+}
+export function isPathInside(child, parent) {
+    const relative = path.relative(parent, child);
+    return !!relative && !relative.startsWith("..") && !path.isAbsolute(relative);
+}
+export function getConflictsForDirectory(projectRoot) {
+    return fs
+        .readdirSync(projectRoot)
+        .filter((file) => !(/\.iml$/.test(file) || tolerableFiles.includes(file)));
+}
+// Any of these files are allowed to exist in the projectRoot
+const tolerableFiles = [
+    // System
+    ".DS_Store",
+    "Thumbs.db",
+    // Git
+    ".git",
+    ".gitattributes",
+    ".gitignore",
+    // Project
+    ".npmignore",
+    "LICENSE",
+    "docs",
+    ".idea",
+    // Package manager
+    "npm-debug.log",
+    "yarn-debug.log",
+    "yarn-error.log",
+];

package/build/common/expo/env.js

@@ -0,0 +1,30 @@
+import GetEnv from "getenv";
+const { boolish } = GetEnv;
+class Env {
+    /** Enable debug logging */
+    get EXPO_DEBUG() {
+        return boolish("EXPO_DEBUG", false);
+    }
+    /** Enable the beta version of Expo (TODO: Should this just be in the beta version of expo releases?) */
+    get EXPO_BETA() {
+        return boolish("EXPO_BETA", false);
+    }
+    /** Is running in non-interactive CI mode */
+    get CI() {
+        return boolish("CI", false);
+    }
+    /** Disable all API caches. Does not disable bundler caches. */
+    get EXPO_NO_CACHE() {
+        return boolish("EXPO_NO_CACHE", false);
+    }
+    /** Disable telemetry (analytics) */
+    get EXPO_NO_TELEMETRY() {
+        return boolish("EXPO_NO_TELEMETRY", false);
+    }
+    // https://github.com/expo/expo/blob/main/packages/%40expo/cli/src/utils/env.ts
+    /** Skip warning users about a dirty git status */
+    get EXPO_NO_GIT_STATUS() {
+        return boolish("EXPO_NO_GIT_STATUS", true);
+    }
+}
+export const env = new Env();