@managesome/eposmatic-toolkit 0.2.720 → 0.2.732

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -275,7 +275,7 @@ describe('Half/Half alone — convertHalfHalfToItem pricing', () => {
275
275
  orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
276
276
  defaultMenuId: null,
277
277
  soldoutModifiers: [],
278
- });
278
+ }).workingData;
279
279
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_torent', true, false);
280
280
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_torent', true, false);
281
281
  const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
@@ -844,13 +844,11 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
844
844
  { item_id: 'torent', sort_id: 2, upsell_price: { BASE_PRICE: 200 } },
845
845
  { item_id: 'halfhalf-1', sort_id: 3, upsell_price: { BASE_PRICE: 100 } },
846
846
  ];
847
- function buildSpecialItem(items = specialItems) {
848
- return (0, specials_helpers_1.convertSpecialToItem)(modifySpecialItems(makeSpecial(), items), {
847
+ function buildState() {
848
+ const item = (0, specials_helpers_1.convertSpecialToItem)(modifySpecialItems(makeSpecial(), specialItems), {
849
849
  milan: makeItem('milan', { modifiers: makePizzaSizeAndExtra() }),
850
850
  torent: makeItem('torent', { price: { BASE_PRICE: 1200 } }),
851
851
  }, { 'halfhalf-1': makeHalfHalfSetup() });
852
- }
853
- function buildEngine(item = buildSpecialItem()) {
854
852
  return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
855
853
  item,
856
854
  orderItem: undefined,
@@ -861,58 +859,50 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
861
859
  soldoutModifiers: [],
862
860
  });
863
861
  }
864
- /**
865
- * Scoped baseline: ONLY the nested half-half segment prices. A special's
866
- * top-level item options reuse their `_id`s at different prices (full upsell
867
- * vs per-segment share), so the unscoped map is walk-order dependent.
868
- */
869
- function nestedBasePrices(item = buildSpecialItem()) {
870
- return (0, order_engine_1.getOptionPriceMapFromItem)(item, PLATFORM, { nestedHalfHalfSegmentsOnly: true });
871
- }
872
- /** Real UI flow: pick one option per segment of the nested half-half. */
873
- function selectNested(engine, picks) {
874
- let next = engine;
875
- next = (0, order_engine_1.setCheckFieldInOrderEngineItem)(next, `mod-pizza_halfhalf-1_seg-1_${picks[0]}`, true);
876
- next = (0, order_engine_1.setCheckFieldInOrderEngineItem)(next, `mod-pizza_halfhalf-1_seg-2_${picks[1]}`, true);
877
- return next;
878
- }
879
- function nestedHalfHalf(engine) {
880
- return engine.modifiers[0].options.find((o) => o._id === 'halfhalf-1');
881
- }
882
- function nestedPrice(engine, segmentIndex, optionId) {
883
- return nestedHalfHalf(engine).modifiers[segmentIndex].options.find((o) => o._id === optionId).price;
884
- }
885
- function topLevelPrice(engine, optionId) {
886
- return engine.modifiers[0].options.find((o) => o._id === optionId).price;
862
+ function buildEngine() {
863
+ return buildState().workingData;
887
864
  }
888
865
  function segmentOptions(engine, halfHalfId = 'halfhalf-1') {
889
866
  const hh = engine.modifiers[0].options.find((o) => o._id === halfHalfId);
890
867
  return hh.modifiers.map((seg) => seg.options.map((o) => ({ id: o._id, price: o.price, default: o.default })));
891
868
  }
892
- it('basic + premium selection raises basic half to premium using special-derived prices (+1 each)', () => {
893
- let engine = buildEngine();
894
- // Real UI flow: selection happens through the special's engine item, so
895
- // the identifier is the FULL path (group -> half-half option -> segment
896
- // -> option). setCheckField keeps prices PRISTINE — normalization is a
897
- // derived pass applied at display/submit time.
898
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true);
869
+ it('basic + premium selection levels the cheap half to the premium one (special-derived prices)', () => {
870
+ const state = buildState();
871
+ const normalize = (engine) => (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
872
+ originalPriceReferences: state.originalPriceReferences,
873
+ });
874
+ // Real UI flow: the selection goes through the special's engine item (the
875
+ // identifier is the FULL path: group -> half-half option -> segment ->
876
+ // option) and the drawer normalizes right after it.
877
+ let engine = normalize((0, order_engine_1.setCheckFieldInOrderEngineItem)(state.workingData, 'mod-pizza_halfhalf-1_seg-1_milan', true, false));
878
+ // Only the cheap half is picked so far — it IS the most expensive selected
879
+ // half, so nothing is levelled yet.
899
880
  expect(segmentOptions(engine)[0].find((o) => o.id === 'milan').price).toBe(0);
900
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true);
901
- const after = segmentOptions((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine));
902
- // seg-1 selected MILAN raised 0 -> 100; seg-2 selected TORENT stays 100.
903
- // Unselected options untouched; NO 575 from Pizza Size anywhere.
881
+ // Picking the premium half (100) makes it drive the rule: every cheaper
882
+ // option — selected or not — is levelled to it, so the drawer can show
883
+ // what picking it would cost. NO 575 from Pizza Size anywhere.
884
+ engine = normalize((0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false));
885
+ const after = segmentOptions(engine);
904
886
  expect(after[0].find((o) => o.id === 'milan').price).toBe(100);
905
887
  expect(after[1].find((o) => o.id === 'torent').price).toBe(100);
906
- const flat = after.flat();
907
- expect(flat.every((o) => o.price === 0 || o.price === 100)).toBe(true);
888
+ // SEG-1's alternatives SWITCH to the other segment's level (SEG-2 still
889
+ // holds the premium pick), so they show the same 100.
890
+ expect(after[0].find((o) => o.id === 'torent').price).toBe(100);
891
+ // SEG-2's alternatives REPLACE its own premium pick when chosen (cheap
892
+ // pair = no level), so MILAN stays at its own price there.
893
+ expect(after[1].find((o) => o.id === 'milan').price).toBe(0);
908
894
  });
909
895
  it('is idempotent (re-applying never lowers or changes prices)', () => {
910
- let engine = buildEngine();
911
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true);
912
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true);
913
- const once = segmentOptions((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine));
914
- const twice = segmentOptions((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine)));
915
- expect(twice).toEqual(once);
896
+ const state = buildState();
897
+ let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(state.workingData, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
898
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
899
+ const once = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
900
+ originalPriceReferences: state.originalPriceReferences,
901
+ });
902
+ const twice = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(once, {
903
+ originalPriceReferences: state.originalPriceReferences,
904
+ });
905
+ expect(segmentOptions(twice)).toEqual(segmentOptions(once));
916
906
  });
