@primeui/scheduler-core 0.0.1-alpha.1

package/dist/chunk-QR2SVYAD.mjs

@@ -0,0 +1,1144 @@
+// src/resource/resource-tree.ts
+function flattenResourceTree(resourceList) {
+  const output = [];
+  for (const resource of resourceList) {
+    output.push(resource);
+    if (resource.children && resource.children.length > 0) {
+      output.push(...flattenResourceTree(resource.children));
+    }
+  }
+  return output;
+}
+function upsertResourceById(resourceList, resource) {
+  const index = resourceList.findIndex((item) => item.id === resource.id);
+  if (index === -1) {
+    return [...resourceList, resource];
+  }
+  const next = [...resourceList];
+  next[index] = resource;
+  return next;
+}
+function addResourceToTree(resourceList, resource, parentId) {
+  if (parentId === void 0 || parentId === null) {
+    return {
+      resources: upsertResourceById(resourceList, resource),
+      changed: true
+    };
+  }
+  let changed = false;
+  const next = resourceList.map((node) => {
+    if (node.id === parentId) {
+      changed = true;
+      const child = resource.parentId === void 0 ? { ...resource, parentId } : resource;
+      return {
+        ...node,
+        children: upsertResourceById(node.children ?? [], child)
+      };
+    }
+    if (!node.children || node.children.length === 0) {
+      return node;
+    }
+    const childResult = addResourceToTree(node.children, resource, parentId);
+    if (!childResult.changed) {
+      return node;
+    }
+    changed = true;
+    return {
+      ...node,
+      children: childResult.resources
+    };
+  });
+  return {
+    resources: changed ? next : resourceList,
+    changed
+  };
+}
+function updateResourceInTree(resourceList, updatedResource) {
+  let changed = false;
+  const next = resourceList.map((node) => {
+    if (node.id === updatedResource.id) {
+      changed = true;
+      return {
+        ...node,
+        ...updatedResource
+      };
+    }
+    if (!node.children || node.children.length === 0) {
+      return node;
+    }
+    const childResult = updateResourceInTree(node.children, updatedResource);
+    if (!childResult.changed) {
+      return node;
+    }
+    changed = true;
+    return {
+      ...node,
+      children: childResult.resources
+    };
+  });
+  return {
+    resources: changed ? next : resourceList,
+    changed
+  };
+}
+function removeResourceFromTree(resourceList, resourceId) {
+  let changed = false;
+  const next = [];
+  for (const node of resourceList) {
+    if (node.id === resourceId) {
+      changed = true;
+      continue;
+    }
+    if (!node.children || node.children.length === 0) {
+      next.push(node);
+      continue;
+    }
+    const childResult = removeResourceFromTree(node.children, resourceId);
+    if (childResult.changed) {
+      changed = true;
+      next.push({
+        ...node,
+        children: childResult.resources
+      });
+    } else {
+      next.push(node);
+    }
+  }
+  return {
+    resources: changed ? next : resourceList,
+    changed
+  };
+}
+function setResourceExpansionInTree(resourceList, resourceId, expanded) {
+  let changed = false;
+  const next = resourceList.map((node) => {
+    if (node.id === resourceId) {
+      changed = true;
+      return {
+        ...node,
+        metadata: {
+          ...node.metadata ?? {},
+          __schedulerExpanded: expanded
+        }
+      };
+    }
+    if (!node.children || node.children.length === 0) {
+      return node;
+    }
+    const childResult = setResourceExpansionInTree(node.children, resourceId, expanded);
+    if (!childResult.changed) {
+      return node;
+    }
+    changed = true;
+    return {
+      ...node,
+      children: childResult.resources
+    };
+  });
+  return {
+    resources: changed ? next : resourceList,
+    changed
+  };
+}
+function dedupeResourceIds(resourceIds) {
+  const seen = /* @__PURE__ */ new Set();
+  const deduped = [];
+  for (const resourceId of resourceIds) {
+    const key = String(resourceId);
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    deduped.push(resourceId);
+  }
+  return deduped;
+}
+function areResourceIdSetsEqual(left, right) {
+  if (left.length !== right.length) {
+    return false;
+  }
+  const leftKeys = dedupeResourceIds(left).map((id) => String(id)).sort();
+  const rightKeys = dedupeResourceIds(right).map((id) => String(id)).sort();
+  if (leftKeys.length !== rightKeys.length) {
+    return false;
+  }
+  for (let i = 0; i < leftKeys.length; i++) {
+    if (leftKeys[i] !== rightKeys[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/resource/resource.store.ts
+function createResourceStore(initialResources = [], options = {}) {
+  const { initialExpanded = true } = options;
+  const resourceMap = /* @__PURE__ */ new Map();
+  const expandedIds = /* @__PURE__ */ new Set();
+  buildResourceMap(initialResources, resourceMap);
+  collectParentExpansionState(initialResources, expandedIds, initialExpanded);
+  const flattenedResources = flattenResources(initialResources, expandedIds, resourceMap);
+  return {
+    resources: initialResources,
+    flattenedResources,
+    expandedIds,
+    visibleResourceIds: new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id)),
+    resourceMap
+  };
+}
+function buildResourceMap(resources, map, parentId) {
+  for (const resource of resources) {
+    const resourceWithParent = parentId !== void 0 ? { ...resource, parentId } : resource;
+    map.set(resource.id, resourceWithParent);
+    if (resource.children && resource.children.length > 0) {
+      buildResourceMap(resource.children, map, resource.id);
+    }
+  }
+}
+function getPersistedExpansion(resource) {
+  const persisted = resource.metadata?.__schedulerExpanded;
+  return typeof persisted === "boolean" ? persisted : void 0;
+}
+function collectParentExpansionState(resources, expandedIds, initialExpanded) {
+  for (const resource of resources) {
+    if (resource.children && resource.children.length > 0) {
+      const persisted = getPersistedExpansion(resource);
+      const shouldExpand = persisted ?? initialExpanded;
+      if (shouldExpand) {
+        expandedIds.add(resource.id);
+      }
+      collectParentExpansionState(resource.children, expandedIds, initialExpanded);
+    }
+  }
+}
+function collectAllParentIds(resources, expandedIds) {
+  for (const resource of resources) {
+    if (resource.children && resource.children.length > 0) {
+      expandedIds.add(resource.id);
+      collectAllParentIds(resource.children, expandedIds);
+    }
+  }
+}
+function flattenResources(resources, expandedIds, resourceMap, depth = 0, ancestorIds = [], parentExpanded = true) {
+  const result = [];
+  for (const resource of resources) {
+    const hasChildren = !!(resource.children && resource.children.length > 0);
+    const isExpanded = !hasChildren || expandedIds.has(resource.id);
+    const isVisible = parentExpanded;
+    result.push({
+      ...resource,
+      depth,
+      hasChildren,
+      isExpanded,
+      isVisible,
+      ancestorIds: [...ancestorIds]
+    });
+    if (hasChildren && resource.children) {
+      const childResources = flattenResources(resource.children, expandedIds, resourceMap, depth + 1, [...ancestorIds, resource.id], isVisible && isExpanded);
+      result.push(...childResources);
+    }
+  }
+  return result;
+}
+function addResource(state, resource, parentId) {
+  const newResources = [...state.resources];
+  if (parentId !== void 0) {
+    const parent = findResourceById(newResources, parentId);
+    if (parent) {
+      if (!parent.children) {
+        parent.children = [];
+      }
+      parent.children.push(resource);
+    }
+  } else {
+    newResources.push(resource);
+  }
+  const newMap = new Map(state.resourceMap);
+  newMap.set(resource.id, { ...resource, parentId });
+  const flattenedResources = flattenResources(newResources, state.expandedIds, newMap);
+  return {
+    ...state,
+    resources: newResources,
+    flattenedResources,
+    resourceMap: newMap,
+    visibleResourceIds: new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id))
+  };
+}
+function updateResource(state, resourceId, updates) {
+  const newResources = updateResourceInTree2(state.resources, resourceId, updates);
+  const newMap = new Map(state.resourceMap);
+  const existing = newMap.get(resourceId);
+  if (existing) {
+    newMap.set(resourceId, { ...existing, ...updates });
+  }
+  const flattenedResources = flattenResources(newResources, state.expandedIds, newMap);
+  return {
+    ...state,
+    resources: newResources,
+    flattenedResources,
+    resourceMap: newMap,
+    visibleResourceIds: new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id))
+  };
+}
+function updateResourceInTree2(resources, resourceId, updates) {
+  return resources.map((resource) => {
+    if (resource.id === resourceId) {
+      return { ...resource, ...updates };
+    }
+    if (resource.children && resource.children.length > 0) {
+      return {
+        ...resource,
+        children: updateResourceInTree2(resource.children, resourceId, updates)
+      };
+    }
+    return resource;
+  });
+}
+function removeResource(state, resourceId) {
+  const newResources = removeResourceFromTree2(state.resources, resourceId);
+  const newMap = new Map(state.resourceMap);
+  removeResourceFromMap(newMap, resourceId);
+  const newExpandedIds = new Set(state.expandedIds);
+  newExpandedIds.delete(resourceId);
+  const flattenedResources = flattenResources(newResources, newExpandedIds, newMap);
+  return {
+    ...state,
+    resources: newResources,
+    flattenedResources,
+    expandedIds: newExpandedIds,
+    resourceMap: newMap,
+    visibleResourceIds: new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id))
+  };
+}
+function removeResourceFromTree2(resources, resourceId) {
+  return resources.filter((resource) => resource.id !== resourceId).map((resource) => {
+    if (resource.children && resource.children.length > 0) {
+      return {
+        ...resource,
+        children: removeResourceFromTree2(resource.children, resourceId)
+      };
+    }
+    return resource;
+  });
+}
+function removeResourceFromMap(map, resourceId) {
+  const resource = map.get(resourceId);
+  map.delete(resourceId);
+  if (resource?.children) {
+    for (const child of resource.children) {
+      removeResourceFromMap(map, child.id);
+    }
+  }
+}
+function expandResource(state, resourceId) {
+  if (state.expandedIds.has(resourceId)) {
+    return state;
+  }
+  const newExpandedIds = new Set(state.expandedIds);
+  newExpandedIds.add(resourceId);
+  const flattenedResources = flattenResources(state.resources, newExpandedIds, state.resourceMap);
+  return {
+    ...state,
+    expandedIds: newExpandedIds,
+    flattenedResources,
+    visibleResourceIds: new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id))
+  };
+}
+function collapseResource(state, resourceId) {
+  if (!state.expandedIds.has(resourceId)) {
+    return state;
+  }
+  const newExpandedIds = new Set(state.expandedIds);
+  newExpandedIds.delete(resourceId);
+  const flattenedResources = flattenResources(state.resources, newExpandedIds, state.resourceMap);
+  return {
+    ...state,
+    expandedIds: newExpandedIds,
+    flattenedResources,
+    visibleResourceIds: new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id))
+  };
+}
+function toggleResourceExpansion(state, resourceId) {
+  if (state.expandedIds.has(resourceId)) {
+    return collapseResource(state, resourceId);
+  }
+  return expandResource(state, resourceId);
+}
+function expandAllResources(state) {
+  const newExpandedIds = /* @__PURE__ */ new Set();
+  collectAllParentIds(state.resources, newExpandedIds);
+  const flattenedResources = flattenResources(state.resources, newExpandedIds, state.resourceMap);
+  return {
+    ...state,
+    expandedIds: newExpandedIds,
+    flattenedResources,
+    visibleResourceIds: new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id))
+  };
+}
+function collapseAllResources(state) {
+  const newExpandedIds = /* @__PURE__ */ new Set();
+  const flattenedResources = flattenResources(state.resources, newExpandedIds, state.resourceMap);
+  return {
+    ...state,
+    expandedIds: newExpandedIds,
+    flattenedResources,
+    visibleResourceIds: new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id))
+  };
+}
+function getResourceById(state, resourceId) {
+  return state.resourceMap.get(resourceId);
+}
+function getResourcesByIds(state, resourceIds) {
+  return resourceIds.map((id) => state.resourceMap.get(id)).filter((r) => r !== void 0);
+}
+function getVisibleResources(state) {
+  return state.flattenedResources.filter((r) => r.isVisible);
+}
+function getChildResources(state, parentId) {
+  const parent = state.resourceMap.get(parentId);
+  return parent?.children ?? [];
+}
+function getParentResource(state, resourceId) {
+  const resource = state.resourceMap.get(resourceId);
+  if (!resource?.parentId) {
+    return void 0;
+  }
+  return state.resourceMap.get(resource.parentId);
+}
+function getAncestorResources(state, resourceId) {
+  const ancestors = [];
+  let current = state.resourceMap.get(resourceId);
+  while (current?.parentId) {
+    const parent = state.resourceMap.get(current.parentId);
+    if (parent) {
+      ancestors.unshift(parent);
+      current = parent;
+    } else {
+      break;
+    }
+  }
+  return ancestors;
+}
+function findResourceById(resources, resourceId) {
+  for (const resource of resources) {
+    if (resource.id === resourceId) {
+      return resource;
+    }
+    if (resource.children) {
+      const found = findResourceById(resource.children, resourceId);
+      if (found) {
+        return found;
+      }
+    }
+  }
+  return void 0;
+}
+function getAllResourceIds(resources) {
+  const ids = [];
+  function collect(resources2) {
+    for (const resource of resources2) {
+      ids.push(resource.id);
+      if (resource.children) {
+        collect(resource.children);
+      }
+    }
+  }
+  collect(resources);
+  return ids;
+}
+function countResources(resources) {
+  let count = 0;
+  function countRecursive(resources2) {
+    for (const resource of resources2) {
+      count++;
+      if (resource.children) {
+        countRecursive(resource.children);
+      }
+    }
+  }
+  countRecursive(resources);
+  return count;
+}
+function getLeafResources(resources) {
+  const leaves = [];
+  function collect(resources2) {
+    for (const resource of resources2) {
+      if (resource.children && resource.children.length > 0) {
+        collect(resource.children);
+      } else {
+        leaves.push(resource);
+      }
+    }
+  }
+  collect(resources);
+  return leaves;
+}
+function getMaxDepth(resources, currentDepth = 0) {
+  let maxDepth = currentDepth;
+  for (const resource of resources) {
+    if (resource.children && resource.children.length > 0) {
+      const childMaxDepth = getMaxDepth(resource.children, currentDepth + 1);
+      maxDepth = Math.max(maxDepth, childMaxDepth);
+    }
+  }
+  return maxDepth;
+}
+function countLeafDescendants(resource) {
+  if (!resource.children || resource.children.length === 0) {
+    return 1;
+  }
+  let count = 0;
+  for (const child of resource.children) {
+    count += countLeafDescendants(child);
+  }
+  return count;
+}
+function getHierarchicalHeaderRows(resources) {
+  const maxDepth = getMaxDepth(resources);
+  const rows = [];
+  for (let depth = 0; depth <= maxDepth; depth++) {
+    rows.push({ depth, cells: [] });
+  }
+  function processResources(resources2, currentDepth) {
+    for (const resource of resources2) {
+      const hasChildren = !!(resource.children && resource.children.length > 0);
+      const colspan = countLeafDescendants(resource);
+      const isLeaf = !hasChildren;
+      rows[currentDepth].cells.push({
+        resource,
+        colspan,
+        depth: currentDepth,
+        isLeaf
+      });
+      if (hasChildren && resource.children) {
+        processResources(resource.children, currentDepth + 1);
+      } else if (currentDepth < maxDepth) {
+        for (let d = currentDepth + 1; d <= maxDepth; d++) {
+          rows[d].cells.push({
+            resource,
+            colspan: 1,
+            depth: d,
+            isLeaf: true
+          });
+        }
+      }
+    }
+  }
+  processResources(resources, 0);
+  return rows;
+}
+function groupResourcesByField(resources, fieldName) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const resource of resources) {
+    const fieldValue = resource.metadata?.[fieldName] ?? resource[fieldName] ?? "Ungrouped";
+    if (!groups.has(fieldValue)) {
+      groups.set(fieldValue, []);
+    }
+    groups.get(fieldValue).push(resource);
+  }
+  const hierarchicalResources = [];
+  for (const [groupName, groupResources] of groups) {
+    hierarchicalResources.push({
+      id: `group-${groupName}`,
+      title: groupName,
+      children: groupResources
+    });
+  }
+  return hierarchicalResources;
+}
+function hasHierarchy(resources) {
+  return resources.some((r) => r.children && r.children.length > 0);
+}
+
+// src/resource/resource.grouping.ts
+var DEFAULT_RESOURCE_AREA_WIDTH = 200;
+var DEFAULT_RESOURCE_ROW_HEIGHT = 40;
+var DEFAULT_RESOURCE_MIN_ROW_HEIGHT = 32;
+function groupEventsByResource(events, state) {
+  const visibleResources = state.flattenedResources.filter((r) => r.isVisible);
+  const groups = [];
+  for (const resource of visibleResources) {
+    const resourceEvents = getEventsForResource(events, resource.id);
+    groups.push({
+      resource,
+      events: resourceEvents
+    });
+  }
+  return groups;
+}
+function groupEventsByDate(events, resources, dates) {
+  const groups = [];
+  for (const date of dates) {
+    const dateStr = formatDateKey(date);
+    const dateEvents = filterEventsByDate(events, date);
+    const resourceGroups = resources.map((resource) => ({
+      resource,
+      events: getEventsForResource(dateEvents, resource.id)
+    }));
+    groups.push({
+      date,
+      dateStr,
+      resources: resourceGroups
+    });
+  }
+  return groups;
+}
+function getEventsForResource(events, resourceId) {
+  return events.filter((event) => {
+    if (event.resourceId !== void 0) {
+      return event.resourceId === resourceId;
+    }
+    if (event.resourceIds && event.resourceIds.length > 0) {
+      return event.resourceIds.includes(resourceId);
+    }
+    return false;
+  });
+}
+function getEventsWithoutResource(events) {
+  return events.filter((event) => event.resourceId === void 0 && (!event.resourceIds || event.resourceIds.length === 0));
+}
+function getResourceIdsForEvent(event) {
+  if (event.resourceIds && event.resourceIds.length > 0) {
+    return event.resourceIds;
+  }
+  if (event.resourceId !== void 0) {
+    return [event.resourceId];
+  }
+  return [];
+}
+function assignEventToResource(event, resourceId) {
+  const newEvent = { ...event };
+  if (event.resourceIds && event.resourceIds.length > 1) {
+    newEvent.resourceIds = [...event.resourceIds.filter((id) => id !== resourceId), resourceId];
+  } else {
+    newEvent.resourceId = resourceId;
+    delete newEvent.resourceIds;
+  }
+  return newEvent;
+}
+function moveEventToResource(event, fromResourceId, toResourceId) {
+  const newEvent = { ...event };
+  if (event.resourceIds && event.resourceIds.length > 1) {
+    newEvent.resourceIds = event.resourceIds.map((id) => id === fromResourceId ? toResourceId : id);
+  } else {
+    newEvent.resourceId = toResourceId;
+  }
+  return newEvent;
+}
+function addResourceToEvent(event, resourceId) {
+  const currentIds = getResourceIdsForEvent(event);
+  if (currentIds.includes(resourceId)) {
+    return event;
+  }
+  return {
+    ...event,
+    resourceIds: [...currentIds, resourceId],
+    resourceId: void 0
+  };
+}
+function removeResourceFromEvent(event, resourceId) {
+  const currentIds = getResourceIdsForEvent(event);
+  const newIds = currentIds.filter((id) => id !== resourceId);
+  if (newIds.length === 0) {
+    const result = { ...event };
+    delete result.resourceId;
+    delete result.resourceIds;
+    return result;
+  }
+  if (newIds.length === 1) {
+    return {
+      ...event,
+      resourceId: newIds[0],
+      resourceIds: void 0
+    };
+  }
+  return {
+    ...event,
+    resourceIds: newIds,
+    resourceId: void 0
+  };
+}
+var LANE_HEIGHT = 24;
+var LANE_GAP = 2;
+var LANE_BASE_PADDING = 4;
+function calculateResourceRowLayouts(visibleResources, rowHeight = DEFAULT_RESOURCE_ROW_HEIGHT, expandedRowHeights, laneCounts) {
+  const layouts = [];
+  let currentTop = 0;
+  for (let i = 0; i < visibleResources.length; i++) {
+    const resource = visibleResources[i];
+    const isGroup = Boolean(resource.hasChildren);
+    const laneCount = Math.max(1, laneCounts?.get(resource.id) ?? 1);
+    let height;
+    if (expandedRowHeights?.has(resource.id)) {
+      height = expandedRowHeights.get(resource.id);
+    } else if (isGroup) {
+      height = rowHeight;
+    } else {
+      const lanesHeight = LANE_BASE_PADDING * 2 + laneCount * (LANE_HEIGHT + LANE_GAP);
+      height = Math.max(rowHeight, lanesHeight);
+    }
+    layouts.push({
+      resource,
+      top: currentTop,
+      height,
+      rowIndex: i,
+      laneCount,
+      isGroup
+    });
+    currentTop += height;
+  }
+  return layouts;
+}
+function calculateResourceColumnLayouts(resources, totalWidth, minColumnWidth = 100) {
+  const layouts = [];
+  const columnWidth = Math.max(minColumnWidth, totalWidth / resources.length);
+  for (let i = 0; i < resources.length; i++) {
+    layouts.push({
+      resource: resources[i],
+      left: i * columnWidth,
+      width: columnWidth,
+      columnIndex: i
+    });
+  }
+  return layouts;
+}
+function getResourceAtPosition(layouts, y) {
+  for (const layout of layouts) {
+    if (y >= layout.top && y < layout.top + layout.height) {
+      return layout.resource;
+    }
+  }
+  return void 0;
+}
+function getResourceColumnAtPosition(layouts, x) {
+  for (const layout of layouts) {
+    if (x >= layout.left && x < layout.left + layout.width) {
+      return layout.resource;
+    }
+  }
+  return void 0;
+}
+function sortResources(resources, options) {
+  const { resourceOrder } = options;
+  if (!resourceOrder) {
+    return resources;
+  }
+  const sorted = [...resources];
+  if (typeof resourceOrder === "function") {
+    sorted.sort(resourceOrder);
+  } else if (resourceOrder === "asc") {
+    sorted.sort((a, b) => a.title.localeCompare(b.title));
+  } else if (resourceOrder === "desc") {
+    sorted.sort((a, b) => b.title.localeCompare(a.title));
+  }
+  return sorted.map((resource) => {
+    if (resource.children && resource.children.length > 0) {
+      return {
+        ...resource,
+        children: sortResources(resource.children, options)
+      };
+    }
+    return resource;
+  });
+}
+function getTotalResourceHeight(layouts) {
+  if (layouts.length === 0) {
+    return 0;
+  }
+  const lastLayout = layouts[layouts.length - 1];
+  return lastLayout.top + lastLayout.height;
+}
+function getResourceAreaWidth(options) {
+  if (typeof options.resourceAreaWidth === "number") {
+    return options.resourceAreaWidth;
+  }
+  if (typeof options.resourceAreaWidth === "string") {
+    const parsed = parseInt(options.resourceAreaWidth, 10);
+    return isNaN(parsed) ? DEFAULT_RESOURCE_AREA_WIDTH : parsed;
+  }
+  return DEFAULT_RESOURCE_AREA_WIDTH;
+}
+function getResourceLabel(resource, options) {
+  if (options?.resourceLabelContent) {
+    return options.resourceLabelContent(resource);
+  }
+  return resource.title;
+}
+function calculateExpandedRowHeight(eventCount, eventHeight = 24, eventGap = 4, minHeight = DEFAULT_RESOURCE_MIN_ROW_HEIGHT, padding = 8) {
+  if (eventCount === 0) {
+    return minHeight;
+  }
+  const contentHeight = eventCount * eventHeight + (eventCount - 1) * eventGap + padding * 2;
+  return Math.max(minHeight, contentHeight);
+}
+function formatDateKey(date) {
+  return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}`;
+}
+function filterEventsByDate(events, date) {
+  const dayStart = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  const dayEnd = new Date(date.getFullYear(), date.getMonth(), date.getDate(), 23, 59, 59, 999);
+  return events.filter((event) => {
+    const eventStart = typeof event.start === "string" ? new Date(event.start) : event.start;
+    const eventEnd = event.end ? typeof event.end === "string" ? new Date(event.end) : event.end : eventStart;
+    return eventStart <= dayEnd && eventEnd >= dayStart;
+  });
+}
+
+// src/resource/resource.filtering.ts
+function filterResources(state, query, options = { enabled: true, searchable: true }) {
+  if (!options.enabled || !query.trim()) {
+    return {
+      filteredResources: state.resources,
+      flattenedResources: state.flattenedResources,
+      matchingIds: new Set(state.resourceMap.keys()),
+      visibleIds: state.visibleResourceIds
+    };
+  }
+  const normalizedQuery = query.toLowerCase().trim();
+  const predicate = options.filterPredicate ?? defaultFilterPredicate;
+  const matchingIds = /* @__PURE__ */ new Set();
+  const parentIdsToShow = /* @__PURE__ */ new Set();
+  findMatchingResources(state.resources, normalizedQuery, predicate, matchingIds, parentIdsToShow);
+  const filteredResources = filterResourceTree(state.resources, matchingIds, parentIdsToShow);
+  const expandedIdsForFilter = new Set(state.expandedIds);
+  for (const id of parentIdsToShow) {
+    expandedIdsForFilter.add(id);
+  }
+  const flattenedResources = flattenResources(filteredResources, expandedIdsForFilter, state.resourceMap);
+  const visibleIds = new Set(flattenedResources.filter((r) => r.isVisible).map((r) => r.id));
+  return {
+    filteredResources,
+    flattenedResources,
+    matchingIds,
+    visibleIds
+  };
+}
+function defaultFilterPredicate(resource, query) {
+  return resource.title.toLowerCase().includes(query);
+}
+function findMatchingResources(resources, query, predicate, matchingIds, parentIdsToShow, ancestorIds = []) {
+  let hasMatchingDescendant = false;
+  for (const resource of resources) {
+    const isMatch = predicate(resource, query);
+    let childHasMatch = false;
+    if (resource.children && resource.children.length > 0) {
+      childHasMatch = findMatchingResources(resource.children, query, predicate, matchingIds, parentIdsToShow, [...ancestorIds, resource.id]);
+    }
+    if (isMatch || childHasMatch) {
+      matchingIds.add(resource.id);
+      for (const ancestorId of ancestorIds) {
+        parentIdsToShow.add(ancestorId);
+      }
+      hasMatchingDescendant = true;
+    }
+  }
+  return hasMatchingDescendant;
+}
+function filterResourceTree(resources, matchingIds, parentIdsToShow) {
+  return resources.filter((resource) => matchingIds.has(resource.id) || parentIdsToShow.has(resource.id)).map((resource) => {
+    if (resource.children && resource.children.length > 0) {
+      const filteredChildren = filterResourceTree(resource.children, matchingIds, parentIdsToShow);
+      if (filteredChildren.length > 0) {
+        return { ...resource, children: filteredChildren };
+      }
+      if (matchingIds.has(resource.id)) {
+        return { ...resource, children: [] };
+      }
+      return null;
+    }
+    return resource;
+  }).filter((r) => r !== null);
+}
+function searchResources(resources, query, predicate) {
+  if (!query.trim()) {
+    return [];
+  }
+  const normalizedQuery = query.toLowerCase().trim();
+  const searchPredicate = predicate ?? defaultFilterPredicate;
+  const results = [];
+  searchResourcesRecursive(resources, normalizedQuery, searchPredicate, results);
+  return results;
+}
+function searchResourcesRecursive(resources, query, predicate, results) {
+  for (const resource of resources) {
+    if (predicate(resource, query)) {
+      results.push(resource);
+    }
+    if (resource.children && resource.children.length > 0) {
+      searchResourcesRecursive(resource.children, query, predicate, results);
+    }
+  }
+}
+function createResourceFilter(options = {}) {
+  return {
+    enabled: options.enabled ?? true,
+    searchable: options.searchable ?? true,
+    placeholder: options.placeholder ?? "Search resources...",
+    filterPredicate: options.filterPredicate
+  };
+}
+function highlightMatch(text, query) {
+  if (!query.trim()) {
+    return [{ text, isMatch: false }];
+  }
+  const normalizedQuery = query.toLowerCase();
+  const normalizedText = text.toLowerCase();
+  const results = [];
+  let lastIndex = 0;
+  let index = normalizedText.indexOf(normalizedQuery);
+  while (index !== -1) {
+    if (index > lastIndex) {
+      results.push({
+        text: text.slice(lastIndex, index),
+        isMatch: false
+      });
+    }
+    results.push({
+      text: text.slice(index, index + query.length),
+      isMatch: true
+    });
+    lastIndex = index + query.length;
+    index = normalizedText.indexOf(normalizedQuery, lastIndex);
+  }
+  if (lastIndex < text.length) {
+    results.push({
+      text: text.slice(lastIndex),
+      isMatch: false
+    });
+  }
+  return results;
+}
+function getFilterStats(filterResult, totalCount) {
+  const matchCount = filterResult.matchingIds.size;
+  return {
+    matchCount,
+    totalCount,
+    percentage: totalCount > 0 ? Math.round(matchCount / totalCount * 100) : 0
+  };
+}
+
+// src/resource/resource-scale-policy.ts
+var HORIZONTAL_RESOURCE_VIEWS = /* @__PURE__ */ new Set(["resourceDay", "resourceWeek", "resourceMonth"]);
+function resolveScaleTier(leafCount) {
+  if (leafCount <= 5) return "small";
+  if (leafCount <= 15) return "medium";
+  if (leafCount <= 30) return "large";
+  return "xlarge";
+}
+function resolveResourceScalePolicy(input) {
+  const { view, resourceLeafCount, horizontalOverflowThreshold, adaptiveModeEnabled } = input;
+  const isHorizontalView = HORIZONTAL_RESOURCE_VIEWS.has(view);
+  const shouldForceHorizontalOverflow = isHorizontalView && resourceLeafCount > horizontalOverflowThreshold;
+  const shouldUseAdaptiveSingleResource = adaptiveModeEnabled && resourceLeafCount <= 1;
+  const scaleTier = resolveScaleTier(resourceLeafCount);
+  return {
+    shouldForceHorizontalOverflow,
+    shouldUseAdaptiveSingleResource,
+    scaleTier
+  };
+}
+
+// src/resource/resource-scale-strategy.ts
+var HORIZONTAL_RESOURCE_VIEWS2 = /* @__PURE__ */ new Set(["resourceDay", "resourceWeek", "resourceMonth"]);
+var MULTI_DAY_HORIZONTAL_VIEWS = /* @__PURE__ */ new Set(["resourceWeek"]);
+var TIMELINE_VIEWS = /* @__PURE__ */ new Set(["resourceTimelineDay", "resourceTimelineWeek", "resourceTimelineMonth"]);
+var DATE_GROUPED_VIEWS = /* @__PURE__ */ new Set(["dateDay", "dateWeek", "dateMonth"]);
+function classifyView(view) {
+  if (HORIZONTAL_RESOURCE_VIEWS2.has(view)) return "resource-horizontal";
+  if (TIMELINE_VIEWS.has(view)) return "resource-timeline";
+  if (DATE_GROUPED_VIEWS.has(view)) return "date-grouped";
+  return "other";
+}
+var GROUP_MIN_WIDTH = {
+  small: 120,
+  medium: 100,
+  large: 80,
+  xlarge: 70
+};
+var DAY_MIN_WIDTH = {
+  small: 60,
+  medium: 56,
+  large: 48,
+  xlarge: 40
+};
+var COLUMN_MODE = {
+  small: "auto",
+  medium: "auto",
+  large: "minmax",
+  xlarge: "fixed"
+};
+var HIERARCHICAL_GROUP_MIN_WIDTH = 100;
+function resolveResourceScaleStrategy(input) {
+  const { policy, view, isHierarchical, currentColumnMode } = input;
+  const { scaleTier, shouldForceHorizontalOverflow, shouldUseAdaptiveSingleResource } = policy;
+  const reasonCodes = [];
+  const viewCategory = classifyView(view);
+  const isHorizontal = viewCategory === "resource-horizontal";
+  const hasDayColumns = MULTI_DAY_HORIZONTAL_VIEWS.has(view);
+  reasonCodes.push(`tier-${scaleTier}`);
+  reasonCodes.push(`view-${viewCategory}`);
+  reasonCodes.push(isHierarchical ? "hierarchical" : "flat");
+  if (shouldForceHorizontalOverflow) reasonCodes.push("force-overflow");
+  if (shouldUseAdaptiveSingleResource) reasonCodes.push("adaptive-single");
+  if (!isHorizontal) {
+    return {
+      recommendedForceOverflow: shouldForceHorizontalOverflow,
+      recommendedAdaptiveSingle: shouldUseAdaptiveSingleResource,
+      recommendedGroupMinWidth: null,
+      recommendedDayMinWidth: null,
+      recommendedColumnMode: null,
+      reasonCodes
+    };
+  }
+  const isCompact = scaleTier === "large" || scaleTier === "xlarge";
+  let recommendedGroupMinWidth = GROUP_MIN_WIDTH[scaleTier];
+  const recommendedDayMinWidth = hasDayColumns ? DAY_MIN_WIDTH[scaleTier] : null;
+  const recommendedColumnMode = COLUMN_MODE[scaleTier];
+  if (isCompact) {
+    reasonCodes.push("group-min-width-compact");
+    if (hasDayColumns) reasonCodes.push("day-min-width-compact");
+  }
+  if (isHierarchical && recommendedGroupMinWidth < HIERARCHICAL_GROUP_MIN_WIDTH) {
+    recommendedGroupMinWidth = HIERARCHICAL_GROUP_MIN_WIDTH;
+    reasonCodes.push("group-min-width-hierarchical");
+  } else if (isHierarchical) {
+    reasonCodes.push("group-min-width-hierarchical");
+  }
+  if (currentColumnMode !== recommendedColumnMode) {
+    reasonCodes.push("column-mode-mismatch");
+  }
+  return {
+    recommendedForceOverflow: shouldForceHorizontalOverflow,
+    recommendedAdaptiveSingle: shouldUseAdaptiveSingleResource,
+    recommendedGroupMinWidth,
+    recommendedDayMinWidth,
+    recommendedColumnMode,
+    reasonCodes
+  };
+}
+
+// src/resource/resource.adaptive.ts
+var DEFAULT_ADAPTIVE_BREAKPOINT = 768;
+var DEFAULT_SIDEBAR_WIDTH = 280;
+function createAdaptiveGroupingState() {
+  return {
+    isMobile: false,
+    isSidebarOpen: false,
+    selectedResourceId: null,
+    selectionPath: []
+  };
+}
+function detectMobileMode(viewportWidth, breakpoint = DEFAULT_ADAPTIVE_BREAKPOINT) {
+  return viewportWidth < breakpoint;
+}
+function getAncestorIds(resourceMap, resourceId) {
+  const ancestors = [];
+  let current = resourceMap.get(resourceId);
+  while (current?.parentId !== void 0) {
+    ancestors.unshift(current.parentId);
+    current = resourceMap.get(current.parentId);
+  }
+  return ancestors;
+}
+function selectResource(state, resourceMap, resourceId, closeSidebarOnSelect = true) {
+  const resource = resourceMap.get(resourceId);
+  if (!resource) return state;
+  const ancestors = getAncestorIds(resourceMap, resourceId);
+  const selectionPath = [...ancestors, resourceId];
+  return {
+    ...state,
+    selectedResourceId: resourceId,
+    selectionPath,
+    isSidebarOpen: closeSidebarOnSelect ? false : state.isSidebarOpen
+  };
+}
+function buildBreadcrumbPath(resourceMap, selectionPath) {
+  return selectionPath.map((id, index) => {
+    const resource = resourceMap.get(id);
+    return {
+      id,
+      title: resource?.title ?? String(id),
+      isRoot: index === 0
+    };
+  });
+}
+function toggleSidebar(state) {
+  return {
+    ...state,
+    isSidebarOpen: !state.isSidebarOpen
+  };
+}
+function openSidebar(state) {
+  return {
+    ...state,
+    isSidebarOpen: true
+  };
+}
+function closeSidebar(state) {
+  return {
+    ...state,
+    isSidebarOpen: false
+  };
+}
+function setMobileMode(state, isMobile) {
+  return {
+    ...state,
+    isMobile,
+    isSidebarOpen: isMobile ? state.isSidebarOpen : false
+  };
+}
+function navigateBreadcrumb(state, resourceMap, targetId) {
+  const targetIndex = state.selectionPath.indexOf(targetId);
+  if (targetIndex === -1) return state;
+  return selectResource(state, resourceMap, targetId, false);
+}
+function getFilteredEventsForResource(events, resourceId, descendantIds) {
+  if (resourceId === null) return events;
+  const matchIds = descendantIds ? /* @__PURE__ */ new Set([resourceId, ...descendantIds]) : /* @__PURE__ */ new Set([resourceId]);
+  return events.filter((event) => {
+    if (event.resourceId !== void 0 && matchIds.has(event.resourceId)) return true;
+    if (Array.isArray(event.resourceIds) && event.resourceIds.some((id) => matchIds.has(id))) return true;
+    return false;
+  });
+}
+function clearResourceSelection(state) {
+  return {
+    ...state,
+    selectedResourceId: null,
+    selectionPath: []
+  };
+}
+function getSelectedResource(resourceMap, resourceId) {
+  if (resourceId === null) return null;
+  return resourceMap.get(resourceId) ?? null;
+}
+function isResourceInPath(selectionPath, resourceId) {
+  return selectionPath.includes(resourceId);
+}
+function getSelectionDepth(selectionPath) {
+  return selectionPath.length;
+}
+var adaptiveClasses = {
+  container: "p-scheduler-adaptive",
+  mobile: "p-scheduler-adaptive-mobile",
+  desktop: "p-scheduler-adaptive-desktop",
+  sidebar: "p-scheduler-adaptive-sidebar",
+  sidebarOpen: "p-scheduler-adaptive-sidebar-open",
+  sidebarLeft: "p-scheduler-adaptive-sidebar-left",
+  sidebarRight: "p-scheduler-adaptive-sidebar-right",
+  sidebarOverlay: "p-scheduler-adaptive-sidebar-overlay",
+  sidebarHeader: "p-scheduler-adaptive-sidebar-header",
+  sidebarBody: "p-scheduler-adaptive-sidebar-body",
+  sidebarClose: "p-scheduler-adaptive-sidebar-close",
+  breadcrumb: "p-scheduler-adaptive-breadcrumb",
+  breadcrumbList: "p-scheduler-adaptive-breadcrumb-list",
+  breadcrumbItem: "p-scheduler-adaptive-breadcrumb-item",
+  breadcrumbItemWrapper: "p-scheduler-adaptive-breadcrumb-item-wrapper",
+  breadcrumbSeparator: "p-scheduler-adaptive-breadcrumb-separator",
+  breadcrumbCurrent: "p-scheduler-adaptive-breadcrumb-current",
+  menuButton: "p-scheduler-adaptive-menu-button",
+  secondaryToolbar: "p-scheduler-adaptive-secondary-toolbar",
+  resourceSelected: "p-scheduler-adaptive-resource-selected"
+};
+
+export { DEFAULT_ADAPTIVE_BREAKPOINT, DEFAULT_RESOURCE_AREA_WIDTH, DEFAULT_RESOURCE_MIN_ROW_HEIGHT, DEFAULT_RESOURCE_ROW_HEIGHT, DEFAULT_SIDEBAR_WIDTH, adaptiveClasses, addResource, addResourceToEvent, addResourceToTree, areResourceIdSetsEqual, assignEventToResource, buildBreadcrumbPath, calculateExpandedRowHeight, calculateResourceColumnLayouts, calculateResourceRowLayouts, clearResourceSelection, closeSidebar, collapseAllResources, collapseResource, countLeafDescendants, countResources, createAdaptiveGroupingState, createResourceFilter, createResourceStore, dedupeResourceIds, detectMobileMode, expandAllResources, expandResource, filterResources, findResourceById, flattenResourceTree, flattenResources, getAllResourceIds, getAncestorIds, getAncestorResources, getChildResources, getEventsForResource, getEventsWithoutResource, getFilterStats, getFilteredEventsForResource, getHierarchicalHeaderRows, getLeafResources, getMaxDepth, getParentResource, getResourceAreaWidth, getResourceAtPosition, getResourceById, getResourceColumnAtPosition, getResourceIdsForEvent, getResourceLabel, getResourcesByIds, getSelectedResource, getSelectionDepth, getTotalResourceHeight, getVisibleResources, groupEventsByDate, groupEventsByResource, groupResourcesByField, hasHierarchy, highlightMatch, isResourceInPath, moveEventToResource, navigateBreadcrumb, openSidebar, removeResource, removeResourceFromEvent, removeResourceFromTree, resolveResourceScalePolicy, resolveResourceScaleStrategy, searchResources, selectResource, setMobileMode, setResourceExpansionInTree, sortResources, toggleResourceExpansion, toggleSidebar, updateResource, updateResourceInTree, upsertResourceById };