@shopify/cli 3.69.4 → 3.71.0

package/dist/chunk-CPEFXM7T.js

@@ -1,45 +0,0 @@
-import {
-  demo
-} from "./chunk-FVUAIT37.js";
-import {
-  base_command_default
-} from "./chunk-KM4TMAQ2.js";
-import {
-  outputInfo,
-  readFile,
-  renderAutocompletePrompt
-} from "./chunk-2NCWYVM4.js";
-import {
-  joinPath
-} from "./chunk-T2GATXSP.js";
-import {
-  init_cjs_shims
-} from "./chunk-POZ5MGPT.js";
-
-// src/cli/commands/demo/catalog.ts
-init_cjs_shims();
-import { fileURLToPath } from "url";
-var Catalog = class extends base_command_default {
-  static {
-    this.description = "Browse the catalog for steps";
-  }
-  static {
-    this.hidden = !0;
-  }
-  async run() {
-    let catalogFile = joinPath(fileURLToPath(import.meta.url), "../../../../../assets/demo-catalog.json"), { steps } = JSON.parse(await readFile(catalogFile)), stepSelection = await renderAutocompletePrompt({
-      message: "Step to display",
-      choices: steps.map(({ title, type }) => ({
-        label: title,
-        value: title,
-        group: type
-      }))
-    }), selectedStep = steps.find(({ title }) => title === stepSelection);
-    outputInfo("The step looks like this:"), await demo({ steps: [selectedStep] }), outputInfo("JSON for this step:"), outputInfo(JSON.stringify(selectedStep, null, 2));
-  }
-};
-
-export {
-  Catalog
-};
-//# sourceMappingURL=chunk-CPEFXM7T.js.map

package/dist/chunk-FVUAIT37.js

