@zorgo/next 1.1.6 → 1.3.0

package/dist/index.d.ts

@@ -2,8 +2,45 @@ import * as _stripe_stripe_js from '@stripe/stripe-js';
 import { StripeElementsOptions } from '@stripe/stripe-js';
 import * as React from 'react';
 import React__default, { RefObject } from 'react';
-import * as react_jsx_runtime from 'react/jsx-runtime';
 import { z } from 'zod';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+
+/**
+ * How the section picker draws itself. Closed set — each value needs a renderer,
+ * so adding one is a code change (and an `alter type portion_geometry add value`).
+ *
+ * Section order is fixed per geometry, and consecutive indices must be spatially
+ * adjacent so any divisor of the division count partitions cleanly (sections 1–3
+ * of 6 are exactly section 1 of 2). Without that, switching a customer from
+ * sixths to halves has no defined answer.
+ *
+ * - `radial` — contiguous arcs from 12 o'clock, counter-clockwise
+ * - `grid`   — column-major: down the left column, then the next column
+ * - `linear` — one end to the other
+ * - `count`  — equal shares of a countable quantity, no geometry
+ */
+declare const PortionGeometrySchema: z.ZodEnum<{
+    radial: "radial";
+    grid: "grid";
+    linear: "linear";
+    count: "count";
+}>;
+type PortionGeometry = z.infer<typeof PortionGeometrySchema>;
+/** A row of `portion_schemes` — a franchise-owned, franchise-named menu entity. */
+declare const PortionSchemeSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    franchise_id: z.ZodNumber;
+    geometry: z.ZodEnum<{
+        radial: "radial";
+        grid: "grid";
+        linear: "linear";
+        count: "count";
+    }>;
+    name: z.ZodString;
+    min_divisions: z.ZodDefault<z.ZodNumber>;
+    max_divisions: z.ZodNumber;
+}, z.core.$strip>;
+type PortionScheme = z.infer<typeof PortionSchemeSchema>;
 
 type LocationStatus = "active" | "permanently_closed";
 interface Location {
@@ -53,16 +90,27 @@ interface ItemVariant {
     components?: Component[];
     base_item_id?: number;
     rules?: Rule[];
+    portion_scheme_id?: number | null;
+    portion_scheme?: PortionScheme | null;
     display_price?: number;
     active_promo_id?: number;
 }
+interface BaseItemImage {
+    image_id: number;
+    base_item_id: number;
+    alias: string;
+    raw_path?: string | null;
+    processed_path?: string | null;
+    sort_index?: number;
+    local_key?: string | null;
+}
 interface MenuItem {
     base_item_id: number;
     category_id: number;
     franchise_id: number;
     name: string;
     per_person?: boolean | null;
-    image_path?: string | null;
+    images?: BaseItemImage[];
     variants: ItemVariant[];
     rules: Rule[];
     description?: string | null;
@@ -100,6 +148,7 @@ interface Rule {
     min_selection: number;
     max_selection?: number;
     included_quantity: number;
+    is_portionable?: boolean;
     items?: RuleItem[];
     components?: RuleComponent[];
 }
@@ -130,14 +179,25 @@ interface CustomizationOption {
     selected: boolean;
     disabled: boolean;
     toggle: () => void;
+    /** Section this option currently targets; null when editing the whole item. */
+    portion?: string | null;
+    /** Section indices this option already covers, for shading the picker. */
+    coveredSections?: number[];
+    /** Already applied to the whole item, so individual sections are moot. */
+    coveredWhole?: boolean;
 }
 interface CustomizationRule extends Rule {
     rule_id: number;
     max: number;
+    /** Weighted, not a row count: two halves of one topping count as 1. */
     selectedCount: number;
     satisfied: boolean;
+    /** "Choose 1. Select up to 5. 1 included" — the rule's limits in words. */
+    subtext: string;
     message: () => string | null;
     options: CustomizationOption[];
+    /** This rule can be applied per-section under the item's scheme. */
+    portionable?: boolean;
 }
 interface OrderItem {
     item_id: number;
@@ -155,6 +215,7 @@ interface OrderItem {
     components?: OrderComponent[];
     selections?: RuleSelection[];
     comments?: string;
+    portion_scheme?: PortionScheme | null;
     status?: "removed" | "modified";
     applied_promo_id?: number;
     discount_amount?: number;
@@ -163,6 +224,7 @@ interface OrderComponent extends Component {
     quantity_servings: number;
     upcharge?: number;
     rule_id?: number;
+    portion?: string | null;
 }
 interface RuleSelection {
     rule_id: number;
@@ -177,6 +239,7 @@ interface Selection {
     serving_price?: number;
     name: string;
     status?: "removed" | "modified" | "added";
+    portion?: string | null;
     component_type_id?: number;
     serving_weight?: number;
     measurement_type?: "weight" | "count";
@@ -383,7 +446,6 @@ declare function useMenu(): {
     items: MenuItem[];
     allItems: MenuItem[];
     categories: Category[];
-    getItemImageUrl: (imagePath?: string | null) => string | null;
 };
 /**
  * Seeds a store with prebuilt data (see the app's prebuild script) during the
@@ -432,11 +494,27 @@ declare function useItemCustomization(baseItemId: number, seed?: OrderItem, edit
     unmetRule: CustomizationRule | null;
     canSubmit: boolean;
     submit: () => OrderItem | null;
+    portionScheme: {
+        id: number;
+        franchise_id: number;
+        geometry: "radial" | "grid" | "linear" | "count";
+        name: string;
+        min_divisions: number;
+        max_divisions: number;
+    } | null;
+    placeOption: (ruleId: number, baseKey: string, portion: string | null, max?: number) => void;
+    clearOption: (ruleId: number, baseKey: string) => void;
+    recutSelections: (next: number) => void;
     quantity: number;
-    setQuantity: React.Dispatch<React.SetStateAction<number>>;
+    setQuantity: (next: number | ((current: number) => number)) => void;
     comments: string;
     setComments: React.Dispatch<React.SetStateAction<string>>;
-    setComponentServings: (componentId: number, qty: number) => void;
+    /**
+     * Set a component's servings for the whole item, or for one section when
+     * `portion` is given. 0 removes it — "no cheese", or "no cheese on the
+     * left half".
+     */
+    setComponentServings: (componentId: number, qty: number, portion?: string | null) => void;
     price: number;
     salePrice: number | undefined;
     isEditMode: boolean;
@@ -1105,4 +1183,95 @@ declare function useFormValues(): Record<string, unknown>;
 
 declare function useFormValidity(): boolean;
 
-export { type Category, CheckboxField, ClickableField, ConditionalRenderer, type Customer, type CustomizationOption, type CustomizationRule, DateField, DateTime, DateTimeRange, DisclaimerText, DiscreteNumberField, DynamicFormShell, EmailField, FieldError, FieldLabel, GuestCountField, Header, IncrementField, type ItemVariant, type Location, LocationField, type Menu, type MenuItem, NameFields, type Order, type OrderComponent, type OrderItem, PhoneField, Platforms, PerPersonSummary as PricePreview, type Promotion, type RecommendationRequest, type RecommendationResult, type RecommendationStrategy, type Rule, type RuleComponent, type RuleItem, type RuleSelection, SectionLabel, type Selection, SliderField, SubmitButton, TextField, type TimeConstraints, TimeField, setZorgoBoot, setZorgoPathnameHook, useCart, useCateringConfig, useCustomer, useField, useFormStatus, useFormValidity, useFormValues, useHydrateMenu, useHydrateStore, useItemCustomization, useLocation, useMenu, useModal, usePayment, usePromotions, useRecommendations, useRegisterField };
+declare function parsePortion(portion: string): {
+    index: number;
+    divisions: number;
+};
+/** A section's share of the whole. No portion = the whole item = 1. */
+declare function portionWeight(portion?: string | null): number;
+/**
+ * Selection keys carry their portion as a suffix: `component:123@1/2`. A bare
+ * key is the whole item, which is what every pre-portion key already is — so
+ * existing state parses unchanged.
+ */
+declare function portionKey(baseKey: string, portion?: string | null): string;
+declare function parsePortionKey(key: string): {
+    baseKey: string;
+    portion: string | null;
+};
+/**
+ * A section's share of a whole-item upcharge, in cents. Rounds up, so covering
+ * every section can cost a cent or two more than the whole — which is why a
+ * selection covering everything collapses to a single portion-less row instead.
+ */
+declare function splitUpcharge(cents: number, divisions: number): number;
+/** Every division count a scheme allows, for the picker's cut selector. */
+declare function divisionsFor(scheme: Pick<PortionScheme, "min_divisions" | "max_divisions">): number[];
+/**
+ * The one place a section index becomes words. The picker, the cart line, the
+ * receipt and the KDS ticket all call this on the same scheme, so the index is
+ * the only token the UI and the data share.
+ */
+declare function portionLabel(portion: string | null | undefined, scheme: Pick<PortionScheme, "geometry">): string;
+/**
+ * Expand per-section overrides on one keyed entity into one row per section —
+ * how "no cheese on the left half" becomes a 0-serving row for that section and
+ * a normal row for the rest. No overrides, or the same value on every section,
+ * is a single whole-item row (§3 collapse).
+ */
+declare function portionRows(baseKey: string, values: Record<string, number>, fallback: number): {
+    portion: string | null;
+    value: number;
+}[];
+/** Weighted count of a rule's selections: two halves of one topping count as 1. */
+declare function selectionWeight(keys: string[]): number;
+/**
+ * Spend `included_quantity` on selection keys in pick order. A topping is a
+ * topping: it takes one included slot no matter how little of the pizza it covers,
+ * so putting pepperoni on one half never leaves half a free slot behind to
+ * discount everything else — and its rows share that one slot, so two halves of
+ * pepperoni consume one included topping, not two. With no portions this is
+ * exactly the old positional rule (`position < included ? 0 : basePrice`).
+ */
+declare function weightedUpcharges(keys: string[], basePriceOf: (baseKey: string) => number, included: number): Map<string, number>;
+/**
+ * Re-express a portion under a different cut, for when the customer switches
+ * from halves to quarters mid-order. Returns null when neither count divides the
+ * other (halves → thirds), meaning the selection can't be carried over.
+ */
+declare function remapPortion(portion: string, nextDivisions: number): string[] | null;
+/**
+ * Positional section wording, geometry-free — deliberately not `portionLabel`.
+ * Derived words ("Left", "Top left") only exist for a few geometry/division
+ * pairs and need the scheme; a receipt has to say something for every cut.
+ */
+declare function sectionLabel(portion?: string | null): string;
+/** A text glyph for a section, or null when unicode has no character for it. */
+declare function portionGlyph(portion: string | null | undefined, geometry?: PortionGeometry | null): string | null;
+interface PortionGroup {
+    portion: string | null;
+    label: string;
+    glyph: string | null;
+    /** The item's rules, each carrying only the selections that land on this section. */
+    selections: RuleSelection[];
+    removals: OrderComponent[];
+    /**
+     * Components present on this section. Whole-item components are the base
+     * recipe — implied by the item's name — so only portioned ones land here,
+     * where "pepperoni on the left" is the whole point of the line.
+     */
+    additions: OrderComponent[];
+}
+/**
+ * One group per covered section: the whole-item group first, then sections in
+ * index order, rules keeping their original order inside each. An item with no
+ * portions anywhere yields exactly one whole-item group, so a surface can render
+ * this unconditionally and show the heading only when `portion_scheme` is set.
+ *
+ * It groups and nothing else — every selection it is handed comes back out. What
+ * counts as worth printing is the surface's call, not this function's.
+ */
+declare function groupItemPortions(item: Pick<OrderItem, "selections" | "components" | "portion_scheme">): PortionGroup[];
+declare function radialSectionPath(index: number, divisions: number, r?: number): string;
+
+export { type Category, CheckboxField, ClickableField, ConditionalRenderer, type Customer, type CustomizationOption, type CustomizationRule, DateField, DateTime, DateTimeRange, DisclaimerText, DiscreteNumberField, DynamicFormShell, EmailField, FieldError, FieldLabel, GuestCountField, Header, IncrementField, type ItemVariant, type Location, LocationField, type Menu, type MenuItem, NameFields, type Order, type OrderComponent, type OrderItem, PhoneField, Platforms, type PortionGroup, PerPersonSummary as PricePreview, type Promotion, type RecommendationRequest, type RecommendationResult, type RecommendationStrategy, type Rule, type RuleComponent, type RuleItem, type RuleSelection, SectionLabel, type Selection, SliderField, SubmitButton, TextField, type TimeConstraints, TimeField, divisionsFor, groupItemPortions, parsePortion, parsePortionKey, portionGlyph, portionKey, portionLabel, portionRows, portionWeight, radialSectionPath, remapPortion, sectionLabel, selectionWeight, setZorgoBoot, setZorgoPathnameHook, splitUpcharge, useCart, useCateringConfig, useCustomer, useField, useFormStatus, useFormValidity, useFormValues, useHydrateMenu, useHydrateStore, useItemCustomization, useLocation, useMenu, useModal, usePayment, usePromotions, useRecommendations, useRegisterField, weightedUpcharges };