shop-cli 0.1.1

package/dist/cli/selection/graphqlSelection.js

@@ -0,0 +1,301 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var graphqlSelection_exports = {};
+__export(graphqlSelection_exports, {
+  parseGraphqlSelectionArg: () => parseGraphqlSelectionArg
+});
+module.exports = __toCommonJS(graphqlSelection_exports);
+var import_node_fs = require("node:fs");
+var import_errors = require("../errors");
+const isNameStart = (ch) => /[A-Za-z_]/.test(ch);
+const isNameContinue = (ch) => /[0-9A-Za-z_]/.test(ch);
+const readSelectionSource = (arg) => {
+  if (arg.startsWith("@file:")) return (0, import_node_fs.readFileSync)(arg.slice("@file:".length), "utf8");
+  if (arg.startsWith("@")) return (0, import_node_fs.readFileSync)(arg.slice(1), "utf8");
+  return arg;
+};
+const tokenize = (src) => {
+  const tokens = [];
+  let i = 0;
+  const peek = () => src[i];
+  const next = () => src[i++];
+  const skipWhitespaceAndComments = () => {
+    while (i < src.length) {
+      const ch = peek();
+      if (!ch) return;
+      if (/\s/.test(ch)) {
+        i++;
+        continue;
+      }
+      if (ch === ",") {
+        tokens.push({ type: "punct", value: "," });
+        i++;
+        continue;
+      }
+      if (ch === "#") {
+        while (i < src.length && src[i] !== "\n") i++;
+        continue;
+      }
+      return;
+    }
+  };
+  const readName = () => {
+    const start = i;
+    i++;
+    while (i < src.length && isNameContinue(src[i])) i++;
+    return src.slice(start, i);
+  };
+  const readString = () => {
+    const quote = next();
+    if (quote !== '"') throw new import_errors.CliError("Internal error: expected quote", 2);
+    let out = "";
+    while (i < src.length) {
+      const ch = next();
+      if (!ch) break;
+      if (ch === '"') return out;
+      if (ch === "\\") {
+        const esc = next();
+        if (!esc) throw new import_errors.CliError("Unterminated string literal", 2);
+        if (esc === '"' || esc === "\\" || esc === "/") out += esc;
+        else if (esc === "b") out += "\b";
+        else if (esc === "f") out += "\f";
+        else if (esc === "n") out += "\n";
+        else if (esc === "r") out += "\r";
+        else if (esc === "t") out += "	";
+        else if (esc === "u") {
+          const hex = src.slice(i, i + 4);
+          if (!/^[0-9A-Fa-f]{4}$/.test(hex)) throw new import_errors.CliError("Invalid unicode escape", 2);
+          out += String.fromCharCode(parseInt(hex, 16));
+          i += 4;
+        } else {
+          throw new import_errors.CliError(`Invalid escape sequence: \\${esc}`, 2);
+        }
+        continue;
+      }
+      out += ch;
+    }
+    throw new import_errors.CliError("Unterminated string literal", 2);
+  };
+  const readNumber = () => {
+    const start = i;
+    if (src[i] === "-") i++;
+    while (i < src.length && /[0-9]/.test(src[i])) i++;
+    if (src[i] === ".") {
+      i++;
+      while (i < src.length && /[0-9]/.test(src[i])) i++;
+    }
+    const raw = src.slice(start, i);
+    const n = Number(raw);
+    if (!Number.isFinite(n)) throw new import_errors.CliError(`Invalid number literal: ${raw}`, 2);
+    return n;
+  };
+  while (i < src.length) {
+    skipWhitespaceAndComments();
+    if (i >= src.length) break;
+    const ch = peek();
+    if (ch === "." && src.slice(i, i + 3) === "...") {
+      i += 3;
+      tokens.push({ type: "spread" });
+      continue;
+    }
+    if (ch === '"') {
+      tokens.push({ type: "string", value: readString() });
+      continue;
+    }
+    if (ch === "-" || /[0-9]/.test(ch)) {
+      tokens.push({ type: "number", value: readNumber() });
+      continue;
+    }
+    if (isNameStart(ch)) {
+      tokens.push({ type: "name", value: readName() });
+      continue;
+    }
+    if (ch === "{" || ch === "}" || ch === "(" || ch === ")" || ch === ":" || ch === "[" || ch === "]") {
+      i++;
+      tokens.push({ type: "punct", value: ch });
+      continue;
+    }
+    throw new import_errors.CliError(`Unexpected character in --selection: ${ch}`, 2);
+  }
+  return tokens.filter((t) => !(t.type === "punct" && t.value === ","));
+};
+const parserPeek = (p) => p.tokens[p.i];
+const parserNext = (p) => p.tokens[p.i++];
+const expectName = (p) => {
+  const tok = parserNext(p);
+  if (!tok || tok.type !== "name") throw new import_errors.CliError("Invalid --selection: expected name", 2);
+  return tok.value;
+};
+const expectPunct = (p, value) => {
+  const tok = parserNext(p);
+  if (!tok || tok.type !== "punct") throw new import_errors.CliError("Invalid --selection: expected punctuation", 2);
+  if (value && tok.value !== value) throw new import_errors.CliError(`Invalid --selection: expected '${value}'`, 2);
+  return tok.value;
+};
+const expectSpread = (p) => {
+  const tok = parserNext(p);
+  if (!tok || tok.type !== "spread") throw new import_errors.CliError("Invalid --selection: expected ...", 2);
+};
+const tryConsumePunct = (p, value) => {
+  const tok = parserPeek(p);
+  if (tok?.type === "punct" && tok.value === value) {
+    p.i++;
+    return true;
+  }
+  return false;
+};
+const parseValue = (p) => {
+  const tok = parserPeek(p);
+  if (!tok) throw new import_errors.CliError("Invalid --selection: expected value", 2);
+  if (tok.type === "string") {
+    p.i++;
+    return tok.value;
+  }
+  if (tok.type === "number") {
+    p.i++;
+    return tok.value;
+  }
+  if (tok.type === "name") {
+    p.i++;
+    if (tok.value === "true") return true;
+    if (tok.value === "false") return false;
+    if (tok.value === "null") return null;
+    return tok.value;
+  }
+  if (tok.type === "punct" && tok.value === "[") {
+    p.i++;
+    const items = [];
+    while (!tryConsumePunct(p, "]")) {
+      items.push(parseValue(p));
+      tryConsumePunct(p, ",");
+    }
+    return items;
+  }
+  if (tok.type === "punct" && tok.value === "{") {
+    p.i++;
+    const obj = {};
+    while (!tryConsumePunct(p, "}")) {
+      const key = expectName(p);
+      expectPunct(p, ":");
+      obj[key] = parseValue(p);
+      tryConsumePunct(p, ",");
+    }
+    return obj;
+  }
+  throw new import_errors.CliError("Invalid --selection: unsupported value", 2);
+};
+const mergeSelectionValue = (current, next) => {
+  if (current === void 0) return next;
+  if (current === true) return next;
+  if (next === true) return current;
+  const merged = { ...current };
+  if (current.__args || next.__args) {
+    merged.__args = { ...current.__args ?? {}, ...next.__args ?? {} };
+  }
+  for (const [k, v] of Object.entries(next)) {
+    if (k === "__args") continue;
+    merged[k] = mergeSelectionValue(merged[k], v);
+  }
+  return merged;
+};
+const parseArguments = (p) => {
+  const args = {};
+  expectPunct(p, "(");
+  while (!tryConsumePunct(p, ")")) {
+    const name = expectName(p);
+    expectPunct(p, ":");
+    args[name] = parseValue(p);
+    tryConsumePunct(p, ",");
+  }
+  return args;
+};
+const parseSelectionSet = (p) => {
+  const out = {};
+  if (tryConsumePunct(p, "{")) {
+    while (!tryConsumePunct(p, "}")) {
+      const selection = parseSelection(p);
+      for (const [k, v] of Object.entries(selection)) {
+        out[k] = mergeSelectionValue(out[k], v);
+      }
+    }
+    return out;
+  }
+  while (p.i < p.tokens.length) {
+    const selection = parseSelection(p);
+    for (const [k, v] of Object.entries(selection)) {
+      out[k] = mergeSelectionValue(out[k], v);
+    }
+  }
+  return out;
+};
+const parseField = (p) => {
+  const firstName = expectName(p);
+  let fieldName = firstName;
+  if (tryConsumePunct(p, ":")) {
+    fieldName = expectName(p);
+  }
+  const tok = parserPeek(p);
+  const hasArgs = tok?.type === "punct" && tok.value === "(";
+  const args = hasArgs ? parseArguments(p) : void 0;
+  const nextTok = parserPeek(p);
+  const hasSelectionSet = nextTok?.type === "punct" && nextTok.value === "{";
+  if (args && !hasSelectionSet) {
+    throw new import_errors.CliError(
+      `Invalid --selection: field '${fieldName}' has arguments but no sub-selection`,
+      2
+    );
+  }
+  const selection = hasSelectionSet ? parseSelectionSet(p) : true;
+  const value = args ? { __args: args, ...selection === true ? {} : selection } : selection;
+  return { [fieldName]: value };
+};
+const parseInlineFragment = (p) => {
+  expectSpread(p);
+  const on = expectName(p);
+  if (on !== "on") throw new import_errors.CliError('Invalid --selection: expected "on" after ...', 2);
+  const typeName = expectName(p);
+  const selection = parseSelectionSet(p);
+  return { [`on_${typeName}`]: selection };
+};
+const parseSelection = (p) => {
+  const tok = parserPeek(p);
+  if (!tok) throw new import_errors.CliError("Invalid --selection: unexpected end", 2);
+  if (tok.type === "spread") return parseInlineFragment(p);
+  if (tok.type === "name") return parseField(p);
+  throw new import_errors.CliError("Invalid --selection: expected field selection", 2);
+};
+const parseGraphqlSelectionArg = (arg) => {
+  const src = readSelectionSource(arg).trim();
+  if (!src) throw new import_errors.CliError("Invalid --selection: empty", 2);
+  const tokens = tokenize(src);
+  const p = { tokens, i: 0 };
+  const selection = parseSelectionSet(p);
+  if (p.i !== p.tokens.length) {
+    throw new import_errors.CliError("Invalid --selection: trailing tokens", 2);
+  }
+  if (Object.keys(selection).length === 0) {
+    throw new import_errors.CliError("Invalid --selection: selection set is empty", 2);
+  }
+  return selection;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseGraphqlSelectionArg
+});
+//# sourceMappingURL=graphqlSelection.js.map

