@shopify/create-app 3.58.2 → 3.59.1

package/dist/chunk-UVY6LL5H.js

@@ -0,0 +1,145 @@
+import {
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// ../cli-kit/src/public/node/context/utilities.ts
+init_cjs_shims();
+function isTruthy(variable) {
+  if (!variable) {
+    return false;
+  }
+  return ["1", "true", "TRUE", "yes", "YES"].includes(variable);
+}
+
+// ../cli-kit/src/private/node/demo-recorder.ts
+init_cjs_shims();
+var DemoRecorder = class {
+  constructor() {
+    this.recorded = [];
+    this.sleepStart = Date.now();
+    this.command = ["shopify", ...process.argv.slice(2)].join(" ");
+  }
+  addEvent({ type, properties }) {
+    if (type === "taskbar") {
+      this.resetSleep();
+    } else {
+      this.addSleep();
+    }
+    this.recorded.push({ type, properties: JSON.parse(JSON.stringify(properties)) });
+    this.sleepStart = Date.now();
+  }
+  recordedEventsJson() {
+    return JSON.stringify(
+      {
+        command: this.command,
+        steps: this.withFormattedConcurrent(this.recorded)
+      },
+      null,
+      2
+    );
+  }
+  addSleep() {
+    const duration = (Date.now() - this.sleepStart) / 1e3;
+    this.sleepStart = Date.now();
+    if (duration > 0.1) {
+      this.recorded.push({ type: "sleep", properties: { duration } });
+    }
+  }
+  resetSleep() {
+    this.sleepStart = Date.now();
+  }
+  addOrUpdateConcurrentOutput({ prefix, index, output }) {
+    let last = this.recorded[this.recorded.length - 1];
+    if (last?.type === "concurrent") {
+      this.resetSleep();
+    } else {
+      const eventProperties = {
+        type: "concurrent",
+        properties: { processes: [], concurrencyStart: Date.now() }
+      };
+      this.addEvent(eventProperties);
+      last = this.recorded[this.recorded.length - 1];
+    }
+    const { processes } = last.properties;
+    while (processes.length <= index) {
+      processes.push({ prefix: "", steps: [] });
+    }
+    processes[index].prefix = prefix;
+    processes[index].steps.push({ timestamp: Date.now(), endMessage: output });
+  }
+  withFormattedConcurrent(recorded) {
+    return recorded.map((event) => {
+      if (event.type === "concurrent") {
+        const { processes, footer, concurrencyStart } = event.properties;
+        const formatted = processes.map(({ prefix, steps }) => {
+          let mostRecentTimestamp = concurrencyStart;
+          const formattedSteps = steps.map(({ timestamp, endMessage }) => {
+            const duration = (timestamp - mostRecentTimestamp) / 1e3;
+            mostRecentTimestamp = timestamp;
+            return { duration, endMessage };
+          });
+          return { prefix, steps: formattedSteps };
+        });
+        return { type: "concurrent", properties: { footer, processes: formatted } };
+      }
+      return event;
+    });
+  }
+};
+var NoopDemoRecorder = class {
+  addEvent(_event) {
+  }
+  recordedEventsJson() {
+    return JSON.stringify({ steps: [] }, null, 2);
+  }
+  addSleep() {
+  }
+  resetSleep() {
+  }
+  addOrUpdateConcurrentOutput(..._args) {
+  }
+};
+var _instance;
+function ensureInstance() {
+  if (!_instance) {
+    if (isRecording()) {
+      _instance = new DemoRecorder();
+    } else {
+      _instance = new NoopDemoRecorder();
+    }
+  }
+}
+function initDemoRecorder() {
+  ensureInstance();
+}
+function recordUIEvent(event) {
+  ensureInstance();
+  _instance.addEvent(event);
+}
+function resetRecordedSleep() {
+  ensureInstance();
+  _instance.resetSleep();
+}
+function printEventsJson() {
+  if (isRecording()) {
+    ensureInstance();
+    _instance.addSleep();
+    console.log(_instance.recordedEventsJson());
+  }
+}
+function addOrUpdateConcurrentUIEventOutput(data) {
+  ensureInstance();
+  _instance.addOrUpdateConcurrentOutput(data);
+}
+function isRecording() {
+  return isTruthy(process.env.RECORD_DEMO);
+}
+
+export {
+  isTruthy,
+  initDemoRecorder,
+  recordUIEvent,
+  resetRecordedSleep,
+  printEventsJson,
+  addOrUpdateConcurrentUIEventOutput
+};

package/dist/chunk-VJ2TN2CW.js

@@ -0,0 +1,72 @@
+import {
+  execa,
+  outputContent,
+  outputDebug
+} from "./chunk-TDBGZYDD.js";
+import {
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// ../cli-kit/src/public/node/os.ts
+init_cjs_shims();
+import { userInfo as osUserInfo } from "os";
+async function username(platform = process.platform) {
+  outputDebug(outputContent`Obtaining user name...`);
+  const environmentVariable = getEnvironmentVariable();
+  if (environmentVariable) {
+    return environmentVariable;
+  }
+  const userInfoUsername = getUsernameFromOsUserInfo();
+  if (userInfoUsername) {
+    return userInfoUsername;
+  }
+  try {
+    if (platform === "win32") {
+      const { stdout } = await execa("whoami");
+      return cleanWindowsCommand(stdout);
+    }
+    const { stdout: userId } = await execa("id", ["-u"]);
+    try {
+      const { stdout } = await execa("id", ["-un", userId]);
+      return stdout;
+    } catch {
+    }
+    return makeUsernameFromId(userId);
+  } catch {
+    return null;
+  }
+}
+function platformAndArch(platform = process.platform, arch = process.arch) {
+  let archString;
+  if (arch === "x64") {
+    archString = "amd64";
+  } else if (arch === "ia32") {
+    archString = "386";
+  } else {
+    archString = arch;
+  }
+  const platformString = platform.match(/^win.+/) ? "windows" : platform;
+  return { platform: platformString, arch: archString };
+}
+function getEnvironmentVariable() {
+  const { env } = process;
+  return env.SUDO_USER || env.C9_USER || env.LOGNAME || env.USER || env.LNAME || env.USERNAME;
+}
+function getUsernameFromOsUserInfo() {
+  try {
+    return osUserInfo().username;
+  } catch {
+    return null;
+  }
+}
+function cleanWindowsCommand(value) {
+  return value.replace(/^.*\\/, "");
+}
+function makeUsernameFromId(userId) {
+  return `no-username-${userId}`;
+}
+
+export {
+  username,
+  platformAndArch
+};

package/dist/chunk-WCNR75S2.js

@@ -0,0 +1,73 @@
+import {
+  __commonJS,
+  __require,
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// ../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js
+var require_is_docker = __commonJS({
+  "../../node_modules/.pnpm/is-docker@2.2.1/node_modules/is-docker/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var fs = __require("fs");
+    var isDocker;
+    function hasDockerEnv() {
+      try {
+        fs.statSync("/.dockerenv");
+        return true;
+      } catch (_) {
+        return false;
+      }
+    }
+    function hasDockerCGroup() {
+      try {
+        return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+      } catch (_) {
+        return false;
+      }
+    }
+    module.exports = () => {
+      if (isDocker === void 0) {
+        isDocker = hasDockerEnv() || hasDockerCGroup();
+      }
+      return isDocker;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js
+var require_is_wsl = __commonJS({
+  "../../node_modules/.pnpm/is-wsl@2.2.0/node_modules/is-wsl/index.js"(exports, module) {
+    "use strict";
+    init_cjs_shims();
+    var os = __require("os");
+    var fs = __require("fs");
+    var isDocker = require_is_docker();
+    var isWsl = () => {
+      if (process.platform !== "linux") {
+        return false;
+      }
+      if (os.release().toLowerCase().includes("microsoft")) {
+        if (isDocker()) {
+          return false;
+        }
+        return true;
+      }
+      try {
+        return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft") ? !isDocker() : false;
+      } catch (_) {
+        return false;
+      }
+    };
+    if (process.env.__IS_WSL_TEST__) {
+      module.exports = isWsl;
+    } else {
+      module.exports = isWsl();
+    }
+  }
+});
+
+export {
+  require_is_docker,
+  require_is_wsl
+};