@pisell/pisellos 2.2.313 → 2.2.315

package/lib/modules/ResourcePlanner/planner.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.createAvailabilityProjection = createAvailabilityProjection;
+exports.getDurationBusinessDate = getDurationBusinessDate;
 exports.getProductTimeRanges = getProductTimeRanges;
 exports.queryAvailabilityProjection = queryAvailabilityProjection;
 exports.validateAvailabilitySelection = validateAvailabilitySelection;
@@ -162,7 +163,11 @@ function resolveCutOffPolicyIssue(policy) {
   return null;
 }
 function addLeadWindow(base, unit, unitType, _timezoneName) {
-  if (unitType === 'days') return (0, _localClock.addLocalCalendarDays)(base, unit);
+  if (unitType === 'days') {
+    const leadDate = (0, _localClock.addLocalCalendarDays)(base, unit);
+    // Positive day lead times start at midnight; zero days keeps the current-time boundary.
+    return Math.trunc(unit) > 0 ? (0, _localClock.localDateToScalarStart)((0, _localClock.formatLocalDate)(leadDate)) : leadDate;
+  }
   if (unitType === 'hours') return (0, _localClock.addLocalHours)(base, unit);
   return (0, _localClock.addLocalMinutes)(base, unit);
 }
@@ -250,6 +255,18 @@ function evaluateCandidateTimeGate(params) {
     };
   }
   const policy = product.cutOffPolicy;
