@myparcel-dev/pdk-admin 1.14.2 → 2.0.1

package/src/composables/shipments/useShipmentData.ts

@@ -1,7 +1,7 @@
 import {computed, type ComputedRef, type Ref, ref, toValue, unref} from 'vue';
 import {type MaybeRef} from '@vueuse/core';
-import {type Shipment} from '@myparcel-dev/pdk-common';
 import {type Carrier} from '@myparcel-dev/sdk';
+import {type Shipment} from '@myparcel-dev/pdk-common';
 import {type AnyActionDefinition} from '../../types';
 import {useQueryStore} from '../../stores';
 import {instantiateActions} from '../../services';
@@ -32,7 +32,7 @@ export const useShipmentData = (id: MaybeRef<number>): UseShipmentData => {
     orderId ? queryStore.getQueriesForOrder(orderId) : undefined,
   ].filter(Boolean);
 
-  const carrierName = shipment.value?.carrier?.name;
+  const carrierName = shipment.value?.carrier?.carrier;
   const carriersQuery = carrierName ? useFetchCarrier(carrierName) : undefined;
 
   return {

package/src/data/index.ts

@@ -1,4 +1,5 @@
 export * from './components';
 export * from './constants';
 export * from './endpoints';
+export * from './orderMode';
 export * from './view';

package/src/data/orderMode.spec.ts

@@ -0,0 +1,22 @@
+import {describe, expect, it} from 'vitest';
+import {OrderMode, resolveOrderMode, SubscriptionFeature} from './orderMode';
+
+describe('resolveOrderMode', () => {
+  it('returns OrderV2 when both ORDER_MANAGEMENT and LEGACY_ORDER_MANAGEMENT are present', () => {
+    expect(resolveOrderMode([SubscriptionFeature.OrderManagement, SubscriptionFeature.LegacyOrderManagement])).toBe(
+      OrderMode.OrderV2,
+    );
+  });
+
+  it('returns OrderV2 when only ORDER_MANAGEMENT is present', () => {
+    expect(resolveOrderMode([SubscriptionFeature.OrderManagement])).toBe(OrderMode.OrderV2);
+  });
+
+  it('returns OrderV1 when only LEGACY_ORDER_MANAGEMENT is present', () => {
+    expect(resolveOrderMode([SubscriptionFeature.LegacyOrderManagement])).toBe(OrderMode.OrderV1);
+  });
+
+  it('returns Shipments when no features are present', () => {
+    expect(resolveOrderMode([])).toBe(OrderMode.Shipments);
+  });
+});

package/src/data/orderMode.ts

@@ -0,0 +1,50 @@
+export enum OrderMode {
+  Shipments = 'Shipments',
+  OrderV1 = 'OrderV1',
+  OrderV2 = 'OrderV2',
+}
+
+export enum SubscriptionFeature {
+  LegacyOrderManagement = 'LEGACY_ORDER_MANAGEMENT',
+  OrderManagement = 'ORDER_MANAGEMENT',
+}
+
+/**
+ * Mapping from the PHP-side `AccountFeaturesServiceInterface::ORDER_MODE_*`
+ * integer constants to the JS-side {@see OrderMode} enum.
+ */
+const ORDER_MODE_BY_NUMERIC: Record<number, OrderMode> = {
+  0: OrderMode.Shipments,
+  1: OrderMode.OrderV1,
+  2: OrderMode.OrderV2,
+};
+
+/**
+ * Translate the numeric `effectiveOrderMode` emitted by the PDK admin context
+ * (when present) into the JS-side {@see OrderMode} enum. Returns `undefined`
+ * when the value is missing or not one of the known modes, so callers can fall
+ * back to feature-based resolution.
+ */
+export const orderModeFromContextValue = (value: unknown): OrderMode | undefined => {
+  if (typeof value === 'number' && value in ORDER_MODE_BY_NUMERIC) {
+    return ORDER_MODE_BY_NUMERIC[value];
+  }
+
+  return undefined;
+};
+
+/**
+ * Derive the active {@see OrderMode} from the raw IAM subscription features.
+ *
+ * Use this only as a fallback for environments where the PDK admin context does
+ * not yet surface a pre-computed `effectiveOrderMode`. Prefer the context value
+ * so any business rules layered on top in PHP (e.g. INT-1590's sales-channel
+ * downgrade) take effect on the JS side automatically.
+ */
+export const resolveOrderMode = (features: string[]): OrderMode => {
+  if (features.includes(SubscriptionFeature.OrderManagement)) return OrderMode.OrderV2;
+
+  if (features.includes(SubscriptionFeature.LegacyOrderManagement)) return OrderMode.OrderV1;
+
+  return OrderMode.Shipments;
+};

package/src/forms/form-builder/builders/buildAfterUpdate.spec.ts

@@ -1,6 +1,6 @@
 import {ref} from 'vue';
 import {afterEach, describe, expect, it, vi} from 'vitest';
-import {mount} from '@vue/test-utils';
+import {flushPromises, mount} from '@vue/test-utils';
 import {defineForm, MagicForm, useFormBuilder} from '@myparcel-dev/vue-form-builder';
 import {buildAfterUpdate} from './buildAfterUpdate';
 
@@ -31,19 +31,16 @@ describe('buildAfterUpdate', () => {
       ],
     });
 
