@pisell/pisellos 2.3.53 → 2.3.55

package/lib/solution/UnifiedBookingSales/index.js

@@ -0,0 +1,1085 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/solution/UnifiedBookingSales/index.ts
+var UnifiedBookingSales_exports = {};
+__export(UnifiedBookingSales_exports, {
+  UnifiedBookingSales: () => UnifiedBookingSales,
+  UnifiedBookingSalesImpl: () => UnifiedBookingSalesImpl,
+  buildBookingFromAssignment: () => buildBookingFromAssignment,
+  buildBookingFromAssignments: () => buildBookingFromAssignments,
+  buildPlannerDiscountResult: () => buildPlannerDiscountResult,
+  buildPlannerLineIdentity: () => buildPlannerLineIdentity,
+  buildPlannerResourcesFromV2: () => buildPlannerResourcesFromV2,
+  collectPlannerResourceIds: () => collectPlannerResourceIds,
+  normalizeProductForPlanner: () => normalizeProductForPlanner
+});
+module.exports = __toCommonJS(UnifiedBookingSales_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var import_modules = require("../../modules");
+var import_getDateIsInSchedule = require("../../modules/Schedule/getDateIsInSchedule");
+var import_types = require("./types");
+var import_BookingTicket = require("../BookingTicket");
+__reExport(UnifiedBookingSales_exports, require("./types"), module.exports);
+var OPEN_DATA_SECTION_CODES = ["sale", "reservation", "fulfillment", "menu", "workflow"];
+var OPEN_DATA_CACHE_TTL = 5 * 60 * 1e3;
+function pickLocalizedText(value) {
+  if (!value)
+    return void 0;
+  if (typeof value === "string")
+    return value;
+  if (typeof value === "object") {
+    return value.en || value.zh || value.default || Object.values(value)[0];
+  }
+  return String(value);
+}
+function resolvePlannerDiscountId(discount) {
+  var _a;
+  return ((_a = discount.discount) == null ? void 0 : _a.resource_id) ?? discount.resource_id ?? discount.id;
+}
+function resolvePlannerDiscountTitle(discount) {
+  var _a;
+  return pickLocalizedText(
+    discount.name || discount.format_title || ((_a = discount.discount) == null ? void 0 : _a.title) || discount.title
+  );
+}
+function isPlannerDiscountAvailable(discount) {
+  var _a;
+  return discount.isDisabled !== true && discount.isAvailable !== false && ((_a = discount.config) == null ? void 0 : _a.isAvailable) !== false;
+}
+function buildPlannerDiscountResult(params) {
+  const {
+    customerId,
+    discountList,
+    products,
+    summaryBefore,
+    summaryAfter,
+    status,
+    preferredDiscountId,
+    preferredDiscountFound
+  } = params;
+  const items = (discountList || []).reduce((result, discount) => {
+    const id = resolvePlannerDiscountId(discount);
+    if (id !== void 0 && id !== null) {
+      result.push({
+        id,
+        name: resolvePlannerDiscountTitle(discount),
+        type: discount.tag || discount.type,
+        available: isPlannerDiscountAvailable(discount),
+        selected: discount.isSelected === true,
+        savedAmount: Number(discount.savedAmount || 0) || void 0,
+        unavailableReason: discount.unavailableReason || discount.reason
+      });
+    }
+    return result;
+  }, []);
+  const discountNameById = new Map(items.map((item) => [String(item.id), item.name]));
+  const applications = [];
+  (products || []).forEach((product) => {
+    const productDiscounts = [
+      ...Array.isArray(product.discount_list) ? product.discount_list : [],
+      ...Array.isArray(product.product_bundle) ? product.product_bundle.flatMap((bundle) => (bundle == null ? void 0 : bundle.discount_list) || []) : []
+    ];
+    productDiscounts.forEach((discount) => {
+      var _a;
+      const type = discount.tag || discount.type;
+      if (!["good_pass", "discount_card", "product_discount_card"].includes(type))
+        return;
+      const discountId = resolvePlannerDiscountId(discount);
+      applications.push({
+        discountId,
+        discountName: discountId === void 0 ? void 0 : discountNameById.get(String(discountId)),
+        discountType: type,
+        productId: product.product_id ?? product.id,
+        productTitle: pickLocalizedText(product.title || product.name || product.product_title),
+        productUid: ((_a = product.metadata) == null ? void 0 : _a.unique_identification_number) || product.unique_identification_number,
+        amount: Number(discount.amount || 0)
+      });
+    });
+  });
+  return {
+    status,
+    customerId,
+    preferredDiscountFound,
+    preferredDiscountApplied: preferredDiscountId === void 0 || preferredDiscountId === null ? void 0 : items.some((item) => String(item.id) === String(preferredDiscountId) && item.selected) && applications.some((item) => String(item.discountId) === String(preferredDiscountId)),
+    availableDiscounts: items.filter((item) => item.available),
+    selectedDiscounts: items.filter((item) => item.selected),
+    applications,
+    summaryBefore,
+    summaryAfter
+  };
+}
+function toNumberId(value) {
+  if (value === void 0 || value === null || value === "")
+    return void 0;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : String(value);
+}
+function resolveProductKind(product) {
+  var _a, _b, _c;
+  if (product.duration)
+    return "duration";
+  if (["session_product", "session_ticket"].includes(product.extension_type))
+    return "session";
+  if (((_a = product.cartDetailValue) == null ? void 0 : _a.session) || ((_c = (_b = product._extend) == null ? void 0 : _b.other) == null ? void 0 : _c.session))
+    return "session";
+  if (Array.isArray(product["schedule.ids"]) && product["schedule.ids"].length > 0)
+    return "session";
+  return "normal";
+}
+function normalizeSchedule(product) {
+  var _a, _b, _c;
+  const session = ((_a = product.cartDetailValue) == null ? void 0 : _a.session) || ((_c = (_b = product._extend) == null ? void 0 : _b.other) == null ? void 0 : _c.session) || product.session;
+  if ((session == null ? void 0 : session.start_at) && (session == null ? void 0 : session.end_at)) {
+    return [{ start_at: session.start_at, end_at: session.end_at }];
+  }
+  const schedules = product.schedules || product.schedule || product._schedule;
+  if (Array.isArray(schedules)) {
+    return schedules.map((item) => ({
+      start_at: item.start_at || item.start || item.start_time,
+      end_at: item.end_at || item.end || item.end_time
+    })).filter((item) => item.start_at && item.end_at);
+  }
+  return [];
+}
+function normalizeRequirements(product) {
+  var _a;
+  const resources = (_a = product.product_resource) == null ? void 0 : _a.resources;
+  if (!Array.isArray(resources))
+    return [];
+  return resources.filter((resource) => (resource == null ? void 0 : resource.status) !== 0).map((resource) => {
+    var _a2, _b;
+    return {
+      formId: toNumberId(resource.id),
+      resourceIds: [
+        ...Array.isArray(resource.default_resource) ? resource.default_resource : [],
+        ...Array.isArray(resource.optional_resource) ? resource.optional_resource : []
+      ].map((id) => toNumberId(id)).filter((id) => id !== void 0),
+      resourceType: resource.type || ((_a2 = resource.select_type) == null ? void 0 : _a2.type) || "single",
+      required: resource.status === 1,
+      capacityRequired: Number(((_b = product.capacity) == null ? void 0 : _b.default) || product.capacity || 1) || 1
+    };
+  });
+}
+function normalizeProductForPlanner(product) {
+  var _a, _b;
+  const raw = product;
+  const kind = resolveProductKind(raw);
+  return {
+    id: raw.id ?? raw.product_id,
+    title: pickLocalizedText(raw.title || raw.name || raw.product_title),
+    kind,
+    durationMinutes: Number(((_a = raw.duration) == null ? void 0 : _a.value) || raw.duration || raw.service_duration || 30) || 30,
+    schedule: normalizeSchedule(raw),
+    resourceRequirements: normalizeRequirements(raw),
+    capacityRequired: Number(((_b = raw.capacity) == null ? void 0 : _b.default) || raw.capacity || 1) || 1,
+    quantity: Number(raw.num || raw.quantity || 1) || 1,
+    price: raw.price ?? raw.selling_price ?? raw.base_price,
+    raw
+  };
+}
+function normalizeResourceType(value) {
+  if (value === "multiple" || value === "capacity")
+    return value;
+  return "single";
+}
+function normalizeResource(raw) {
+  var _a, _b;
+  const id = raw.resourceId ?? raw.resource_id ?? raw.id;
+  if (id === void 0 || id === null || id === "")
+    return null;
+  const combinedResourceIds = (_a = raw.combined_resource) == null ? void 0 : _a.resource_ids;
+  return {
+    id,
+    formId: raw.formId ?? raw.form_id ?? raw.resource_form_id,
+    name: raw.resourceName || raw.main_field || raw.name || raw.title,
+    resourceType: normalizeResourceType(raw.type || raw.resourceType || ((_b = raw.select_type) == null ? void 0 : _b.type)),
+    capacity: Number(raw.capacity || raw.max_capacity || 1) || 1,
+    times: Array.isArray(raw.times) ? raw.times : [],
+    childResourceIds: Array.isArray(combinedResourceIds) ? combinedResourceIds : void 0,
+    raw
+  };
+}
+function normalizeScheduleIds(raw) {
+  const ids = raw.schedule ?? raw.schedule_ids ?? raw.scheduleIds ?? [];
+  return (Array.isArray(ids) ? ids : [ids]).map((id) => toNumberId(id)).filter((id) => id !== void 0);
+}
+function collectRawScheduleIds(rawResources) {
+  const ids = /* @__PURE__ */ new Map();
+  (rawResources || []).forEach((resource) => {
+    normalizeScheduleIds(resource).forEach((id) => {
+      ids.set(String(id), id);
+    });
+  });
+  return Array.from(ids.values());
+}
+function scheduleListHasIds(scheduleList, scheduleIds) {
+  if (!scheduleIds.length)
+    return true;
+  const existingIds = new Set((scheduleList || []).map((schedule) => String(schedule.id)));
+  return scheduleIds.every((id) => existingIds.has(String(id)));
+}
+function dateRangeDays(dateRange) {
+  if (!(dateRange == null ? void 0 : dateRange.start) || !(dateRange == null ? void 0 : dateRange.end))
+    return [];
+  const dates = [];
+  let cursor = (0, import_dayjs.default)(dateRange.start);
+  const end = (0, import_dayjs.default)(dateRange.end);
+  if (!cursor.isValid() || !end.isValid() || end.isBefore(cursor, "day"))
+    return dates;
+  while (cursor.isSame(end, "day") || cursor.isBefore(end, "day")) {
+    dates.push(cursor.format("YYYY-MM-DD"));
+    cursor = cursor.add(1, "day");
+  }
+  return dates;
+}
+function normalizePlannerEvent(rawEvent, resourceId) {
+  const startAt = rawEvent.start_at ?? rawEvent.startAt ?? rawEvent.start_time ?? rawEvent.startTime;
+  const endAt = rawEvent.end_at ?? rawEvent.endAt ?? rawEvent.end_time ?? rawEvent.endTime;
+  if (!startAt || !endAt)
+    return null;
+  const rawSource = rawEvent.source;
+  const source = rawSource === "remote" || rawSource === "cart" || rawSource === "selection" ? rawSource : "remote";
+  return {
+    ...rawEvent,
+    resourceId,
+    resource_id: rawEvent.resource_id ?? rawEvent.resourceId ?? resourceId,
+    start_at: startAt,
+    end_at: endAt,
+    pax: Number(rawEvent.pax ?? rawEvent.number ?? rawEvent.capacity ?? 1) || 1,
+    source
+  };
+}
+function normalizeResourceV2(raw) {
+  const normalized = normalizeResource({
+    ...raw,
+    times: []
+  });
+  if (!normalized)
+    return null;
+  return normalized;
+}
+function buildResourceWindowFallbackTimes(params) {
+  const { raw, dates, scheduleIds } = params;
+  const rawStart = raw.start_time || raw.start_at || raw.startTime;
+  const rawEnd = raw.end_time || raw.end_at || raw.endTime;
+  if (!rawStart || !rawEnd)
+    return [];
+  const startBoundary = (0, import_dayjs.default)(rawStart);
+  const endBoundary = (0, import_dayjs.default)(rawEnd);
+  if (!startBoundary.isValid() || !endBoundary.isValid() || !endBoundary.isAfter(startBoundary)) {
+    return [];
+  }
+  return dates.flatMap((date) => {
+    const dayStart = (0, import_dayjs.default)(`${date} 00:00:00`);
+    const dayEnd = (0, import_dayjs.default)(`${date} 23:59:59`);
+    const start = startBoundary.isAfter(dayStart) ? startBoundary : dayStart;
+    const end = endBoundary.isBefore(dayEnd) ? endBoundary : dayEnd;
+    if (!end.isAfter(start))
+      return [];
+    return [{
+      start_at: start.format("YYYY-MM-DD HH:mm:ss"),
+      end_at: end.format("YYYY-MM-DD HH:mm:ss"),
+      schedule_ids: scheduleIds,
+      source: "resource_window_fallback"
+    }];
+  });
+}
+function buildPlannerResourcesFromV2(params) {
+  const scheduleMap = new Map(
+    (params.scheduleList || []).map((schedule) => [String(schedule.id), schedule])
+  );
+  const dates = dateRangeDays(params.dateRange);
+  const externalEvents = [];
+  const resources = (params.rawResources || []).map((raw) => {
+    const resource = normalizeResourceV2(raw);
+    if (!resource)
+      return null;
+    const scheduleIds = normalizeScheduleIds(raw);
+    const schedules = scheduleIds.map((id) => scheduleMap.get(String(id))).filter(Boolean);
+    const matchedScheduleIds = new Set(schedules.map((schedule) => String(schedule.id)));
+    const missingScheduleIds = scheduleIds.filter((id) => !matchedScheduleIds.has(String(id)));
+    if (missingScheduleIds.length > 0) {
+      resource.raw = {
+        ...resource.raw || raw,
+        _plannerMissingScheduleIds: missingScheduleIds
+      };
+    }
+    resource.times = dates.flatMap((date) => (0, import_getDateIsInSchedule.getScheduleStartEndTimePoints)(date, schedules).map((slot) => ({
+      start_at: (0, import_dayjs.default)(slot.start_at).format("YYYY-MM-DD HH:mm:ss"),
+      end_at: (0, import_dayjs.default)(slot.end_at).format("YYYY-MM-DD HH:mm:ss"),
+      schedule_ids: scheduleIds
+    })));
+    if (resource.times.length === 0 && missingScheduleIds.length > 0) {
+      resource.times = buildResourceWindowFallbackTimes({
+        raw,
+        dates,
+        scheduleIds
+      });
+    }
+    const eventList = Array.isArray(raw.event_list) ? raw.event_list : [];
+    eventList.forEach((event) => {
+      const normalizedEvent = normalizePlannerEvent(event, resource.id);
+      if (normalizedEvent)
+        externalEvents.push(normalizedEvent);
+    });
+    return resource;
+  }).filter((resource) => resource !== null);
+  return {
+    resources,
+    externalEvents
+  };
+}
+function collectPlannerResourceIds(products, explicitResourceIds = []) {
+  const ids = /* @__PURE__ */ new Map();
+  const add = (value) => {
+    if (value === void 0 || value === null || value === "")
+      return;
+    ids.set(String(value), value);
+  };
+  explicitResourceIds.forEach(add);
+  products.forEach((product) => {
+    var _a;
+    (_a = product.resourceRequirements) == null ? void 0 : _a.forEach((requirement) => {
+      var _a2;
+      (_a2 = requirement.resourceIds) == null ? void 0 : _a2.forEach(add);
+    });
+  });
+  return Array.from(ids.values());
+}
+function samePlannerId(left, right) {
+  if (left === void 0 || right === void 0)
+    return false;
+  return String(left) === String(right);
+}
+function findRequirementForAssignment(product, assignment) {
+  const requirements = product.resourceRequirements || [];
+  return requirements.find((requirement) => (requirement.resourceIds || []).some((id) => samePlannerId(id, assignment.resourceId))) || (requirements.length === 1 ? requirements[0] : void 0) || requirements.find((requirement) => requirement.required) || requirements[0];
+}
+function buildBookingFromAssignment(params) {
+  return buildBookingFromAssignments({
+    assignments: [params.assignment],
+    product: params.product
+  });
+}
+function buildBookingFromAssignments(params) {
+  const { assignments, product } = params;
+  const firstAssignment = assignments[0];
+  const start = (0, import_dayjs.default)(firstAssignment.start_at);
+  const end = (0, import_dayjs.default)(firstAssignment.end_at);
+  return {
+    start_date: start.format("YYYY-MM-DD"),
+    start_time: start.format("HH:mm"),
+    end_date: end.format("YYYY-MM-DD"),
+    end_time: end.format("HH:mm"),
+    duration: Math.max(1, end.diff(start, "minute")),
+    like_status: "common",
+    schedule_id: 0,
+    resources: assignments.map((assignment) => {
+      const requirement = findRequirementForAssignment(product, assignment);
+      return {
+        id: assignment.resourceId,
+        resource_id: assignment.resourceId,
+        form_id: requirement == null ? void 0 : requirement.formId,
+        relation_type: "form",
+        relation_id: assignment.resourceId,
+        like_status: "common",
+        capacity: assignment.capacityRequired || product.capacityRequired || 1
+      };
+    }),
+    metadata: {
+      unified_booking_sales: true,
+      planner_source: product.kind
+    }
+  };
+}
+function buildAssignmentGroupKey(assignment) {
+  return [
+    assignment.productId,
+    assignment.start_at,
+    assignment.end_at
+  ].join(":");
+}
+function buildPlannerLineIdentity(product) {
+  var _a;
+  return {
+    product_id: product.product_id,
+    product_variant_id: product.product_variant_id ?? 0,
+    unique_identification_number: ((_a = product.metadata) == null ? void 0 : _a.unique_identification_number) || product.unique_identification_number,
+    product_sku: product.product_sku,
+    product_bundle: product.product_bundle
+  };
+}
+var UnifiedBookingSalesImpl = class extends import_BookingTicket.BookingTicket {
+  constructor() {
+    super(...arguments);
+    this.defaultName = "unifiedBookingSales";
+    this.defaultVersion = "1.0.0";
+    this.store = {};
+    this.unifiedProductCatalog = [];
+    this.openDataTarget = null;
+    this.loadOpenDataInFlight = null;
+    this.loadOpenDataInFlightTarget = null;
+  }
+  /**
+   * Kiosk 不能把已收款订单留在本地等待重试：默认直接等待云端 checkout。
+   * 兼容仍需要 WebPOS 待同步模式的入口可显式传 checkoutSyncTaskEnabled: true。
+   */
+  shouldUseCheckoutSyncTask() {
+    var _a;
+    const configured = (_a = this.otherParams) == null ? void 0 : _a.checkoutSyncTaskEnabled;
+    return typeof configured === "boolean" ? configured : false;
+  }
+  /** UnifiedBookingSales 的真实结账默认请求收据数据，供云端确认后再本地打印。 */
+  getDefaultCheckoutSmallTicketDataFlag() {
+    return 1;
+  }
+  getRegisteredModuleNames() {
+    return [...super.getRegisteredModuleNames(), "resourcePlanner", "openData"];
+  }
+  createSubModule(moduleName) {
+    if (moduleName === "resourcePlanner") {
+      return new import_modules.ResourcePlannerModule(`${this.name}_resourcePlanner`);
+    }
+    if (moduleName === "openData") {
+      return new import_modules.OpenDataModule(`${this.name}_openData`);
+    }
+    return super.createSubModule(moduleName);
+  }
+  /**
+   * Loads OpenData without borrowing BookingTicket. Cache ownership is tied to the exact
+   * business/channel target so a reused solution instance cannot leak another entry's menus.
+   */
+  async loadOpenData(params) {
+    if (!this.store.openData) {
+      throw new Error("[UnifiedBookingSales] openData 模块未初始化");
+    }
+    const businessCode = String(params.businessCode || "").trim();
+    const channel = String(params.channel || "").trim();
+    if (!businessCode || !channel) {
+      throw new Error("[UnifiedBookingSales] OpenData 需要 businessCode 与 channel");
+    }
+    const target = `${businessCode}+${channel}`;
+    const cachedData = this.store.openData.getOpenData();
+    const lastFetchedAt = this.store.openData.getLastFetchedAt();
+    if (!params.force && this.openDataTarget === target && cachedData && lastFetchedAt && Date.now() - lastFetchedAt < OPEN_DATA_CACHE_TTL) {
+      return cachedData;
+    }
+    if (this.loadOpenDataInFlight) {
+      if (this.loadOpenDataInFlightTarget === target) {
+        return await this.loadOpenDataInFlight;
+      }
+      await this.loadOpenDataInFlight;
+      return this.loadOpenData(params);
+    }
+    this.loadOpenDataInFlightTarget = target;
+    this.loadOpenDataInFlight = this.store.openData.fetchOpenData({
+      scope: "board",
+      target,
+      section_code: [...OPEN_DATA_SECTION_CODES]
+    });
+    try {
+      const openData = await this.loadOpenDataInFlight;
+      this.openDataTarget = target;
+      this.otherParams.openData = openData;
+      this.otherParams.businessCode = businessCode;
+      this.otherParams.channel = channel;
+      return openData;
+    } finally {
+      this.loadOpenDataInFlight = null;
+      this.loadOpenDataInFlightTarget = null;
+    }
+  }
+  async getOpenData() {
+    var _a, _b, _c;
+    const businessCode = String(((_a = this.otherParams) == null ? void 0 : _a.businessCode) || "").trim();
+    const channel = String(((_b = this.otherParams) == null ? void 0 : _b.channel) || "").trim();
+    if (!businessCode || !channel)
+      return null;
+    const target = `${businessCode}+${channel}`;
+    const cachedData = ((_c = this.store.openData) == null ? void 0 : _c.getOpenData()) || null;
+    if (cachedData && this.openDataTarget === target)
+      return cachedData;
+    return this.loadOpenData({ businessCode, channel });
+  }
+  /**
+   * Loads the product catalog used by both UI and Planner. Schedule data is requested with each
+   * product because session products carry their fixed intervals there.
+   */
+  async loadProducts(params = {}, options) {
+    if (!this.store.products)
+      throw new Error("[UnifiedBookingSales] products 模块未初始化");
+    const schedule_date = params.schedule_date || (0, import_dayjs.default)().format("YYYY-MM-DD");
+    const schedule_datetime = params.schedule_datetime || `${schedule_date} ${(0, import_dayjs.default)().format("HH:mm:ss")}`;
+    const result = await this.store.products.loadProducts({
+      with_count: ["bundleGroup", "optionGroup"],
+      with_schedule: 1,
+      ...params,
+      schedule_date,
+      schedule_datetime,
+      cacheId: this.cacheId
+    }, options);
+    this.unifiedProductCatalog = Array.isArray(result) ? [...result] : [];
+    await this.core.effects.emit(`${this.name}:onProductsLoaded`, result);
+    return result;
+  }
+  /** Date-first entry point. It delegates protocol details and cache ownership to ScheduleModule. */
+  async loadScheduleAvailableDate(params) {
+    if (!this.store.schedule)
+      throw new Error("[UnifiedBookingSales] schedule 模块未初始化");
+    return this.store.schedule.loadScheduleAvailableDate(params);
+  }
+  /**
+   * Implements the date-first product pool: the chosen date's product ids plus globally sellable
+   * other_product_ids. If a batch product query is unexpectedly empty, retry one id at a time so
+   * a partial backend incompatibility does not hide the entire date's catalog.
+   */
+  async loadProductsByScheduleDate(params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+    const {
+      date,
+      custom_page_id,
+      channel,
+      product_ids,
+      ...productLoadParams
+    } = params;
+    if (!this.store.schedule)
+      throw new Error("[UnifiedBookingSales] schedule 模块未初始化");
+    const cachedDates = ((_b = (_a = this.store.schedule).getAvailabilityScheduleDateList) == null ? void 0 : _b.call(_a)) || [];
+    const hasCachedDate = cachedDates.some((item) => item.date === date);
+    const hasOtherProducts = (((_d = (_c = this.store.schedule).getOtherProductsIds) == null ? void 0 : _d.call(_c)) || []).length > 0;
+    if (!hasCachedDate && !hasOtherProducts) {
+      await this.loadScheduleAvailableDate({
+        startDate: date,
+        endDate: date,
+        custom_page_id,
+        channel
+      });
+    }
+    const scheduleDate = (_g = (_f = (_e = this.store.schedule).getAvailabilityScheduleDateList) == null ? void 0 : _f.call(_e)) == null ? void 0 : _g.find((item) => item.date === date);
+    const productIdFilter = (product_ids == null ? void 0 : product_ids.length) ? new Set(product_ids.map((id) => String(id))) : null;
+    const availableProductIds = [
+      ...(scheduleDate == null ? void 0 : scheduleDate.product_ids) || [],
+      ...((_i = (_h = this.store.schedule).getOtherProductsIds) == null ? void 0 : _i.call(_h)) || []
+    ].filter((id, index, self) => self.indexOf(id) === index).filter((id) => !productIdFilter || productIdFilter.has(String(id)));
+    if (!availableProductIds.length) {
+      this.unifiedProductCatalog = [];
+      await this.core.effects.emit(`${this.name}:onProductsLoaded`, []);
+      return [];
+    }
+    const products = await this.loadProducts({
+      ...productLoadParams,
+      product_ids: availableProductIds,
+      schedule_date: date
+    });
+    if (products.length || availableProductIds.length <= 1)
+      return products;
+    const fallbackProducts = [];
+    for (const productId of availableProductIds) {
+      const result = await this.loadProducts({
+        ...productLoadParams,
+        product_ids: [productId],
+        schedule_date: date
+      });
+      result.forEach((product) => {
+        const id = (product == null ? void 0 : product.id) ?? (product == null ? void 0 : product.product_id);
+        if (!fallbackProducts.some((item) => String((item == null ? void 0 : item.id) ?? (item == null ? void 0 : item.product_id)) === String(id))) {
+          fallbackProducts.push(product);
+        }
+      });
+    }
+    this.unifiedProductCatalog = [...fallbackProducts];
+    await this.core.effects.emit(`${this.name}:onProductsLoaded`, fallbackProducts);
+    return fallbackProducts;
+  }
+  /** Returns a copy so UI consumers cannot accidentally mutate the solution's product cache. */
+  getProductCatalog() {
+    return { products: [...this.unifiedProductCatalog] };
+  }
+  /**
+   * Read-only compatibility view for salesSdk skins. It reconnects a booking to its product but
+   * must not be used to mutate tempOrder; all writes go through BaseSales / planner APIs.
+   */
+  // getCart(): BookingTicketCartView {
+  //   const tempOrder = this.getTempOrder();
+  //   const salesDetail = this.getSalesOrder();
+  //   const items = tempOrder?.products || [];
+  //   const bookings = salesDetail?.bookings || tempOrder?.bookings || [];
+  //   return {
+  //     items,
+  //     bookings: bookings.map((booking: any) => {
+  //       const productUid = booking?.product_uid;
+  //       const product = productUid
+  //         ? items.find((item: any) => {
+  //           const uid = item?.metadata?.unique_identification_number || item?.unique_identification_number;
+  //           return String(uid || '') === String(productUid);
+  //         }) || null
+  //         : null;
+  //       return {
+  //         ...booking,
+  //         _extend: {
+  //           ...(booking?._extend || {}),
+  //           product,
+  //           addTimeProduct: [],
+  //           canAddTime: false,
+  //         },
+  //       };
+  //     }),
+  //   };
+  // }
+  /**
+   * Loads the current customer's product coupons and discount cards after planner lines exist,
+   * then optionally lets the existing Rules engine select the best valid combination. This is a
+   * diagnostic boundary for new booking skins: no pricing logic is duplicated in the planner.
+   */
+  async applyPlannerDiscounts(params = {}) {
+    const tempOrder = this.getTempOrder();
+    const requestedCustomerId = params.customerId ?? (tempOrder == null ? void 0 : tempOrder.customer_id);
+    const parsedCustomerId = Number(requestedCustomerId);
+    const customerId = Number.isFinite(parsedCustomerId) && parsedCustomerId > 1 ? parsedCustomerId : null;
+    const summaryBefore = await this.getSummary();
+    if (!customerId) {
+      return buildPlannerDiscountResult({
+        customerId: null,
+        discountList: this.getDiscountList(),
+        products: (tempOrder == null ? void 0 : tempOrder.products) || [],
+        summaryBefore,
+        summaryAfter: summaryBefore,
+        status: "no_customer"
+      });
+    }
+    await this.loadDiscountConfig({ customerId, action: "create" });
+    const preferredDiscountId = params.preferredDiscountId;
+    const preferredDiscount = preferredDiscountId === void 0 || preferredDiscountId === null ? void 0 : this.getDiscountList().find((discount) => String(resolvePlannerDiscountId(discount) ?? "") === String(preferredDiscountId));
+    if (preferredDiscount) {
+      const preferredId = resolvePlannerDiscountId(preferredDiscount);
+      const selectedOtherDiscounts = this.getDiscountList().filter((discount) => discount.isSelected === true && String(resolvePlannerDiscountId(discount) ?? "") !== String(preferredId));
+      for (const discount of selectedOtherDiscounts) {
+        const discountId = Number(resolvePlannerDiscountId(discount));
+        if (Number.isFinite(discountId)) {
+          await this.setDiscountSelected({ discountId, isSelected: false });
+        }
+      }
+      await this.setDiscountSelected({
+        discountId: Number(preferredId),
+        isSelected: true
+      });
+    } else if (preferredDiscountId === void 0 || preferredDiscountId === null) {
+      if (params.applyBestDiscount !== false)
+        await this.bestDiscount();
+    } else if (params.applyBestDiscount !== false) {
+      await this.bestDiscount();
+    }
+    const nextTempOrder = this.getTempOrder();
+    return buildPlannerDiscountResult({
+      customerId,
+      discountList: this.getDiscountList(),
+      products: (nextTempOrder == null ? void 0 : nextTempOrder.products) || [],
+      summaryBefore,
+      summaryAfter: await this.getSummary(),
+      status: params.applyBestDiscount === false && !preferredDiscount ? "loaded" : "applied",
+      preferredDiscountId,
+      preferredDiscountFound: preferredDiscountId === void 0 || preferredDiscountId === null ? void 0 : Boolean(preferredDiscount)
+    });
+  }
+  /** ResourcePlanner is a required child module; fail early instead of producing partial availability. */
+  getPlanner() {
+    if (!this.store.resourcePlanner) {
+      throw new Error("[UnifiedBookingSales] resourcePlanner 模块未初始化");
+    }
+    return this.store.resourcePlanner;
+  }
+  buildUnifiedOrderProduct(sourceProduct, ownershipKey, product) {
+    const orderProduct = this.transformBaseProductToOrderProduct({
+      payload: {
+        ...sourceProduct,
+        id: sourceProduct.id ?? (product == null ? void 0 : product.id),
+        product_id: sourceProduct.product_id ?? sourceProduct.id ?? (product == null ? void 0 : product.id),
+        quantity: sourceProduct.quantity ?? sourceProduct.num ?? (product == null ? void 0 : product.quantity) ?? 1,
+        price: sourceProduct.price ?? (product == null ? void 0 : product.price),
+        selling_price: sourceProduct.selling_price ?? sourceProduct.price ?? (product == null ? void 0 : product.price),
+        metadata: {
+          ...sourceProduct.metadata || {},
+          [ownershipKey]: true
+        }
+      },
+      sourceProduct
+    });
+    if (orderProduct && typeof orderProduct === "object") {
+      orderProduct.metadata = {
+        ...orderProduct.metadata || {},
+        [ownershipKey]: true
+      };
+    }
+    return orderProduct;
+  }
+  /** Replacing a staged selection is idempotent and never removes unrelated cart lines. */
+  async removeExistingStagedLines(ownershipKey) {
+    var _a;
+    const existingLines = (((_a = this.getTempOrder()) == null ? void 0 : _a.products) || []).filter((product) => {
+      var _a2;
+      return ((_a2 = product == null ? void 0 : product.metadata) == null ? void 0 : _a2[ownershipKey]) === true;
+    });
+    if (existingLines.length > 0) {
+      await this.removeProductsFromOrder(existingLines.map(buildPlannerLineIdentity));
+    }
+  }
+  async stageProducts(params, ownershipKey) {
+    var _a;
+    const productIds = params.productIds || [];
+    if (!productIds.length)
+      return this.getTempOrder();
+    if ((_a = params.rawProducts) == null ? void 0 : _a.length) {
+      this.unifiedProductCatalog = params.rawProducts;
+    } else {
+      const existingIds = new Set((this.unifiedProductCatalog || []).map((product) => String(product.id ?? product.product_id)));
+      const missingIds = productIds.filter((id) => !existingIds.has(String(id)));
+      if (missingIds.length || params.productLoadParams) {
+        await this.loadProducts({
+          ...params.productLoadParams || {},
+          product_ids: productIds.map(Number).filter(Number.isFinite)
+        });
+      }
+    }
+    await this.removeExistingStagedLines(ownershipKey);
+    const productIdSet = new Set(productIds.map((id) => String(id)));
+    const selectedProducts = (this.unifiedProductCatalog || []).filter((product) => productIdSet.has(String(product.id ?? product.product_id)));
+    for (const sourceProduct of selectedProducts) {
+      const productInput = this.buildUnifiedOrderProduct(sourceProduct, ownershipKey);
+      if (productInput)
+        await this.addProductToOrder(productInput);
+    }
+    return this.getTempOrder();
+  }
+  /**
+   * Adds the current product choice to an otherwise clean planner cart without creating bookings.
+   * This separates "what the customer wants" from the later time/resource confirmation step.
+   */
+  async stagePlannerProducts(params) {
+    return this.stageProducts(params, "unified_booking_sales");
+  }
+  /**
+   * Adds ordinary retail products without asking ResourcePlanner for booking facts.
+   * Its staged lines have separate ownership so planner and retail skins can coexist safely.
+   */
+  async stageRetailProducts(params) {
+    return this.stageProducts(params, "unified_booking_sales_retail");
+  }
+  /**
+   * Adds one retail line without replacing the cart's existing retail selection.
+   * This is intentionally separate from stageRetailProducts(), whose contract is
+   * "replace the staged selection" for demo and wizard-like callers.
+   */
+  async addRetailProduct(params) {
+    var _a, _b;
+    const quantity = Math.floor(Number(params.quantity ?? 1));
+    if (!Number.isFinite(quantity) || quantity <= 0) {
+      throw new Error("[UnifiedBookingSales] retail 商品数量必须大于 0");
+    }
+    const productId = params.productId ?? ((_a = params.product) == null ? void 0 : _a.id) ?? ((_b = params.product) == null ? void 0 : _b.product_id);
+    let sourceProduct = params.product;
+    if (!sourceProduct && productId !== void 0 && productId !== null) {
+      sourceProduct = this.unifiedProductCatalog.find(
+        (product) => String(product.id ?? product.product_id) === String(productId)
+      );
+    }
+    if (!sourceProduct && productId !== void 0 && productId !== null) {
+      const products = await this.loadProducts({
+        ...params.productLoadParams || {},
+        product_ids: [Number(productId)].filter(Number.isFinite)
+      });
+      sourceProduct = products.find(
+        (product) => String(product.id ?? product.product_id) === String(productId)
+      );
+    }
+    if (!sourceProduct) {
+      throw new Error(`[UnifiedBookingSales] 未找到零售商品 ${String(productId ?? "")}`.trim());
+    }
+    const orderProduct = this.buildUnifiedOrderProduct(
+      {
+        ...sourceProduct,
+        quantity
+      },
+      "unified_booking_sales_retail"
+    );
+    if (!orderProduct) {
+      throw new Error("[UnifiedBookingSales] 无法生成零售商品订单行");
+    }
+    return this.addProductToOrder(orderProduct);
+  }
+  /** Normalizes caller-provided products or loads the catalog before any resource request is made. */
+  async loadPlannerProducts(params) {
+    var _a, _b, _c, _d, _e, _f;
+    if ((_b = (_a = params.context) == null ? void 0 : _a.products) == null ? void 0 : _b.length)
+      return params.context.products;
+    if ((_c = params.rawProducts) == null ? void 0 : _c.length)
+      return params.rawProducts.map(normalizeProductForPlanner);
+    const productIds = params.productIds || ((_d = params.productLoadParams) == null ? void 0 : _d.product_ids) || [];
+    if (productIds.length > 0 || params.productLoadParams) {
+      await this.loadProducts({
+        ...params.date ? { schedule_date: params.date } : {},
+        ...params.productLoadParams || {},
+        product_ids: productIds.length ? productIds.map(Number).filter(Number.isFinite) : (_e = params.productLoadParams) == null ? void 0 : _e.product_ids
+      });
+    }
+    return (((_f = this.getProductCatalog) == null ? void 0 : _f.call(this).products) || []).map(normalizeProductForPlanner);
+  }
+  /** Loads the reusable store-level schedule catalog on demand. */
+  async ensurePlannerSchedulesLoaded() {
+    var _a, _b, _c, _d, _e, _f;
+    if (!this.store.schedule)
+      throw new Error("[UnifiedBookingSales] schedule 模块未初始化");
+    const scheduleList = ((_b = (_a = this.store.schedule).getScheduleList) == null ? void 0 : _b.call(_a)) || [];
+    if (!((_d = (_c = this.store.schedule).isScheduleListLoaded) == null ? void 0 : _d.call(_c)) || scheduleList.length === 0) {
+      await this.store.schedule.loadAllSchedule();
+    }
+    return ((_f = (_e = this.store.schedule).getScheduleList) == null ? void 0 : _f.call(_e)) || [];
+  }
+  /**
+   * v2 resources reference schedule ids rather than expanded work times. Refresh once when the
+   * cached schedule catalog cannot materialize all referenced ids.
+   */
+  async ensurePlannerSchedulesForResources(rawResources) {
+    var _a, _b;
+    let scheduleList = await this.ensurePlannerSchedulesLoaded();
+    const scheduleIds = collectRawScheduleIds(rawResources);
+    if (!scheduleListHasIds(scheduleList, scheduleIds)) {
+      await this.store.schedule.loadAllSchedule({ useCache: false });
+      scheduleList = ((_b = (_a = this.store.schedule).getScheduleList) == null ? void 0 : _b.call(_a)) || [];
+    }
+    return scheduleList;
+  }
+  /**
+   * Fetches resource metadata plus flat occupied events. Work windows are intentionally derived
+   * locally in buildPlannerResourcesFromV2 from /schedule, rather than requested from the legacy
+   * resource dates endpoint.
+   */
+  async fetchPlannerResourcesV2(params) {
+    const response = await this.request.get("/schedule/resource/list/v2", {
+      start_date: params.dateRange.start,
+      end_date: params.dateRange.end,
+      resource_ids: params.resourceIds,
+      front_end_cache_id: false
+    }, {
+      useCache: false
+    });
+    const data = response == null ? void 0 : response.data;
+    if (Array.isArray(data))
+      return data;
+    if (Array.isArray(data == null ? void 0 : data.list))
+      return data.list;
+    return [];
+  }
+  /**
+   * Resolves the Planner context in precedence order: explicit normalized context, test raw data,
+   * then the v2 resource API inferred from selected product requirements and any URL lock.
+   */
+  async loadPlannerResources(params, products = []) {
+    var _a, _b, _c, _d, _e, _f;
+    if ((_b = (_a = params.context) == null ? void 0 : _a.resources) == null ? void 0 : _b.length) {
+      return {
+        resources: params.context.resources,
+        externalEvents: params.context.externalEvents || []
+      };
+    }
+    if ((_c = params.rawResources) == null ? void 0 : _c.length) {
+      return {
+        resources: params.rawResources.map(normalizeResource).filter((resource) => resource !== null),
+        externalEvents: ((_d = params.context) == null ? void 0 : _d.externalEvents) || []
+      };
+    }
+    const resourceIds = collectPlannerResourceIds(products, params.resourceIds || []);
+    if (!params.useResourceDateApi || !params.dateRange || resourceIds.length === 0) {
+      return {
+        resources: [],
+        externalEvents: ((_e = params.context) == null ? void 0 : _e.externalEvents) || []
+      };
+    }
+    const rawResources = await this.fetchPlannerResourcesV2({
+      dateRange: params.dateRange,
+      resourceIds
+    });
+    const scheduleList = await this.ensurePlannerSchedulesForResources(rawResources);
+    const materialized = buildPlannerResourcesFromV2({
+      rawResources,
+      scheduleList,
+      dateRange: params.dateRange
+    });
+    return {
+      resources: materialized.resources,
+      externalEvents: [
+        ...((_f = params.context) == null ? void 0 : _f.externalEvents) || [],
+        ...materialized.externalEvents
+      ]
+    };
+  }
+  /**
+   * Boundary between IO and pure planning. Once this returns, all later availability/slot calls
+   * operate on the ResourcePlanner snapshot and do not issue resource requests themselves.
+   */
+  async loadPlannerContext(params = {}) {
+    const products = await this.loadPlannerProducts(params);
+    const plannerResources = await this.loadPlannerResources(params, products);
+    const context = {
+      ...params.context || {},
+      products,
+      resources: plannerResources.resources,
+      externalEvents: plannerResources.externalEvents
+    };
+    const snapshot = this.getPlanner().setContext(context);
+    this.getPlanner().setSelectionPatch({
+      mode: params.mode,
+      productIds: params.productIds || [],
+      date: params.date,
+      startTime: params.startTime,
+      endTime: params.endTime,
+      resourceIds: params.resourceIds || []
+    });
+    await this.core.effects.emit(`${this.name}:${import_types.UnifiedBookingSalesHooks.onPlannerContextLoaded}`, snapshot);
+    return this.getPlanner().getSnapshot();
+  }
+  /** Returns cells, date summaries and a derived grid; cells are continuous ranges, not UI slots. */
+  async queryPlannerAvailability(query = {}) {
+    return this.getPlanner().queryAvailability(query);
+  }
+  /** Turns compatible availability ranges into user-selectable intervals and ready-to-commit assignments. */
+  resolveAssignableSlots(query = {}) {
+    return this.getPlanner().resolveAssignableSlots(query);
+  }
+  /** Stores a UI choice only. It is deliberately side-effect free with respect to tempOrder. */
+  setPlannerSelection(patch) {
+    return this.getPlanner().setSelectionPatch(patch);
+  }
+  /**
+   * Legacy-friendly automatic assignment for already fixed intervals. Duration products without a
+   * start time intentionally remain unresolved; callers offering a picker should use slots.
+   */
+  async autoAssignPlanner(query = {}) {
+    const result = this.getPlanner().autoAssign(query);
+    if (result.conflicts.length) {
+      console.warn("[UnifiedBookingSales] autoAssignPlanner 存在未分配项", result.conflicts);
+    }
+    return this.getPlanner().getSnapshot();
+  }
+  /** Rechecks remote events, capacity and conflicts among the current selection before committing. */
+  validatePlannerSelection() {
+    return this.getPlanner().validateSelection();
+  }
+  /** Read-only snapshot for UI diagnostics and progressive flow steps. */
+  getPlannerSnapshot() {
+    return this.getPlanner().getSnapshot();
+  }
+  /**
+   * Validates then writes assignments to tempOrder. Real order submission is opt-in so UI callers
+   * can safely preview the cart; pass submitAfterCommit only after an explicit confirmation.
+   */
+  async commitPlannerSelection(params = {}) {
+    if (params.selection) {
+      this.setPlannerSelection(params.selection);
+    }
+    if (params.assignments) {
+      this.setPlannerSelection({ assignments: params.assignments });
+    }
+    const snapshot = this.getPlannerSnapshot();
+    const assignments = snapshot.selection.assignments || [];
+    if (assignments.length === 0) {
+      return {
+        tempOrder: this.getTempOrder(),
+        assignments,
+        validation: {
+          ok: false,
+          conflicts: [{
+            type: "missing_assignment",
+            message: "没有可提交的 planner assignment，请先执行 autoAssignPlanner 或传入 assignments"
+          }]
+        }
+      };
+    }
+    const validation = this.validatePlannerSelection();
+    if (!validation.ok) {
+      return {
+        tempOrder: this.getTempOrder(),
+        assignments,
+        validation
+      };
+    }
+    const productsById = new Map(
+      snapshot.context.products.map((product) => [String(product.id), product])
+    );
+    await this.removeExistingStagedLines("unified_booking_sales");
+    const assignmentGroups = /* @__PURE__ */ new Map();
+    assignments.forEach((assignment) => {
+      const key = buildAssignmentGroupKey(assignment);
+      assignmentGroups.set(key, [...assignmentGroups.get(key) || [], assignment]);
+    });
+    for (const groupAssignments of assignmentGroups.values()) {
+      const product = productsById.get(String(groupAssignments[0].productId));
+      if (!product)
+        continue;
+      const sourceProduct = product.raw || { id: product.id, title: product.title, price: product.price };
+      const productInput = this.buildUnifiedOrderProduct(
+        sourceProduct,
+        "unified_booking_sales",
+        product
+      );
+      if (!productInput)
+        continue;
+      await this.addProductToOrder(productInput, buildBookingFromAssignments({
+        assignments: groupAssignments,
+        product
+      }));
+    }
+    let submitResult;
+    if (params.submitAfterCommit) {
+      submitResult = await this.submitSalesOrder();
+    }
+    const result = {
+      tempOrder: this.getTempOrder(),
+      assignments,
+      validation,
+      submitResult
+    };
+    await this.core.effects.emit(`${this.name}:${import_types.UnifiedBookingSalesHooks.onPlannerCommitted}`, result);
+    return result;
+  }
+};
+var UnifiedBookingSales = UnifiedBookingSalesImpl;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UnifiedBookingSales,
+  UnifiedBookingSalesImpl,
+  buildBookingFromAssignment,
+  buildBookingFromAssignments,
+  buildPlannerDiscountResult,
+  buildPlannerLineIdentity,
+  buildPlannerResourcesFromV2,
+  collectPlannerResourceIds,
+  normalizeProductForPlanner,
+  ...require("./types")
+});