@fayz-ai/plugin-menu 0.2.0

package/src/data/mock.ts

@@ -0,0 +1,289 @@
+import type { MenuDataProvider } from './types'
+import type {
+  MenuCategory, MenuItem, ModifierGroup,
+  CreateMenuItemInput, UpdateMenuItemInput, CreateMenuCategoryInput,
+  MenuItemQuery, PaginatedResult, MenuSummary,
+} from '../types'
+
+let uid = 0
+function nextId(prefix: string) { return prefix + '-' + (++uid) }
+function now(): string { return new Date().toISOString() }
+
+function paginate<T>(items: T[], page?: number, pageSize?: number): PaginatedResult<T> {
+  const p = page ?? 1
+  const ps = pageSize ?? 50
+  const start = (p - 1) * ps
+  return { data: items.slice(start, start + ps), total: items.length }
+}
+
+function seedCategories(): MenuCategory[] {
+  const t = 'mock-tenant'
+  const ts = now()
+  return [
+    { id: nextId('cat'), name: 'Burgers', icon: '🍔', color: '#f59e0b', sortOrder: 0, isActive: true, itemCount: 3, tenantId: t, createdAt: ts, updatedAt: ts },
+    { id: nextId('cat'), name: 'Sides', icon: '🍟', color: '#22c55e', sortOrder: 1, isActive: true, itemCount: 3, tenantId: t, createdAt: ts, updatedAt: ts },
+    { id: nextId('cat'), name: 'Drinks', icon: '🥤', color: '#3b82f6', sortOrder: 2, isActive: true, itemCount: 4, tenantId: t, createdAt: ts, updatedAt: ts },
+    { id: nextId('cat'), name: 'Desserts', icon: '🍰', color: '#ec4899', sortOrder: 3, isActive: true, itemCount: 2, tenantId: t, createdAt: ts, updatedAt: ts },
+    { id: nextId('cat'), name: 'Combos', icon: '⭐', color: '#8b5cf6', sortOrder: 4, isActive: true, itemCount: 0, tenantId: t, createdAt: ts, updatedAt: ts },
+  ]
+}
+
+function seedItems(categories: MenuCategory[]): MenuItem[] {
+  const t = 'mock-tenant'
+  const ts = now()
+  const [burgers, sides, drinks, desserts] = categories.map((c) => c.id)
+
+  const item = (
+    name: string, price: number, categoryId: string, categoryName: string,
+    opts: Partial<MenuItem> = {},
+  ): MenuItem => ({
+    id: nextId('mi'),
+    name,
+    price,
+    currency: 'BRL',
+    categoryId,
+    categoryName,
+    status: 'available',
+    isActive: true,
+    availableForPos: true,
+    availableForDelivery: true,
+    sortOrder: 0,
+    isFeatured: false,
+    tenantId: t,
+    createdAt: ts,
+    updatedAt: ts,
+    ...opts,
+  })
+
+  let order = 0
+  return [
+    item('Classic Burger', 32, burgers, 'Burgers', { prepTimeMinutes: 12, sortOrder: order++, isFeatured: true }),
+    item('Cheese Burger', 36, burgers, 'Burgers', { prepTimeMinutes: 12, sortOrder: order++ }),
+    item('BBQ Bacon', 42, burgers, 'Burgers', { prepTimeMinutes: 15, sortOrder: order++, isFeatured: true }),
+    item('Fries', 15, sides, 'Sides', { prepTimeMinutes: 8, sortOrder: order++ }),
+    item('Onion Rings', 18, sides, 'Sides', { prepTimeMinutes: 8, sortOrder: order++ }),
+    item('Coleslaw', 12, sides, 'Sides', { prepTimeMinutes: 2, sortOrder: order++, availableForDelivery: false }),
+    item('Soda', 8, drinks, 'Drinks', { prepTimeMinutes: 1, sortOrder: order++ }),
+    item('Juice', 12, drinks, 'Drinks', { prepTimeMinutes: 3, sortOrder: order++ }),
+    item('Water', 5, drinks, 'Drinks', { prepTimeMinutes: 0, sortOrder: order++ }),
+    item('Milkshake', 16, drinks, 'Drinks', { prepTimeMinutes: 5, sortOrder: order++, isFeatured: true }),
+    item('Brownie', 14, desserts, 'Desserts', { prepTimeMinutes: 1, sortOrder: order++ }),
+    item('Ice Cream', 12, desserts, 'Desserts', { prepTimeMinutes: 2, sortOrder: order++, availableForDelivery: false }),
+  ]
+}
+
+function seedModifierGroups(): ModifierGroup[] {
+  const t = 'mock-tenant'
+  const ts = now()
+
+  const g1Id = nextId('mg')
+  const g2Id = nextId('mg')
+
+  return [
+    {
+      id: g1Id, name: 'Extra Toppings', minSelections: 0, maxSelections: 3, isRequired: false, sortOrder: 0, tenantId: t, createdAt: ts,
+      items: [
+        { id: nextId('mod'), groupId: g1Id, name: 'Extra Cheese', priceAdjustment: 5, isActive: true, sortOrder: 0 },
+        { id: nextId('mod'), groupId: g1Id, name: 'Bacon', priceAdjustment: 7, isActive: true, sortOrder: 1 },
+        { id: nextId('mod'), groupId: g1Id, name: 'Jalapeños', priceAdjustment: 4, isActive: true, sortOrder: 2 },
+      ],
+    },
+    {
+      id: g2Id, name: 'Drink Size', minSelections: 1, maxSelections: 1, isRequired: true, sortOrder: 1, tenantId: t, createdAt: ts,
+      items: [
+        { id: nextId('mod'), groupId: g2Id, name: 'Small', priceAdjustment: 0, isActive: true, sortOrder: 0 },
+        { id: nextId('mod'), groupId: g2Id, name: 'Medium', priceAdjustment: 3, isActive: true, sortOrder: 1 },
+        { id: nextId('mod'), groupId: g2Id, name: 'Large', priceAdjustment: 5, isActive: true, sortOrder: 2 },
+      ],
+    },
+  ]
+}
+
+export function createMockMenuProvider(): MenuDataProvider {
+  const tenantId = 'mock-tenant'
+  const categories = seedCategories()
+  const items = seedItems(categories)
+  const modifierGroups = seedModifierGroups()
+
+  return {
+    async getCategories(): Promise<MenuCategory[]> {
+      return [...categories].sort((a, b) => a.sortOrder - b.sortOrder)
+    },
+
+    async getCategoryById(id: string): Promise<MenuCategory | null> {
+      return categories.find((c) => c.id === id) ?? null
+    },
+
+    async createCategory(input: CreateMenuCategoryInput): Promise<MenuCategory> {
+      const cat: MenuCategory = {
+        id: nextId('cat'),
+        name: input.name,
+        parentId: input.parentId,
+        icon: input.icon,
+        color: input.color,
+        sortOrder: input.sortOrder ?? categories.length,
+        isActive: true,
+        itemCount: 0,
+        tenantId,
+        createdAt: now(),
+        updatedAt: now(),
+      }
+      categories.push(cat)
+      return cat
+    },
+
+    async updateCategory(id: string, data: Partial<MenuCategory>): Promise<MenuCategory> {
+      const cat = categories.find((c) => c.id === id)
+      if (!cat) throw new Error(`Category ${id} not found`)
+      Object.assign(cat, data, { updatedAt: now() })
+      return cat
+    },
+
+    async deleteCategory(id: string): Promise<void> {
+      const idx = categories.findIndex((c) => c.id === id)
+      if (idx >= 0) categories.splice(idx, 1)
+    },
+
+    async reorderCategories(ids: string[]): Promise<void> {
+      ids.forEach((id, i) => {
+        const cat = categories.find((c) => c.id === id)
+        if (cat) cat.sortOrder = i
+      })
+    },
+
+    async getMenuItems(query: MenuItemQuery): Promise<PaginatedResult<MenuItem>> {
+      let results = [...items]
+      if (query.categoryId) results = results.filter((i) => i.categoryId === query.categoryId)
+      if (query.status) {
+        const statuses = Array.isArray(query.status) ? query.status : [query.status]
+        results = results.filter((i) => statuses.includes(i.status))
+      }
+      if (query.availableForPos !== undefined) results = results.filter((i) => i.availableForPos === query.availableForPos)
+      if (query.availableForDelivery !== undefined) results = results.filter((i) => i.availableForDelivery === query.availableForDelivery)
+      if (query.isFeatured !== undefined) results = results.filter((i) => i.isFeatured === query.isFeatured)
+      if (query.search) {
+        const s = query.search.toLowerCase()
+        results = results.filter((i) => i.name.toLowerCase().includes(s) || i.description?.toLowerCase().includes(s))
+      }
+      results.sort((a, b) => a.sortOrder - b.sortOrder)
+      return paginate(results, query.page, query.pageSize)
+    },
+
+    async getMenuItemById(id: string): Promise<MenuItem | null> {
+      return items.find((i) => i.id === id) ?? null
+    },
+
+    async createMenuItem(input: CreateMenuItemInput): Promise<MenuItem> {
+      const cat = input.categoryId ? categories.find((c) => c.id === input.categoryId) : undefined
+      const item: MenuItem = {
+        id: nextId('mi'),
+        name: input.name,
+        description: input.description,
+        price: input.price,
+        cost: input.cost,
+        currency: 'BRL',
+        imageUrl: input.imageUrl,
+        categoryId: input.categoryId,
+        categoryName: cat?.name,
+        status: input.status ?? 'available',
+        isActive: true,
+        prepTimeMinutes: input.prepTimeMinutes,
+        allergens: input.allergens,
+        dietaryTags: input.dietaryTags,
+        availableForPos: input.availableForPos ?? true,
+        availableForDelivery: input.availableForDelivery ?? true,
+        deliveryPrice: input.deliveryPrice,
+        sortOrder: items.length,
+        isFeatured: input.isFeatured ?? false,
+        modifierGroupIds: input.modifierGroupIds,
+        tenantId,
+        createdAt: now(),
+        updatedAt: now(),
+      }
+      items.push(item)
+      if (cat) cat.itemCount = (cat.itemCount ?? 0) + 1
+      return item
+    },
+
+    async updateMenuItem(id: string, data: UpdateMenuItemInput): Promise<MenuItem> {
+      const item = items.find((i) => i.id === id)
+      if (!item) throw new Error(`MenuItem ${id} not found`)
+      Object.assign(item, data, { updatedAt: now() })
+      return item
+    },
+
+    async deleteMenuItem(id: string): Promise<void> {
+      const idx = items.findIndex((i) => i.id === id)
+      if (idx >= 0) {
+        const [removed] = items.splice(idx, 1)
+        if (removed.categoryId) {
+          const cat = categories.find((c) => c.id === removed.categoryId)
+          if (cat && cat.itemCount) cat.itemCount--
+        }
+      }
+    },
+
+    async toggleAvailability(id: string, field: 'status' | 'availableForPos' | 'availableForDelivery', value: any): Promise<MenuItem> {
+      const item = items.find((i) => i.id === id)
+      if (!item) throw new Error(`MenuItem ${id} not found`)
+      ;(item as any)[field] = value
+      item.updatedAt = now()
+      return item
+    },
+
+    async reorderItems(categoryId: string, ids: string[]): Promise<void> {
+      ids.forEach((id, i) => {
+        const item = items.find((it) => it.id === id && it.categoryId === categoryId)
+        if (item) item.sortOrder = i
+      })
+    },
+
+    async getModifierGroups(): Promise<ModifierGroup[]> {
+      return [...modifierGroups].sort((a, b) => a.sortOrder - b.sortOrder)
+    },
+
+    async createModifierGroup(input: Partial<ModifierGroup>): Promise<ModifierGroup> {
+      const group: ModifierGroup = {
+        id: nextId('mg'),
+        name: input.name ?? '',
+        minSelections: input.minSelections ?? 0,
+        maxSelections: input.maxSelections ?? 1,
+        isRequired: input.isRequired ?? false,
+        sortOrder: input.sortOrder ?? modifierGroups.length,
+        items: input.items ?? [],
+        tenantId,
+        createdAt: now(),
+      }
+      modifierGroups.push(group)
+      return group
+    },
+
+    async updateModifierGroup(id: string, data: Partial<ModifierGroup>): Promise<ModifierGroup> {
+      const group = modifierGroups.find((g) => g.id === id)
+      if (!group) throw new Error(`ModifierGroup ${id} not found`)
+      Object.assign(group, data)
+      return group
+    },
+
+    async deleteModifierGroup(id: string): Promise<void> {
+      const idx = modifierGroups.findIndex((g) => g.id === id)
+      if (idx >= 0) modifierGroups.splice(idx, 1)
+    },
+
+    async getSummary(): Promise<MenuSummary> {
+      const available = items.filter((i) => i.status === 'available')
+      const soldOut = items.filter((i) => i.status === 'sold_out')
+      const hidden = items.filter((i) => i.status === 'hidden')
+      const prices = items.filter((i) => i.price > 0).map((i) => i.price)
+      return {
+        totalItems: items.length,
+        availableItems: available.length,
+        soldOutItems: soldOut.length,
+        hiddenItems: hidden.length,
+        categoryCount: categories.length,
+        averagePrice: prices.length ? prices.reduce((a, b) => a + b, 0) / prices.length : 0,
+        featuredCount: items.filter((i) => i.isFeatured).length,
+      }
+    },
+  }
+}

