@unabridged/midwest 0.18.0 → 0.19.0

package/dist/javascript/collection/app/components/midwest/horizontal_scroll_component/horizontal_scroll_component_controller.js

@@ -0,0 +1,24 @@
+import { Controller } from '@hotwired/stimulus';
+
+class HorizontalScroll extends Controller {
+  resizeObserver = null;
+  connect() {
+    this.updateOverflow();
+    this.element.addEventListener("scroll", this.updateOverflow);
+    this.resizeObserver = new ResizeObserver(this.updateOverflow);
+    this.resizeObserver.observe(this.element);
+  }
+  disconnect() {
+    this.element.removeEventListener("scroll", this.updateOverflow);
+    this.resizeObserver?.disconnect();
+    this.resizeObserver = null;
+  }
+  updateOverflow = () => {
+    const el = this.element;
+    el.classList.toggle("can-scroll-left", el.scrollLeft > 0);
+    el.classList.toggle("can-scroll-right", el.scrollLeft < el.scrollWidth - el.clientWidth - 1);
+  };
+}
+
+export { HorizontalScroll as default };
+//# sourceMappingURL=horizontal_scroll_component_controller.js.map

package/dist/javascript/collection/app/components/midwest/horizontal_scroll_component/horizontal_scroll_component_controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"horizontal_scroll_component_controller.js","sources":["../../../../../../../app/components/midwest/horizontal_scroll_component/horizontal_scroll_component_controller.ts"],"sourcesContent":["import { Controller } from '@hotwired/stimulus'\n\nexport default class HorizontalScroll extends Controller<HTMLElement> {\n  private resizeObserver: ResizeObserver | null = null\n\n  connect () {\n    this.updateOverflow()\n    this.element.addEventListener('scroll', this.updateOverflow)\n    this.resizeObserver = new ResizeObserver(this.updateOverflow)\n    this.resizeObserver.observe(this.element)\n  }\n\n  disconnect () {\n    this.element.removeEventListener('scroll', this.updateOverflow)\n    this.resizeObserver?.disconnect()\n    this.resizeObserver = null\n  }\n\n  private updateOverflow = () => {\n    const el = this.element\n    el.classList.toggle('can-scroll-left', el.scrollLeft > 0)\n    el.classList.toggle('can-scroll-right', el.scrollLeft < el.scrollWidth - el.clientWidth - 1)\n  }\n}\n"],"names":[],"mappings":";;AAEA,MAAqB,yBAAyB,UAAwB,CAAA;AAAA,EAC5D,cAAwC,GAAA,IAAA,CAAA;AAAA,EAEhD,OAAW,GAAA;AACT,IAAA,IAAA,CAAK,cAAe,EAAA,CAAA;AACpB,IAAA,IAAA,CAAK,OAAQ,CAAA,gBAAA,CAAiB,QAAU,EAAA,IAAA,CAAK,cAAc,CAAA,CAAA;AAC3D,IAAA,IAAA,CAAK,cAAiB,GAAA,IAAI,cAAe,CAAA,IAAA,CAAK,cAAc,CAAA,CAAA;AAC5D,IAAK,IAAA,CAAA,cAAA,CAAe,OAAQ,CAAA,IAAA,CAAK,OAAO,CAAA,CAAA;AAAA,GAC1C;AAAA,EAEA,UAAc,GAAA;AACZ,IAAA,IAAA,CAAK,OAAQ,CAAA,mBAAA,CAAoB,QAAU,EAAA,IAAA,CAAK,cAAc,CAAA,CAAA;AAC9D,IAAA,IAAA,CAAK,gBAAgB,UAAW,EAAA,CAAA;AAChC,IAAA,IAAA,CAAK,cAAiB,GAAA,IAAA,CAAA;AAAA,GACxB;AAAA,EAEQ,iBAAiB,MAAM;AAC7B,IAAA,MAAM,KAAK,IAAK,CAAA,OAAA,CAAA;AAChB,IAAA,EAAA,CAAG,SAAU,CAAA,MAAA,CAAO,iBAAmB,EAAA,EAAA,CAAG,aAAa,CAAC,CAAA,CAAA;AACxD,IAAG,EAAA,CAAA,SAAA,CAAU,OAAO,kBAAoB,EAAA,EAAA,CAAG,aAAa,EAAG,CAAA,WAAA,GAAc,EAAG,CAAA,WAAA,GAAc,CAAC,CAAA,CAAA;AAAA,GAC7F,CAAA;AACF;;;;"}