917
907
  it('does nothing when the half-half flag is off', () => {
918
908
  const item = (0, specials_helpers_1.convertSpecialToItem)(modifySpecialItems(makeSpecial(), specialItems), { milan: makeItem('milan'), torent: makeItem('torent') }, { 'halfhalf-1': makeHalfHalfSetup({ choose_expensive_segment_price: false }) });
@@ -924,7 +914,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
924
914
  orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
925
915
  defaultMenuId: null,
926
916
  soldoutModifiers: [],
927
- });
917
+ }).workingData;
928
918
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
929
919
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
930
920
  const after = segmentOptions(engine);
@@ -944,7 +934,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
944
934
  orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
945
935
  defaultMenuId: null,
946
936
  soldoutModifiers: [],
947
- });
937
+ }).workingData;
948
938
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_milan', true, false);
949
939
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_torent', true, false);
950
940
  const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
@@ -964,7 +954,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
964
954
  'hh-flag': makeHalfHalfSetup({ _id: 'hh-flag' }),
965
955
  'hh-no-flag': makeHalfHalfSetup({ _id: 'hh-no-flag', choose_expensive_segment_price: false }),
966
956
  });
967
- let engine = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
957
+ const state = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
968
958
  item,
969
959
  orderItem: undefined,
970
960
  platform: PLATFORM,
@@ -973,179 +963,54 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
973
963
  defaultMenuId: null,
974
964
  soldoutModifiers: [],
975
965
  });
976
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-1_milan', true);
977
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-2_torent', true);
978
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-1_milan', true);
979
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-2_torent', true);
980
- const normalized = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine);
981
- const hhFlag = normalized.modifiers[0].options.find((o) => o._id === 'hh-flag');
982
- const hhNoFlag = normalized.modifiers[0].options.find((o) => o._id === 'hh-no-flag');
983
- // Flagged: selected free milan raised to the selected expensive half (+100);
966
+ let engine = state.workingData;
967
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-1_milan', true, false);
968
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-2_torent', true, false);
969
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-1_milan', true, false);
970
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-2_torent', true, false);
971
+ engine = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
972
+ originalPriceReferences: state.originalPriceReferences,
973
+ });
974
+ const hhFlag = engine.modifiers[0].options.find((o) => o._id === 'hh-flag');
975
+ const hhNoFlag = engine.modifiers[0].options.find((o) => o._id === 'hh-no-flag');
976
+ // Flagged: the cheap half is levelled to the selected expensive half;
984
977
  // un-flagged: stays free.
985
978
  expect(hhFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
986
979
  expect(hhNoFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(0);
987
980
  });
