restaurant-kit 0.1.0

package/dist/testimonials/testimonialMutations.js

@@ -0,0 +1,52 @@
+function u(t) {
+  return Number.isFinite(t) ? Math.min(5, Math.max(1, Math.round(t))) : 5;
+}
+function o(t) {
+  return [...t.testimonials ?? []].sort((i, r) => i.order - r.order);
+}
+function f(t) {
+  return o(t).filter((i) => i.isVisible && i.text.trim());
+}
+function s(t, i) {
+  return { ...t, testimonials: i.map((r, n) => r.order === n ? r : { ...r, order: n }) };
+}
+function c() {
+  return {
+    id: `testimonial-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 7)}`,
+    author: "",
+    rating: 5,
+    text: "",
+    order: Number.MAX_SAFE_INTEGER,
+    isVisible: !0
+  };
+}
+function l(t, i) {
+  return s(t, [...o(t), i]);
+}
+function m(t, i, r) {
+  if (!t.testimonials?.some((e) => e.id === i)) return t;
+  const n = o(t).map(
+    (e) => e.id === i ? { ...e, ...r, ...r.rating === void 0 ? {} : { rating: u(r.rating) } } : e
+  );
+  return s(t, n);
+}
+function g(t, i) {
+  return t.testimonials?.some((r) => r.id === i) ? s(
+    t,
+    o(t).filter((r) => r.id !== i)
+  ) : t;
+}
+function x(t, i, r) {
+  const n = [...o(t)], e = n.findIndex((d) => d.id === i), a = e + r;
+  return e < 0 || a < 0 || a >= n.length ? t : ([n[e], n[a]] = [n[a], n[e]], s(t, n));
+}
+export {
+  l as addTestimonial,
+  u as clampRating,
+  c as createTestimonialDraft,
+  g as deleteTestimonial,
+  x as moveTestimonial,
+  o as sortedTestimonials,
+  m as updateTestimonial,
+  f as visibleTestimonials
+};

package/dist/types/RestaurantSiteRoutes.d.ts