@@ -1,312 +0,0 @@
-import {
-  z
-} from "./chunk-NLUGD7PZ.js";
-import {
-  AbortError,
-  BugError,
-  outputInfo,
-  renderAutocompletePrompt,
-  renderConcurrent,
-  renderConfirmationPrompt,
-  renderFatalError,
-  renderInfo,
-  renderSelectPrompt,
-  renderSuccess,
-  renderTable,
-  renderTasks,
-  renderTextPrompt,
-  renderWarning,
-  sleep
-} from "./chunk-2NCWYVM4.js";
-import {
-  init_cjs_shims
-} from "./chunk-POZ5MGPT.js";
-
-// src/cli/services/demo.ts
-init_cjs_shims();
-function oneOrMore(singular) {
-  return z.union([singular, z.array(singular)]);
-}
-var scalar = z.union([z.string(), z.number(), z.boolean(), z.null(), z.undefined()]), linkSchema = z.object({ label: z.string(), url: z.string() }), inlineTokenSchema = z.union([
-  z.string(),
-  z.object({ command: z.string() }),
-  z.object({ link: linkSchema }),
-  z.object({ char: z.string().length(1) }),
-  z.object({ userInput: z.string() }),
-  z.object({ subdued: z.string() }),
-  z.object({ filePath: z.string() }),
-  z.object({ bold: z.string() })
-]), headlineTokenSchema = oneOrMore(
-  z.union([
-    z.string(),
-    z.object({ command: z.string() }),
-    z.object({ char: z.string().length(1) }),
-    z.object({ userInput: z.string() }),
-    z.object({ subdued: z.string() }),
-    z.object({ filePath: z.string() })
-  ])
-), inlineTokenItemSchema = oneOrMore(inlineTokenSchema), listSchema = z.object({
-  list: z.object({
-    title: z.string().optional(),
-    items: z.array(inlineTokenItemSchema),
-    ordered: z.boolean().optional()
-  })
-}), tokenItemSchema = oneOrMore(z.union([inlineTokenSchema, listSchema])), tableSchema = z.object({
-  rows: z.array(z.object({}).catchall(scalar)),
-  columns: z.object({}).catchall(
-    z.object({
-      header: z.string().optional(),
-      color: z.string().optional()
-    })
-  )
-}), infoTableSchema = z.union([
-  z.object({}).catchall(z.array(inlineTokenItemSchema)),
-  z.array(
-    z.object({
-      color: z.string().optional(),
-      header: z.string(),
-      helperText: z.string().optional(),
-      bullet: z.string().optional(),
-      items: z.array(inlineTokenItemSchema)
-    })
-  )
-]), abstractDemoStepSchema = z.object({
-  type: z.string(),
-  properties: z.object({}),
-  // optional properties for documentation purposes
-  title: z.string().optional(),
-  description: z.string().optional()
-}), outputStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("output"),
-  properties: z.object({
-    content: z.string()
-  })
-}), renderStepPropertiesSchema = z.object({
-  headline: headlineTokenSchema.optional(),
-  body: tokenItemSchema.optional(),
-  nextSteps: z.array(inlineTokenItemSchema).optional(),
-  reference: z.array(inlineTokenItemSchema).optional(),
-  link: linkSchema.optional(),
-  customSections: z.array(
-    z.object({
-      title: z.string().optional(),
-      body: tokenItemSchema
-    })
-  ).optional(),
-  orderedNextSteps: z.boolean().optional()
-}), renderInfoStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("info"),
-  properties: renderStepPropertiesSchema
-}), renderSuccessStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("success"),
-  properties: renderStepPropertiesSchema
-}), renderWarningStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("warning"),
-  properties: renderStepPropertiesSchema
-}), renderFatalErrorStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("fatalError"),
-  properties: z.object({
-    errorType: z.union([z.literal("abort"), z.literal("bug")]),
-    message: z.string(),
-    tryMessage: z.string().optional(),
-    nextSteps: z.array(inlineTokenItemSchema).optional()
-  })
-}), renderTableStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("table"),
-  properties: tableSchema
-}), renderAutoCompletePromptStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("autocompletePrompt"),
-  properties: z.object({
-    message: z.string(),
-    choices: z.array(
-      z.object({
-        label: z.string(),
-        value: z.string()
-      })
-    )
-  })
-}), renderConfirmationPromptStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("confirmationPrompt"),
-  properties: z.object({
-    message: headlineTokenSchema,
-    infoTable: infoTableSchema.optional(),
-    defaultValue: z.boolean().optional(),
-    confirmationMessage: z.string(),
-    cancellationMessage: z.string()
-  })
-}), renderSelectPromptStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("selectPrompt"),
-  properties: z.object({
-    message: headlineTokenSchema,
-    choices: z.array(
-      z.object({
-        label: z.string(),
-        value: z.string(),
-        key: z.string().length(1).optional(),
-        group: z.string().optional(),
-        disabled: z.boolean().optional()
-      })
-    ),
-    defaultValue: z.string().optional(),
-    infoTable: infoTableSchema.optional()
-  })
-}), renderTextPromptStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("textPrompt"),
-  properties: z.object({
-    message: z.string(),
-    defaultValue: z.string().optional(),
-    password: z.boolean().optional(),
-    allowEmpty: z.boolean().optional()
-  })
-}), sleepStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("sleep"),
-  properties: z.object({
-    duration: z.number()
-  })
-}), taskbarStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("taskbar"),
-  properties: z.object({
-    steps: z.array(
-      z.object({
-        title: z.string(),
-        duration: z.number()
-      })
-    )
-  })
-}), renderConcurrentPropertiesSchema = z.object({
-  processes: z.array(
-    z.object({
-      prefix: z.string(),
-      steps: z.array(
-        z.object({
-          startMessage: z.string().optional(),
-          duration: z.number(),
-          endMessage: z.string().optional()
-        })
-      )
-    })
-  )
-}), renderConcurrentStepSchema = abstractDemoStepSchema.extend({
-  type: z.literal("concurrent"),
-  properties: renderConcurrentPropertiesSchema
-}), demoStepSchema = z.discriminatedUnion("type", [
-  outputStepSchema,
-  renderInfoStepSchema,
-  renderSuccessStepSchema,
-  renderWarningStepSchema,
-  renderTableStepSchema,
-  renderFatalErrorStepSchema,
-  renderAutoCompletePromptStepSchema,
-  renderConfirmationPromptStepSchema,
-  renderSelectPromptStepSchema,
-  renderTextPromptStepSchema,
-  sleepStepSchema,
-  taskbarStepSchema,
-  renderConcurrentStepSchema
-]), demoStepsSchema = z.object({
-  $schema: z.string().optional(),
-  command: z.string().optional(),
-  steps: z.array(demoStepSchema)
-});
-async function demo(stepsJsonData) {
-  let { steps, command } = demoStepsSchema.parse(stepsJsonData), executors = steps.map(executorForStep);
-  await simulateTyping(command);
-  for (let executor of executors)
-    await executor();
-}
-async function simulateTyping(text) {
-  if (!text)
-    return;
-  console.clear(), process.stdout.write("$ ");
-  let chars = text.split("");
-  for (; chars.length > 0; ) {
-    let char = chars.shift();
-    process.stdout.write(char), await sleep(0.1 + Math.random() / 10);
-  }
-  process.stdout.write(`
-`), await sleep(1 + Math.random() / 10);
-}
-function executorForStep(step) {
-  switch (step.type) {
-    case "output":
-      return async () => {
-        outputInfo(step.properties.content);
-      };
-    case "sleep":
-      return async () => {
-        await sleep(step.properties.duration);
-      };
-    case "taskbar":
-      return taskbarExecutor(step.properties.steps);
-    case "concurrent":
-      return concurrentExecutor(step.properties);
-    case "info":
-      return async () => {
-        renderInfo(step.properties);
-      };
-    case "success":
-      return async () => {
-        renderSuccess(step.properties);
-      };
-    case "warning":
-      return async () => {
-        renderWarning(step.properties);
-      };
-    case "fatalError":
-      return async () => {
-        let { errorType, message, nextSteps, tryMessage } = step.properties;
-        errorType === "abort" ? renderFatalError(new AbortError(message, tryMessage, nextSteps)) : renderFatalError(new BugError(message, tryMessage));
-      };
-    case "table":
-      return async () => {
-        renderTable(step.properties);
-      };
-    case "autocompletePrompt":
-      return async () => {
-        await renderAutocompletePrompt(step.properties);
-      };
-    case "confirmationPrompt":
-      return async () => {
-        await renderConfirmationPrompt(step.properties);
-      };
-    case "selectPrompt":
-      return async () => {
-        await renderSelectPrompt(step.properties);
-      };
-    case "textPrompt":
-      return async () => {
-        await renderTextPrompt(step.properties);
-      };
-    default:
-      throw new Error(`Unknown step type: ${step.type}`);
-  }
-}
-function taskbarExecutor(steps) {
-  return async () => {
-    let tasks = steps.map(({ title, duration }) => ({
-      title,
-      task: async () => sleep(duration)
-    }));
-    await renderTasks(tasks);
-  };
-}
-function concurrentExecutor({ processes }) {
-  return async () => {
-    let concurrentProcesses = processes.map(({ prefix, steps }) => ({
-      prefix,
-      action: async (stdout) => {
-        for (let step of steps) {
-          let { startMessage, duration, endMessage } = step;
-          startMessage && stdout.write(startMessage), await sleep(duration), endMessage && stdout.write(endMessage);
-        }
-      }
-    }));
-    await renderConcurrent({ processes: concurrentProcesses });
-  };
-}
-
-export {
-  demoStepsSchema,
-  demo
-};
-//# sourceMappingURL=chunk-FVUAIT37.js.map

