@spree/dashboard-core 1.0.0-rc.2 → 1.0.0-rc.4

package/src/lib/money.ts

@@ -0,0 +1,99 @@
+import { compareMoney, decimalPlaces, isDecimalString, sumMoney } from '@spree/admin-sdk'
+
+/** Whether an amount is a decimal string above zero. Blank or malformed is not. */
+export function isPositiveMoney(value: string | null | undefined): boolean {
+  return isDecimalString(value) && compareMoney(value, '0') > 0
+}
+
+/**
+ * Moves the decimal point of a decimal string by whole places, exactly, and
+ * writes the result without trailing zeros ("0.077" shifted by 2 is "7.7").
+ * Anything that is not a decimal string comes back unchanged.
+ */
+export function shiftDecimalPoint(value: string, places: number): string {
+  if (!isDecimalString(value)) return value
+
+  const negative = value.startsWith('-')
+  const [whole, fraction = ''] = (negative ? value.slice(1) : value).split('.')
+  let digits = whole + fraction
+  let point = whole.length + places
+  if (point < 0) {
+    digits = '0'.repeat(-point) + digits
+    point = 0
+  }
+  digits = digits.padEnd(point, '0')
+
+  const integer = digits.slice(0, point).replace(/^0+(?=\d)/, '') || '0'
+  const decimals = digits.slice(point).replace(/0+$/, '')
+  const text = decimals ? `${integer}.${decimals}` : integer
+  return negative && /[1-9]/.test(text) ? `-${text}` : text
+}
+
+/** A fraction rate ("0.23") as the percentage a merchant reads ("23"). Blank stays blank. */
+export function fractionToPercent(fraction: string | null | undefined): string {
+  return fraction == null || fraction === '' ? '' : shiftDecimalPoint(fraction, 2)
+}
+
+/** A typed percentage ("23") as the fraction rate the API stores ("0.23"). Blank stays blank. */
+export function percentToFraction(percent: string | null | undefined): string {
+  return percent == null || percent === '' ? '' : shiftDecimalPoint(percent.trim(), -2)
+}
+
+function scaled(value: string): { units: bigint; scale: number } {
+  const negative = value.startsWith('-')
+  const [whole, fraction = ''] = (negative ? value.slice(1) : value).split('.')
+  const units = BigInt(whole + fraction)
+  return { units: negative ? -units : units, scale: fraction.length }
+}
+
+/**
+ * numerator / denominator, where the numerator carries `scale` decimals,
+ * rounded half away from zero to the currency's decimals.
+ */
+function roundToCurrency(
+  numerator: bigint,
+  scale: number,
+  denominator: bigint,
+  currency: string,
+): string {
+  const places = decimalPlaces(currency)
+  const negative = numerator < 0n !== denominator < 0n
+  let dividend = numerator < 0n ? -numerator : numerator
+  let divisor = denominator < 0n ? -denominator : denominator
+  if (scale > places) divisor *= 10n ** BigInt(scale - places)
+  else dividend *= 10n ** BigInt(places - scale)
+
+  let units = dividend / divisor
+  if ((dividend % divisor) * 2n >= divisor) units += 1n
+
+  const text = shiftDecimalPoint((negative ? -units : units).toString(), -places)
+  return sumMoney([text], currency)
+}
+
+/**
+ * A percentage of an amount, exactly, rounded half away from zero to the
+ * currency's decimals ("10" percent of "19.99" USD is "2.00").
+ */
+export function percentOf(amount: string, percent: string, currency: string): string {
+  const left = scaled(amount)
+  const right = scaled(percent)
+  // The percentage is a hundredth, so the product carries two more places.
+  return roundToCurrency(left.units * right.units, left.scale + right.scale + 2, 1n, currency)
+}
+
+/**
+ * The share of an amount that `part` of `whole` units carries ("10.00" for 1
+ * of 3 is "3.33"), rounded half away from zero to the currency's decimals.
+ */
+export function prorateMoney(
+  amount: string,
+  part: number,
+  whole: number,
+  currency: string,
+): string {
+  if (!Number.isInteger(part) || !Number.isInteger(whole) || whole === 0) {
+    throw new Error(`Cannot prorate ${part} of ${whole}`)
+  }
+  const { units, scale } = scaled(amount)
+  return roundToCurrency(units * BigInt(part), scale, BigInt(whole), currency)
+}

