@pisell/pisellos 0.0.568 → 0.10.1

package/dist/modules/ResourcePlanner/planner.js

@@ -0,0 +1,1069 @@
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
+function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+import dayjs from 'dayjs';
+export var DEFAULT_RESOURCE_PLANNER_CONTEXT = {
+  products: [],
+  resources: [],
+  externalEvents: [],
+  slotDurationMinutes: 30,
+  businessStartTime: '09:00',
+  businessEndTime: '18:00'
+};
+export var DEFAULT_RESOURCE_PLANNER_SELECTION = {
+  productIds: [],
+  resourceIds: [],
+  assignments: []
+};
+export function normalizePlannerContext() {
+  var input = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  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 dayjs(value).format('YYYY-MM-DD');
+}
+function timeOf(value) {
+  return dayjs(value).format('HH:mm');
+}
+function toDateTime(date, time) {
+  if (/^\d{4}-\d{2}-\d{2}/.test(time)) return dayjs(time);
+  return dayjs("".concat(date, " ").concat(time.length === 5 ? "".concat(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) {
+  var result = [];
+  var cursor = dayjs(start);
+  var finalDay = dayjs(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 _query$productIds;
+  if (!((_query$productIds = query.productIds) !== null && _query$productIds !== void 0 && _query$productIds.length)) return products;
+  return products.filter(function (product) {
+    return query.productIds.some(function (id) {
+      return sameId(id, product.id);
+    });
+  });
+}
+function getQueryResources(resources, query) {
+  var _query$resourceIds;
+  if (!((_query$resourceIds = query.resourceIds) !== null && _query$resourceIds !== void 0 && _query$resourceIds.length)) return resources;
+  return resources.filter(function (resource) {
+    return query.resourceIds.some(function (id) {
+      return sameId(id, resource.id);
+    });
+  });
+}
+function matchesResourceRequirement(resource, requirement) {
+  var _requirement$resource;
+  var isFormlessCandidate = resource.formId == null;
+  var formMatches = requirement.formId == null || isFormlessCandidate || sameId(requirement.formId, resource.formId);
+  var resourceMatches = !((_requirement$resource = requirement.resourceIds) !== null && _requirement$resource !== void 0 && _requirement$resource.length) || isFormlessCandidate || requirement.resourceIds.some(function (id) {
+    return sameId(id, resource.id);
+  });
+  return formMatches && resourceMatches;
+}
+function resolveProductTitle(product) {
+  var _product$raw, _product$raw2, _product$raw3;
+  var rawTitle = ((_product$raw = product.raw) === null || _product$raw === void 0 ? void 0 : _product$raw.title) || ((_product$raw2 = product.raw) === null || _product$raw2 === void 0 ? void 0 : _product$raw2.name) || ((_product$raw3 = product.raw) === null || _product$raw3 === void 0 ? void 0 : _product$raw3.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 undefined;
+}
+export function buildDemandIntervals(products, query, context) {
+  var dates = query.date ? [query.date] : query.dateRange ? addDays(query.dateRange.start, query.dateRange.end) : [];
+  var selectedProducts = getQueryProducts(products, query);
+  var intervals = [];
+  var _iterator = _createForOfIteratorHelper(selectedProducts),
+    _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done;) {
+      var product = _step.value;
+      var quantity = Math.max(1, Number(product.quantity || 1));
+      var capacityRequired = Math.max(1, Number(query.pax || product.capacityRequired || 1));
+      var requirements = product.resourceRequirements || [];
+      if (product.kind === 'session' || product.kind === 'venue_slot') {
+        var schedules = product.schedule || [];
+        var _iterator2 = _createForOfIteratorHelper(schedules),
+          _step2;
+        try {
+          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+            var schedule = _step2.value;
+            var scheduleDate = dateOf(schedule.start_at);
+            if (dates.length > 0 && !dates.includes(scheduleDate)) continue;
+            var start = dayjs(schedule.start_at);
+            var end = dayjs(schedule.end_at);
+            intervals.push({
+              id: "".concat(product.id, ":").concat(start.toISOString(), ":").concat(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: quantity,
+              capacityRequired: capacityRequired,
+              resourceRequirements: requirements
+            });
+          }
+        } catch (err) {
+          _iterator2.e(err);
+        } finally {
+          _iterator2.f();
+        }
+        continue;
+      }
+      if (product.kind === 'duration') {
+        var duration = Math.max(1, Number(product.durationMinutes || 30));
+        var _iterator3 = _createForOfIteratorHelper(dates),
+          _step3;
+        try {
+          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+            var currentDate = _step3.value;
+            var _start = query.startTime ? toDateTime(currentDate, query.startTime) : toDateTime(currentDate, (context === null || context === void 0 ? void 0 : context.businessStartTime) || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessStartTime);
+            var _end = query.startTime && query.endTime ? toDateTime(currentDate, query.endTime) : query.startTime ? _start.add(duration, 'minute') : toDateTime(currentDate, (context === null || context === void 0 ? void 0 : context.businessEndTime) || DEFAULT_RESOURCE_PLANNER_CONTEXT.businessEndTime);
+            if (!_end.isAfter(_start)) _end = _end.add(1, 'day');
+            intervals.push({
+              id: "".concat(product.id, ":").concat(currentDate, ":").concat(query.startTime || 'range'),
+              productId: product.id,
+              source: 'duration',
+              date: currentDate,
+              start_at: _start.toISOString(),
+              end_at: _end.toISOString(),
+              durationMinutes: duration,
+              quantity: quantity,
+              capacityRequired: capacityRequired,
+              resourceRequirements: requirements
+            });
+          }
+        } catch (err) {
+          _iterator3.e(err);
+        } finally {
+          _iterator3.f();
+        }
+      }
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
+  }
+  return intervals;
+}
+function getEventsForResource(resource, contextEvents) {
+  var embeddedEvents = resource.times.flatMap(function (time) {
+    return time.event_list || [];
+  });
+  return [].concat(_toConsumableArray(embeddedEvents), _toConsumableArray(contextEvents.filter(function (event) {
+    var _event$resourceId;
+    return sameId((_event$resourceId = event.resourceId) !== null && _event$resourceId !== void 0 ? _event$resourceId : event.resource_id, resource.id);
+  }))).filter(Boolean);
+}
+function collectEventsByResource(resources, contextEvents) {
+  var eventsByResource = new Map();
+  resources.forEach(function (resource) {
+    eventsByResource.set(String(resource.id), getEventsForResource(resource, contextEvents));
+  });
+  return eventsByResource;
+}
+function getWorkingSegmentsForInterval(resource, interval) {
+  var intervalStart = dayjs(interval.start_at);
+  var intervalEnd = dayjs(interval.end_at);
+  return resource.times.map(function (time) {
+    var start = maxDayjs(dayjs(time.start_at), intervalStart);
+    var end = minDayjs(dayjs(time.end_at), intervalEnd);
+    return {
+      start: start,
+      end: end
+    };
+  }).filter(function (segment) {
+    return segment.end.isAfter(segment.start);
+  });
+}
+function mergeBusySegments(segments) {
+  var sorted = _toConsumableArray(segments).filter(function (segment) {
+    return segment.end.isAfter(segment.start);
+  }).sort(function (left, right) {
+    return left.start.valueOf() - right.start.valueOf();
+  });
+  var merged = [];
+  sorted.forEach(function (segment) {
+    var previous = merged[merged.length - 1];
+    if (previous && !segment.start.isAfter(previous.end)) {
+      previous.end = maxDayjs(previous.end, segment.end);
+    } else {
+      merged.push(_objectSpread({}, segment));
+    }
+  });
+  return merged;
+}
+function subtractBusyIntervals(workingSegments, events) {
+  var available = [];
+  workingSegments.forEach(function (working) {
+    var busySegments = mergeBusySegments(events.filter(function (event) {
+      return overlaps(working.start, working.end, dayjs(event.start_at), dayjs(event.end_at));
+    }).map(function (event) {
+      return {
+        start: maxDayjs(dayjs(event.start_at), working.start),
+        end: minDayjs(dayjs(event.end_at), working.end)
+      };
+    }));
+    var cursor = working.start;
+    busySegments.forEach(function (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) {
+  var workingSegments = params.workingSegments,
+    events = params.events,
+    maxCapacity = params.maxCapacity,
+    requiredCapacity = params.requiredCapacity;
+  var ranges = [];
+  workingSegments.forEach(function (working) {
+    var boundaries = new Map([[working.start.valueOf(), working.start], [working.end.valueOf(), working.end]]);
+    events.forEach(function (event) {
+      var eventStart = dayjs(event.start_at);
+      var eventEnd = dayjs(event.end_at);
+      if (!overlaps(working.start, working.end, eventStart, eventEnd)) return;
+      var clippedStart = maxDayjs(eventStart, working.start);
+      var clippedEnd = minDayjs(eventEnd, working.end);
+      boundaries.set(clippedStart.valueOf(), clippedStart);
+      boundaries.set(clippedEnd.valueOf(), clippedEnd);
+    });
+    var points = Array.from(boundaries.values()).sort(function (left, right) {
+      return left.valueOf() - right.valueOf();
+    });
+    var _loop = function _loop() {
+        var start = points[index];
+        var end = points[index + 1];
+        if (!end.isAfter(start)) return 0; // continue
+        var usedCapacity = events.filter(function (event) {
+          return overlaps(start, end, dayjs(event.start_at), dayjs(event.end_at));
+        }).reduce(function (sum, event) {
+          return sum + Math.max(1, Number(event.pax || 1));
+        }, 0);
+        var remainingCapacity = Math.max(0, maxCapacity - usedCapacity);
+        if (remainingCapacity < requiredCapacity) return 0; // continue
+        var status = remainingCapacity < maxCapacity ? 'limited' : 'available';
+        var 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: start,
+            end: end,
+            remainingCapacity: remainingCapacity,
+            maxCapacity: maxCapacity,
+            status: status
+          });
+        }
+      },
+      _ret;
+    for (var index = 0; index < points.length - 1; index += 1) {
+      _ret = _loop();
+      if (_ret === 0) continue;
+    }
+  });
+  return ranges;
+}
+function rangeFitsDuration(segment, durationMinutes) {
+  return segment.end.diff(segment.start, 'minute') >= durationMinutes;
+}
+function makeAvailabilityRangeCell(params) {
+  var _segment$remainingCap;
+  var interval = params.interval,
+    resource = params.resource,
+    segment = params.segment;
+  var maxCapacity = Math.max(1, Number(segment.maxCapacity || resource.capacity || 1));
+  var remainingCapacity = resource.resourceType === 'single' ? 1 : Math.max(0, Number((_segment$remainingCap = segment.remainingCapacity) !== null && _segment$remainingCap !== void 0 ? _segment$remainingCap : maxCapacity));
+  var status = resource.resourceType === 'single' ? 'available' : segment.status || (remainingCapacity < maxCapacity ? 'limited' : 'available');
+  return {
+    key: "".concat(interval.productId, ":").concat(resource.id, ":").concat(segment.start.toISOString(), ":").concat(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: status,
+    remainingCapacity: remainingCapacity,
+    maxCapacity: maxCapacity,
+    reasonCodes: [],
+    conflicts: []
+  };
+}
+function buildAvailabilityCellsForResource(params) {
+  var resource = params.resource,
+    interval = params.interval,
+    events = params.events;
+  var requiredCapacity = Math.max(1, Number(interval.capacityRequired || 1));
+  var durationMinutes = Math.max(1, Number(interval.durationMinutes || 1));
+  var maxCapacity = Math.max(1, Number(resource.capacity || 1));
+  var workingSegments = getWorkingSegmentsForInterval(resource, interval);
+  var now = dayjs();
+  workingSegments = workingSegments.map(function (segment) {
+    return {
+      start: segment.end.isAfter(now) ? maxDayjs(segment.start, now) : segment.start,
+      end: segment.end
+    };
+  }).filter(function (segment) {
+    return segment.end.isAfter(segment.start);
+  });
+  var availableSegments = resource.resourceType === 'single' ? subtractBusyIntervals(workingSegments, events).map(function (segment) {
+    return _objectSpread(_objectSpread({}, segment), {}, {
+      remainingCapacity: 1,
+      maxCapacity: 1,
+      status: 'available'
+    });
+  }) : buildCapacityRanges({
+    workingSegments: workingSegments,
+    events: events,
+    maxCapacity: maxCapacity,
+    requiredCapacity: requiredCapacity
+  });
+  return availableSegments.filter(function (segment) {
+    return rangeFitsDuration(segment, durationMinutes);
+  }).map(function (segment) {
+    return makeAvailabilityRangeCell({
+      interval: interval,
+      resource: resource,
+      segment: segment
+    });
+  });
+}
+export function evaluateResourceForInterval(params) {
+  var resource = params.resource,
+    interval = params.interval,
+    context = params.context;
+  var start = dayjs(interval.start_at);
+  var end = dayjs(interval.end_at);
+  var conflicts = [];
+  var reasonCodes = [];
+  var maxCapacity = Math.max(1, Number(resource.capacity || 1));
+  var requiredCapacity = Math.max(1, Number(interval.capacityRequired || 1));
+  if (start.isBefore(dayjs())) {
+    reasonCodes.push('past');
+    conflicts.push({
+      type: 'past',
+      message: '时间已过期',
+      resourceId: resource.id,
+      productId: interval.productId
+    });
+  }
+  var insideResourceTime = resource.times.some(function (time) {
+    return containsRange(dayjs(time.start_at), dayjs(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
+    });
+  }
+  var events = getEventsForResource(resource, context.externalEvents);
+  var overlapping = events.filter(function (event) {
+    return overlaps(start, end, dayjs(event.start_at), dayjs(event.end_at));
+  });
+  var usedCapacity = resource.resourceType === 'single' ? overlapping.length : overlapping.reduce(function (sum, event) {
+    return sum + Math.max(1, Number(event.pax || 1));
+  }, 0);
+  var 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.apply(conflicts, _toConsumableArray(overlapping.map(function (event) {
+      return {
+        type: 'remote_event_overlap',
+        message: '资源时间被已有预约占用',
+        event: 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
+    });
+  }
+  var 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: "".concat(interval.productId, ":").concat(resource.id, ":").concat(interval.start_at, ":").concat(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: status,
+    remainingCapacity: remainingCapacity,
+    maxCapacity: maxCapacity,
+    reasonCodes: reasonCodes,
+    conflicts: conflicts
+  };
+}
+function aggregateStatus(cells) {
+  if (!cells.length) return 'unavailable';
+  if (cells.some(function (cell) {
+    return cell.status === 'available';
+  })) return 'available';
+  if (cells.some(function (cell) {
+    return cell.status === 'limited';
+  })) return 'limited';
+  if (cells.some(function (cell) {
+    return cell.status === 'past';
+  })) return 'past';
+  if (cells.some(function (cell) {
+    return cell.status === 'full';
+  })) return 'full';
+  if (cells.some(function (cell) {
+    return cell.status === 'conflict';
+  })) return 'conflict';
+  return 'unavailable';
+}
+function uniqueReasonCodes(cells) {
+  return Array.from(new Set(cells.flatMap(function (cell) {
+    return cell.reasonCodes || [];
+  })));
+}
+function buildProductOptions(products, cells, query) {
+  var queryProducts = getQueryProducts(products, query);
+  return queryProducts.map(function (product) {
+    var productCells = cells.filter(function (cell) {
+      return sameId(cell.productId, product.id);
+    });
+    var status = product.kind === 'normal' ? 'available' : aggregateStatus(productCells);
+    return {
+      productId: product.id,
+      title: resolveProductTitle(product),
+      status: status,
+      reasonCodes: uniqueReasonCodes(productCells)
+    };
+  });
+}
+function buildResourceOptions(resources, cells, query) {
+  var queryResources = getQueryResources(resources, query);
+  return queryResources.map(function (resource) {
+    var resourceCells = cells.filter(function (cell) {
+      return cell.resourceId !== undefined && sameId(cell.resourceId, resource.id);
+    });
+    var bestCell = resourceCells.find(function (cell) {
+      return cell.status === 'available';
+    }) || resourceCells.find(function (cell) {
+      return 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 || bestCell === void 0 ? void 0 : bestCell.remainingCapacity,
+      maxCapacity: (bestCell === null || bestCell === void 0 ? void 0 : bestCell.maxCapacity) || resource.capacity,
+      reasonCodes: uniqueReasonCodes(resourceCells)
+    };
+  });
+}
+function buildDateSummary(cells, query) {
+  var dates = query.date ? [query.date] : query.dateRange ? addDays(query.dateRange.start, query.dateRange.end) : Array.from(new Set(cells.map(function (cell) {
+    return cell.date;
+  }).filter(Boolean)));
+  return dates.map(function (date) {
+    var dateCells = cells.filter(function (cell) {
+      return cell.date === date;
+    });
+    var availableCount = dateCells.filter(function (cell) {
+      return cell.status === 'available' || cell.status === 'limited';
+    }).length;
+    return {
+      date: date,
+      status: dateCells.length ? aggregateStatus(dateCells) : 'unavailable',
+      availableCount: availableCount,
+      totalCount: dateCells.length
+    };
+  });
+}
+function buildTimeLabels(date, context, query) {
+  if (!date) return [];
+  var slotMinutes = query.slotDurationMinutes || context.slotDurationMinutes;
+  var labels = [];
+  var cursor = toDateTime(date, context.businessStartTime);
+  var 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) {
+  var slotMinutes = product.kind === 'duration' ? Math.max(1, Number(product.durationMinutes || query.slotDurationMinutes || context.slotDurationMinutes)) : query.slotDurationMinutes || context.slotDurationMinutes;
+  var start = toDateTime(date, label);
+  var end = start.add(slotMinutes, 'minute');
+  return {
+    id: "".concat(product.id, ":").concat(date, ":").concat(label),
+    productId: product.id,
+    source: product.kind === 'session' ? 'session' : product.kind === 'venue_slot' ? 'venue_slot' : 'duration',
+    date: 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 _query$dateRange;
+  var date = query.date || ((_query$dateRange = query.dateRange) === null || _query$dateRange === void 0 ? void 0 : _query$dateRange.start);
+  var products = getQueryProducts(context.products, query).filter(function (product) {
+    return product.kind !== 'normal';
+  });
+  var resources = getQueryResources(context.resources, query);
+  var timeLabels = buildTimeLabels(date, context, query);
+  if (!date || !products.length || !resources.length) {
+    return {
+      date: date,
+      timeLabels: timeLabels,
+      resources: []
+    };
+  }
+  var rows = resources.map(function (resource) {
+    var slots = timeLabels.map(function (label) {
+      var product = products[0];
+      var interval = buildGridSlotInterval(product, date, label, context, query);
+      var start = dayjs(interval.start_at);
+      var end = dayjs(interval.end_at);
+      var cell = cells.find(function (item) {
+        return sameId(item.productId, product.id) && sameId(item.resourceId, resource.id) && item.date === date && (item.status === 'available' || item.status === 'limited') && containsRange(dayjs(item.start_at), dayjs(item.end_at), start, end);
+      });
+      return {
+        startTime: label,
+        endTime: dayjs(interval.end_at).format('HH:mm'),
+        status: (cell === null || cell === void 0 ? void 0 : cell.status) || 'unavailable',
+        resourceId: resource.id,
+        productId: product.id,
+        remainingCapacity: cell === null || cell === void 0 ? void 0 : cell.remainingCapacity,
+        maxCapacity: (cell === null || cell === void 0 ? void 0 : cell.maxCapacity) || resource.capacity,
+        reasonCodes: (cell === null || cell === void 0 ? void 0 : cell.reasonCodes) || ['outside_available_range']
+      };
+    });
+    return {
+      resourceId: resource.id,
+      resourceName: resource.name,
+      resourceFormId: resource.formId,
+      slots: slots
+    };
+  });
+  return {
+    date: date,
+    timeLabels: timeLabels,
+    resources: rows
+  };
+}
+export function queryPlannerAvailability(contextInput) {
+  var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var context = normalizePlannerContext(contextInput);
+  var intervals = buildDemandIntervals(context.products, query, context);
+  var resources = getQueryResources(context.resources, query);
+  var eventsByResource = collectEventsByResource(resources, context.externalEvents);
+  var cells = [];
+  var _iterator4 = _createForOfIteratorHelper(intervals),
+    _step4;
+  try {
+    var _loop2 = function _loop2() {
+      var interval = _step4.value;
+      var candidateResources = resources.filter(function (resource) {
+        var requirements = interval.resourceRequirements || [];
+        if (!requirements.length) return true;
+        return requirements.some(function (requirement) {
+          return matchesResourceRequirement(resource, requirement);
+        });
+      });
+      if (!candidateResources.length) {
+        cells.push({
+          key: "".concat(interval.productId, ":missing-resource:").concat(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
+          }]
+        });
+        return 1; // continue
+      }
+      candidateResources.forEach(function (resource) {
+        if (interval.source === 'duration' && !query.startTime) {
+          cells.push.apply(cells, _toConsumableArray(buildAvailabilityCellsForResource({
+            resource: resource,
+            interval: interval,
+            events: eventsByResource.get(String(resource.id)) || []
+          })));
+          return;
+        }
+        cells.push(evaluateResourceForInterval({
+          resource: resource,
+          interval: interval,
+          context: context
+        }));
+      });
+    };
+    for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+      if (_loop2()) continue;
+    }
+  } catch (err) {
+    _iterator4.e(err);
+  } finally {
+    _iterator4.f();
+  }
+  return {
+    query: 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: cells
+  };
+}
+function getIntervalRequirements(interval) {
+  return interval.resourceRequirements.length ? interval.resourceRequirements : [{
+    capacityRequired: interval.capacityRequired,
+    required: true
+  }];
+}
+function buildAssignableCandidateGroups(params) {
+  var interval = params.interval,
+    cells = params.cells,
+    resources = params.resources;
+  var conflicts = [];
+  var groups = getIntervalRequirements(interval).map(function (requirement) {
+    var candidateCells = cells.filter(function (cell) {
+      if (!sameId(cell.productId, interval.productId)) return false;
+      if (cell.date !== interval.date) return false;
+      if (cell.resourceId === undefined) return false;
+      if (cell.status !== 'available' && cell.status !== 'limited') return false;
+      var cellStart = dayjs(cell.start_at);
+      var cellEnd = dayjs(cell.end_at);
+      var intervalStart = dayjs(interval.start_at);
+      var intervalEnd = dayjs(interval.end_at);
+      return containsRange(cellStart, cellEnd, intervalStart, intervalEnd) || interval.source === 'duration';
+    });
+    return candidateCells.flatMap(function (cell) {
+      var resource = resources.find(function (item) {
+        return sameId(item.id, cell.resourceId);
+      });
+      if (!resource || !matchesResourceRequirement(resource, requirement)) return [];
+      return [{
+        requirement: requirement,
+        resource: resource,
+        cell: cell
+      }];
+    });
+  });
+  groups.forEach(function (group, index) {
+    var _interval$resourceReq;
+    if (group.length) return;
+    conflicts.push({
+      type: 'missing_resource',
+      message: '没有匹配商品需求的可用资源',
+      productId: interval.productId,
+      resourceId: (_interval$resourceReq = interval.resourceRequirements[index]) === null || _interval$resourceReq === void 0 || (_interval$resourceReq = _interval$resourceReq.resourceIds) === null || _interval$resourceReq === void 0 ? void 0 : _interval$resourceReq[0]
+    });
+  });
+  return {
+    groups: groups,
+    conflicts: conflicts
+  };
+}
+function combineCandidateGroups(groups) {
+  if (!groups.length || groups.some(function (group) {
+    return group.length === 0;
+  })) return [];
+  return groups.reduce(function (combinations, group) {
+    return combinations.flatMap(function (combination) {
+      return group.map(function (candidate) {
+        return [].concat(_toConsumableArray(combination), [candidate]);
+      });
+    });
+  }, [[]]);
+}
+function buildSlotFromCandidates(params) {
+  var interval = params.interval,
+    candidates = params.candidates,
+    start = params.start,
+    end = params.end;
+  if (!end.isAfter(start)) return null;
+  var status = candidates.some(function (candidate) {
+    return candidate.cell.status === 'limited';
+  }) ? 'limited' : 'available';
+  var assignments = candidates.map(function (candidate) {
+    return {
+      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()].concat(_toConsumableArray(candidates.map(function (candidate) {
+      return 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: status,
+    resources: candidates.map(function (candidate) {
+      return {
+        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: assignments,
+    conflicts: []
+  };
+}
+function buildSlotsForInterval(params) {
+  var interval = params.interval,
+    candidates = params.candidates,
+    query = params.query,
+    context = params.context;
+  var start = candidates.reduce(function (current, candidate) {
+    return maxDayjs(current, dayjs(candidate.cell.start_at));
+  }, dayjs(interval.start_at));
+  var end = candidates.reduce(function (current, candidate) {
+    return minDayjs(current, dayjs(candidate.cell.end_at));
+  }, dayjs(interval.end_at));
+  var durationMinutes = Math.max(1, Number(interval.durationMinutes || 1));
+  if (interval.source !== 'duration' || query.startTime) {
+    var fixedStart = dayjs(interval.start_at);
+    var fixedEnd = dayjs(interval.end_at);
+    if (containsRange(start, end, fixedStart, fixedEnd) || candidates.every(function (candidate) {
+      return candidate.cell.cellType === 'fixed_interval';
+    })) {
+      var slot = buildSlotFromCandidates({
+        interval: interval,
+        candidates: candidates,
+        start: fixedStart,
+        end: fixedEnd
+      });
+      return slot ? [slot] : [];
+    }
+    return [];
+  }
+  var stepMinutes = Math.max(1, Number(query.slotDurationMinutes || context.slotDurationMinutes || 30));
+  var slots = [];
+  var cursor = start;
+  while (!cursor.add(durationMinutes, 'minute').isAfter(end)) {
+    var slotEnd = cursor.add(durationMinutes, 'minute');
+    var _slot = buildSlotFromCandidates({
+      interval: interval,
+      candidates: candidates,
+      start: cursor,
+      end: slotEnd
+    });
+    if (_slot) slots.push(_slot);
+    cursor = cursor.add(stepMinutes, 'minute');
+  }
+  return slots;
+}
+export function resolveAssignableSlots(contextInput) {
+  var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var context = normalizePlannerContext(contextInput);
+  var projection = queryPlannerAvailability(context, query);
+  var resources = getQueryResources(context.resources, query);
+  var slotsByKey = new Map();
+  var conflicts = [];
+  projection.demandIntervals.forEach(function (interval) {
+    var _buildAssignableCandi = buildAssignableCandidateGroups({
+        interval: interval,
+        cells: projection.cells,
+        resources: resources
+      }),
+      groups = _buildAssignableCandi.groups,
+      groupConflicts = _buildAssignableCandi.conflicts;
+    conflicts.push.apply(conflicts, _toConsumableArray(groupConflicts));
+    combineCandidateGroups(groups).forEach(function (candidates) {
+      buildSlotsForInterval({
+        interval: interval,
+        candidates: candidates,
+        query: query,
+        context: context
+      }).forEach(function (slot) {
+        if (!slotsByKey.has(slot.key)) slotsByKey.set(slot.key, slot);
+      });
+    });
+  });
+  return {
+    projection: projection,
+    slots: Array.from(slotsByKey.values()),
+    conflicts: conflicts
+  };
+}
+export function autoAssignResources(contextInput) {
+  var query = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var baseContext = normalizePlannerContext(contextInput);
+  var projection = queryPlannerAvailability(baseContext, query);
+  var assignments = [];
+  var conflicts = [];
+  var missingTimeProductIds = new Set();
+  var _iterator5 = _createForOfIteratorHelper(projection.demandIntervals),
+    _step5;
+  try {
+    var _loop3 = function _loop3() {
+        var interval = _step5.value;
+        if (interval.source === 'duration' && !query.startTime) {
+          var productKey = String(interval.productId);
+          if (!missingTimeProductIds.has(productKey)) {
+            missingTimeProductIds.add(productKey);
+            conflicts.push({
+              type: 'missing_time',
+              message: 'duration 商品需要先确定开始时间后才能自动分配资源',
+              productId: interval.productId
+            });
+          }
+          return 0; // continue
+        }
+        var contextWithAssignments = withAssignmentEvents(baseContext, assignments);
+        var candidateResources = getQueryResources(contextWithAssignments.resources, query).filter(function (resource) {
+          var requirements = interval.resourceRequirements || [];
+          if (!requirements.length) return true;
+          return requirements.some(function (requirement) {
+            return matchesResourceRequirement(resource, requirement);
+          });
+        });
+        var availableCell = candidateResources.map(function (resource) {
+          return evaluateResourceForInterval({
+            resource: resource,
+            interval: interval,
+            context: contextWithAssignments
+          });
+        }).find(function (cell) {
+          return cell.status === 'available' || cell.status === 'limited';
+        });
+        if (!(availableCell !== null && availableCell !== void 0 && availableCell.resourceId)) {
+          conflicts.push({
+            type: 'missing_resource',
+            message: '无法为商品自动分配可用资源',
+            productId: interval.productId
+          });
+          return 0; // continue
+        }
+        assignments.push({
+          productId: interval.productId,
+          resourceId: availableCell.resourceId,
+          start_at: interval.start_at,
+          end_at: interval.end_at,
+          capacityRequired: interval.capacityRequired
+        });
+      },
+      _ret2;
+    for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+      _ret2 = _loop3();
+      if (_ret2 === 0) continue;
+    }
+  } catch (err) {
+    _iterator5.e(err);
+  } finally {
+    _iterator5.f();
+  }
+  return {
+    assignments: assignments,
+    conflicts: conflicts
+  };
+}
+function withAssignmentEvents(context, assignments) {
+  if (!assignments.length) return context;
+  return _objectSpread(_objectSpread({}, context), {}, {
+    externalEvents: [].concat(_toConsumableArray(context.externalEvents), _toConsumableArray(assignments.map(function (assignment) {
+      return {
+        resourceId: assignment.resourceId,
+        start_at: assignment.start_at,
+        end_at: assignment.end_at,
+        pax: assignment.capacityRequired || 1,
+        source: 'selection'
+      };
+    })))
+  });
+}
+export function validateAssignments(contextInput, selection) {
+  if (selection.assignments.length > 0) {
+    var context = normalizePlannerContext(contextInput);
+    var _conflicts = [];
+    var _loop4 = function _loop4() {
+        var assignment = selection.assignments[index];
+        var product = context.products.find(function (item) {
+          return sameId(item.id, assignment.productId);
+        });
+        var resource = context.resources.find(function (item) {
+          return sameId(item.id, assignment.resourceId);
+        });
+        if (!product) {
+          _conflicts.push({
+            type: 'missing_resource',
+            message: 'assignment 对应的商品不存在',
+            productId: assignment.productId
+          });
+          return 0; // continue
+        }
+        if (!resource) {
+          _conflicts.push({
+            type: 'missing_resource',
+            message: 'assignment 对应的资源不存在',
+            productId: assignment.productId,
+            resourceId: assignment.resourceId
+          });
+          return 0; // continue
+        }
+        var start = dayjs(assignment.start_at);
+        var end = dayjs(assignment.end_at);
+        var interval = {
+          id: "".concat(assignment.productId, ":").concat(assignment.resourceId, ":").concat(assignment.start_at, ":").concat(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 || []
+        };
+        var cell = evaluateResourceForInterval({
+          resource: resource,
+          interval: interval,
+          context: context
+        });
+        if (cell.status !== 'available' && cell.status !== 'limited') {
+          _conflicts.push.apply(_conflicts, _toConsumableArray(cell.conflicts));
+        }
+        var priorContext = withAssignmentEvents(context, selection.assignments.slice(0, index));
+        var selfConflictCell = evaluateResourceForInterval({
+          resource: resource,
+          interval: interval,
+          context: priorContext
+        });
+        if (selfConflictCell.status !== 'available' && selfConflictCell.status !== 'limited') {
+          _conflicts.push.apply(_conflicts, _toConsumableArray(selfConflictCell.conflicts.map(function (conflict) {
+            return _objectSpread(_objectSpread({}, conflict), {}, {
+              type: 'cart_overlap',
+              message: '本次选择中存在资源时间冲突'
+            });
+          })));
+        }
+      },
+      _ret3;
+    for (var index = 0; index < selection.assignments.length; index += 1) {
+      _ret3 = _loop4();
+      if (_ret3 === 0) continue;
+    }
+    return {
+      ok: _conflicts.length === 0,
+      conflicts: _conflicts
+    };
+  }
+  var projection = queryPlannerAvailability(contextInput, {
+    productIds: selection.productIds,
+    date: selection.date,
+    startTime: selection.startTime,
+    endTime: selection.endTime,
+    resourceIds: selection.resourceIds,
+    mode: selection.mode
+  });
+  var conflicts = projection.cells.filter(function (cell) {
+    return cell.status !== 'available' && cell.status !== 'limited';
+  }).flatMap(function (cell) {
+    return cell.conflicts;
+  });
+  return {
+    ok: conflicts.length === 0,
+    conflicts: conflicts
+  };
+}