package/dist/javascript/collection/app/components/midwest/table_component/load_more_controller.js

@@ -0,0 +1,60 @@
+import { Controller } from '@hotwired/stimulus';
+
+class LoadMore extends Controller {
+  static values = {
+    url: String,
+    tbodyId: String
+  };
+  observer = null;
+  loading = false;
+  connect() {
+    if (!this.urlValue)
+      return;
+    this.observer = new IntersectionObserver(
+      (entries) => {
+        if (entries[0].isIntersecting)
+          this.load();
+      },
+      // Start fetching 300px before the sentinel enters the viewport so rows
+      // appear before the user actually reaches the bottom.
+      { rootMargin: "0px 0px 300px 0px" }
+    );
+    this.observer.observe(this.element);
+  }
+  disconnect() {
+    this.observer?.disconnect();
+    this.observer = null;
+  }
+  async load() {
+    if (this.loading)
+      return;
+    this.loading = true;
+    this.observer?.disconnect();
+    try {
+      const response = await fetch(this.urlValue, {
+        headers: {
+          Accept: "text/html",
+          "X-Requested-With": "XMLHttpRequest"
+        },
+        credentials: "same-origin"
+      });
+      if (!response.ok)
+        return;
+      const html = await response.text();
+      const doc = new DOMParser().parseFromString(html, "text/html");
+      const tbody = document.getElementById(this.tbodyIdValue);
+      const newRows = Array.from(
+        doc.querySelectorAll(".midwest-table-body tr")
+      );
+      if (!tbody || newRows.length === 0)
+        return;
+      this.element.remove();
+      newRows.forEach((row) => tbody.appendChild(document.importNode(row, true)));
+    } catch {
+      this.loading = false;
+    }
+  }
+}
+
+export { LoadMore as default };
+//# sourceMappingURL=load_more_controller.js.map