package/src/{products → lib}/normalize-money.ts

@@ -4,8 +4,8 @@
 // dashboard converts here, in the browser, and never relies on the server to
 // parse comma-vs-period. See docs/plans/5.5-client-side-money-normalization.md.
 //
-// The locale is the currency's display locale (its market locale, e.g. EUR →
-// `de`), so the same locale drives both display formatting and this parse.
+// The locale is the admin's own (`useMoneyLocale`), the same one the field is
+// displayed in, so a value reads back exactly as it was shown.
 
 /**
  * Derives a locale's decimal and group separators via `Intl`. `fr` groups with

package/src/lib/permissions.ts

@@ -20,6 +20,7 @@ export const Subject = {
   CustomerGroup: 'customer_group',
   AdminUser: 'admin_user',
   ApiKey: 'api_key',
+  OauthApplication: 'oauth_application',
   AllowedOrigin: 'allowed_origin',
   Store: 'store',
   // The store's packaging vocabulary: the box it ships parcels in, and the
@@ -45,6 +46,7 @@ export const Subject = {
   ClaimReason: 'claim_reason',
   RefundReason: 'refund_reason',
   OrderCancellationReason: 'order_cancellation_reason',
+  TaxExemptionReason: 'tax_exemption_reason',
   CustomFieldDefinition: 'custom_field_definition',
   Integration: 'integration',
   PaymentMethod: 'payment_method',

package/src/lib/return-refunds.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it } from 'vitest'
+import { paidForUnits, returnOwesNothing, returnRefundSummary } from './return-refunds'
+
+const figures = {
+  status: 'received',
+  refund_total: '20.00',
+  refunded_total: '0.00',
+}
+
+describe('returnRefundSummary', () => {
+  it('reports what is owed until money goes back', () => {
+    expect(returnRefundSummary(figures, 'USD', 'en')).toEqual({ kind: 'owed', amount: '$20.00' })
+  })
+
+  it('names the full amount when less went back than was owed', () => {
+    expect(
+      returnRefundSummary(
+        {
+          ...figures,
+          status: 'refunded',
+          refunded_total: '15.00',
+        },
+        'USD',
+        'en',
+      ),
+    ).toEqual({ kind: 'refunded_short', amount: '$15.00', total: '$20.00' })
+  })
+
+  it('reports a full refund', () => {
+    expect(
+      returnRefundSummary(
+        {
+          ...figures,
+          status: 'refunded',
+          refunded_total: '20.00',
+        },
+        'USD',
+        'en',
+      ),
+    ).toEqual({ kind: 'refunded', amount: '$20.00' })
+  })
+})
+
+describe('returnOwesNothing', () => {
+  it('is true only for a zero amount', () => {
+    expect(returnOwesNothing('0.00')).toBe(true)
+    expect(returnOwesNothing('0.01')).toBe(false)
+  })
+})
+
+describe('paidForUnits', () => {
+  it('shares the paid amount and tax across the chosen units', () => {
+    const line = { quantity: 3, discounted_amount: '9.00', additional_tax_total: '1.00' }
+    expect(paidForUnits(line, 1, 'USD')).toBe('3.33')
+    expect(paidForUnits(line, 3, 'USD')).toBe('10.00')
+  })
+
+  it('is blank when nothing is chosen or the amount is unknown', () => {
+    expect(paidForUnits({ quantity: 2, discounted_amount: '5.00' }, 0, 'USD')).toBe('')
+    expect(paidForUnits({ quantity: 2, discounted_amount: null }, 1, 'USD')).toBe('')
+  })
+})

package/src/lib/return-refunds.ts

@@ -0,0 +1,70 @@
+import { compareMoney, isDecimalString, isZeroMoney, sumMoney } from '@spree/admin-sdk'
+import { formatMoney } from './formatters'
+import { prorateMoney } from './money'
+
+/** True when a received return is owed nothing, so completing it moves no money. */
+export function returnOwesNothing(refundableTotal: string): boolean {
+  return isZeroMoney(refundableTotal)
+}
+
+export type ReturnRefundFigures = {
+  status: string
+  refund_total: string
+  refunded_total: string
+}
+
+/**
+ * What a return's card reports: what it is owed until money goes back, then
+ * what actually went back — which a merchant keeping a restocking fee makes
+ * less than it was owed, so that case also names the full amount. Money that
+ * went back counts even before the return is marked refunded: a refund that
+ * succeeded on one payment and was declined on the next leaves it received.
+ *
+ * A return carries no currency of its own, so the caller passes its order's.
+ * Without one the amounts come back as the API wrote them.
+ */
+export function returnRefundSummary(
+  returnRecord: ReturnRefundFigures,
+  currency?: string,
+  locale?: string,
+):
+  | { kind: 'owed'; amount: string }
+  | { kind: 'refunded'; amount: string }
+  | { kind: 'refunded_short'; amount: string; total: string } {
+  const format = (amount: string) => (currency ? formatMoney(amount, currency, locale) : amount)
+
+  if (returnRecord.status !== 'refunded' && isZeroMoney(returnRecord.refunded_total)) {
+    return { kind: 'owed', amount: format(returnRecord.refund_total) }
+  }
+
+  if (compareMoney(returnRecord.refunded_total || '0', returnRecord.refund_total || '0') < 0) {
+    return {
+      kind: 'refunded_short',
+      amount: format(returnRecord.refunded_total),
+      total: format(returnRecord.refund_total),
+    }
+  }
+
+  return { kind: 'refunded', amount: format(returnRecord.refunded_total) }
+}
+
+/**
+ * What the customer paid, tax included, for `quantity` units of a line — the
+ * refund a claim offers until the merchant types their own. Blank when the
+ * line's amounts are unknown.
+ */
+export function paidForUnits(
+  line: {
+    quantity: number
+    discounted_amount?: string | null
+    additional_tax_total?: string | null
+  },
+  quantity: number,
+  currency: string,
+): string {
+  if (quantity <= 0 || line.quantity <= 0 || !isDecimalString(line.discounted_amount)) return ''
+
+  const tax = isDecimalString(line.additional_tax_total) ? line.additional_tax_total : '0'
+  const paid = sumMoney([line.discounted_amount, tax])
+  return prorateMoney(paid, quantity, line.quantity, currency)
+}

