@koda-sl/baker-cli 0.513.0 → 0.515.0

package/dist/chunk-LQ2BRGMX.js

@@ -0,0 +1,274 @@
+import {
+  chatgptDraftOpInputSchema,
+  chatgptFailure
+} from "./chunk-GGK2CX6B.js";
+import {
+  writeJsonEnvelope
+} from "./chunk-6DPSWLGY.js";
+import {
+  ApiError,
+  apiPost
+} from "./chunk-X7VQFLHI.js";
+import {
+  requireChatId
+} from "./chunk-LGK7UWBN.js";
+import {
+  registerSchema
+} from "./chunk-Q7US4OOA.js";
+
+// src/commands/ads/chatgpt/write-shared.ts
+import { defineCommand } from "citty";
+function fail(envelope) {
+  writeJsonEnvelope({ ...envelope });
+  process.exit(1);
+}
+function failWriteValidation(message) {
+  fail({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message,
+      fix: { action: "add_required_field", explanation: `${message}. Nothing was staged.` },
+      retryable: false
+    }
+  });
+}
+function writeFailure(err, reference) {
+  if (!(err instanceof ApiError) && err instanceof Error && err.message.includes("BAKER_CHAT_ID")) {
+    return {
+      ok: false,
+      error: {
+        code: "NO_CHAT",
+        message: err.message,
+        fix: {
+          action: "reject",
+          explanation: "ChatGPT Ads changes are staged on a chat and apply when it is published; run this from the chat."
+        },
+        retryable: false
+      }
+    };
+  }
+  return chatgptFailure(err, reference);
+}
+function decimalPlaces(value) {
+  const [mantissa, exponent] = String(value).trim().split(/e/i);
+  const written = (mantissa?.split(".")[1] ?? "").length;
+  return Math.max(0, written - (exponent ? Number(exponent) : 0));
+}
+function parseChatgptMoney(value) {
+  if (value === void 0 || value === "") {
+    return { ok: true, micros: void 0 };
+  }
+  const amount = Number(value);
+  if (!Number.isFinite(amount) || amount <= 0) {
+    return { ok: false, reason: "must be a positive amount, for example 12.50" };
+  }
+  if (decimalPlaces(value) > 6) {
+    return { ok: false, reason: "is finer than ChatGPT Ads can express" };
+  }
+  return { ok: true, micros: Math.round(amount * 1e6) };
+}
+function microsFromArg(value, flag) {
+  const parsed = parseChatgptMoney(value);
+  if (!parsed.ok) {
+    failWriteValidation(`${flag} ${parsed.reason}`);
+  }
+  return parsed.micros;
+}
+function csvArg(value) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    return void 0;
+  }
+  const parts = value.split(",").map((part) => part.trim()).filter(Boolean);
+  return parts.length > 0 ? parts : void 0;
+}
+function schemaArgs(args) {
+  return Object.fromEntries(
+    Object.entries(args).map(([name, arg]) => [
+      name,
+      {
+        type: arg.type,
+        description: arg.description,
+        required: arg.required === true
+      }
+    ])
+  );
+}
+function lowerArg(value) {
+  return typeof value === "string" && value.trim() !== "" ? value.trim().toLowerCase() : void 0;
+}
+function lowerCsvArg(value) {
+  return csvArg(value)?.map((part) => part.toLowerCase());
+}
+function compact(payload) {
+  return Object.fromEntries(Object.entries(payload).filter(([, value]) => value !== void 0 && value !== ""));
+}
+function requireTarget(args, name) {
+  const value = args[name];
+  if (typeof value !== "string" || value.trim().length === 0) {
+    failWriteValidation(`${name} is required`);
+  }
+  return value.trim();
+}
+function requireTargets(args, name) {
+  const ids = csvArg(args[name]);
+  if (!ids) {
+    failWriteValidation(`${name} is required \u2014 pass one or more ids, comma-separated`);
+  }
+  return ids;
+}
+function preflight(raw) {
+  const parsed = chatgptDraftOpInputSchema.safeParse(raw);
+  if (parsed.success) {
+    return parsed.data;
+  }
+  const fields = parsed.error.issues.map((issue) => ({ path: issue.path.join("."), message: issue.message }));
+  const message = fields.map((field) => field.path ? `${field.path}: ${field.message}` : field.message).join("; ");
+  return fail({
+    ok: false,
+    error: {
+      code: "VALIDATION_ERROR",
+      message,
+      fix: {
+        action: "retry_with_modified_query",
+        explanation: "Fix the named fields and stage again. Nothing was staged \u2014 the draft is as it was before this call."
+      },
+      retryable: false
+    }
+  });
+}
+async function postStage(chatId, op) {
+  return await apiPost("/api/ads/chatgpt/draft/stage", { chatId, op });
+}
+async function stageChatgptOp(raw, reference, hintsFor) {
+  const op = preflight(raw);
+  try {
+    const staged = await postStage(requireChatId(), op);
+    const hints = hintsFor?.(staged) ?? [];
+    writeJsonEnvelope({ ok: true, data: staged, ...hints.length > 0 ? { hints } : {} });
+  } catch (err) {
+    fail(writeFailure(err, reference));
+  }
+}
+async function stageChatgptOps(raws, reference) {
+  if (raws.length === 1 && raws[0]) {
+    await stageChatgptOp(raws[0], reference);
+    return;
+  }
+  const ops = raws.map(preflight);
+  const staged = [];
+  try {
+    const chatId = requireChatId();
+    for (const op of ops) {
+      staged.push(await postStage(chatId, op));
+    }
+    writeJsonEnvelope({ ok: true, data: staged });
+  } catch (err) {
+    const failure = writeFailure(err, reference);
+    if (staged.length > 0) {
+      failure.error.message = `${failure.error.message} (already staged: ${staged.map((s) => s.summary).join("; ")})`;
+    }
+    fail(failure);
+  }
+}
+function clearableCsvArg(value) {
+  return typeof value === "string" && value.trim().toLowerCase() === "none" ? [] : csvArg(value);
+}
+function clearableArg(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return void 0;
+  }
+  return value.trim().toLowerCase() === "none" ? null : value.trim();
+}
+function cropArg(value, flag) {
+  const parts = csvArg(value);
+  if (!parts) {
+    return void 0;
+  }
+  const numbers = parts.map(Number);
+  const [x, y, width, height] = numbers;
+  if (numbers.length !== 4 || numbers.some(Number.isNaN) || x === void 0 || y === void 0 || width === void 0 || height === void 0) {
+    failWriteValidation(`${flag} takes four shares of the image, x,y,width,height \u2014 e.g. 0.1,0,0.8,0.8`);
+  }
+  return { x, y, width, height };
+}
+var STATUS_OF = {
+  pause: "paused",
+  resume: "active",
+  archive: "archived"
+};
+function statusOps(entity, ids, status) {
+  return ids.map((id) => ({ kind: `${entity}.update`, target: id, payload: { status } }));
+}
+var STATUS_NOUN = {
+  campaign: { command: "campaigns", plural: "campaigns", example: "cmpn_123,cmpn_456" },
+  adGroup: { command: "ad-groups", plural: "ad groups", example: "adgrp_123,adgrp_456" },
+  ad: { command: "ads", plural: "cards", example: "ad_123,ad_456" }
+};
+var STATUS_DOING = { pause: "pausing", resume: "resuming", archive: "archiving" };
+function statusCommand(entity, verb, reference) {
+  const noun = STATUS_NOUN[entity];
+  const args = {
+    ids: { type: "positional", description: `${noun.plural} ids, comma-separated`, required: true }
+  };
+  const forGood = verb === "archive" ? ` Archiving is for good: ChatGPT Ads cannot bring archived ${noun.plural} back, and their results stay in reports. Pause instead unless the user asked to archive.` : "";
+  registerSchema({
+    command: `ads.chatgpt.${noun.command}.${verb}`,
+    description: `Stage ${STATUS_DOING[verb]} one or more ChatGPT Ads ${noun.plural}. Pass every id in one call.${forGood}`,
+    args: schemaArgs(args)
+  });
+  return defineCommand({
+    meta: {
+      name: verb,
+      description: `Stage ${STATUS_DOING[verb]} ${noun.plural}.${forGood}
+
+Example:
+  baker ads chatgpt ${noun.command} ${verb} ${noun.example}`
+    },
+    args,
+    run: async ({ args: parsed }) => {
+      await stageChatgptOps(statusOps(entity, requireTargets(parsed, "ids"), STATUS_OF[verb]), reference);
+    }
+  });
+}
+function productFiltersArg(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return void 0;
+  }
+  if (value.trim().toLowerCase() === "none") {
+    return [];
+  }
+  return value.split(";").map((condition) => condition.trim()).filter(Boolean).map((condition) => {
+    const match = /^(\S+)\s+(\S+)\s+(.+)$/.exec(condition);
+    if (!match?.[1] || !match[2] || !match[3]) {
+      failWriteValidation(
+        `"${condition}" is not a product filter \u2014 write field operator values, e.g. price lte 5000`
+      );
+    }
+    return {
+      field: match[1],
+      operator: match[2].toLowerCase(),
+      values: match[3].split("|").map((part) => part.trim()).filter(Boolean)
+    };
+  });
+}
+
+export {
+  failWriteValidation,
+  microsFromArg,
+  csvArg,
+  schemaArgs,
+  lowerArg,
+  lowerCsvArg,
+  compact,
+  requireTarget,
+  requireTargets,
+  stageChatgptOp,
+  stageChatgptOps,
+  clearableCsvArg,
+  clearableArg,
+  cropArg,
+  statusCommand,
+  productFiltersArg
+};
+//# sourceMappingURL=chunk-LQ2BRGMX.js.map

