@managesome/eposmatic-toolkit 0.2.718 → 0.2.719

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.
@@ -68,14 +68,40 @@ export declare function applyNestedChooseExpensiveSegmentPrice(orderEngineItem:
68
68
  * item (`modifiers -> options -> nested modifiers -> options ...`). Used as
69
69
  * the baseline for `choose_expensive_segment_price` so applying the rule never
70
70
  * depends on previously raised prices.
71
+ *
72
+ * The flat `_id -> price` shape can only represent ONE value per option
73
+ * `_id`, so callers MUST keep the map to a single price scope. A half-half
74
+ * nested in a special is exactly the case where that fails: its segment
75
+ * options are built FROM the special's items, so they reuse the SAME `_id`s
76
+ * as the special's top-level options while their prices differ (top-level =
77
+ * full upsell, segment = per-segment share). `nestedHalfHalfSegmentsOnly`
78
+ * keeps the map to the subtrees of HALF_HALF options (the segment trees plus
79
+ * their nested modifiers), excluding top-level option prices — the special
80
+ * drawer feeds this map to `resetOrderEngineItemPrices` / the nested
81
+ * normalization, so the walk order of the item can never leak a top-level
82
+ * price into a segment (or the other way around). Standalone half-half items
83
+ * are a single scope: every segment shares its option `_id`s with the SAME
84
+ * price, so the unscoped map is safe there.
71
85
  */
72
- export declare function getOptionPriceMapFromItem(item: IItem | ISimplifiedCatalogItem, platform: PLATFORMS_ENUM | null | undefined): Record<string, number>;
86
+ export declare function getOptionPriceMapFromItem(item: IItem | ISimplifiedCatalogItem, platform: PLATFORMS_ENUM | null | undefined, options?: {
87
+ nestedHalfHalfSegmentsOnly?: boolean;
88
+ }): Record<string, number>;
73
89
  /**
74
90
  * Restores every engine option price from the pristine `basePrices` map (by
75
91
  * option `_id`). Called when the drawer builds the engine item so state
76
92
  * (sidebar prices, edit baselines) never carries a previous normalization.
93
+ *
94
+ * `options.nestedHalfHalfOnly` restricts the reset to the subtrees of
95
+ * HALF_HALF options — the exact scope `getOptionPriceMapFromItem` builds when
96
+ * called with `nestedHalfHalfSegmentsOnly`. A special's top-level options
97
+ * reuse their `_id`s at different prices (full upsell vs per-segment share),
98
+ * so a blanket reset with the scoped map would push the segment share onto
99
+ * the top-level option. ALWAYS pass the SAME scope to the map builder and to
100
+ * this reset.
77
101
  */
