@myparcel-dev/pdk-admin 1.14.2 → 2.0.1

package/src/forms/shipmentOptions/wireProxyCapabilities.ts

@@ -0,0 +1,102 @@
+import {computed, onScopeDispose, type Ref} from 'vue';
+import {type FormInstance} from '@myparcel-dev/vue-form-builder';
+import {BackendEndpoint, type Plugin} from '@myparcel-dev/pdk-common';
+import {globalLogger} from '../../services';
+import {useQueryStore} from '../../stores';
+import {
+  useShipmentCapabilitiesQuery,
+  type CapabilitiesSelection,
+} from '../../actions/composables/queries/account/useShipmentCapabilitiesQuery';
+import {
+  useOrderCapabilitiesQuery,
+  type OrderCapabilitiesInput,
+} from '../../actions/composables/queries/account/useOrderCapabilitiesQuery';
+import {useCapabilitiesWatcher, type FormInput, type OrderInput} from './useCapabilitiesWatcher';
+import {FIELD_CARRIER, FIELD_DELIVERY_TYPE, FIELD_MANUAL_WEIGHT, FIELD_PACKAGE_TYPE} from './field';
+
+/**
+ * Wire BOTH capabilities queries — order-scoped (cc + weight) and shipment-scoped (full
+ * selection) — into the shipment-options form for a single order, register them in the query
+ * store under composite-string modifiers (`${orderId}.order` and `${orderId}.shipment`), and
+ * tear them down when the form's scope disposes (modal close).
+ *
+ * The two queries serve different concerns:
+ *
+ * - **Order query** drives the carrier / packageType / deliveryType dropdowns from each
+ *   carrier's flat union arrays. Refetches only when destination or weight change.
+ * - **Shipment query** drives per-option metadata (`isRequired`, `requires`, `excludes`,
+ *   `insuredAmount`) for the chosen combination. Refetches when any axis of the selection
+ *   changes; the empty-result case is the invalid-combo signal consumed by
+ *   `useCapabilitiesAutoClear`.
+ *
+ * Manual-weight reactivity: weight is sourced from `FIELD_MANUAL_WEIGHT` when the user has set
+ * one, otherwise from `order.physicalProperties.initialWeight`. Both queries refetch when
+ * weight changes through the slider.
+ *
+ * Skipped for bulk forms (no single orderId) and for orders without an externalIdentifier (no
+ * key to register under).
+ */
+export const wireProxyCapabilities = (
+  form: FormInstance,
+  order: Plugin.ModelContextOrderDataContext,
+): {selection: Readonly<Ref<CapabilitiesSelection>>} | undefined => {
+  const orderId = order.externalIdentifier;
+
+  if (!orderId) {
+    globalLogger.debug('wireProxyCapabilities', 'skipped — order has no externalIdentifier', {order});
+
+    return undefined;
+  }
+
+  const orderModifier = `${orderId}.order`;
+  const shipmentModifier = `${orderId}.shipment`;
+
+  // Use `form.getValue(name)` (which goes through `q(field.ref)` / `toValue` internally) rather
+  // than `form.values[name]` so reactive deps are tracked correctly inside computed/watchers.
+  const orderInput = computed<OrderInput>(() => {
+    // FIELD_MANUAL_WEIGHT carries `TriState.Inherit` (-1) when the user hasn't entered a manual
+    // override; only positive numbers represent an actual weight. Treat anything else as "unset"
+    // and fall back to the order's initial weight.
+    const manualWeightRaw = form.getValue(FIELD_MANUAL_WEIGHT);
+    const manualWeight = typeof manualWeightRaw === 'number' && manualWeightRaw > 0 ? manualWeightRaw : undefined;
+
+    return {
+      cc: order.shippingAddress?.cc,
+      weight: manualWeight ?? order.physicalProperties?.initialWeight,
+    };
+  });
+
+  const formInput = computed<FormInput>(() => ({
+    carrier: form.getValue<string | undefined>(FIELD_CARRIER),
+    packageType: form.getValue<string | undefined>(FIELD_PACKAGE_TYPE),
+    deliveryType: form.getValue<string | undefined>(FIELD_DELIVERY_TYPE),
+  }));
+
+  const selection = useCapabilitiesWatcher(orderInput, formInput);
+
+  const orderInputForQuery = computed<OrderCapabilitiesInput>(() => ({
+    cc: selection.value.cc,
+    weight: selection.value.weight,
+  }));
+
+  const orderQuery = useOrderCapabilitiesQuery(orderInputForQuery);
+  const shipmentQuery = useShipmentCapabilitiesQuery(selection);
+
+  const queryStore = useQueryStore();
+
+  queryStore.register(BackendEndpoint.ProxyCapabilities, orderModifier, orderQuery);
+  queryStore.register(BackendEndpoint.ProxyCapabilities, shipmentModifier, shipmentQuery);
+
+  // Drop both store entries when the form scope disposes (modal close). Without this, reopening
+  // the modal for the same order would surface the prior session's stale data because
+  // `register` returns the existing entry on second registration.
+  onScopeDispose(() => {
+    queryStore.unregister(BackendEndpoint.ProxyCapabilities, orderModifier);
+    queryStore.unregister(BackendEndpoint.ProxyCapabilities, shipmentModifier);
+  });
+
+  return {selection};
+};
+
+// Re-exported for the auto-clear composable so it can refer to the same selection-shape type.
+export type {CapabilitiesSelection};