package/dist/javascript/collection/app/components/midwest/table_component/load_more_controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"load_more_controller.js","sources":["../../../../../../../app/components/midwest/table_component/load_more_controller.ts"],"sourcesContent":["import { Controller } from '@hotwired/stimulus'\n\n// Enables infinite scroll on a `midwest-table` by observing a sentinel <tr>\n// element at the bottom of the tbody.  When the sentinel scrolls near the\n// viewport, this controller fetches the next-page URL, extracts the new <tr>\n// elements from the returned HTML, and appends them (plus the new sentinel,\n// if present) to the current tbody — replacing itself in the process.\n//\n// Values\n//   url      — URL for the next page (built by TablePresenter#next_page_url)\n//   tbodyId  — DOM id of the <tbody> to append rows into\nexport default class LoadMore extends Controller<HTMLTableRowElement> {\n  static values = {\n    url:     String,\n    tbodyId: String,\n  }\n\n  declare urlValue:     string\n  declare tbodyIdValue: string\n\n  private observer: IntersectionObserver | null = null\n  private loading = false\n\n  connect () {\n    // No URL means this is the last page — nothing to load.\n    if (!this.urlValue) return\n\n    this.observer = new IntersectionObserver(\n      (entries) => { if (entries[0].isIntersecting) this.load() },\n      // Start fetching 300px before the sentinel enters the viewport so rows\n      // appear before the user actually reaches the bottom.\n      { rootMargin: '0px 0px 300px 0px' }\n    )\n    this.observer.observe(this.element)\n  }\n\n  disconnect () {\n    this.observer?.disconnect()\n    this.observer = null\n  }\n\n  private async load () {\n    if (this.loading) return\n    this.loading = true\n    this.observer?.disconnect()\n\n    try {\n      const response = await fetch(this.urlValue, {\n        headers: {\n          Accept:            'text/html',\n          'X-Requested-With': 'XMLHttpRequest',\n        },\n        credentials: 'same-origin',\n      })\n\n      if (!response.ok) return\n\n      const html    = await response.text()\n      const doc     = new DOMParser().parseFromString(html, 'text/html')\n      const tbody   = document.getElementById(this.tbodyIdValue)\n      const newRows = Array.from(\n        doc.querySelectorAll<HTMLTableRowElement>('.midwest-table-body tr')\n      )\n\n      if (!tbody || newRows.length === 0) return\n\n      // Remove the current sentinel before appending new rows so its position\n      // doesn't shift the table layout during the DOM update.\n      this.element.remove()\n\n      // Import each row (including any new sentinel for the next page) into the\n      // current document and append it to the live tbody.\n      newRows.forEach(row => tbody.appendChild(document.importNode(row, true)))\n    } catch {\n      // Silently fail — the table remains fully functional, just without\n      // auto-loading more rows.\n      this.loading = false\n    }\n  }\n}\n"],"names":[],"mappings":";;AAWA,MAAqB,iBAAiB,UAAgC,CAAA;AAAA,EACpE,OAAO,MAAS,GAAA;AAAA,IACd,GAAS,EAAA,MAAA;AAAA,IACT,OAAS,EAAA,MAAA;AAAA,GACX,CAAA;AAAA,EAKQ,QAAwC,GAAA,IAAA,CAAA;AAAA,EACxC,OAAU,GAAA,KAAA,CAAA;AAAA,EAElB,OAAW,GAAA;AAET,IAAA,IAAI,CAAC,IAAK,CAAA,QAAA;AAAU,MAAA,OAAA;AAEpB,IAAA,IAAA,CAAK,WAAW,IAAI,oBAAA;AAAA,MAClB,CAAC,OAAY,KAAA;AAAE,QAAI,IAAA,OAAA,CAAQ,CAAC,CAAE,CAAA,cAAA;AAAgB,UAAA,IAAA,CAAK,IAAK,EAAA,CAAA;AAAA,OAAE;AAAA;AAAA;AAAA,MAG1D,EAAE,YAAY,mBAAoB,EAAA;AAAA,KACpC,CAAA;AACA,IAAK,IAAA,CAAA,QAAA,CAAS,OAAQ,CAAA,IAAA,CAAK,OAAO,CAAA,CAAA;AAAA,GACpC;AAAA,EAEA,UAAc,GAAA;AACZ,IAAA,IAAA,CAAK,UAAU,UAAW,EAAA,CAAA;AAC1B,IAAA,IAAA,CAAK,QAAW,GAAA,IAAA,CAAA;AAAA,GAClB;AAAA,EAEA,MAAc,IAAQ,GAAA;AACpB,IAAA,IAAI,IAAK,CAAA,OAAA;AAAS,MAAA,OAAA;AAClB,IAAA,IAAA,CAAK,OAAU,GAAA,IAAA,CAAA;AACf,IAAA,IAAA,CAAK,UAAU,UAAW,EAAA,CAAA;AAE1B,IAAI,IAAA;AACF,MAAA,MAAM,QAAW,GAAA,MAAM,KAAM,CAAA,IAAA,CAAK,QAAU,EAAA;AAAA,QAC1C,OAAS,EAAA;AAAA,UACP,MAAmB,EAAA,WAAA;AAAA,UACnB,kBAAoB,EAAA,gBAAA;AAAA,SACtB;AAAA,QACA,WAAa,EAAA,aAAA;AAAA,OACd,CAAA,CAAA;AAED,MAAA,IAAI,CAAC,QAAS,CAAA,EAAA;AAAI,QAAA,OAAA;AAElB,MAAM,MAAA,IAAA,GAAU,MAAM,QAAA,CAAS,IAAK,EAAA,CAAA;AACpC,MAAA,MAAM,MAAU,IAAI,SAAA,EAAY,CAAA,eAAA,CAAgB,MAAM,WAAW,CAAA,CAAA;AACjE,MAAA,MAAM,KAAU,GAAA,QAAA,CAAS,cAAe,CAAA,IAAA,CAAK,YAAY,CAAA,CAAA;AACzD,MAAA,MAAM,UAAU,KAAM,CAAA,IAAA;AAAA,QACpB,GAAA,CAAI,iBAAsC,wBAAwB,CAAA;AAAA,OACpE,CAAA;AAEA,MAAI,IAAA,CAAC,KAAS,IAAA,OAAA,CAAQ,MAAW,KAAA,CAAA;AAAG,QAAA,OAAA;AAIpC,MAAA,IAAA,CAAK,QAAQ,MAAO,EAAA,CAAA;AAIpB,MAAQ,OAAA,CAAA,OAAA,CAAQ,SAAO,KAAM,CAAA,WAAA,CAAY,SAAS,UAAW,CAAA,GAAA,EAAK,IAAI,CAAC,CAAC,CAAA,CAAA;AAAA,KACxE,CAAA,MAAA;AAGA,MAAA,IAAA,CAAK,OAAU,GAAA,KAAA,CAAA;AAAA,KACjB;AAAA,GACF;AACF;;;;"}

