@shopify/create-app 3.94.3 → 4.1.0

package/dist/chunk-CEGG2EWP.js

@@ -0,0 +1,104 @@
+import {
+  outputDebug
+} from "./chunk-BMI6QCMV.js";
+import {
+  init_cjs_shims
+} from "./chunk-PKR7KJ6P.js";
+
+// ../cli-kit/dist/public/node/tree-kill.js
+init_cjs_shims();
+import { spawn } from "child_process";
+function treeKill(pid = process.pid, killSignal = "SIGTERM", killRoot = !0, callback) {
+  adaptedTreeKill(pid, killSignal, killRoot, callback ?? ((error) => {
+    error && outputDebug(`Failed to kill process ${pid}: ${error}`);
+  }));
+}
+function adaptedTreeKill(pid, killSignal, killRoot, callback) {
+  let rootPid = typeof pid == "number" ? pid.toString() : pid;
+  if (!/^\d+$/.test(rootPid))
+    if (callback) {
+      callback(new Error("pid must be a number"));
+      return;
+    } else
+      throw new Error("pid must be a number");
+  let tree = {};
+  tree[rootPid] = [];
+  let pidsToProcess = /* @__PURE__ */ new Set();
+  switch (pidsToProcess.add(rootPid), process.platform) {
+    case "win32": {
+      spawn("taskkill", ["/pid", rootPid, "/T", "/F"]).on("close", (code) => {
+        callback && (code === 0 ? callback() : callback(new Error(`taskkill exited with code ${code}`)));
+      });
+      break;
+    }
+    case "darwin":
+      buildProcessTree(rootPid, tree, pidsToProcess, function(parentPid) {
+        return spawn("pgrep", ["-lfP", parentPid]);
+      }, function() {
+        killAll(tree, killSignal, rootPid, killRoot, callback);
+      });
+      break;
+    default:
+      buildProcessTree(rootPid, tree, pidsToProcess, function(parentPid) {
+        return spawn("ps", ["-o", "pid command", "--no-headers", "--ppid", parentPid]);
+      }, function() {
+        killAll(tree, killSignal, rootPid, killRoot, callback);
+      });
+      break;
+  }
+}
+function killAll(tree, killSignal, rootPid, killRoot, callback) {
+  let killed = /* @__PURE__ */ new Set();
+  try {
+    Object.keys(tree).forEach(function(pid) {
+      tree[pid].forEach(function(pidpid) {
+        killed.has(pidpid) || (killPid(pidpid, killSignal), killed.add(pidpid));
+      }), pid === rootPid && killRoot && !killed.has(pid) && (killPid(pid, killSignal), killed.add(pid));
+    });
+  } catch (err) {
+    if (callback) {
+      callback(err);
+      return;
+    } else
+      throw err;
+  }
+  callback && callback();
+}
+function killPid(pid, killSignal) {
+  try {
+    process.kill(parseInt(pid, 10), killSignal);
+  } catch (err) {
+    if (err.code !== "ESRCH")
+      throw err;
+  }
+}
+function buildProcessTree(parentPid, tree, pidsToProcess, spawnChildProcessesList, cb) {
+  let ps = spawnChildProcessesList(parentPid), allData = "";
+  ps.stdout?.on("data", function(data) {
+    let dataStr = data.toString("ascii");
+    allData += dataStr;
+  });
+  let onClose = (code) => {
+    if (pidsToProcess.delete(parentPid), code !== 0) {
+      if (pidsToProcess.size === 0) {
+        cb();
+        return;
+      }
+      return;
+    }
+    allData.trim().split(`
+`).forEach(function(line) {
+      let match = line.match(/^(\d+)\s(.*)$/);
+      if (match) {
+        let pid = match[1], cmd = match[2];
+        tree[parentPid].push(pid), tree[pid] = [], outputDebug(`Killing process ${pid}: ${cmd}`), pidsToProcess.add(pid), buildProcessTree(pid, tree, pidsToProcess, spawnChildProcessesList, cb);
+      }
+    });
+  };
+  ps.on("close", onClose);
+}
+
+export {
+  treeKill
+};
+//# sourceMappingURL=chunk-CEGG2EWP.js.map