package/src/index.ts

@@ -42,6 +42,7 @@ export {
   AdminModalKey,
   AdminView,
   NotificationCategory,
+  OrderMode,
   allAdminComponentNames,
   optionalAdminActionContainerComponentNames,
   optionalAdminComponentNames,
@@ -99,6 +100,7 @@ export {
   useModalElementContext,
   useMultiSelectInputContext,
   useOrderData,
+  useOrderMode,
   useOrdersData,
   useProductData,
   useRadioGroupContext,

package/src/pdk/instance/plugins/createRegisterComponentsPlugin.ts

@@ -67,6 +67,8 @@ export const createRegisterComponentsPlugin: PdkAppPlugin = ({config, logger}) =
       Object.entries(getOptionalComponents(app)).forEach(([componentName, component]) => {
         const componentToRegister = typeof component === 'string' ? componentsFromConfig[component] : component;
 
+        if (!componentToRegister) return;
+
         app.component(prefixComponent(componentName), markRaw(componentToRegister));
       });
 

package/src/sdk/composables/api/useFetchCarrier.ts

@@ -1,18 +1,53 @@
 /* eslint-disable @typescript-eslint/explicit-module-boundary-types */
 import {useQuery, useQueryClient} from '@tanstack/vue-query';
 import {type EndpointResponse, type GetCarrier} from '@myparcel-dev/sdk';
-import {type CarrierName} from '@myparcel-dev/constants';
+import {CarrierId, CarrierName, type CarrierNameOrId} from '@myparcel-dev/constants';
 import {useMyParcelApi} from '../useMyParcelApi';
 
-export const useFetchCarrier = (carrier?: CarrierName) => {
+const KNOWN_CARRIER_NAMES = new Set<string>(Object.values(CarrierName));
+const KNOWN_CARRIER_IDS = new Set<number>(
+  Object.values(CarrierId).filter((value): value is number => typeof value === 'number'),
+);
+
+const resolveCarrierIdentifier = (input: string | number): CarrierNameOrId => {
+  if (typeof input === 'number') {
+    if (KNOWN_CARRIER_IDS.has(input)) {
+      return input as CarrierNameOrId;
+    }
+
+    // eslint-disable-next-line no-console
+    console.warn(`[useFetchCarrier] Unknown carrier ID "${input}", it may cause issues.`);
+
+    return input as CarrierNameOrId;
+  }
+
+  if (KNOWN_CARRIER_NAMES.has(input)) {
+    return input as CarrierNameOrId;
+  }
+
+  const normalized = input.replace(/_/g, '').toLowerCase();
+
+  if (KNOWN_CARRIER_NAMES.has(normalized)) {
+    return normalized as CarrierNameOrId;
+  }
+
+  // eslint-disable-next-line no-console
+  console.warn(`[useFetchCarrier] Unknown carrier identifier "${input}", it may cause issues.`);
+
+  // Cast input as CarrierNameOrId, even if it's not valid, to allow the query to run and return an error from the API if it's truly invalid.
+  return input as CarrierNameOrId;
+};
+
+export const useFetchCarrier = (carrier?: string | number) => {
+  const resolved = carrier === undefined ? undefined : resolveCarrierIdentifier(carrier);
   const queryClient = useQueryClient();
-  const queryKey = ['carriers', {name: carrier}] as const;
+  const queryKey = ['carriers', {name: resolved}] as const;
 
   return useQuery<EndpointResponse<GetCarrier>[number]>(
     queryKey,
     async () => {
       const sdk = useMyParcelApi();
-      const carriers = await sdk.getCarrier(carrier ? {path: {carrier}} : undefined);
+      const carriers = await sdk.getCarrier(resolved === undefined ? undefined : {path: {carrier: resolved}});
 
       return carriers[0];
     },

package/src/sdk/composables/usePdkAdminApi.ts

@@ -1,6 +1,6 @@
 import {createGlobalState} from '@vueuse/core';
-import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
 import {createMyParcelSdk, type HttpMethod, type MyParcelSdk} from '@myparcel-dev/sdk';
+import {type BackendEndpoint} from '@myparcel-dev/pdk-common';
 import {AbstractPdkEndpoint} from '../endpoints';
 import {PdkFetchClient} from '../PdkFetchClient';
 import {useGlobalContext} from '../../composables';
@@ -16,12 +16,17 @@ export const usePdkAdminApi = createGlobalState((): MyParcelSdk<AbstractPdkEndpo
   });
 
   const pdkEndpoints = Object.entries(globalContext.endpoints).map(([endpointName, options]) => {
+    // Effectively cast null as 'undefined' to prevent the SDK casting the prefix property to the string 'null'.
+    const property = typeof options.property === 'string' ? options.property : undefined;
+    const responseProperty = typeof options.responseProperty === 'string' ? options.responseProperty : undefined;
     class PdkEndpoint extends AbstractPdkEndpoint {
       public readonly method = options.method.toUpperCase() as HttpMethod;
       public readonly name = endpointName as BackendEndpoint;
       public readonly path = options.path;
-      public readonly property = options.property;
-      public readonly responseProperty = options.responseProperty ?? options.property;
+      public readonly property = property;
+      // If this is undefined, the SDK falls back to the endpoint instance's `property` value above.
+      public readonly responseProperty = responseProperty;
+      public readonly useDataEnvelope = typeof options.useDataEnvelope === 'undefined' ? true : options.useDataEnvelope;
     }
 
     return new PdkEndpoint({

package/src/stores/useActionStore.spec.ts

@@ -0,0 +1,101 @@
+// @vitest-environment happy-dom
+
+import {computed, defineComponent, h} from 'vue';
+import {afterEach, beforeEach, describe, expect, it, vi} from 'vitest';
+import {mount} from '@vue/test-utils';
+import {AdminAction, OrderMode} from '../data';
+import {useOrderMode} from '../composables/context/useOrderMode';
+import {ORDER_VIEW_IN_BACKOFFICE_ID} from '../actions';
+import {doComponentTestSetup, doComponentTestTeardown} from '../__tests__';
+import {useActionStore} from './useActionStore';
+
+vi.mock('../composables/context/useOrderMode', () => ({
+  useOrderMode: vi.fn(),
+}));
+
+const mockedUseOrderMode = vi.mocked(useOrderMode);
+
+describe('useActionStore', () => {
+  beforeEach(() => {
+    doComponentTestSetup();
+  });
+
+  afterEach(() => {
+    doComponentTestTeardown();
+  });
+
+  describe('registerOrderActions', () => {
+    const mountWithStore = (mode: OrderMode) => {
+      mockedUseOrderMode.mockReturnValue(computed(() => mode));
+
+      let store!: ReturnType<typeof useActionStore>;
+
+      mount(
+        defineComponent({
+          setup() {
+            store = useActionStore();
+            store.registerOrderActions();
+
+            return () => h('div');
+          },
+        }),
+      );
+
+      return store;
+    };
+
+    const commonActions = [AdminAction.OrdersEdit, AdminAction.OrdersFetch, AdminAction.OrdersUpdate];
+
+    it.each(commonActions)('registers common action %s regardless of mode', (action) => {
+      for (const mode of [OrderMode.Shipments, OrderMode.OrderV1, OrderMode.OrderV2]) {
+        const store = mountWithStore(mode);
+        expect(store.get(action), `${action} should be registered in ${mode} mode`).toBeDefined();
+      }
+    });
+
+    it('registers shipment-specific actions in Shipments mode', () => {
+      const store = mountWithStore(OrderMode.Shipments);
+
+      expect(store.get(AdminAction.OrdersPrint)).toBeDefined();
+      expect(store.get(AdminAction.OrdersExport)).toBeDefined();
+      expect(store.get(AdminAction.OrdersExportPrint)).toBeDefined();
+      expect(store.get(AdminAction.ShipmentsExportReturn)).toBeDefined();
+      expect(store.get(AdminAction.ShipmentsDelete)).toBeDefined();
+      expect(store.get(AdminAction.ShipmentsUpdate)).toBeDefined();
+      expect(store.get(AdminAction.ShipmentsPrint)).toBeDefined();
+      expect(store.get(ORDER_VIEW_IN_BACKOFFICE_ID)).toBeUndefined();
+    });
+
+    it('registers order export and backoffice actions in OrderV1 mode', () => {
+      const store = mountWithStore(OrderMode.OrderV1);
+
+      expect(store.get(AdminAction.OrdersExport)).toBeDefined();
+      expect(store.get(ORDER_VIEW_IN_BACKOFFICE_ID)).toBeDefined();
+      expect(store.get(AdminAction.OrdersExportPrint)).toBeUndefined();
+      expect(store.get(AdminAction.ShipmentsExportReturn)).toBeUndefined();
+      expect(store.get(AdminAction.ShipmentsDelete)).toBeUndefined();
+      expect(store.get(AdminAction.ShipmentsUpdate)).toBeUndefined();
+      expect(store.get(AdminAction.ShipmentsPrint)).toBeUndefined();
+    });
+
+    it('registers the same shipment-specific action set as Shipments in OrderV2 mode (hybrid)', () => {
+      const store = mountWithStore(OrderMode.OrderV2);
+
+      expect(store.get(AdminAction.OrdersPrint)).toBeDefined();
+      expect(store.get(AdminAction.OrdersExport)).toBeDefined();
+      expect(store.get(AdminAction.OrdersExportPrint)).toBeDefined();
+      expect(store.get(AdminAction.ShipmentsExportReturn)).toBeDefined();
+      expect(store.get(AdminAction.ShipmentsDelete)).toBeDefined();
+      expect(store.get(AdminAction.ShipmentsUpdate)).toBeDefined();
+      expect(store.get(AdminAction.ShipmentsPrint)).toBeDefined();
+      // The backoffice view is V1-only and should still not appear in V2.
+      expect(store.get(ORDER_VIEW_IN_BACKOFFICE_ID)).toBeUndefined();
+    });
+
+    it('registers shipmentsExportReturn exactly once in Shipments mode', () => {
+      const store = mountWithStore(OrderMode.Shipments);
+
+      expect(store.get(AdminAction.ShipmentsExportReturn)).toBeDefined();
+    });
+  });
+});

package/src/stores/useActionStore.ts

@@ -4,22 +4,14 @@ import {type OneOrMore, type PromiseOr, toArray} from '@myparcel-dev/ts-utils';
 import {type ActionParameters, type AnyActionDefinition, type ResolvedAction} from '../types';
 import {createAction, getActionIdentifier} from '../services';
 import {type AdminAction} from '../data';
-import {usePluginSettings} from '../composables';
+import {useOrderMode} from '../composables';
 import {
   modalCloseAction,
   modalSubmitFormAction,
-  orderExportAction,
-  orderExportToShipmentsAction,
   ordersEditAction,
-  ordersExportPrintShipmentsAction,
   ordersFetchAction,
-  ordersPrintAction,
   ordersUpdateAction,
-  orderViewInBackofficeAction,
-  shipmentsDeleteAction,
-  shipmentsExportReturnAction,
-  shipmentsPrintAction,
-  shipmentsUpdateAction,
+  STORE_MODE_ACTIONS,
   webhooksCreateAction,
   webhooksDeleteAction,
   webhooksFetchAction,
@@ -62,25 +54,9 @@ export const useActionStore = defineStore('actions', () => {
     dispatch,
 
     registerOrderActions: () => {
-      const pluginSettings = usePluginSettings();
+      const orderMode = useOrderMode();
 
-      register([
-        ordersEditAction,
-        ordersFetchAction,
-        ordersPrintAction,
-        ordersUpdateAction,
-        ...(pluginSettings.order.orderMode
-          ? [orderExportAction, orderViewInBackofficeAction]
-          : [
-              orderExportToShipmentsAction,
-              ordersExportPrintShipmentsAction,
-              shipmentsExportReturnAction,
-              shipmentsExportReturnAction,
-              shipmentsDeleteAction,
-              shipmentsUpdateAction,
-              shipmentsPrintAction,
-            ]),
-      ]);
+      register([ordersEditAction, ordersFetchAction, ordersUpdateAction, ...STORE_MODE_ACTIONS[orderMode.value]]);
     },
 
     registerModalActions: () => {

package/src/stores/useQueryStore.ts

@@ -80,6 +80,20 @@ export const useQueryStore = defineStore('query', () => {
     return query;
   };
 
+  /**
+   * Drop the entry for {endpoint, modifier?} from the store. Used when a feature that registered
+   * its own query is unmounted (e.g. shipment-options modal closing) so a fresh registration on
+   * the next open isn't shadowed by stale data.
+   */
+  const unregister = <E extends BackendEndpoint>(endpoint: E, modifier?: PlainModifier): void => {
+    const key = createQueryCacheKey(endpoint, modifier);
+
+    if (queries.value[key] === undefined) return;
+
+    globalLogger.debug(`Unregistering query ${key}`);
+    delete queries.value[key];
+  };
+
   const registerShipmentQueries = (
     shipmentIds: MaybeRef<OneOrMore<number>>,
     orderIds?: MaybeRef<OneOrMore<string>>,
@@ -125,6 +139,7 @@ export const useQueryStore = defineStore('query', () => {
     get,
     has,
     register,
+    unregister,
 
     registerShipmentQueries,
 

package/src/types/actions/endpoints.types.ts

@@ -29,4 +29,5 @@ export type BackendQueryEndpoints =
   | BackendEndpoint.FetchOrders
   | BackendEndpoint.FetchProducts
   | BackendEndpoint.FetchShipments
-  | BackendEndpoint.FetchWebhooks;
+  | BackendEndpoint.FetchWebhooks
+  | BackendEndpoint.ProxyCapabilities;

package/src/types/sdk.types.ts

@@ -1,6 +1,8 @@
+import {type RecursivePartial} from '@myparcel-dev/ts-utils';
 import {
   type AdminContextKey,
   type BackendEndpoint,
+  type CarrierModel,
   type ExtractEndpointDefinition,
   type LabelFormat,
   type LabelOutput,
@@ -10,7 +12,6 @@ import {
   type Settings,
   type Shipment,
 } from '@myparcel-dev/pdk-common';
-import {type RecursivePartial} from '@myparcel-dev/ts-utils';
 import {type AdminContextObject} from './context.types';
 import {type WebhookDefinition} from './common.types';
 
@@ -185,6 +186,57 @@ interface DebugSwitchToProductionApiDefinition extends PdkEndpointDefinition {
   response: void;
 }
 
+interface ProxyCapabilitiesDefinition extends PdkEndpointDefinition {
+  name: BackendEndpoint.ProxyCapabilities;
+  /**
+   * Action-control parameters live in the query string so the request body stays a clean
+   * mirror of the actual capabilities API contract.
+   *
+   * `filterSupported` (opt-in): when `true`, the action applies the registered-option allowlist
+   * server-side (`Carrier::filterRegisteredOptions`). When `false` or `undefined`, the backend
+   * should treat it as not opted in, preserving the existing unfiltered SDK passthrough
+   * behavior for callers.
+   */
+  parameters?: {filterSupported?: boolean};
+  /**
+   * Body shape mirrors the actual capabilities API request: camelCase keys at every level
+   * matching the SDK's attribute maps (`countryCode`, `physicalProperties`, `packageType`,
+   * `deliveryType`). The PHP action translates these top-level camelCase keys to the
+   * snake_case names the SDK PHP model uses internally — generic translation read from the
+   * SDK's own attribute map.
+   *
+   * `physicalProperties.weight` is an object `{value, unit}`, not a primitive — that's how the
+   * SDK's `PhysicalPropertiesWeightV2` model defines it on the wire.
+   */
+  body: {
+    recipient: {countryCode: string};
+    physicalProperties?: {
+      weight?: {value: number; unit: 'g' | 'kg'};
+    };
+    carrier?: string;
+    packageType?: string;
+    deliveryType?: string;
+    options?: string[];
+  };
+  response: {results: CarrierModel[]};
+  formattedResponse: CarrierModel[];
+}
+
+/**
+ * Body / parameters / call shape for `pdk.proxyCapabilities`. Both order-scoped and
+ * shipment-scoped query composables share these — the order-scoped call simply omits
+ * `parameters` at the call site. Derived from {@link ProxyCapabilitiesDefinition} so any
+ * change to the endpoint contract flows through automatically.
+ */
+export type ProxyCapabilitiesBody = NonNullable<ProxyCapabilitiesDefinition['body']>;
+
+export type ProxyCapabilitiesParameters = NonNullable<ProxyCapabilitiesDefinition['parameters']>;
+
+export type ProxyCapabilitiesCall = (options: {
+  body: ProxyCapabilitiesBody;
+  parameters?: ProxyCapabilitiesParameters;
+}) => Promise<ProxyCapabilitiesDefinition['response']>;
+
 export type BackendEndpointDefinition =
   | CreateWebhooksDefinition
   | DebugDownloadLogsDefinition
@@ -201,6 +253,7 @@ export type BackendEndpointDefinition =
   | FetchWebhooksDefinition
   | PrintOrdersDefinition
   | PrintShipmentsDefinition
+  | ProxyCapabilitiesDefinition
   | UpdateAccountDefinition
   | UpdateOrdersDefinition
   | UpdatePluginSettingsDefinition

package/src/utils/forms/formToBody.ts

@@ -1,6 +1,7 @@
 import {type FormInstance} from '@myparcel-dev/vue-form-builder';
 import {isOfType} from '@myparcel-dev/ts-utils';
 import {convertDotNotationToObject} from '../convertDotNotationToObject';
+import {getEnabledValues} from './getEnabledValues';
 
 export const formToBody = <T extends Record<string, unknown> = Record<string, unknown>>(
   form?: false | FormInstance | T,
@@ -9,7 +10,7 @@ export const formToBody = <T extends Record<string, unknown> = Record<string, un
     return form ? form : ({} as T);
   }
 
-  const formValues = form.getValues();
+  const formValues = getEnabledValues(form);
   return convertDotNotationToObject(formValues, (value) => {
     return typeof value === 'boolean' ? Number(value) : value;
   }) as T;

package/src/utils/forms/getEnabledValues.spec.ts

@@ -0,0 +1,66 @@
+import {describe, expect, it} from 'vitest';
+import {ref, computed} from 'vue';
+import {type FormInstance} from '@myparcel-dev/vue-form-builder';
+import {getEnabledValues} from './getEnabledValues';
+
+const createMockField = (name: string, value: unknown, isDisabled: boolean) => ({
+  name,
+  ref: ref(value),
+  isDisabled: ref(isDisabled),
+});
+
+const createMockForm = (fields: ReturnType<typeof createMockField>[]): FormInstance => {
+  const allValues: Record<string, unknown> = {};
+
+  for (const field of fields) {
+    allValues[field.name] = field.ref.value;
+  }
+
+  return {
+    interactiveFields: computed(() => fields),
+    getValues: () => allValues,
+  } as unknown as FormInstance;
+};
+
+describe('getEnabledValues', () => {
+  it('returns values from enabled fields only', () => {
+    const form = createMockForm([
+      createMockField('deliveryOptions.carrier', 'POSTNL', false),
+      createMockField('deliveryOptions.shipmentOptions.requiresSignature', true, false),
+      createMockField('deliveryOptions.shipmentOptions.requiresAgeVerification', true, true),
+    ]);
+
+    const values = getEnabledValues(form);
+
+    expect(values).toEqual({
+      'deliveryOptions.carrier': 'POSTNL',
+      'deliveryOptions.shipmentOptions.requiresSignature': true,
+    });
+    expect(values).not.toHaveProperty('deliveryOptions.shipmentOptions.requiresAgeVerification');
+  });
+
+  it('returns all values when no fields are disabled', () => {
+    const form = createMockForm([
+      createMockField('deliveryOptions.carrier', 'POSTNL', false),
+      createMockField('deliveryOptions.shipmentOptions.requiresSignature', true, false),
+    ]);
+
+    const values = getEnabledValues(form);
+
+    expect(values).toEqual({
+      'deliveryOptions.carrier': 'POSTNL',
+      'deliveryOptions.shipmentOptions.requiresSignature': true,
+    });
+  });
+
+  it('returns empty object when all fields are disabled', () => {
+    const form = createMockForm([
+      createMockField('deliveryOptions.shipmentOptions.requiresSignature', true, true),
+      createMockField('deliveryOptions.shipmentOptions.requiresAgeVerification', false, true),
+    ]);
+
+    const values = getEnabledValues(form);
+
+    expect(values).toEqual({});
+  });
+});

package/src/utils/forms/getEnabledValues.ts

@@ -0,0 +1,25 @@
+import {toValue} from 'vue';
+import {type FormInstance} from '@myparcel-dev/vue-form-builder';
+
+type FormValues = Record<string, unknown>;
+
+/**
+ * Returns form values excluding disabled fields.
+ *
+ * Works around a vue-form-builder bug where `getValues()` retains stale
+ * values from fields that became disabled after initialisation (e.g. when
+ * switching carriers hides unsupported shipment options).
+ */
+export const getEnabledValues = <T extends FormValues = FormValues>(form: FormInstance): T => {
+  const values: FormValues = {};
+
+  for (const field of toValue(form.interactiveFields)) {
+    if (toValue(field.isDisabled)) {
+      continue;
+    }
+
+    values[field.name] = toValue(field.ref);
+  }
+
+  return values as T;
+};

package/src/utils/forms/index.ts

@@ -2,3 +2,4 @@ export * from './createFormElement';
 export * from './createShipmentFormName';
 export * from './formToBody';
 export * from './generateFieldId';
+export * from './getEnabledValues';

package/src/utils/translations/getDynamicTranslation.ts

@@ -3,5 +3,5 @@ export const getDynamicTranslation = (prefix: string, input?: string): string =>
     return prefix;
   }
 
-  return `${prefix}_${input}`;
+  return `${prefix}_${input.toLowerCase()}`;
 };

package/src/views/OrderBox.vue

@@ -1,13 +1,21 @@
 <template>
   <ShipmentOptionsBox />
 
-  <ShipmentTableBox v-if="!orderMode && data?.shipments.some((item) => !item.deleted)" />
+  <!--
+    Shipments mode plus V2 hybrid both surface manual shipments here.
+    @TODO INT-1590: restrict to OrderMode.Shipments once V2 with an active sales
+          channel hides the manual paths again. Original gate preserved as a
+          comment below for easy restoration.
+  -->
+  <!-- <ShipmentTableBox v-if="orderMode === OrderMode.Shipments && data?.shipments.some((item) => !item.deleted)" /> -->
+  <ShipmentTableBox v-if="orderMode !== OrderMode.OrderV1 && data?.shipments.some((item) => !item.deleted)" />
 </template>
 
 <script lang="ts" setup>
 import {computed, defineAsyncComponent, toValue} from 'vue';
 import {useActionStore, useQueryStore} from '../stores';
-import {useOrderData, usePluginSettings} from '../composables';
+import {OrderMode} from '../data';
+import {useOrderData, useOrderMode} from '../composables';
 import ShipmentOptionsBox from '../components/OrderBox/ShipmentOptionsBox.vue';
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
@@ -22,11 +30,9 @@ const actionStore = useActionStore();
 
 actionStore.registerOrderActions();
 
-const pluginSettings = usePluginSettings();
+const orderMode = useOrderMode();
 
 const {query} = useOrderData();
 
 const data = computed(() => toValue(query.data));
-
-const {orderMode} = pluginSettings.order;
 </script>