78
- export declare function resetOrderEngineItemPrices(orderEngineItem: IOrderEngineItem, basePrices: Record<string, number>): IOrderEngineItem;
102
+ export declare function resetOrderEngineItemPrices(orderEngineItem: IOrderEngineItem, basePrices: Record<string, number>, options?: {
103
+ nestedHalfHalfOnly?: boolean;
104
+ }): IOrderEngineItem;
79
105
  export type IOrderEngineItemRewardClaim = {
80
106
  type: 'offer';
81
107
  offerId: string;
@@ -502,26 +502,65 @@ function applyNestedChooseExpensiveSegmentPrice(orderEngineItem, options) {
502
502
  * item (`modifiers -> options -> nested modifiers -> options ...`). Used as
503
503
  * the baseline for `choose_expensive_segment_price` so applying the rule never
504
504
  * depends on previously raised prices.
505
+ *
506
+ * The flat `_id -> price` shape can only represent ONE value per option
507
+ * `_id`, so callers MUST keep the map to a single price scope. A half-half
508
+ * nested in a special is exactly the case where that fails: its segment
509
+ * options are built FROM the special's items, so they reuse the SAME `_id`s
510
+ * as the special's top-level options while their prices differ (top-level =
511
+ * full upsell, segment = per-segment share). `nestedHalfHalfSegmentsOnly`
512
+ * keeps the map to the subtrees of HALF_HALF options (the segment trees plus
513
+ * their nested modifiers), excluding top-level option prices — the special
514
+ * drawer feeds this map to `resetOrderEngineItemPrices` / the nested
515
+ * normalization, so the walk order of the item can never leak a top-level
516
+ * price into a segment (or the other way around). Standalone half-half items
517
+ * are a single scope: every segment shares its option `_id`s with the SAME
518
+ * price, so the unscoped map is safe there.
505
519
  */
506
- function getOptionPriceMapFromItem(item, platform) {
520
+ function getOptionPriceMapFromItem(item, platform, options) {
507
521
  const priceMap = {};
508
- const walk = (modifiers) => {
522
+ const nestedHalfHalfSegmentsOnly = options?.nestedHalfHalfSegmentsOnly === true;
523
+ const walk = (modifiers, insideHalfHalf) => {
509
524
  (modifiers ?? []).forEach((modifier) => {
510
525
  (modifier.options ?? []).forEach((option) => {
511
- priceMap[option._id] = (0, platform_catalog_1.getPriceEnum)(option.price, platform);
512
- walk(option.modifiers);
526
+ const isHalfHalf = option.ref_type === constants_1.MODIFIER_OPTION_REF_TYPE_ENUM.HALF_HALF;
527
+ // Inside a half-half subtree every option belongs to the segment
528
+ // scope; at the top level only record when not scoped (or record
529
+ // nothing because the option is the half-half hub itself, whose price
530
+ // is NOT part of the segment scope).
531
+ if (insideHalfHalf || !nestedHalfHalfSegmentsOnly) {
532
+ priceMap[option._id] = (0, platform_catalog_1.getPriceEnum)(option.price, platform);
533
+ }
534
+ walk(option.modifiers, insideHalfHalf || isHalfHalf);
513
535
  });
514
536
  });
515
537
  };
516
- walk(item.modifiers);
538
+ walk(item.modifiers, false);
517
539
  return priceMap;
518
540
  }
519
541
  /**
520
542
  * Restores every engine option price from the pristine `basePrices` map (by
521
543
  * option `_id`). Called when the drawer builds the engine item so state
522
544
  * (sidebar prices, edit baselines) never carries a previous normalization.
545
+ *
546
+ * `options.nestedHalfHalfOnly` restricts the reset to the subtrees of
547
+ * HALF_HALF options — the exact scope `getOptionPriceMapFromItem` builds when
548
+ * called with `nestedHalfHalfSegmentsOnly`. A special's top-level options
549
+ * reuse their `_id`s at different prices (full upsell vs per-segment share),
550
+ * so a blanket reset with the scoped map would push the segment share onto
551
+ * the top-level option. ALWAYS pass the SAME scope to the map builder and to
552
+ * this reset.
523
553
  */
524
- function resetOrderEngineItemPrices(orderEngineItem, basePrices) {
554
+ function resetOrderEngineItemPrices(orderEngineItem, basePrices, options) {
555
+ if (options?.nestedHalfHalfOnly === true) {
556
+ const modifiers = (orderEngineItem.modifiers ?? []).map((modifier) => ({
557
+ ...modifier,
558
+ options: (modifier.options ?? []).map((option) => option.ref_type !== constants_1.MODIFIER_OPTION_REF_TYPE_ENUM.HALF_HALF
559
+ ? option
560
+ : { ...option, modifiers: resetEngineOptionPrices(option.modifiers ?? [], basePrices) }),
561
+ }));
562
+ return syncOrderEngineItem({ ...orderEngineItem, modifiers });
563
+ }
525
564
  const modifiers = resetEngineOptionPrices(orderEngineItem.modifiers ?? [], basePrices);
526
565
  return syncOrderEngineItem({ ...orderEngineItem, modifiers });
527
566
  }
@@ -270,6 +270,26 @@ describe('applyNestedChooseExpensiveSegmentPrice — selected-halves max', () =>
270
270
  function halfHalfOption(item) {
271
271
  return item.modifiers[0].options[0];
272
272
  }
273
+ /** Marks the given option of a segment as a free slot (`is_free`). */
274
+ function markFree(item, segmentId, optionId) {
275
+ return {
276
+ ...item,
277
+ modifiers: item.modifiers.map((modifier) => ({
278
+ ...modifier,
279
+ options: modifier.options.map((option) => option.ref_type === constants_1.MODIFIER_OPTION_REF_TYPE_ENUM.HALF_HALF
280
+ ? {
281
+ ...option,
282
+ modifiers: option.modifiers.map((segment) => segment._id === segmentId
283
+ ? {
284
+ ...segment,
285
+ options: segment.options.map((o) => (o._id === optionId ? { ...o, is_free: true } : o)),
286
+ }
287
+ : segment),
288
+ }
289
+ : option),
290
+ })),
291
+ };
292
+ }
273
293
  function segmentPrice(item, segmentId, optionId) {
274
294
  const option = halfHalfOption(item).modifiers.find((m) => m._id === segmentId);
275
295
  return option.options.find((o) => o._id === optionId).price;
@@ -299,4 +319,96 @@ describe('applyNestedChooseExpensiveSegmentPrice — selected-halves max', () =>
299
319
  expect(segmentPrice(lowered, 'seg-1', 'milan')).toBe(500);
300
320
  expect(segmentPrice(lowered, 'seg-2', 'milan2')).toBe(500);
301
321
  });
322
+ it('changing picks: cheap pair lowers the raised half, swap keeps the max', () => {
323
+ const basePrices = { milan: 500, torent: 600, milan2: 500, torent2: 600 };
324
+ const hub = makeHub(makeSegmentGroups());
325
+ // milan (500) + torent2 (600) -> milan raised to 600.
326
+ const premium = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(hub, { 'seg-1': 'milan', 'seg-2': 'torent2' }));
327
+ expect(segmentPrice(premium, 'seg-1', 'milan')).toBe(600);
328
+ // -> cheap pair milan + milan2: the previously raised milan returns to 500.
329
+ const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(premium, { 'seg-1': 'milan', 'seg-2': 'milan2' }), { basePrices });
330
+ expect(segmentPrice(cheap, 'seg-1', 'milan')).toBe(500);
331
+ expect(segmentPrice(cheap, 'seg-2', 'milan2')).toBe(500);
332
+ // De-selected torent2 keeps its own 600.
333
+ expect(segmentPrice(cheap, 'seg-2', 'torent2')).toBe(600);
334
+ // -> swap to torent + milan2: the newly expensive half is raised and the
335
+ // de-selected milan is re-based (no leftover 600).
336
+ const swapped = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(premium, { 'seg-1': 'torent', 'seg-2': 'milan2' }), { basePrices });
337
+ expect(segmentPrice(swapped, 'seg-1', 'torent')).toBe(600);
338
+ expect(segmentPrice(swapped, 'seg-2', 'milan2')).toBe(600);
339
+ expect(segmentPrice(swapped, 'seg-1', 'milan')).toBe(500);
340
+ });
341
+ it('full change matrix: every switch recomputes from base prices (pristine vs raised source)', () => {
342
+ const basePrices = { milan: 500, torent: 600, milan2: 500, torent2: 600 };
343
+ const combos = [
344
+ { 'seg-1': 'milan', 'seg-2': 'milan2' },
345
+ { 'seg-1': 'milan', 'seg-2': 'torent2' },
346
+ { 'seg-1': 'torent', 'seg-2': 'milan2' },
347
+ { 'seg-1': 'torent', 'seg-2': 'torent2' },
348
+ ];
349
+ const hub = makeHub(makeSegmentGroups());
350
+ for (const from of combos) {
351
+ const fromDisplay = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(hub, from));
352
+ for (const to of combos) {
353
+ const expected = Math.max(basePrices[to['seg-1']], basePrices[to['seg-2']]);
354
+ for (const source of [hub, fromDisplay]) {
355
+ const result = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(source, to), {
356
+ basePrices,
357
+ });
358
+ expect(segmentPrice(result, 'seg-1', to['seg-1'])).toBe(expected);
359
+ expect(segmentPrice(result, 'seg-2', to['seg-2'])).toBe(expected);
360
+ // Every half de-selected by the switch is back to its own price.
361
+ for (const segmentId of ['seg-1', 'seg-2']) {
362
+ const fromOption = from[segmentId];
363
+ if ([to['seg-1'], to['seg-2']].includes(fromOption))
364
+ continue;
365
+ expect(segmentPrice(result, segmentId, fromOption)).toBe(basePrices[fromOption]);
366
+ }
367
+ }
368
+ }
369
+ }
370
+ });
371
+ it('is idempotent when re-applied with basePrices', () => {
372
+ const basePrices = { milan: 500, torent: 600, milan2: 500, torent2: 600 };
373
+ const once = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(makeHub(makeSegmentGroups()), { 'seg-1': 'milan', 'seg-2': 'torent2' }), { basePrices });
374
+ const twice = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(once, { basePrices });
375
+ expect(twice).toEqual(once);
376
+ });
377
+ it('resetOrderEngineItemPrices restores nested segment prices (edit flow)', () => {
378
+ const basePrices = { milan: 500, torent: 600, milan2: 500, torent2: 600 };
379
+ const raised = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(makeHub(makeSegmentGroups()), { 'seg-1': 'milan', 'seg-2': 'torent2' }));
380
+ expect(segmentPrice(raised, 'seg-1', 'milan')).toBe(600);
381
+ // Reopening an edit: the persisted raise is re-based from the pristine map.
382
+ const rebased = (0, order_engine_1.resetOrderEngineItemPrices)(raised, basePrices);
383
+ expect(segmentPrice(rebased, 'seg-1', 'milan')).toBe(500);
384
+ expect(segmentPrice(rebased, 'seg-1', 'torent')).toBe(600);
385
+ expect(segmentPrice(rebased, 'seg-2', 'torent2')).toBe(600);
386
+ // Changing the pick afterwards lowers correctly (no accumulation).
387
+ const cheap = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(withSelections(rebased, { 'seg-1': 'milan', 'seg-2': 'milan2' }), { basePrices });
388
+ expect(segmentPrice(cheap, 'seg-1', 'milan')).toBe(500);
389
+ expect(segmentPrice(cheap, 'seg-2', 'milan2')).toBe(500);
390
+ });
391
+ it('single selected segment: nothing to raise', () => {
392
+ const item = withSelections(makeHub(makeSegmentGroups()), { 'seg-1': 'milan' });
393
+ const result = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(item);
394
+ expect(segmentPrice(result, 'seg-1', 'milan')).toBe(500);
395
+ // No selection in segment 2 — its options keep their own prices.
396
+ expect(segmentPrice(result, 'seg-2', 'milan2')).toBe(500);
397
+ expect(segmentPrice(result, 'seg-2', 'torent2')).toBe(600);
398
+ });
399
+ it('no selection at all: nothing is raised or invented', () => {
400
+ const item = withSelections(makeHub(makeSegmentGroups()), {});
401
+ const result = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(item);
402
+ expect(segmentPrice(result, 'seg-1', 'milan')).toBe(500);
403
+ expect(segmentPrice(result, 'seg-1', 'torent')).toBe(600);
404
+ expect(segmentPrice(result, 'seg-2', 'torent2')).toBe(600);
405
+ });
406
+ it('a free selected half neither drives the max nor gets raised', () => {
407
+ // The expensive side (torent2, 600) sits in a free slot: the paid half
408
+ // (milan, 500) must NOT be raised to it.
409
+ const item = markFree(withSelections(makeHub(makeSegmentGroups()), { 'seg-1': 'milan', 'seg-2': 'torent2' }), 'seg-2', 'torent2');
410
+ const result = (0, order_engine_1.applyNestedChooseExpensiveSegmentPrice)(item);
411
+ expect(segmentPrice(result, 'seg-1', 'milan')).toBe(500);
412
+ expect(segmentPrice(result, 'seg-2', 'torent2')).toBe(600);
413
+ });
302
414
  });
