@pisell/pisellos 0.0.568 → 0.0.569

package/lib/modules/ResourcePlanner/planner.js

@@ -0,0 +1,895 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DEFAULT_RESOURCE_PLANNER_SELECTION = exports.DEFAULT_RESOURCE_PLANNER_CONTEXT = void 0;
+exports.autoAssignResources = autoAssignResources;
+exports.buildDemandIntervals = buildDemandIntervals;
+exports.evaluateResourceForInterval = evaluateResourceForInterval;
+exports.normalizePlannerContext = normalizePlannerContext;
+exports.queryPlannerAvailability = queryPlannerAvailability;
+exports.resolveAssignableSlots = resolveAssignableSlots;
+exports.validateAssignments = validateAssignments;
+var _dayjs = _interopRequireDefault(require("dayjs"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_RESOURCE_PLANNER_CONTEXT = exports.DEFAULT_RESOURCE_PLANNER_CONTEXT = {
+  products: [],
+  resources: [],
+  externalEvents: [],
+  slotDurationMinutes: 30,
+  businessStartTime: '09:00',
+  businessEndTime: '18:00'
+};
+const DEFAULT_RESOURCE_PLANNER_SELECTION = exports.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, _dayjs.default)(value).format('YYYY-MM-DD');
+}
+function timeOf(value) {
+  return (0, _dayjs.default)(value).format('HH:mm');
+}
+function toDateTime(date, time) {
+  if (/^\d{4}-\d{2}-\d{2}/.test(time)) return (0, _dayjs.default)(time);
+  return (0, _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, _dayjs.default)(start);
+  const finalDay = (0, _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) {
+  if (!query.productIds?.length) return products;
+  return products.filter(product => query.productIds.some(id => sameId(id, product.id)));
+}
+function getQueryResources(resources, query) {
+  if (!query.resourceIds?.length) return resources;
+  return resources.filter(resource => query.resourceIds.some(id => sameId(id, resource.id)));
+}
+function matchesResourceRequirement(resource, requirement) {
+  const isFormlessCandidate = resource.formId == null;
+  const formMatches = requirement.formId == null || isFormlessCandidate || sameId(requirement.formId, resource.formId);
+  const resourceMatches = !requirement.resourceIds?.length || isFormlessCandidate || requirement.resourceIds.some(id => sameId(id, resource.id));
+  return formMatches && resourceMatches;
+}
+function resolveProductTitle(product) {
+  const rawTitle = product.raw?.title || product.raw?.name || product.raw?.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;
+}
+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, _dayjs.default)(schedule.start_at);
+        const end = (0, _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?.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?.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 = new Map();
+  resources.forEach(resource => {
+    eventsByResource.set(String(resource.id), getEventsForResource(resource, contextEvents));
+  });
+  return eventsByResource;
+}
+function getWorkingSegmentsForInterval(resource, interval) {
+  const intervalStart = (0, _dayjs.default)(interval.start_at);
+  const intervalEnd = (0, _dayjs.default)(interval.end_at);
+  return resource.times.map(time => {
+    const start = maxDayjs((0, _dayjs.default)(time.start_at), intervalStart);
+    const end = minDayjs((0, _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, _dayjs.default)(event.start_at), (0, _dayjs.default)(event.end_at))).map(event => ({
+      start: maxDayjs((0, _dayjs.default)(event.start_at), working.start),
+      end: minDayjs((0, _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 = new Map([[working.start.valueOf(), working.start], [working.end.valueOf(), working.end]]);
+    events.forEach(event => {
+      const eventStart = (0, _dayjs.default)(event.start_at);
+      const eventEnd = (0, _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, _dayjs.default)(event.start_at), (0, _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, _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, _dayjs.default)(interval.start_at);
+  const end = (0, _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, _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, _dayjs.default)(time.start_at), (0, _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, _dayjs.default)(event.start_at), (0, _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 !== undefined && 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?.remainingCapacity,
+      maxCapacity: 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) {
+  const date = query.date || query.dateRange?.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, _dayjs.default)(interval.start_at);
+      const end = (0, _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, _dayjs.default)(item.start_at), (0, _dayjs.default)(item.end_at), start, end));
+      return {
+        startTime: label,
+        endTime: (0, _dayjs.default)(interval.end_at).format('HH:mm'),
+        status: cell?.status || 'unavailable',
+        resourceId: resource.id,
+        productId: product.id,
+        remainingCapacity: cell?.remainingCapacity,
+        maxCapacity: cell?.maxCapacity || resource.capacity,
+        reasonCodes: 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 === undefined) return false;
+      if (cell.status !== 'available' && cell.status !== 'limited') return false;
+      const cellStart = (0, _dayjs.default)(cell.start_at);
+      const cellEnd = (0, _dayjs.default)(cell.end_at);
+      const intervalStart = (0, _dayjs.default)(interval.start_at);
+      const intervalEnd = (0, _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) => {
+    if (group.length) return;
+    conflicts.push({
+      type: 'missing_resource',
+      message: '没有匹配商品需求的可用资源',
+      productId: interval.productId,
+      resourceId: interval.resourceRequirements[index]?.resourceIds?.[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, _dayjs.default)(candidate.cell.start_at)), (0, _dayjs.default)(interval.start_at));
+  const end = candidates.reduce((current, candidate) => minDayjs(current, (0, _dayjs.default)(candidate.cell.end_at)), (0, _dayjs.default)(interval.end_at));
+  const durationMinutes = Math.max(1, Number(interval.durationMinutes || 1));
+  if (interval.source !== 'duration' || query.startTime) {
+    const fixedStart = (0, _dayjs.default)(interval.start_at);
+    const fixedEnd = (0, _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 = 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 = 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?.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 conflicts = [];
+    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) {
+        conflicts.push({
+          type: 'missing_resource',
+          message: 'assignment 对应的商品不存在',
+          productId: assignment.productId
+        });
+        continue;
+      }
+      if (!resource) {
+        conflicts.push({
+          type: 'missing_resource',
+          message: 'assignment 对应的资源不存在',
+          productId: assignment.productId,
+          resourceId: assignment.resourceId
+        });
+        continue;
+      }
+      const start = (0, _dayjs.default)(assignment.start_at);
+      const end = (0, _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') {
+        conflicts.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') {
+        conflicts.push(...selfConflictCell.conflicts.map(conflict => ({
+          ...conflict,
+          type: 'cart_overlap',
+          message: '本次选择中存在资源时间冲突'
+        })));
+      }
+    }
+    return {
+      ok: conflicts.length === 0,
+      conflicts
+    };
+  }
+  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
+  };
+}