package/dist/cli/selection/select.d.ts

@@ -0,0 +1,13 @@
+import type { CliView } from '../router';
+import { type GenqlSelection } from './graphqlSelection';
+export declare const resolveSelection: ({ resource, typeName, view, baseSelection, select, selection, include, ensureId, defaultConnectionFirst, }: {
+    resource?: string;
+    typeName?: string;
+    view: CliView;
+    baseSelection: GenqlSelection;
+    select: unknown;
+    selection: unknown;
+    include?: unknown;
+    ensureId: boolean;
+    defaultConnectionFirst?: number;
+}) => GenqlSelection;

package/dist/cli/selection/select.js

@@ -0,0 +1,136 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var select_exports = {};
+__export(select_exports, {
+  resolveSelection: () => resolveSelection
+});
+module.exports = __toCommonJS(select_exports);
+var import_errors = require("../errors");
+var import_graphqlSelection = require("./graphqlSelection");
+var import_buildAllSelection = require("./buildAllSelection");
+var import_introspection = require("../introspection");
+var import_stripDeprecated = require("./stripDeprecated");
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const assertValidDotPath = (path) => {
+  const parts = path.split(".").filter(Boolean);
+  if (parts.length === 0) throw new import_errors.CliError(`Invalid --select path: ${path}`, 2);
+  for (const part of parts) {
+    if (!/^[_A-Za-z][_0-9A-Za-z]*$/.test(part)) {
+      throw new import_errors.CliError(`Invalid --select path segment: ${part}`, 2);
+    }
+  }
+  return parts;
+};
+const deepCloneSelection = (selection) => JSON.parse(JSON.stringify(selection));
+const hasAnyFields = (selection) => Object.keys(selection).filter((k) => k !== "__args").length > 0;
+const ensureIdSelected = (selection) => {
+  if (!("id" in selection)) selection.id = true;
+  return selection;
+};
+const mergeDotPath = ({
+  selection,
+  path,
+  defaultConnectionFirst
+}) => {
+  const parts = assertValidDotPath(path);
+  let cursor = selection;
+  for (let i = 0; i < parts.length; i++) {
+    const key = parts[i];
+    const isLeaf = i === parts.length - 1;
+    const nextKey = parts[i + 1];
+    const selectingConnectionChildren = nextKey === "nodes" || nextKey === "edges";
+    if (isLeaf) {
+      const existing2 = cursor[key];
+      if (existing2 === void 0) {
+        cursor[key] = true;
+      } else if (existing2 === true) {
+      } else if (isPlainObject(existing2)) {
+      } else {
+        cursor[key] = true;
+      }
+      return;
+    }
+    const existing = cursor[key];
+    if (existing === true) {
+      throw new import_errors.CliError(`Invalid --select: cannot select nested fields under '${parts.slice(0, i + 1).join(".")}'`, 2);
+    }
+    if (!isPlainObject(existing)) {
+      cursor[key] = {};
+    }
+    const obj = cursor[key];
+    if (selectingConnectionChildren) {
+      if (!obj.__args) obj.__args = { first: defaultConnectionFirst };
+      if (!obj.pageInfo) obj.pageInfo = { hasNextPage: true, endCursor: true };
+    }
+    cursor = obj;
+  }
+};
+const resolveSelection = ({
+  resource,
+  typeName,
+  view,
+  baseSelection,
+  select,
+  selection,
+  include,
+  ensureId,
+  defaultConnectionFirst = 10
+}) => {
+  const override = typeof selection === "string" && selection.length > 0 ? (0, import_graphqlSelection.parseGraphqlSelectionArg)(selection) : void 0;
+  const selectPaths = Array.isArray(select) ? select : select === void 0 ? [] : [select];
+  for (const p of selectPaths) {
+    if (typeof p !== "string") throw new import_errors.CliError("--select must be a string (repeatable)", 2);
+  }
+  const includeValues = Array.isArray(include) ? include : include === void 0 ? [] : [include];
+  for (const v of includeValues) {
+    if (typeof v !== "string") throw new import_errors.CliError("--include must be a string (repeatable)", 2);
+  }
+  const includes = Array.from(new Set(includeValues));
+  const resolvedTypeName = typeName ?? (resource ? import_introspection.resourceToType[resource] : void 0);
+  const mergedBase = (() => {
+    if (view === "raw") return {};
+    if (view === "all") {
+      if (!resolvedTypeName) {
+        const suffix = resource ? ` for resource: ${resource}` : "";
+        throw new import_errors.CliError(`--view all is not supported${suffix}`, 2);
+      }
+      if (includes.length) (0, import_buildAllSelection.validateIncludes)(resolvedTypeName, includes);
+      return (0, import_buildAllSelection.buildAllSelection)(resolvedTypeName, includes, 0, 2, /* @__PURE__ */ new Set(), defaultConnectionFirst);
+    }
+    return deepCloneSelection(baseSelection);
+  })();
+  const baseForBuiltInViews = !override && resolvedTypeName && view !== "raw" ? (0, import_stripDeprecated.stripDeprecatedFromSelection)(resolvedTypeName, mergedBase) : mergedBase;
+  let out = override ? deepCloneSelection(override) : baseForBuiltInViews;
+  for (const p of selectPaths) {
+    mergeDotPath({ selection: out, path: p, defaultConnectionFirst });
+  }
+  if (ensureId) ensureIdSelected(out);
+  if (!hasAnyFields(out)) {
+    if (view === "raw") {
+      throw new import_errors.CliError("--view raw requires --select and/or --selection", 2);
+    }
+    throw new import_errors.CliError("Selection set is empty", 2);
+  }
+  return out;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveSelection
+});
+//# sourceMappingURL=select.js.map