@@ -0,0 +1,11 @@
+import type { RestaurantKitApiOptions } from "./config/siteConfigContext";
+import type { RestaurantSiteConfig } from "./config/siteTypes";
+import type { DynamicMenu } from "./menu/menuSchema";
+type RestaurantSiteProps = {
+    readonly config: RestaurantSiteConfig;
+    readonly seedMenu: DynamicMenu;
+    /** Pass your Vite env here: `{ baseUrl: import.meta.env.VITE_MENU_API_BASE_URL, publicMenuUrl: import.meta.env.VITE_MENU_API_URL }`. */
+    readonly api?: RestaurantKitApiOptions;
+};
+export declare function RestaurantSite({ config, seedMenu, api }: RestaurantSiteProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminActionMenu.d.ts

@@ -0,0 +1,20 @@
+import type { ReactNode } from "react";
+type AdminActionMenuProps = {
+    children: ReactNode;
+    label: string;
+};
+export declare function AdminActionMenu({ children, label }: AdminActionMenuProps): import("react").JSX.Element;
+type AdminActionItemProps = {
+    children: ReactNode;
+    disabled?: boolean;
+    isDanger?: boolean;
+    onSelect: () => void;
+};
+export declare function AdminActionItem({ children, disabled, isDanger, onSelect }: AdminActionItemProps): import("react").JSX.Element;
+export declare function AdminActionSeparator(): import("react").JSX.Element;
+type AdminActionSubMenuProps = {
+    children: ReactNode;
+    label: ReactNode;
+};
+export declare function AdminActionSubMenu({ children, label }: AdminActionSubMenuProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminAuthPanel.d.ts

@@ -0,0 +1,13 @@
+import type { AdminAuthStrategy } from "../menu/menuApi";
+type AdminAuthPanelProps = {
+    /** null while the API has not reported a strategy (unreachable, or still loading). */
+    strategy: AdminAuthStrategy | null;
+    isLoadingDraft: boolean;
+    isSigningIn: boolean;
+    message: string;
+    onRetry: () => void;
+    onSignInWithAccess: () => void;
+    onSignInWithPassword: (password: string) => void;
+};
+export declare function AdminAuthPanel({ strategy, isLoadingDraft, isSigningIn, message, onRetry, onSignInWithAccess, onSignInWithPassword }: AdminAuthPanelProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminBackupsDialog.d.ts

@@ -0,0 +1,9 @@
+import type { MenuBackup } from "../menu/menuApi";
+type AdminBackupsDialogProps = {
+    listBackups: () => Promise<readonly MenuBackup[]>;
+    onClose: () => void;
+    onRestore: (key: string) => void;
+};
+/** Lists the backups written on each publish; restoring one overwrites the draft, not the live menu. */
+export declare function AdminBackupsDialog({ listBackups, onClose, onRestore }: AdminBackupsDialogProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminDraftProvider.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+import { type UseAdminMenuDraftOptions } from "./useAdminMenuDraft";
+type AdminDraftProviderProps = {
+    readonly children: ReactNode;
+    readonly options?: UseAdminMenuDraftOptions;
+};
+/**
+ * Owns the admin draft above the editor and preview routes, so navigating between them keeps
+ * unsaved edits in memory instead of remounting the editor and reloading the remote draft.
+ */
+export declare function AdminDraftProvider({ children, options }: AdminDraftProviderProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminGroupsPanel.d.ts

@@ -0,0 +1,14 @@
+import type { MenuGroup } from "../menu/menuSchema";
+export type AdminGroupRow = {
+    readonly group: MenuGroup;
+    readonly itemCount: number;
+    readonly hasSections: boolean;
+};
+type AdminGroupsPanelProps = {
+    groups: readonly AdminGroupRow[];
+    onAddGroup: () => void;
+    onDeleteGroup: (groupId: string) => void;
+    onUpdateGroup: (groupId: string, patch: Partial<MenuGroup>) => void;
+};
+export declare function AdminGroupsPanel({ groups, onAddGroup, onDeleteGroup, onUpdateGroup }: AdminGroupsPanelProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminItemDrawer.d.ts

@@ -0,0 +1,16 @@
+import "react-image-crop/dist/ReactCrop.css";
+import type { MenuItem, MenuSize } from "../menu/menuSchema";
+type AdminItemDrawerProps = {
+    isUploadingImage: boolean;
+    item: MenuItem;
+    onAddSize: () => void;
+    onClose: () => void;
+    onDelete: () => void;
+    onRemoveImage: () => void;
+    onRemoveSize: (sizeId: string) => void;
+    onUpdate: (patch: Partial<MenuItem>) => void;
+    onUpdateSize: (sizeId: string, patch: Partial<MenuSize>) => void;
+    onUploadImage: (file: File) => void;
+};
+export declare function AdminItemDrawer({ isUploadingImage, item, onAddSize, onClose, onDelete, onRemoveImage, onRemoveSize, onUpdate, onUpdateSize, onUploadImage }: AdminItemDrawerProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminMenuCard.d.ts

@@ -0,0 +1,10 @@
+import type { MenuItem } from "../menu/menuSchema";
+type AdminMenuCardProps = {
+    index: number;
+    isReordering: boolean;
+    isUploadingImage: boolean;
+    item: MenuItem;
+    onEdit: () => void;
+};
+export declare function AdminMenuCard({ index, isReordering, isUploadingImage, item, onEdit }: AdminMenuCardProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminMenuGroupTabs.d.ts

@@ -0,0 +1,11 @@
+import type { MenuGroup } from "../menu/menuSchema";
+type AdminMenuGroupTabsProps = {
+    activeGroupId: string;
+    editingGroupId: string;
+    groups: readonly MenuGroup[];
+    onSelectGroup: (groupId: string) => void;
+    onSetEditingGroupId: (groupId: string) => void;
+    onUpdateGroup: (groupId: string, patch: Partial<MenuGroup>) => void;
+};
+export declare function AdminMenuGroupTabs({ activeGroupId, editingGroupId, groups, onSelectGroup, onSetEditingGroupId, onUpdateGroup }: AdminMenuGroupTabsProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminMenuIconPicker.d.ts

@@ -0,0 +1,8 @@
+import type { MenuIcon } from "../menu/menuSchema";
+type AdminMenuIconPickerProps = {
+    readonly label: string;
+    readonly value: MenuIcon;
+    readonly onChange: (icon: MenuIcon) => void;
+};
+export declare function AdminMenuIconPicker({ label, value, onChange }: AdminMenuIconPickerProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminRoutes.d.ts

@@ -0,0 +1,5 @@
+import { AdminMenuEditor } from "../pages/AdminMenuEditor";
+import { AdminPreview } from "../pages/AdminPreview";
+/** Everything under `/admin`, in one module so `RestaurantSite` can load it on demand. */
+export declare function AdminLayout(): import("react").JSX.Element;
+export { AdminMenuEditor, AdminPreview };

package/dist/types/admin/AdminSectionEditor.d.ts

@@ -0,0 +1,20 @@
+import type { MenuCategory, MenuGroup, MenuItem } from "../menu/menuSchema";
+type AdminSectionEditorProps = {
+    category: MenuCategory;
+    groupLabel: string;
+    groups: readonly MenuGroup[];
+    isFirstSection: boolean;
+    isLastSection: boolean;
+    isReordering: boolean;
+    items: readonly MenuItem[];
+    uploadingItemIds: ReadonlySet<string>;
+    onAddItem: () => void;
+    onDeleteSection: () => void;
+    onEditItemDetails: (itemId: string) => void;
+    onFocusSection: () => void;
+    onMoveSection: (direction: -1 | 1) => void;
+    onToggleReorderItems: () => void;
+    onUpdateCategory: (patch: Partial<MenuCategory>) => void;
+};
+export declare function AdminSectionEditor({ category, groupLabel, groups, isFirstSection, isLastSection, isReordering, items, uploadingItemIds, onAddItem, onDeleteSection, onEditItemDetails, onFocusSection, onMoveSection, onToggleReorderItems, onUpdateCategory, }: AdminSectionEditorProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/AdminTestimonialsPanel.d.ts

@@ -0,0 +1,7 @@
+import type { DynamicMenu } from "../menu/menuSchema";
+type AdminTestimonialsPanelProps = {
+    readonly menu: DynamicMenu;
+    readonly applyMenuMutation: (mutateMenu: (menu: DynamicMenu) => DynamicMenu) => void;
+};
+export declare function AdminTestimonialsPanel({ menu, applyMenuMutation }: AdminTestimonialsPanelProps): import("react").JSX.Element;
+export {};

package/dist/types/admin/adminDraftContext.d.ts

@@ -0,0 +1,2 @@
+import type { AdminMenuDraft } from "./useAdminMenuDraft";
+export declare const AdminDraftContext: import("react").Context<AdminMenuDraft | null>;

package/dist/types/admin/adminEditorUtils.d.ts

@@ -0,0 +1,22 @@
+import type { MenuItem } from "../menu/menuSchema";
+export { formatPrice } from "../menu/priceFormat";
+export { imageSrc as imageSource } from "../menu-browser/menuItemDisplay";
+export type SortableData = {
+    kind: "group";
+    id: string;
+} | {
+    kind: "item";
+    id: string;
+    categoryId: string;
+};
+export type SortableEntity = {
+    readonly id?: string | number;
+    readonly data?: unknown;
+    readonly index?: number;
+} | null;
+export declare function slugify(value: string): string;
+export declare function uniqueId(prefix: string, label: string): string;
+export declare function emptyItem(categoryId: string): MenuItem;
+export declare function getApiErrorMessage(error: unknown): string;
+export declare function isLikelyAuthError(error: unknown): boolean;
+export declare function sortableDataFromEntity(entity: SortableEntity): SortableData | null;

package/dist/types/admin/adminMenuCommands.d.ts

@@ -0,0 +1,73 @@
+import type { DynamicMenu, MenuCategory, MenuGroup, MenuItem, MenuSize } from "../menu/menuSchema";
+export type AdminMenuCommand = {
+    readonly type: "add-group";
+    readonly group: MenuGroup;
+} | {
+    readonly type: "update-group";
+    readonly groupId: string;
+    readonly patch: Partial<MenuGroup>;
+} | {
+    readonly type: "delete-group";
+    readonly groupId: string;
+} | {
+    readonly type: "move-group";
+    readonly groupId: string;
+    readonly direction: -1 | 1;
+} | {
+    readonly type: "reorder-groups";
+    readonly orderedGroupIds: readonly string[];
+} | {
+    readonly type: "add-section";
+    readonly category: MenuCategory;
+} | {
+    readonly type: "update-section";
+    readonly categoryId: string;
+    readonly patch: Partial<MenuCategory>;
+} | {
+    readonly type: "delete-section";
+    readonly categoryId: string;
+} | {
+    readonly type: "move-section";
+    readonly categoryId: string;
+    readonly direction: -1 | 1;
+} | {
+    readonly type: "add-item";
+    readonly item: MenuItem;
+} | {
+    readonly type: "update-item";
+    readonly itemId: string;
+    readonly patch: Partial<MenuItem>;
+} | {
+    readonly type: "delete-item";
+    readonly itemId: string;
+} | {
+    readonly type: "move-item-before";
+    readonly sourceItemId: string;
+    readonly targetItemId: string;
+} | {
+    readonly type: "add-size";
+    readonly itemId: string;
+    readonly size: MenuSize;
+} | {
+    readonly type: "update-size";
+    readonly itemId: string;
+    readonly sizeId: string;
+    readonly patch: Partial<MenuSize>;
+} | {
+    readonly type: "delete-size";
+    readonly itemId: string;
+    readonly sizeId: string;
+};
+export type AdminMenuCommandRejection = "pinned-group" | "group-has-sections" | "section-has-items";
+export type AdminMenuCommandResult = {
+    readonly status: "applied";
+    readonly menu: DynamicMenu;
+} | {
+    readonly status: "rejected";
+    readonly reason: AdminMenuCommandRejection;
+};
+export declare function createMenuGroupDraft(menu: DynamicMenu): MenuGroup;
+export declare function createMenuCategoryDraft(menu: DynamicMenu, groupId: string): MenuCategory;
+export declare function createMenuSizeDraft(item: MenuItem): MenuSize;
+export declare function getAdminMenuCommandRejection(menu: DynamicMenu, command: AdminMenuCommand): AdminMenuCommandRejection | null;
+export declare function applyAdminMenuCommand(menu: DynamicMenu, command: AdminMenuCommand): AdminMenuCommandResult;

package/dist/types/admin/useAdminDraft.d.ts

@@ -0,0 +1,5 @@
+import { type AdminMenuDraft, type UseAdminMenuDraftOptions } from "./useAdminMenuDraft";
+/** The draft from the nearest provider, or null when no provider is mounted. */
+export declare function useAdminDraftContext(): AdminMenuDraft | null;
+/** Prefers a provider-owned draft; falls back to a local one so the editor works standalone. */
+export declare function useAdminDraft(options?: UseAdminMenuDraftOptions): AdminMenuDraft;

package/dist/types/admin/useAdminMenuDraft.d.ts

@@ -0,0 +1,41 @@
+import type { AdminSession, MenuApiClient, MenuBackup, RestoreDraftSource } from "../menu/menuApi";
+import type { DynamicMenu, MenuItem } from "../menu/menuSchema";
+import { type AdminMenuCommand, type AdminMenuCommandRejection } from "./adminMenuCommands";
+export type UseAdminMenuDraftOptions = {
+    readonly api?: MenuApiClient;
+    readonly initialMenu?: DynamicMenu;
+    /** When false the hook is inert: no remote load, no beforeunload guard. Used when a provider above already owns the draft. */
+    readonly enabled?: boolean;
+};
+export type AdminMenuDraft = {
+    readonly draftMenu: DynamicMenu;
+    readonly hasUnsavedChanges: boolean;
+    readonly isLoadingDraft: boolean;
+    readonly isSavingDraft: boolean;
+    readonly isPublishingDraft: boolean;
+    readonly isBusy: boolean;
+    readonly authErrorMessage: string;
+    /** null until the API has answered /api/admin/session (or when it is unreachable). */
+    readonly authSession: AdminSession | null;
+    readonly isSigningIn: boolean;
+    readonly loadRemoteDraft: () => void;
+    /** Cloudflare Access strategy: full-page redirect through the Access login. */
+    readonly signIn: () => void;
+    /** Password strategy: exchanges the password for a session cookie, then reloads the draft. */
+    readonly signInWithPassword: (password: string) => Promise<void>;
+    readonly signOut: () => Promise<void>;
+    readonly saveDraft: () => Promise<void>;
+    readonly publishDraft: () => Promise<void>;
+    /** Drops unsaved edits by reloading the remote draft. */
+    readonly discardChanges: () => void;
+    /** Overwrites the remote draft with the published menu or a backup, then reloads it. */
+    readonly restoreDraft: (source: RestoreDraftSource) => Promise<void>;
+    readonly listBackups: () => Promise<readonly MenuBackup[]>;
+    readonly isRestoring: boolean;
+    readonly applyMenuMutation: (mutateMenu: (menu: DynamicMenu) => DynamicMenu) => void;
+    readonly applyCommand: (command: AdminMenuCommand) => AdminMenuCommandRejection | null;
+    readonly uploadingItemIds: ReadonlySet<string>;
+    readonly uploadItemImage: (item: MenuItem, file: File) => Promise<void>;
+    readonly removeItemImage: (item: MenuItem) => Promise<void>;
+};
+export declare function useAdminMenuDraft(options?: UseAdminMenuDraftOptions): AdminMenuDraft;

package/dist/types/cart/CartDrawer.d.ts

@@ -0,0 +1,7 @@
+import type { CartItem } from "./cartTypes";
+type CartDrawerProps = {
+    /** When provided, each line gets an Edit action that hands the line back for editing. */
+    onEditItem?: (item: CartItem) => void;
+};
+export declare function CartDrawer({ onEditItem }?: CartDrawerProps): import("react").JSX.Element;
+export {};

package/dist/types/cart/CartProvider.d.ts

@@ -0,0 +1,4 @@
+import { type ReactNode } from "react";
+export declare function CartProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/cart/cartContext.d.ts

@@ -0,0 +1,2 @@
+import type { CartContextValue } from "./cartTypes";
+export declare const CartContext: import("react").Context<CartContextValue | null>;

package/dist/types/cart/cartOrder.d.ts

@@ -0,0 +1,9 @@
+import type { CartItem, CartSelection } from "./cartTypes";
+export type CartOrderConfig = {
+    readonly whatsappNumber: string;
+    readonly orderGreeting: string;
+};
+export declare function cartSelectionKey(selection: CartSelection): string;
+export declare function formatVariationName(name?: string): string;
+export declare function buildWhatsAppMessage(items: readonly CartItem[], orderNote: string, config: CartOrderConfig): string;
+export declare function buildWhatsAppOrderUrl(items: readonly CartItem[], orderNote: string, config: CartOrderConfig): string;

package/dist/types/cart/cartReducer.d.ts

@@ -0,0 +1,36 @@
+import type { CartSelection, CartState } from "./cartTypes";
+export type CartAction = {
+    type: "add";
+    selection: CartSelection;
+    quantity?: number;
+    note?: string;
+}
+/** `note` omitted keeps the line's note; `null` or a blank string clears it. */
+ | {
+    type: "replace";
+    key: string;
+    selection: CartSelection;
+    quantity?: number;
+    note?: string | null;
+} | {
+    type: "decrease";
+    key: string;
+} | {
+    type: "remove";
+    key: string;
+} | {
+    type: "set-note";
+    key: string;
+    note: string;
+} | {
+    type: "set-order-note";
+    note: string;
+} | {
+    type: "open";
+} | {
+    type: "close";
+} | {
+    type: "clear";
+};
+export declare const initialCartState: CartState;
+export declare function cartReducer(state: CartState, action: CartAction): CartState;

package/dist/types/cart/cartTypes.d.ts

@@ -0,0 +1,37 @@
+export type CartSelection = {
+    readonly itemId: string;
+    readonly itemName: string;
+    readonly variationId?: string;
+    readonly variationName?: string;
+    readonly removedIngredients?: readonly string[];
+};
+export type CartItem = CartSelection & {
+    readonly key: string;
+    readonly quantity: number;
+    readonly note?: string;
+};
+export type CartState = {
+    readonly items: readonly CartItem[];
+    readonly isOpen: boolean;
+    readonly orderNote: string;
+};
+export type CartContextValue = CartState & {
+    readonly itemCount: number;
+    readonly addItem: (selection: CartSelection, options?: {
+        quantity?: number;
+        note?: string;
+    }) => void;
+    /** `note: null` (or "") clears the note when the edit merges into an existing line; omitting it keeps the line's note. */
+    readonly replaceItem: (key: string, selection: CartSelection, options?: {
+        quantity?: number;
+        note?: string | null;
+    }) => void;
+    readonly decreaseItem: (key: string) => void;
+    readonly removeItem: (key: string) => void;
+    readonly getQuantity: (selection: CartSelection) => number;
+    readonly setItemNote: (key: string, note: string) => void;
+    readonly setOrderNote: (note: string) => void;
+    readonly openCart: () => void;
+    readonly closeCart: () => void;
+    readonly clearCart: () => void;
+};

package/dist/types/cart/useCart.d.ts

@@ -0,0 +1 @@
+export declare function useCart(): import("./cartTypes").CartContextValue;

package/dist/types/components/Brand.d.ts

@@ -0,0 +1,5 @@
+type BrandProps = {
+    className?: string;
+};
+export declare function Brand({ className }: BrandProps): import("react").JSX.Element;
+export {};

package/dist/types/components/Footer.d.ts

@@ -0,0 +1 @@
+export declare function Footer(): import("react").JSX.Element;

package/dist/types/components/Header.d.ts

@@ -0,0 +1 @@
+export declare function Header(): import("react").JSX.Element;

package/dist/types/components/Hero.d.ts

@@ -0,0 +1 @@
+export declare function Hero(): import("react").JSX.Element;

package/dist/types/components/InstagramIcon.d.ts

@@ -0,0 +1,6 @@
+type InstagramIconProps = {
+    className?: string;
+};
+/** Outline glyph matching lucide's stroke style; lucide 1.x no longer ships brand icons. */
+export declare function InstagramIcon({ className }: InstagramIconProps): import("react").JSX.Element;
+export {};

package/dist/types/components/LocationsSection.d.ts

@@ -0,0 +1 @@
+export declare function LocationsSection(): import("react").JSX.Element;

package/dist/types/components/Marquee.d.ts

@@ -0,0 +1 @@
+export declare function Marquee(): import("react").JSX.Element;

package/dist/types/components/OrderIcon.d.ts

@@ -0,0 +1,4 @@
+/** Icon for an order button: WhatsApp glyph, the ordering app's logo, or a plain outbound arrow. */
+export declare function OrderIcon({ className }: {
+    readonly className?: string;
+}): import("react").JSX.Element;

package/dist/types/components/RatingSection.d.ts

@@ -0,0 +1 @@
+export declare function RatingSection(): import("react").JSX.Element;

package/dist/types/components/TestimonialsSection.d.ts

@@ -0,0 +1,2 @@
+/** Owner-curated customer reviews. Renders nothing until the menu has a visible testimonial. */
+export declare function TestimonialsSection(): import("react").JSX.Element | null;

package/dist/types/components/WhatsAppIcon.d.ts

@@ -0,0 +1,5 @@
+type WhatsAppIconProps = {
+    className?: string;
+};
+export declare function WhatsAppIcon({ className }: WhatsAppIconProps): import("react").JSX.Element;
+export {};

package/dist/types/config/RestaurantKitProvider.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from "react";
+import { type MenuApiClient } from "../menu/menuApi";
+import type { DynamicMenu } from "../menu/menuSchema";
+import { type RestaurantKitApiOptions } from "./siteConfigContext";
+import type { RestaurantSiteConfig } from "./siteTypes";
+type RestaurantKitProviderProps = {
+    readonly config: RestaurantSiteConfig;
+    readonly seedMenu: DynamicMenu;
+    /**
+     * API endpoints, typically fed from the site's own Vite env:
+     * `{ baseUrl: import.meta.env.VITE_MENU_API_BASE_URL, publicMenuUrl: import.meta.env.VITE_MENU_API_URL }`.
+     */
+    readonly api?: RestaurantKitApiOptions;
+    /** Override the API client entirely (tests, custom transports). */
+    readonly menuApi?: MenuApiClient;
+    readonly children: ReactNode;
+};
+/**
+ * Single source of restaurant identity. Everything that needs the config, seed menu, API
+ * client, or draft key reads it from here — there is no module-scope fallback, so two
+ * providers on one page can never bleed into each other.
+ */
+export declare function RestaurantKitProvider({ config, seedMenu, api, menuApi, children }: RestaurantKitProviderProps): import("react").JSX.Element;
+export {};

package/dist/types/config/siteConfigContext.d.ts

@@ -0,0 +1,28 @@
+import type { MenuApiClient } from "../menu/menuApi";
+import type { DynamicMenu } from "../menu/menuSchema";
+import type { RestaurantSiteConfig } from "./siteTypes";
+export type RestaurantKitApiOptions = {
+    /** Origin of the menu Worker for admin calls. Empty = same origin. */
+    readonly baseUrl?: string;
+    /** URL of the published menu JSON. Defaults to `<baseUrl>/api/menu`. */
+    readonly publicMenuUrl?: string;
+    /** "auto" (default): browser-local adapter on localhost unless `baseUrl` is set. */
+    readonly mode?: "auto" | "local" | "remote";
+};
+export type RestaurantKitValue = {
+    readonly config: RestaurantSiteConfig;
+    readonly seedMenu: DynamicMenu;
+    /** Remote client, or the browser-local adapter (see `isLocalApi`). Built once per provider. */
+    readonly menuApi: MenuApiClient;
+    /** True when drafts live in this browser's localStorage instead of the Worker. */
+    readonly isLocalApi: boolean;
+    /** Where the public site fetches the published menu from. */
+    readonly publicMenuUrl: string;
+    /** localStorage key for the local-dev draft, namespaced by restaurant id. */
+    readonly draftStorageKey: string;
+};
+export declare const SiteConfigContext: import("react").Context<RestaurantKitValue | null>;
+export declare function useRestaurantKit(): RestaurantKitValue;
+export declare function useSiteConfig(): RestaurantSiteConfig;
+export declare function useSeedMenu(): DynamicMenu;
+export declare function useMenuApi(): MenuApiClient;

package/dist/types/config/siteTypes.d.ts

@@ -0,0 +1,50 @@
+/**
+ * How customers order.
+ * - `whatsapp` (default): cart + "Add to cart" on every item, order sent as a WhatsApp message.
+ * - `external`: cart off. The menu is browse-only and every order button links to `url`
+ *   (Toters, Talabat, the restaurant's own app…).
+ */
+export type OrderingConfig = {
+    readonly mode: "whatsapp";
+} | {
+    readonly mode: "external";
+    readonly url: string;
+    /** Full button text, e.g. "Order on Toters". */
+    readonly label: string;
+    /** Header pill text. Defaults to "Order". */
+    readonly shortLabel?: string;
+    /** Logo of the ordering app, shown inside the buttons. Falls back to an arrow. */
+    readonly iconSrc?: string;
+};
+export type RestaurantSiteConfig = {
+    readonly restaurantId: string;
+    readonly brandName: string;
+    readonly tagline: string;
+    readonly locationLabel: string;
+    readonly address: string;
+    readonly phoneDisplay: string;
+    readonly phoneHref: string;
+    /** International form, no `+`. Empty string hides every WhatsApp link. */
+    readonly whatsappNumber: string;
+    readonly instagramHandle: string;
+    readonly instagramUrl: string;
+    readonly mapsUrl: string;
+    readonly logoSrc: string;
+    readonly rating: string;
+    readonly ratingLabel: string;
+    readonly reviewCount: string;
+    readonly cuisineSummary: string;
+    readonly localBadge: string;
+    readonly orderGreeting: string;
+    readonly highlights: readonly string[];
+    readonly heroEyebrow: string;
+    readonly heroSubline: string;
+    readonly ratingHeadline: string;
+    readonly ratingCopy: string;
+    readonly footerNote: string;
+    /** Optional copy for the Testimonials section (shown only when the menu has visible testimonials). */
+    readonly testimonialsEyebrow?: string;
+    readonly testimonialsHeadline?: string;
+    /** Optional. Omit for the default WhatsApp cart. */
+    readonly ordering?: OrderingConfig;
+};