@managesome/eposmatic-toolkit 0.2.719 → 0.2.721

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,57 +859,37 @@ 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)', () => {
869
+ it('basic + premium selection levels the cheap half to the premium one (special-derived prices)', () => {
893
870
  let engine = buildEngine();
894
871
  // Real UI flow: selection happens through the special's engine item, so
895
872
  // 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);
873
+ // -> option) and setCheckField auto-normalizes via its SPECIAL branch.
874
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
875
+ // Only the cheap half is picked so far — it IS the most expensive selected
876
+ // half, so nothing is raised yet.
899
877
  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.
878
+ // Picking the premium half (100) makes it drive the rule: every cheaper
879
+ // option — selected or not — is levelled to it, so the drawer can show
880
+ // what picking it would cost. NO 575 from Pizza Size anywhere.
881
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
882
+ const after = segmentOptions(engine);
904
883
  expect(after[0].find((o) => o.id === 'milan').price).toBe(100);
905
884
  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);
885
+ expect(after.flat().every((o) => o.price === 100)).toBe(true);
908
886
  });
909
887
  it('is idempotent (re-applying never lowers or changes prices)', () => {
910
888
  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)));
889
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
890
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
891
+ const once = segmentOptions(engine);
892
+ const twice = segmentOptions((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine));
915
893
  expect(twice).toEqual(once);
916
894
  });
917
895
  it('does nothing when the half-half flag is off', () => {
@@ -924,7 +902,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
924
902
  orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
925
903
  defaultMenuId: null,
926
904
  soldoutModifiers: [],
927
- });
905
+ }).workingData;
928
906
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
929
907
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
930
908
  const after = segmentOptions(engine);
@@ -944,7 +922,7 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
944
922
  orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
945
923
  defaultMenuId: null,
946
924
  soldoutModifiers: [],
947
- });
925
+ }).workingData;
948
926
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_milan', true, false);
949
927
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_torent', true, false);
950
928
  const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine);
@@ -972,160 +950,51 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
972
950
  orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
973
951
  defaultMenuId: null,
974
952
  soldoutModifiers: [],
975
- });
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);
953
+ }).workingData;
954
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-1_milan', true, false);
955
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-flag_seg-2_torent', true, false);
956
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-1_milan', true, false);
957
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_hh-no-flag_seg-2_torent', true, false);
958
+ const hhFlag = engine.modifiers[0].options.find((o) => o._id === 'hh-flag');
959
+ const hhNoFlag = engine.modifiers[0].options.find((o) => o._id === 'hh-no-flag');
960
+ // Flagged: the cheap half is levelled to the selected expensive half;
984
961
  // un-flagged: stays free.
