@shopify/create-app 3.58.2 → 3.59.1

package/dist/chunk-G6FN5VUE.js

@@ -0,0 +1,102 @@
+import {
+  basename,
+  dirname,
+  extname,
+  isAbsolute,
+  join,
+  normalize,
+  relative,
+  resolve
+} from "./chunk-GXPKATXW.js";
+import {
+  __commonJS,
+  __require,
+  __toESM,
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// ../../node_modules/.pnpm/commondir@1.0.1/node_modules/commondir/index.js
+var require_commondir = __commonJS({
+  "../../node_modules/.pnpm/commondir@1.0.1/node_modules/commondir/index.js"(exports, module) {
+    init_cjs_shims();
+    var path = __require("path");
+    module.exports = function(basedir, relfiles) {
+      if (relfiles) {
+        var files = relfiles.map(function(r) {
+          return path.resolve(basedir, r);
+        });
+      } else {
+        var files = basedir;
+      }
+      var res = files.slice(1).reduce(function(ps, file) {
+        if (!file.match(/^([A-Za-z]:)?\/|\\/)) {
+          throw new Error("relative path without a basedir");
+        }
+        var xs = file.split(/\/+|\\+/);
+        for (var i = 0; ps[i] === xs[i] && i < Math.min(ps.length, xs.length); i++)
+          ;
+        return ps.slice(0, i);
+      }, files[0].split(/\/+|\\+/));
+      return res.length > 1 ? res.join("/") : "/";
+    };
+  }
+});
+
+// ../cli-kit/src/public/node/path.ts
+init_cjs_shims();
+var import_commondir = __toESM(require_commondir(), 1);
+import { fileURLToPath } from "url";
+function joinPath(...paths) {
+  return join(...paths);
+}
+function normalizePath(path) {
+  return normalize(path);
+}
+function resolvePath(...paths) {
+  return resolve(...paths);
+}
+function relativePath(from, to) {
+  return relative(from, to);
+}
+function isAbsolutePath(path) {
+  return isAbsolute(path);
+}
+function dirname2(path) {
+  return dirname(path);
+}
+function basename2(path, ext) {
+  return basename(path, ext);
+}
+function extname2(path) {
+  return extname(path);
+}
+function relativizePath(path, dir = cwd()) {
+  const result = (0, import_commondir.default)([path, dir]);
+  const relativePath2 = relative(dir, path);
+  const relativeComponents = relativePath2.split("/").filter((component) => component === "..").length;
+  if (result === "/" || relativePath2 === "" || relativeComponents > 2) {
+    return path;
+  } else {
+    return relativePath2;
+  }
+}
+function moduleDirectory(moduleURL) {
+  return dirname2(fileURLToPath(moduleURL));
+}
+function cwd() {
+  return normalize(process.env.INIT_CWD ? process.env.INIT_CWD : process.cwd());
+}
+
+export {
+  joinPath,
+  normalizePath,
+  resolvePath,
+  relativePath,
+  isAbsolutePath,
+  dirname2 as dirname,
+  basename2 as basename,
+  extname2 as extname,
+  relativizePath,
+  moduleDirectory,
+  cwd
+};

package/dist/chunk-GXPKATXW.js

@@ -0,0 +1,194 @@
+import {
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// ../../node_modules/.pnpm/pathe@1.1.1/node_modules/pathe/dist/shared/pathe.92c04245.mjs
+init_cjs_shims();
+function normalizeWindowsPath(input = "") {
+  if (!input || !input.includes("\\")) {
+    return input;
+  }
+  return input.replace(/\\/g, "/");
+}
+var _UNC_REGEX = /^[/\\]{2}/;
+var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
+var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
+var normalize = function(path2) {
+  if (path2.length === 0) {
+    return ".";
+  }
+  path2 = normalizeWindowsPath(path2);
+  const isUNCPath = path2.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path2);
+  const trailingSeparator = path2[path2.length - 1] === "/";
+  path2 = normalizeString(path2, !isPathAbsolute);
+  if (path2.length === 0) {
+    if (isPathAbsolute) {
+      return "/";
+    }
+    return trailingSeparator ? "./" : ".";
+  }
+  if (trailingSeparator) {
+    path2 += "/";
+  }
+  if (_DRIVE_LETTER_RE.test(path2)) {
+    path2 += "/";
+  }
+  if (isUNCPath) {
+    if (!isPathAbsolute) {
+      return `//./${path2}`;
+    }
+    return `//${path2}`;
+  }
+  return isPathAbsolute && !isAbsolute(path2) ? `/${path2}` : path2;
+};
+var join = function(...arguments_) {
+  if (arguments_.length === 0) {
+    return ".";
+  }
+  let joined;
+  for (const argument of arguments_) {
+    if (argument && argument.length > 0) {
+      if (joined === void 0) {
+        joined = argument;
+      } else {
+        joined += `/${argument}`;
+      }
+    }
+  }
+  if (joined === void 0) {
+    return ".";
+  }
+  return normalize(joined.replace(/\/\/+/g, "/"));
+};
+function cwd() {
+  if (typeof process !== "undefined") {
+    return process.cwd().replace(/\\/g, "/");
+  }
+  return "/";
+}
+var resolve = function(...arguments_) {
+  arguments_ = arguments_.map((argument) => normalizeWindowsPath(argument));
+  let resolvedPath = "";
+  let resolvedAbsolute = false;
+  for (let index = arguments_.length - 1; index >= -1 && !resolvedAbsolute; index--) {
+    const path2 = index >= 0 ? arguments_[index] : cwd();
+    if (!path2 || path2.length === 0) {
+      continue;
+    }
+    resolvedPath = `${path2}/${resolvedPath}`;
+    resolvedAbsolute = isAbsolute(path2);
+  }
+  resolvedPath = normalizeString(resolvedPath, !resolvedAbsolute);
+  if (resolvedAbsolute && !isAbsolute(resolvedPath)) {
+    return `/${resolvedPath}`;
+  }
+  return resolvedPath.length > 0 ? resolvedPath : ".";
+};
+function normalizeString(path2, allowAboveRoot) {
+  let res = "";
+  let lastSegmentLength = 0;
+  let lastSlash = -1;
+  let dots = 0;
+  let char = null;
+  for (let index = 0; index <= path2.length; ++index) {
+    if (index < path2.length) {
+      char = path2[index];
+    } else if (char === "/") {
+      break;
+    } else {
+      char = "/";
+    }
+    if (char === "/") {
+      if (lastSlash === index - 1 || dots === 1)
+        ;
+      else if (dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res[res.length - 1] !== "." || res[res.length - 2] !== ".") {
+          if (res.length > 2) {
+            const lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex === -1) {
+              res = "";
+              lastSegmentLength = 0;
+            } else {
+              res = res.slice(0, lastSlashIndex);
+              lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+            }
+            lastSlash = index;
+            dots = 0;
+            continue;
+          } else if (res.length > 0) {
+            res = "";
+            lastSegmentLength = 0;
+            lastSlash = index;
+            dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          res += res.length > 0 ? "/.." : "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0) {
+          res += `/${path2.slice(lastSlash + 1, index)}`;
+        } else {
+          res = path2.slice(lastSlash + 1, index);
+        }
+        lastSegmentLength = index - lastSlash - 1;
+      }
+      lastSlash = index;
+      dots = 0;
+    } else if (char === "." && dots !== -1) {
+      ++dots;
+    } else {
+      dots = -1;
+    }
+  }
+  return res;
+}
+var isAbsolute = function(p) {
+  return _IS_ABSOLUTE_RE.test(p);
+};
+var _EXTNAME_RE = /.(\.[^./]+)$/;
+var extname = function(p) {
+  const match = _EXTNAME_RE.exec(normalizeWindowsPath(p));
+  return match && match[1] || "";
+};
+var relative = function(from, to) {
+  const _from = resolve(from).split("/");
+  const _to = resolve(to).split("/");
+  const _fromCopy = [..._from];
+  for (const segment of _fromCopy) {
+    if (_to[0] !== segment) {
+      break;
+    }
+    _from.shift();
+    _to.shift();
+  }
+  return [..._from.map(() => ".."), ..._to].join("/");
+};
+var dirname = function(p) {
+  const segments = normalizeWindowsPath(p).replace(/\/$/, "").split("/").slice(0, -1);
+  if (segments.length === 1 && _DRIVE_LETTER_RE.test(segments[0])) {
+    segments[0] += "/";
+  }
+  return segments.join("/") || (isAbsolute(p) ? "/" : ".");
+};
+var basename = function(p, extension) {
+  const lastSegment = normalizeWindowsPath(p).split("/").pop();
+  return extension && lastSegment.endsWith(extension) ? lastSegment.slice(0, -extension.length) : lastSegment;
+};
+
+// ../../node_modules/.pnpm/pathe@1.1.1/node_modules/pathe/dist/index.mjs
+init_cjs_shims();
+
+export {
+  normalize,
+  join,
+  resolve,
+  isAbsolute,
+  extname,
+  relative,
+  dirname,
+  basename
+};