package/dist/cli/selection/stripDeprecated.d.ts

@@ -0,0 +1,2 @@
+import type { GenqlSelection } from './graphqlSelection';
+export declare const stripDeprecatedFromSelection: (typeName: string, selection: GenqlSelection) => GenqlSelection;

package/dist/cli/selection/stripDeprecated.js

@@ -0,0 +1,63 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stripDeprecated_exports = {};
+__export(stripDeprecated_exports, {
+  stripDeprecatedFromSelection: () => stripDeprecatedFromSelection
+});
+module.exports = __toCommonJS(stripDeprecated_exports);
+var import_introspection = require("../introspection");
+var import_deprecations = require("../introspection/deprecations");
+const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const stripDeprecatedInner = (typeName, selection) => {
+  const fields = (0, import_introspection.getFields)(typeName);
+  const fieldMap = new Map(fields.map((f) => [f.name, f]));
+  for (const key of Object.keys(selection)) {
+    if (key === "__args") continue;
+    if ((0, import_deprecations.isDeprecatedField)(typeName, key)) {
+      delete selection[key];
+      continue;
+    }
+    const value = selection[key];
+    if (!isPlainObject(value)) continue;
+    const info = fieldMap.get(key);
+    if (!info) continue;
+    if (info.isConnection) {
+      const nodeType = info.connectionNodeTypeName;
+      if (!nodeType) continue;
+      const nodes = value.nodes;
+      if (isPlainObject(nodes)) stripDeprecatedInner(nodeType, nodes);
+      const edges = value.edges;
+      const node = isPlainObject(edges) ? edges.node : void 0;
+      if (isPlainObject(node)) stripDeprecatedInner(nodeType, node);
+      continue;
+    }
+    if (!info.isScalar) {
+      stripDeprecatedInner(info.typeName, value);
+    }
+  }
+};
+const stripDeprecatedFromSelection = (typeName, selection) => {
+  stripDeprecatedInner(typeName, selection);
+  return selection;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stripDeprecatedFromSelection
+});
+//# sourceMappingURL=stripDeprecated.js.map