package/src/lib/route-registry.ts

@@ -3,22 +3,34 @@ import { useSyncExternalStore } from 'react'
 import type { SubjectName } from './permissions'
 
 /**
- * Dashboard route contributed by a plugin. Mounted under the dashboard's
- * `/_authenticated/$storeId/_plugins/$` catch-all, which reads this registry
- * at render time and dispatches based on the splat path.
+ * Where a registry route mounts:
+ *
+ * - `store` (default) — inside a store, under `/$storeId`, with the store's
+ *   sidebar and top bar.
+ * - `authenticated` — at the root, for signed-in users, outside any store
+ *   (account or onboarding pages). Signed-out visitors go to the login page.
+ * - `public` — at the root, with no sign-in required (a sign-up or terms page).
+ */
+export type RouteScope = 'store' | 'authenticated' | 'public'
+
+/**
+ * Dashboard route contributed by a plugin. Store routes mount under the
+ * dashboard's `/_authenticated/$storeId/$` catch-all, which reads this
+ * registry at render time and dispatches based on the splat path.
  *
  * Path patterns use TanStack-Router-style param tokens (`$brandId`) inside the
  * plugin's namespace. The dashboard strips the `/$storeId/` prefix before
  * matching, so a plugin pattern of `/brands/$brandId` matches the URL
  * `/store_xyz/brands/br_abc123` with `params: { brandId: 'br_abc123' }`.
  */
