@spree/dashboard-core 1.0.0-rc.3 → 1.0.0-rc.5

package/src/components/table-toolbar.tsx

@@ -1,3 +1,4 @@
+import type { FilterPredicate } from '@spree/core'
 import {
   Button,
   Checkbox,
@@ -36,7 +37,7 @@ import {
   XIcon,
 } from '@spree/dashboard-ui/icons'
 import { useQuery } from '@tanstack/react-query'
-import { useCallback, useDeferredValue, useMemo, useState } from 'react'
+import { Fragment, useCallback, useDeferredValue, useMemo, useState } from 'react'
 import { useTranslation } from 'react-i18next'
 import { getApiClient } from '../api-client'
 import { useAuth } from '../hooks/use-auth'
@@ -55,6 +56,7 @@ import {
 } from '../lib/table-registry'
 import { useOptionalStore } from '../providers/store-provider'
 import { useTenantId } from '../providers/tenant-provider'
+import { LocaleLabel, useLocaleLabel } from './locale-select'
 import { StoreDatePicker } from './store-date-picker'
 
 interface TableToolbarProps {
@@ -81,7 +83,16 @@ interface TableToolbarProps {
 
 // Operator labels are stored as i18n keys (`admin.components.table_toolbar.operators.*`)
 // and resolved with `t()` at render time so they follow the active language.
-const operatorsByType: Record<string, { value: string; labelKey: string }[]> = {
+type OperatorOption = { value: FilterPredicate; labelKey: string }
+
+const storeCodeOperators: OperatorOption[] = [
+  { value: 'eq', labelKey: 'admin.components.table_toolbar.operators.is' },
+  { value: 'not_eq', labelKey: 'admin.components.table_toolbar.operators.is_not' },
+  { value: 'in', labelKey: 'admin.components.table_toolbar.operators.is_any_of' },
+  { value: 'not_in', labelKey: 'admin.components.table_toolbar.operators.is_none_of' },
+]
+
+const operatorsByType: Record<string, OperatorOption[]> = {
   string: [
     // `i_cont` (case-insensitive) rather than `cont` — an admin typing
     // "2 years" expects to match "2 Years".
@@ -125,13 +136,9 @@ const operatorsByType: Record<string, { value: string; labelKey: string }[]> = {
     { value: 'not_in', labelKey: 'admin.components.table_toolbar.operators.is_none_of' },
   ],
   // Same shape as `enum` — the value picker just sources its option list
-  // from the active store's `supported_currencies`.
-  currency: [
-    { value: 'eq', labelKey: 'admin.components.table_toolbar.operators.is' },
-    { value: 'not_eq', labelKey: 'admin.components.table_toolbar.operators.is_not' },
-    { value: 'in', labelKey: 'admin.components.table_toolbar.operators.is_any_of' },
-    { value: 'not_in', labelKey: 'admin.components.table_toolbar.operators.is_none_of' },
-  ],
+  // from the currencies / languages of the active store's markets.
+  currency: storeCodeOperators,
+  locale: storeCodeOperators,
 }
 
 function getOperators(type: string) {
@@ -155,7 +162,7 @@ const noValueOperators = ['present', 'blank']
 
 /** Stable empty list, so a panel with no store doesn't rebuild `items` (and
  *  re-emit Base UI Select state) on every render. */
-const noCurrencies: string[] = []
+const noCodes: string[] = []
 
 // ============================================================================
 // TableToolbar
@@ -489,6 +496,15 @@ function FilterChip({
               <ResourceFilterValue value={first.value} config={col.filterResource} />
             ) : col?.filterType === 'tags' ? (
               <span>{parseFilterIds(first.value).join(', ')}</span>
+            ) : col?.filterType === 'locale' ? (
+              <span>
+                {parseFilterIds(first.value).map((code, index) => (
+                  <Fragment key={code}>
+                    {index > 0 && ', '}
+                    <LocaleLabel code={code} />
+                  </Fragment>
+                ))}
+              </span>
             ) : col?.filterType === 'enum' && col.filterOptions ? (
               <span>
                 {parseFilterIds(first.value)
@@ -515,6 +531,25 @@ function FilterChip({
   )
 }
 
+/**
+ * The whole option list of a resource small enough to fetch once (`listAll`),
+ * cached under `[queryKey, tenant, 'all']` — the key the resource's own
+ * full-list hook uses, so filters and the rest of the dashboard share one
+ * fetch that the resource's writes invalidate.
+ */
+function useListAll(
+  config: ColumnDef['filterResource'],
+  tenantId: string | undefined,
+  enabled = true,
+) {
+  return useQuery({
+    queryKey: [config?.queryKey, tenantId, 'all'],
+    queryFn: () => config?.listAll?.() ?? Promise.resolve({ data: [] }),
+    enabled: enabled && Boolean(config?.listAll),
+    staleTime: config?.staleTime ?? 60_000,
+  })
+}
+
 /**
  * Hydrates the CSV id list in a resource filter into human labels. Reuses
  * the resource's `hydrate` callback so each chip benefits from React Query's
@@ -530,19 +565,21 @@ function ResourceFilterValue({
   const tenantId = useTenantId()
   const ids = useMemo(() => parseFilterIds(value), [value])
 
-  const { data } = useQuery({
+  const all = useListAll(config, tenantId, ids.length > 0)
+  const hydrated = useQuery({
     // Tenant-scope the cache key so chips don't resolve against another
     // tenant's hydrate results after a store or seller switch.
-    queryKey: ['filter-chip', config.queryKey, tenantId, ids],
+    queryKey: [config.queryKey, tenantId, 'filter-chip', ids],
     queryFn: () => config.hydrate(ids),
-    enabled: ids.length > 0,
-    staleTime: 60_000,
+    enabled: ids.length > 0 && !config.listAll,
+    staleTime: config.staleTime ?? 60_000,
   })
+  const records = config.listAll ? all.data?.data : hydrated.data?.data
 
   if (ids.length === 0) return null
 
   const labels = ids.map((id) => {
-    const record = data?.data.find((r) => r.id === id)
+    const record = records?.find((r) => r.id === id)
     return record ? config.getOptionLabel(record) : id
   })
 
@@ -768,12 +805,7 @@ function QuickResourceFilter({
     [existingValue],
   )
 
-  const { data } = useQuery({
-    queryKey: ['quick-filter-all', config.queryKey, tenantId],
-    queryFn: () => config.listAll?.() ?? Promise.resolve({ data: [] }),
-    enabled: !!config.listAll,
-    staleTime: 60_000,
-  })
+  const { data } = useListAll(config, tenantId)
   const options = useMemo(
     () =>
       (data?.data ?? []).map((item) => ({ value: item.id, label: config.getOptionLabel(item) })),
@@ -1101,10 +1133,15 @@ function InlineValueList({
   const tagsClient = getApiClient().tags
   const isTags = column.filterType === 'tags'
   const isCurrency = column.filterType === 'currency'
-  // `filterType: 'currency'` is only declared by tables in the operator's
-  // dashboard, which always has a store. Reading it optionally keeps the panel
-  // mountable in one that has none.
-  const currencies = useOptionalStore()?.currencies ?? noCurrencies
+  const isLocale = column.filterType === 'locale'
+  // Store codes are listed client-side from the store payload, never searched.
+  const isStoreCode = isCurrency || isLocale
+  // `filterType: 'currency'` / `'locale'` are only declared by tables in the
+  // operator's dashboard, which always has a store. Reading it optionally
+  // keeps the panel mountable in one that has none.
+  const store = useOptionalStore()
+  const storeCodes = (isCurrency ? store?.currencies : isLocale ? store?.locales : null) ?? noCodes
+  const localeLabel = useLocaleLabel()
 
   // Tags arrive as one list and are filtered client-side; resources are
   // searched server-side, since their vocabulary is unbounded.
@@ -1129,18 +1166,23 @@ function InlineValueList({
   // genuinely new query reaches the network.
   const deferredQuery = useDeferredValue(query)
 
+  // A resource listed whole is fetched once and narrowed here as the operator
+  // types; anything larger is searched server-side.
+  const listed = Boolean(column.filterResource?.listAll)
+  const all = useListAll(column.filterResource, tenantId, !isTags && !isStoreCode)
+
   const resources = useQuery({
     // Tenant-scoped so a store or seller switch cannot reuse the previous
     // tenant's results.
-    queryKey: ['panel-resource-filter', column.filterResource?.queryKey, tenantId, deferredQuery],
+    queryKey: [column.filterResource?.queryKey, tenantId, 'panel-resource-filter', deferredQuery],
     queryFn: () => column.filterResource?.search(deferredQuery),
-    enabled: !isTags && !isCurrency && Boolean(column.filterResource),
+    enabled: !isTags && !isStoreCode && !listed && Boolean(column.filterResource),
     // These lists are reference data an operator reopens repeatedly while
     // narrowing one list, and the result is small now that only the displayed
     // fields are requested. Holding it for the session keeps reopening the
     // panel instant; `gcTime` outlives the unmount between opens.
-    staleTime: 5 * 60_000,
-    gcTime: 30 * 60_000,
+    staleTime: column.filterResource?.staleTime ?? 5 * 60_000,
+    gcTime: Math.max(30 * 60_000, column.filterResource?.staleTime ?? 0),
     // Keeps the previous matches on screen while the next query resolves, so
     // the list does not blank on every keystroke.
     //
@@ -1149,7 +1191,7 @@ function InlineValueList({
     // drops them instead of briefly offering another tenant's records as
     // though they were this one's.
     placeholderData: (previous, previousQuery) => {
-      const [, previousResource, previousTenant] = (previousQuery?.queryKey ?? []) as unknown[]
+      const [previousResource, previousTenant] = (previousQuery?.queryKey ?? []) as unknown[]
       const sameScope =
         previousResource === column.filterResource?.queryKey && previousTenant === tenantId
       return sameScope ? previous : undefined
@@ -1157,11 +1199,14 @@ function InlineValueList({
   })
 
   const options = useMemo(() => {
-    if (isCurrency) {
+    if (isStoreCode) {
       const needle = query.trim().toLowerCase()
-      return currencies
-        .filter((code) => !needle || code.toLowerCase().includes(needle))
-        .map((code) => ({ value: code, label: code }))
+      return storeCodes
+        .map((code) => ({
+          value: code,
+          label: isLocale ? localeLabel(code) : code,
+        }))
+        .filter((option) => !needle || option.label.toLowerCase().includes(needle))
     }
     if (isTags) {
       const names = tags.data?.data?.map((tag) => tag.name) ?? []
@@ -1171,25 +1216,45 @@ function InlineValueList({
     }
     const config = column.filterResource
     if (!config) return []
-    return (resources.data?.data ?? []).map((record) => ({
+    const records = (listed ? all.data?.data : resources.data?.data) ?? []
+    const resourceOptions = records.map((record) => ({
       value: record.id,
       label: config.getOptionLabel(record),
     }))
-  }, [isCurrency, currencies, isTags, tags.data, resources.data, column.filterResource, query])
-
-  // Selected values ride at the top so a choice made before searching does not
-  // disappear the moment the query stops matching it.
+    if (!listed) return resourceOptions
+    const needle = query.trim().toLowerCase()
+    return resourceOptions.filter(
+      (option) => !needle || option.label.toLowerCase().includes(needle),
+    )
+  }, [
+    listed,
+    all.data,
+    isStoreCode,
+    isLocale,
+    storeCodes,
+    localeLabel,
+    isTags,
+    tags.data,
+    resources.data,
+    column.filterResource,
+    query,
+  ])
+
+  // Values already selected when the list opens ride at the top, so an active
+  // filter is visible without scrolling. The set is frozen at mount: ticking a
+  // box must not move rows under the pointer.
+  const [pinned] = useState(() => selected)
   const ordered = useMemo(() => {
-    const chosen = options.filter((option) => selected.includes(option.value))
-    const rest = options.filter((option) => !selected.includes(option.value))
+    const chosen = options.filter((option) => pinned.includes(option.value))
+    const rest = options.filter((option) => !pinned.includes(option.value))
     // Not truncated: a list cut at ten looks like a list of ten, and a
     // vocabulary of forty tags would silently lose thirty with nothing on
     // screen to say so. The container scrolls instead, so the scrollbar
     // reports how much more there is — and searching narrows it.
     return [...chosen, ...rest]
-  }, [options, selected])
+  }, [options, pinned])
 
-  if (!isCurrency && (tags.isLoading || resources.isLoading)) {
+  if (!isStoreCode && (tags.isLoading || resources.isLoading || all.isLoading)) {
     return (
       <p className="px-2 py-6 text-center text-muted-foreground">{t('admin.common.loading')}</p>
     )
@@ -1272,7 +1337,7 @@ function FilterPanel({
   // Types whose values are chosen from a list rather than typed. `multi` ones
   // accumulate a set and need an explicit Apply; the single ones commit on the
   // click that picks them.
-  const multi = type === 'tags' || type === 'resource' || type === 'currency'
+  const multi = type === 'tags' || type === 'resource' || type === 'currency' || type === 'locale'
   // Dates are their own shape: a list of relative presets, with the calendar
   // behind "custom". Same presets the quick filter offers, so a range means
   // the same thing wherever it was set.
@@ -1507,6 +1572,7 @@ function FilterPanel({
             behind the panel is already showing the result. */}
         {field && multi && column && (
           <InlineValueList
+            key={column.key}
             column={column}
             tenantId={tenantId}
             query={query}
@@ -1650,7 +1716,7 @@ function FilterPanel({
               </Select>
             ) : null}
 
-            {/* Everything picked from a list — currency, tags, resources — or
+            {/* Everything picked from a list — currency, locale, tags, resources — or
                 from a calendar is handled above; this branch is only the types
                 you type into. */}
             {!noValueOperators.includes(operator) && listOptions.length === 0 && (

package/src/hooks/use-display-name.ts

@@ -1,24 +1,7 @@
 import { useMemo } from 'react'
 import { useTranslation } from 'react-i18next'
 
-/**
- * Resolves a code to its display name via `Intl.DisplayNames`, localized to a
- * given UI language. Returns `undefined` when the runtime lacks coverage so
- * callers can apply their own fallback (usually the raw code).
- *
- * Standalone (non-hook) variant for module-level use outside React.
- */
-export function intlDisplayName(
-  type: Intl.DisplayNamesType,
-  locale: string,
-  code: string,
-): string | undefined {
-  try {
-    return new Intl.DisplayNames([locale, 'en'], { type }).of(code)
-  } catch {
-    return undefined
-  }
-}
+export { intlDisplayName } from '@spree/core'
 
 /**
  * Hook returning a memoized `code -> name` resolver for one `Intl.DisplayNames`

package/src/hooks/use-file-upload.ts

@@ -1,3 +1,4 @@
+import type { FileUploadVisibility } from '@spree/core'
 import { useMutation } from '@tanstack/react-query'
 import { getApiClient } from '../api-client'
 
@@ -31,7 +32,7 @@ interface FileUploadOptions {
    * (documents, imports, digital products). Attaching a file never moves it
    * between storage services, so this has to be decided up front.
    */
-  visibility?: 'public' | 'private'
+  visibility?: FileUploadVisibility
 }
 
 export function useFileUpload(options: FileUploadOptions = {}) {

package/src/hooks/use-import.ts

@@ -1,3 +1,4 @@
+import { IMPORT_STATUSES, subsetOf } from '@spree/core'
 import { toastManager } from '@spree/dashboard-ui'
 import {
   type QueryClient,
@@ -20,7 +21,7 @@ import { useTenantId } from '../providers/tenant-provider'
 import { useAuth } from './use-auth'
 
 /** Statuses the wizard polls through — row creation and processing. */
-const ACTIVE_STATUSES = new Set(['completed_mapping', 'processing'])
+const ACTIVE_STATUSES = subsetOf(IMPORT_STATUSES, ['completed_mapping', 'processing'])
 
 const IMPORT_POLL_INTERVAL_MS = 2000
 const ROWS_POLL_INTERVAL_MS = 5000
@@ -49,7 +50,7 @@ const IMPORT_TOUCHED_RESOURCES = [
 
 /** Whether the import's pipeline is still running (the poll's continue predicate). */
 export function isImportActive(status: string | undefined): boolean {
-  return !!status && ACTIVE_STATUSES.has(status)
+  return !!status && ACTIVE_STATUSES.includes(status)
 }
 
 /**

package/src/index.ts

@@ -11,6 +11,17 @@
 //     import { AuthProvider } from '@spree/dashboard-core/providers/auth-provider'
 //     import { useResourceMutation } from '@spree/dashboard-core/hooks/use-resource-mutation'
 
+// Money helpers from @spree/core, offered here as before for plugin authors
+export {
+  currencyParts,
+  fractionToPercent,
+  isPositiveMoney,
+  normalizeMoneyInput,
+  percentOf,
+  percentToFraction,
+  prorateMoney,
+  shiftDecimalPoint,
+} from '@spree/core'
 export * from './api-client'
 // ---------------------------------------------------------------------------
 // Admin SDK client (Vite-aware singleton; reads VITE_SPREE_API_URL at build)
@@ -81,7 +92,6 @@ export * from './lib/create-action-registry'
 // Registries — pluggable extension points (nav, route, slot, table,
 // settings-nav, form fields, custom field components)
 // ---------------------------------------------------------------------------
-export * from './lib/currency-parts'
 export * from './lib/custom-field-components'
 export * from './lib/date-presets'
 export * from './lib/delivery-form'
@@ -103,9 +113,7 @@ export * from './lib/i18n'
 export * from './lib/import-types'
 export * from './lib/iso-codes'
 export * from './lib/label-upload-form'
-export * from './lib/money'
 export * from './lib/nav-registry'
-export * from './lib/normalize-money'
 export * from './lib/permissions'
 export * from './lib/progress'
 export * from './lib/query-client'
@@ -115,6 +123,7 @@ export * from './lib/route-registry'
 export * from './lib/search-registry'
 export * from './lib/settings-nav-registry'
 export * from './lib/slot-registry'
+export * from './lib/store-config'
 export * from './lib/table-registry'
 export { ensureTimestampColumns } from './lib/timestamp-columns'
 export * from './lib/type-labels'
@@ -131,6 +140,7 @@ export * from './products/product-form-cards'
 export * from './products/product-form-mapping'
 export * from './products/product-schema'
 export * from './products/product-types'
+export type { SheetSaveHandler } from './products/sheet-save-handlers'
 export * from './products/use-product-form-data'
 export * from './products/variants-matrix'
 export * from './products/video-url'

package/src/lib/currencies.ts

@@ -1,18 +1,2 @@
-import type { CurrencyCode } from '@spree/admin-sdk'
-import { isCurrencyCode } from './iso-codes'
-
-/**
- * Every ISO 4217 currency code the runtime knows about — the active-currency
- * counterpart to the Rails admin's `Money::Currency.table` list. Used for
- * contexts where the merchant can pick *any* currency (a market's currency)
- * rather than one the store already supports. Degrades to an empty list on
- * runtimes without `Intl.supportedValuesOf`, so callers fall back to
- * `supported_currencies`.
- */
-export const ALL_CURRENCY_CODES: CurrencyCode[] = (() => {
-  try {
-    return Intl.supportedValuesOf('currency').filter(isCurrencyCode)
-  } catch {
-    return []
-  }
-})()
+/** @deprecated Import `ACTIVE_CURRENCY_CODES` from `@spree/core`. Removed in 6.1. */
+export { ACTIVE_CURRENCY_CODES as ALL_CURRENCY_CODES } from '@spree/core'

package/src/lib/currency-parts.ts

@@ -1,21 +1,2 @@
-// Resolve a currency code into its symbol + decimal separator under the
-// current locale, with a safe fallback for unknown/invalid currencies.
-// Shared between the server-backed BulkPriceEditor and the form-backed
-// ProductBulkPriceEditor.
-export function currencyParts(
-  currencyCode: string,
-  locale: string,
-): { symbol: string; decimal: string } {
-  try {
-    const parts = new Intl.NumberFormat(locale, {
-      style: 'currency',
-      currency: currencyCode,
-    }).formatToParts(1234.56)
-    return {
-      symbol: parts.find((p) => p.type === 'currency')?.value ?? currencyCode,
-      decimal: parts.find((p) => p.type === 'decimal')?.value ?? '.',
-    }
-  } catch {
-    return { symbol: currencyCode, decimal: '.' }
-  }
-}
+/** @deprecated Import from `@spree/core`. Removed in 6.1. */
+export { currencyParts } from '@spree/core'

package/src/lib/filters-to-ransack.ts

@@ -1,3 +1,4 @@
+import { FILTER_PREDICATES } from '@spree/core'
 import { type ColumnDef, type FilterRule, parseFilterIds } from './table-registry'
 
 /**
@@ -20,7 +21,9 @@ import { type ColumnDef, type FilterRule, parseFilterIds } from './table-registr
 // `q[xxx_in][]=...` for each item. The chip stores the IDs as a CSV string
 // in `FilterRule.value` so the URL serializer (which already JSON-stringifies
 // FilterRule[]) stays simple.
-const ARRAY_OPERATORS = new Set(['in', 'not_in'])
+const ARRAY_OPERATORS = new Set<string>(
+  Object.values(FILTER_PREDICATES).flatMap((predicates) => predicates.list),
+)
 
 const NEGATING_OPERATORS = new Set(['not_in', 'not_eq'])
 

package/src/lib/form-fields-registry.ts

@@ -30,7 +30,8 @@ const registrations = new Map<string, FormFieldRegistration[]>()
 
 /**
  * Registry of extension fields per built-in form. Form keys match the form's
- * slot prefix — `'product'` for the product detail form. Registered names
+ * slot prefix — `'product'` for the product detail form, `'product.media'` and
+ * `'product.variant'` for the rows of its media and variant lists. Registered names
  * must be unique per form; duplicates throw so two plugins can't silently
  * fight over one attribute.
  */
@@ -96,6 +97,27 @@ export function extensionSubmitValues(
   return out
 }
 
+/** Names of every extension field registered on `formKey`. */
+export function extensionFieldNames(formKey: string): string[] {
+  return (registrations.get(formKey) ?? []).map((registration) => registration.name)
+}
+
+/**
+ * Extension field values carried by one row of a nested list — a media or
+ * variant row of the product form, registered under `'product.media'` /
+ * `'product.variant'`. Only keys the row actually holds are returned, so a
+ * row added after hydration (a fresh upload) sends nothing it never had.
+ */
+export function extensionRowValues(formKey: string, row: unknown): Record<string, unknown> {
+  if (!row || typeof row !== 'object') return {}
+
+  const out: Record<string, unknown> = {}
+  for (const name of extensionFieldNames(formKey)) {
+    if (name in row) out[name] = (row as Record<string, unknown>)[name]
+  }
+  return out
+}
+
 /** Test-only: clear the registry. Not exported from the package index. */
 export function __resetFormFieldsRegistry(): void {
   registrations.clear()

package/src/lib/form-mappers.ts

@@ -1,4 +1,4 @@
-import type { CountryCode } from '@spree/admin-sdk'
+import type { CountryCode } from '@spree/core'
 import type { PanelAccountParams } from '../api-client'
 
 /**

package/src/lib/formatters.ts

@@ -1,4 +1,5 @@
-import { formatMoney, type Price } from '@spree/admin-sdk'
+import type { Price } from '@spree/admin-sdk'
+import { formatMoney } from '@spree/core'
 import { parseISO } from 'date-fns'
 import { formatInTimeZone } from 'date-fns-tz'
 import i18n from 'i18next'
@@ -19,9 +20,8 @@ export function formatPrice(
 }
 
 /**
- * Formats an API amount (a decimal string) in its currency, falling back to
- * the bare number for a currency `Intl` does not know, and to `fallback` when
- * either is missing.
+ * Formats an API amount (a decimal string) in its currency, or answers
+ * `fallback` when either is missing or `Intl` cannot format the pair.
  */
 export function formatAmount(
   amount: string | null | undefined,
@@ -29,12 +29,8 @@ export function formatAmount(
   locale?: string,
   fallback = '—',
 ): string {
-  if (amount === null || amount === undefined || amount === '' || !currency) return fallback
-  try {
-    return formatMoney(amount, currency, locale) || fallback
-  } catch {
-    return `${amount} ${currency}`
-  }
+  if (!currency) return fallback
+  return formatMoney(amount, currency, locale) || fallback
 }
 
 export function formatStoreDateTime(iso: string, timezone: string) {

package/src/lib/fulfillment-items.ts

@@ -1,3 +1,4 @@
+import { ORDER_FULFILLMENT_STATUSES, subsetOf } from '@spree/core'
 import i18n from 'i18next'
 import { formatMoney } from './formatters'
 
@@ -86,6 +87,16 @@ function claimedQuantities(fulfillments: GroupableFulfillment[]): Map<string, nu
  */
 export const GONE_STATUSES = ['fulfilled', 'delivered']
 
+/** The order-level fulfillment statuses the order lists filter on. */
+export const FILTERABLE_ORDER_FULFILLMENT_STATUSES = subsetOf(ORDER_FULFILLMENT_STATUSES, [
+  'backorder',
+  'canceled',
+  'partial',
+  'unfulfilled',
+  'fulfilled',
+  'delivered',
+])
+
 export function fulfilledQuantities(fulfillments: GroupableFulfillment[]): Map<string, number> {
   const fulfilled = new Map<string, number>()
 

package/src/lib/i18n.ts

@@ -1,6 +1,6 @@
+import { localeEndonym } from '@spree/core'
 import i18n from 'i18next'
 import { initReactI18next } from 'react-i18next'
-import { intlDisplayName } from '../hooks/use-display-name'
 // Relative path, not `@/...`: dashboard-core ships source; the consuming
 // project's `@/*` alias is theirs alone (see Phase 1's rationale).
 import en from '../locales/en.json'
@@ -153,17 +153,6 @@ function localeCodesFromBundlePaths(paths: string[]): string[] {
   return ['en', ...paths.map((path) => path.replace(/^.*\/locales\//, '').replace('.json', ''))]
 }
 
-// Each language's endonym (its own name: `Deutsch`, `中文`). `Intl.DisplayNames`
-// answers in the language's own convention, so some come back lowercase
-// (`français`, `polski`); capitalize the first letter by THAT language's casing
-// rules rather than the current locale's. Scripts without case are unaffected,
-// and an unknown code falls back to itself.
-function localeEndonym(code: string): string {
-  const name = intlDisplayName('language', code, code) ?? code
-
-  return name.charAt(0).toLocaleUpperCase(code) + name.slice(1)
-}
-
 // The languages the running panel can display, as it declared them. `null`
 // until a panel does, which accepts every code — the behaviour before panels
 // declared anything.

package/src/lib/iso-codes.ts

@@ -1,30 +1,15 @@
-import type { CountryCode, CurrencyCode, LocaleCode } from '@spree/admin-sdk'
+import {
+  type CountryCode,
+  type CurrencyCode,
+  isCountryCode,
+  isCurrencyCode,
+  isLocaleCode,
+  type LocaleCode,
+} from '@spree/core'
 import i18n from 'i18next'
 import { z } from 'zod/v4'
 
-/**
- * Whether a value has the shape of an ISO 3166-1 alpha-2 country code.
- *
- * Shape only: the server holds the authoritative list and rejects a code it
- * does not know, so the dashboard does not ship a second copy of it. This is
- * the one place a plain string becomes a `CountryCode`.
- */
-export function isCountryCode(value: unknown): value is CountryCode {
-  return typeof value === 'string' && /^[A-Z]{2}$/.test(value)
-}
-
-/** Whether a value has the shape of an ISO 4217 currency code. See `isCountryCode`. */
-export function isCurrencyCode(value: unknown): value is CurrencyCode {
-  return typeof value === 'string' && /^[A-Z]{3}$/.test(value)
-}
-
-/**
- * Whether a value has the shape of a locale code: an ISO 639-1 language,
- * optionally with a region (`en`, `pt-BR`, `es-419`). See `isCountryCode`.
- */
-export function isLocaleCode(value: unknown): value is LocaleCode {
-  return typeof value === 'string' && /^[a-z]{2,3}(-[A-Z0-9]{2,3})?$/.test(value)
-}
+export { isCountryCode, isCurrencyCode, isLocaleCode }
 
 /**
  * A required country field. A form that allows leaving it blank widens it