package/src/data/types.ts

@@ -0,0 +1,33 @@
+import type {
+  MenuCategory, MenuItem, ModifierGroup,
+  CreateMenuItemInput, UpdateMenuItemInput, CreateMenuCategoryInput,
+  MenuItemQuery, PaginatedResult, MenuSummary,
+} from '../types'
+
+export interface MenuDataProvider {
+  // Categories
+  getCategories(): Promise<MenuCategory[]>
+  getCategoryById(id: string): Promise<MenuCategory | null>
+  createCategory(input: CreateMenuCategoryInput): Promise<MenuCategory>
+  updateCategory(id: string, data: Partial<MenuCategory>): Promise<MenuCategory>
+  deleteCategory(id: string): Promise<void>
+  reorderCategories(ids: string[]): Promise<void>
+
+  // Menu Items
+  getMenuItems(query: MenuItemQuery): Promise<PaginatedResult<MenuItem>>
+  getMenuItemById(id: string): Promise<MenuItem | null>
+  createMenuItem(input: CreateMenuItemInput): Promise<MenuItem>
+  updateMenuItem(id: string, data: UpdateMenuItemInput): Promise<MenuItem>
+  deleteMenuItem(id: string): Promise<void>
+  toggleAvailability(id: string, field: 'status' | 'availableForPos' | 'availableForDelivery', value: any): Promise<MenuItem>
+  reorderItems(categoryId: string, ids: string[]): Promise<void>
+
+  // Modifier Groups
+  getModifierGroups(): Promise<ModifierGroup[]>
+  createModifierGroup(input: Partial<ModifierGroup>): Promise<ModifierGroup>
+  updateModifierGroup(id: string, data: Partial<ModifierGroup>): Promise<ModifierGroup>
+  deleteModifierGroup(id: string): Promise<void>
+
+  // Summary
+  getSummary(): Promise<MenuSummary>
+}

