@pisell/pisellos 2.3.72 → 2.3.74

package/dist/solution/UnifiedBookingSales/remoteOccupancyCache.d.ts

@@ -0,0 +1,49 @@
+import type { AvailabilityDateRange } from '../../modules/ResourcePlanner';
+type AvailabilityId = number | string;
+export declare class AvailabilityRemoteOccupancyCache {
+    private readonly maxCells;
+    private readonly cells;
+    private readonly resourceMeta;
+    private readonly resourceCellCounts;
+    constructor(maxCells?: number);
+    clear(): void;
+    read(params: {
+        scopeKey: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+    }): Record<string, any>[] | null;
+    hasCompleteCoverage(params: {
+        scopeKey: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+    }): boolean;
+    publish(params: {
+        scopeKey: string;
+        timezoneName: string;
+        resourceIds: AvailabilityId[];
+        dateRange: AvailabilityDateRange;
+        rawResources: Record<string, any>[];
+        version: number;
+    }): void;
+    private buildResourceKey;
+    private buildCellKey;
+    private touchCell;
+    /**
+     * A response is one coherent resource snapshot for its requested range. If any overlapping day
+     * already contains a newer response, publishing only the older response's remaining days would
+     * let a cross-midnight event leak back into that newer day when ranges are recomposed.
+     */
+    private canPublishResourceRange;
+    /**
+     * A day cell stores the original event range so it can be reconstructed without losing server
+     * identity. When a newer adjacent-day response replaces that event, evict older neighbour cells
+     * whose event overlaps the refreshed range. The next wider read becomes a cache miss instead of
+     * reintroducing stale occupancy from the neighbour.
+     */
+    private invalidateAdjacentOverlappingCells;
+    private deleteCell;
+    private deleteResourceCells;
+    private writeResourceMeta;
+    private writeCell;
+}
+export {};

package/dist/solution/UnifiedBookingSales/remoteOccupancyCache.js