package/dist/chunk-DJW2W7VA.js

@@ -0,0 +1,21 @@
+import {
+  __commonJS,
+  init_cjs_shims
+} from "./chunk-PKR7KJ6P.js";
+
+// ../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js
+var require_has_flag = __commonJS({
+  "../../node_modules/.pnpm/has-flag@4.0.0/node_modules/has-flag/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    module.exports = (flag, argv = process.argv) => {
+      let prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--", position = argv.indexOf(prefix + flag), terminatorPosition = argv.indexOf("--");
+      return position !== -1 && (terminatorPosition === -1 || position < terminatorPosition);
+    };
+  }
+});
+
+export {
+  require_has_flag
+};
+//# sourceMappingURL=chunk-DJW2W7VA.js.map

package/dist/{chunk-LI75HRH4.js → chunk-DWGHKWV5.js}

@@ -13859,4 +13859,4 @@ export {
   debugApis,
   init_prettier
 };
-//# sourceMappingURL=chunk-LI75HRH4.js.map
+//# sourceMappingURL=chunk-DWGHKWV5.js.map

package/dist/chunk-JCETIRLI.js

@@ -0,0 +1,30 @@
+import {
+  init_cjs_shims
+} from "./chunk-PKR7KJ6P.js";
+
+// ../cli-kit/dist/private/node/context/deprecations-store.js
+init_cjs_shims();
+var deprecationsStore = {
+  nextDeprecationDate: void 0
+};
+function getNextDeprecationDate() {
+  return deprecationsStore.nextDeprecationDate;
+}
+function setNextDeprecationDate(dates) {
+  if (dates.length < 1)
+    return;
+  let earliestFutureDateTime = earliestDateTimeAfter(Date.now(), dates);
+  if (!earliestFutureDateTime)
+    return;
+  let nextDeprecationDate = getNextDeprecationDate();
+  (!nextDeprecationDate || earliestFutureDateTime < nextDeprecationDate.getTime()) && (deprecationsStore.nextDeprecationDate = new Date(earliestFutureDateTime));
+}
+function earliestDateTimeAfter(afterTime, dates) {
+  return dates.map((date) => date.getTime()).sort().find((time) => time > afterTime);
+}
+
+export {
+  getNextDeprecationDate,
+  setNextDeprecationDate
+};
+//# sourceMappingURL=chunk-JCETIRLI.js.map

package/dist/chunk-JT5MT2JE.js