package/dist/javascript/collection/app/components/midwest/table_component/table_component_controller.js

@@ -0,0 +1,30 @@
+import { Controller } from '@hotwired/stimulus';
+
+class Table extends Controller {
+  static targets = ["selectAll", "rowCheckbox"];
+  toggleAll() {
+    const checked = this.selectAllTarget.checked;
+    this.rowCheckboxTargets.forEach((cb) => {
+      cb.checked = checked;
+    });
+  }
+  updateSelectAll() {
+    if (!this.hasSelectAllTarget)
+      return;
+    const total = this.rowCheckboxTargets.length;
+    const checkedCount = this.rowCheckboxTargets.filter((cb) => cb.checked).length;
+    if (checkedCount === 0) {
+      this.selectAllTarget.checked = false;
+      this.selectAllTarget.indeterminate = false;
+    } else if (checkedCount === total) {
+      this.selectAllTarget.checked = true;
+      this.selectAllTarget.indeterminate = false;
+    } else {
+      this.selectAllTarget.checked = false;
+      this.selectAllTarget.indeterminate = true;
+    }
+  }
+}
+
+export { Table as default };
+//# sourceMappingURL=table_component_controller.js.map

package/dist/javascript/collection/app/components/midwest/table_component/table_component_controller.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table_component_controller.js","sources":["../../../../../../../app/components/midwest/table_component/table_component_controller.ts"],"sourcesContent":["import { Controller } from '@hotwired/stimulus'\n\nexport default class Table extends Controller<HTMLElement> {\n  static targets = ['selectAll', 'rowCheckbox']\n\n  declare readonly selectAllTarget: HTMLInputElement\n  declare readonly rowCheckboxTargets: HTMLInputElement[]\n  declare readonly hasSelectAllTarget: boolean\n\n  toggleAll () {\n    const checked = this.selectAllTarget.checked\n    this.rowCheckboxTargets.forEach(cb => { cb.checked = checked })\n  }\n\n  updateSelectAll () {\n    if (!this.hasSelectAllTarget) return\n\n    const total = this.rowCheckboxTargets.length\n    const checkedCount = this.rowCheckboxTargets.filter(cb => cb.checked).length\n\n    if (checkedCount === 0) {\n      this.selectAllTarget.checked = false\n      this.selectAllTarget.indeterminate = false\n    } else if (checkedCount === total) {\n      this.selectAllTarget.checked = true\n      this.selectAllTarget.indeterminate = false\n    } else {\n      this.selectAllTarget.checked = false\n      this.selectAllTarget.indeterminate = true\n    }\n  }\n}\n"],"names":[],"mappings":";;AAEA,MAAqB,cAAc,UAAwB,CAAA;AAAA,EACzD,OAAO,OAAA,GAAU,CAAC,WAAA,EAAa,aAAa,CAAA,CAAA;AAAA,EAM5C,SAAa,GAAA;AACX,IAAM,MAAA,OAAA,GAAU,KAAK,eAAgB,CAAA,OAAA,CAAA;AACrC,IAAK,IAAA,CAAA,kBAAA,CAAmB,QAAQ,CAAM,EAAA,KAAA;AAAE,MAAA,EAAA,CAAG,OAAU,GAAA,OAAA,CAAA;AAAA,KAAS,CAAA,CAAA;AAAA,GAChE;AAAA,EAEA,eAAmB,GAAA;AACjB,IAAA,IAAI,CAAC,IAAK,CAAA,kBAAA;AAAoB,MAAA,OAAA;AAE9B,IAAM,MAAA,KAAA,GAAQ,KAAK,kBAAmB,CAAA,MAAA,CAAA;AACtC,IAAA,MAAM,eAAe,IAAK,CAAA,kBAAA,CAAmB,OAAO,CAAM,EAAA,KAAA,EAAA,CAAG,OAAO,CAAE,CAAA,MAAA,CAAA;AAEtE,IAAA,IAAI,iBAAiB,CAAG,EAAA;AACtB,MAAA,IAAA,CAAK,gBAAgB,OAAU,GAAA,KAAA,CAAA;AAC/B,MAAA,IAAA,CAAK,gBAAgB,aAAgB,GAAA,KAAA,CAAA;AAAA,KACvC,MAAA,IAAW,iBAAiB,KAAO,EAAA;AACjC,MAAA,IAAA,CAAK,gBAAgB,OAAU,GAAA,IAAA,CAAA;AAC/B,MAAA,IAAA,CAAK,gBAAgB,aAAgB,GAAA,KAAA,CAAA;AAAA,KAChC,MAAA;AACL,MAAA,IAAA,CAAK,gBAAgB,OAAU,GAAA,KAAA,CAAA;AAC/B,MAAA,IAAA,CAAK,gBAAgB,aAAgB,GAAA,IAAA,CAAA;AAAA,KACvC;AAAA,GACF;AACF;;;;"}

