@shopify/create-app 3.58.2 → 3.59.0

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-VMPTLMJN.js

@@ -0,0 +1,144 @@
+import {
+  generateRandomNameForSubdirectory,
+  installGlobalCLIPrompt,
+  renderSelectPrompt,
+  renderText,
+  renderTextPrompt
+} from "./chunk-WLJ2CNLG.js";
+import {
+  __export,
+  init_cjs_shims
+} from "./chunk-M63RTPGR.js";
+
+// src/prompts/init.ts
+var init_exports = {};
+__export(init_exports, {
+  default: () => init_default,
+  isPredefinedTemplate: () => isPredefinedTemplate,
+  templates: () => templates,
+  visibleTemplates: () => visibleTemplates
+});
+init_cjs_shims();
+var templates = {
+  remix: {
+    url: "https://github.com/Shopify/shopify-app-template-remix",
+    label: "Start with Remix (recommended)",
+    visible: true,
+    branches: {
+      prompt: "For your Remix template, which language do you want?",
+      options: {
+        javascript: { branch: "javascript", label: "JavaScript" },
+        typescript: { branch: "main", label: "TypeScript" }
+      }
+    }
+  },
+  none: {
+    url: "https://github.com/Shopify/shopify-app-template-none",
+    label: "Start by adding your first extension",
+    visible: true
+  },
+  node: {
+    url: "https://github.com/Shopify/shopify-app-template-node",
+    visible: false
+  },
+  php: {
+    url: "https://github.com/Shopify/shopify-app-template-php",
+    visible: false
+  },
+  ruby: {
+    url: "https://github.com/Shopify/shopify-app-template-ruby",
+    visible: false
+  }
+};
+var allTemplates = Object.keys(templates);
+var visibleTemplates = allTemplates.filter((key) => templates[key].visible);
+var templateOptionsInOrder = ["remix", "none"];
+var init = async (options) => {
+  let name = options.name;
+  let template = options.template;
+  const flavor = options.flavor;
+  const defaults = {
+    name: await generateRandomNameForSubdirectory({ suffix: "app", directory: options.directory }),
+    template: templates.remix.url
+  };
+  let welcomed = false;
+  if (!name) {
+    renderText({ text: "\nWelcome. Let\u2019s get started by naming your app project. You can change it later." });
+    welcomed = true;
+    name = await renderTextPrompt({
+      message: "Your project name?",
+      defaultValue: defaults.name,
+      validate: (value) => {
+        if (value.length === 0) {
+          return "App name can't be empty";
+        }
+        if (value.length > 30) {
+          return "Enter a shorter name (30 character max.)";
+        }
+        if (value.toLowerCase().includes("shopify")) {
+          return "App name can't include the word 'shopify'";
+        }
+      }
+    });
+  }
+  if (!template) {
+    if (!welcomed) {
+      renderText({ text: "\nWelcome. Let\u2019s get started by choosing a template for your app project." });
+      welcomed = true;
+    }
+    template = await renderSelectPrompt({
+      choices: templateOptionsInOrder.map((key) => {
+        return {
+          label: templates[key].label || key,
+          value: key
+        };
+      }),
+      message: "Get started building your app:",
+      defaultValue: allTemplates.find((key) => templates[key].url === defaults.template)
+    });
+  }
+  const answers = {
+    ...options,
+    name,
+    template,
+    templateType: isPredefinedTemplate(template) ? template : "custom",
+    globalCLIResult: { install: false, alreadyInstalled: false }
+  };
+  let selectedUrl;
+  let branch;
+  if (answers.templateType !== "custom") {
+    const selectedTemplate = templates[answers.templateType];
+    selectedUrl = selectedTemplate.url;
+    if (selectedTemplate.branches) {
+      if (flavor) {
+        branch = selectedTemplate.branches.options[flavor]?.branch;
+      } else {
+        branch = await renderSelectPrompt({
+          message: selectedTemplate.branches.prompt || "Choose a flavor:",
+          choices: Object.entries(selectedTemplate.branches.options).map(([_key, branch2]) => ({
+            value: branch2.branch,
+            label: branch2.label
+          }))
+        });
+      }
+    }
+  }
+  if (branch) {
+    selectedUrl += `#${branch}`;
+  }
+  answers.template = selectedUrl || answers.template || defaults.template;
+  answers.globalCLIResult = await installGlobalCLIPrompt();
+  return answers;
+};
+var init_default = init;
+function isPredefinedTemplate(template) {
+  return allTemplates.includes(template);
+}
+
+export {
+  templates,
+  visibleTemplates,
+  init_default,
+  isPredefinedTemplate,
+  init_exports
+};

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
+};