package/dist/chunk-FWX3KCDM.js

@@ -1,116 +0,0 @@
-import {
-  require_zod_to_json_schema
-} from "./chunk-QSUS3GJF.js";
-import {
-  demoStepsSchema
-} from "./chunk-FVUAIT37.js";
-import {
-  base_command_default
-} from "./chunk-KM4TMAQ2.js";
-import {
-  AbortError,
-  fileExists,
-  mkdir,
-  outputContent,
-  outputSuccess,
-  outputToken,
-  readFile,
-  renderAutocompletePrompt,
-  writeFile
-} from "./chunk-2NCWYVM4.js";
-import {
-  require_lib
-} from "./chunk-27ILOE3X.js";
-import {
-  cwd,
-  joinPath,
-  resolvePath
-} from "./chunk-T2GATXSP.js";
-import {
-  __toESM,
-  init_cjs_shims
-} from "./chunk-POZ5MGPT.js";
-
-// src/cli/commands/demo/generate-file.ts
-init_cjs_shims();
-var import_zod_to_json_schema = __toESM(require_zod_to_json_schema(), 1), import_core = __toESM(require_lib(), 1);
-import { createRequire } from "module";
-var schemaFilename = "demo-schema.json", GenerateFile = class _GenerateFile extends base_command_default {
-  static {
-    this.description = "Create a command design file";
-  }
-  static {
-    this.summary = "Creates a JSON file alongside a JSON schema that will validate it";
-  }
-  static {
-    this.hidden = !0;
-  }
-  static {
-    this.flags = {
-      path: import_core.Flags.string({
-        hidden: !1,
-        description: "The directory for generating the demo file.",
-        env: "SHOPIFY_FLAG_PATH",
-        parse: async (input) => resolvePath(input),
-        default: async () => cwd()
-      }),
-      file: import_core.Flags.string({
-        hidden: !1,
-        description: "The name of the demo file.",
-        env: "SHOPIFY_FLAG_FILENAME",
-        required: !0,
-        validate: (input) => input === schemaFilename ? `The demo file can't be named ${schemaFilename}, as this is used for the schema file.` : !0
-      })
-    };
-  }
-  async run() {
-    let { flags } = await this.parse(_GenerateFile);
-    await mkdir(flags.path);
-    let demoFilePath = joinPath(flags.path, flags.file);
-    if (await fileExists(demoFilePath))
-      throw new AbortError(`The file ${demoFilePath} already exists.`);
-    let demoSchemaPath = joinPath(flags.path, schemaFilename), jsonSchema = import_zod_to_json_schema.default.default(demoStepsSchema, "demo-steps");
-    await Promise.all([
-      writeFile(demoSchemaPath, JSON.stringify(jsonSchema, null, 2)),
-      writeFile(
-        demoFilePath,
-        JSON.stringify(
-          {
-            $schema: `./${schemaFilename}`,
-            steps: await selectSteps()
-          },
-          null,
-          2
-        )
-      )
-    ]), outputSuccess(outputContent`Created ${outputToken.path(demoFilePath)} and ${outputToken.path(demoSchemaPath)}`);
-  }
-};
-async function selectSteps() {
-  let catalogFile = createRequire(import.meta.url).resolve("@shopify/cli/assets/demo-catalog.json"), { steps } = JSON.parse(await readFile(catalogFile)), selectedSteps = [];
-  for (; ; ) {
-    let stepSelection = await renderAutocompletePrompt({
-      message: "Add a step to the demo file",
-      choices: [
-        {
-          label: "I'm done",
-          value: "done"
-        },
-        ...steps.map(({ title, type }) => ({
-          label: title,
-          value: title,
-          group: type
-        }))
-      ]
-    });
-    if (stepSelection === "done")
-      break;
-    selectedSteps.push(steps.find(({ title }) => title === stepSelection));
-  }
-  return selectedSteps;
-}
-
-export {
-  GenerateFile
-};
-//# sourceMappingURL=chunk-FWX3KCDM.js.map