@@ -844,11 +844,13 @@ 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 buildEngine() {
848
- const item = (0, specials_helpers_1.convertSpecialToItem)(modifySpecialItems(makeSpecial(), specialItems), {
847
+ function buildSpecialItem(items = specialItems) {
848
+ return (0, specials_helpers_1.convertSpecialToItem)(modifySpecialItems(makeSpecial(), items), {
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()) {
852
854
  return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
853
855
  item,
854
856
  orderItem: undefined,
@@ -859,6 +861,30 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
859
861
  soldoutModifiers: [],
860
862
  });
861
863
  }
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;
887
+ }
862
888
  function segmentOptions(engine, halfHalfId = 'halfhalf-1') {
863
889
  const hh = engine.modifiers[0].options.find((o) => o._id === halfHalfId);
864
890
  return hh.modifiers.map((seg) => seg.options.map((o) => ({ id: o._id, price: o.price, default: o.default })));
@@ -959,6 +985,133 @@ describe('choose_expensive_segment_price end-to-end (specials with half-half)',
959
985
  expect(hhFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(100);
960
986
  expect(hhNoFlag.modifiers[0].options.find((o) => o._id === 'milan').price).toBe(0);
961
987
  });
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: [],
1099
+ });
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,
1111
+ });
1112
+ expect(nestedPrice(cheap, 0, 'milan')).toBe(0);
1113
+ expect(nestedPrice(cheap, 1, 'milan')).toBe(0);
1114
+ });
962
1115
  });