package/dist/chunk-M7QZSEHF.js

@@ -0,0 +1,175 @@
+import {
+  termsRefusalFix
+} from "./chunk-Y2JZX6JB.js";
+import {
+  handleConnectionError,
+  isOrganizationReadRefusal,
+  needsConnectionFix,
+  writeAdsJson,
+  writeJsonEnvelope
+} from "./chunk-6DPSWLGY.js";
+import {
+  ApiError
+} from "./chunk-X7VQFLHI.js";
+import {
+  getEnv
+} from "./chunk-LGK7UWBN.js";
+
+// ../api/src/ads-meta/permissionGates.ts
+var META_PERMISSION_NOT_ENABLED_MESSAGE = {
+  catalog: "Catalog changes need the Catalog permission for Meta \u2014 ask a Baker admin to turn it on, then reconnect Meta. Everything else on Meta keeps working: tell the user, and carry on with the rest of the job.",
+  pagePosts: "Facebook Page posts need the Page posts permission for Meta \u2014 ask a Baker admin to turn it on, then reconnect Meta. Everything else on Meta keeps working: tell the user, and carry on with the rest of the job."
+};
+var META_PERMISSION_RECONNECT_MESSAGE = {
+  catalog: "Catalog changes need the Catalog permission for Meta. It is turned on for this company, but this Meta connection was made before, so it does not hold it \u2014 ask the user to reconnect Meta in the dashboard, then try again. Everything else on Meta keeps working meanwhile.",
+  pagePosts: "Facebook Page posts need the Page posts permission for Meta. It is turned on for this company, but this Meta connection was made before, so it does not hold it \u2014 ask the user to reconnect Meta in the dashboard, then try again. Everything else on Meta keeps working meanwhile."
+};
+var META_UNREQUESTED_PERMISSION_MESSAGE = {
+  comments: "Reading and moderating comments on ads needs Meta permissions Baker's Meta connection does not ask for yet (reading people's comments and managing them on the Page). Tell the user that comment moderation happens in Meta Business Suite for now, and carry on with the rest of the job.",
+  instagramMedia: "Listing an Instagram account's posts needs a Meta permission Baker's Meta connection does not ask for yet. Ask the user for the post's link or id instead, or boost it from Meta Business Suite, and carry on."
+};
+var META_PAGE_ADS_PERMISSION_REMEDY = "A Baker admin turns it on with the lead ads switch for this company; then the user reconnects Meta in the dashboard. Tell the user, and carry on with the rest of the job.";
+function isMetaPermissionGateRefusal(message) {
+  return [
+    ...Object.values(META_PERMISSION_NOT_ENABLED_MESSAGE),
+    ...Object.values(META_PERMISSION_RECONNECT_MESSAGE),
+    ...Object.values(META_UNREQUESTED_PERMISSION_MESSAGE),
+    META_PAGE_ADS_PERMISSION_REMEDY
+  ].some((refusal) => message.includes(refusal));
+}
+
+// src/commands/ads/meta/shared.ts
+var DAY_MS = 864e5;
+function metaForbiddenFix(message) {
+  if (isMetaPermissionGateRefusal(message)) {
+    return { action: "reject", explanation: message };
+  }
+  if (message.includes("has not accepted Meta's Lead Generation Terms")) {
+    return {
+      action: "reject",
+      explanation: `${message}
+
+Meta confirmed the Page's terms status using its Page access. Give the Page owner the terms link in the error and ask them to accept it before trying the form or lead ad set again. Do not suggest reconnecting Meta for this refusal; continue with other work that does not require the form or ad set.`
+    };
+  }
+  return {
+    action: "reject",
+    explanation: [
+      message,
+      "This is a permission refusal, not a dead connection, and Meta returns the same code for two causes with opposite remedies. Tell them apart by how much else works before you answer.",
+      "If other reads on this account are ALSO refused (campaigns, ad sets, insights), the connection is short a permission it was never granted. Only the user can widen it, by reconnecting Meta from the dashboard.",
+      "If those reads work and only this object is refused, the asset (pixel/dataset, Page, or catalog) belongs to a Business the connected user holds no role in. Ad-account access does not carry asset access and reconnecting cannot grant it \u2014 the client assigns that asset to the connected user or partner in Meta Business settings, under the asset's own section (Data sources \u2192 Datasets for a pixel).",
+      "Either way do not retry the same call, and do not abort the wider job. Continue with what you can read, and state in your answer that this specific check could not run and why \u2014 never present the task as verified when this step was skipped."
+    ].join("\n\n")
+  };
+}
+function handleMetaError(err) {
+  if (err instanceof ApiError) {
+    if (needsConnectionFix(err.code, err.message)) {
+      handleConnectionError("meta_ads", err.message);
+    }
+    const terms = termsRefusalFix(err.code, err.message);
+    if (terms) {
+      writeJsonEnvelope({
+        ok: false,
+        error: { code: terms.code, message: err.message, fix: terms.fix, retryable: false }
+      });
+      process.exit(1);
+    }
+    const envelope = {
+      ok: false,
+      error: {
+        code: err.code,
+        message: err.message,
+        fix: err.code === "FORBIDDEN" && !isOrganizationReadRefusal(err.message) ? metaForbiddenFix(err.message) : { action: "reject", explanation: err.message },
+        retryable: err.code === "RATE_LIMITED" || err.code === "UNAVAILABLE" || err.code === "INTERNAL_ERROR"
+      }
+    };
+    writeAdsJson(envelope);
+    process.exit(1);
+  }
+  const message = err instanceof Error ? err.message : "Unexpected error";
+  writeAdsJson({ ok: false, error: { code: "NETWORK_ERROR", message } });
+  process.exit(1);
+}
+var ACCOUNT_ID_RE = /^(act_)?[0-9]+$/;
+function resolveAccountIdArg(args) {
+  const fromArgs = args["account-id"];
+  const id = fromArgs || getEnv().BAKER_META_AD_ACCOUNT_ID;
+  if (!id) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "MISSING_ACCOUNT_ID",
+        message: "Pass --account-id or set BAKER_META_AD_ACCOUNT_ID. Run `baker ads meta accounts` to find IDs."
+      }
+    });
+    process.exit(1);
+  }
+  if (!ACCOUNT_ID_RE.test(id)) {
+    writeAdsJson({
+      ok: false,
+      error: {
+        code: "INVALID_ACCOUNT_ID",
+        message: `Invalid account ID "${id}". Expected numeric ID, optionally prefixed with "act_".`
+      }
+    });
+    process.exit(1);
+  }
+  return id.startsWith("act_") ? id : `act_${id}`;
+}
+function getDateRange(args) {
+  const datePreset = args["date-preset"];
+  const since = args.since;
+  const until = args.until;
+  if (since && until) return { since, until };
+  return { datePreset: datePreset ?? "last_7d" };
+}
+function todayIso() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+function daysAgoIso(days) {
+  return new Date(Date.now() - days * DAY_MS).toISOString().slice(0, 10);
+}
+function csvOrJson(args) {
+  return args.output ?? "json";
+}
+var NAME_CONTAINS_ARG = {
+  type: "string",
+  description: "Only rows whose name contains this text, matched by Meta before anything is returned. Start here to find one entity by name: --name-contains octubre --all-statuses"
+};
+function resolveEffectiveStatus(args) {
+  if (args["all-statuses"]) {
+    return void 0;
+  }
+  const explicit = args["effective-status"];
+  if (explicit) {
+    return explicit;
+  }
+  return "ACTIVE";
+}
+function statusFilterHints(rows, effectiveStatus, noun) {
+  if (rows.length > 0 || effectiveStatus === void 0) return [];
+  if (effectiveStatus === "ACTIVE") {
+    return [
+      `No ACTIVE ${noun}. The ACTIVE filter hides paused, archived and in-review ones (under a paused campaign or ad set that is all of them), so this does NOT mean none exist. Re-run with --all-statuses before concluding there are none.`
+    ];
+  }
+  return [
+    `No ${noun} with effective_status ${effectiveStatus}. Re-run with --all-statuses to see every status before concluding there are none.`
+  ];
+}
+
+export {
+  metaForbiddenFix,
+  handleMetaError,
+  resolveAccountIdArg,
+  getDateRange,
+  todayIso,
+  daysAgoIso,
+  csvOrJson,
+  NAME_CONTAINS_ARG,
+  resolveEffectiveStatus,
+  statusFilterHints
+};
+//# sourceMappingURL=chunk-M7QZSEHF.js.map