@@ -0,0 +1,430 @@
+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); }
+var _excluded = ["event_list"];
+function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
+function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function _iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
+function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
+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 _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 _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+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 _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 _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 _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; }
+import { cloneDeep } from 'lodash-es';
+import { addLocalCalendarDays, dateOrdinalFromLocalDate, formatLocalDate, localDateTimeToScalar, localDateToScalarStart, nextDate, parseLocalDateTime } from "../../modules/ResourcePlanner/localClock";
+function uniqueIds(values) {
+  var result = new Map();
+  values.forEach(function (value) {
+    if (value === undefined || value === null || value === '') return;
+    result.set(String(value), value);
+  });
+  return Array.from(result.values());
+}
+function buildDateList(dateRange) {
+  if (!(dateRange !== null && dateRange !== void 0 && dateRange.startDate) || !(dateRange !== null && dateRange !== void 0 && dateRange.endDate)) return [];
+  try {
+    var startOrdinal = dateOrdinalFromLocalDate(dateRange.startDate);
+    var endOrdinal = dateOrdinalFromLocalDate(dateRange.endDate);
+    if (endOrdinal < startOrdinal) return [];
+    var dates = [];
+    var cursor = localDateToScalarStart(dateRange.startDate);
+    for (var ordinal = startOrdinal; ordinal <= endOrdinal; ordinal += 1) {
+      dates.push(formatLocalDate(cursor));
+      cursor = addLocalCalendarDays(cursor, 1);
+    }
+    return dates;
+  } catch (_unused) {
+    return [];
+  }
+}
+function resolveResourceId(raw) {
+  var _ref, _raw$resourceId;
+  var id = (_ref = (_raw$resourceId = raw.resourceId) !== null && _raw$resourceId !== void 0 ? _raw$resourceId : raw.resource_id) !== null && _ref !== void 0 ? _ref : raw.id;
+  if (id === undefined || id === null || id === '') return null;
+  return id;
+}
+function getRawEventStartAt(rawEvent) {
+  var _ref2, _ref3, _rawEvent$start_at;
+  var startAt = (_ref2 = (_ref3 = (_rawEvent$start_at = rawEvent.start_at) !== null && _rawEvent$start_at !== void 0 ? _rawEvent$start_at : rawEvent.startAt) !== null && _ref3 !== void 0 ? _ref3 : rawEvent.start_time) !== null && _ref2 !== void 0 ? _ref2 : rawEvent.startTime;
+  return startAt ? String(startAt) : null;
+}
+function getRawEventEndAt(rawEvent) {
+  var _ref4, _ref5, _rawEvent$end_at;
+  var endAt = (_ref4 = (_ref5 = (_rawEvent$end_at = rawEvent.end_at) !== null && _rawEvent$end_at !== void 0 ? _rawEvent$end_at : rawEvent.endAt) !== null && _ref5 !== void 0 ? _ref5 : rawEvent.end_time) !== null && _ref4 !== void 0 ? _ref4 : rawEvent.endTime;
+  return endAt ? String(endAt) : null;
+}
+function parseEventScalar(value) {
+  return localDateTimeToScalar(parseLocalDateTime(value));
+}
+function buildEventIdentity(resourceId, rawEvent) {
+  var _rawEvent$schedule_ev, _ref6, _rawEvent$booking_uid, _rawEvent$metadata, _ref7, _rawEvent$product_uid, _rawEvent$metadata2;
+  var scheduleEventId = (_rawEvent$schedule_ev = rawEvent.schedule_event_id) !== null && _rawEvent$schedule_ev !== void 0 ? _rawEvent$schedule_ev : rawEvent.scheduleEventId;
+  if (scheduleEventId !== undefined && scheduleEventId !== null && scheduleEventId !== '') {
+    return "scheduleEvent:".concat(String(resourceId), ":").concat(String(scheduleEventId));
+  }
+  var bookingUid = (_ref6 = (_rawEvent$booking_uid = rawEvent.booking_uid) !== null && _rawEvent$booking_uid !== void 0 ? _rawEvent$booking_uid : rawEvent.bookingUid) !== null && _ref6 !== void 0 ? _ref6 : (_rawEvent$metadata = rawEvent.metadata) === null || _rawEvent$metadata === void 0 ? void 0 : _rawEvent$metadata.unique_identification_number;
+  if (bookingUid !== undefined && bookingUid !== null && bookingUid !== '') {
+    return "bookingUid:".concat(String(resourceId), ":").concat(String(bookingUid));
+  }
+  var productUid = (_ref7 = (_rawEvent$product_uid = rawEvent.product_uid) !== null && _rawEvent$product_uid !== void 0 ? _rawEvent$product_uid : rawEvent.productUid) !== null && _ref7 !== void 0 ? _ref7 : (_rawEvent$metadata2 = rawEvent.metadata) === null || _rawEvent$metadata2 === void 0 ? void 0 : _rawEvent$metadata2.product_uid;
+  if (productUid !== undefined && productUid !== null && productUid !== '') {
+    return "productUid:".concat(String(resourceId), ":").concat(String(productUid));
+  }
+  return ['range', String(resourceId), getRawEventStartAt(rawEvent) || '', getRawEventEndAt(rawEvent) || ''].join(':');
+}
+function bucketEventDates(params) {
+  var startAt = getRawEventStartAt(params.rawEvent);
+  var endAt = getRawEventEndAt(params.rawEvent);
+  if (!startAt || !endAt) return [];
+  try {
+    var startScalar = parseEventScalar(startAt);
+    var endScalar = parseEventScalar(endAt);
+    if (endScalar <= startScalar) return [];
+    var endInclusiveScalar = endScalar - 1000;
+    var startDate = formatLocalDate(startScalar);
+    var endDate = formatLocalDate(endInclusiveScalar);
+    var startOrdinal = dateOrdinalFromLocalDate(startDate);
+    var endOrdinal = dateOrdinalFromLocalDate(endDate);
+    if (endOrdinal < startOrdinal) return [];
+    var dates = [];
+    var cursorDate = startDate;
+    for (var ordinal = startOrdinal; ordinal <= endOrdinal; ordinal += 1) {
+      if (params.requestedDates.has(cursorDate)) {
+        dates.push(cursorDate);
+      }
+      cursorDate = nextDate(cursorDate);
+    }
+    return dates;
+  } catch (_unused2) {
+    return [];
+  }
+}
+function sortEventList(events) {
+  return _toConsumableArray(events).sort(function (left, right) {
+    var _ref8, _left$resource_id, _ref9, _right$resource_id;
+    var leftStart = getRawEventStartAt(left) || '';
+    var rightStart = getRawEventStartAt(right) || '';
+    if (leftStart !== rightStart) return leftStart.localeCompare(rightStart);
+    var leftEnd = getRawEventEndAt(left) || '';
+    var rightEnd = getRawEventEndAt(right) || '';
+    if (leftEnd !== rightEnd) return leftEnd.localeCompare(rightEnd);
+    return buildEventIdentity((_ref8 = (_left$resource_id = left.resource_id) !== null && _left$resource_id !== void 0 ? _left$resource_id : left.resourceId) !== null && _ref8 !== void 0 ? _ref8 : '', left).localeCompare(buildEventIdentity((_ref9 = (_right$resource_id = right.resource_id) !== null && _right$resource_id !== void 0 ? _right$resource_id : right.resourceId) !== null && _ref9 !== void 0 ? _ref9 : '', right));
+  });
+}
+export var AvailabilityRemoteOccupancyCache = /*#__PURE__*/function () {
+  function AvailabilityRemoteOccupancyCache() {
+    var maxCells = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 4096;
+    _classCallCheck(this, AvailabilityRemoteOccupancyCache);
+    _defineProperty(this, "maxCells", void 0);
+    _defineProperty(this, "cells", new Map());
+    _defineProperty(this, "resourceMeta", new Map());
+    _defineProperty(this, "resourceCellCounts", new Map());
+    this.maxCells = maxCells;
+  }
+  _createClass(AvailabilityRemoteOccupancyCache, [{
+    key: "clear",
+    value: function clear() {
+      this.cells.clear();
+      this.resourceMeta.clear();
+      this.resourceCellCounts.clear();
+    }
+  }, {
+    key: "read",
+    value: function read(params) {
+      var _this = this;
+      var requestedResourceIds = uniqueIds(params.resourceIds);
+      var requestedDates = buildDateList(params.dateRange);
+      if (requestedResourceIds.length === 0 || requestedDates.length === 0) return [];
+      var resources = [];
+      var _iterator = _createForOfIteratorHelper(requestedResourceIds),
+        _step;
+      try {
+        var _loop = function _loop() {
+            var resourceId = _step.value;
+            var resourceKey = _this.buildResourceKey(params.scopeKey, resourceId);
+            var eventList = new Map();
+            var _iterator2 = _createForOfIteratorHelper(requestedDates),
+              _step2;
+            try {
+              for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                var date = _step2.value;
+                var cellKey = _this.buildCellKey(resourceKey, date);
+                var cell = _this.touchCell(cellKey);
+                if (!cell) return {
+                  v: null
+                };
+                cell.eventList.forEach(function (rawEvent) {
+                  eventList.set(buildEventIdentity(resourceId, rawEvent), cloneDeep(rawEvent));
+                });
+              }
+            } catch (err) {
+              _iterator2.e(err);
+            } finally {
+              _iterator2.f();
+            }
+            var metadataEntry = _this.resourceMeta.get(resourceKey);
+            if (!metadataEntry) return {
+              v: null
+            };
+            if (metadataEntry.status === 'absent') return 0; // continue
+            if (!metadataEntry.metadata) return {
+              v: null
+            };
+            resources.push(_objectSpread(_objectSpread({}, cloneDeep(metadataEntry.metadata)), {}, {
+              event_list: sortEventList(Array.from(eventList.values()))
+            }));
+          },
+          _ret;
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          _ret = _loop();
+          if (_ret === 0) continue;
+          if (_ret) return _ret.v;
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return resources;
+    }
+  }, {
+    key: "hasCompleteCoverage",
+    value: function hasCompleteCoverage(params) {
+      var requestedResourceIds = uniqueIds(params.resourceIds);
+      var requestedDates = buildDateList(params.dateRange);
+      if (requestedResourceIds.length === 0 || requestedDates.length === 0) return true;
+      var _iterator3 = _createForOfIteratorHelper(requestedResourceIds),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var resourceId = _step3.value;
+          var resourceKey = this.buildResourceKey(params.scopeKey, resourceId);
+          var _iterator4 = _createForOfIteratorHelper(requestedDates),
+            _step4;
+          try {
+            for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+              var date = _step4.value;
+              var cell = this.cells.get(this.buildCellKey(resourceKey, date));
+              if (!cell) return false;
+            }
+          } catch (err) {
+            _iterator4.e(err);
+          } finally {
+            _iterator4.f();
+          }
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      return true;
+    }
+  }, {
+    key: "publish",
+    value: function publish(params) {
+      var _this2 = this;
+      var requestedResourceIds = uniqueIds(params.resourceIds);
+      var requestedDates = buildDateList(params.dateRange);
+      if (requestedResourceIds.length === 0 || requestedDates.length === 0) return;
+      var requestedDateSet = new Set(requestedDates);
+      var publishedAt = Date.now();
+      var requestedResourceKeyById = new Map(requestedResourceIds.map(function (resourceId) {
+        return [String(resourceId), _this2.buildResourceKey(params.scopeKey, resourceId)];
+      }));
+      var rawResourceById = new Map();
+      (params.rawResources || []).forEach(function (rawResource) {
+        var resourceId = resolveResourceId(rawResource);
+        if (resourceId !== null && requestedResourceKeyById.has(String(resourceId))) {
+          rawResourceById.set(String(resourceId), rawResource);
+        }
+      });
+      requestedResourceIds.forEach(function (resourceId) {
+        var resourceKey = requestedResourceKeyById.get(String(resourceId));
+        if (!resourceKey) return;
+        if (!_this2.canPublishResourceRange(resourceKey, requestedDates, params.version)) return;
+        var rawResource = rawResourceById.get(String(resourceId));
+        var nextStatus = rawResource ? 'present' : 'absent';
+        var currentMetadata = _this2.resourceMeta.get(resourceKey);
+        if (currentMetadata && currentMetadata.version <= params.version && currentMetadata.status !== nextStatus) {
+          _this2.deleteResourceCells(resourceKey);
+        }
+        _this2.invalidateAdjacentOverlappingCells({
+          resourceKey: resourceKey,
+          requestedDates: requestedDateSet,
+          timezoneName: params.timezoneName
+        });
+        var metadata = rawResource ? function (_ref10) {
+          var _eventList = _ref10.event_list,
+            rest = _objectWithoutProperties(_ref10, _excluded);
+          return rest;
+        }(rawResource) : undefined;
+        _this2.writeResourceMeta(resourceKey, nextStatus, metadata, params.version);
+        var eventsByDate = new Map();
+        requestedDates.forEach(function (date) {
+          eventsByDate.set(date, new Map());
+        });
+        var eventList = Array.isArray(rawResource === null || rawResource === void 0 ? void 0 : rawResource.event_list) ? rawResource.event_list : [];
+        eventList.forEach(function (event) {
+          var rawEvent = cloneDeep(event);
+          var identity = buildEventIdentity(resourceId, rawEvent);
+          bucketEventDates({
+            rawEvent: rawEvent,
+            timezoneName: params.timezoneName,
+            requestedDates: requestedDateSet
+          }).forEach(function (date) {
+            var _eventsByDate$get;
+            (_eventsByDate$get = eventsByDate.get(date)) === null || _eventsByDate$get === void 0 || _eventsByDate$get.set(identity, rawEvent);
+          });
+        });
+        requestedDates.forEach(function (date) {
+          var _eventsByDate$get2;
+          _this2.writeCell({
+            key: _this2.buildCellKey(resourceKey, date),
+            resourceKey: resourceKey,
+            version: params.version,
+            eventList: sortEventList(Array.from(((_eventsByDate$get2 = eventsByDate.get(date)) === null || _eventsByDate$get2 === void 0 ? void 0 : _eventsByDate$get2.values()) || [])),
+            fetchedAt: publishedAt,
+            lastAccessedAt: publishedAt
+          });
+        });
+      });
+    }
+  }, {
+    key: "buildResourceKey",
+    value: function buildResourceKey(scopeKey, resourceId) {
+      return "".concat(scopeKey, ":").concat(String(resourceId));
+    }
+  }, {
+    key: "buildCellKey",
+    value: function buildCellKey(resourceKey, date) {
+      return "".concat(resourceKey, ":").concat(date);
+    }
+  }, {
+    key: "touchCell",
+    value: function touchCell(cellKey) {
+      var entry = this.cells.get(cellKey);
+      if (!entry) return null;
+      entry.lastAccessedAt = Date.now();
+      this.cells.delete(cellKey);
+      this.cells.set(cellKey, entry);
+      return entry;
+    }
+
+    /**
+     * A response is one coherent resource snapshot for its requested range. If any overlapping day
+     * already contains a newer response, publishing only the older response's remaining days would
+     * let a cross-midnight event leak back into that newer day when ranges are recomposed.
+     */
+  }, {
+    key: "canPublishResourceRange",
+    value: function canPublishResourceRange(resourceKey, requestedDates, version) {
+      var _this3 = this;
+      var metadata = this.resourceMeta.get(resourceKey);
+      if (metadata && metadata.version > version) return false;
+      return requestedDates.every(function (date) {
+        var current = _this3.cells.get(_this3.buildCellKey(resourceKey, date));
+        return !current || current.version <= version;
+      });
+    }
+
+    /**
+     * A day cell stores the original event range so it can be reconstructed without losing server
+     * identity. When a newer adjacent-day response replaces that event, evict older neighbour cells
+     * whose event overlaps the refreshed range. The next wider read becomes a cache miss instead of
+     * reintroducing stale occupancy from the neighbour.
+     */
+  }, {
+    key: "invalidateAdjacentOverlappingCells",
+    value: function invalidateAdjacentOverlappingCells(params) {
+      var _this4 = this;
+      var keysToDelete = [];
+      this.cells.forEach(function (cell, cellKey) {
+        if (cell.resourceKey !== params.resourceKey) return;
+        var cellDate = cellKey.slice(cell.resourceKey.length + 1);
+        if (params.requestedDates.has(cellDate)) return;
+        var overlapsRequestedDate = cell.eventList.some(function (rawEvent) {
+          return bucketEventDates({
+            rawEvent: rawEvent,
+            timezoneName: params.timezoneName,
+            requestedDates: params.requestedDates
+          }).length > 0;
+        });
+        if (overlapsRequestedDate) keysToDelete.push(cellKey);
+      });
+      keysToDelete.forEach(function (cellKey) {
+        return _this4.deleteCell(cellKey);
+      });
+    }
+  }, {
+    key: "deleteCell",
+    value: function deleteCell(cellKey) {
+      var entry = this.cells.get(cellKey);
+      if (!entry) return;
+      this.cells.delete(cellKey);
+      var nextCount = (this.resourceCellCounts.get(entry.resourceKey) || 1) - 1;
+      if (nextCount <= 0) {
+        this.resourceCellCounts.delete(entry.resourceKey);
+        this.resourceMeta.delete(entry.resourceKey);
+        return;
+      }
+      this.resourceCellCounts.set(entry.resourceKey, nextCount);
+    }
+  }, {
+    key: "deleteResourceCells",
+    value: function deleteResourceCells(resourceKey) {
+      var _this5 = this;
+      var keysToDelete = [];
+      this.cells.forEach(function (cell, cellKey) {
+        if (cell.resourceKey === resourceKey) keysToDelete.push(cellKey);
+      });
+      keysToDelete.forEach(function (cellKey) {
+        return _this5.deleteCell(cellKey);
+      });
+    }
+  }, {
+    key: "writeResourceMeta",
+    value: function writeResourceMeta(resourceKey, status, metadata, version) {
+      var current = this.resourceMeta.get(resourceKey);
+      if (current && current.version > version) return;
+      this.resourceMeta.set(resourceKey, {
+        version: version,
+        status: status,
+        metadata: metadata ? cloneDeep(metadata) : undefined
+      });
+    }
+  }, {
+    key: "writeCell",
+    value: function writeCell(entry) {
+      var current = this.cells.get(entry.key);
+      if (current && current.version > entry.version) return;
+      if (!current) {
+        this.resourceCellCounts.set(entry.resourceKey, (this.resourceCellCounts.get(entry.resourceKey) || 0) + 1);
+      } else {
+        this.cells.delete(entry.key);
+      }
+      this.cells.set(entry.key, _objectSpread(_objectSpread({}, entry), {}, {
+        eventList: cloneDeep(entry.eventList)
+      }));
+      while (this.cells.size > this.maxCells) {
+        var oldest = this.cells.entries().next().value;
+        if (!oldest) break;
+        var _oldest = _slicedToArray(oldest, 1),
+          oldestKey = _oldest[0];
+        this.deleteCell(oldestKey);
+      }
+    }
+  }]);
+  return AvailabilityRemoteOccupancyCache;
+}();