985
962
  expect(hhFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
986
963
  expect(hhNoFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(0);
987
964
  });
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('edit flow: a persisted nested raise is re-based before the next change', () => {
1081
- const specialItem = buildSpecialItem();
1082
- const basePrices = nestedBasePrices(specialItem);
1083
- // Submit the premium pair: the order item carries the raised segment price.
1084
- const submitted = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(buildEngine(specialItem), ['milan', 'torent']), { basePrices });
1085
- const orderItem = (0, order_engine_1.convertOrderEngineItemToOrderItem)(submitted, TENANT_ID);
1086
- const persistedHalfHalf = (orderItem.modifiers ?? [])
1087
- .find((m) => m._id === 'mod-pizza')
1088
- .options.find((o) => o._id === 'halfhalf-1');
1089
- expect(persistedHalfHalf.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
1090
- // Reopening the drawer for edit reads those raised prices back...
1091
- const reopened = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
1092
- item: specialItem,
1093
- orderItem,
1094
- platform: PLATFORM,
1095
- tenantId: TENANT_ID,
1096
- orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.SPECIAL,
1097
- defaultMenuId: null,
1098
- soldoutModifiers: [],
965
+ it('references make the nested rule reversible in place (special flow)', () => {
966
+ const state = buildState();
967
+ let engine = state.workingData;
968
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-1_milan', true, false);
969
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'mod-pizza_halfhalf-1_seg-2_torent', true, false);
970
+ const premium = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(engine, {
971
+ originalPriceReferences: state.originalPriceReferences,
1099
972
  });
1100
- expect(nestedPrice(reopened, 0, 'milan')).toBe(100);
1101
- // ...and the scoped reset restores the definition baseline (top-level
1102
- // prices are untouched by it).
1103
- const rebased = (0, order_engine_1.resetOrderEngineItemPrices)(reopened, basePrices, { nestedHalfHalfOnly: true });
1104
- expect(nestedPrice(rebased, 0, 'milan')).toBe(0);
1105
- expect(topLevelPrice(rebased, 'torent')).toBe(200);
1106
- // Submitting without changes keeps the premium charging...
1107
- expect(nestedPrice((0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(rebased, { basePrices }), 0, 'milan')).toBe(100);
1108
- // ...while switching the second half lowers to the definition prices.
1109
- const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(selectNested(rebased, ['milan', 'milan']), {
1110
- basePrices,
973
+ expect(segmentOptions(premium)[0].find((o) => o.id === 'milan').price).toBe(100);
974
+ // Switch the second half back to MILAN on the RAISED item: the previously
975
+ // upgraded milan returns to its own price (cheap pair)...
976
+ const switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(premium, 'mod-pizza_halfhalf-1_seg-2_milan', true, false);
977
+ const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(switched, {
978
+ originalPriceReferences: state.originalPriceReferences,
1111
979
  });
1112
- expect(nestedPrice(cheap, 0, 'milan')).toBe(0);
1113
- expect(nestedPrice(cheap, 1, 'milan')).toBe(0);
980
+ const cheapSegments = segmentOptions(cheap);
981
+ expect(cheapSegments[0].find((o) => o.id === 'milan').price).toBe(0);
982
+ expect(cheapSegments[1].find((o) => o.id === 'milan').price).toBe(0);
983
+ // ...and the special's own (top-level) option prices are never re-based.
984
+ expect(cheap.modifiers[0].options.find((o) => o._id === 'torent').price).toBe(200);
1114
985
  });
1115
986
  });
1116
987
  // ============================================================================
1117
- // 5) Engine — choose_expensive_segment_price uses the MAX OF THE SELECTED halves
988
+ // 5) Engine — option price references (classic half-half flow)
1118
989
  // ============================================================================
1119
- describe('choose_expensive_segment_price: selected-halves max (new semantics)', () => {
1120
- // A(500) B(500) C(600) D(600) halves — user example: the expensive half is
1121
- // at most the most expensive SELECTED one, not the setup's global max.
1122
- const itemsMap4 = {
990
+ describe('choose_expensive_segment_price — option price references (classic flow)', () => {
991
+ const itemsMap = {
1123
992
  a: makeItem('a', { price: { BASE_PRICE: 1000 } }),
1124
993
  b: makeItem('b', { price: { BASE_PRICE: 1000 } }),
1125
994
  c: makeItem('c', { price: { BASE_PRICE: 1200 } }),
1126
995
  d: makeItem('d', { price: { BASE_PRICE: 1200 } }),
1127
996
  };
1128
- const setup4 = () => makeHalfHalfSetup({
997
+ const setup = () => makeHalfHalfSetup({
1129
998
  upsell_price: null,
1130
999
  items: [
1131
1000
  { item_id: 'a', sort_id: 1, upsell_price: null },
@@ -1134,11 +1003,8 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
1134
1003
  { item_id: 'd', sort_id: 4, upsell_price: null },
1135
1004
  ],
1136
1005
  });
1137
- const converted = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup4(), itemsMap4);
1138
- const basePrices = (0, order_engine_1.getOptionPriceMapFromItem)(converted, PLATFORM);
1139
- // a/b = 1000/2 = 500, c/d = 1200/2 = 600 (the user's $5/$5/$6/$6 example).
1140
- const baseValues = { a: 500, b: 500, c: 600, d: 600 };
1141
- function freshEngine(item = converted) {
1006
+ function buildState() {
1007
+ const item = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup(), itemsMap);
1142
1008
  return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
1143
1009
  item,
1144
1010
  orderItem: undefined,
@@ -1149,263 +1015,74 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
1149
1015
  soldoutModifiers: [],
1150
1016
  });
1151
1017
  }
1152
- function selectEngine(picks) {
1153
- let engine = freshEngine();
1154
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-1_${picks[0]}`, true);
1155
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-2_${picks[1]}`, true);
1156
- return engine;
1157
- }
1158
- function selectedPrices(engine) {
1159
- return engine.modifiers.map((m) => m.options.find((o) => o.default).price);
1160
- }
1161
- function optionPrice(engine, segmentId, optionId) {
1162
- return engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
1163
- }
1164
- /** The drawer's display/submit pass: recompute on a copy from pristine prices. */
1165
- function normalize(engine) {
1166
- return (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices });
1167
- }
1168
- /** Real UI flow: pick one option per segment (the radio group clears the sibling). */
1169
- function pick(engine, segmentIndex, optionId) {
1170
- return (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-${segmentIndex + 1}_${optionId}`, true);
1171
- }
1172
- it('A+B stays 5+5 (global max must NOT leak)', () => {
1173
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
1174
- expect(selectedPrices(result)).toEqual([500, 500]);
1018
+ const priceAt = (engine, segmentId, optionId) => engine.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
1019
+ it('originalPriceReferences: definition prices keyed by the option path', () => {
1020
+ const { originalPriceReferences } = buildState();
1021
+ // a/b = 1000/2 = 500, c/d = 1200/2 = 600 — for BOTH segments.
1022
+ expect(originalPriceReferences['seg-1_a']).toBe(500);
1023
+ expect(originalPriceReferences['seg-1_b']).toBe(500);
1024
+ expect(originalPriceReferences['seg-1_c']).toBe(600);
1025
+ expect(originalPriceReferences['seg-1_d']).toBe(600);
1026
+ expect(originalPriceReferences['seg-2_a']).toBe(500);
1027
+ expect(originalPriceReferences['seg-2_d']).toBe(600);
1175
1028
  });
1176
- it('B+C raises B to C (6+6)', () => {
1177
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['b', 'c']));
1178
- expect(selectedPrices(result)).toEqual([600, 600]);
1179
- });
1180
- it('C+B is order independent (6+6)', () => {
1181
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['c', 'b']));
1182
- expect(selectedPrices(result)).toEqual([600, 600]);
1183
- });
1184
- it('C+D needs no raise (6+6)', () => {
1185
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['c', 'd']));
1186
- expect(selectedPrices(result)).toEqual([600, 600]);
1187
- });
1188
- it('A+D raises A to D (6+6)', () => {
1189
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'd']));
1190
- expect(selectedPrices(result)).toEqual([600, 600]);
1191
- });
1192
- it('unselected options keep their own prices; item-level upsell untouched', () => {
1193
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
1194
- const seg1 = result.modifiers.find((m) => m._id === 'seg-1');
1195
- expect(seg1.options.find((o) => o._id === 'c').price).toBe(600);
1196
- expect(seg1.options.find((o) => o._id === 'd').price).toBe(600);
1197
- // Setup upsell is null -> engine item price 0 (added once, never normalized).
1198
- expect(result.price).toBe(0);
1199
- });
1200
- it('LOWERS again when switching from an expensive pair to a cheap pair (basePrices reset)', () => {
1201
- // B+C -> B is raised to 600...
1202
- const expensive = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['b', 'c']));
1203
- expect(selectedPrices(expensive)).toEqual([600, 600]);
1204
- // ...then the user switches BOTH halves to the cheap pair A+B. Re-applying
1205
- // with pristine basePrices must bring B back down to 500.
1206
- let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(expensive, 'seg-1_b', false);
1029
+ it('A+B charges 5+5: expensive UNSELECTED options never leak into the max', () => {
1030
+ const { originalPriceReferences, workingData } = buildState();
1031
+ let engine = workingData;
1207
1032
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_a', true);
1208
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', false);
1209
1033
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_b', true);
1210
- const lowered = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices });
1211
- expect(selectedPrices(lowered)).toEqual([500, 500]);
1212
- });
1213
- it('workable conversion no longer bakes the global max into option prices', () => {
1214
- const workable = (0, halfhalf_setup_helpers_1.convertHalfHalfSetupToWorkableHalfHalfSetup)([setup4()], itemsMap4, PLATFORM, TENANT_ID);
1215
- // a/b stay 500, c/d stay 600 — NOT all raised to 600 at conversion.
1216
- expect(workable[0].items.map((i) => priceOf(i.price))).toEqual([500, 500, 600, 600]);
1217
- });
1218
- it('user flow: after B+C, switching to C+D returns the de-selected B to 500', () => {
1219
- const engine = selectEngine(['b', 'c']);
1220
- const displayed = normalize(engine);
1221
- expect(selectedPrices(displayed)).toEqual([600, 600]);
1222
- // From the pristine drawer state AND from the raised display alike.
1223
- for (const source of [engine, displayed]) {
1224
- const result = normalize(pick(pick(source, 0, 'c'), 1, 'd'));
1225
- expect(selectedPrices(result)).toEqual([600, 600]);
1226
- // B is no longer selected anywhere -> back to its own 500.
1227
- expect(optionPrice(result, 'seg-1', 'b')).toBe(500);
1228
- expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
1229
- // D keeps its own 600 and C stays selected at 600.
1230
- expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
1231
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1232
- }
1233
- });
1234
- it('user flow: after B+C, switching to C,B keeps 6+6 and de-selected segment-1 B drops to 500', () => {
1235
- const engine = selectEngine(['b', 'c']);
1236
- const displayed = normalize(engine);
1237
- for (const source of [engine, displayed]) {
1238
- const result = normalize(pick(pick(source, 0, 'c'), 1, 'b'));
1239
- expect(selectedPrices(result)).toEqual([600, 600]);
1240
- // Segment 1 now charges C (600); its B is de-selected -> 500.
1241
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1242
- expect(optionPrice(result, 'seg-1', 'b')).toBe(500);
1243
- // Segment 2 charges B raised to C's price.
1244
- expect(optionPrice(result, 'seg-2', 'b')).toBe(600);
1245
- }
1246
- });
1247
- it('user flow: after B+C, switching to A+B lowers the previously raised B to 500', () => {
1248
- const engine = selectEngine(['b', 'c']);
1249
- const displayed = normalize(engine);
1250
- expect(selectedPrices(displayed)).toEqual([600, 600]);
1251
- for (const source of [engine, displayed]) {
1252
- const result = normalize(pick(pick(source, 0, 'a'), 1, 'b'));
1253
- expect(selectedPrices(result)).toEqual([500, 500]);
1254
- // The de-selected C keeps its own 600; nothing left over from the old pair.
1255
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1256
- expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
1257
- expect(optionPrice(result, 'seg-2', 'c')).toBe(600);
1258
- }
1034
+ const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
1035
+ expect(priceAt(result, 'seg-1', 'a')).toBe(500);
1036
+ expect(priceAt(result, 'seg-2', 'b')).toBe(500);
1037
+ // Expensive options keep their own (higher) price.
1038
+ expect(priceAt(result, 'seg-1', 'c')).toBe(600);
1259
1039
  });
1260
- it('a full session (B+C -> C,D -> C,B -> A,B) recomputes from pristine prices at every step', () => {
1261
- const engine = selectEngine(['b', 'c']);
1262
- expect(selectedPrices(normalize(engine))).toEqual([600, 600]);
1263
- const step1 = pick(pick(engine, 0, 'c'), 1, 'd');
1264
- const displayed1 = normalize(step1);
1265
- expect(selectedPrices(displayed1)).toEqual([600, 600]);
1266
- expect(optionPrice(displayed1, 'seg-1', 'b')).toBe(500);
1267
- const step2 = pick(pick(step1, 0, 'c'), 1, 'b');
1268
- const displayed2 = normalize(step2);
1269
- expect(selectedPrices(displayed2)).toEqual([600, 600]);
1270
- const step3 = pick(pick(step2, 0, 'a'), 1, 'b');
1271
- const displayed3 = normalize(step3);
1272
- expect(selectedPrices(displayed3)).toEqual([500, 500]);
1273
- // Every unselected option is its own price again.
1274
- expect(optionPrice(displayed3, 'seg-1', 'c')).toBe(600);
1275
- expect(optionPrice(displayed3, 'seg-1', 'd')).toBe(600);
1276
- expect(optionPrice(displayed3, 'seg-2', 'c')).toBe(600);
1040
+ it('B+C charges 6+6 and levels the cheaper options before they are picked', () => {
1041
+ const { originalPriceReferences, workingData } = buildState();
1042
+ let engine = workingData;
1043
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
1044
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
1045
+ const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
1046
+ // Selected: B levelled 500 -> 600, C stays 600.
1047
+ expect(priceAt(result, 'seg-1', 'b')).toBe(600);
1048
+ expect(priceAt(result, 'seg-2', 'c')).toBe(600);
1049
+ // Unselected cheap options SHOW what picking them would cost.
1050
+ expect(priceAt(result, 'seg-1', 'a')).toBe(600);
1051
+ expect(priceAt(result, 'seg-2', 'a')).toBe(600);
1052
+ expect(priceAt(result, 'seg-2', 'b')).toBe(600);
1277
1053
  });
1278
- it('full change matrix: every ordered pair -> pair switch recomputes from pristine prices', () => {
1279
- const combos = [
1280
- ['a', 'b'],
1281
- ['b', 'a'],
1282
- ['a', 'c'],
1283
- ['c', 'a'],
1284
- ['a', 'd'],
1285
- ['d', 'a'],
1286
- ['b', 'c'],
1287
- ['c', 'b'],
1288
- ['b', 'd'],
1289
- ['d', 'b'],
1290
- ['c', 'd'],
1291
- ['d', 'c'],
1292
- ];
1293
- for (const from of combos) {
1294
- const fromPristine = selectEngine(from);
1295
- const fromDisplay = normalize(fromPristine);
1296
- const expectedFrom = Math.max(baseValues[from[0]], baseValues[from[1]]);
1297
- expect(selectedPrices(fromDisplay)).toEqual([expectedFrom, expectedFrom]);
1298
- for (const to of combos) {
1299
- const expectedTo = Math.max(baseValues[to[0]], baseValues[to[1]]);
1300
- for (const source of [fromPristine, fromDisplay]) {
1301
- const result = normalize(pick(pick(source, 0, to[0]), 1, to[1]));
1302
- expect(selectedPrices(result)).toEqual([expectedTo, expectedTo]);
1303
- // Every half de-selected by the switch is back to its own price.
1304
- for (const optionId of from) {
1305
- if (to.includes(optionId))
1306
- continue;
1307
- expect(optionPrice(result, 'seg-1', optionId)).toBe(baseValues[optionId]);
1308
- expect(optionPrice(result, 'seg-2', optionId)).toBe(baseValues[optionId]);
1309
- }
1310
- }
1311
- }
1312
- }
1054
+ it('switching B+C -> A+B on the SAME (already levelled) item lowers again', () => {
1055
+ const { originalPriceReferences, workingData } = buildState();
1056
+ let engine = workingData;
1057
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-1_b', true);
1058
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_c', true);
1059
+ const raised = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
1060
+ expect(priceAt(raised, 'seg-1', 'b')).toBe(600);
1061
+ // The user changes the choice in place: B -> A, C -> B.
1062
+ let switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(raised, 'seg-1_a', true);
1063
+ switched = (0, order_engine_1.setCheckFieldInOrderEngineItem)(switched, 'seg-2_b', true);
1064
+ const lowered = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(switched, { originalPriceReferences });
1065
+ expect(priceAt(lowered, 'seg-1', 'a')).toBe(500);
1066
+ expect(priceAt(lowered, 'seg-2', 'b')).toBe(500);
1067
+ // De-selected C is back to its own price: nothing accumulates.
1068
+ expect(priceAt(lowered, 'seg-1', 'c')).toBe(600);
1069
+ expect(priceAt(lowered, 'seg-2', 'c')).toBe(600);
1313
1070
  });
1314
- it('edit flow: persisted raised prices are re-based before the next change', () => {
1315
- // Submit B+C -> the order item stores segment-1 B at 600.
1316
- const submitted = normalize(selectEngine(['b', 'c']));
1317
- const orderItem = (0, order_engine_1.convertOrderEngineItemToOrderItem)(submitted, TENANT_ID);
1318
- expect((orderItem.modifiers ?? []).find((m) => m._id === 'seg-1').options.find((o) => o._id === 'b').price).toBe(600);
1319
- // Reopen the drawer for edit: the persisted raise reads back into the engine...
1320
- const reopened = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
1321
- item: converted,
1322
- orderItem,
1323
- platform: PLATFORM,
1324
- tenantId: TENANT_ID,
1325
- orderItemType: constants_1.ORDER_ITEM_TYPE_ENUM.HALF_HALF,
1326
- defaultMenuId: null,
1327
- soldoutModifiers: [],
1328
- });
1329
- expect(optionPrice(reopened, 'seg-1', 'b')).toBe(600);
1330
- // ...and the pristine reset restores the catalog baseline.
1331
- const rebased = (0, order_engine_1.resetOrderEngineItemPrices)(reopened, basePrices);
1332
- expect(optionPrice(rebased, 'seg-1', 'b')).toBe(500);
1333
- // Submitting without changes keeps B+C at 6+6...
1334
- expect(selectedPrices(normalize(rebased))).toEqual([600, 600]);
1335
- // ...while switching to A+B lowers B back to 5.
1336
- const changed = normalize(pick(pick(rebased, 0, 'a'), 1, 'b'));
1337
- expect(selectedPrices(changed)).toEqual([500, 500]);
1338
- expect(optionPrice(changed, 'seg-1', 'b')).toBe(500);
1339
- expect(optionPrice(changed, 'seg-2', 'b')).toBe(500);
1340
- });
1341
- it('single selected half: nothing to raise, the other segment stays untouched', () => {
1342
- const result = normalize(pick(freshEngine(), 0, 'a'));
1343
- expect(optionPrice(result, 'seg-1', 'a')).toBe(500);
1344
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1345
- // Segment 2 has no selection at all — its options keep their own prices.
1346
- expect(optionPrice(result, 'seg-2', 'a')).toBe(500);
1347
- expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
1348
- });
1349
- it('no selection at all: prices are re-based and nothing is raised or invented', () => {
1350
- const source = freshEngine();
1351
- // Legacy call (no basePrices): unchanged item is returned as is.
1352
- expect((0, order_engine_1.applyChooseExpensiveSegmentPrice)(source)).toBe(source);
1353
- const result = normalize(source);
1354
- expect(optionPrice(result, 'seg-1', 'a')).toBe(500);
1355
- expect(optionPrice(result, 'seg-1', 'c')).toBe(600);
1356
- expect(optionPrice(result, 'seg-2', 'b')).toBe(500);
1357
- expect(optionPrice(result, 'seg-2', 'd')).toBe(600);
1358
- });
1359
- it('quarters (4 segments): max over the four selected sides; switching sides re-bases', () => {
1360
- const quarters = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(makeHalfHalfSetup({
1361
- upsell_price: null,
1362
- segments: [
1363
- { _id: 'q-1', name: 'Quarter 1', sort_id: 1 },
1364
- { _id: 'q-2', name: 'Quarter 2', sort_id: 2 },
1365
- { _id: 'q-3', name: 'Quarter 3', sort_id: 3 },
1366
- { _id: 'q-4', name: 'Quarter 4', sort_id: 4 },
1367
- ],
1368
- items: [
1369
- { item_id: 'a', sort_id: 1, upsell_price: null },
1370
- { item_id: 'b', sort_id: 2, upsell_price: null },
1371
- { item_id: 'c', sort_id: 3, upsell_price: null },
1372
- { item_id: 'd', sort_id: 4, upsell_price: null },
1373
- ],
1374
- }), itemsMap4);
1375
- const quarterBase = (0, order_engine_1.getOptionPriceMapFromItem)(quarters, PLATFORM);
1376
- const quarterPrice = (item, segmentId, optionId) => item.modifiers.find((m) => m._id === segmentId).options.find((o) => o._id === optionId).price;
1377
- let engine = freshEngine(quarters);
1378
- // a/b = 1000/4 = 250, c/d = 1200/4 = 300.
1379
- expect(quarterPrice(engine, 'q-1', 'a')).toBe(250);
1380
- expect(quarterPrice(engine, 'q-1', 'c')).toBe(300);
1381
- const picks = [
1382
- ['q-1', 'a'],
1383
- ['q-2', 'a'],
1384
- ['q-3', 'd'],
1385
- ['q-4', 'd'],
1386
- ];
1387
- for (const [segmentId, optionId] of picks) {
1388
- engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `${segmentId}_${optionId}`, true);
1389
- }
1390
- const mixed = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { basePrices: quarterBase });
1391
- for (const segmentId of ['q-1', 'q-2']) {
1392
- expect(quarterPrice(mixed, segmentId, 'a')).toBe(300);
1393
- }
1394
- for (const segmentId of ['q-3', 'q-4']) {
1395
- expect(quarterPrice(mixed, segmentId, 'd')).toBe(300);
1396
- }
1397
- // All four sides cheap: everything returns to 250 (from the raised state too).
1398
- for (const source of [engine, mixed]) {
1399
- let cheap = source;
1400
- for (const segmentId of ['q-1', 'q-2', 'q-3', 'q-4']) {
1401
- cheap = (0, order_engine_1.setCheckFieldInOrderEngineItem)(cheap, `${segmentId}_a`, true);
1402
- }
1403
- const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(cheap, { basePrices: quarterBase });
1404
- for (const segmentId of ['q-1', 'q-2', 'q-3', 'q-4']) {
1405
- expect(quarterPrice(result, segmentId, 'a')).toBe(250);
1406
- }
1407
- // De-selected c/d keep their own 300.
1408
- expect(quarterPrice(result, 'q-1', 'd')).toBe(300);
1409
- }
1071
+ it('edit flow: persisted, already-raised prices are re-based from the definition', () => {
1072
+ const { originalPriceReferences, workingData } = buildState();
1073
+ // Simulate an edit line: B was charged 600 by a previous normalization.
1074
+ const persisted = {
1075
+ ...workingData,
1076
+ modifiers: workingData.modifiers.map((modifier) => ({
1077
+ ...modifier,
1078
+ options: modifier.options.map((option) => (option._id === 'b' ? { ...option, price: 600 } : option)),
1079
+ })),
1080
+ };
1081
+ let engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(persisted, 'seg-1_b', true);
1082
+ engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, 'seg-2_a', true);
1083
+ const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(engine, { originalPriceReferences });
1084
+ // B's persisted 600 is NOT the baseline: A+B is a cheap pair (5+5).
1085
+ expect(priceAt(result, 'seg-1', 'b')).toBe(500);
1086
+ expect(priceAt(result, 'seg-2', 'a')).toBe(500);
1410
1087
  });
1411
1088
  });