+  // Current duration items can be shown outside business hours. Their real
+  // interval must remain unavailable, including products with no resource groups.
+  if (evaluationContext.useDurationTimeGrid && product.kind === 'duration' && !projection.meta.defaults.operatingHours.windows.some(window => {
+    const range = normalizeAbsoluteRange(window);
+    return range && contains(range, candidateRange);
+  })) {
+    return {
+      status: 'unavailable',
+      reasonCodes: ['outside_operating_hours'],
+      conflictCode: 'booking_cutoff'
+    };
+  }
   if (!policy) return null;
   if (resolveCutOffPolicyIssue(policy)) {
     return {
@@ -286,8 +303,8 @@ function evaluateCandidateTimeGate(params) {
     // otherwise a minute refresh turns it into 0 capacity and incorrectly
     // advances a create flow to the next slot. The earlier `past` gate still
     // rejects the anchor once its booking range has ended.
-    const isActivePosDurationAnchor = evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration' && !product.isFlexibleDuration && evaluationContext.durationCandidateAnchorAtMs === candidateRange.start;
-    const usesMinutePrecision = product.isFlexibleDuration || evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration';
+    const isActivePosDurationAnchor = evaluationContext.useExactDurationCandidateMinute && !evaluationContext.enforceSaleCutoff && product.kind === 'duration' && !product.isFlexibleDuration && evaluationContext.durationCandidateAnchorAtMs === candidateRange.start;
+    const usesMinutePrecision = product.isFlexibleDuration || evaluationContext.useDurationTimeGrid || evaluationContext.useExactDurationCandidateMinute && product.kind === 'duration';
     const hasNotReachedStart = isActivePosDurationAnchor || (usesMinutePrecision ? floorToMinute(now) <= candidateRange.start : now < candidateRange.start);
     if (hasNotReachedStart) return null;
     return {
@@ -489,11 +506,34 @@ function normalizeOperatingHours(params) {
   }));
   const windows = normalizeWindows(sourceWindows);
   const excludedWindows = normalizeWindows(params.input?.excludedWindows || []);
+  // Keep original dates and opening anchors separately: the availability
+  // windows below may be clipped at midnight or merged without segment identity.
+  const periodMap = new Map();
+  const originalPeriods = params.input?.businessPeriods || [...sourceWindows, ...(params.input?.excludedWindows || [])].map(window => ({
+    businessDate: window.businessDate || window.startAt.slice(0, 10),
+    startAt: window.openingAnchorAt || window.startAt,
+    endAt: window.endAt
+  }));
+  originalPeriods.forEach(period => {
+    const range = normalizeAbsoluteRange(period);
+    if (!range) return;
+    const previous = periodMap.get(period.businessDate);
+    periodMap.set(period.businessDate, {
+      start: previous ? Math.min(previous.start, range.start) : range.start,
+      end: previous ? Math.max(previous.end, range.end) : range.end
+    });
+  });
+  const businessPeriods = Array.from(periodMap, ([businessDate, range]) => ({
+    businessDate,
+    startAt: formatDateTime(range.start, params.timezoneName, params.fixedOffsetMinutes),
+    endAt: formatDateTime(range.end, params.timezoneName, params.fixedOffsetMinutes)
+  })).sort((left, right) => left.startAt.localeCompare(right.startAt));
   return {
     source: params.input?.source || params.fallbackSource,
     scheduleIds: uniqById(params.input?.scheduleIds || []),
     missingScheduleIds: uniqById(params.input?.missingScheduleIds || []),
     windows,
+    businessPeriods,
     ...(excludedWindows.length > 0 ? {
       excludedWindows
     } : {})
@@ -992,6 +1032,162 @@ function createDurationTimeRangeWithEnd(product, start, bookingEnd, projection,
     scheduleRefs: []
   };
 }
+
+/** Resolve the label without changing the real calendar timestamp. */
+function getDurationBusinessDate(projection, startAt) {
+  const start = toDateTime(startAt);
+  const periods = projection.meta.defaults.operatingHours.businessPeriods || [];
+  const period = [...periods].reverse().find(item => {
+    const range = normalizeAbsoluteRange(item);
+    return range && range.start <= start && start < range.end;
+  });
+  return period?.businessDate || startAt.slice(0, 10);
+}
+function getAlignedDurationRanges(params) {
+  const {
+    projection,
+    product,
+    request,
+    runtimeOptions,
+    dateRange,
+    operatingRanges,
+    baseRanges,
+    resourceWindowIndex,
+    fixedOffsetMinutes
+  } = params;
+  const step = projection.meta.defaults.slotStepMinutes;
+  const now = floorToMinute(toDateTime(runtimeOptions.evaluatedAt || projection.meta.durationCandidateAnchorAt));
+  if (!Number.isFinite(now)) throw availabilityError('INVALID_TARGET_FILTER', 'evaluatedAt 必须是有效时间');
+  const nowAt = formatDateTime(now, projection.meta.timezone, fixedOffsetMinutes);
+  const currentBusinessDate = getDurationBusinessDate(projection, nowAt);
+  const inRequestedDays = date => date >= dateRange.startDate && date <= dateRange.endDate;
+  const periods = (projection.meta.defaults.operatingHours.businessPeriods || []).filter(period => inRequestedDays(period.businessDate));
+  // A prepared month includes tomorrow's windows too; the single-day UI must
+  // receive the selected business cycle's end, not tomorrow's closing time.
+  const operatingEndAt = dateRange.startDate === dateRange.endDate && periods.length ? periods.reduce((latest, period) => period.endAt > latest ? period.endAt : latest, periods[0].endAt) : undefined;
+  const ranges = [];
+  const duration = resolveRequestedDurationMinutes(product, request);
+  const addRange = (start, end, businessDate) => {
+    if (end <= start) return;
+    const candidate = createDurationTimeRangeWithEnd(product, start, end, projection, fixedOffsetMinutes);
+    candidate.businessDate = businessDate || getDurationBusinessDate(projection, candidate.startAt);
+    if (inRequestedDays(candidate.businessDate)) ranges.push(candidate);
+  };
+  // A flexible end comes from resources that actually cover this exact start,
+  // never from the next future window. Keep alternative real ends separate.
+  const flexibleEnds = start => {
+    const operating = operatingRanges.find(range => range.start <= start && start < range.end);
+    if (!operating) return [];
+    const businessDate = getDurationBusinessDate(projection, formatDateTime(start, projection.meta.timezone, fixedOffsetMinutes));
+    const period = projection.meta.defaults.operatingHours.businessPeriods?.find(item => item.businessDate === businessDate);
+    const operatingEnd = Math.min(operating.end, period ? toDateTime(period.endAt) : operating.end);
+    const requiredGroups = (product.requirementGroups || []).filter(group => group.required !== false);
+    const groups = requiredGroups.map(group => projection.resources.filter(resource => matchesRequirementGroup(group, resource, product, request.partySize)).filter(resource => !request.resourceIds?.length || request.resourceIds.some(id => sameId(id, resource.id))).flatMap(resource => (resourceWindowIndex.get(String(resource.id)) || []).filter(range => range.start <= start && start < range.end).map(range => Math.min(range.end, operatingEnd))));
+    if (groups.some(ends => ends.length === 0)) return [];
+    if (!groups.length) return [operatingEnd];
+    return Array.from(new Set(groups.flat())).filter(end => groups.every(ends => ends.some(availableEnd => availableEnd >= end))).sort((left, right) => left - right);
+  };
+  if (product.isFlexibleDuration) {
+    // Preserve the existing continuous-window UI, with the business-day label.
+    periods.forEach(period => {
+      const periodRange = normalizeAbsoluteRange(period);
+      baseRanges.forEach(range => {
+        const start = Math.max(range.start, periodRange.start, now);
+        const end = Math.min(range.end, periodRange.end);
+        if (start < end) addRange(start, end, period.businessDate);
+      });
+    });
+  } else {
+    periods.forEach(period => {
+      const periodRange = normalizeAbsoluteRange(period);
+      const anchor = 60 % step === 0 ? toDateStart(period.businessDate) : periodRange.start;
+      baseRanges.forEach(range => {
+        const lower = Math.max(range.start, periodRange.start, now);
+        const upper = Math.min(range.end, periodRange.end);
+        let cursor = anchor + Math.ceil((lower - anchor) / (step * 60000)) * step * 60000;
+        for (; cursor + duration * 60000 <= upper; cursor += step * 60000) {
+          addRange(cursor, cursor + duration * 60000, period.businessDate);
+        }
+      });
+    });
+  }
+  let unavailableCurrentTime;
+  if (inRequestedDays(currentBusinessDate)) {
+    if (product.isFlexibleDuration) {
+      const ends = flexibleEnds(now);
+      ends.forEach(end => addRange(now, end, currentBusinessDate));
+      if (!ends.length) {
+        unavailableCurrentTime = {
+          productId: product.id,
+          startAt: nowAt,
+          date: formatDate(now),
+          businessDate: currentBusinessDate,
+          startTime: formatTime(now),
+          status: 'unavailable',
+          reasonCodes: [operatingRanges.some(range => range.start <= now && now < range.end) ? 'outside_resource_window' : 'outside_operating_hours']
+        };
+      }
+    } else {
+      // Even outside a working window the fixed product has a real end. Query
+      // reports unavailable; POS manual capabilities remain a separate policy.
+      addRange(now, now + duration * 60000, currentBusinessDate);
+    }
+  }
+  const rememberedAt = request.rememberedStartAtByProductId?.[String(product.id)];
+  if (rememberedAt !== undefined) {
+    const start = toDateTime(rememberedAt);
+    if (!Number.isFinite(start)) throw availabilityError('INVALID_TARGET_FILTER', '记忆开始时间必须是完整日期时间');
+    if (product.isFlexibleDuration) {
+      flexibleEnds(start).forEach(end => addRange(start, end));
+    } else {
+      addRange(start, start + duration * 60000);
+    }
+  }
+  const editingAt = request.editingStartAtByProductId?.[String(product.id)];
+  if (editingAt !== undefined) {
+    const start = toDateTime(editingAt);
+    const editingDuration = Number(request.durationMinutesByProductId?.[String(product.id)]);
+    if (!Number.isFinite(start) || !Number.isInteger(editingDuration) || editingDuration <= 0) {
+      throw availabilityError('INVALID_TARGET_FILTER', '编辑时间必须包含完整开始日期时间和明确的正整数时长');
+    }
+    // Editing restores the original interval, including its actual overnight
+    // date. It neither adopts the current grid nor recomputes a flexible end.
+    if (request.allowOutsideOperatingHoursForRequestedStartTimes || operatingRanges.some(range => range.start <= start && start < range.end)) {
+      addRange(start, addMinutesZoned(start, editingDuration, projection.meta.timezone));
+    }
+  }
+
+  // Explicit custom input keeps its existing start + requested duration
+  // semantics. Remembered input above must never use this default-30 path.
+  if (dateRange.startDate === dateRange.endDate) {
+    resolveRequestedDurationStartTimes(product, request).forEach(startTime => {
+      const sameDayStart = toDateTimeInDate(dateRange.startDate, startTime);
+      const period = periods.find(item => item.businessDate === dateRange.startDate);
+      const periodRange = period ? normalizeAbsoluteRange(period) : null;
+      const nextDayStart = (0, _localClock.addLocalCalendarDays)(sameDayStart, 1);
+      // HH:mm is entered within a selected business day, whose early hours
+      // may belong to the next calendar day. Do not move other out-of-hours
+      // manual input to tomorrow merely because the business closes overnight.
+      const start = periodRange && !(periodRange.start <= sameDayStart && sameDayStart < periodRange.end) && periodRange.start <= nextDayStart && nextDayStart < periodRange.end ? nextDayStart : sameDayStart;
+      if (request.allowOutsideOperatingHoursForRequestedStartTimes || operatingRanges.some(range => range.start <= start && start < range.end)) {
+        addRange(start, start + duration * 60000);
+      }
+    });
+  }
+  return {
+    productId: product.id,
+    title: product.title,
+    kind: product.kind,
+    slotStepMinutes: step,
+    ...(operatingEndAt ? {
+      operatingEndAt
+    } : {}),
+    ranges: dedupeProductRanges(ranges),
+    ...(unavailableCurrentTime ? {
+      unavailableCurrentTime
+    } : {})
+  };
+}
 function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
   const normalizedPartySize = normalizePartySize(request.partySize);
   const dateRange = resolveProjectionDateRange(projection, request.dateRange);
@@ -1044,6 +1240,19 @@ function getProductTimeRanges(projection, request = {}, runtimeOptions = {}) {
       includeExcludedWindows: allowExcludedScheduleDateOverride
     })).reduce((current, ranges) => current === null ? ranges : intersectRangeLists(current, ranges), null) || [] : null;
     const baseRanges = resourceRanges === null ? operatingRanges : intersectRangeLists(resourceRanges, operatingRanges);