package/src/index.ts

@@ -0,0 +1,184 @@
+import React from 'react'
+import type { PluginManifest, PluginScope, VerticalId } from '@fayz-ai/core'
+import { registerTranslations } from '@fayz-ai/core'
+import type { EntityLookup } from '@fayz-ai/saas'
+import type { MenuDataProvider } from './data/types'
+import { createMockMenuProvider } from './data/mock'
+import { createMenuStore } from './store'
+import { menuRegistries } from './registries'
+import { menuLocales } from './locales'
+import { PluginSettingsPanel } from '@fayz-ai/saas'
+
+// Lazy import page to avoid circular dependency issues
+const MenuPage = React.lazy(() => import('./MenuPage').then((m) => ({ default: m.MenuPage })))
+
+// ---------------------------------------------------------------------------
+// Labels
+// ---------------------------------------------------------------------------
+
+export interface MenuPluginLabels {
+  pageTitle: string
+  menuManager: string
+  categories: string
+  newItem: string
+}
+
+const DEFAULT_LABELS: MenuPluginLabels = {
+  pageTitle: 'Menu',
+  menuManager: 'Menu Manager',
+  categories: 'Categories',
+  newItem: 'New Item',
+}
+
+// ---------------------------------------------------------------------------
+// Currency
+// ---------------------------------------------------------------------------
+
+const DEFAULT_CURRENCY = { code: 'BRL', locale: 'pt-BR', symbol: 'R$' }
+
+// ---------------------------------------------------------------------------
+// Options
+// ---------------------------------------------------------------------------
+
+export interface MenuPluginOptions {
+  modules?: {
+    modifiers?: boolean
+    deliveryPricing?: boolean
+  }
+  labels?: Partial<MenuPluginLabels>
+  currency?: { code?: string; locale?: string; symbol?: string }
+  navPosition?: number
+  navSection?: 'main' | 'secondary' | 'settings'
+  scope?: PluginScope
+  verticalId?: VerticalId
+  dataProvider?: MenuDataProvider
+  menuItemLookup?: EntityLookup
+}
+
+// ---------------------------------------------------------------------------
+// Config resolver
+// ---------------------------------------------------------------------------
+
+function resolveConfig(options?: MenuPluginOptions) {
+  return {
+    modules: {
+      modifiers: options?.modules?.modifiers !== false,
+      deliveryPricing: options?.modules?.deliveryPricing === true,
+    },
+    labels: { ...DEFAULT_LABELS, ...options?.labels },
+    currency: { ...DEFAULT_CURRENCY, ...options?.currency },
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Factory
+// ---------------------------------------------------------------------------
+
+export function createMenuPlugin(options?: MenuPluginOptions): PluginManifest {
+  const config = resolveConfig(options)
+  registerTranslations(menuLocales)
+  const provider = options?.dataProvider ?? createMockMenuProvider()
+  const store = createMenuStore(provider)
+
+  const PageComponent: React.FC<any> = () =>
+    React.createElement(React.Suspense, { fallback: null },
+      React.createElement(MenuPage, { config, provider, store, registries: menuRegistries })
+    )
+
+  return {
+    id: 'menu',
+    name: config.labels.pageTitle,
+    icon: 'UtensilsCrossed',
+    version: '1.0.0',
+    scope: options?.scope ?? 'vertical',
+    verticalId: options?.verticalId,
+    defaultEnabled: true,
+    dependencies: [],
+    navigation: [
+      {
+        section: options?.navSection ?? 'main',
+        position: options?.navPosition ?? 5,
+        label: config.labels.pageTitle,
+        route: '/menu',
+        icon: 'UtensilsCrossed',
+        permission: { feature: 'menu', action: 'read' as const },
+      },
+    ],
+    routes: [
+      {
+        path: '/menu',
+        component: PageComponent,
+        permission: { feature: 'menu', action: 'read' as const },
+      },
+    ],
+    widgets: [],
+    aiTools: [
+      {
+        id: 'menu.list-items',
+        name: 'listMenuItems',
+        description: 'Lists menu items, optionally filtered by category or status.',
+        icon: 'UtensilsCrossed',
+        mode: 'read' as const,
+        category: 'Menu',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            category: { type: 'string' as const, description: 'Category name to filter by' },
+            status: { type: 'string' as const, enum: ['available', 'sold_out', 'hidden'] },
+          },
+        },
+        suggestions: [
+          { label: 'What items are on the menu?' },
+          { label: 'Which items are sold out right now?' },
+        ],
+      },
+      {
+        id: 'menu.toggle-availability',
+        name: 'toggleMenuItemAvailability',
+        description: 'Marks a menu item as available or sold out.',
+        icon: 'ToggleLeft',
+        mode: 'persist' as const,
+        category: 'Menu',
+        parameters: {
+          type: 'object' as const,
+          properties: {
+            itemName: { type: 'string' as const, description: 'Menu item name' },
+            status: { type: 'string' as const, enum: ['available', 'sold_out'] },
+          },
+          required: ['itemName', 'status'],
+        },
+        permission: { feature: 'menu', action: 'edit' as const },
+      },
+    ],
+    registries: menuRegistries,
+    settings: [
+      {
+        id: 'menu',
+        label: config.labels.pageTitle,
+        icon: 'UtensilsCrossed',
+        component: (() => {
+          const MenuSettingsTab: React.ComponentType<unknown> = () =>
+            React.createElement(PluginSettingsPanel, {
+              title: 'Menu Settings',
+              subtitle: 'Categories, allergens, and modifiers',
+              registries: menuRegistries,
+              routeBase: '/settings/menu',
+            })
+          MenuSettingsTab.displayName = 'MenuSettingsTab'
+          return MenuSettingsTab
+        })(),
+        order: 20,
+        permission: { feature: 'menu', action: 'read' as const },
+      },
+    ],
+    locales: menuLocales,
+  }
+}
+
+export type { MenuDataProvider } from './data/types'
+export { createFayzMenuProvider } from './data/fayz'
+export type { FayzMenuProviderOptions } from './data/fayz'
+export type { ResolvedMenuConfig } from './MenuContext'
+// Domain types — public so any host can implement a MenuDataProvider (e.g. an
+// app-local Supabase provider during plugin incubation).
+export type * from './types'