package/dist/chunk-FX2HB3CJ.js

@@ -1,58 +0,0 @@
-import {
-  require_zod_to_json_schema
-} from "./chunk-QSUS3GJF.js";
-import {
-  demoStepsSchema
-} from "./chunk-FVUAIT37.js";
-import {
-  base_command_default
-} from "./chunk-KM4TMAQ2.js";
-import {
-  outputInfo,
-  renderInfo
-} from "./chunk-2NCWYVM4.js";
-import {
-  __toESM,
-  init_cjs_shims
-} from "./chunk-POZ5MGPT.js";
-
-// src/cli/commands/demo/print-ai-prompt.ts
-init_cjs_shims();
-var import_zod_to_json_schema = __toESM(require_zod_to_json_schema(), 1);
-var PrintAIPrompt = class extends base_command_default {
-  static {
-    this.description = "Prints the prompts for a chat-enabled LLM to generate a demo";
-  }
-  static {
-    this.hidden = !0;
-  }
-  async run() {
-    let jsonSchema = import_zod_to_json_schema.default.default(demoStepsSchema, "demo-steps"), printable = JSON.stringify(jsonSchema);
-    renderInfo({ body: "Copy and paste the following into the system prompt." }), outputInfo(`You are creating a demo for a Shopify CLI command, using a strictly typed JSON file.
-The file defines the steps that will be executed during the demo.
-
-The JSON schema for this file is:
-\`\`\`json
-${printable}
-\`\`\`
-`), renderInfo({ body: "Then, fill out the following and paste it into the chat box." }), outputInfo(`Generate a human-readable JSON file which will be used to create the demo. The JSON file must be typed according to the JSON schema.
-
-The purpose of the command is: {A short description of the command.}
-
-The demo should perform the following steps:
-
-{
-  List the steps for the command, like:
-  1. Prompt for this
-  2. Autocomplete that
-}
-
-============================================================
-`);
-  }
-};
-
-export {
-  PrintAIPrompt
-};
-//# sourceMappingURL=chunk-FX2HB3CJ.js.map