package/dist/javascript/collection/node_modules/@floating-ui/core/dist/floating-ui.core.js

@@ -0,0 +1,561 @@
+import { evaluate, placements, getAlignmentSides, getSide, getAlignment, getSideAxis, clamp, getAlignmentAxis, getPaddingObject, rectToClientRect, getOppositeAlignmentPlacement, sides, getOppositeAxis, getAxisLength } from '../../utils/dist/floating-ui.utils.js';
+
+function computeCoordsFromPlacement(_ref, placement, rtl) {
+  let {
+    reference,
+    floating
+  } = _ref;
+  const sideAxis = getSideAxis(placement);
+  const alignmentAxis = getAlignmentAxis(placement);
+  const alignLength = getAxisLength(alignmentAxis);
+  const side = getSide(placement);
+  const isVertical = sideAxis === 'y';
+  const commonX = reference.x + reference.width / 2 - floating.width / 2;
+  const commonY = reference.y + reference.height / 2 - floating.height / 2;
+  const commonAlign = reference[alignLength] / 2 - floating[alignLength] / 2;
+  let coords;
+  switch (side) {
+    case 'top':
+      coords = {
+        x: commonX,
+        y: reference.y - floating.height
+      };
+      break;
+    case 'bottom':
+      coords = {
+        x: commonX,
+        y: reference.y + reference.height
+      };
+      break;
+    case 'right':
+      coords = {
+        x: reference.x + reference.width,
+        y: commonY
+      };
+      break;
+    case 'left':
+      coords = {
+        x: reference.x - floating.width,
+        y: commonY
+      };
+      break;
+    default:
+      coords = {
+        x: reference.x,
+        y: reference.y
+      };
+  }
+  switch (getAlignment(placement)) {
+    case 'start':
+      coords[alignmentAxis] -= commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+    case 'end':
+      coords[alignmentAxis] += commonAlign * (rtl && isVertical ? -1 : 1);
+      break;
+  }
+  return coords;
+}
+
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+async function detectOverflow(state, options) {
+  var _await$platform$isEle;
+  if (options === void 0) {
+    options = {};
+  }
+  const {
+    x,
+    y,
+    platform,
+    rects,
+    elements,
+    strategy
+  } = state;
+  const {
+    boundary = 'clippingAncestors',
+    rootBoundary = 'viewport',
+    elementContext = 'floating',
+    altBoundary = false,
+    padding = 0
+  } = evaluate(options, state);
+  const paddingObject = getPaddingObject(padding);
+  const altContext = elementContext === 'floating' ? 'reference' : 'floating';
+  const element = elements[altBoundary ? altContext : elementContext];
+  const clippingClientRect = rectToClientRect(await platform.getClippingRect({
+    element: ((_await$platform$isEle = await (platform.isElement == null ? void 0 : platform.isElement(element))) != null ? _await$platform$isEle : true) ? element : element.contextElement || (await (platform.getDocumentElement == null ? void 0 : platform.getDocumentElement(elements.floating))),
+    boundary,
+    rootBoundary,
+    strategy
+  }));
+  const rect = elementContext === 'floating' ? {
+    x,
+    y,
+    width: rects.floating.width,
+    height: rects.floating.height
+  } : rects.reference;
+  const offsetParent = await (platform.getOffsetParent == null ? void 0 : platform.getOffsetParent(elements.floating));
+  const offsetScale = (await (platform.isElement == null ? void 0 : platform.isElement(offsetParent))) ? (await (platform.getScale == null ? void 0 : platform.getScale(offsetParent))) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  };
+  const elementClientRect = rectToClientRect(platform.convertOffsetParentRelativeRectToViewportRelativeRect ? await platform.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements,
+    rect,
+    offsetParent,
+    strategy
+  }) : rect);
+  return {
+    top: (clippingClientRect.top - elementClientRect.top + paddingObject.top) / offsetScale.y,
+    bottom: (elementClientRect.bottom - clippingClientRect.bottom + paddingObject.bottom) / offsetScale.y,
+    left: (clippingClientRect.left - elementClientRect.left + paddingObject.left) / offsetScale.x,
+    right: (elementClientRect.right - clippingClientRect.right + paddingObject.right) / offsetScale.x
+  };
+}
+
+// Maximum number of resets that can occur before bailing to avoid infinite reset loops.
+const MAX_RESET_COUNT = 50;
+
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ *
+ * This export does not have any `platform` interface logic. You will need to
+ * write one for the platform you are using Floating UI with.
+ */
+const computePosition = async (reference, floating, config) => {
+  const {
+    placement = 'bottom',
+    strategy = 'absolute',
+    middleware = [],
+    platform
+  } = config;
+  const platformWithDetectOverflow = platform.detectOverflow ? platform : {
+    ...platform,
+    detectOverflow
+  };
+  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(floating));
+  let rects = await platform.getElementRects({
+    reference,
+    floating,
+    strategy
+  });
+  let {
+    x,
+    y
+  } = computeCoordsFromPlacement(rects, placement, rtl);
+  let statefulPlacement = placement;
+  let resetCount = 0;
+  const middlewareData = {};
+  for (let i = 0; i < middleware.length; i++) {
+    const currentMiddleware = middleware[i];
+    if (!currentMiddleware) {
+      continue;
+    }
+    const {
+      name,
+      fn
+    } = currentMiddleware;
+    const {
+      x: nextX,
+      y: nextY,
+      data,
+      reset
+    } = await fn({
+      x,
+      y,
+      initialPlacement: placement,
+      placement: statefulPlacement,
+      strategy,
+      middlewareData,
+      rects,
+      platform: platformWithDetectOverflow,
+      elements: {
+        reference,
+        floating
+      }
+    });
+    x = nextX != null ? nextX : x;
+    y = nextY != null ? nextY : y;
+    middlewareData[name] = {
+      ...middlewareData[name],
+      ...data
+    };
+    if (reset && resetCount < MAX_RESET_COUNT) {
+      resetCount++;
+      if (typeof reset === 'object') {
+        if (reset.placement) {
+          statefulPlacement = reset.placement;
+        }
+        if (reset.rects) {
+          rects = reset.rects === true ? await platform.getElementRects({
+            reference,
+            floating,
+            strategy
+          }) : reset.rects;
+        }
+        ({
+          x,
+          y
+        } = computeCoordsFromPlacement(rects, statefulPlacement, rtl));
+      }
+      i = -1;
+    }
+  }
+  return {
+    x,
+    y,
+    placement: statefulPlacement,
+    strategy,
+    middlewareData
+  };
+};
+
+function getPlacementList(alignment, autoAlignment, allowedPlacements) {
+  const allowedPlacementsSortedByAlignment = alignment ? [...allowedPlacements.filter(placement => getAlignment(placement) === alignment), ...allowedPlacements.filter(placement => getAlignment(placement) !== alignment)] : allowedPlacements.filter(placement => getSide(placement) === placement);
+  return allowedPlacementsSortedByAlignment.filter(placement => {
+    if (alignment) {
+      return getAlignment(placement) === alignment || (autoAlignment ? getOppositeAlignmentPlacement(placement) !== placement : false);
+    }
+    return true;
+  });
+}
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+const autoPlacement = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'autoPlacement',
+    options,
+    async fn(state) {
+      var _middlewareData$autoP, _middlewareData$autoP2, _placementsThatFitOnE;
+      const {
+        rects,
+        middlewareData,
+        placement,
+        platform,
+        elements
+      } = state;
+      const {
+        crossAxis = false,
+        alignment,
+        allowedPlacements = placements,
+        autoAlignment = true,
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const placements$1 = alignment !== undefined || allowedPlacements === placements ? getPlacementList(alignment || null, autoAlignment, allowedPlacements) : allowedPlacements;
+      const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+      const currentIndex = ((_middlewareData$autoP = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP.index) || 0;
+      const currentPlacement = placements$1[currentIndex];
+      if (currentPlacement == null) {
+        return {};
+      }
+      const alignmentSides = getAlignmentSides(currentPlacement, rects, await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating)));
+
+      // Make `computeCoords` start from the right place.
+      if (placement !== currentPlacement) {
+        return {
+          reset: {
+            placement: placements$1[0]
+          }
+        };
+      }
+      const currentOverflows = [overflow[getSide(currentPlacement)], overflow[alignmentSides[0]], overflow[alignmentSides[1]]];
+      const allOverflows = [...(((_middlewareData$autoP2 = middlewareData.autoPlacement) == null ? void 0 : _middlewareData$autoP2.overflows) || []), {
+        placement: currentPlacement,
+        overflows: currentOverflows
+      }];
+      const nextPlacement = placements$1[currentIndex + 1];
+
+      // There are more placements to check.
+      if (nextPlacement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: nextPlacement
+          }
+        };
+      }
+      const placementsSortedByMostSpace = allOverflows.map(d => {
+        const alignment = getAlignment(d.placement);
+        return [d.placement, alignment && crossAxis ?
+        // Check along the mainAxis and main crossAxis side.
+        d.overflows.slice(0, 2).reduce((acc, v) => acc + v, 0) :
+        // Check only the mainAxis.
+        d.overflows[0], d.overflows];
+      }).sort((a, b) => a[1] - b[1]);
+      const placementsThatFitOnEachSide = placementsSortedByMostSpace.filter(d => d[2].slice(0,
+      // Aligned placements should not check their opposite crossAxis
+      // side.
+      getAlignment(d[0]) ? 2 : 3).every(v => v <= 0));
+      const resetPlacement = ((_placementsThatFitOnE = placementsThatFitOnEachSide[0]) == null ? void 0 : _placementsThatFitOnE[0]) || placementsSortedByMostSpace[0][0];
+      if (resetPlacement !== placement) {
+        return {
+          data: {
+            index: currentIndex + 1,
+            overflows: allOverflows
+          },
+          reset: {
+            placement: resetPlacement
+          }
+        };
+      }
+      return {};
+    }
+  };
+};
+
+function getSideOffsets(overflow, rect) {
+  return {
+    top: overflow.top - rect.height,
+    right: overflow.right - rect.width,
+    bottom: overflow.bottom - rect.height,
+    left: overflow.left - rect.width
+  };
+}
+function isAnySideFullyClipped(overflow) {
+  return sides.some(side => overflow[side] >= 0);
+}
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+const hide = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'hide',
+    options,
+    async fn(state) {
+      const {
+        rects,
+        platform
+      } = state;
+      const {
+        strategy = 'referenceHidden',
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      switch (strategy) {
+        case 'referenceHidden':
+          {
+            const overflow = await platform.detectOverflow(state, {
+              ...detectOverflowOptions,
+              elementContext: 'reference'
+            });
+            const offsets = getSideOffsets(overflow, rects.reference);
+            return {
+              data: {
+                referenceHiddenOffsets: offsets,
+                referenceHidden: isAnySideFullyClipped(offsets)
+              }
+            };
+          }
+        case 'escaped':
+          {
+            const overflow = await platform.detectOverflow(state, {
+              ...detectOverflowOptions,
+              altBoundary: true
+            });
+            const offsets = getSideOffsets(overflow, rects.floating);
+            return {
+              data: {
+                escapedOffsets: offsets,
+                escaped: isAnySideFullyClipped(offsets)
+              }
+            };
+          }
+        default:
+          {
+            return {};
+          }
+      }
+    }
+  };
+};
+
+const originSides = /*#__PURE__*/new Set(['left', 'top']);
+
+// For type backwards-compatibility, the `OffsetOptions` type was also
+// Derivable.
+
+async function convertValueToCoords(state, options) {
+  const {
+    placement,
+    platform,
+    elements
+  } = state;
+  const rtl = await (platform.isRTL == null ? void 0 : platform.isRTL(elements.floating));
+  const side = getSide(placement);
+  const alignment = getAlignment(placement);
+  const isVertical = getSideAxis(placement) === 'y';
+  const mainAxisMulti = originSides.has(side) ? -1 : 1;
+  const crossAxisMulti = rtl && isVertical ? -1 : 1;
+  const rawValue = evaluate(options, state);
+
+  // eslint-disable-next-line prefer-const
+  let {
+    mainAxis,
+    crossAxis,
+    alignmentAxis
+  } = typeof rawValue === 'number' ? {
+    mainAxis: rawValue,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: rawValue.mainAxis || 0,
+    crossAxis: rawValue.crossAxis || 0,
+    alignmentAxis: rawValue.alignmentAxis
+  };
+  if (alignment && typeof alignmentAxis === 'number') {
+    crossAxis = alignment === 'end' ? alignmentAxis * -1 : alignmentAxis;
+  }
+  return isVertical ? {
+    x: crossAxis * crossAxisMulti,
+    y: mainAxis * mainAxisMulti
+  } : {
+    x: mainAxis * mainAxisMulti,
+    y: crossAxis * crossAxisMulti
+  };
+}
+
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+const offset = function (options) {
+  if (options === void 0) {
+    options = 0;
+  }
+  return {
+    name: 'offset',
+    options,
+    async fn(state) {
+      var _middlewareData$offse, _middlewareData$arrow;
+      const {
+        x,
+        y,
+        placement,
+        middlewareData
+      } = state;
+      const diffCoords = await convertValueToCoords(state, options);
+
+      // If the placement is the same and the arrow caused an alignment offset
+      // then we don't need to change the positioning coordinates.
+      if (placement === ((_middlewareData$offse = middlewareData.offset) == null ? void 0 : _middlewareData$offse.placement) && (_middlewareData$arrow = middlewareData.arrow) != null && _middlewareData$arrow.alignmentOffset) {
+        return {};
+      }
+      return {
+        x: x + diffCoords.x,
+        y: y + diffCoords.y,
+        data: {
+          ...diffCoords,
+          placement
+        }
+      };
+    }
+  };
+};
+
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+const shift = function (options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    name: 'shift',
+    options,
+    async fn(state) {
+      const {
+        x,
+        y,
+        placement,
+        platform
+      } = state;
+      const {
+        mainAxis: checkMainAxis = true,
+        crossAxis: checkCrossAxis = false,
+        limiter = {
+          fn: _ref => {
+            let {
+              x,
+              y
+            } = _ref;
+            return {
+              x,
+              y
+            };
+          }
+        },
+        ...detectOverflowOptions
+      } = evaluate(options, state);
+      const coords = {
+        x,
+        y
+      };
+      const overflow = await platform.detectOverflow(state, detectOverflowOptions);
+      const crossAxis = getSideAxis(getSide(placement));
+      const mainAxis = getOppositeAxis(crossAxis);
+      let mainAxisCoord = coords[mainAxis];
+      let crossAxisCoord = coords[crossAxis];
+      if (checkMainAxis) {
+        const minSide = mainAxis === 'y' ? 'top' : 'left';
+        const maxSide = mainAxis === 'y' ? 'bottom' : 'right';
+        const min = mainAxisCoord + overflow[minSide];
+        const max = mainAxisCoord - overflow[maxSide];
+        mainAxisCoord = clamp(min, mainAxisCoord, max);
+      }
+      if (checkCrossAxis) {
+        const minSide = crossAxis === 'y' ? 'top' : 'left';
+        const maxSide = crossAxis === 'y' ? 'bottom' : 'right';
+        const min = crossAxisCoord + overflow[minSide];
+        const max = crossAxisCoord - overflow[maxSide];
+        crossAxisCoord = clamp(min, crossAxisCoord, max);
+      }
+      const limitedCoords = limiter.fn({
+        ...state,
+        [mainAxis]: mainAxisCoord,
+        [crossAxis]: crossAxisCoord
+      });
+      return {
+        ...limitedCoords,
+        data: {
+          x: limitedCoords.x - x,
+          y: limitedCoords.y - y,
+          enabled: {
+            [mainAxis]: checkMainAxis,
+            [crossAxis]: checkCrossAxis
+          }
+        }
+      };
+    }
+  };
+};
+
+export { autoPlacement, computePosition, detectOverflow, hide, offset, rectToClientRect, shift };
+//# sourceMappingURL=floating-ui.core.js.map