package/src/locales/en.ts

@@ -0,0 +1,64 @@
+export const en: Record<string, string> = {
+  'menu.title': 'Menu',
+  'menu.nav.manager': 'Menu',
+  'menu.nav.categories': 'Categories',
+  'menu.nav.items': 'Items',
+  'menu.nav.modifiers': 'Modifiers',
+  'menu.manager.title': 'Menu Manager',
+  'menu.manager.subtitle': 'Manage your menu items and categories',
+  'menu.manager.search': 'Search menu...',
+  'menu.manager.allCategories': 'All Categories',
+  'menu.manager.newItem': 'New Item',
+  'menu.manager.noItems': 'No menu items yet',
+  'menu.manager.noItemsDesc': 'Add your first menu item to get started',
+  'menu.manager.addFirst': 'Add first item',
+  'menu.manager.available': 'Available',
+  'menu.manager.soldOut': 'Sold Out',
+  'menu.manager.hidden': 'Hidden',
+  'menu.manager.pos': 'POS',
+  'menu.manager.delivery': 'Delivery',
+  'menu.manager.featured': 'Featured',
+  'menu.manager.prepTime': 'Prep time',
+  'menu.manager.min': 'min',
+  'menu.manager.addCategory': 'Add Category',
+  'menu.manager.addProduct': 'Add Product',
+  'menu.manager.item': 'Item',
+  'menu.manager.price': 'Price',
+  'menu.manager.deliveryPrice': 'Delivery $',
+  'menu.manager.itemsCount': '{{count}} items',
+  'menu.manager.noResults': 'No categories or items match your search.',
+  'menu.manager.noResultsDesc': 'Try a different search term or category filter.',
+  'menu.itemForm.newTitle': 'New Menu Item',
+  'menu.itemForm.editTitle': 'Edit Menu Item',
+  'menu.itemForm.name': 'Item name',
+  'menu.itemForm.description': 'Description',
+  'menu.itemForm.price': 'Price',
+  'menu.itemForm.cost': 'Cost',
+  'menu.itemForm.category': 'Category',
+  'menu.itemForm.prepTime': 'Prep time (min)',
+  'menu.itemForm.image': 'Image URL',
+  'menu.itemForm.allergens': 'Allergens',
+  'menu.itemForm.dietaryTags': 'Dietary tags',
+  'menu.itemForm.availableForPos': 'Available for POS',
+  'menu.itemForm.availableForDelivery': 'Available for Delivery',
+  'menu.itemForm.deliveryPrice': 'Delivery price',
+  'menu.itemForm.isFeatured': 'Featured item',
+  'menu.itemForm.save': 'Save',
+  'menu.itemForm.cancel': 'Cancel',
+  'menu.itemForm.saving': 'Saving...',
+  'menu.categories.title': 'Categories',
+  'menu.categories.newCategory': 'New Category',
+  'menu.categories.name': 'Category name',
+  'menu.settings.title': 'Menu Settings',
+  'menu.settings.general': 'General',
+  'menu.settings.taxRate': 'Default tax rate',
+  'menu.settings.currency': 'Currency',
+  'menu.form.categoryName': 'Category name',
+  'menu.form.itemName': 'Item name',
+  'menu.form.description': 'Description',
+  'menu.form.category': 'Category',
+  'menu.form.uncategorized': 'Uncategorized',
+  'menu.form.optional': 'optional',
+  'menu.form.save': 'Save',
+  'menu.form.cancel': 'Cancel',
+}