@@ -0,0 +1,371 @@
+import {
+  cacheRetrieve,
+  cacheRetrieveOrRepopulate
+} from "./chunk-RB7BXTZQ.js";
+import {
+  AbortController,
+  exec
+} from "./chunk-C5OLLQWI.js";
+import {
+  runWithTimer
+} from "./chunk-SWITKWBS.js";
+import {
+  AbortError,
+  BugError
+} from "./chunk-MIECGF3H.js";
+import {
+  require_semver
+} from "./chunk-6OOTYTVB.js";
+import {
+  fileExists,
+  fileExistsSync,
+  findPathUp,
+  glob,
+  inferPackageManagerForGlobalCLI,
+  outputContent,
+  outputDebug,
+  outputToken,
+  readFile,
+  writeFile
+} from "./chunk-BMI6QCMV.js";
+import {
+  dirname,
+  joinPath
+} from "./chunk-ACS6S42W.js";
+import {
+  __toESM,
+  init_cjs_shims
+} from "./chunk-PKR7KJ6P.js";
+
+// ../cli-kit/dist/public/node/node-package-manager.js
+init_cjs_shims();
+
+// ../cli-kit/dist/public/common/json.js
+init_cjs_shims();
+function parseJSON(jsonString, context) {
+  try {
+    return JSON.parse(jsonString);
+  } catch (error) {
+    let errorMessage = error instanceof Error ? error.message : String(error), contextMessage = context ? ` from ${context}` : "";
+    throw new AbortError(`Failed to parse JSON${contextMessage}.
+${errorMessage}`);
+  }
+}
+
+// ../cli-kit/dist/public/node/node-package-manager.js
+var import_semver = __toESM(require_semver(), 1), yarnLockfile = "yarn.lock", npmLockfile = "package-lock.json", pnpmLockfile = "pnpm-lock.yaml", bunLockfile = "bun.lockb", modernBunLockfile = "bun.lock", pnpmWorkspaceFile = "pnpm-workspace.yaml", lockfiles = [yarnLockfile, pnpmLockfile, npmLockfile, bunLockfile, modernBunLockfile], lockfilesByManager = {
+  yarn: [yarnLockfile],
+  npm: [npmLockfile],
+  pnpm: [pnpmLockfile],
+  bun: [bunLockfile, modernBunLockfile],
+  homebrew: [],
+  unknown: []
+}, packageManager = ["yarn", "npm", "pnpm", "bun", "homebrew", "unknown"], UnknownPackageManagerError = class extends AbortError {
+  constructor() {
+    super("Unknown package manager");
+  }
+}, PackageJsonNotFoundError = class extends AbortError {
+  constructor(directory) {
+    super(outputContent`The directory ${outputToken.path(directory)} doesn't have a package.json.`);
+  }
+}, FindUpAndReadPackageJsonNotFoundError = class extends BugError {
+  constructor(directory) {
+    super(outputContent`Couldn't find a a package.json traversing directories from ${outputToken.path(directory)}`);
+  }
+};
+function packageManagerFromUserAgent(env = process.env) {
+  return env.npm_config_user_agent?.includes("yarn") ? "yarn" : env.npm_config_user_agent?.includes("pnpm") ? "pnpm" : env.npm_config_user_agent?.includes("bun") ? "bun" : env.npm_config_user_agent?.includes("npm") ? "npm" : "unknown";
+}
+function hasBunLockfileSync(directory) {
+  return fileExistsSync(joinPath(directory, bunLockfile)) || fileExistsSync(joinPath(directory, modernBunLockfile));
+}
+function normalizePackageManagerForProject(packageManager2) {
+  switch (packageManager2) {
+    case "yarn":
+    case "npm":
+    case "pnpm":
+    case "bun":
+      return packageManager2;
+    case "homebrew":
+    case "unknown":
+      return "npm";
+  }
+}
+function packageManagerBinaryCommand(packageManager2, binary, ...binaryArgs) {
+  switch (packageManager2) {
+    case "npm":
+      return { command: "npm", args: ["exec", "--", binary, ...binaryArgs] };
+    case "pnpm":
+      return { command: "pnpm", args: ["exec", binary, ...binaryArgs] };
+    case "yarn":
+      return { command: "yarn", args: ["run", binary, ...binaryArgs] };
+    case "bun":
+      return { command: "bun", args: ["x", binary, ...binaryArgs] };
+  }
+}
+async function getPackageManager(fromDirectory) {
+  let current = fromDirectory;
+  for (outputDebug(outputContent`Looking for a lockfile in ${outputToken.path(current)}...`); ; ) {
+    if (fileExistsSync(joinPath(current, yarnLockfile)))
+      return "yarn";
+    if (fileExistsSync(joinPath(current, pnpmLockfile)) || fileExistsSync(joinPath(current, pnpmWorkspaceFile)))
+      return "pnpm";
+    if (hasBunLockfileSync(current))
+      return "bun";
+    if (fileExistsSync(joinPath(current, npmLockfile)))
+      return "npm";
+    let parent = dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  let pm = packageManagerFromUserAgent();
+  return pm !== "unknown" ? pm : "npm";
+}
+async function packageManagerBinaryCommandForDirectory(fromDirectory, binary, ...binaryArgs) {
+  let packageManager2 = normalizePackageManagerForProject(await getPackageManager(fromDirectory));
+  return packageManagerBinaryCommand(packageManager2, binary, ...binaryArgs);
+}
+async function installNPMDependenciesRecursively(options) {
+  let packageJsons = await glob(joinPath(options.directory, "**/package.json"), {
+    ignore: [joinPath(options.directory, "node_modules/**/package.json")],
+    cwd: options.directory,
+    onlyFiles: !0,
+    deep: options.deep
+  }), abortController = new AbortController();
+  try {
+    await Promise.all(packageJsons.map(async (packageJsonPath) => {
+      let directory = dirname(packageJsonPath);
+      await installNodeModules({
+        directory,
+        packageManager: options.packageManager,
+        stdout: void 0,
+        stderr: void 0,
+        signal: abortController.signal,
+        args: []
+      });
+    }));
+  } catch (error) {
+    throw abortController.abort(), error;
+  }
+}
+async function installNodeModules(options) {
+  let execOptions = {
+    cwd: options.directory,
+    stdin: void 0,
+    stdout: options.stdout,
+    stderr: options.stderr,
+    signal: options.signal
+  }, args = ["install"];
+  options.args && (args = args.concat(options.args)), await runWithTimer("cmd_all_timing_network_ms")(async () => {
+    await exec(options.packageManager, args, execOptions);
+  });
+}
+async function getPackageName(packageJsonPath) {
+  return (await readAndParsePackageJson(packageJsonPath)).name;
+}
+async function getPackageVersion(packageJsonPath) {
+  return (await readAndParsePackageJson(packageJsonPath)).version;
+}
+async function getDependencies(packageJsonPath) {
+  let packageJsonContent = await readAndParsePackageJson(packageJsonPath), dependencies = packageJsonContent.dependencies ?? {}, devDependencies = packageJsonContent.devDependencies ?? {};
+  return { ...dependencies, ...devDependencies };
+}
+async function usesWorkspaces(appDirectory) {
+  let packageJsonPath = joinPath(appDirectory, "package.json"), packageJsonContent = await readAndParsePackageJson(packageJsonPath), pnpmWorkspacePath = joinPath(appDirectory, pnpmWorkspaceFile);
+  return !!packageJsonContent.workspaces || fileExists(pnpmWorkspacePath);
+}
+async function checkForNewVersion(dependency, currentVersion, { cacheExpiryInHours = 0 } = {}) {
+  let getLatestVersion = async () => (outputDebug(outputContent`Checking if there's a version of ${dependency} newer than ${currentVersion}`), getLatestNPMPackageVersion(dependency)), cacheKey = `npm-package-${dependency}`, lastVersion;
+  try {
+    lastVersion = await cacheRetrieveOrRepopulate(cacheKey, getLatestVersion, cacheExpiryInHours * 3600 * 1e3);
+  } catch {
+    return;
+  }
+  if (lastVersion && new import_semver.SemVer(currentVersion).compare(lastVersion) < 0)
+    return lastVersion;
+}
+function checkForCachedNewVersion(dependency, currentVersion) {
+  let cacheKey = `npm-package-${dependency}`, lastVersion = cacheRetrieve(cacheKey)?.value;
+  if (lastVersion && new import_semver.SemVer(currentVersion).compare(lastVersion) < 0)
+    return lastVersion;
+}
+function versionSatisfies(version, requirements) {
+  return (0, import_semver.satisfies)(version, requirements);
+}
+async function readAndParsePackageJson(packageJsonPath) {
+  if (!await fileExists(packageJsonPath))
+    throw new PackageJsonNotFoundError(dirname(packageJsonPath));
+  return parseJSON(await readFile(packageJsonPath), packageJsonPath);
+}
+async function addNPMDependenciesIfNeeded(dependencies, options) {
+  outputDebug(outputContent`Adding the following dependencies if needed:
+${outputToken.json(dependencies)}
+With options:
+${outputToken.json(options)}
+  `);
+  let packageJsonPath = joinPath(options.directory, "package.json");
+  if (!await fileExists(packageJsonPath))
+    throw new PackageJsonNotFoundError(options.directory);
+  let existingDependencies = Object.keys(await getDependencies(packageJsonPath)), dependenciesToAdd = dependencies.filter((dep) => !existingDependencies.includes(dep.name));
+  dependenciesToAdd.length !== 0 && await addNPMDependencies(dependenciesToAdd, options);
+}
+async function addNPMDependencies(dependencies, options) {
+  let dependenciesWithVersion = dependencies.map((dep) => dep.version ? `${dep.name}@${dep.version}` : dep.name);
+  switch (options.stdout?.write(`Installing ${dependenciesWithVersion.join(" ")} with ${options.packageManager}`), options.packageManager) {
+    case "npm":
+      for (let dep of dependenciesWithVersion)
+        await installDependencies(options, argumentsToAddDependenciesWithNPM(dep, options.type));
+      break;
+    case "yarn":
+      await installDependencies(options, argumentsToAddDependenciesWithYarn(dependenciesWithVersion, options.type, !!options.addToRootDirectory));
+      break;
+    case "pnpm":
+      await installDependencies(options, argumentsToAddDependenciesWithPNPM(dependenciesWithVersion, options.type, !!options.addToRootDirectory));
+      break;
+    case "bun":
+      await installDependencies(options, argumentsToAddDependenciesWithBun(dependenciesWithVersion, options.type)), await installDependencies(options, ["install"]);
+      break;
+    case "homebrew":
+      throw new AbortError("Homebrew can't be used to install project dependencies. Use npm, yarn, pnpm, or bun.");
+    case "unknown":
+      throw new UnknownPackageManagerError();
+  }
+}
+async function installDependencies(options, args) {
+  return runWithTimer("cmd_all_timing_network_ms")(async () => exec(options.packageManager, args, {
+    cwd: options.directory,
+    stdout: options.stdout,
+    stderr: options.stderr,
+    signal: options.signal
+  }));
+}
+async function addNPMDependenciesWithoutVersionIfNeeded(dependencies, options) {
+  await addNPMDependenciesIfNeeded(dependencies.map((dependency) => ({ name: dependency, version: void 0 })), options);
+}
+function argumentsToAddDependenciesWithNPM(dependency, type) {
+  let command = ["install"];
+  switch (command = command.concat(dependency), type) {
+    case "dev":
+      command.push("--save-dev");
+      break;
+    case "peer":
+      command.push("--save-peer");
+      break;
+    case "prod":
+      command.push("--save-prod");
+      break;
+  }
+  return dependency.match(/@\d/g) && command.push("--save-exact"), command;
+}
+function argumentsToAddDependenciesWithYarn(dependencies, type, addAtRoot = !1) {
+  let command = ["add"];
+  switch (addAtRoot && command.push("-W"), command = command.concat(dependencies), type) {
+    case "dev":
+      command.push("--dev");
+      break;
+    case "peer":
+      command.push("--peer");
+      break;
+    case "prod":
+      command.push("--prod");
+      break;
+  }
+  return command;
+}
+function argumentsToAddDependenciesWithPNPM(dependencies, type, addAtRoot = !1) {
+  let command = ["add"];
+  switch (addAtRoot && command.push("-w"), command = command.concat(dependencies), type) {
+    case "dev":
+      command.push("--save-dev");
+      break;
+    case "peer":
+      command.push("--save-peer");
+      break;
+    case "prod":
+      command.push("--save-prod");
+      break;
+  }
+  return command;
+}
+function argumentsToAddDependenciesWithBun(dependencies, type) {
+  let command = ["add"];
+  switch (command = command.concat(dependencies), type) {
+    case "dev":
+      command.push("--development");
+      break;
+    case "peer":
+      command.push("--optional");
+      break;
+    case "prod":
+      break;
+  }
+  return command;
+}
+async function findUpAndReadPackageJson(fromDirectory) {
+  let packageJsonPath = await findPathUp("package.json", { cwd: fromDirectory, type: "file" });
+  if (packageJsonPath) {
+    let packageJson = parseJSON(await readFile(packageJsonPath), packageJsonPath);
+    return { path: packageJsonPath, content: packageJson };
+  } else
+    throw new FindUpAndReadPackageJsonNotFoundError(fromDirectory);
+}
+async function addResolutionOrOverride(directory, dependencies) {
+  let packageManager2 = await getPackageManager(directory), packageJsonPath = joinPath(directory, "package.json"), packageJsonContent = await readAndParsePackageJson(packageJsonPath);
+  packageManager2 === "yarn" && (packageJsonContent.resolutions = packageJsonContent.resolutions ? { ...packageJsonContent.resolutions, ...dependencies } : dependencies), (packageManager2 === "npm" || packageManager2 === "pnpm" || packageManager2 === "bun") && (packageJsonContent.overrides = packageJsonContent.overrides ? { ...packageJsonContent.overrides, ...dependencies } : dependencies), await writeFile(packageJsonPath, JSON.stringify(packageJsonContent, null, 2));
+}
+async function getLatestNPMPackageVersion(name) {
+  return outputDebug(outputContent`Getting the latest version of NPM package: ${outputToken.raw(name)}`), runWithTimer("cmd_all_timing_network_ms")(async () => {
+    let { default: latestVersion } = await import("./latest-version-3PFKLJZM.js");
+    return latestVersion(name);
+  });
+}
+async function writePackageJSON(directory, packageJSON) {
+  outputDebug(outputContent`JSON-encoding and writing content to package.json at ${outputToken.path(directory)}...`);
+  let packagePath = joinPath(directory, "package.json");
+  await writeFile(packagePath, JSON.stringify(packageJSON, null, 2));
+}
+function inferPackageManager(optionsPackageManager, env = process.env) {
+  if (optionsPackageManager && packageManager.includes(optionsPackageManager))
+    return optionsPackageManager;
+  let usedPackageManager = packageManagerFromUserAgent(env);
+  if (usedPackageManager !== "unknown")
+    return usedPackageManager;
+  let globalPackageManager = inferPackageManagerForGlobalCLI();
+  return globalPackageManager !== "unknown" ? globalPackageManager : "npm";
+}
+
+export {
+  yarnLockfile,
+  npmLockfile,
+  pnpmLockfile,
+  bunLockfile,
+  pnpmWorkspaceFile,
+  lockfiles,
+  lockfilesByManager,
+  packageManager,
+  UnknownPackageManagerError,
+  PackageJsonNotFoundError,
+  FindUpAndReadPackageJsonNotFoundError,
+  packageManagerFromUserAgent,
+  getPackageManager,
+  packageManagerBinaryCommandForDirectory,
+  installNPMDependenciesRecursively,
+  installNodeModules,
+  getPackageName,
+  getPackageVersion,
+  getDependencies,
+  usesWorkspaces,
+  checkForNewVersion,
+  checkForCachedNewVersion,
+  versionSatisfies,
+  readAndParsePackageJson,
+  addNPMDependenciesIfNeeded,
+  addNPMDependencies,
+  addNPMDependenciesWithoutVersionIfNeeded,
+  findUpAndReadPackageJson,
+  addResolutionOrOverride,
+  writePackageJSON,
+  inferPackageManager
+};
+//# sourceMappingURL=chunk-JT5MT2JE.js.map