-    const wrapper = mount(MagicForm, {props: {form}});
+    mount(MagicForm, {props: {form}});
 
     expect(afterUpdate).not.toHaveBeenCalled();
 
     form.setValue('test', 'test');
 
-    const testField = form.getField('test');
-    // todo remove this when afterUpdate is properly triggered
-    testField?.afterUpdate(testField);
+    // afterUpdate fires async, so wait for it to settle.
+    await flushPromises();
 
-    await wrapper.vm.$nextTick();
-
-    expect(afterUpdate).toHaveBeenCalledTimes(1);
+    expect(afterUpdate).toHaveBeenCalled();
     expect(form.getValue('test')).toBe('hello');
   });
 });

package/src/forms/form-builder/operations/executeOperations.spec.ts

@@ -1,6 +1,6 @@
 import {ref} from 'vue';
 import {afterEach, describe, expect, it, vi} from 'vitest';
-import {mount} from '@vue/test-utils';
+import {flushPromises, mount} from '@vue/test-utils';
 import {defineForm, MagicForm, useFormBuilder} from '@myparcel-dev/vue-form-builder';
 import {buildAfterUpdate} from '../builders';
 
@@ -49,17 +49,14 @@ describe('executeOperations', () => {
       ],
     });
 
-    const wrapper = mount(MagicForm, {props: {form}});
+    mount(MagicForm, {props: {form}});
 
     expect(method).not.toHaveBeenCalled();
 
     form.setValue('test', 'test');
 
-    const testField = form.getField('test');
-    // todo remove this when afterUpdate is properly triggered
-    testField?.afterUpdate(testField);
-
-    await wrapper.vm.$nextTick();
+    // afterUpdate fires async, so wait for it to settle.
+    await flushPromises();
 
     expect(method).toHaveBeenCalledTimes(1);
     expect(method).toHaveBeenCalledWith({$value: 'hello'});

package/src/forms/form-builder/operations/executeSetPropOperation.spec.ts

@@ -1,6 +1,6 @@
 import {ref} from 'vue';
 import {afterEach, describe, expect, it} from 'vitest';
-import {mount} from '@vue/test-utils';
+import {flushPromises, mount} from '@vue/test-utils';
 import {defineForm, MagicForm, useFormBuilder} from '@myparcel-dev/vue-form-builder';
 import {type FormSetPropOperation, type PropVal} from '../types';
 import {buildAfterUpdate} from '../builders';
@@ -147,15 +147,12 @@ describe('executeSetPropOperation', () => {
       ],
     });
 
-    const wrapper = mount(MagicForm, {props: {form}});
+    mount(MagicForm, {props: {form}});
 
     form.setValue('aardbei', 'test');
 