988
- it('nested base prices are scoped and walk-order independent (top-level price never leaks)', () => {
989
- // Half-half FIRST in the item order: an unscoped map ends with the
990
- // top-level torent price (200) instead of the segment share (100).
991
- const halfHalfFirst = [
992
- { item_id: 'halfhalf-1', sort_id: 1, upsell_price: { BASE_PRICE: 100 } },
993
- { item_id: 'milan', sort_id: 2, upsell_price: null },
994
- { item_id: 'torent', sort_id: 3, upsell_price: { BASE_PRICE: 200 } },
995
- ];
996
- const specialItem = buildSpecialItem(halfHalfFirst);
997
- const scoped = nestedBasePrices(specialItem);
998
- // Segment scope only: the half-half hub and top-level items are absent.
999
- expect(scoped.torent).toBe(100);
1000
- expect(scoped.milan).toBe(0);
1001
- expect(scoped['halfhalf-1']).toBeUndefined();
1002
- // Unscoped, the LAST walker wins — here the top-level torent (200), which
1003
- // is exactly why the drawer scopes the map for specials.
1004
- expect((0, order_engine_1.getOptionPriceMapFromItem)(specialItem, PLATFORM).torent).toBe(200);
1005
- // With the scoped map the pipeline stays correct: the drawn half is raised
1006
- // to the segment share (100) and top-level prices are never touched.
1007
- const engine = (0, order_engine_1.resetOrderEngineItemPrices)(buildEngine(specialItem), scoped, {
1008
- nestedHalfHalfOnly: true,
1009
- });
1010
- expect(topLevelPrice(engine, 'torent')).toBe(200);
1011
- const result = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(engine, ['milan', 'torent']), {
1012
- basePrices: scoped,
1013
- });
1014
- expect(nestedPrice(result, 0, 'milan')).toBe(100);
1015
- expect(nestedPrice(result, 1, 'torent')).toBe(100);
1016
- expect(topLevelPrice(result, 'torent')).toBe(200);
1017
- // Default order (half-half LAST): the scoped map is IDENTICAL, while the
1018
- // unscoped one flips to the segment share — order must not matter.
1019
- const defaultItem = buildSpecialItem();
1020
- expect(nestedBasePrices(defaultItem).torent).toBe(100);
1021
- expect((0, order_engine_1.getOptionPriceMapFromItem)(defaultItem, PLATFORM).torent).toBe(100);
1022
- });
1023
- it('user flow: after milan+torent, changing the second half back to milan re-bases the raised half', () => {
1024
- const basePrices = nestedBasePrices();
1025
- const engine = selectNested(buildEngine(), ['milan', 'torent']);
1026
- // Premium pair: milan (0) is raised to torent's segment share (100).
1027
- const displayed = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, { basePrices });
1028
- expect(nestedPrice(displayed, 0, 'milan')).toBe(100);
1029
- expect(nestedPrice(displayed, 1, 'torent')).toBe(100);
1030
- // The user switches the SECOND half to milan (cheap pair). From the
1031
- // pristine drawer state AND from the raised display: the artificially
1032
- // upgraded milan goes back to its own price.
1033
- for (const source of [engine, displayed]) {
1034
- const switched = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(source, ['milan', 'milan']), {
1035
- basePrices,
1036
- });
1037
- expect(nestedPrice(switched, 0, 'milan')).toBe(0);
1038
- expect(nestedPrice(switched, 1, 'milan')).toBe(0);
1039
- // De-selected torent keeps its own segment share everywhere.
1040
- expect(nestedPrice(switched, 0, 'torent')).toBe(100);
1041
- expect(nestedPrice(switched, 1, 'torent')).toBe(100);
1042
- expect(topLevelPrice(switched, 'torent')).toBe(200);
1043
- }
1044
- // Switching back to the premium pair raises again.
1045
- const premiumAgain = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(selectNested(displayed, ['milan', 'milan']), ['torent', 'torent']), { basePrices });
1046
- expect(nestedPrice(premiumAgain, 0, 'torent')).toBe(100);
1047
- expect(nestedPrice(premiumAgain, 1, 'torent')).toBe(100);
1048
- });
1049
- it('full change matrix (nested): every switch recomputes from the scoped pristine prices', () => {
1050
- const basePrices = nestedBasePrices();
1051
- const baseValues = { milan: 0, torent: 100 };
1052
- const combos = [
1053
- ['milan', 'milan'],
1054
- ['milan', 'torent'],
1055
- ['torent', 'milan'],
1056
- ['torent', 'torent'],
1057
- ];
1058
- const engine = buildEngine();
1059
- for (const from of combos) {
1060
- const fromDisplay = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(engine, from), { basePrices });
1061
- for (const to of combos) {
1062
- const expected = Math.max(baseValues[to[0]], baseValues[to[1]]);
1063
- for (const source of [engine, fromDisplay]) {
1064
- const result = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(source, to), { basePrices });
1065
- expect(nestedPrice(result, 0, to[0])).toBe(expected);
1066
- expect(nestedPrice(result, 1, to[1])).toBe(expected);
1067
- expect(topLevelPrice(result, 'torent')).toBe(200);
1068
- }
1069
- }
1070
- }
1071
- });
1072
- it('is idempotent with basePrices (re-applying never lowers or changes prices)', () => {
1073
- const basePrices = nestedBasePrices();
1074
- const once = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(buildEngine(), ['milan', 'torent']), {
1075
- basePrices,
1076
- });
1077
- const twice = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(once, { basePrices });
1078
- expect(twice).toEqual(once);
1079
- });
1080
- it('engine memory: nested raises are reversible in place, top-level prices untouched', () => {
1081
- // No external maps at all — the engine re-bases from its own stamps.
1082
- let engine = selectNested(buildEngine(), ['milan', 'torent']);
1083
- engine = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine);
1084
- expect(nestedPrice(engine, 0, 'milan')).toBe(100);
1085
- expect(nestedPrice(engine, 1, 'torent')).toBe(100);
1086
- // Stamps are per tree position: the nested segment share (100/0) never
1087
- // collides with the special's own top-level option price (200).
1088
- expect(nestedHalfHalf(engine).modifiers[0].options.find((o) => o._id === 'torent').base_price).toBe(100);
1089
- expect(engine.modifiers[0].options.find((o) => o._id === 'torent').base_price).toBe(200);
1090
- // The user changes the second half to milan on the RAISED engine.
1091
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_milan', true);
1092
- engine = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine);
1093
- // Artificially upgraded milan is back to its own price; de-selected torent
1094
- // keeps its own; the top-level option is never touched.
1095
- expect(nestedPrice(engine, 0, 'milan')).toBe(0);
1096
- expect(nestedPrice(engine, 1, 'milan')).toBe(0);
1097
- expect(nestedPrice(engine, 0, 'torent')).toBe(100);
1098
- expect(topLevelPrice(engine, 'torent')).toBe(200);
1099
- });
1100
- it('edit flow: a persisted nested raise is re-based before the next change', () => {
1101
- const specialItem = buildSpecialItem();
1102
- const basePrices = nestedBasePrices(specialItem);
1103
- // Submit the premium pair: the order item carries the raised segment price.
1104
- const submitted = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(buildEngine(specialItem), ['milan', 'torent']), { basePrices });
1105
- const orderItem = (0, order_engine_1.convertOrderEngineItemToOrderItem)(submitted, TENANT_ID);
1106
- const persistedHalfHalf = (orderItem.modifiers ?? [])
1107
- .find((m) => m._id === 'mod-pizza')
1108
- .options.find((o) => o._id === 'halfhalf-1');
1109
- expect(persistedHalfHalf.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
1110
- // Reopening the drawer for edit reads those raised prices back...
1111
- const reopened = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
1112
- item: specialItem,
1113
- orderItem,
1114
- platform: PLATFORM,
1115
- tenantId: TENANT_ID,
1116
- orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
1117
- defaultMenuId: null,
1118
- soldoutModifiers: [],
981
+ it('references make the nested rule reversible in place (special flow)', () => {
982
+ const state = buildState();
983
+ let engine = state.workingData;
984
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
985
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
986
+ const premium = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
987
+ originalPriceReferences: state.originalPriceReferences,
1119
988
  });
1120
- expect(nestedPrice(reopened, 0, 'milan')).toBe(100);
1121
- // ...and the scoped reset restores the definition baseline (top-level
1122
- // prices are untouched by it).
1123
- const rebased = (0, order_engine_1.resetOrderEngineItemPrices)(reopened, basePrices, { nestedHalfHalfOnly: true });
1124
- expect(nestedPrice(rebased, 0, 'milan')).toBe(0);
1125
- expect(topLevelPrice(rebased, 'torent')).toBe(200);
1126
- // Submitting without changes keeps the premium charging...
1127
- expect(nestedPrice((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(rebased, { basePrices }), 0, 'milan')).toBe(100);
1128
- // ...while switching the second half lowers to the definition prices.
1129
- const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(rebased, ['milan', 'milan']), {
1130
- basePrices,
989
+ expect(segmentOptions(premium)[0].find((o) => o.id === 'milan').price).toBe(100);
990
+ // Switch the second half back to MILAN on the RAISED item: the previously
991
+ // upgraded milan returns to its own price (cheap pair)...
992
+ const switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(premium, 'mod-pizza_halfhalf-1_seg-2_milan', true, false);
993
+ const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(switched, {
994
+ originalPriceReferences: state.originalPriceReferences,
1131
995
  });
1132
- expect(nestedPrice(cheap, 0, 'milan')).toBe(0);
1133
- expect(nestedPrice(cheap, 1, 'milan')).toBe(0);
996
+ const cheapSegments = segmentOptions(cheap);
997
+ expect(cheapSegments[0].find((o) => o.id === 'milan').price).toBe(0);
998
+ expect(cheapSegments[1].find((o) => o.id === 'milan').price).toBe(0);
999
+ // ...and the special's own (top-level) option prices are never re-based.
1000
+ expect(cheap.modifiers[0].options.find((o) => o._id === 'torent').price).toBe(200);
1134
1001
  });
1135
1002
  });
