@pisell/pisellos 2.2.313 → 2.2.315

package/lib/model/strategy/adapter/itemRule/evaluator.d.ts

@@ -1,5 +1,5 @@
 import type { StrategyConfig } from '../../type';
-import { type ItemRuleBusinessData, type ItemRuleEvaluationResult, type QuantityCheckResult, type QuantityLimitResult, type PrefillItemResult, type AllergyRequirement } from './type';
+import { type ItemRuleBusinessData, type ItemRuleEvaluationResult, type QuantityCheckResult, type QuantityLimitResult, type PrefillItemResult, type ItemRuleCartAction, type AllergyRequirement } from './type';
 /**
  * ItemRule 评估器
  *
@@ -47,4 +47,6 @@ export declare class ItemRuleEvaluator {
      * 便捷方法：仅获取需要预填到购物车的商品
      */
     getPrefillItems(businessData: ItemRuleBusinessData): PrefillItemResult[];
+    /** 获取按优先级排序的购物车动作，交由销售业务层执行。 */
+    getCartActions(businessData: ItemRuleBusinessData): ItemRuleCartAction[];
 }

package/lib/model/strategy/adapter/itemRule/evaluator.js

@@ -43,6 +43,7 @@ class ItemRuleEvaluator {
     const configs = businessData.strategyConfigs ? businessData.strategyConfigs.filter(c => c.metadata.type === 'item_rule') : this.strategyConfigs;
     const allQuantityChecks = [];
     const allPrefillItems = [];
+    const allCartActions = [];
     const allAllergyRequirements = [];
     const rawResults = [];
     const context = this.adapter.prepareContext(businessData);
@@ -52,16 +53,19 @@ class ItemRuleEvaluator {
       const {
         quantityChecks,
         prefillItems,
+        cartActions,
         allergyRequirements
       } = this.adapter.transformResult(evalResult, businessData);
       allQuantityChecks.push(...quantityChecks);
       allPrefillItems.push(...prefillItems);
+      allCartActions.push(...cartActions);
       allAllergyRequirements.push(...allergyRequirements);
     }
     const failedChecks = allQuantityChecks.filter(c => !c.passed);
     return {
       quantityChecks: allQuantityChecks,
       prefillItems: allPrefillItems,
+      cartActions: allCartActions.sort((left, right) => right.priority - left.priority),
       allergyRequirements: allAllergyRequirements,
       allPassed: failedChecks.length === 0,
       failedChecks,
@@ -130,5 +134,10 @@ class ItemRuleEvaluator {
     const result = this.evaluate(businessData);
     return result.prefillItems;
   }
+
+  /** 获取按优先级排序的购物车动作，交由销售业务层执行。 */
+  getCartActions(businessData) {
+    return this.evaluate(businessData).cartActions;
+  }
 }
 exports.ItemRuleEvaluator = ItemRuleEvaluator;

package/lib/model/strategy/adapter/itemRule/type.d.ts

@@ -4,6 +4,8 @@ export declare const ITEM_RULE_ACTION_TYPES: {
     readonly QUANTITY_CHECK: "QUANTITY_CHECK";
     /** 预填购物车 */
     readonly PREFILL_CART: "PREFILL_CART";
+    /** 按商品 ID 删除购物车商品 */
+    readonly DELETE_PRODUCT: "DELETE_PRODUCT";
     /** 加购前过敏信息确认 */
     readonly ALLERGY_CHECK: "ALLERGY_CHECK";
 };
@@ -101,6 +103,10 @@ export interface AllergyRequirement {
     promptScope: AllergyPromptScope;
     allowNote: boolean;
 }
+/** 购物车动作触发时机，与数量校验的提交范围相互独立。 */
+export type ItemRuleExecutionScope = 'set_handover';
+/** 预填数量来源；主商品数量不扩展到 QUANTITY_CHECK。 */
+export type PrefillQuantitySource = QuantitySource | 'main_product_number';
 /**
  * 预填商品项
  */
@@ -110,9 +116,11 @@ export interface PrefillProduct {
     /** 变体 ID（可选，0 或不填表示无变体/默认） */
     product_variant_id?: number;
     /** 数量来源 */
-    quantityFrom: QuantitySource;
+    quantityFrom: PrefillQuantitySource;
     /** 固定数量（当 quantityFrom 为 'fixed' 时使用） */
     quantity?: number;
+    /** 设置取餐方式时同步自动附加行的数量，重复执行不累加。 */
+    repeat_skip?: boolean;
 }
 /**
  * Prefill Cart Action 的详细配置
@@ -120,9 +128,18 @@ export interface PrefillProduct {
  * 存储在 ActionEffect.config 中
  */
 export interface PrefillCartConfig {
+    /** 不填时保持原有预填时机；set_handover 仅在设置取餐方式时执行。 */
+    scope?: ItemRuleExecutionScope;
     /** 要预填的商品列表 */
     products: PrefillProduct[];
 }
+/** 删除指定商品的全部购物车行，不区分变体或是否为自动添加。 */
+export interface DeleteProductConfig {
+    scope: ItemRuleExecutionScope;
+    products: Array<{
+        product_id: number;
+    }>;
+}
 /**
  * 购物车商品摘要
  */
@@ -157,6 +174,10 @@ export interface ItemRuleBusinessData {
     historicalItems?: CartItemSummary[];
     /** 服务类型（如 'dine-in', 'takeaway'） */
     serviceType?: string;
+    /** 当前购物车动作触发时机；未填时不评估 set_handover 动作。 */
+    executionScope?: ItemRuleExecutionScope;
+    /** 由销售业务层提供的主商品总数量，不包含附加费用商品。 */
+    mainProductNumber?: number;
     /** 当前业务渠道（如 'kiosk', 'pos', 'online_store'） */
     channel?: string;
     /** 当前正在加入购物车的商品；ALLERGY_CHECK 只读取该商品的 Target。 */
@@ -209,7 +230,23 @@ export interface PrefillItemResult {
     product_variant_id?: number;
     /** 应添加的数量 */
     quantity: number;
+    /** true 时执行器同步自动附加行数量；quantity=0 表示移除该自动行。 */
+    repeat_skip?: boolean;
 }
+/** 保留不同购物车动作之间的优先级与执行顺序。 */
+export type ItemRuleCartAction = {
+    strategyId: string;
+    ruleId: string;
+    priority: number;
+} & ({
+    type: 'PREFILL_CART';
+    products: PrefillItemResult[];
+} | {
+    type: 'DELETE_PRODUCT';
+    products: Array<{
+        product_id: number;
+    }>;
+});
 /**
  * 单条规则的数量限制（不含校验结果，仅描述配置中的约束）
  */
@@ -258,6 +295,8 @@ export interface ItemRuleEvaluationResult {
     quantityChecks: QuantityCheckResult[];
     /** 需要预填的商品列表 */
     prefillItems: PrefillItemResult[];
+    /** 按 priority 降序排列的购物车动作；同优先级保持策略与动作顺序。 */
+    cartActions: ItemRuleCartAction[];
     /** 当前商品命中的过敏门禁要求；不同 Action/商品不会合并。 */
     allergyRequirements: AllergyRequirement[];
     /** 所有校验是否全部通过 */

package/lib/model/strategy/adapter/itemRule/type.js

@@ -13,6 +13,8 @@ const ITEM_RULE_ACTION_TYPES = exports.ITEM_RULE_ACTION_TYPES = {
   QUANTITY_CHECK: 'QUANTITY_CHECK',
   /** 预填购物车 */
   PREFILL_CART: 'PREFILL_CART',
+  /** 按商品 ID 删除购物车商品 */
+  DELETE_PRODUCT: 'DELETE_PRODUCT',
   /** 加购前过敏信息确认 */
   ALLERGY_CHECK: 'ALLERGY_CHECK'
 };
@@ -78,6 +80,10 @@ const ITEM_RULE_TEMPLATES = exports.ITEM_RULE_TEMPLATES = {
 // Prefill Cart 相关类型
 // ============================================
 
+/** 购物车动作触发时机，与数量校验的提交范围相互独立。 */
+
+/** 预填数量来源；主商品数量不扩展到 QUANTITY_CHECK。 */
+
 /**
  * 预填商品项
  */
@@ -88,6 +94,8 @@ const ITEM_RULE_TEMPLATES = exports.ITEM_RULE_TEMPLATES = {
  * 存储在 ActionEffect.config 中
  */
 
+/** 删除指定商品的全部购物车行，不区分变体或是否为自动添加。 */
+
 // ============================================
 // 业务数据类型（Evaluator 输入）
 // ============================================
@@ -116,6 +124,8 @@ const ITEM_RULE_TEMPLATES = exports.ITEM_RULE_TEMPLATES = {
  * 单个 Prefill Cart 的预填结果
  */
 
+/** 保留不同购物车动作之间的优先级与执行顺序。 */
+
 /**
  * 单条规则的数量限制（不含校验结果，仅描述配置中的约束）
  */

package/lib/modules/BookingContext/utils/productExtend.d.ts

@@ -7,6 +7,13 @@ import { TimeSlicesResult, TimeSlice, DurationSlice } from './timeSlices';
  * 让 OS 这层完全可在 Node 单测下运行（dayjs 在 Node 也是纯函数）。
  */
 export interface BookingCalcContext {
+    /** Sales channel; remembered duration starts are accepted only by POS. */
+    channel?: string;
+    /** Start-only device preference for this decision; never reuse a cached end/resource. */
+    rememberedTime?: {
+        businessDate: string;
+        startAt: string;
+    };
     /** 来自 `/core/board/management/config` 的整套配置；常用路径见 sliceTimeSlices / appointmentTimingPreference。 */
     bookingConfig?: any;
     /** 资源 origin map（id → resource origin）。 */

package/lib/modules/BookingContext/utils/productExtend.js

@@ -28,6 +28,44 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
  * 让 OS 这层完全可在 Node 单测下运行（dayjs 在 Node 也是纯函数）。
  */
 
+/** Rebuild only the derived booking fields; SKU, quantity, notes and Holder stay intact. */
+function seedRememberedBookingStart(cacheItem, ctx) {
+  const remembered = ctx.rememberedTime;
+  const invalid = () => Object.assign(new Error('Remembered time requires a valid POS duration start.'), {
+    code: 'INVALID_REMEMBERED_TIME'
+  });
+  const duration = cacheItem?.duration;
+  const durationType = typeof duration === 'object' && duration ? String(duration.type || '').toLowerCase() : '';
+  const durationValue = typeof duration === 'object' && duration ? duration.value : duration;
+  const isDuration = (0, _flexible.isProductFlexibleDuration)(duration) || ['', 'fixed', 'minute', 'minutes', 'hour', 'hours'].includes(durationType) && Number.isFinite(Number(durationValue)) && Number(durationValue) > 0;
+  const isCalendarDate = value => {
+    if (typeof value !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value)) return false;
+    const date = new Date(`${value}T00:00:00.000Z`);
+    return Number.isFinite(date.getTime()) && date.toISOString().slice(0, 10) === value;
+  };
+  const parts = typeof remembered?.startAt === 'string' ? /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2})(?::(\d{2})(?:\.\d{1,3})?)?(?:Z|[+-](\d{2}):(\d{2}))?$/.exec(remembered.startAt) : null;
+  if (String(ctx.channel || '').trim().toLowerCase() !== 'pos' || !isDuration || (0, _serviceTimes.isMultiDayProduct)(cacheItem) || (0, _serviceTimes.isSessionProduct)(cacheItem) || cacheItem?.cartDetailValue?.session || cacheItem?._extend?.other?.session || !isCalendarDate(remembered?.businessDate) || !parts || !isCalendarDate(parts[1]) || Number(parts[2]) > 23 || Number(parts[3]) > 59 || Number(parts[4] || 0) > 59 || Number(parts[5] || 0) > 23 || Number(parts[6] || 0) > 59) throw invalid();
+  // Parse the actual instant with the same runtime clock used by the legacy booking helpers.
+  // The business-day label must not replace the calendar date of an overnight start.
+  const start = (0, _dayjs.default)(remembered.startAt);
+  if (!start.isValid()) throw invalid();
+  const extend = {
+    ...(cacheItem?._extend || {})
+  };
+  for (const key of ['start_date', 'startDate', 'start_time', 'end_date', 'endDate', 'end_time', 'duration', 'resource', 'resources', 'capacity', 'booking', 'availabilitySelection']) delete extend[key];
+  return {
+    ...cacheItem,
+    new: 1,
+    autoClose: false,
+    _data: {},
+    _extend: {
+      ...extend,
+      start_date: start.format('YYYY-MM-DD'),
+      start_time: start.format(start.millisecond() ? 'HH:mm:ss.SSS' : start.second() ? 'HH:mm:ss' : 'HH:mm')
+    }
+  };
+}
+
 /** 从 BookingContext.date 提取 HH:mm（仅当日期带有效时分时）。 */
 function derivePresetStartTimeFromDate(date) {
   if (date == null) return undefined;
@@ -195,10 +233,15 @@ function getServiceStartTimeAndEndTime(params) {
  */
 function getProductExtend(params) {
   const {
-    cacheItem,
-    ctx,
     isDisabledTime
   } = params;
+  const hasRememberedTime = params.ctx.rememberedTime !== undefined;
+  const cacheItem = hasRememberedTime ? seedRememberedBookingStart(params.cacheItem, params.ctx) : params.cacheItem;
+  const ctx = hasRememberedTime ? {
+    ...params.ctx,
+    previousService: undefined,
+    presetStartTime: undefined
+  } : params.ctx;
   const isNew = cacheItem.new || !cacheItem._extend?.endDate;
   const _cacheItem = {
     ...cacheItem

package/lib/modules/BookingContext/utils/resources.js

@@ -241,7 +241,7 @@ function getResourceMaxFreeTime(resource, isAutoAllocationOn) {
   if (!isAutoAllocationOn(form_id)) return [];
   const usableList = (renderList || []).filter(d => d.usable && d.id !== 0);
   let defaultResource = [];
-  let maxFreeTime = 0;
+  let maxFreeTime = -1;
   usableList.forEach(d => {
     const {
       times = []

package/lib/modules/BusinessAvailability/index.d.ts

@@ -0,0 +1,30 @@
+import type { MultiLangObject } from '../OpenData/types';
+import type { ScheduleItem } from '../Schedule/types';
+export type BusinessClosedBehavior = 'show_menu_disabled' | 'hide_all';
+export interface BusinessAvailability {
+    status: 'open' | 'paused' | 'closed' | 'error';
+    behavior: BusinessClosedBehavior | null;
+    message: string | MultiLangObject | null;
+    /** Epoch milliseconds. Re-evaluate the cached configuration at this time. */
+    nextChangeAt: number;
+    requirePaymentOnSubmit: boolean;
+    error?: string;
+}
+export interface BusinessAvailabilityConfig {
+    paused: boolean;
+    pauseBehavior: BusinessClosedBehavior;
+    closedBehavior: BusinessClosedBehavior;
+    pauseMessage: BusinessAvailability['message'];
+    closedMessage: BusinessAvailability['message'];
+    scheduleIds: number[];
+    invalidScheduleIds: boolean;
+    requirePaymentOnSubmit: boolean;
+}
+export declare function normalizeBusinessAvailabilityConfig(data: Record<string, unknown>): BusinessAvailabilityConfig;
+/** Business ordering is independent of reservation switches and Pickup slot availability. */
+export declare function computeBusinessAvailability(input: {
+    config: BusinessAvailabilityConfig;
+    schedules: ScheduleItem[];
+    timezone: string;
+    now: Date;
+}): BusinessAvailability;

package/lib/modules/BusinessAvailability/index.js

@@ -0,0 +1,146 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.computeBusinessAvailability = computeBusinessAvailability;
+exports.normalizeBusinessAvailabilityConfig = normalizeBusinessAvailabilityConfig;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+var _isSameOrAfter = _interopRequireDefault(require("dayjs/plugin/isSameOrAfter"));
+var _isSameOrBefore = _interopRequireDefault(require("dayjs/plugin/isSameOrBefore"));
+var _getDateIsInSchedule = require("../Schedule/getDateIsInSchedule");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+_dayjs.default.extend(_isSameOrAfter.default);
+_dayjs.default.extend(_isSameOrBefore.default);
+const DAY = 86_400_000;
+const behavior = value => value === 'show_menu_disabled' ? value : 'hide_all';
+const message = value => typeof value === 'string' || value !== null && typeof value === 'object' && !Array.isArray(value) ? value : null;
+function normalizeBusinessAvailabilityConfig(data) {
+  const rawIds = data['availability.operating_hours'];
+  const ids = Array.isArray(rawIds) ? rawIds.map(id => typeof id === 'number' || typeof id === 'string' ? Number(id) : NaN) : [];
+  const validIds = ids.filter(id => Number.isInteger(id) && id > 0);
+  const paused = data['availability.paused'];
+  return {
+    paused: paused === true || paused === 1 || paused === 'true' || paused === '1',
+    pauseBehavior: behavior(data['availability.pause_behavior']),
+    closedBehavior: behavior(data['availability.closed_behavior']),
+    pauseMessage: message(data['availability.pause_message']),
+    closedMessage: message(data['availability.closed_message']),
+    scheduleIds: [...new Set(validIds)],
+    invalidScheduleIds: rawIds != null && (!Array.isArray(rawIds) || validIds.length !== ids.length),
+    // Only an explicitly disabled setting changes the existing payment flow.
+    requirePaymentOnSubmit: data['sale.require_payment_on_submit'] !== false
+  };
+}
+function createClock(timezone) {
+  if (!timezone) throw new Error('Store timezone is unavailable.');
+  const formatter = new Intl.DateTimeFormat('en-GB', {
+    timeZone: timezone,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+    hour: '2-digit',
+    minute: '2-digit',
+    second: '2-digit',
+    hourCycle: 'h23'
+  });
+  const local = timestamp => {
+    const parts = {};
+    formatter.formatToParts(timestamp).forEach(part => {
+      parts[part.type] = part.value;
+    });
+    const date = `${parts.year}-${parts.month}-${parts.day}`;
+    return {
+      date,
+      scalar: Date.parse(`${date}T${parts.hour}:${parts.minute}:${parts.second}Z`)
+    };
+  };
+  const offsets = new Set();
+  const instants = scalar => {
+    offsets.clear();
+    for (let hours = -36; hours <= 36; hours += 6) {
+      const sample = scalar + hours * 3_600_000;
+      offsets.add(local(sample).scalar - sample);
+    }
+    return [...offsets].map(offset => scalar - offset).filter(instant => local(instant).scalar === scalar).sort((a, b) => a - b);
+  };
+  return {
+    local,
+    instants
+  };
+}
+
+/** Business ordering is independent of reservation switches and Pickup slot availability. */
+function computeBusinessAvailability(input) {
+  const {
+    config,
+    schedules,
+    timezone,
+    now
+  } = input;
+  const nowAt = now.getTime();
+  const base = {
+    requirePaymentOnSubmit: config.requirePaymentOnSubmit,
+    nextChangeAt: nowAt + DAY
+  };
+  if (config.paused) {
+    return {
+      ...base,
+      status: 'paused',
+      behavior: config.pauseBehavior,
+      message: config.pauseMessage
+    };
+  }
+  if (config.invalidScheduleIds) throw new Error('Business operating-hours configuration is invalid.');
+  if (!config.scheduleIds.length) return {
+    ...base,
+    status: 'open',
+    behavior: null,
+    message: null
+  };
+  const selected = schedules.filter(schedule => config.scheduleIds.includes(Number(schedule.id)));
+  if (config.scheduleIds.some(id => !selected.some(schedule => Number(schedule.id) === id))) {
+    throw new Error('A configured business operating-hours schedule is unavailable.');
+  }
+  const clock = createClock(timezone);
+  const current = clock.local(nowAt);
+  const today = Date.parse(`${current.date}T00:00:00Z`);
+  const nextMidnight = clock.instants(today + DAY).find(instant => instant > nowAt);
+  let nextChangeAt = nextMidnight ?? nowAt + 60_000;
+  let open = false;
+  // Yesterday contributes the tail of overnight windows; today supplies the next boundary.
+  for (const dateAt of [today - DAY, today]) {
+    const date = new Date(dateAt).toISOString().slice(0, 10);
+    // Schedule's resolver merges by time-of-day, so resolve each schedule independently.
+    for (const schedule of selected) {
+      for (const window of (0, _getDateIsInSchedule.getScheduleStartEndTimePoints)(date, [schedule])) {
+        const toMinutes = value => {
+          if (!/^(?:[01]\d|2[0-3]):[0-5]\d$/.test(value) && value !== '24:00') {
+            throw new Error('Business operating-hours schedule contains an invalid time.');
+          }
+          const [hours, minutes] = value.split(':').map(Number);
+          return hours * 60 + minutes;
+        };
+        const start = dateAt + toMinutes(window.start_time) * 60_000;
+        let end = dateAt + toMinutes(window.end_time) * 60_000;
+        if (end <= start) end += DAY;
+        if (current.scalar >= start && current.scalar < end) open = true;
+        for (const boundary of [start, end]) {
+          for (const instant of clock.instants(boundary)) {
+            if (instant > nowAt) nextChangeAt = Math.min(nextChangeAt, instant);
+          }
+        }
+      }
+    }
+  }
+  // A timezone offset change can repeat/skip a wall-clock boundary. A local-only safety
+  // check also covers throttled timers; it does not fetch either configuration source.
+  nextChangeAt = Math.min(nextChangeAt, nowAt + 60_000);
+  return {
+    ...base,
+    nextChangeAt,
+    status: open ? 'open' : 'closed',
+    behavior: open ? null : config.closedBehavior,
+    message: open ? null : config.closedMessage
+  };
+}

package/lib/modules/Cart/index.js

@@ -89,7 +89,8 @@ class CartModule extends _BaseModule.BaseModule {
       bundle,
       options,
       date,
-      quantity = 1
+      quantity = 1,
+      isLegacyOrder
     } = params;
     // 生成一个唯一的 ID
     let cartItem = {
@@ -108,7 +109,8 @@ class CartModule extends _BaseModule.BaseModule {
         bundle,
         options,
         product_variant_id: newProduct.product_variant_id,
-        quantity
+        quantity,
+        isLegacyOrder
       });
     }
     if (account) {

package/lib/modules/Cart/types.d.ts

@@ -180,6 +180,8 @@ export interface IAddItemParams {
     };
     /** 商品组合规格ID */
     product_variant_id?: number;
+    /** 是否由旧版下单流程加入购物车 */
+    isLegacyOrder?: boolean;
 }
 /**
  * 更新购物车信息参数

package/lib/modules/Cart/utils/cartProduct.d.ts

@@ -21,6 +21,7 @@ export declare const formatProductToCartItem: (params: {
     product_variant_id?: number;
     quantity?: number;
     discounts?: any[];
+    isLegacyOrder?: boolean;
 }) => CartItem;
 export declare const formatProductToCartItemOrigin: (params: {
     cartItem: CartItem;
@@ -29,6 +30,7 @@ export declare const formatProductToCartItemOrigin: (params: {
     options?: any;
     product_variant_id?: number;
     quantity?: number;
+    isLegacyOrder?: boolean;
 }) => any;
 /**
  * 获取商品总价
@@ -61,7 +63,7 @@ export declare const getProductOriginTotalPrice: (params: {
  * @param options 套餐规格信息
  * @returns 格式化后的套餐规格信息
  */
-export declare const formatOptions: (options: any) => any;
+export declare const formatOptions: (options: any, product?: ProductData) => any;
 export declare const formatOptionsToOrigin: (options: any) => any;
 /**
  * 格式化商品套餐信息

package/lib/modules/Cart/utils/cartProduct.js

@@ -106,7 +106,7 @@ const formatProductToCartItem = params => {
     cartItem.bundle = formatBundle(bundle);
   }
   if (options?.length) {
-    cartItem.options = formatOptions(options);
+    cartItem.options = formatOptions(options, product);
   }
   // 拼装出 product_option_string
   if (product_variant_id) {
@@ -148,22 +148,32 @@ const formatProductToCartItemOrigin = params => {
     bundle,
     options,
     product_variant_id,
-    quantity = 1
+    quantity = 1,
+    isLegacyOrder = false
   } = params;
   let origin = cartItem._origin;
   const product_discount_difference = (origin.product?.discount_list || []).filter(item => !item?.metadata?.custom_product_bundle_map_id).reduce((pre, cur) => {
     return pre + (cur?.metadata?.product_discount_difference || 0);
   }, 0);
   if (product) {
+    const {
+      option: _option,
+      ...legacyProductSku
+    } = origin.product?.product_sku || {};
     origin.product = {
       ...(origin.product || {}),
       num: quantity,
       product_id: product.id,
       product_variant_id: product_variant_id || 0,
       product_bundle: origin.product?.product_bundle || [],
-      product_sku: origin.product?.product_sku || {
-        option: []
-      },
+      ...(isLegacyOrder ? {
+        product_sku: legacyProductSku,
+        product_option_item: origin.product?.product_option_item || []
+      } : {
+        product_sku: origin.product?.product_sku || {
+          option: []
+        }
+      }),
       metadata: {
         product_discount_difference
       }
@@ -176,17 +186,22 @@ const formatProductToCartItemOrigin = params => {
       origin.product.product_bundle = formatBundleToOrigin(bundle);
     }
     if (options?.length) {
-      origin.product.product_sku = {
-        ...(origin.product.product_sku || {}),
-        option: formatOptionsToOrigin(options).map(option => {
-          const next = {
-            ...option,
-            add_price: option.add_price ?? option.price
-          };
-          delete next.price;
-          return next;
-        })
-      };
+      const formattedOptions = formatOptionsToOrigin(options);
+      if (isLegacyOrder) {
+        origin.product.product_option_item = formattedOptions;
+      } else {
+        origin.product.product_sku = {
+          ...(origin.product.product_sku || {}),
+          option: formattedOptions.map(option => {
+            const next = {
+              ...option,
+              add_price: option.add_price ?? option.price
+            };
+            delete next.price;
+            return next;
+          })
+        };
+      }
     }
   }
   return origin;
@@ -299,12 +314,16 @@ const getProductOriginTotalPrice = params => {
  * @returns 格式化后的套餐规格信息
  */
 exports.getProductOriginTotalPrice = getProductOriginTotalPrice;
-const formatOptions = options => {
+const formatOptions = (options, product) => {
   if (!options?.length) return [];
   return options.map(item => {
+    const optionGroupId = item?.option_group_id;
+    const optionItemId = item?.id ?? item?.option_group_item_id ?? item?.product_option_item_id;
+    const optionGroup = product?.option_group?.find(group => String(group?.id) === String(optionGroupId));
+    const optionItem = optionGroup?.option_item?.find(candidate => String(candidate?.id) === String(optionItemId));
     return {
-      id: item?.id,
-      name: item?.name,
+      id: optionItemId,
+      name: item?.name ?? item?.title ?? optionItem?.name ?? optionItem?.title,
       num: item?.num,
       price: item?.price,
       total: item?.price,
@@ -320,7 +339,7 @@ const formatOptionsToOrigin = options => {
   return options.map(d => {
     return {
       num: d.num,
-      option_group_item_id: d.option_group_item_id,
+      option_group_item_id: d?.option_group_item_id || d?.product_option_item_id,
       option_group_id: d.option_group_id
     };
   });

package/lib/modules/FulfillmentTiming/index.d.ts

@@ -0,0 +1,11 @@
+import type { PickupTimingAvailability, PickupTimingBookingTimes, PickupTimingClockInput, PickupTimingComputeInput, PickupTimingConfig, PickupTimingSelection, PickupTimingSlot, PickupTimingValidationResult } from './types';
+export * from './types';
+/** Consume effective OpenData values only; legacy switches never enable Pickup. */
+export declare function normalizePickupTimingConfig(openData: Record<string, unknown>): PickupTimingConfig;
+export declare function resolvePickupTimingDateTime(date: string, time: string, timezone: string, instant?: string): PickupTimingSlot | undefined;
+export declare function getAsapPickupTiming({ config, timezone, now }: PickupTimingClockInput): PickupTimingSlot;
+export declare function pickupTimingSlotToBookingTimes(slot: PickupTimingSlot): PickupTimingBookingTimes;
+export declare function computePickupTimingAvailability(input: PickupTimingComputeInput): PickupTimingAvailability;
+export declare function validatePickupTimingSelection(selection: PickupTimingSelection, input: PickupTimingComputeInput & {
+    allowManualOverride?: boolean;
+}): PickupTimingValidationResult;