-export interface RouteEntry {
+export interface StoreRouteEntry {
   /**
    * Stable identifier — used for register/remove/update and as the React key.
    * Mirrors the slug a plugin would use in its `nav.add({ key })` call so the
    * sidebar entry and route stay paired.
    */
   key: string
+  scope?: 'store'
   /**
    * Path pattern relative to `/$storeId`. Examples: `/brands`,
    * `/brands/$brandId`, `/wishlists/$wishlistId/items`.
@@ -30,7 +42,7 @@ export interface RouteEntry {
    * The component to render. Receives:
    * - `params`: extracted path params (e.g. matching `/brands/$brandId`
    *   against `/brands/br_abc` yields `{ brandId: 'br_abc' }`)
-   * - `storeId`: the current store — every plugin route is implicitly scoped
+   * - `storeId`: the current store — every store route is implicitly scoped
    *   under `/$storeId/...`
    * - `searchParams`: the URL search-state object from TanStack Router. Use
    *   this with `<ResourceTable searchParams={searchParams} ... />` so
@@ -49,6 +61,27 @@ export interface RouteEntry {
   subject?: SubjectName
 }
 
+/**
+ * Route mounted at the dashboard's root, outside any store. Unlike store
+ * routes these become real router routes when `createDashboardRouter` runs,
+ * so they must be registered before it — `plugins.ts` and installed plugins
+ * always are.
+ */
+export interface RootRouteEntry {
+  key: string
+  scope: 'authenticated' | 'public'
+  /** Full URL path, e.g. `/sign-up` or `/account/$section`. Must start with `/`. */
+  path: string
+  component: ComponentType<{
+    params: Record<string, string>
+    searchParams: Record<string, unknown>
+  }>
+}
+
+export type RouteEntry = StoreRouteEntry | RootRouteEntry
+
+const ROUTE_SCOPES: readonly RouteScope[] = ['store', 'authenticated', 'public']
+
 const entries: RouteEntry[] = []
 const listeners = new Set<() => void>()
 
@@ -63,10 +96,6 @@ function subscribe(listener: () => void): () => void {
   }
 }
 
-function getSnapshot(): readonly RouteEntry[] {
-  return entries
-}
-
 interface RouteMutator {
   /** Register a route. Throws if `key` is already registered. */
   add(entry: RouteEntry): void
@@ -82,6 +111,11 @@ export const pluginRoutes: RouteMutator = {
     if (!entry.path.startsWith('/')) {
       throw new Error(`Plugin route "${entry.key}" path must start with "/", got "${entry.path}".`)
     }
+    if (entry.scope !== undefined && !ROUTE_SCOPES.includes(entry.scope)) {
+      throw new Error(
+        `Plugin route "${entry.key}" scope must be one of ${ROUTE_SCOPES.join(', ')}, got "${entry.scope}".`,
+      )
+    }
     entries.push(entry)
     notify()
   },
@@ -93,17 +127,22 @@ export const pluginRoutes: RouteMutator = {
   },
 }
 
+/** Every registered route, read outside React. */
+export function getPluginRoutes(): readonly RouteEntry[] {
+  return entries
+}
+
 /**
  * Subscribe to plugin route updates. Returns the full list of registered
  * routes; the catch-all renderer matches against this on every navigation.
  */
 export function usePluginRoutes(): readonly RouteEntry[] {
-  return useSyncExternalStore(subscribe, getSnapshot, getSnapshot)
+  return useSyncExternalStore(subscribe, getPluginRoutes, getPluginRoutes)
 }
 
 /**
  * Match a URL splat (the bit after `/$storeId/`) against the registered
- * routes. Returns the matched entry plus the extracted path params, or
+ * store routes. Returns the matched entry plus the extracted path params, or
  * `null` if nothing matched.
  *
  * Path patterns support TanStack-style `$param` tokens. A pattern segment
@@ -117,12 +156,12 @@ export function usePluginRoutes(): readonly RouteEntry[] {
 export function matchPluginRoute(
   splat: string,
   routes: readonly RouteEntry[],
-): { entry: RouteEntry; params: Record<string, string> } | null {
+): { entry: StoreRouteEntry; params: Record<string, string> } | null {
   // Normalize: strip leading slash, drop empty trailing segments.
   const urlSegments = splat.replace(/^\/+/, '').split('/').filter(Boolean)
-  const bySpecificity = [...routes].sort(
-    (a, b) => countDynamicSegments(a.path) - countDynamicSegments(b.path),
-  )
+  const bySpecificity = routes
+    .filter(isStoreRoute)
+    .sort((a, b) => countDynamicSegments(a.path) - countDynamicSegments(b.path))
   for (const entry of bySpecificity) {
     const patternSegments = entry.path.replace(/^\/+/, '').split('/').filter(Boolean)
     if (patternSegments.length !== urlSegments.length) continue
@@ -144,6 +183,10 @@ export function matchPluginRoute(
   return null
 }
 
+function isStoreRoute(entry: RouteEntry): entry is StoreRouteEntry {
+  return entry.scope === undefined || entry.scope === 'store'
+}
+
 function countDynamicSegments(path: string): number {
   return path
     .replace(/^\/+/, '')

package/src/lib/settings-nav-registry.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, it } from 'vitest'
+import { canSeeSettingsEntry, type SettingsNavEntry } from './settings-nav-registry'
+
+const entry = (overrides: Partial<SettingsNavEntry>): SettingsNavEntry => ({
+  key: 'settings.example',
+  label: 'Example',
+  path: '/example',
+  group: 'store',
+  ...overrides,
+})
+
+const allowing =
+  (...subjects: string[]) =>
+  (_action: string, subject: string) =>
+    subjects.includes(subject)
+
+describe('canSeeSettingsEntry', () => {
+  it('shows an entry without a subject to everyone', () => {
+    expect(canSeeSettingsEntry(entry({}), allowing())).toBe(true)
+  })
+
+  it('checks a single subject', () => {
+    expect(canSeeSettingsEntry(entry({ subject: 'tax_rate' }), allowing('tax_rate'))).toBe(true)
+    expect(canSeeSettingsEntry(entry({ subject: 'tax_rate' }), allowing())).toBe(false)
+  })
+
+  // A page of tabs is reachable through any one of them.
+  it('shows an entry with several subjects when any one is allowed', () => {
+    const taxes = entry({ subjects: ['tax_category', 'tax_rate', 'tax_exemption_reason'] })
+
+    expect(canSeeSettingsEntry(taxes, allowing('tax_exemption_reason'))).toBe(true)
+    expect(canSeeSettingsEntry(taxes, allowing('product'))).toBe(false)
+  })
+})

package/src/lib/settings-nav-registry.ts

@@ -60,6 +60,12 @@ export interface SettingsNavEntry {
   position?: number
   /** CanCanCan subject required to see this item. Omit for always-visible. */
   subject?: SubjectName
+  /**
+   * For a page holding several resources, as tabs: the entry is shown when
+   * `action` is allowed on any of these, so a role reaching one tab still
+   * finds the page. Takes precedence over `subject`.
+   */
+  subjects?: SubjectName[]
   /**
    * Action checked against `subject`. Defaults to `'read'`. Settings pages
    * that only exist to *change* something (store settings, emails) should
@@ -220,6 +226,19 @@ export function settingsEntryMatches(
   return haystack.some((value) => value?.toLowerCase().includes(needle))
 }
 
+/**
+ * Whether a staff member may reach this settings entry. The sidebar, the
+ * settings landing page and the command palette all ask this, so they agree.
+ */
+export function canSeeSettingsEntry(
+  entry: SettingsNavEntry,
+  can: (action: string, subject: string) => boolean,
+): boolean {
+  const action = entry.action ?? 'read'
+  if (entry.subjects?.length) return entry.subjects.some((subject) => can(action, subject))
+  return !entry.subject || can(action, entry.subject)
+}
+
 /**
  * Drop entries the current staff member cannot reach. Exported because the
  * sidebar and the settings landing page must agree on what a role can see —
@@ -231,7 +250,7 @@ export function filterSettingsByPermissions(
   permissions: { can: (action: string, subject: string) => boolean },
 ): SettingsNavSnapshot {
   return regroup(snapshot, (entry) =>
-    !entry.subject ? true : permissions.can(entry.action ?? 'read', entry.subject),
+    canSeeSettingsEntry(entry, (action, subject) => permissions.can(action, subject)),
   )
 }
 
@@ -265,9 +284,7 @@ export function hasVisibleSettingsEntries(permissions: unknown): boolean {
     ?.can
   if (typeof can !== 'function') return false
 
-  return getSnapshot().all.some(
-    (entry) => !entry.subject || can(entry.action ?? 'read', entry.subject),
-  )
+  return getSnapshot().all.some((entry) => canSeeSettingsEntry(entry, can))
 }
 
 /** Test-only: clear the registry. */

package/src/lib/slot-registry.ts

@@ -44,6 +44,16 @@ export interface NoStoreAccessSlotContext {
   signOut: () => Promise<void>
 }
 
+/**
+ * The page a signed-in user lands on at `/`, before entering a store. By
+ * default it opens their first store, or shows the `no_store_access` screen
+ * when they have none. Registering an entry replaces the whole page — for
+ * example with a list of stores to choose from and a way to create one.
+ */
+export const STORE_SELECTION_SLOT = 'store_selection'
+
+export type StoreSelectionSlotContext = NoStoreAccessSlotContext
+
 // ============================================================================
 // Registry — module-singleton keyed by slot name
 // ============================================================================

package/src/lib/storefront.ts

@@ -5,14 +5,14 @@ import type { Store } from '@spree/admin-sdk'
  * or `null` when no storefront URL is configured.
  *
  * The serialized `store.url` always resolves — the backend falls back to the
- * store's formatted URL — so gate on the explicit `preferred_storefront_url`
+ * store's formatted URL — so gate on the explicit `storefront_url`
  * preference: only return a link once a real storefront has been set.
  *
  * @param store the current store, or null/undefined while it loads
  * @returns an absolute URL, or null when the store has no configured storefront
  */
 export function storefrontHref(store: Store | null | undefined): string | null {
-  if (!store?.preferred_storefront_url) return null
+  if (!store?.storefront_url) return null
 
   // Best-effort: prefix with https if the URL is just a hostname.
   return /^https?:\/\//.test(store.url) ? store.url : `https://${store.url}`

package/src/locales/ar.json

@@ -183,7 +183,9 @@
       "searching": "جارٍ البحث…",
       "select_placeholder": "اختر…",
       "unsaved_changes": "لديك تغييرات غير محفوظة.",
-      "yes": "نعم"
+      "yes": "نعم",
+      "done": "تم",
+      "error": "حدث خطأ ما."
     },
     "components": {
       "address_block": {
@@ -1463,11 +1465,13 @@
         "seeded_report_read_only": "هذا تقرير مدمج ولا يمكن تغييره. احفظ نسخة بدلاً من ذلك.",
         "taken": "مستخدم بالفعل",
         "too_long": "طويل جدًا (الحد الأقصى {{count}} حرفًا)",
+        "too_many_decimals": "يحتوي على أكثر من {{count}} منازل عشرية",
         "too_short": "قصير جدًا (الحد الأدنى {{count}} حرفًا)",
         "wrong_length": "الطول غير صحيح (يجب أن يكون {{count}} حرفًا)"
       },
       "country_required": "البلد مطلوب",
       "currency_required": "العملة مطلوبة",
+      "locale_required": "اللغة مطلوبة",
       "first_name_required": "الاسم الأول مطلوب",
       "invalid_email": "أدخل بريدًا إلكترونيًا صالحًا",
       "invalid_email_or_password": "بريد إلكتروني أو كلمة مرور غير صالحة",
@@ -1479,7 +1483,8 @@
       "passwords_dont_match": "كلمتا المرور غير متطابقتين",
       "positive_number": "يجب أن يكون {{field}} أكبر من 0",
       "required": "{{field}} مطلوب",
-      "store_name_required": "اسم المتجر مطلوب"
+      "store_name_required": "اسم المتجر مطلوب",
+      "too_many_decimals": "يمكن أن يحتوي {{field}} على {{count}} منازل عشرية كحد أقصى"
     },
     "products": {
       "autocomplete": {

package/src/locales/de.json

@@ -183,7 +183,9 @@
       "searching": "Wird gesucht…",
       "select_placeholder": "Auswählen…",
       "unsaved_changes": "Sie haben ungespeicherte Änderungen.",
-      "yes": "Ja"
+      "yes": "Ja",
+      "done": "Fertig",
+      "error": "Etwas ist schiefgelaufen."
     },
     "components": {
       "address_block": {
@@ -1463,11 +1465,13 @@
         "seeded_report_read_only": "Dies ist ein integrierter Bericht und kann nicht geändert werden. Speichern Sie stattdessen eine Kopie.",
         "taken": "ist bereits vergeben",
         "too_long": "ist zu lang (maximal {{count}} Zeichen)",
+        "too_many_decimals": "hat mehr als {{count}} Nachkommastellen",
         "too_short": "ist zu kurz (mindestens {{count}} Zeichen)",
         "wrong_length": "hat die falsche Länge (sollte {{count}} Zeichen haben)"
       },
       "country_required": "Land ist erforderlich",
       "currency_required": "Währung ist erforderlich",
+      "locale_required": "Sprache ist erforderlich",
       "first_name_required": "Vorname ist erforderlich",
       "invalid_email": "Geben Sie eine gültige E-Mail-Adresse ein",
       "invalid_email_or_password": "Ungültige E-Mail-Adresse oder ungültiges Passwort",
@@ -1479,7 +1483,8 @@
       "passwords_dont_match": "Die Passwörter stimmen nicht überein",
       "positive_number": "{{field}} muss größer als 0 sein",
       "required": "{{field}} ist erforderlich",
-      "store_name_required": "Shopname ist erforderlich"
+      "store_name_required": "Shopname ist erforderlich",
+      "too_many_decimals": "{{field}} darf höchstens {{count}} Nachkommastellen haben"
     },
     "products": {
       "autocomplete": {

package/src/locales/en.json

@@ -183,7 +183,9 @@
       "searching": "Searching…",
       "select_placeholder": "Select…",
       "unsaved_changes": "You have unsaved changes.",
-      "yes": "Yes"
+      "yes": "Yes",
+      "done": "Done",
+      "error": "Something went wrong."
     },
     "components": {
       "address_block": {
@@ -1465,11 +1467,13 @@
         "seeded_report_read_only": "This is a built-in report and cannot be changed. Save a copy instead.",
         "taken": "has already been taken",
         "too_long": "is too long (maximum is {{count}} characters)",
+        "too_many_decimals": "has more than {{count}} decimal places",
         "too_short": "is too short (minimum is {{count}} characters)",
         "wrong_length": "is the wrong length (should be {{count}} characters)"
       },
       "country_required": "Country is required",
       "currency_required": "Currency is required",
+      "locale_required": "Language is required",
       "first_name_required": "First name is required",
       "invalid_email": "Enter a valid email",
       "invalid_email_or_password": "Invalid email or password",
@@ -1481,7 +1485,8 @@
       "passwords_dont_match": "Passwords do not match",
       "positive_number": "{{field}} must be greater than 0",
       "required": "{{field}} is required",
-      "store_name_required": "Store name is required"
+      "store_name_required": "Store name is required",
+      "too_many_decimals": "{{field}} can have at most {{count}} decimal places"
     },
     "products": {
       "autocomplete": {