963
1116
  // ============================================================================
964
1117
  // 5) Engine — choose_expensive_segment_price uses the MAX OF THE SELECTED halves
@@ -983,9 +1136,11 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
983
1136
  });
984
1137
  const converted = (0, halfhalf_setup_helpers_1.convertHalfHalfToItem)(setup4(), itemsMap4);
985
1138
  const basePrices = (0, order_engine_1.getOptionPriceMapFromItem)(converted, PLATFORM);
986
- function selectEngine(picks) {
987
- let engine = (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
988
- item: converted,
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) {
1142
+ return (0, order_engine_1.convertCatalogItemToOrderEngineItem)({
1143
+ item,
989
1144
  orderItem: undefined,
990
1145
  platform: PLATFORM,
991
1146
  tenantId: TENANT_ID,
@@ -993,6 +1148,9 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
993
1148
  defaultMenuId: null,
994
1149
  soldoutModifiers: [],
995
1150
  });
1151
+ }
1152
+ function selectEngine(picks) {
1153
+ let engine = freshEngine();
996
1154
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-1_${picks[0]}`, true);
997
1155
  engine = (0, order_engine_1.setCheckFieldInOrderEngineItem)(engine, `seg-2_${picks[1]}`, true);
998
1156
  return engine;
@@ -1000,6 +1158,17 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
1000
1158
  function selectedPrices(engine) {
1001
1159
  return engine.modifiers.map((m) => m.options.find((o) => o.default).price);
1002
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
+ }
1003
1172
  it('A+B stays 5+5 (global max must NOT leak)', () => {
1004
1173
  const result = (0, order_engine_1.applyChooseExpensiveSegmentPrice)(selectEngine(['a', 'b']));
1005
1174
  expect(selectedPrices(result)).toEqual([500, 500]);
@@ -1046,4 +1215,197 @@ describe('choose_expensive_segment_price: selected-halves max (new semantics)',
1046
1215
  // a/b stay 500, c/d stay 600 — NOT all raised to 600 at conversion.
1047
1216
  expect(workable[0].items.map((i) => priceOf(i.price))).toEqual([500, 500, 600, 600]);
1048
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
+ }
1259
+ });
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);
1277
+ });
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
+ }
1313
+ });
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
+ }
1410
+ });
1049
1411
  });
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@managesome/eposmatic-toolkit",
3
- "version": "0.2.718",
3
+ "version": "0.2.719",
4
4
  "description": "A Toolkit Library for Eposmatic",
5
5
  "main": "lib/index.js",
6
6
  "types": "lib/index.d.ts",