+    if (runtimeOptions.useDurationTimeGrid) {
+      return getAlignedDurationRanges({
+        projection,
+        product,
+        request,
+        runtimeOptions,
+        dateRange,
+        operatingRanges,
+        baseRanges,
+        resourceWindowIndex,
+        fixedOffsetMinutes
+      });
+    }
     const durationMinutes = resolveRequestedDurationMinutes(product, request);
     const flexibleStartAt = (() => {
       if (!product.isFlexibleDuration) return undefined;
@@ -1265,7 +1474,9 @@ function buildEvaluationContext(params) {
     selectionsByGroupKey,
     useExactDurationCandidateMinute: params.useExactDurationCandidateMinute === true,
     durationCandidateAnchorAtMs: Number.isFinite(durationCandidateAnchorAt) ? floorToMinute(durationCandidateAnchorAt) : null,
-    allowExcludedScheduleDateOverride: params.allowExcludedScheduleDateOverride === true
+    allowExcludedScheduleDateOverride: params.allowExcludedScheduleDateOverride === true,
+    useDurationTimeGrid: params.useDurationTimeGrid === true,
+    enforceSaleCutoff: params.enforceSaleCutoff === true
   };
 }
 function summarizeStatuses(statuses) {
@@ -1672,6 +1883,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
     projection,
     evaluatedAt,
     resourceIds: request.resourceIds,
+    useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+    enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
     useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
     allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
   });