package/dist/cli/suggest.d.ts

@@ -0,0 +1,5 @@
+export declare const findSuggestions: ({ query, candidates, limit, }: {
+    query: string;
+    candidates: string[];
+    limit?: number;
+}) => string[];

package/dist/cli/suggest.js

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var suggest_exports = {};
+__export(suggest_exports, {
+  findSuggestions: () => findSuggestions
+});
+module.exports = __toCommonJS(suggest_exports);
+const fuzzyMatch = (needle, haystack) => {
+  const lowerNeedle = needle.toLowerCase();
+  const lowerHaystack = haystack.toLowerCase();
+  let ni = 0;
+  for (let hi = 0; hi < lowerHaystack.length && ni < lowerNeedle.length; hi++) {
+    if (lowerHaystack[hi] === lowerNeedle[ni]) ni++;
+  }
+  return ni === lowerNeedle.length;
+};
+const levenshteinDistance = (a, b, maxDistance = 3) => {
+  if (a === b) return 0;
+  if (a.length === 0) return b.length;
+  if (b.length === 0) return a.length;
+  if (Math.abs(a.length - b.length) > maxDistance) return maxDistance + 1;
+  const v0 = new Array(b.length + 1);
+  const v1 = new Array(b.length + 1);
+  for (let i = 0; i <= b.length; i++) v0[i] = i;
+  for (let i = 0; i < a.length; i++) {
+    v1[0] = i + 1;
+    let bestInRow = v1[0];
+    for (let j = 0; j < b.length; j++) {
+      const cost = a[i] === b[j] ? 0 : 1;
+      v1[j + 1] = Math.min(
+        v1[j] + 1,
+        // insertion
+        v0[j + 1] + 1,
+        // deletion
+        v0[j] + cost
+        // substitution
+      );
+      if (v1[j + 1] < bestInRow) bestInRow = v1[j + 1];
+    }
+    if (bestInRow > maxDistance) return maxDistance + 1;
+    for (let j = 0; j <= b.length; j++) v0[j] = v1[j];
+  }
+  return v1[b.length];
+};
+const scoreMatch = (query, candidate) => {
+  const q = query.toLowerCase();
+  const c = candidate.toLowerCase();
+  if (c === q) return 0;
+  if (c === `${q}s` || c === `${q}es`) return 1;
+  if (c.startsWith(q)) return 2;
+  if (q.startsWith(c)) return 3;
+  if (c.includes(q)) return 4;
+  if (q.includes(c)) return 5;
+  const dist = levenshteinDistance(q, c, 3);
+  if (dist <= 3) return 10 + dist;
+  if (fuzzyMatch(query, candidate)) return 20;
+  if (fuzzyMatch(candidate, query)) return 21;
+  return Infinity;
+};
+const findSuggestions = ({
+  query,
+  candidates,
+  limit = 3
+}) => {
+  const scored = candidates.map((name) => ({ name, score: scoreMatch(query, name) })).filter(({ score }) => score < Infinity).sort((a, b) => a.score - b.score || a.name.localeCompare(b.name)).slice(0, limit);
+  return scored.map(({ name }) => name);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  findSuggestions
+});
+//# sourceMappingURL=suggest.js.map

package/dist/cli/userErrors.d.ts

@@ -0,0 +1,4 @@
+export declare const maybeFailOnUserErrors: ({ payload, failOnUserErrors, }: {
+    payload: any;
+    failOnUserErrors: boolean;
+}) => void;

package/dist/cli/userErrors.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var userErrors_exports = {};
+__export(userErrors_exports, {
+  maybeFailOnUserErrors: () => maybeFailOnUserErrors
+});
+module.exports = __toCommonJS(userErrors_exports);
+var import_errors = require("./errors");
+var import_output = require("./output");
+const maybeFailOnUserErrors = ({
+  payload,
+  failOnUserErrors
+}) => {
+  const userErrors = payload?.userErrors;
+  if (!Array.isArray(userErrors) || userErrors.length === 0) return;
+  (0, import_output.printJsonError)({ userErrors });
+  if (failOnUserErrors) {
+    throw new import_errors.CliError("Shopify returned userErrors", 2);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  maybeFailOnUserErrors
+});
+//# sourceMappingURL=userErrors.js.map