1136
1003
  // ============================================================================
1137
- // 5) Engine — choose_expensive_segment_price uses the MAX OF THE SELECTED halves
1004
+ // 5) Engine — option price references (classic half-half flow)
1138
1005
  // ============================================================================
1139
- describe('choose_expensive_segment_price: selected-halves max (new semantics)', () => {
1140
- // A(500) B(500) C(600) D(600) halves — user example: the expensive half is
1141
- // at most the most expensive SELECTED one, not the setup's global max.
1142
- const itemsMap4 = {
1006
+ describe('choose_expensive_segment_price — option price references (classic flow)', () => {
1007
+ const itemsMap = {
1143
1008
  a: makeItem('a', { price: { BASE_PRICE: 1000 } }),
1144
1009
  b: makeItem('b', { price: { BASE_PRICE: 1000 } }),
1145
1010
  c: makeItem('c', { price: { BASE_PRICE: 1200 } }),
1146
1011
  d: makeItem('d', { price: { BASE_PRICE: 1200 } }),
1147
1012
  };
1148
- const setup4 = () => makeHalfHalfSetup({
1013
+ const setup = () => makeHalfHalfSetup({
1149
1014
  upsell_price: null,
1150
1015
  items: [
1151
1016
  { item_id: 'a', sort_id: 1, upsell_price: null },
@@ -1154,11 +1019,8 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
1154
1019
  { item_id: 'd', sort_id: 4, upsell_price: null },
1155
1020
  ],
1156
1021
  });
1157
- const converted = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup4(), itemsMap4);
1158
- const basePrices = (0, order_engine_1.getOptionPriceMapFromItem)(converted, PLATFORM);
1159
- // a/b = 1000/2 = 500, c/d = 1200/2 = 600 (the user's $5/$5/$6/$6 example).
1160
- const baseValues = { a: 500, b: 500, c: 600, d: 600 };
1161
- function freshEngine(item = converted) {
1022
+ function buildState() {
1023
+ const item = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup(), itemsMap);
1162
1024
  return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
1163
1025
  item,
1164
1026
  orderItem: undefined,
@@ -1169,383 +1031,79 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
1169
1031
  soldoutModifiers: [],
1170
1032
  });
1171
1033
  }
1172
- function selectEngine(picks) {
1173
- let engine = freshEngine();
1174
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-1_${picks[0]}`, true);
1175
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-2_${picks[1]}`, true);
1176
- return engine;
1177
- }
1178
- function selectedPrices(engine) {
1179
- return engine.modifiers.map((m) => m.options.find((o) => o.default).price);
1180
- }
1181
- function optionPrice(engine, segmentId, optionId) {
1182
- return engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
1183
- }
1184
- /** The drawer's display/submit pass: recompute on a copy from pristine prices. */
1185
- function normalize(engine) {
1186
- return (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices });
1187
- }
1188
- /** Real UI flow: pick one option per segment (the radio group clears the sibling). */
1189
- function pick(engine, segmentIndex, optionId) {
1190
- return (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-${segmentIndex + 1}_${optionId}`, true);
1191
- }
1192
- it('A+B stays 5+5 (global max must NOT leak)', () => {
1193
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
1194
- expect(selectedPrices(result)).toEqual([500, 500]);
1195
- });
1196
- it('B+C raises B to C (6+6)', () => {
1197
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['b', 'c']));
1198
- expect(selectedPrices(result)).toEqual([600, 600]);
1199
- });
1200
- it('C+B is order independent (6+6)', () => {
1201
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['c', 'b']));
1202
- expect(selectedPrices(result)).toEqual([600, 600]);
1203
- });
1204
- it('C+D needs no raise (6+6)', () => {
1205
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['c', 'd']));
1206
- expect(selectedPrices(result)).toEqual([600, 600]);
1207
- });
1208
- it('A+D raises A to D (6+6)', () => {
1209
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'd']));
1210
- expect(selectedPrices(result)).toEqual([600, 600]);
1211
- });
1212
- it('unselected options keep their own prices; item-level upsell untouched', () => {
1213
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
1214
- const seg1 = result.modifiers.find((m) => m._id === 'seg-1');
1215
- expect(seg1.options.find((o) => o._id === 'c').price).toBe(600);
1216
- expect(seg1.options.find((o) => o._id === 'd').price).toBe(600);
1217
- // Setup upsell is null -> engine item price 0 (added once, never normalized).
1218
- expect(result.price).toBe(0);
1219
- });
1220
- it('LOWERS again when switching from an expensive pair to a cheap pair (basePrices reset)', () => {
1221
- // B+C -> B is raised to 600...
1222
- const expensive = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['b', 'c']));
1223
- expect(selectedPrices(expensive)).toEqual([600, 600]);
1224
- // ...then the user switches BOTH halves to the cheap pair A+B. Re-applying
1225
- // with pristine basePrices must bring B back down to 500.
1226
- let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(expensive, 'seg-1_b', false);
1034
+ const priceAt = (engine, segmentId, optionId) => engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
1035
+ it('originalPriceReferences: definition prices keyed by the option path', () => {
1036
+ const { originalPriceReferences } = buildState();
1037
+ // a/b = 1000/2 = 500, c/d = 1200/2 = 600 — for BOTH segments.
1038
+ expect(originalPriceReferences['seg-1_a']).toBe(500);
1039
+ expect(originalPriceReferences['seg-1_b']).toBe(500);
1040
+ expect(originalPriceReferences['seg-1_c']).toBe(600);
1041
+ expect(originalPriceReferences['seg-1_d']).toBe(600);
1042
+ expect(originalPriceReferences['seg-2_a']).toBe(500);
1043
+ expect(originalPriceReferences['seg-2_d']).toBe(600);
1044
+ });
1045
+ it('A+B charges 5+5: expensive UNSELECTED options never leak into the max', () => {
1046
+ const { originalPriceReferences, workingData } = buildState();
1047
+ let engine = workingData;
1227
1048
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_a', true);
1228
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', false);
1229
1049
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_b', true);
1230
- const lowered = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices });
1231
- expect(selectedPrices(lowered)).toEqual([500, 500]);
1232
- });
1233
- it('workable conversion no longer bakes the global max into option prices', () => {
1234
- const workable = (0, halfhalf_setup_helpers_1.convertHalfHalfSetupToWorkableHalfHalfSetup)([setup4()], itemsMap4, PLATFORM, TENANT_ID);
1235
- // a/b stay 500, c/d stay 600 — NOT all raised to 600 at conversion.
1236
- expect(workable[0].items.map((i) => priceOf(i.price))).toEqual([500, 500, 600, 600]);
1237
- });
1238
- it('user flow: after B+C, switching to C+D returns the de-selected B to 500', () => {
1239
- const engine = selectEngine(['b', 'c']);
1240
- const displayed = normalize(engine);
1241
- expect(selectedPrices(displayed)).toEqual([600, 600]);
1242
- // From the pristine drawer state AND from the raised display alike.
1243
- for (const source of [engine, displayed]) {
1244
- const result = normalize(pick(pick(source, 0, 'c'), 1, 'd'));
1245
- expect(selectedPrices(result)).toEqual([600, 600]);
1246
- // B is no longer selected anywhere -> back to its own 500.
1247
- expect(optionPrice(result, 'seg-1', 'b')).toBe(500);
1248
- expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
1249
- // D keeps its own 600 and C stays selected at 600.
1250
- expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
1251
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1252
- }
1253
- });
1254
- it('user flow: after B+C, switching to C,B keeps 6+6 and de-selected segment-1 B drops to 500', () => {
1255
- const engine = selectEngine(['b', 'c']);
1256
- const displayed = normalize(engine);
1257
- for (const source of [engine, displayed]) {
1258
- const result = normalize(pick(pick(source, 0, 'c'), 1, 'b'));
1259
- expect(selectedPrices(result)).toEqual([600, 600]);
1260
- // Segment 1 now charges C (600); its B is de-selected -> 500.
1261
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1262
- expect(optionPrice(result, 'seg-1', 'b')).toBe(500);
1263
- // Segment 2 charges B raised to C's price.
1264
- expect(optionPrice(result, 'seg-2', 'b')).toBe(600);
1265
- }
1266
- });
1267
- it('user flow: after B+C, switching to A+B lowers the previously raised B to 500', () => {
1268
- const engine = selectEngine(['b', 'c']);
1269
- const displayed = normalize(engine);
1270
- expect(selectedPrices(displayed)).toEqual([600, 600]);
1271
- for (const source of [engine, displayed]) {
1272
- const result = normalize(pick(pick(source, 0, 'a'), 1, 'b'));
1273
- expect(selectedPrices(result)).toEqual([500, 500]);
1274
- // The de-selected C keeps its own 600; nothing left over from the old pair.
1275
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1276
- expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
1277
- expect(optionPrice(result, 'seg-2', 'c')).toBe(600);
1278
- }
1279
- });
1280
- it('a full session (B+C -> C,D -> C,B -> A,B) recomputes from pristine prices at every step', () => {
1281
- const engine = selectEngine(['b', 'c']);
1282
- expect(selectedPrices(normalize(engine))).toEqual([600, 600]);
1283
- const step1 = pick(pick(engine, 0, 'c'), 1, 'd');
1284
- const displayed1 = normalize(step1);
1285
- expect(selectedPrices(displayed1)).toEqual([600, 600]);
1286
- expect(optionPrice(displayed1, 'seg-1', 'b')).toBe(500);
1287
- const step2 = pick(pick(step1, 0, 'c'), 1, 'b');
1288
- const displayed2 = normalize(step2);
1289
- expect(selectedPrices(displayed2)).toEqual([600, 600]);
1290
- const step3 = pick(pick(step2, 0, 'a'), 1, 'b');
1291
- const displayed3 = normalize(step3);
1292
- expect(selectedPrices(displayed3)).toEqual([500, 500]);
1293
- // Every unselected option is its own price again.
1294
- expect(optionPrice(displayed3, 'seg-1', 'c')).toBe(600);
1295
- expect(optionPrice(displayed3, 'seg-1', 'd')).toBe(600);
1296
- expect(optionPrice(displayed3, 'seg-2', 'c')).toBe(600);
1297
- });
1298
- it('full change matrix: every ordered pair -> pair switch recomputes from pristine prices', () => {
1299
- const combos = [
1300
- ['a', 'b'],
1301
- ['b', 'a'],
1302
- ['a', 'c'],
1303
- ['c', 'a'],
1304
- ['a', 'd'],
1305
- ['d', 'a'],
1306
- ['b', 'c'],
1307
- ['c', 'b'],
1308
- ['b', 'd'],
1309
- ['d', 'b'],
1310
- ['c', 'd'],
1311
- ['d', 'c'],
1312
- ];
1313
- for (const from of combos) {
1314
- const fromPristine = selectEngine(from);
1315
- const fromDisplay = normalize(fromPristine);
1316
- const expectedFrom = Math.max(baseValues[from[0]], baseValues[from[1]]);
1317
- expect(selectedPrices(fromDisplay)).toEqual([expectedFrom, expectedFrom]);
1318
- for (const to of combos) {
1319
- const expectedTo = Math.max(baseValues[to[0]], baseValues[to[1]]);
1320
- for (const source of [fromPristine, fromDisplay]) {
1321
- const result = normalize(pick(pick(source, 0, to[0]), 1, to[1]));
1322
- expect(selectedPrices(result)).toEqual([expectedTo, expectedTo]);
1323
- // Every half de-selected by the switch is back to its own price.
1324
- for (const optionId of from) {
1325
- if (to.includes(optionId))
1326
- continue;
1327
- expect(optionPrice(result, 'seg-1', optionId)).toBe(baseValues[optionId]);
1328
- expect(optionPrice(result, 'seg-2', optionId)).toBe(baseValues[optionId]);
1329
- }
1330
- }
1331
- }
1332
- }
1333
- });
1334
- it('edit flow: persisted raised prices are re-based before the next change', () => {
1335
- // Submit B+C -> the order item stores segment-1 B at 600.
1336
- const submitted = normalize(selectEngine(['b', 'c']));
1337
- const orderItem = (0, order_engine_1.convertOrderEngineItemToOrderItem)(submitted, TENANT_ID);
1338
- expect((orderItem.modifiers ?? []).find((m) => m._id === 'seg-1').options.find((o) => o._id === 'b').price).toBe(600);
1339
- // Reopen the drawer for edit: the persisted raise reads back into the engine...
1340
- const reopened = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
1341
- item: converted,
1342
- orderItem,
1343
- platform: PLATFORM,
1344
- tenantId: TENANT_ID,
1345
- orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
1346
- defaultMenuId: null,
1347
- soldoutModifiers: [],
1348
- });
1349
- expect(optionPrice(reopened, 'seg-1', 'b')).toBe(600);
1350
- // ...and the pristine reset restores the catalog baseline.
1351
- const rebased = (0, order_engine_1.resetOrderEngineItemPrices)(reopened, basePrices);
1352
- expect(optionPrice(rebased, 'seg-1', 'b')).toBe(500);
1353
- // Submitting without changes keeps B+C at 6+6...
1354
- expect(selectedPrices(normalize(rebased))).toEqual([600, 600]);
1355
- // ...while switching to A+B lowers B back to 5.
1356
- const changed = normalize(pick(pick(rebased, 0, 'a'), 1, 'b'));
1357
- expect(selectedPrices(changed)).toEqual([500, 500]);
1358
- expect(optionPrice(changed, 'seg-1', 'b')).toBe(500);
1359
- expect(optionPrice(changed, 'seg-2', 'b')).toBe(500);
1360
- });
1361
- it('single selected half: nothing to raise, the other segment stays untouched', () => {
1362
- const result = normalize(pick(freshEngine(), 0, 'a'));
1363
- expect(optionPrice(result, 'seg-1', 'a')).toBe(500);
1364
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1365
- // Segment 2 has no selection at all — its options keep their own prices.
1366
- expect(optionPrice(result, 'seg-2', 'a')).toBe(500);
1367
- expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
1368
- });
1369
- it('no selection at all: prices are re-based and nothing is raised or invented', () => {
1370
- const source = freshEngine();
1371
- // Legacy call (no basePrices): unchanged item is returned as is.
1372
- expect((0, order_engine_1.applyChooseExpensiveSegmentPrice)(source)).toBe(source);
1373
- const result = normalize(source);
1374
- expect(optionPrice(result, 'seg-1', 'a')).toBe(500);
1375
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1376
- expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
1377
- expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
1378
- });
1379
- it('quarters (4 segments): max over the four selected sides; switching sides re-bases', () => {
1380
- const quarters = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(makeHalfHalfSetup({
1381
- upsell_price: null,
1382
- segments: [
1383
- { _id: 'q-1', name: 'Quarter 1', sort_id: 1 },
1384
- { _id: 'q-2', name: 'Quarter 2', sort_id: 2 },
1385
- { _id: 'q-3', name: 'Quarter 3', sort_id: 3 },
1386
- { _id: 'q-4', name: 'Quarter 4', sort_id: 4 },
1387
- ],
1388
- items: [
1389
- { item_id: 'a', sort_id: 1, upsell_price: null },
1390
- { item_id: 'b', sort_id: 2, upsell_price: null },
1391
- { item_id: 'c', sort_id: 3, upsell_price: null },
1392
- { item_id: 'd', sort_id: 4, upsell_price: null },
1393
- ],
1394
- }), itemsMap4);
1395
- const quarterBase = (0, order_engine_1.getOptionPriceMapFromItem)(quarters, PLATFORM);
1396
- const quarterPrice = (item, segmentId, optionId) => item.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
1397
- let engine = freshEngine(quarters);
1398
- // a/b = 1000/4 = 250, c/d = 1200/4 = 300.
1399
- expect(quarterPrice(engine, 'q-1', 'a')).toBe(250);
1400
- expect(quarterPrice(engine, 'q-1', 'c')).toBe(300);
1401
- const picks = [
1402
- ['q-1', 'a'],
1403
- ['q-2', 'a'],
1404
- ['q-3', 'd'],
1405
- ['q-4', 'd'],
1406
- ];
1407
- for (const [segmentId, optionId] of picks) {
1408
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `${segmentId}_${optionId}`, true);
1409
- }
1410
- const mixed = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices: quarterBase });
1411
- for (const segmentId of ['q-1', 'q-2']) {
1412
- expect(quarterPrice(mixed, segmentId, 'a')).toBe(300);
1413
- }
1414
- for (const segmentId of ['q-3', 'q-4']) {
1415
- expect(quarterPrice(mixed, segmentId, 'd')).toBe(300);
1416
- }
1417
- // All four sides cheap: everything returns to 250 (from the raised state too).
1418
- for (const source of [engine, mixed]) {
1419
- let cheap = source;
1420
- for (const segmentId of ['q-1', 'q-2', 'q-3', 'q-4']) {
1421
- cheap = (0, order_engine_1.setCheckFieldInOrderEngineItem)(cheap, `${segmentId}_a`, true);
1422
- }
1423
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(cheap, { basePrices: quarterBase });
1424
- for (const segmentId of ['q-1', 'q-2', 'q-3', 'q-4']) {
1425
- expect(quarterPrice(result, segmentId, 'a')).toBe(250);
1426
- }
1427
- // De-selected c/d keep their own 300.
1428
- expect(quarterPrice(result, 'q-1', 'd')).toBe(300);
1429
- }
1430
- });
1431
- });
1432
- // ============================================================================
1433
- // 6) Engine memory — `base_price` (reversible normalization without maps)
1434
- // ============================================================================
1435
- describe('engine memory: base_price makes choose_expensive reversible in place', () => {
1436
- const itemsMap = {
1437
- a: makeItem('a', { price: { BASE_PRICE: 1000 } }),
1438
- b: makeItem('b', { price: { BASE_PRICE: 1000 } }),
1439
- c: makeItem('c', { price: { BASE_PRICE: 1200 } }),
1440
- d: makeItem('d', { price: { BASE_PRICE: 1200 } }),
1441
- };
1442
- const setup = () => makeHalfHalfSetup({
1443
- upsell_price: null,
1444
- items: [
1445
- { item_id: 'a', sort_id: 1, upsell_price: null },
1446
- { item_id: 'b', sort_id: 2, upsell_price: null },
1447
- { item_id: 'c', sort_id: 3, upsell_price: null },
1448
- { item_id: 'd', sort_id: 4, upsell_price: null },
1449
- ],
1450
- });
1451
- function buildEngine() {
1452
- const converted = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup(), itemsMap);
1453
- return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
1454
- item: converted,
1455
- orderItem: undefined,
1456
- platform: PLATFORM,
1457
- tenantId: TENANT_ID,
1458
- orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
1459
- defaultMenuId: null,
1460
- soldoutModifiers: [],
1461
- });
1462
- }
1463
- function priceOf(engine, segmentId, optionId, base = false) {
1464
- const option = engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId);
1465
- return base ? option.base_price : option.price;
1466
- }
1467
- it('conversion stamps the catalog definition on every option', () => {
1468
- const engine = buildEngine();
1469
- const expected = [
1470
- ['a', 500],
1471
- ['b', 500],
1472
- ['c', 600],
1473
- ['d', 600],
1474
- ];
1475
- for (const [optionId, value] of expected) {
1476
- expect(priceOf(engine, 'seg-1', optionId, true)).toBe(value);
1477
- expect(priceOf(engine, 'seg-1', optionId)).toBe(value);
1478
- expect(priceOf(engine, 'seg-2', optionId, true)).toBe(value);
1479
- }
1480
- });
1481
- it('changing the choice on the SAME (raised) engine lowers again — no external map', () => {
1482
- let engine = buildEngine();
1050
+ const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
1051
+ expect(priceAt(result, 'seg-1', 'a')).toBe(500);
1052
+ expect(priceAt(result, 'seg-2', 'b')).toBe(500);
1053
+ // Expensive options keep their own (higher) price.
1054
+ expect(priceAt(result, 'seg-1', 'c')).toBe(600);
1055
+ });
1056
+ it('B+C charges 6+6 and every segment previews its OWN switch level (max with the OTHER segment)', () => {
1057
+ const { originalPriceReferences, workingData } = buildState();
1058
+ let engine = workingData;
1483
1059
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
1484
1060
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
1485
- // B+C -> B raised to 600.
1486
- engine = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
1487
- expect(priceOf(engine, 'seg-1', 'b')).toBe(600);
1488
- expect(priceOf(engine, 'seg-2', 'c')).toBe(600);
1489
- // User changes to A+B on the raised engine: B must come back to its 500.
1490
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_a', true);
1491
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_b', true);
1492
- engine = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
1493
- expect(priceOf(engine, 'seg-1', 'a')).toBe(500);
1494
- expect(priceOf(engine, 'seg-1', 'b')).toBe(500);
1495
- expect(priceOf(engine, 'seg-2', 'b')).toBe(500);
1496
- // De-selected C keeps its own price; nothing drifts.
1497
- expect(priceOf(engine, 'seg-1', 'c')).toBe(600);
1498
- expect(priceOf(engine, 'seg-2', 'c')).toBe(600);
1499
- });
1500
- it('de-selecting a raised half on the SAME engine returns it to its own price', () => {
1501
- let engine = buildEngine();
1061
+ const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
1062
+ // Selected: B levelled 500 -> 600, C stays 600.
1063
+ expect(priceAt(result, 'seg-1', 'b')).toBe(600);
1064
+ expect(priceAt(result, 'seg-2', 'c')).toBe(600);
1065
+ // SEG-1's alternatives SWITCH to the other segment's level: with C (600)
1066
+ // still picked, choosing any of them keeps the pair at 6+6.
1067
+ expect(priceAt(result, 'seg-1', 'a')).toBe(600);
1068
+ // SEG-2's alternatives REPLACE its own pick (C), so their preview is
1069
+ // max(own 500, the OTHER segment's pick B = 500) = 500 — picking one
1070
+ // makes the pair 5+5.
1071
+ expect(priceAt(result, 'seg-2', 'a')).toBe(500);
1072
+ expect(priceAt(result, 'seg-2', 'b')).toBe(500);
1073
+ expect(priceAt(result, 'seg-2', 'd')).toBe(600); // own (higher)
1074
+ });
1075
+ it('switching B+C -> A+B on the SAME (already levelled) item lowers again', () => {
1076
+ const { originalPriceReferences, workingData } = buildState();
1077
+ let engine = workingData;
1502
1078
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
1503
1079
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
1504
- engine = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
1505
- expect(priceOf(engine, 'seg-1', 'b')).toBe(600);
1506
- // B+C -> C+D
1507
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_c', true);
1508
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_d', true);
1509
- engine = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
1510
- expect(priceOf(engine, 'seg-1', 'c')).toBe(600);
1511
- expect(priceOf(engine, 'seg-2', 'd')).toBe(600);
1512
- expect(priceOf(engine, 'seg-1', 'b')).toBe(500);
1513
- expect(priceOf(engine, 'seg-2', 'b')).toBe(500);
1514
- });
1515
- it('re-applying without a selection change is stable (no drift)', () => {
1516
- let engine = buildEngine();
1517
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_a', true);
1518
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_d', true);
1519
- const once = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
1520
- const twice = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(once);
1521
- expect(priceOf(twice, 'seg-1', 'a')).toBe(priceOf(once, 'seg-1', 'a'));
1522
- expect(priceOf(twice, 'seg-2', 'd')).toBe(priceOf(once, 'seg-2', 'd'));
1523
- expect(twice).toEqual(once);
1524
- });
1525
- it('modern flow: a de-structured line with raised segment prices re-bases from the definition', () => {
1526
- const workable = (0, halfhalf_setup_helpers_1.convertHalfHalfSetupToWorkableHalfHalfSetup)([setup()], itemsMap, PLATFORM, TENANT_ID)[0];
1527
- // Persisted edit state: segment 1 carries B at the previously charged 600.
1528
- const segmentB = { ...(0, order_engine_1.convertItemToOrderItem)(workable.items[1], null, PLATFORM, TENANT_ID), price: 600 };
1529
- // B + C: the raise is recomputed from the definition (500 -> 600), not
1530
- // accumulated on the persisted price, and the baseline stays the catalog.
1531
- const premium = (0, halfhalf_setup_helpers_1.convertHalfHalfToOrderEngineItem)({
1532
- halfHalfItem: workable,
1533
- selectedHalfHalfItems: [segmentB, (0, order_engine_1.convertItemToOrderItem)(workable.items[2], null, PLATFORM, TENANT_ID)],
1534
- quantity: 1,
1535
- platform: PLATFORM,
1536
- chooseExpensiveSegmentPrice: true,
1537
- });
1538
- expect(priceOf(premium, 'seg-1', 'b')).toBe(600);
1539
- expect(priceOf(premium, 'seg-1', 'b', true)).toBe(500);
1540
- // User changes to A + B: the persisted 600 must drop to the definition 500.
1541
- const cheap = (0, halfhalf_setup_helpers_1.convertHalfHalfToOrderEngineItem)({
1542
- halfHalfItem: workable,
1543
- selectedHalfHalfItems: [(0, order_engine_1.convertItemToOrderItem)(workable.items[0], null, PLATFORM, TENANT_ID), segmentB],
1544
- quantity: 1,
1545
- platform: PLATFORM,
1546
- chooseExpensiveSegmentPrice: true,
1547
- });
1548
- expect(priceOf(cheap, 'seg-1', 'a')).toBe(500);
1549
- expect(priceOf(cheap, 'seg-2', 'b')).toBe(500);
1080
+ const raised = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
1081
+ expect(priceAt(raised, 'seg-1', 'b')).toBe(600);
1082
+ // The user changes the choice in place: B -> A, C -> B.
1083
+ let switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(raised, 'seg-1_a', true);
1084
+ switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(switched, 'seg-2_b', true);
1085
+ const lowered = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(switched, { originalPriceReferences });
1086
+ expect(priceAt(lowered, 'seg-1', 'a')).toBe(500);
1087
+ expect(priceAt(lowered, 'seg-2', 'b')).toBe(500);
1088
+ // De-selected C is back to its own price: nothing accumulates.
1089
+ expect(priceAt(lowered, 'seg-1', 'c')).toBe(600);
1090
+ expect(priceAt(lowered, 'seg-2', 'c')).toBe(600);
1091
+ });
1092
+ it('edit flow: persisted, already-raised prices are re-based from the definition', () => {
1093
+ const { originalPriceReferences, workingData } = buildState();
1094
+ // Simulate an edit line: B was charged 600 by a previous normalization.
1095
+ const persisted = {
1096
+ ...workingData,
1097
+ modifiers: workingData.modifiers.map((modifier) => ({
1098
+ ...modifier,
1099
+ options: modifier.options.map((option) => (option._id === 'b' ? { ...option, price: 600 } : option)),
1100
+ })),
1101
+ };
1102
+ let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(persisted, 'seg-1_b', true);
1103
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_a', true);
1104
+ const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
1105
+ // B's persisted 600 is NOT the baseline: A+B is a cheap pair (5+5).
1106
+ expect(priceAt(result, 'seg-1', 'b')).toBe(500);
1107
+ expect(priceAt(result, 'seg-2', 'a')).toBe(500);
1550
1108
  });
1551
1109
  });