@pisell/pisellos 0.0.568 → 0.10.1

package/lib/modules/ResourcePlanner/planner.js

@@ -0,0 +1,933 @@
+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 __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/modules/ResourcePlanner/planner.ts
+var planner_exports = {};
+__export(planner_exports, {
+  DEFAULT_RESOURCE_PLANNER_CONTEXT: () => DEFAULT_RESOURCE_PLANNER_CONTEXT,
+  DEFAULT_RESOURCE_PLANNER_SELECTION: () => DEFAULT_RESOURCE_PLANNER_SELECTION,
+  autoAssignResources: () => autoAssignResources,
+  buildDemandIntervals: () => buildDemandIntervals,
+  evaluateResourceForInterval: () => evaluateResourceForInterval,
+  normalizePlannerContext: () => normalizePlannerContext,
+  queryPlannerAvailability: () => queryPlannerAvailability,
+  resolveAssignableSlots: () => resolveAssignableSlots,
+  validateAssignments: () => validateAssignments
+});
+module.exports = __toCommonJS(planner_exports);
+var import_dayjs = __toESM(require("dayjs"));
+var DEFAULT_RESOURCE_PLANNER_CONTEXT = {
+  products: [],
+  resources: [],
+  externalEvents: [],
+  slotDurationMinutes: 30,
+  businessStartTime: "09:00",
+  businessEndTime: "18:00"
+};
+var DEFAULT_RESOURCE_PLANNER_SELECTION = {
+  productIds: [],
+  resourceIds: [],
+  assignments: []
+};
+function normalizePlannerContext(input = {}) {
+  return {
+    products: Array.isArray(input.products) ? input.products : [],
+    resources: Array.isArray(input.resources) ? input.resources : [],
+    externalEvents: Array.isArray(input.externalEvents) ? input.externalEvents : [],
+    slotDurationMinutes: input.slotDurationMinutes || DEFAULT_RESOURCE_PLANNER_CONTEXT.slotDurationMinutes,
+    businessStartTime: input.businessStartTime || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessStartTime,
+    businessEndTime: input.businessEndTime || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessEndTime
+  };
+}
+function sameId(left, right) {
+  return String(left) === String(right);
+}
+function dateOf(value) {
+  return (0, import_dayjs.default)(value).format("YYYY-MM-DD");
+}
+function timeOf(value) {
+  return (0, import_dayjs.default)(value).format("HH:mm");
+}
+function toDateTime(date, time) {
+  if (/^\d{4}-\d{2}-\d{2}/.test(time))
+    return (0, import_dayjs.default)(time);
+  return (0, import_dayjs.default)(`${date} ${time.length === 5 ? `${time}:00` : time}`);
+}
+function overlaps(startA, endA, startB, endB) {
+  return startA.isBefore(endB) && endA.isAfter(startB);
+}
+function containsRange(outerStart, outerEnd, innerStart, innerEnd) {
+  return !innerStart.isBefore(outerStart) && !innerEnd.isAfter(outerEnd);
+}
+function maxDayjs(left, right) {
+  return left.isAfter(right) ? left : right;
+}
+function minDayjs(left, right) {
+  return left.isBefore(right) ? left : right;
+}
+function addDays(start, end) {
+  const result = [];
+  let cursor = (0, import_dayjs.default)(start);
+  const finalDay = (0, import_dayjs.default)(end);
+  while (!cursor.isAfter(finalDay, "day")) {
+    result.push(cursor.format("YYYY-MM-DD"));
+    cursor = cursor.add(1, "day");
+  }
+  return result;
+}
+function getQueryProducts(products, query) {
+  var _a;
+  if (!((_a = query.productIds) == null ? void 0 : _a.length))
+    return products;
+  return products.filter((product) => query.productIds.some((id) => sameId(id, product.id)));
+}
+function getQueryResources(resources, query) {
+  var _a;
+  if (!((_a = query.resourceIds) == null ? void 0 : _a.length))
+    return resources;
+  return resources.filter((resource) => query.resourceIds.some((id) => sameId(id, resource.id)));
+}
+function matchesResourceRequirement(resource, requirement) {
+  var _a;
+  const isFormlessCandidate = resource.formId == null;
+  const formMatches = requirement.formId == null || isFormlessCandidate || sameId(requirement.formId, resource.formId);
+  const resourceMatches = !((_a = requirement.resourceIds) == null ? void 0 : _a.length) || isFormlessCandidate || requirement.resourceIds.some((id) => sameId(id, resource.id));
+  return formMatches && resourceMatches;
+}
+function resolveProductTitle(product) {
+  var _a, _b, _c;
+  const rawTitle = ((_a = product.raw) == null ? void 0 : _a.title) || ((_b = product.raw) == null ? void 0 : _b.name) || ((_c = product.raw) == null ? void 0 : _c.product_title);
+  if (typeof product.title === "string")
+    return product.title;
+  if (typeof rawTitle === "string")
+    return rawTitle;
+  if (rawTitle && typeof rawTitle === "object") {
+    return rawTitle.en || rawTitle.zh || rawTitle.default || Object.values(rawTitle)[0];
+  }
+  return void 0;
+}
+function buildDemandIntervals(products, query, context) {
+  const dates = query.date ? [query.date] : query.dateRange ? addDays(query.dateRange.start, query.dateRange.end) : [];
+  const selectedProducts = getQueryProducts(products, query);
+  const intervals = [];
+  for (const product of selectedProducts) {
+    const quantity = Math.max(1, Number(product.quantity || 1));
+    const capacityRequired = Math.max(1, Number(query.pax || product.capacityRequired || 1));
+    const requirements = product.resourceRequirements || [];
+    if (product.kind === "session" || product.kind === "venue_slot") {
+      const schedules = product.schedule || [];
+      for (const schedule of schedules) {
+        const scheduleDate = dateOf(schedule.start_at);
+        if (dates.length > 0 && !dates.includes(scheduleDate))
+          continue;
+        const start = (0, import_dayjs.default)(schedule.start_at);
+        const end = (0, import_dayjs.default)(schedule.end_at);
+        intervals.push({
+          id: `${product.id}:${start.toISOString()}:${end.toISOString()}`,
+          productId: product.id,
+          source: product.kind,
+          date: dateOf(schedule.start_at),
+          start_at: start.toISOString(),
+          end_at: end.toISOString(),
+          durationMinutes: Math.max(1, end.diff(start, "minute")),
+          quantity,
+          capacityRequired,
+          resourceRequirements: requirements
+        });
+      }
+      continue;
+    }
+    if (product.kind === "duration") {
+      const duration = Math.max(1, Number(product.durationMinutes || 30));
+      for (const currentDate of dates) {
+        const start = query.startTime ? toDateTime(currentDate, query.startTime) : toDateTime(currentDate, (context == null ? void 0 : context.businessStartTime) || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessStartTime);
+        let end = query.startTime && query.endTime ? toDateTime(currentDate, query.endTime) : query.startTime ? start.add(duration, "minute") : toDateTime(currentDate, (context == null ? void 0 : context.businessEndTime) || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessEndTime);
+        if (!end.isAfter(start))
+          end = end.add(1, "day");
+        intervals.push({
+          id: `${product.id}:${currentDate}:${query.startTime || "range"}`,
+          productId: product.id,
+          source: "duration",
+          date: currentDate,
+          start_at: start.toISOString(),
+          end_at: end.toISOString(),
+          durationMinutes: duration,
+          quantity,
+          capacityRequired,
+          resourceRequirements: requirements
+        });
+      }
+    }
+  }
+  return intervals;
+}
+function getEventsForResource(resource, contextEvents) {
+  const embeddedEvents = resource.times.flatMap((time) => time.event_list || []);
+  return [
+    ...embeddedEvents,
+    ...contextEvents.filter((event) => sameId(event.resourceId ?? event.resource_id, resource.id))
+  ].filter(Boolean);
+}
+function collectEventsByResource(resources, contextEvents) {
+  const eventsByResource = /* @__PURE__ */ new Map();
+  resources.forEach((resource) => {
+    eventsByResource.set(String(resource.id), getEventsForResource(resource, contextEvents));
+  });
+  return eventsByResource;
+}
+function getWorkingSegmentsForInterval(resource, interval) {
+  const intervalStart = (0, import_dayjs.default)(interval.start_at);
+  const intervalEnd = (0, import_dayjs.default)(interval.end_at);
+  return resource.times.map((time) => {
+    const start = maxDayjs((0, import_dayjs.default)(time.start_at), intervalStart);
+    const end = minDayjs((0, import_dayjs.default)(time.end_at), intervalEnd);
+    return { start, end };
+  }).filter((segment) => segment.end.isAfter(segment.start));
+}
+function mergeBusySegments(segments) {
+  const sorted = [...segments].filter((segment) => segment.end.isAfter(segment.start)).sort((left, right) => left.start.valueOf() - right.start.valueOf());
+  const merged = [];
+  sorted.forEach((segment) => {
+    const previous = merged[merged.length - 1];
+    if (previous && !segment.start.isAfter(previous.end)) {
+      previous.end = maxDayjs(previous.end, segment.end);
+    } else {
+      merged.push({ ...segment });
+    }
+  });
+  return merged;
+}
+function subtractBusyIntervals(workingSegments, events) {
+  const available = [];
+  workingSegments.forEach((working) => {
+    const busySegments = mergeBusySegments(events.filter((event) => overlaps(working.start, working.end, (0, import_dayjs.default)(event.start_at), (0, import_dayjs.default)(event.end_at))).map((event) => ({
+      start: maxDayjs((0, import_dayjs.default)(event.start_at), working.start),
+      end: minDayjs((0, import_dayjs.default)(event.end_at), working.end)
+    })));
+    let cursor = working.start;
+    busySegments.forEach((busy) => {
+      if (busy.start.isAfter(cursor)) {
+        available.push({ start: cursor, end: busy.start });
+      }
+      if (busy.end.isAfter(cursor))
+        cursor = busy.end;
+    });
+    if (working.end.isAfter(cursor)) {
+      available.push({ start: cursor, end: working.end });
+    }
+  });
+  return available;
+}
+function buildCapacityRanges(params) {
+  const { workingSegments, events, maxCapacity, requiredCapacity } = params;
+  const ranges = [];
+  workingSegments.forEach((working) => {
+    const boundaries = /* @__PURE__ */ new Map([
+      [working.start.valueOf(), working.start],
+      [working.end.valueOf(), working.end]
+    ]);
+    events.forEach((event) => {
+      const eventStart = (0, import_dayjs.default)(event.start_at);
+      const eventEnd = (0, import_dayjs.default)(event.end_at);
+      if (!overlaps(working.start, working.end, eventStart, eventEnd))
+        return;
+      const clippedStart = maxDayjs(eventStart, working.start);
+      const clippedEnd = minDayjs(eventEnd, working.end);
+      boundaries.set(clippedStart.valueOf(), clippedStart);
+      boundaries.set(clippedEnd.valueOf(), clippedEnd);
+    });
+    const points = Array.from(boundaries.values()).sort((left, right) => left.valueOf() - right.valueOf());
+    for (let index = 0; index < points.length - 1; index += 1) {
+      const start = points[index];
+      const end = points[index + 1];
+      if (!end.isAfter(start))
+        continue;
+      const usedCapacity = events.filter((event) => overlaps(start, end, (0, import_dayjs.default)(event.start_at), (0, import_dayjs.default)(event.end_at))).reduce((sum, event) => sum + Math.max(1, Number(event.pax || 1)), 0);
+      const remainingCapacity = Math.max(0, maxCapacity - usedCapacity);
+      if (remainingCapacity < requiredCapacity)
+        continue;
+      const status = remainingCapacity < maxCapacity ? "limited" : "available";
+      const previous = ranges[ranges.length - 1];
+      if (previous && previous.end.isSame(start) && previous.remainingCapacity === remainingCapacity && previous.maxCapacity === maxCapacity && previous.status === status) {
+        previous.end = end;
+      } else {
+        ranges.push({
+          start,
+          end,
+          remainingCapacity,
+          maxCapacity,
+          status
+        });
+      }
+    }
+  });
+  return ranges;
+}
+function rangeFitsDuration(segment, durationMinutes) {
+  return segment.end.diff(segment.start, "minute") >= durationMinutes;
+}
+function makeAvailabilityRangeCell(params) {
+  const { interval, resource, segment } = params;
+  const maxCapacity = Math.max(1, Number(segment.maxCapacity || resource.capacity || 1));
+  const remainingCapacity = resource.resourceType === "single" ? 1 : Math.max(0, Number(segment.remainingCapacity ?? maxCapacity));
+  const status = resource.resourceType === "single" ? "available" : segment.status || (remainingCapacity < maxCapacity ? "limited" : "available");
+  return {
+    key: `${interval.productId}:${resource.id}:${segment.start.toISOString()}:${segment.end.toISOString()}`,
+    productId: interval.productId,
+    resourceId: resource.id,
+    date: interval.date,
+    start_at: segment.start.toISOString(),
+    end_at: segment.end.toISOString(),
+    startTime: segment.start.format("HH:mm"),
+    endTime: segment.end.format("HH:mm"),
+    durationMinutes: interval.durationMinutes,
+    cellType: "availability_range",
+    status,
+    remainingCapacity,
+    maxCapacity,
+    reasonCodes: [],
+    conflicts: []
+  };
+}
+function buildAvailabilityCellsForResource(params) {
+  const { resource, interval, events } = params;
+  const requiredCapacity = Math.max(1, Number(interval.capacityRequired || 1));
+  const durationMinutes = Math.max(1, Number(interval.durationMinutes || 1));
+  const maxCapacity = Math.max(1, Number(resource.capacity || 1));
+  let workingSegments = getWorkingSegmentsForInterval(resource, interval);
+  const now = (0, import_dayjs.default)();
+  workingSegments = workingSegments.map((segment) => ({
+    start: segment.end.isAfter(now) ? maxDayjs(segment.start, now) : segment.start,
+    end: segment.end
+  })).filter((segment) => segment.end.isAfter(segment.start));
+  const availableSegments = resource.resourceType === "single" ? subtractBusyIntervals(workingSegments, events).map((segment) => ({
+    ...segment,
+    remainingCapacity: 1,
+    maxCapacity: 1,
+    status: "available"
+  })) : buildCapacityRanges({
+    workingSegments,
+    events,
+    maxCapacity,
+    requiredCapacity
+  });
+  return availableSegments.filter((segment) => rangeFitsDuration(segment, durationMinutes)).map((segment) => makeAvailabilityRangeCell({
+    interval,
+    resource,
+    segment
+  }));
+}
+function evaluateResourceForInterval(params) {
+  const { resource, interval, context } = params;
+  const start = (0, import_dayjs.default)(interval.start_at);
+  const end = (0, import_dayjs.default)(interval.end_at);
+  const conflicts = [];
+  const reasonCodes = [];
+  const maxCapacity = Math.max(1, Number(resource.capacity || 1));
+  const requiredCapacity = Math.max(1, Number(interval.capacityRequired || 1));
+  if (start.isBefore((0, import_dayjs.default)())) {
+    reasonCodes.push("past");
+    conflicts.push({
+      type: "past",
+      message: "时间已过期",
+      resourceId: resource.id,
+      productId: interval.productId
+    });
+  }
+  const insideResourceTime = resource.times.some((time) => {
+    return containsRange((0, import_dayjs.default)(time.start_at), (0, import_dayjs.default)(time.end_at), start, end);
+  });
+  if (!insideResourceTime) {
+    reasonCodes.push("outside_resource_time");
+    conflicts.push({
+      type: "outside_resource_time",
+      message: "所选时间不在资源可用时间内",
+      resourceId: resource.id,
+      productId: interval.productId
+    });
+  }
+  const events = getEventsForResource(resource, context.externalEvents);
+  const overlapping = events.filter((event) => overlaps(start, end, (0, import_dayjs.default)(event.start_at), (0, import_dayjs.default)(event.end_at)));
+  const usedCapacity = resource.resourceType === "single" ? overlapping.length : overlapping.reduce((sum, event) => sum + Math.max(1, Number(event.pax || 1)), 0);
+  const remainingCapacity = resource.resourceType === "single" ? overlapping.length > 0 ? 0 : 1 : Math.max(0, maxCapacity - usedCapacity);
+  if (overlapping.length > 0 && resource.resourceType === "single") {
+    reasonCodes.push("remote_event_overlap");
+    conflicts.push(...overlapping.map((event) => ({
+      type: "remote_event_overlap",
+      message: "资源时间被已有预约占用",
+      event,
+      resourceId: resource.id,
+      productId: interval.productId
+    })));
+  }
+  if (resource.resourceType !== "single" && remainingCapacity < requiredCapacity) {
+    reasonCodes.push("capacity_full");
+    conflicts.push({
+      type: "capacity_full",
+      message: "资源剩余容量不足",
+      resourceId: resource.id,
+      productId: interval.productId
+    });
+  }
+  let status = "available";
+  if (reasonCodes.includes("past"))
+    status = "past";
+  else if (reasonCodes.includes("outside_resource_time"))
+    status = "unavailable";
+  else if (reasonCodes.includes("remote_event_overlap") || reasonCodes.includes("capacity_full")) {
+    status = "full";
+  } else if (remainingCapacity < maxCapacity) {
+    status = "limited";
+  }
+  return {
+    key: `${interval.productId}:${resource.id}:${interval.start_at}:${interval.end_at}`,
+    productId: interval.productId,
+    resourceId: resource.id,
+    date: interval.date,
+    start_at: interval.start_at,
+    end_at: interval.end_at,
+    startTime: timeOf(interval.start_at),
+    endTime: timeOf(interval.end_at),
+    durationMinutes: interval.durationMinutes,
+    cellType: status === "available" || status === "limited" ? "fixed_interval" : "unavailable",
+    status,
+    remainingCapacity,
+    maxCapacity,
+    reasonCodes,
+    conflicts
+  };
+}
+function aggregateStatus(cells) {
+  if (!cells.length)
+    return "unavailable";
+  if (cells.some((cell) => cell.status === "available"))
+    return "available";
+  if (cells.some((cell) => cell.status === "limited"))
+    return "limited";
+  if (cells.some((cell) => cell.status === "past"))
+    return "past";
+  if (cells.some((cell) => cell.status === "full"))
+    return "full";
+  if (cells.some((cell) => cell.status === "conflict"))
+    return "conflict";
+  return "unavailable";
+}
+function uniqueReasonCodes(cells) {
+  return Array.from(new Set(cells.flatMap((cell) => cell.reasonCodes || [])));
+}
+function buildProductOptions(products, cells, query) {
+  const queryProducts = getQueryProducts(products, query);
+  return queryProducts.map((product) => {
+    const productCells = cells.filter((cell) => sameId(cell.productId, product.id));
+    const status = product.kind === "normal" ? "available" : aggregateStatus(productCells);
+    return {
+      productId: product.id,
+      title: resolveProductTitle(product),
+      status,
+      reasonCodes: uniqueReasonCodes(productCells)
+    };
+  });
+}
+function buildResourceOptions(resources, cells, query) {
+  const queryResources = getQueryResources(resources, query);
+  return queryResources.map((resource) => {
+    const resourceCells = cells.filter((cell) => cell.resourceId !== void 0 && sameId(cell.resourceId, resource.id));
+    const bestCell = resourceCells.find((cell) => cell.status === "available") || resourceCells.find((cell) => cell.status === "limited") || resourceCells[0];
+    return {
+      resourceId: resource.id,
+      resourceName: resource.name,
+      resourceFormId: resource.formId,
+      resourceType: resource.resourceType,
+      status: resourceCells.length ? aggregateStatus(resourceCells) : "unavailable",
+      remainingCapacity: bestCell == null ? void 0 : bestCell.remainingCapacity,
+      maxCapacity: (bestCell == null ? void 0 : bestCell.maxCapacity) || resource.capacity,
+      reasonCodes: uniqueReasonCodes(resourceCells)
+    };
+  });
+}
+function buildDateSummary(cells, query) {
+  const dates = query.date ? [query.date] : query.dateRange ? addDays(query.dateRange.start, query.dateRange.end) : Array.from(new Set(cells.map((cell) => cell.date).filter(Boolean)));
+  return dates.map((date) => {
+    const dateCells = cells.filter((cell) => cell.date === date);
+    const availableCount = dateCells.filter((cell) => cell.status === "available" || cell.status === "limited").length;
+    return {
+      date,
+      status: dateCells.length ? aggregateStatus(dateCells) : "unavailable",
+      availableCount,
+      totalCount: dateCells.length
+    };
+  });
+}
+function buildTimeLabels(date, context, query) {
+  if (!date)
+    return [];
+  const slotMinutes = query.slotDurationMinutes || context.slotDurationMinutes;
+  const labels = [];
+  let cursor = toDateTime(date, context.businessStartTime);
+  let end = toDateTime(date, context.businessEndTime);
+  if (!end.isAfter(cursor))
+    end = end.add(1, "day");
+  while (cursor.isBefore(end)) {
+    labels.push(cursor.format("HH:mm"));
+    cursor = cursor.add(slotMinutes, "minute");
+  }
+  return labels;
+}
+function buildGridSlotInterval(product, date, label, context, query) {
+  const slotMinutes = product.kind === "duration" ? Math.max(1, Number(product.durationMinutes || query.slotDurationMinutes || context.slotDurationMinutes)) : query.slotDurationMinutes || context.slotDurationMinutes;
+  const start = toDateTime(date, label);
+  const end = start.add(slotMinutes, "minute");
+  return {
+    id: `${product.id}:${date}:${label}`,
+    productId: product.id,
+    source: product.kind === "session" ? "session" : product.kind === "venue_slot" ? "venue_slot" : "duration",
+    date,
+    start_at: start.toISOString(),
+    end_at: end.toISOString(),
+    durationMinutes: slotMinutes,
+    quantity: Math.max(1, Number(product.quantity || 1)),
+    capacityRequired: Math.max(1, Number(query.pax || product.capacityRequired || 1)),
+    resourceRequirements: product.resourceRequirements || []
+  };
+}
+function buildTimeGrid(context, query, cells) {
+  var _a;
+  const date = query.date || ((_a = query.dateRange) == null ? void 0 : _a.start);
+  const products = getQueryProducts(context.products, query).filter((product) => product.kind !== "normal");
+  const resources = getQueryResources(context.resources, query);
+  const timeLabels = buildTimeLabels(date, context, query);
+  if (!date || !products.length || !resources.length) {
+    return { date, timeLabels, resources: [] };
+  }
+  const rows = resources.map((resource) => {
+    const slots = timeLabels.map((label) => {
+      const product = products[0];
+      const interval = buildGridSlotInterval(product, date, label, context, query);
+      const start = (0, import_dayjs.default)(interval.start_at);
+      const end = (0, import_dayjs.default)(interval.end_at);
+      const cell = cells.find((item) => sameId(item.productId, product.id) && sameId(item.resourceId, resource.id) && item.date === date && (item.status === "available" || item.status === "limited") && containsRange((0, import_dayjs.default)(item.start_at), (0, import_dayjs.default)(item.end_at), start, end));
+      return {
+        startTime: label,
+        endTime: (0, import_dayjs.default)(interval.end_at).format("HH:mm"),
+        status: (cell == null ? void 0 : cell.status) || "unavailable",
+        resourceId: resource.id,
+        productId: product.id,
+        remainingCapacity: cell == null ? void 0 : cell.remainingCapacity,
+        maxCapacity: (cell == null ? void 0 : cell.maxCapacity) || resource.capacity,
+        reasonCodes: (cell == null ? void 0 : cell.reasonCodes) || ["outside_available_range"]
+      };
+    });
+    return {
+      resourceId: resource.id,
+      resourceName: resource.name,
+      resourceFormId: resource.formId,
+      slots
+    };
+  });
+  return { date, timeLabels, resources: rows };
+}
+function queryPlannerAvailability(contextInput, query = {}) {
+  const context = normalizePlannerContext(contextInput);
+  const intervals = buildDemandIntervals(context.products, query, context);
+  const resources = getQueryResources(context.resources, query);
+  const eventsByResource = collectEventsByResource(resources, context.externalEvents);
+  const cells = [];
+  for (const interval of intervals) {
+    const candidateResources = resources.filter((resource) => {
+      const requirements = interval.resourceRequirements || [];
+      if (!requirements.length)
+        return true;
+      return requirements.some((requirement) => matchesResourceRequirement(resource, requirement));
+    });
+    if (!candidateResources.length) {
+      cells.push({
+        key: `${interval.productId}:missing-resource:${interval.start_at}`,
+        productId: interval.productId,
+        date: interval.date,
+        start_at: interval.start_at,
+        end_at: interval.end_at,
+        startTime: timeOf(interval.start_at),
+        endTime: timeOf(interval.end_at),
+        durationMinutes: interval.durationMinutes,
+        cellType: "unavailable",
+        status: "unavailable",
+        reasonCodes: ["missing_resource"],
+        conflicts: [{
+          type: "missing_resource",
+          message: "没有匹配商品需求的资源",
+          productId: interval.productId
+        }]
+      });
+      continue;
+    }
+    candidateResources.forEach((resource) => {
+      if (interval.source === "duration" && !query.startTime) {
+        cells.push(...buildAvailabilityCellsForResource({
+          resource,
+          interval,
+          events: eventsByResource.get(String(resource.id)) || []
+        }));
+        return;
+      }
+      cells.push(evaluateResourceForInterval({ resource, interval, context }));
+    });
+  }
+  return {
+    query,
+    demandIntervals: intervals,
+    productOptions: buildProductOptions(context.products, cells, query),
+    resourceOptions: buildResourceOptions(context.resources, cells, query),
+    dateSummary: buildDateSummary(cells, query),
+    timeGrid: buildTimeGrid(context, query, cells),
+    cells
+  };
+}
+function getIntervalRequirements(interval) {
+  return interval.resourceRequirements.length ? interval.resourceRequirements : [{
+    capacityRequired: interval.capacityRequired,
+    required: true
+  }];
+}
+function buildAssignableCandidateGroups(params) {
+  const { interval, cells, resources } = params;
+  const conflicts = [];
+  const groups = getIntervalRequirements(interval).map((requirement) => {
+    const candidateCells = cells.filter((cell) => {
+      if (!sameId(cell.productId, interval.productId))
+        return false;
+      if (cell.date !== interval.date)
+        return false;
+      if (cell.resourceId === void 0)
+        return false;
+      if (cell.status !== "available" && cell.status !== "limited")
+        return false;
+      const cellStart = (0, import_dayjs.default)(cell.start_at);
+      const cellEnd = (0, import_dayjs.default)(cell.end_at);
+      const intervalStart = (0, import_dayjs.default)(interval.start_at);
+      const intervalEnd = (0, import_dayjs.default)(interval.end_at);
+      return containsRange(cellStart, cellEnd, intervalStart, intervalEnd) || interval.source === "duration";
+    });
+    return candidateCells.flatMap((cell) => {
+      const resource = resources.find((item) => sameId(item.id, cell.resourceId));
+      if (!resource || !matchesResourceRequirement(resource, requirement))
+        return [];
+      return [{ requirement, resource, cell }];
+    });
+  });
+  groups.forEach((group, index) => {
+    var _a, _b;
+    if (group.length)
+      return;
+    conflicts.push({
+      type: "missing_resource",
+      message: "没有匹配商品需求的可用资源",
+      productId: interval.productId,
+      resourceId: (_b = (_a = interval.resourceRequirements[index]) == null ? void 0 : _a.resourceIds) == null ? void 0 : _b[0]
+    });
+  });
+  return { groups, conflicts };
+}
+function combineCandidateGroups(groups) {
+  if (!groups.length || groups.some((group) => group.length === 0))
+    return [];
+  return groups.reduce((combinations, group) => combinations.flatMap((combination) => group.map((candidate) => [...combination, candidate])), [[]]);
+}
+function buildSlotFromCandidates(params) {
+  const { interval, candidates, start, end } = params;
+  if (!end.isAfter(start))
+    return null;
+  const status = candidates.some((candidate) => candidate.cell.status === "limited") ? "limited" : "available";
+  const assignments = candidates.map((candidate) => ({
+    productId: interval.productId,
+    resourceId: candidate.resource.id,
+    start_at: start.toISOString(),
+    end_at: end.toISOString(),
+    capacityRequired: Math.max(1, Number(
+      candidate.requirement.capacityRequired || interval.capacityRequired || 1
+    ))
+  }));
+  return {
+    key: [
+      interval.productId,
+      start.toISOString(),
+      end.toISOString(),
+      ...candidates.map((candidate) => candidate.resource.id)
+    ].join(":"),
+    productId: interval.productId,
+    date: interval.date,
+    start_at: start.toISOString(),
+    end_at: end.toISOString(),
+    startTime: start.format("HH:mm"),
+    endTime: end.format("HH:mm"),
+    durationMinutes: Math.max(1, end.diff(start, "minute")),
+    status,
+    resources: candidates.map((candidate) => ({
+      resourceId: candidate.resource.id,
+      resourceName: candidate.resource.name,
+      resourceFormId: candidate.resource.formId,
+      resourceType: candidate.resource.resourceType,
+      capacityRequired: Math.max(1, Number(
+        candidate.requirement.capacityRequired || interval.capacityRequired || 1
+      )),
+      remainingCapacity: candidate.cell.remainingCapacity,
+      maxCapacity: candidate.cell.maxCapacity
+    })),
+    assignments,
+    conflicts: []
+  };
+}
+function buildSlotsForInterval(params) {
+  const { interval, candidates, query, context } = params;
+  const start = candidates.reduce(
+    (current, candidate) => maxDayjs(current, (0, import_dayjs.default)(candidate.cell.start_at)),
+    (0, import_dayjs.default)(interval.start_at)
+  );
+  const end = candidates.reduce(
+    (current, candidate) => minDayjs(current, (0, import_dayjs.default)(candidate.cell.end_at)),
+    (0, import_dayjs.default)(interval.end_at)
+  );
+  const durationMinutes = Math.max(1, Number(interval.durationMinutes || 1));
+  if (interval.source !== "duration" || query.startTime) {
+    const fixedStart = (0, import_dayjs.default)(interval.start_at);
+    const fixedEnd = (0, import_dayjs.default)(interval.end_at);
+    if (containsRange(start, end, fixedStart, fixedEnd) || candidates.every((candidate) => candidate.cell.cellType === "fixed_interval")) {
+      const slot = buildSlotFromCandidates({
+        interval,
+        candidates,
+        start: fixedStart,
+        end: fixedEnd
+      });
+      return slot ? [slot] : [];
+    }
+    return [];
+  }
+  const stepMinutes = Math.max(1, Number(query.slotDurationMinutes || context.slotDurationMinutes || 30));
+  const slots = [];
+  let cursor = start;
+  while (!cursor.add(durationMinutes, "minute").isAfter(end)) {
+    const slotEnd = cursor.add(durationMinutes, "minute");
+    const slot = buildSlotFromCandidates({
+      interval,
+      candidates,
+      start: cursor,
+      end: slotEnd
+    });
+    if (slot)
+      slots.push(slot);
+    cursor = cursor.add(stepMinutes, "minute");
+  }
+  return slots;
+}
+function resolveAssignableSlots(contextInput, query = {}) {
+  const context = normalizePlannerContext(contextInput);
+  const projection = queryPlannerAvailability(context, query);
+  const resources = getQueryResources(context.resources, query);
+  const slotsByKey = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  projection.demandIntervals.forEach((interval) => {
+    const { groups, conflicts: groupConflicts } = buildAssignableCandidateGroups({
+      interval,
+      cells: projection.cells,
+      resources
+    });
+    conflicts.push(...groupConflicts);
+    combineCandidateGroups(groups).forEach((candidates) => {
+      buildSlotsForInterval({
+        interval,
+        candidates,
+        query,
+        context
+      }).forEach((slot) => {
+        if (!slotsByKey.has(slot.key))
+          slotsByKey.set(slot.key, slot);
+      });
+    });
+  });
+  return {
+    projection,
+    slots: Array.from(slotsByKey.values()),
+    conflicts
+  };
+}
+function autoAssignResources(contextInput, query = {}) {
+  const baseContext = normalizePlannerContext(contextInput);
+  const projection = queryPlannerAvailability(baseContext, query);
+  const assignments = [];
+  const conflicts = [];
+  const missingTimeProductIds = /* @__PURE__ */ new Set();
+  for (const interval of projection.demandIntervals) {
+    if (interval.source === "duration" && !query.startTime) {
+      const productKey = String(interval.productId);
+      if (!missingTimeProductIds.has(productKey)) {
+        missingTimeProductIds.add(productKey);
+        conflicts.push({
+          type: "missing_time",
+          message: "duration 商品需要先确定开始时间后才能自动分配资源",
+          productId: interval.productId
+        });
+      }
+      continue;
+    }
+    const contextWithAssignments = withAssignmentEvents(baseContext, assignments);
+    const candidateResources = getQueryResources(contextWithAssignments.resources, query).filter((resource) => {
+      const requirements = interval.resourceRequirements || [];
+      if (!requirements.length)
+        return true;
+      return requirements.some((requirement) => matchesResourceRequirement(resource, requirement));
+    });
+    const availableCell = candidateResources.map((resource) => evaluateResourceForInterval({
+      resource,
+      interval,
+      context: contextWithAssignments
+    })).find((cell) => cell.status === "available" || cell.status === "limited");
+    if (!(availableCell == null ? void 0 : availableCell.resourceId)) {
+      conflicts.push({
+        type: "missing_resource",
+        message: "无法为商品自动分配可用资源",
+        productId: interval.productId
+      });
+      continue;
+    }
+    assignments.push({
+      productId: interval.productId,
+      resourceId: availableCell.resourceId,
+      start_at: interval.start_at,
+      end_at: interval.end_at,
+      capacityRequired: interval.capacityRequired
+    });
+  }
+  return { assignments, conflicts };
+}
+function withAssignmentEvents(context, assignments) {
+  if (!assignments.length)
+    return context;
+  return {
+    ...context,
+    externalEvents: [
+      ...context.externalEvents,
+      ...assignments.map((assignment) => ({
+        resourceId: assignment.resourceId,
+        start_at: assignment.start_at,
+        end_at: assignment.end_at,
+        pax: assignment.capacityRequired || 1,
+        source: "selection"
+      }))
+    ]
+  };
+}
+function validateAssignments(contextInput, selection) {
+  if (selection.assignments.length > 0) {
+    const context = normalizePlannerContext(contextInput);
+    const conflicts2 = [];
+    for (let index = 0; index < selection.assignments.length; index += 1) {
+      const assignment = selection.assignments[index];
+      const product = context.products.find((item) => sameId(item.id, assignment.productId));
+      const resource = context.resources.find((item) => sameId(item.id, assignment.resourceId));
+      if (!product) {
+        conflicts2.push({
+          type: "missing_resource",
+          message: "assignment 对应的商品不存在",
+          productId: assignment.productId
+        });
+        continue;
+      }
+      if (!resource) {
+        conflicts2.push({
+          type: "missing_resource",
+          message: "assignment 对应的资源不存在",
+          productId: assignment.productId,
+          resourceId: assignment.resourceId
+        });
+        continue;
+      }
+      const start = (0, import_dayjs.default)(assignment.start_at);
+      const end = (0, import_dayjs.default)(assignment.end_at);
+      const interval = {
+        id: `${assignment.productId}:${assignment.resourceId}:${assignment.start_at}:${assignment.end_at}`,
+        productId: assignment.productId,
+        source: product.kind === "session" ? "session" : product.kind === "venue_slot" ? "venue_slot" : "duration",
+        date: start.format("YYYY-MM-DD"),
+        start_at: assignment.start_at,
+        end_at: assignment.end_at,
+        durationMinutes: Math.max(1, end.diff(start, "minute")),
+        quantity: Math.max(1, Number(product.quantity || 1)),
+        capacityRequired: Math.max(1, Number(assignment.capacityRequired || product.capacityRequired || 1)),
+        resourceRequirements: product.resourceRequirements || []
+      };
+      const cell = evaluateResourceForInterval({ resource, interval, context });
+      if (cell.status !== "available" && cell.status !== "limited") {
+        conflicts2.push(...cell.conflicts);
+      }
+      const priorContext = withAssignmentEvents(
+        context,
+        selection.assignments.slice(0, index)
+      );
+      const selfConflictCell = evaluateResourceForInterval({
+        resource,
+        interval,
+        context: priorContext
+      });
+      if (selfConflictCell.status !== "available" && selfConflictCell.status !== "limited") {
+        conflicts2.push(...selfConflictCell.conflicts.map((conflict) => ({
+          ...conflict,
+          type: "cart_overlap",
+          message: "本次选择中存在资源时间冲突"
+        })));
+      }
+    }
+    return {
+      ok: conflicts2.length === 0,
+      conflicts: conflicts2
+    };
+  }
+  const projection = queryPlannerAvailability(contextInput, {
+    productIds: selection.productIds,
+    date: selection.date,
+    startTime: selection.startTime,
+    endTime: selection.endTime,
+    resourceIds: selection.resourceIds,
+    mode: selection.mode
+  });
+  const conflicts = projection.cells.filter((cell) => cell.status !== "available" && cell.status !== "limited").flatMap((cell) => cell.conflicts);
+  return {
+    ok: conflicts.length === 0,
+    conflicts
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_RESOURCE_PLANNER_CONTEXT,
+  DEFAULT_RESOURCE_PLANNER_SELECTION,
+  autoAssignResources,
+  buildDemandIntervals,
+  evaluateResourceForInterval,
+  normalizePlannerContext,
+  queryPlannerAvailability,
+  resolveAssignableSlots,
+  validateAssignments
+});