-    const testField = form.getField('aardbei');
-    // todo remove this when afterUpdate is properly triggered
-    testField?.afterUpdate(testField);
-
-    await wrapper.vm.$nextTick();
+    // afterUpdate fires async, so wait for it to settle.
+    await flushPromises();
 
     expect({
       aardbei: form.getField('aardbei')?.props,

package/src/forms/form-builder/operations/executeSetValueOperation.spec.ts

@@ -1,8 +1,9 @@
 import {ref} from 'vue';
 import {afterEach, describe, expect, it} from 'vitest';
 import {flushPromises, mount} from '@vue/test-utils';
-import {defineForm, MagicForm, useFormBuilder} from '@myparcel-dev/vue-form-builder';
+import {type InteractiveElementInstance, defineForm, MagicForm, useFormBuilder} from '@myparcel-dev/vue-form-builder';
 import {type AnyVal, type FormSetValueOperation} from '../types';
+import {setFieldRef} from '../utils';
 import {buildAfterUpdate} from '../builders';
 
 interface TestInput {
@@ -192,7 +193,7 @@ describe('executeSetValueOperation', () => {
 
     mount(MagicForm, {props: {form}});
 
-    form.setValue('test', 'test');
+    setFieldRef(form.getField('test') as InteractiveElementInstance, 'test');
 
     await flushPromises();
 

package/src/forms/form-builder/utils/createValueSetter.ts

@@ -4,18 +4,31 @@ import {type AnyVal} from '../types';
 
 export type FormValueSetter = (value: AnyVal, target?: string) => void;
 
+/**
+ * Set a field's ref value, handling both Vue Ref and raw value cases.
+ *
+ * vue-form-builder replaces `field.ref` with a raw value after the first
+ * render cycle, so we can't always rely on `field.ref.value = x`.
+ */
+export const setFieldRef = (field: InteractiveElementInstance, value: AnyVal): void => {
+  if (isRef(field.ref)) {
+    field.ref.value = value;
+  } else {
+    // @ts-expect-error ref was replaced with a raw value by the component render
+    field.ref = value;
+  }
+};
+
 export const createValueSetter = (instance: InteractiveElementInstance, prefix: string): FormValueSetter => {
   return (value, target) => {
     if (target) {
-      instance.form.setValue(`${prefix}${target}`, value);
-    } else {
-      if (isRef(instance.ref)) {
-        instance.ref.value = value;
-        return;
-      }
+      const targetField = instance.form.getField(`${prefix}${target}`) as InteractiveElementInstance | undefined;
 
-      // @ts-expect-error todo
-      instance.ref = value;
+      if (targetField) {
+        setFieldRef(targetField, value);
+      }
+    } else {
+      setFieldRef(instance, value);
     }
   };
 };

package/src/forms/helpers/addCapabilitiesClearNotification.ts

@@ -0,0 +1,39 @@
+import {Variant} from '@myparcel-dev/pdk-common';
+import {type PdkNotification} from '../../types';
+import {useModalStore, type useNotificationStore} from '../../stores';
+import {AdminModalKey, NotificationCategory} from '../../data';
+
+export const CAPABILITIES_CLEARED_NOTIFICATION_ID = 'capabilities_cleared';
+
+/**
+ * Add (or replace) the rolling "capabilities cleared" notification.
+ *
+ * The notification store skips `add` when an entry with the same id is already present, so
+ * we explicitly remove the prior one first to surface the new content list. Pass an
+ * already-localized `title` and `lines` — translation happens at the call site (auto-clear)
+ * because that's the layer holding the carrier name + axis context for parameterized lookups.
+ *
+ * Targets `NotificationCategory.Modal` when the shipment-options modal is open and
+ * `NotificationCategory.Action` otherwise — the modal shells (preset packages) only mount a
+ * `Modal` container, while the order-detail `ShipmentOptionsBox` mounts an `Action` container.
+ */
+export const addCapabilitiesClearNotification = (
+  notificationStore: ReturnType<typeof useNotificationStore>,
+  title: string,
+  lines: string[],
+): void => {
+  if (lines.length === 0) return;
+
+  const isModal = AdminModalKey.ShipmentOptions === useModalStore().opened;
+
+  notificationStore.remove(CAPABILITIES_CLEARED_NOTIFICATION_ID);
+
+  notificationStore.add({
+    id: CAPABILITIES_CLEARED_NOTIFICATION_ID,
+    variant: Variant.Warning,
+    title,
+    content: lines,
+    category: isModal ? NotificationCategory.Modal : NotificationCategory.Action,
+    timeout: false,
+  } as PdkNotification);
+};

package/src/forms/helpers/getDeliveryTypes.ts

@@ -1,18 +1,13 @@
-import {type FormInstance} from '@myparcel-dev/vue-form-builder';
-import {DeliveryTypeName} from '@myparcel-dev/constants';
+import {type CarrierModel} from '@myparcel-dev/pdk-common';
 import {getDynamicTranslation} from '../../utils';
 import {type SelectOption} from '../../types';
-import {getCarrier} from './getCarrier';
 
-export const getDeliveryTypes = (form?: FormInstance): SelectOption[] => {
-  let array = Object.values(DeliveryTypeName);
-
-  if (form) {
-    const carrier = getCarrier(form);
-    array = array.filter((name) => carrier?.capabilities.deliveryTypes.includes(name));
+export const getDeliveryTypes = (carrier: CarrierModel | undefined): SelectOption[] => {
+  if (!carrier) {
+    return [];
   }
 
-  return array.map((name) => ({
+  return carrier.deliveryTypes.map((name) => ({
     label: getDynamicTranslation('delivery_type', name),
     value: name,
   }));

package/src/forms/helpers/getFieldLabel.ts

@@ -1,6 +1,11 @@
 import {snakeCase} from 'lodash-unified';
-import {type Shipment} from '@myparcel-dev/pdk-common';
 import {SHIPMENT_OPTIONS} from '../shipmentOptions';
 
-export const getFieldLabel = (name: keyof Shipment.ModelShipmentOptions): string =>
+/**
+ * Generates a translation key for a shipment option field label.
+ *
+ * Accepts `string` because option names come from the carrier context at
+ * runtime. Converts to snake_case for the translation lookup.
+ */
+export const getFieldLabel = (name: string): string =>
   snakeCase(`${SHIPMENT_OPTIONS}_${name}`);

package/src/forms/helpers/getPackageTypes.ts

@@ -1,19 +1,14 @@
-import {type FormInstance} from '@myparcel-dev/vue-form-builder';
-import {PackageTypeName} from '@myparcel-dev/constants';
+import {type CarrierModel} from '@myparcel-dev/pdk-common';
 import {getPackageTypeTranslation} from '../../utils';
 import {type SelectOption} from '../../types';
-import {getCarrier} from './getCarrier';
 
-export const getPackageTypes = (form?: FormInstance): SelectOption[] => {
-  let array = Object.values(PackageTypeName);
-
-  if (form) {
-    const carrier = getCarrier(form);
-    array = array.filter((name) => carrier?.capabilities.packageTypes.includes(name));
+export const getPackageTypes = (carrier: CarrierModel | undefined): SelectOption[] => {
+  if (!carrier) {
+    return [];
   }
 
-  return array.map((name) => ({
-    label: getPackageTypeTranslation(name),
-    value: name,
+  return carrier.packageTypes.map((packageType) => ({
+    label: getPackageTypeTranslation(packageType),
+    value: packageType,
   }));
 };

package/src/forms/helpers/index.ts

@@ -1,21 +1,14 @@
 export * from './addBulkEditNotification';
+export * from './addCapabilitiesClearNotification';
 export * from './createDefaultOption';
-export * from './createHasShipmentOptionWatcher';
 export * from './createLabel';
 export * from './defineFormField';
-export * from './getCarrier';
+export * from './getDeliveryTypes';
 export * from './getFieldLabel';
 export * from './getFormCarrierName';
-export * from './getInsuranceOptions';
 export * from './getPackageTypes';
-export * from './hasPostNlAgeCheck';
-export * from './hasShipmentOption';
-export * from './isPackageTypeMailbox';
-export * from './isPackageTypePackage';
-export * from './isPackageTypePackageOrSmall';
-export * from './isPackageTypeSmallPackage';
 export * from './resolveFormComponent';
 export * from './setFieldProp';
-export * from './setPostNlAgeCheckSubtext';
 export * from './triStateFieldIsEnabled';
 export * from './updateFieldsDefaults';
+export * from './useFormCapabilities';

package/src/forms/helpers/useFormCapabilities.spec.ts

@@ -0,0 +1,227 @@
+import {describe, expect, it, vi, beforeEach} from 'vitest';
+import {ref} from 'vue';
+import {AdminContextKey, BackendEndpoint, type CarrierModel, TriState} from '@myparcel-dev/pdk-common';
+
+type FakeQuery = {
+  status: ReturnType<typeof ref<string>>;
+  data: ReturnType<typeof ref<unknown>>;
+};
+
+const orderModifier = (id: string) => `${id}.order`;
+const shipmentModifier = (id: string) => `${id}.shipment`;
+
+const buildQueryStore = () => {
+  const queries = new Map<string, FakeQuery>();
+  const dynamicCarriers = ref<CarrierModel[]>([]);
+
+  return {
+    queries,
+    dynamicCarriers,
+    setQuery: (modifier: string, status: string, data: unknown) =>
+      queries.set(`${BackendEndpoint.ProxyCapabilities}.${modifier}`, {
+        status: ref(status),
+        data: ref(data),
+      }),
+    setDynamicCarriers: (carriers: CarrierModel[]) => {
+      dynamicCarriers.value = carriers;
+    },
+    has: (endpoint: BackendEndpoint, modifier: string) =>
+      queries.has(`${endpoint}.${modifier}`),
+    get: (endpoint: BackendEndpoint, modifier?: string) => {
+      if (endpoint === BackendEndpoint.FetchContext && modifier === AdminContextKey.Dynamic) {
+        return {
+          status: ref('success'),
+          data: ref({carriers: dynamicCarriers.value}),
+        };
+      }
+
+      return queries.get(`${endpoint}.${modifier}`) ?? {status: ref('idle'), data: ref(undefined)};
+    },
+  };
+};
+
+let queryStore: ReturnType<typeof buildQueryStore>;
+let mockOrderId: string | undefined = 'order-1';
+
+vi.mock('../../stores', () => ({
+  useQueryStore: () => queryStore,
+}));
+
+vi.mock('../../utils', () => ({
+  getOrderId: () => mockOrderId,
+}));
+
+vi.mock('../../composables', () => ({
+  Format: {Currency: 'currency'},
+  useContext: () => ({carriers: []}),
+}));
+
+const buildCarrier = (overrides: Partial<CarrierModel>): CarrierModel =>
+  ({
+    carrier: 'POSTNL',
+    packageTypes: [],
+    deliveryTypes: [],
+    options: {},
+    ...overrides,
+  }) as CarrierModel;
+
+const formStub = (carrierName: string) => ({
+  getValue: (name: string) => (name === 'deliveryOptions.carrier' ? carrierName : undefined),
+}) as never;
+
+describe('useFormCapabilities', () => {
+  beforeEach(() => {
+    queryStore = buildQueryStore();
+    mockOrderId = 'order-1';
+  });
+
+  describe('getCarrierCapabilitiesForOrder', () => {
+    it('returns the order-query carrier when the query is success and the chosen carrier is in the results', async () => {
+      const order = buildCarrier({carrier: 'POSTNL', packageTypes: ['PACKAGE']});
+      const dynamic = buildCarrier({carrier: 'POSTNL', packageTypes: ['DIGITAL_STAMP']});
+      queryStore.setQuery(orderModifier('order-1'), 'success', [order]);
+      queryStore.setDynamicCarriers([dynamic]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+      const capabilities = useFormCapabilities();
+
+      expect(capabilities.getCarrierCapabilitiesForOrder(formStub('POSTNL'))).toEqual(order);
+    });
+
+    it('falls back to dynamic carriers when the query is loading', async () => {
+      const dynamic = buildCarrier({carrier: 'POSTNL'});
+      queryStore.setQuery(orderModifier('order-1'), 'loading', undefined);
+      queryStore.setDynamicCarriers([dynamic]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().getCarrierCapabilitiesForOrder(formStub('POSTNL'))).toEqual(dynamic);
+    });
+
+    it('falls back to dynamic carriers when the query is errored (loading-state masquerade is intentional)', async () => {
+      const dynamic = buildCarrier({carrier: 'POSTNL'});
+      queryStore.setQuery(orderModifier('order-1'), 'error', undefined);
+      queryStore.setDynamicCarriers([dynamic]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().getCarrierCapabilitiesForOrder(formStub('POSTNL'))).toEqual(dynamic);
+    });
+
+    it('falls back to dynamic carriers when the orderId is missing (bulk path)', async () => {
+      mockOrderId = undefined;
+      const dynamic = buildCarrier({carrier: 'POSTNL'});
+      queryStore.setDynamicCarriers([dynamic]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().getCarrierCapabilitiesForOrder(formStub('POSTNL'))).toEqual(dynamic);
+    });
+  });
+
+  describe('getCarrierCapabilitiesForShipment tri-state', () => {
+    it('returns the narrow shipment carrier when the query is success and the carrier matches', async () => {
+      const shipment = buildCarrier({
+        carrier: 'POSTNL',
+        options: {requiresSignature: {isRequired: true} as never},
+      });
+      queryStore.setQuery(shipmentModifier('order-1'), 'success', [shipment]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().getCarrierCapabilitiesForShipment(formStub('POSTNL'))).toEqual(shipment);
+    });
+
+    it('falls back to order data when the shipment query is loading', async () => {
+      const order = buildCarrier({carrier: 'POSTNL', packageTypes: ['PACKAGE']});
+      queryStore.setQuery(orderModifier('order-1'), 'success', [order]);
+      queryStore.setQuery(shipmentModifier('order-1'), 'loading', undefined);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().getCarrierCapabilitiesForShipment(formStub('POSTNL'))).toEqual(order);
+    });
+
+    it('returns undefined when the shipment query is success but the chosen carrier is not in the results (invalid combo)', async () => {
+      queryStore.setQuery(shipmentModifier('order-1'), 'success', [buildCarrier({carrier: 'DPD'})]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().getCarrierCapabilitiesForShipment(formStub('POSTNL'))).toBeUndefined();
+    });
+  });
+
+  describe('hasShipmentOption', () => {
+    it('returns true when the shipment carrier exposes the option', async () => {
+      const shipment = buildCarrier({
+        carrier: 'POSTNL',
+        options: {requiresSignature: {} as never},
+      });
+      queryStore.setQuery(shipmentModifier('order-1'), 'success', [shipment]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().hasShipmentOption(formStub('POSTNL'), 'requiresSignature')).toBe(true);
+    });
+
+    it('returns false when the option is absent from the carrier', async () => {
+      const shipment = buildCarrier({carrier: 'POSTNL', options: {}});
+      queryStore.setQuery(shipmentModifier('order-1'), 'success', [shipment]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().hasShipmentOption(formStub('POSTNL'), 'requiresSignature')).toBe(false);
+    });
+  });
+
+  describe('getInsuranceOptions', () => {
+    const formatter = {format: (_: unknown, n: number) => `€${n}`} as never;
+
+    it('returns [] when max insurance amount is zero', async () => {
+      const shipment = buildCarrier({
+        carrier: 'POSTNL',
+        options: {
+          insurance: {
+            insuredAmount: {
+              min: {amount: 0, currency: 'EUR'},
+              max: {amount: 0, currency: 'EUR'},
+              default: {amount: 0, currency: 'EUR'},
+            },
+          } as never,
+        },
+      });
+      queryStore.setQuery(shipmentModifier('order-1'), 'success', [shipment]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+
+      expect(useFormCapabilities().getInsuranceOptions(formStub('POSTNL'), formatter)).toEqual([]);
+    });
+
+    it('switches step from 250 to 500 across the 500€ threshold', async () => {
+      const shipment = buildCarrier({
+        carrier: 'POSTNL',
+        options: {
+          insurance: {
+            insuredAmount: {
+              min: {amount: 0, currency: 'EUR'},
+              // max is 1000€ in cents
+              max: {amount: 100_000, currency: 'EUR'},
+              default: {amount: 0, currency: 'EUR'},
+            },
+          } as never,
+        },
+      });
+      queryStore.setQuery(shipmentModifier('order-1'), 'success', [shipment]);
+
+      const {useFormCapabilities} = await import('./useFormCapabilities');
+      const opts = useFormCapabilities().getInsuranceOptions(formStub('POSTNL'), formatter);
+      const values = opts.map((o) => o.value);
+
+      // First entry is the inherit default; subsequent values are cent amounts as strings.
+      expect(values[0]).toBe(TriState.Inherit);
+      // 0, 250, 500 (low steps) — then 1000 (high step from 500). Exact sequence verifies
+      // the boundary semantics — replacing `<` with `<=` on LOW_THRESHOLD would shift these.
+      expect(values.slice(1)).toEqual(['0', '25000', '50000', '100000']);
+    });
+  });
+});