package/dist/chunk-HCBGYFVF.js

@@ -0,0 +1,99 @@
+import {
+  platformAndArch
+} from "./chunk-VJ2TN2CW.js";
+import {
+  getPackageManager,
+  packageManagerFromUserAgent
+} from "./chunk-YJIQMGQH.js";
+import {
+  addPublicMetadata,
+  addSensitiveMetadata,
+  ciPlatform,
+  cloudEnvironment,
+  currentProcessIsGlobal,
+  macAddress
+} from "./chunk-TDBGZYDD.js";
+import {
+  cwd
+} from "./chunk-G6FN5VUE.js";
+import {
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// ../cli-kit/src/private/node/analytics.ts
+init_cjs_shims();
+
+// ../cli-kit/src/public/node/crypto.ts
+init_cjs_shims();
+import crypto from "crypto";
+function hashString(str) {
+  return crypto.createHash("sha1").update(str).digest("hex");
+}
+
+// ../cli-kit/src/private/node/analytics.ts
+async function startAnalytics({
+  commandContent,
+  args,
+  currentTime = (/* @__PURE__ */ new Date()).getTime(),
+  commandClass
+}) {
+  let startCommand = commandContent.command;
+  if (commandClass && Object.prototype.hasOwnProperty.call(commandClass, "analyticsNameOverride")) {
+    startCommand = commandClass.analyticsNameOverride() ?? commandContent.command;
+  }
+  await addSensitiveMetadata(() => ({
+    commandStartOptions: {
+      startTime: currentTime,
+      startCommand,
+      startArgs: args
+    }
+  }));
+  await addPublicMetadata(() => ({
+    cmd_all_launcher: packageManagerFromUserAgent(),
+    cmd_all_alias_used: commandContent.alias,
+    cmd_all_topic: commandContent.topic,
+    cmd_all_plugin: commandClass?.plugin?.name,
+    cmd_all_force: flagIncluded("force", commandClass) ? args.includes("--force") : void 0
+  }));
+}
+async function getEnvironmentData(config) {
+  const ciplatform = ciPlatform();
+  const pluginNames = getPluginNames(config);
+  const shopifyPlugins = pluginNames.filter((plugin) => plugin.startsWith("@shopify/"));
+  const { platform, arch } = platformAndArch();
+  return {
+    uname: `${platform} ${arch}`,
+    env_ci: ciplatform.isCI,
+    env_ci_platform: ciplatform.name,
+    env_plugin_installed_any_custom: pluginNames.length !== shopifyPlugins.length,
+    env_plugin_installed_shopify: JSON.stringify(shopifyPlugins),
+    env_shell: config.shell,
+    env_web_ide: cloudEnvironment().editor ? cloudEnvironment().platform : void 0,
+    env_device_id: hashString(await macAddress()),
+    env_cloud: cloudEnvironment().platform,
+    env_package_manager: await getPackageManager(cwd()),
+    env_is_global: currentProcessIsGlobal()
+  };
+}
+async function getSensitiveEnvironmentData(config) {
+  return {
+    env_plugin_installed_all: JSON.stringify(getPluginNames(config))
+  };
+}
+function getPluginNames(config) {
+  const pluginNames = [...config.plugins.keys()];
+  return pluginNames.sort().filter((plugin) => !plugin.startsWith("@oclif/"));
+}
+function flagIncluded(flag, commandClass) {
+  if (!commandClass)
+    return false;
+  const commandFlags = commandClass.flags ?? {};
+  return Object.keys(commandFlags).includes(flag);
+}
+
+export {
+  hashString,
+  startAnalytics,
+  getEnvironmentData,
+  getSensitiveEnvironmentData
+};

package/dist/chunk-IL6UMTVA.js

@@ -0,0 +1,62 @@
+import {
+  CLI_KIT_VERSION
+} from "./chunk-SSNXQGVF.js";
+import {
+  installNodeModules
+} from "./chunk-YJIQMGQH.js";
+import {
+  findPathUp
+} from "./chunk-TDBGZYDD.js";
+import {
+  moduleDirectory,
+  normalizePath
+} from "./chunk-G6FN5VUE.js";
+import {
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// src/utils/template/npm.ts
+init_cjs_shims();
+import { platform } from "os";
+async function updateCLIDependencies({
+  packageJSON,
+  local,
+  useGlobalCLI
+}) {
+  packageJSON.dependencies = packageJSON.dependencies || {};
+  if (useGlobalCLI) {
+    delete packageJSON.dependencies["@shopify/cli"];
+  } else {
+    packageJSON.dependencies["@shopify/cli"] = CLI_KIT_VERSION;
+  }
+  delete packageJSON.dependencies["@shopify/app"];
+  if (local) {
+    const cliPath = await packagePath("cli");
+    packageJSON.dependencies["@shopify/cli"] = cliPath;
+    const dependencyOverrides = {
+      "@shopify/cli": cliPath
+    };
+    packageJSON.overrides = packageJSON.overrides ? { ...packageJSON.overrides, ...dependencyOverrides } : dependencyOverrides;
+    packageJSON.resolutions = packageJSON.resolutions ? { ...packageJSON.resolutions, ...dependencyOverrides } : dependencyOverrides;
+  }
+  return packageJSON;
+}
+async function packagePath(packageName) {
+  const packageAbsolutePath = await findPathUp(`packages/${packageName}`, {
+    type: "directory",
+    cwd: moduleDirectory(import.meta.url)
+  });
+  return `file:${packageAbsolutePath}`;
+}
+async function getDeepInstallNPMTasks({
+  from,
+  packageManager
+}) {
+  const args = platform() === "win32" && packageManager === "yarn" ? ["--network-concurrency", "1"] : [];
+  return installNodeModules({ directory: normalizePath(from), packageManager, args });
+}
+
+export {
+  updateCLIDependencies,
+  getDeepInstallNPMTasks
+};

package/dist/chunk-LKGDG6WW.js

@@ -0,0 +1,87 @@
+import {
+  __commonJS,
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// ../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
+var require_wrappy = __commonJS({
+  "../../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports, module) {
+    init_cjs_shims();
+    module.exports = wrappy;
+    function wrappy(fn, cb) {
+      if (fn && cb)
+        return wrappy(fn)(cb);
+      if (typeof fn !== "function")
+        throw new TypeError("need wrapper function");
+      Object.keys(fn).forEach(function(k) {
+        wrapper[k] = fn[k];
+      });
+      return wrapper;
+      function wrapper() {
+        var args = new Array(arguments.length);
+        for (var i = 0; i < args.length; i++) {
+          args[i] = arguments[i];
+        }
+        var ret = fn.apply(this, args);
+        var cb2 = args[args.length - 1];
+        if (typeof ret === "function" && ret !== cb2) {
+          Object.keys(cb2).forEach(function(k) {
+            ret[k] = cb2[k];
+          });
+        }
+        return ret;
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
+var require_once = __commonJS({
+  "../../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports, module) {
+    init_cjs_shims();
+    var wrappy = require_wrappy();
+    module.exports = wrappy(once);
+    module.exports.strict = wrappy(onceStrict);
+    once.proto = once(function() {
+      Object.defineProperty(Function.prototype, "once", {
+        value: function() {
+          return once(this);
+        },
+        configurable: true
+      });
+      Object.defineProperty(Function.prototype, "onceStrict", {
+        value: function() {
+          return onceStrict(this);
+        },
+        configurable: true
+      });
+    });
+    function once(fn) {
+      var f = function() {
+        if (f.called)
+          return f.value;
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      f.called = false;
+      return f;
+    }
+    function onceStrict(fn) {
+      var f = function() {
+        if (f.called)
+          throw new Error(f.onceError);
+        f.called = true;
+        return f.value = fn.apply(this, arguments);
+      };
+      var name = fn.name || "Function wrapped with `once`";
+      f.onceError = name + " shouldn't be called more than once";
+      f.called = false;
+      return f;
+    }
+  }
+});
+
+export {
+  require_wrappy,
+  require_once
+};

package/dist/chunk-M63RTPGR.js

@@ -0,0 +1,63 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// ../../bin/bundling/cjs-shims.js
+import { createRequire } from "node:module";
+import path from "node:path";
+import url from "node:url";
+var init_cjs_shims = __esm({
+  "../../bin/bundling/cjs-shims.js"() {
+    "use strict";
+    globalThis.require = createRequire(import.meta.url);
+    globalThis.__filename = url.fileURLToPath(import.meta.url);
+    globalThis.__dirname = path.dirname(__filename);
+  }
+});
+
+export {
+  __require,
+  __esm,
+  __commonJS,
+  __export,
+  __toESM,
+  __toCommonJS,
+  init_cjs_shims
+};