package/dist/chunk-GYP4MV72.js

@@ -1,59 +0,0 @@
-import {
-  demo
-} from "./chunk-FVUAIT37.js";
-import {
-  base_command_default
-} from "./chunk-KM4TMAQ2.js";
-import {
-  readFile
-} from "./chunk-2NCWYVM4.js";
-import {
-  require_lib
-} from "./chunk-27ILOE3X.js";
-import {
-  cwd,
-  resolvePath
-} from "./chunk-T2GATXSP.js";
-import {
-  __toESM,
-  init_cjs_shims
-} from "./chunk-POZ5MGPT.js";
-
-// src/cli/commands/demo/index.ts
-init_cjs_shims();
-var import_core = __toESM(require_lib(), 1);
-var Demo = class _Demo extends base_command_default {
-  static {
-    this.description = "Demo a command design defined in a file";
-  }
-  static {
-    this.hidden = !0;
-  }
-  static {
-    this.flags = {
-      path: import_core.Flags.string({
-        hidden: !1,
-        description: "The directory where the demo file is located. Defaults to the current directory.",
-        env: "SHOPIFY_FLAG_PATH",
-        parse: async (input) => resolvePath(input),
-        default: async () => cwd()
-      }),
-      file: import_core.Flags.string({
-        hidden: !1,
-        description: "The name of the demo file.",
-        env: "SHOPIFY_FLAG_PATH",
-        parse: async (input) => resolvePath(input),
-        default: async () => cwd()
-      })
-    };
-  }
-  async run() {
-    let { flags } = await this.parse(_Demo), contents = await readFile(flags.file), design = JSON.parse(contents);
-    await demo(design);
-  }
-};
-
-export {
-  Demo
-};
-//# sourceMappingURL=chunk-GYP4MV72.js.map