package/dist/chunk-NB2FU6EZ.js

@@ -0,0 +1,179 @@
+import {
+  CHECKOUT_RECORD_REFUSAL,
+  CONVERSION_COUNT_MODES,
+  findNameCollision,
+  isCheckoutRecordKey,
+  isLandingViewKey,
+  parseEventKey
+} from "./chunk-JOE42ZW6.js";
+
+// src/commands/analytics/conversionArgs.ts
+var ConversionArgsError = class extends Error {
+  constructor(message, fix) {
+    super(message);
+    this.fix = fix;
+  }
+};
+function allValues(flag, argv) {
+  const values = [];
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === flag) {
+      const next = argv[i + 1];
+      if (next !== void 0 && !next.startsWith("--")) values.push(next);
+      continue;
+    }
+    if (arg.startsWith(`${flag}=`)) values.push(arg.slice(flag.length + 1));
+  }
+  return values.map((value) => value.trim()).filter((value) => value !== "");
+}
+function onlyOnce(value, flag, argv) {
+  if (value === void 0) return void 0;
+  const given = argv.filter((arg) => arg === flag || arg.startsWith(`${flag}=`)).length;
+  if (given > 1) {
+    throw new ConversionArgsError(
+      `${flag} was given ${given} times and only the last would have been used. It takes one value.`
+    );
+  }
+  const trimmed = String(value).trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function repeatable(flag, cittyValue, argv) {
+  const fromArgv = allValues(flag, argv);
+  if (fromArgv.length > 0) return fromArgv;
+  if (cittyValue === void 0) return [];
+  const trimmed = String(cittyValue).trim();
+  return trimmed === "" ? [] : [trimmed];
+}
+function checkFlagShape(args) {
+  if (args.eventKeys.length > 0 && args.name === void 0 && args.countMode === void 0) {
+    throw new ConversionArgsError(
+      "--event needs --name: a conversion nobody named is a row labelled with a UUID. (--event with only --count-mode changes how an event already counted is counted.)"
+    );
+  }
+  if (args.name !== void 0 && args.eventKeys.length === 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError("--name needs --event, naming which event to count.");
+  }
+  if (args.renameFrom !== void 0 && args.renameTo === void 0) {
+    throw new ConversionArgsError('--rename needs --to: `--rename "Lead form" --to "Lead"`.');
+  }
+  if (args.renameTo !== void 0 && args.renameFrom === void 0) {
+    throw new ConversionArgsError(
+      '--to needs --rename, naming which outcome to rename: `--rename "Lead form" --to "Lead"`.'
+    );
+  }
+}
+function checkEventKeys(eventKeys) {
+  for (const eventKey of eventKeys) {
+    if (parseEventKey(eventKey) === null) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not an event key. Run with --candidates (or --flow <slug> for one Form) and copy one; they look like form:<form>:<step>:<trigger>, submit:<form>, page:<name> or exit:<host>.`
+      );
+    }
+    if (isLandingViewKey(eventKey)) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is a landing being viewed \u2014 a funnel step, never a conversion. Add it as a step with \`baker funnel\` instead.`
+      );
+    }
+    if (isCheckoutRecordKey(eventKey)) {
+      throw new ConversionArgsError(CHECKOUT_RECORD_REFUSAL.message, CHECKOUT_RECORD_REFUSAL.fix);
+    }
+  }
+}
+function readDays(raw) {
+  if (raw === void 0) return void 0;
+  const days = Number(raw);
+  if (!Number.isFinite(days) || days <= 0) {
+    throw new ConversionArgsError("--days must be a positive number of days.");
+  }
+  return days;
+}
+function parseConversionsArgs(raw, argv) {
+  const countMode = onlyOnce(raw["count-mode"], "--count-mode", argv);
+  if (countMode !== void 0 && !CONVERSION_COUNT_MODES.includes(countMode)) {
+    throw new ConversionArgsError(`--count-mode must be one of ${CONVERSION_COUNT_MODES.join(", ")}.`);
+  }
+  const args = {
+    eventKeys: repeatable("--event", raw.event, argv),
+    removeKeys: repeatable("--remove", raw.remove, argv),
+    name: onlyOnce(raw.name, "--name", argv),
+    countMode,
+    renameFrom: onlyOnce(raw.rename, "--rename", argv),
+    renameTo: onlyOnce(raw.to, "--to", argv),
+    removeName: onlyOnce(raw["remove-name"], "--remove-name", argv),
+    flowSlug: onlyOnce(raw.flow, "--flow", argv),
+    candidates: raw.candidates === true,
+    full: raw.full === true,
+    days: readDays(raw.days)
+  };
+  checkFlagShape(args);
+  checkEventKeys(args.eventKeys);
+  return args;
+}
+function existingNames(existing) {
+  return [...new Set(existing.map((row) => row.name))];
+}
+function checkNameCollision(name, existing) {
+  const collision = findNameCollision(name, existingNames(existing));
+  if (collision === null) return;
+  throw new ConversionArgsError(
+    `This company already counts "${collision}", and "${name}" would be a second row for the same outcome \u2014 Baker groups by exact name, so the number would be split in two. Use "${collision}" to make them one number, or pick a name that means something different.`
+  );
+}
+function under(name, existing) {
+  const rows = existing.filter((row) => row.name === name);
+  if (rows.length === 0) {
+    throw new ConversionArgsError(
+      `Nothing is counted under "${name}". This company counts: ${existingNames(existing).join(", ") || "nothing yet"}.`
+    );
+  }
+  return rows;
+}
+function setFromEvents(args, existing) {
+  if (args.eventKeys.length === 0) return [];
+  if (args.name !== void 0) {
+    checkNameCollision(args.name, existing);
+    const name = args.name;
+    return args.eventKeys.map((eventKey) => ({
+      eventKey,
+      name,
+      ...args.countMode ? { countMode: args.countMode } : {}
+    }));
+  }
+  return args.eventKeys.map((eventKey) => {
+    const current = existing.find((row) => row.eventKey === eventKey);
+    if (!current) {
+      throw new ConversionArgsError(
+        `"${eventKey}" is not counted, so there is no count mode to change. Add it with --event "${eventKey}" --name "<what a person calls it>" --count-mode ${args.countMode}.`
+      );
+    }
+    return { eventKey, name: current.name, countMode: args.countMode };
+  });
+}
+function setFromRename(args, existing) {
+  if (args.renameFrom === void 0 || args.renameTo === void 0) return [];
+  const renameTo = args.renameTo;
+  checkNameCollision(renameTo, existing);
+  return under(args.renameFrom, existing).map((row) => ({
+    eventKey: row.eventKey,
+    name: renameTo,
+    countMode: row.countMode
+  }));
+}
+function conversionsWrite(args, existing) {
+  const set = [...setFromEvents(args, existing), ...setFromRename(args, existing)];
+  const remove = [
+    ...args.removeKeys,
+    ...args.removeName === void 0 ? [] : under(args.removeName, existing).map((row) => row.eventKey)
+  ];
+  if (set.length === 0 && remove.length === 0) return null;
+  return { ...set.length > 0 ? { set } : {}, ...remove.length > 0 ? { remove } : {} };
+}
+
+export {
+  ConversionArgsError,
+  onlyOnce,
+  parseConversionsArgs,
+  conversionsWrite
+};
+//# sourceMappingURL=chunk-NB2FU6EZ.js.map