@@ -1748,6 +1961,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
     partySize: normalizedPartySize
   }, {
     evaluatedAt,
+    useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+    enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
     useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
     allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
   });
@@ -1772,7 +1987,8 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
           candidateRangeCache,
           evaluationContext
         });
-        const aggregate = byDate.get(candidate.date) || {
+        const candidateDate = runtimeOptions.useDurationTimeGrid ? candidate.businessDate || candidate.date : candidate.date;
+        const aggregate = byDate.get(candidateDate) || {
           availableCount: 0,
           totalCount: 0,
           maxPartySize: 0,
@@ -1790,8 +2006,24 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
         aggregate.maxCapacity += evaluated.maxCapacity;
         pushStatusAggregate(aggregate.statusAggregate, evaluated.status);
         evaluated.reasonCodes.forEach(reasonCode => aggregate.reasonCodeSet.add(reasonCode));
-        byDate.set(candidate.date, aggregate);
+        byDate.set(candidateDate, aggregate);
       });
+      if (group.unavailableCurrentTime) {
+        const current = group.unavailableCurrentTime;
+        const aggregate = byDate.get(current.businessDate) || {
+          availableCount: 0,
+          totalCount: 0,
+          maxPartySize: 0,
+          remainingCapacity: 0,
+          maxCapacity: 0,
+          reasonCodeSet: new Set(),
+          statusAggregate: createStatusAggregate()
+        };
+        aggregate.totalCount += 1;
+        pushStatusAggregate(aggregate.statusAggregate, 'unavailable');
+        current.reasonCodes.forEach(reason => aggregate.reasonCodeSet.add(reason));
+        byDate.set(current.businessDate, aggregate);
+      }
       const dates = enumerateDates(dateRange.startDate, dateRange.endDate).map(date => {
         const aggregate = byDate.get(date);
         return {
@@ -1849,10 +2081,20 @@ function queryAvailabilityProjection(projection, request, runtimeOptions = {}) {
       maxPartySize = Math.max(maxPartySize, evaluated.maxPartySize);
       pushStatusAggregate(productStatusAggregate, evaluated.status);
       evaluated.reasonCodes.forEach(reasonCode => productReasonCodeSet.add(reasonCode));
-      const dateAggregate = dateStatusMap.get(candidate.date) || createStatusAggregate();
+      const candidateDate = runtimeOptions.useDurationTimeGrid ? candidate.businessDate || candidate.date : candidate.date;
+      const dateAggregate = dateStatusMap.get(candidateDate) || createStatusAggregate();
       pushStatusAggregate(dateAggregate, evaluated.status);
-      dateStatusMap.set(candidate.date, dateAggregate);
+      dateStatusMap.set(candidateDate, dateAggregate);
     });
+    if (group.unavailableCurrentTime) {
+      const current = group.unavailableCurrentTime;
+      totalTimeCount += 1;
+      pushStatusAggregate(productStatusAggregate, 'unavailable');
+      current.reasonCodes.forEach(reason => productReasonCodeSet.add(reason));
+      const dateAggregate = dateStatusMap.get(current.businessDate) || createStatusAggregate();
+      pushStatusAggregate(dateAggregate, 'unavailable');
+      dateStatusMap.set(current.businessDate, dateAggregate);
+    }
     const availableDateCount = Array.from(dateStatusMap.values()).filter(aggregate => {
       const status = summarizeStatusAggregate(aggregate);
       return status === 'available' || status === 'limited';
@@ -1921,6 +2163,8 @@ function validateAvailabilitySelection(projection, params, runtimeOptions = {})
       projection,
       evaluatedAt,
       requirementSelections: params.requirementSelections,
+      useDurationTimeGrid: runtimeOptions.useDurationTimeGrid,
+      enforceSaleCutoff: runtimeOptions.enforceSaleCutoff,
       useExactDurationCandidateMinute: runtimeOptions.useExactDurationCandidateMinute,
       allowExcludedScheduleDateOverride: runtimeOptions.allowExcludedScheduleDateOverride
     })

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

@@ -92,6 +92,9 @@ export interface AvailabilityProduct {
     raw?: Record<string, any>;
 }
 export interface AvailabilityResourceWindow extends AvailabilityAbsoluteRange {
+    /** Original business day and opening anchor, before coverage clipping. */
+    businessDate?: string;
+    openingAnchorAt?: string;
     source?: string;
     raw?: Record<string, any>;
 }
@@ -101,10 +104,15 @@ export interface AvailabilityOperatingHoursSnapshot {
     scheduleIds: AvailabilityId[];
     missingScheduleIds: AvailabilityId[];
     windows: AvailabilityResourceWindow[];
+    /** Complete business cycles; lunch gaps remain in windows, not in this envelope. */
+    businessPeriods?: AvailabilityBusinessPeriod[];
     /** Schedule windows omitted only because their date is excluded. POS may use
      * these to surface an unavailable, manually selectable candidate. */
     excludedWindows?: AvailabilityResourceWindow[];
 }
+export interface AvailabilityBusinessPeriod extends AvailabilityAbsoluteRange {
+    businessDate: string;
+}
 export interface AvailabilityResource {
     id: AvailabilityId;
     formId?: AvailabilityId;
@@ -212,6 +220,17 @@ export interface ProductTimeRange extends AvailabilityDisplayRange {
     bookingEndAt: string;
     scheduleRefs: AvailabilityScheduleRef[];
     primaryScheduleRef?: AvailabilityScheduleRef;
+    /** Business-day label. date/startAt keep the actual calendar date. */
+    businessDate?: string;
+}
+export interface UnavailableCurrentTime {
+    productId: AvailabilityId;
+    startAt: string;
+    date: string;
+    businessDate: string;
+    startTime: string;
+    status: 'unavailable';
+    reasonCodes: string[];
 }
 export interface ProductTimeRangeGroup {
     productId: AvailabilityId;
@@ -221,6 +240,8 @@ export interface ProductTimeRangeGroup {
     /** 单日查询对应营业窗口的最终结束时刻，不受资源排班是否为空影响。 */
     operatingEndAt?: string;
     ranges: ProductTimeRange[];
+    /** A display-only current item when flexible duration has no valid end. Never submit it. */
+    unavailableCurrentTime?: UnavailableCurrentTime;
 }
 export interface AvailabilityAssignment extends AvailabilityAbsoluteRange {
     productId: AvailabilityId;
@@ -242,6 +263,10 @@ export interface GetProductTimeRangesRequest {
     partySize?: number;
     durationMinutesByProductId?: Record<string, number>;
     durationStartTimesByProductId?: Record<string, string[]>;
+    /** Restore only the exact remembered start; recompute the end from current product/windows. */
+    rememberedStartAtByProductId?: Record<string, string>;
+    /** Edit only: preserve the full actual start plus an explicit durationMinutesByProductId. */
+    editingStartAtByProductId?: Record<string, string>;
     /**
      * POS 手工输入时间的兼容开关：只为明确请求的 start time 补候选，
      * 不改变常规候选列表仍按营业时间生成的规则。
@@ -250,6 +275,10 @@ export interface GetProductTimeRangesRequest {
 }
 export interface GetProductTimeRangesRuntimeOptions {
     evaluatedAt?: string;
+    /** Enabled by the POS/Kiosk facade only; other consumers retain their existing grid. */
+    useDurationTimeGrid?: boolean;
+    /** Automatic remembered selection must not use POS opening-minute cutoff exceptions. */
+    enforceSaleCutoff?: boolean;
     /**
      * Internal POS capability: fixed-duration candidates start from the stable
      * context anchor's current minute instead of rounding up to ten minutes, and

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

@@ -10,6 +10,10 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
     private openCache;
     private fatherModule;
     private hasLoadedScheduleList;
+    private scheduleListPromise;
+    private scheduleListRequestVersion;
+    private scheduleCatalogScope;
+    private otherParams;
     constructor(name?: string, version?: string);
     initialize(core: PisellCore, options: ModuleOptions): Promise<void>;
     /**
@@ -19,6 +23,9 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
      * scheduleModule.updateOtherParams({ openCache: true, cacheId: 'cache-2' });
      */
     updateOtherParams(params: Record<string, any>): void;
+    private syncScheduleCatalogScope;
+    private resetScheduleCatalog;
+    destroy(): void;
     /**
      * 加载当前店铺下所有 schedule
      *
@@ -27,6 +34,7 @@ export declare class ScheduleModule extends BaseModule implements Module, Schedu
     loadAllSchedule(options?: {
         useCache?: boolean;
     }): Promise<void>;
+    private loadScheduleCatalog;
     setScheduleList(list: ScheduleItem[]): void;
     private syncScheduleMap;
     getScheduleList(): ScheduleItem[];

package/lib/modules/Schedule/index.js

@@ -24,10 +24,18 @@ class ScheduleModule extends _BaseModule.BaseModule {
   openCache = false;
   fatherModule;
   hasLoadedScheduleList = false;
+  scheduleListPromise = null;
+  scheduleListRequestVersion = 0;
+  scheduleCatalogScope = '';
+  otherParams = {};
   constructor(name, version) {
     super(name, version);
   }
   async initialize(core, options) {
+    // The store proxies initialState, so capture its input before resets write through it.
+    const initialScheduleList = options.initialState?.scheduleList;
+    const hasInitialScheduleList = Array.isArray(initialScheduleList);
+    this.resetScheduleCatalog();
     this.core = core;
 
     // 获取依赖的插件
@@ -40,24 +48,18 @@ class ScheduleModule extends _BaseModule.BaseModule {
     //   this.state = { ...this.state, ...options.initialState }
     // }
     this.store = options?.store;
+    this.updateOtherParams(options.otherParams || {});
     if (options.initialState) {
-      this.store.scheduleList = options.initialState.scheduleList;
+      this.store.scheduleList = hasInitialScheduleList ? initialScheduleList : [];
       this.syncScheduleMap();
       this.store.availabilityDateList = options.initialState.availabilityDateList;
-      this.hasLoadedScheduleList = Array.isArray(options.initialState.scheduleList);
+      this.hasLoadedScheduleList = hasInitialScheduleList;
     } else {
       this.store.scheduleList = [];
       this.store.map = new Map();
       this.store.availabilityDateList = [];
       this.hasLoadedScheduleList = false;
     }
-    if (options.otherParams?.cacheId) {
-      this.openCache = options.otherParams.openCache;
-      this.cacheId = options.otherParams.cacheId;
-    }
-    if (options.otherParams?.fatherModule) {
-      this.fatherModule = options.otherParams.fatherModule;
-    }
   }
 
   /**
@@ -68,9 +70,34 @@ class ScheduleModule extends _BaseModule.BaseModule {
    */
   updateOtherParams(params) {
     const otherParams = params || {};
+    this.otherParams = {
+      ...otherParams
+    };
     this.openCache = otherParams.openCache ?? false;
     this.cacheId = otherParams.cacheId;
     this.fatherModule = otherParams.fatherModule;
+    this.syncScheduleCatalogScope();
+  }
+  syncScheduleCatalogScope() {
+    const context = this.core?.context;
+    const shopId = typeof context?.getData === 'function' ? context.getData('shop_id') : context?.shop_id;
+    const params = this.otherParams;
+    const scope = JSON.stringify([this.cacheId, this.fatherModule, params.businessCode ?? params.business_code, params.channel, params.platform, params.businessTimezone, shopId].map(value => String(value ?? '').trim()));
+    if (scope !== this.scheduleCatalogScope) {
+      this.resetScheduleCatalog();
+      this.scheduleCatalogScope = scope;
+    }
+  }
+  resetScheduleCatalog() {
+    this.scheduleListRequestVersion += 1;
+    this.scheduleListPromise = null;
+    this.hasLoadedScheduleList = false;
+    this.store.scheduleList = [];
+    this.store.map = new Map();
+  }
+  destroy() {
+    this.resetScheduleCatalog();
+    super.destroy();
   }
 
   /**
@@ -79,14 +106,40 @@ class ScheduleModule extends _BaseModule.BaseModule {
    * @memberof ScheduleModule
    */
   async loadAllSchedule(options = {}) {
-    const scheduleList = await this.request.get(`/schedule`, {
+    this.syncScheduleCatalogScope();
+    const useCache = options.useCache ?? true;
+    if (useCache) {
+      if (this.scheduleListPromise) return this.scheduleListPromise;
+      if (this.hasLoadedScheduleList) return;
+    }
+    const requestVersion = ++this.scheduleListRequestVersion;
+    const promise = this.loadScheduleCatalog(useCache, requestVersion);
+    this.scheduleListPromise = promise;
+    try {
+      await promise;
+    } finally {
+      if (this.scheduleListPromise === promise) {
+        this.scheduleListPromise = null;
+      }
+    }
+  }
+  async loadScheduleCatalog(useCache, requestVersion) {
+    const response = await this.request.get(`/schedule`, {
       num: 999
     }, {
-      useCache: options.useCache ?? true
+      useCache
     });
-    this.setScheduleList(scheduleList.data?.list || []);
+    if (response.code !== undefined && Number(response.code) !== 200 || response.status === false || typeof response.status === 'number' && response.status >= 400 || response.success === false) {
+      throw new Error(response.message || 'Schedule catalog request failed');
+    }
+    this.syncScheduleCatalogScope();
+    // A refresh or a different runtime may have superseded this request.
+    if (requestVersion === this.scheduleListRequestVersion) {
+      this.setScheduleList(response.data?.list || []);
+    }
   }
   setScheduleList(list) {
+    this.syncScheduleCatalogScope();
     this.store.scheduleList = list;
     this.syncScheduleMap();
     this.hasLoadedScheduleList = true;
@@ -95,9 +148,11 @@ class ScheduleModule extends _BaseModule.BaseModule {
     this.store.map = new Map((this.store.scheduleList || []).map(schedule => [Number(schedule.id), schedule]));
   }
   getScheduleList() {
+    this.syncScheduleCatalogScope();
     return this.store.scheduleList || [];
   }
   isScheduleListLoaded() {
+    this.syncScheduleCatalogScope();
     return this.hasLoadedScheduleList;
   }
   async loadScheduleAvailableDate({
@@ -149,6 +204,7 @@ class ScheduleModule extends _BaseModule.BaseModule {
     return dates;
   }
   getScheduleListByIds(ids) {
+    this.syncScheduleCatalogScope();
     const idSet = new Set(ids.map(id => String(id)));
     if (this.store.map instanceof Map && this.store.map.size > 0) {
       return ids.map(id => this.store.map.get(Number(id))).filter(Boolean);

package/lib/modules/index.d.ts

@@ -17,6 +17,7 @@ export * from './Schedule';
 export * from './Quotation';
 export * from './ScanOrderLogger';
 export * from './OpenData';
+export * from './FulfillmentTiming';
 export * from './BookingContext';
 export * from './Holder';
 export * from './ResourcePlanner';

package/lib/modules/index.js

@@ -212,6 +212,17 @@ Object.keys(_OpenData).forEach(function (key) {
     }
   });
 });
+var _FulfillmentTiming = require("./FulfillmentTiming");
+Object.keys(_FulfillmentTiming).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _FulfillmentTiming[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _FulfillmentTiming[key];
+    }
+  });
+});
 var _BookingContext = require("./BookingContext");
 Object.keys(_BookingContext).forEach(function (key) {
   if (key === "default" || key === "__esModule") return;

package/lib/plugins/request.d.ts

@@ -56,6 +56,13 @@ export interface CacheProps {
  * 请求配置
  */
 export interface RequestOptions {
+    /** Customer-only, credential-free GET /open/document/{id} on picoding. */
+    publicInvoiceDocument?: boolean;
+    /** Route through the host's configured picoding environment. */
+    pisell2?: boolean;
+    /** Let the caller handle read-only preview failures without host navigation/toasts. */
+    manualErrorHandling?: boolean;
+    skipErrorHandler?: boolean;
     url?: string;
     method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
     headers?: Record<string, string>;

package/lib/server/index.d.ts

@@ -499,6 +499,7 @@ declare class Server {
     private buildLocalPaymentSurchargeUpdate;
     private handleGetLocalPayment;
     private handleUpdateLocalPayment;
+    private handleFinalizeLocalEftposPayment;
     private runLocalPaymentUpdateInQueue;
     private processLocalPaymentUpdate;
     private processSuccessfulLocalPayment;