@12-apps/discounts 1.3.0 → 1.5.0

package/src/react/discount-form.tsx

@@ -12,8 +12,10 @@ import {
 } from "@12-apps/ui/form/total-form";
 import { Stack } from "@12-apps/ui/mui/Stack";
 
+import type { ComboRequirement } from "../engine/types";
+
 import type { DiscountFormPayload, DiscountsApiClient, DiscountWireRecord, WireTargetGroup } from "./api";
-import type { DiscountsWebCopy } from "./copy";
+import { fill, type DiscountsWebCopy } from "./copy";
 import {
   DiscountSwitches,
   LimitFields,
@@ -22,6 +24,7 @@ import {
   WindowFields,
   type CurrencyFieldComponent,
 } from "./discount-form-fields";
+import { comboUnits } from "./combo-slot-builder";
 import { DiscountTargetPicker } from "./discount-target-picker";
 import type { DiscountsFormatters } from "./format";
 
@@ -46,6 +49,9 @@ interface DiscountFormValues extends Record<string, string> {
   type: string;
   percentOff: string;
   amountOff: string;
+  bundlePrice: string;
+  freeUnits: string;
+  maxComboApplications: string;
   scope: string;
   trigger: string;
   code: string;
@@ -67,6 +73,9 @@ const BLANK: DiscountFormValues = {
   type: "PERCENTAGE",
   percentOff: "",
   amountOff: "",
+  bundlePrice: "",
+  freeUnits: "",
+  maxComboApplications: "",
   scope: "ORDER",
   trigger: "AUTOMATIC",
   code: "",
@@ -89,6 +98,10 @@ function initialValues(
     type: editing.type,
     percentOff: editing.percentOffBp === null ? "" : formatters.toInput(editing.percentOffBp / 100),
     amountOff: cents(editing.amountOffCents),
+    bundlePrice: cents(editing.bundlePriceCents ?? null),
+    freeUnits: editing.freeUnits == null ? "" : String(editing.freeUnits),
+    maxComboApplications:
+      editing.maxComboApplications == null ? "" : String(editing.maxComboApplications),
     scope: editing.scope,
     trigger: editing.trigger,
     code: editing.code ?? "",
@@ -100,31 +113,125 @@ function initialValues(
   };
 }
 
-/** The value half: a rate in (0, 100], or an amount above zero. */
+/** A whole number above zero, as typed. `null` when it is neither. */
+function positiveCount(typed: string): number | null {
+  const trimmed = typed.trim();
+  if (trimmed === "") return null;
+  const value = Number(trimmed);
+  return Number.isInteger(value) && value > 0 ? value : null;
+}
+
+/** A money field that has to hold something above zero. */
+function checkMoney(
+  typed: string,
+  field: string,
+  message: string,
+  formatters: DiscountsFormatters,
+): Record<string, string> {
+  const amount = formatters.parseDecimal(typed);
+  return amount === null || amount <= 0 ? { [field]: message } : {};
+}
+
+/**
+ * The free count, which is the one reward bounded by another field.
+ *
+ * "Take 3, three free" is a giveaway rather than a promotion, so it is compared
+ * against what ONE application of the combo takes out of the cart. The ceiling
+ * is named in the message: an operator told only "too many" has to guess the
+ * number.
+ */
+function checkFreeUnits(
+  typed: string,
+  slots: readonly ComboRequirement[],
+  copy: DiscountsWebCopy,
+): Record<string, string> {
+  const free = positiveCount(typed);
+  if (free === null) return { freeUnits: copy.form.invalidFreeUnits };
+  const units = comboUnits(slots);
+  if (free >= units) {
+    return {
+      freeUnits: fill(copy.form.freeUnitsExceedCombo, { units, max: Math.max(units - 1, 0) }),
+    };
+  }
+  return {};
+}
+
+/** The rate, in the 0–100 an operator thinks in rather than basis points. */
+function checkPercent(
+  typed: string,
+  formatters: DiscountsFormatters,
+  copy: DiscountsWebCopy,
+): Record<string, string> {
+  const percent = formatters.parseDecimal(typed);
+  return percent === null || percent <= 0 || percent > 100
+    ? { percentOff: copy.form.invalidPercent }
+    : {};
+}
+
+/** The reward, checked against the input the chosen type actually mounted. */
 function checkValue(
   values: DiscountFormValues,
+  slots: readonly ComboRequirement[],
   formatters: DiscountsFormatters,
   copy: DiscountsWebCopy,
 ): Record<string, string> {
-  if (values.type === "PERCENTAGE") {
-    const percent = formatters.parseDecimal(values.percentOff);
-    if (percent === null || percent <= 0 || percent > 100) {
-      return { percentOff: copy.form.invalidPercent };
-    }
-    return {};
+  if (values.type === "FIXED_AMOUNT") {
+    return checkMoney(values.amountOff, "amountOff", copy.form.invalidAmount, formatters);
+  }
+  if (values.type === "BUNDLE_PRICE") {
+    return checkMoney(values.bundlePrice, "bundlePrice", copy.form.invalidBundlePrice, formatters);
   }
-  const amount = formatters.parseDecimal(values.amountOff);
-  return amount === null || amount <= 0 ? { amountOff: copy.form.invalidAmount } : {};
+  if (values.type === "FREE_UNITS") return checkFreeUnits(values.freeUnits, slots, copy);
+  return checkPercent(values.percentOff, formatters, copy);
+}
+
+/**
+ * The combo half: the groups themselves, and the per-cart cap.
+ *
+ * Every rule here is also the server's (`validate-combo.ts`), and deliberately
+ * so — this half exists to attach the refusal to the input the operator is
+ * looking at, never to be the authority.
+ */
+function checkCombo(
+  values: DiscountFormValues,
+  slots: readonly ComboRequirement[],
+  copy: DiscountsWebCopy,
+): Record<string, string> {
+  if (values.scope !== "COMBO") return {};
+  if (slots.length === 0) return { scope: copy.form.comboSlotsRequired };
+  const errors: Record<string, string> = {};
+  if (slots.some((slot) => !Number.isInteger(slot.quantity) || slot.quantity <= 0)) {
+    errors.scope = copy.form.invalidComboQuantity;
+  } else if (
+    slots.some((slot) => slot.categoryIds.length === 0 && slot.menuItemIds.length === 0)
+  ) {
+    errors.scope = copy.form.comboSlotTargetRequired;
+  }
+  if (values.maxComboApplications.trim() !== "" && positiveCount(values.maxComboApplications) === null) {
+    errors.maxComboApplications = copy.form.invalidMaxComboApplications;
+  }
+  return errors;
+}
+
+/** What the pickers and the builder currently hold, in one argument. */
+interface FormTargets {
+  categoryIds: string[];
+  menuItemIds: string[];
+  comboRequirements: ComboRequirement[];
 }
 
 /** The cross-field rules a per-input schema cannot express. */
 function validate(
   values: DiscountFormValues,
-  targets: { categoryIds: string[]; menuItemIds: string[] },
+  targets: FormTargets,
   formatters: DiscountsFormatters,
   copy: DiscountsWebCopy,
 ): Record<string, string> {
-  const errors: Record<string, string> = { ...checkValue(values, formatters, copy) };
+  const slots = targets.comboRequirements;
+  const errors: Record<string, string> = {
+    ...checkValue(values, slots, formatters, copy),
+    ...checkCombo(values, slots, copy),
+  };
   if (values.trigger === "CODE" && values.code.trim() === "") {
     errors.code = copy.form.codeRequired;
   }
@@ -148,15 +255,23 @@ function useNonStringState(editing: DiscountWireRecord | null) {
   const [stackable, setStackable] = useState<boolean>(editing?.stackable ?? true);
   const [categoryIds, setCategoryIds] = useState<string[]>(editing?.categoryIds ?? []);
   const [menuItemIds, setMenuItemIds] = useState<string[]>(editing?.menuItemIds ?? []);
+  // The combo's groups are the third array, and the one whose ORDER matters:
+  // the list the operator built is the list a card reads back, and the server
+  // stamps each group's index as its stored `position`.
+  const [comboRequirements, setComboRequirements] = useState<ComboRequirement[]>(() =>
+    editing?.comboRequirements ? [...editing.comboRequirements] : [],
+  );
   return {
     active,
     stackable,
     categoryIds,
     menuItemIds,
+    comboRequirements,
     setActive,
     setStackable,
     setCategoryIds,
     setMenuItemIds,
+    setComboRequirements,
   };
 }
 
@@ -190,7 +305,11 @@ function makeSubmit(
   const { api, copy, formatters, editing, onSaved, onError } = props;
   return async function handleSubmit(values, { setFieldErrors }): Promise<void> {
     setError(null);
-    const targets = { categoryIds: extra.categoryIds, menuItemIds: extra.menuItemIds };
+    const targets: FormTargets = {
+      categoryIds: extra.categoryIds,
+      menuItemIds: extra.menuItemIds,
+      comboRequirements: extra.comboRequirements,
+    };
     const invalid = validate(values, targets, formatters, copy);
     if (Object.keys(invalid).length > 0) {
       setFieldErrors(invalid);
@@ -241,8 +360,10 @@ export function DiscountForm(props: DiscountFormProps): JSX.Element {
           selection={{
             categoryIds: extra.categoryIds,
             menuItemIds: extra.menuItemIds,
+            comboRequirements: extra.comboRequirements,
             onCategoryIdsChange: extra.setCategoryIds,
             onMenuItemIdsChange: extra.setMenuItemIds,
+            onComboRequirementsChange: extra.setComboRequirements,
           }}
         />
         <WindowFields copy={copy} />

package/src/react/discount-target-picker.tsx

@@ -1,23 +1,24 @@
 "use client";
 
-import { useState, type JSX } from "react";
+import type { JSX } from "react";
 
-import { Autocomplete } from "@12-apps/ui/form/Autocomplete";
-import { CategorySelect } from "@12-apps/ui/form/CategorySelect";
-import { FormControl, FormLabel, FormMessage } from "@12-apps/ui/form/Form";
 import { useFormContext } from "@12-apps/ui/form/total-form";
 
+import type { ComboRequirement } from "../engine/types";
+
+import type { WireTargetGroup } from "./api";
+import { ComboSlotBuilder } from "./combo-slot-builder";
 import { fill, type DiscountsWebCopy } from "./copy";
-import type { WireTarget, WireTargetGroup } from "./api";
+import { TargetPickerField } from "./target-picker-field";
 
 /**
  * What a scoped discount points at, picked from the host's own collections.
  *
- * There is no shared multi-select in `@12-apps/ui`, so this composes
- * `Autocomplete` in multiple mode — chips plus type-to-filter, the same control
- * `AddressAutocomplete` is built on. A collection that NESTS gets
- * `CategorySelect` instead: a flat combobox would put a subcategory beside its
- * parent with nothing to tell them apart.
+ * This file is the ROUTER: it reads the scope and decides which shape the
+ * targets take. The controls themselves live next door — one collection's
+ * picker in `target-picker-field`, the quantified group list in
+ * `combo-slot-builder` — because the combo builder needs the former per group
+ * and a file cannot import its own importer.
  *
  * Which collections exist is not decided here. The surface reads them from
  * `GET /discounts/targets`, which answers whatever the host registered — so
@@ -32,62 +33,15 @@ import type { WireTarget, WireTargetGroup } from "./api";
  * leaving a stale one on screen would suggest otherwise.
  */
 
-/** One labelled multi-select of targets, with its own input-text state. */
-function TargetField({
-  label,
-  placeholder,
-  requiredMessage,
-  options,
-  ids,
-  onChange,
-  dataTestId,
-}: {
-  label: string;
-  placeholder: string;
-  requiredMessage: string;
-  options: WireTarget[];
-  ids: readonly string[];
-  onChange: (next: string[]) => void;
-  dataTestId: string;
-}): JSX.Element {
-  const [query, setQuery] = useState("");
-  const byId = new Map(options.map((option) => [option.id, option]));
-  // An id whose option is missing — a target archived since the rule was saved
-  // — still renders as a chip, so saving cannot silently drop it.
-  const selected = ids.map((id) => byId.get(id) ?? { id, name: id });
-
-  return (
-    <FormControl fullWidth>
-      <FormLabel error={ids.length === 0}>{label}</FormLabel>
-      <div data-testid={dataTestId}>
-        <Autocomplete<WireTarget>
-          multiple
-          value={query}
-          onChange={setQuery}
-          suggestions={options}
-          selectedItems={selected}
-          onSelectedItemsChange={(items) => onChange(items.map((item) => item.id))}
-          getKey={(option) => option.id}
-          getLabel={(option) => option.name}
-          placeholder={placeholder}
-          inputAriaLabel={label}
-        />
-      </div>
-      {ids.length === 0 && (
-        <FormMessage error dataTestId={`${dataTestId}-message`}>
-          {requiredMessage}
-        </FormMessage>
-      )}
-    </FormControl>
-  );
-}
-
-/** The ids currently chosen for one dimension. */
+/** What the form currently has chosen, in every shape a scope can need. */
 interface DiscountTargetSelection {
   categoryIds: string[];
   menuItemIds: string[];
+  /** The combo's groups, in the operator's own order. Empty at every other scope. */
+  comboRequirements: readonly ComboRequirement[];
   onCategoryIdsChange: (next: string[]) => void;
   onMenuItemIdsChange: (next: string[]) => void;
+  onComboRequirementsChange: (next: ComboRequirement[]) => void;
 }
 
 /** Which selection a dimension reads and writes. */
@@ -112,6 +66,12 @@ function scopeFor(targetType: string): string {
  * Reads the LIVE `scope` from the form context, so flipping the toggle swaps
  * the picker immediately without the parent form having to mirror the value
  * into its own state.
+ *
+ * COMBO is the third branch (FUT-268) and it is a different SHAPE, not another
+ * picker: a combo is a list of quantified groups, so it gets the builder and
+ * every collection at once, while CATEGORY and ITEM each get exactly one
+ * collection's picker. ORDER still renders nothing — an order-wide discount
+ * covers everything, so a target list there is not empty, it is meaningless.
  */
 export function DiscountTargetPicker({
   groups,
@@ -124,36 +84,32 @@ export function DiscountTargetPicker({
 }): JSX.Element | null {
   const { values } = useFormContext();
   const scope = values.scope ?? "ORDER";
-  const group = groups.find((entry) => scopeFor(entry.targetType) === scope);
-  if (!group) return null;
-
-  const { ids, onChange } = bind(group.targetType, selection);
-  const label = fill(copy.targets.pick, { collection: group.label });
-  const dataTestId = `discount-${group.slug}-targets`;
 
-  if (group.nests) {
+  if (scope === "COMBO") {
     return (
-      <CategorySelect
-        label={label}
-        fullWidth
-        allowParentSelection
-        options={group.targets}
-        value={ids}
-        onChange={onChange}
-        error={ids.length === 0 ? copy.targets.required : undefined}
-        dataTestId={dataTestId}
+      <ComboSlotBuilder
+        slots={selection.comboRequirements}
+        groups={groups}
+        copy={copy}
+        onChange={selection.onComboRequirementsChange}
       />
     );
   }
+
+  const group = groups.find((entry) => scopeFor(entry.targetType) === scope);
+  if (!group) return null;
+
+  const { ids, onChange } = bind(group.targetType, selection);
   return (
-    <TargetField
-      label={label}
+    <TargetPickerField
+      group={group}
+      label={fill(copy.targets.pick, { collection: group.label })}
       placeholder={fill(copy.targets.search, { collection: group.label })}
       requiredMessage={copy.targets.required}
-      options={group.targets}
       ids={ids}
       onChange={onChange}
-      dataTestId={dataTestId}
+      copy={copy.categorySelect}
+      dataTestId={`discount-${group.slug}-targets`}
     />
   );
 }

package/src/react/discounts-screen.tsx

@@ -6,8 +6,15 @@ import { useSearchParams } from "react-router-dom";
 import AddIcon from "@mui/icons-material/Add";
 
 import { useServerDataViews } from "@12-apps/app-shell/react";
-import { CardActionsProvider, useRowConfirm } from "@12-apps/ui/data-display/CardKit";
-import { DataViewsGrid, type DataViewState } from "@12-apps/ui/data-display/DataViews";
+import {
+  CardActionsProvider,
+  useRowConfirm,
+} from "@12-apps/ui/data-display/CardKit";
+import {
+  DataViewsCopyProvider,
+  DataViewsGrid,
+  type DataViewState,
+} from "@12-apps/ui/data-display/DataViews";
 import type { RowAction } from "@12-apps/ui/data-display/DataViews";
 import { ErrorState } from "@12-apps/ui/data-display/ErrorState";
 import { LoadingState } from "@12-apps/ui/data-display/LoadingState";
@@ -87,6 +94,7 @@ function useBulkDelete(
             confirmText: copy.actions.delete,
           },
     errorText: copy.actions.deleteFailed,
+    copy: copy.confirmAction,
     dataTestId: "discount-bulk-delete-confirm",
   });
 }
@@ -103,7 +111,9 @@ function HeaderControls({
 }): JSX.Element {
   return (
     <>
-      <Dashboard.Info title={copy.screen.aboutTitle}>{copy.screen.aboutBody}</Dashboard.Info>
+      <Dashboard.Info title={copy.screen.aboutTitle}>
+        {copy.screen.aboutBody}
+      </Dashboard.Info>
       <Dashboard.Spacer />
       <Dashboard.Export
         formats={[
@@ -234,6 +244,68 @@ function CreateDialog({
   );
 }
 
+/**
+ * Everything below the header: the create dialog and the grid.
+ *
+ * Split out of {@link DiscountsScreen} only to keep that component inside the
+ * size gate — this is one tree, not a second concern.
+ */
+function ScreenBody({
+  createOpen,
+  setCreateOpen,
+  menu,
+  refresh,
+  rows,
+  copy,
+  appliedState,
+  server,
+  onVisibleRowsChange,
+  bulkDelete,
+}: {
+  createOpen: boolean;
+  setCreateOpen: (open: boolean) => void;
+  menu: MenuBinding;
+  refresh: () => void;
+  rows: DiscountListItem[];
+  copy: DiscountsWebCopy;
+  appliedState: DataViewState;
+  server: ReturnType<typeof useServerDataViews>;
+  onVisibleRowsChange: (rows: DiscountListItem[]) => void;
+  bulkDelete: ReturnType<typeof useBulkDelete>;
+}): JSX.Element {
+  return (
+    <Dashboard.Body>
+      <CreateDialog
+        open={createOpen}
+        menu={menu}
+        onClose={() => setCreateOpen(false)}
+        onSaved={() => {
+          setCreateOpen(false);
+          refresh();
+        }}
+      />
+      <CardActionsProvider
+        // The menus read the refresh and the error channel from here; the
+        // tenant is already baked into `apiBase`, so there is nothing for a
+        // slug to do but be a second place it could disagree.
+        tenantSlug=""
+        onRefresh={refresh}
+        errorTitle={copy.actions.actionFailed}
+      >
+        <DiscountsGrid
+          rows={rows}
+          copy={copy}
+          menu={menu}
+          appliedState={appliedState}
+          server={server}
+          onVisibleRowsChange={onVisibleRowsChange}
+          bulkDelete={bulkDelete}
+        />
+      </CardActionsProvider>
+    </Dashboard.Body>
+  );
+}
+
 export function DiscountsScreen(props: DiscountsScreenProps): JSX.Element {
   const { api, copy, formatters, currencyField, onError, breadcrumb } = props;
   const [searchParams] = useSearchParams();
@@ -246,12 +318,16 @@ export function DiscountsScreen(props: DiscountsScreenProps): JSX.Element {
   // "now"s could disagree about which of them is still running.
   const rows = useMemo(() => {
     const now = new Date();
-    return (data.page?.data ?? []).map((record) => toListItem(record, formatters, copy, now));
+    return (data.page?.data ?? []).map((record) =>
+      toListItem(record, formatters, copy, now),
+    );
   }, [data.page, formatters, copy]);
 
   // Seeded ONCE from the URL. Re-applying it on every render would wipe the
   // operator's column-visibility choices each time the query synced back.
-  const [appliedState] = useState<DataViewState>(() => discountsAppliedState(searchParams, copy));
+  const [appliedState] = useState<DataViewState>(() =>
+    discountsAppliedState(searchParams, copy),
+  );
 
   const server = useServerDataViews({
     totalCount: data.page?.pagination.total ?? 0,
@@ -260,7 +336,14 @@ export function DiscountsScreen(props: DiscountsScreenProps): JSX.Element {
     toParams: discountsQueryToParams,
   });
 
-  const menu: MenuBinding = { api, copy, formatters, currencyField, groups: data.groups, onError };
+  const menu: MenuBinding = {
+    api,
+    copy,
+    formatters,
+    currencyField,
+    groups: data.groups,
+    onError,
+  };
 
   if (data.loading) return <LoadingState dataTestId="discounts-loading" />;
   if (data.error !== null) {
@@ -275,40 +358,31 @@ export function DiscountsScreen(props: DiscountsScreenProps): JSX.Element {
   }
 
   return (
-    <Dashboard testIdPrefix="discounts-dashboard">
-      {breadcrumb && <Dashboard.Breadcrumb items={[...breadcrumb]} />}
-      <Dashboard.Header title={copy.screen.title}>
-        <HeaderControls rows={visibleRows} copy={copy} onCreate={() => setCreateOpen(true)} />
-      </Dashboard.Header>
-      <Dashboard.Body>
-        <CreateDialog
-          open={createOpen}
-          menu={menu}
-          onClose={() => setCreateOpen(false)}
-          onSaved={() => {
-            setCreateOpen(false);
-            data.refresh();
-          }}
-        />
-        <CardActionsProvider
-          // The menus read the refresh and the error channel from here; the
-          // tenant is already baked into `apiBase`, so there is nothing for a
-          // slug to do but be a second place it could disagree.
-          tenantSlug=""
-          onRefresh={data.refresh}
-          errorTitle={copy.actions.actionFailed}
-        >
-          <DiscountsGrid
-            rows={rows}
+    // The grid, its toolbar and its saved-view dialogs read their words from
+    // here: `@12-apps/ui` ships none and throws rather than falling back.
+    <DataViewsCopyProvider copy={copy.dataViews}>
+      <Dashboard testIdPrefix="discounts-dashboard">
+        {breadcrumb && <Dashboard.Breadcrumb items={[...breadcrumb]} />}
+        <Dashboard.Header title={copy.screen.title}>
+          <HeaderControls
+            rows={visibleRows}
             copy={copy}
-            menu={menu}
-            appliedState={appliedState}
-            server={server}
-            onVisibleRowsChange={setVisibleRows}
-            bulkDelete={bulkDelete}
+            onCreate={() => setCreateOpen(true)}
           />
-        </CardActionsProvider>
-      </Dashboard.Body>
-    </Dashboard>
+        </Dashboard.Header>
+        <ScreenBody
+          createOpen={createOpen}
+          setCreateOpen={setCreateOpen}
+          menu={menu}
+          refresh={data.refresh}
+          rows={rows}
+          copy={copy}
+          appliedState={appliedState}
+          server={server}
+          onVisibleRowsChange={setVisibleRows}
+          bulkDelete={bulkDelete}
+        />
+      </Dashboard>
+    </DataViewsCopyProvider>
   );
 }

package/src/react/pt-BR.ts

@@ -1,3 +1,9 @@
+import {
+  PT_BR_CATEGORY_SELECT_COPY,
+  PT_BR_CONFIRM_ACTION_COPY,
+  PT_BR_DATA_VIEWS_COPY,
+} from "@12-apps/ui/pt-BR";
+
 import type { DiscountsWebCopy } from "./copy";
 
 /**
@@ -75,6 +81,10 @@ export const PT_BR_DISCOUNTS_WEB_COPY: DiscountsWebCopy = {
     percentOff: "Desconto (%)",
     percentPlaceholder: "10",
     amountOff: "Valor do desconto",
+    bundlePrice: "Preço do combo",
+    freeUnits: "Itens grátis",
+    freeUnitsHint:
+      "Quantas unidades do combo saem de graça. Em um grupo de 3, deixar 1 grátis é o clássico \"leve 3, pague 2\".",
     trigger: "Ativação",
     code: "Código do cupom",
     codePlaceholder: "BEMVINDO10",
@@ -84,6 +94,8 @@ export const PT_BR_DISCOUNTS_WEB_COPY: DiscountsWebCopy = {
     minSubtotal: "Pedido mínimo",
     usageLimit: "Limite de usos",
     perBuyerLimit: "Limite por cliente",
+    maxComboApplications: "Combos por pedido",
+    maxComboApplicationsHint: "Deixe em branco para valer quantas vezes couber no carrinho.",
     active: "Ativo",
     activeHint: "Desligue para pausar a promoção sem excluí-la.",
     stackable: "Acumulável",
@@ -94,11 +106,30 @@ export const PT_BR_DISCOUNTS_WEB_COPY: DiscountsWebCopy = {
     nameRequired: "Informe o nome da promoção.",
     invalidPercent: "Informe uma porcentagem maior que 0 e no máximo 100.",
     invalidAmount: "Informe um valor de desconto maior que zero.",
+    invalidBundlePrice: "Informe o preço do combo, maior que zero.",
+    invalidFreeUnits: "Informe quantos itens saem de graça, a partir de 1.",
+    freeUnitsExceedCombo:
+      "O combo tem {units} itens; deixe grátis no máximo {max} para ainda ser uma promoção.",
     codeRequired: "Informe o código do cupom que o cliente vai digitar.",
     categoryTargetRequired: "Selecione ao menos uma categoria para este desconto.",
     itemTargetRequired: "Selecione ao menos um produto para este desconto.",
+    comboSlotsRequired: "Monte o combo: adicione ao menos um grupo de itens.",
+    comboSlotTargetRequired: "Escolha o que pode entrar em cada grupo do combo.",
+    invalidComboQuantity: "Informe quantas unidades cada grupo leva, a partir de 1.",
+    invalidMaxComboApplications: "Informe quantos combos cabem por pedido, a partir de 1.",
     endsBeforeStarts: "A data de término deve ser posterior à data de início.",
   },
+  combo: {
+    title: "Monte o combo",
+    hint: "Cada grupo é uma parte do combo: quantas unidades leva e o que pode entrar nela.",
+    addSlot: "Adicionar grupo",
+    removeSlot: "Remover o grupo {position}",
+    slot: "Grupo {position}",
+    quantity: "Quantidade",
+    pick: "{collection} deste grupo",
+    empty: "Nenhum grupo ainda. Adicione o primeiro para montar o combo.",
+    summary: "O combo leva {units} itens em {groups} grupos.",
+  },
   targets: {
     pick: "{collection} com desconto",
     search: "Buscar em {collection}…",
@@ -129,4 +160,7 @@ export const PT_BR_DISCOUNTS_WEB_COPY: DiscountsWebCopy = {
     perBuyerLimit: "Limite por cliente",
     unlimited: "Sem limite",
   },
+  confirmAction: PT_BR_CONFIRM_ACTION_COPY,
+  dataViews: PT_BR_DATA_VIEWS_COPY,
+  categorySelect: PT_BR_CATEGORY_SELECT_COPY,
 };