package/src/locales/index.ts

@@ -0,0 +1,4 @@
+import { en } from './en'
+import { ptBR } from './pt-BR'
+
+export const menuLocales: Record<string, Record<string, string>> = { en, 'pt-BR': ptBR }

package/src/locales/pt-BR.ts

@@ -0,0 +1,64 @@
+export const ptBR: Record<string, string> = {
+  'menu.title': 'Cardápio',
+  'menu.nav.manager': 'Cardápio',
+  'menu.nav.categories': 'Categorias',
+  'menu.nav.items': 'Itens',
+  'menu.nav.modifiers': 'Modificadores',
+  'menu.manager.title': 'Gerenciar Cardápio',
+  'menu.manager.subtitle': 'Gerencie itens e categorias do cardápio',
+  'menu.manager.search': 'Buscar no cardápio...',
+  'menu.manager.allCategories': 'Todas as Categorias',
+  'menu.manager.newItem': 'Novo Item',
+  'menu.manager.noItems': 'Nenhum item no cardápio',
+  'menu.manager.noItemsDesc': 'Adicione o primeiro item para começar',
+  'menu.manager.addFirst': 'Adicionar primeiro item',
+  'menu.manager.available': 'Disponível',
+  'menu.manager.soldOut': 'Esgotado',
+  'menu.manager.hidden': 'Oculto',
+  'menu.manager.pos': 'PDV',
+  'menu.manager.delivery': 'Delivery',
+  'menu.manager.featured': 'Destaque',
+  'menu.manager.prepTime': 'Tempo de preparo',
+  'menu.manager.min': 'min',
+  'menu.manager.addCategory': 'Adicionar Categoria',
+  'menu.manager.addProduct': 'Adicionar Produto',
+  'menu.manager.item': 'Item',
+  'menu.manager.price': 'Preço',
+  'menu.manager.deliveryPrice': 'Delivery R$',
+  'menu.manager.itemsCount': '{{count}} itens',
+  'menu.manager.noResults': 'Nenhuma categoria ou item encontrado.',
+  'menu.manager.noResultsDesc': 'Tente um termo diferente ou filtro de categoria.',
+  'menu.itemForm.newTitle': 'Novo Item do Cardápio',
+  'menu.itemForm.editTitle': 'Editar Item do Cardápio',
+  'menu.itemForm.name': 'Nome do item',
+  'menu.itemForm.description': 'Descrição',
+  'menu.itemForm.price': 'Preço',
+  'menu.itemForm.cost': 'Custo',
+  'menu.itemForm.category': 'Categoria',
+  'menu.itemForm.prepTime': 'Tempo de preparo (min)',
+  'menu.itemForm.image': 'URL da imagem',
+  'menu.itemForm.allergens': 'Alérgenos',
+  'menu.itemForm.dietaryTags': 'Tags dietéticas',
+  'menu.itemForm.availableForPos': 'Disponível no PDV',
+  'menu.itemForm.availableForDelivery': 'Disponível para Delivery',
+  'menu.itemForm.deliveryPrice': 'Preço delivery',
+  'menu.itemForm.isFeatured': 'Item em destaque',
+  'menu.itemForm.save': 'Salvar',
+  'menu.itemForm.cancel': 'Cancelar',
+  'menu.itemForm.saving': 'Salvando...',
+  'menu.categories.title': 'Categorias',
+  'menu.categories.newCategory': 'Nova Categoria',
+  'menu.categories.name': 'Nome da categoria',
+  'menu.settings.title': 'Configurações do Cardápio',
+  'menu.settings.general': 'Geral',
+  'menu.settings.taxRate': 'Taxa padrão',
+  'menu.settings.currency': 'Moeda',
+  'menu.form.categoryName': 'Nome da categoria',
+  'menu.form.itemName': 'Nome do item',
+  'menu.form.description': 'Descrição',
+  'menu.form.category': 'Categoria',
+  'menu.form.uncategorized': 'Sem categoria',
+  'menu.form.optional': 'opcional',
+  'menu.form.save': 'Salvar',
+  'menu.form.cancel': 'Cancelar',
+}