bitz-react-admin-ui 1.7.0 → 1.7.2

package/dist/node_modules/.store/@fullcalendar_timegrid@6.1.11/node_modules/@fullcalendar/timegrid/internal.mjs

@@ -0,0 +1,900 @@
+import { DayTable as le } from "../../../../@fullcalendar_daygrid@6.1.11/node_modules/@fullcalendar/daygrid/internal.mjs";
+import { x as k, z as v, bK as ae, bO as de, bV as ce, cw as fe, be as H, bl as he, b0 as ge, cq as ue, C as L, cc as G, b$ as me, ct as j, cb as pe, ch as X, ck as O, ca as q, d as M, bs as C, bt as F, bu as ve, bp as A, aY as be, bP as Se, B as y, V as ye, bo as xe, bW as Ce, o as we, cf as Z, ba as $, H as Re, q as U, bR as De, cm as ke, cl as Ee, bS as W, bw as Te, cs as Me, cp as Ne, co as Pe, bT as Ie, cr as ze, cj as Ae, bE as We, bA as He, bD as Le, bC as Oe, bB as J } from "../../../../@fullcalendar_core@6.1.11/node_modules/@fullcalendar/core/internal-common.mjs";
+import { createElement as l, createRef as w, Fragment as T } from "../../../../preact@10.12.1/node_modules/preact/dist/preact.module.mjs";
+class Fe extends be {
+  getKeyInfo() {
+    return {
+      allDay: {},
+      timed: {}
+    };
+  }
+  getKeysForDateSpan(e) {
+    return e.allDay ? ["allDay"] : ["timed"];
+  }
+  getKeysForEventDef(e) {
+    return e.allDay ? Se(e) ? ["timed", "allDay"] : ["allDay"] : ["timed"];
+  }
+}
+const Be = k({
+  hour: "numeric",
+  minute: "2-digit",
+  omitZeroMinute: !0,
+  meridiem: "short"
+});
+function Q(n) {
+  let e = [
+    "fc-timegrid-slot",
+    "fc-timegrid-slot-label",
+    n.isLabeled ? "fc-scrollgrid-shrink" : "fc-timegrid-slot-minor"
+  ];
+  return l(ye.Consumer, null, (t) => {
+    if (!n.isLabeled)
+      return l("td", { className: e.join(" "), "data-time": n.isoTimeStr });
+    let { dateEnv: i, options: s, viewApi: r } = t, o = (
+      // TODO: fully pre-parse
+      s.slotLabelFormat == null ? Be : Array.isArray(s.slotLabelFormat) ? k(s.slotLabelFormat[0]) : k(s.slotLabelFormat)
+    ), a = {
+      level: 0,
+      time: n.time,
+      date: i.toDate(n.date),
+      view: r,
+      text: i.format(n.date, o)
+    };
+    return l(L, { elTag: "td", elClasses: e, elAttrs: {
+      "data-time": n.isoTimeStr
+    }, renderProps: a, generatorName: "slotLabelContent", customGenerator: s.slotLabelContent, defaultGenerator: Ge, classNameGenerator: s.slotLabelClassNames, didMount: s.slotLabelDidMount, willUnmount: s.slotLabelWillUnmount }, (d) => l(
+      "div",
+      { className: "fc-timegrid-slot-label-frame fc-scrollgrid-shrink-frame" },
+      l(d, { elTag: "div", elClasses: [
+        "fc-timegrid-slot-label-cushion",
+        "fc-scrollgrid-shrink-cushion"
+      ] })
+    ));
+  });
+}
+function Ge(n) {
+  return n.text;
+}
+class je extends y {
+  render() {
+    return this.props.slatMetas.map((e) => l(
+      "tr",
+      { key: e.key },
+      l(Q, Object.assign({}, e))
+    ));
+  }
+}
+const qe = k({ week: "short" }), Ue = 5;
+class _e extends H {
+  constructor() {
+    super(...arguments), this.allDaySplitter = new Fe(), this.headerElRef = w(), this.rootElRef = w(), this.scrollerElRef = w(), this.state = {
+      slatCoords: null
+    }, this.handleScrollTopRequest = (e) => {
+      let t = this.scrollerElRef.current;
+      t && (t.scrollTop = e);
+    }, this.renderHeadAxis = (e, t = "") => {
+      let { options: i } = this.context, { dateProfile: s } = this.props, r = s.renderRange, a = he(r.start, r.end) === 1 ? ge(this.context, r.start, "week") : {};
+      return i.weekNumbers && e === "day" ? l(ue, { elTag: "th", elClasses: [
+        "fc-timegrid-axis",
+        "fc-scrollgrid-shrink"
+      ], elAttrs: {
+        "aria-hidden": !0
+      }, date: r.start, defaultFormat: qe }, (d) => l(
+        "div",
+        { className: [
+          "fc-timegrid-axis-frame",
+          "fc-scrollgrid-shrink-frame",
+          "fc-timegrid-axis-frame-liquid"
+        ].join(" "), style: { height: t } },
+        l(d, { elTag: "a", elClasses: [
+          "fc-timegrid-axis-cushion",
+          "fc-scrollgrid-shrink-cushion",
+          "fc-scrollgrid-sync-inner"
+        ], elAttrs: a })
+      )) : l(
+        "th",
+        { "aria-hidden": !0, className: "fc-timegrid-axis" },
+        l("div", { className: "fc-timegrid-axis-frame", style: { height: t } })
+      );
+    }, this.renderTableRowAxis = (e) => {
+      let { options: t, viewApi: i } = this.context, s = {
+        text: t.allDayText,
+        view: i
+      };
+      return (
+        // TODO: make reusable hook. used in list view too
+        l(L, { elTag: "td", elClasses: [
+          "fc-timegrid-axis",
+          "fc-scrollgrid-shrink"
+        ], elAttrs: {
+          "aria-hidden": !0
+        }, renderProps: s, generatorName: "allDayContent", customGenerator: t.allDayContent, defaultGenerator: Ve, classNameGenerator: t.allDayClassNames, didMount: t.allDayDidMount, willUnmount: t.allDayWillUnmount }, (r) => l(
+          "div",
+          { className: [
+            "fc-timegrid-axis-frame",
+            "fc-scrollgrid-shrink-frame",
+            e == null ? " fc-timegrid-axis-frame-liquid" : ""
+          ].join(" "), style: { height: e } },
+          l(r, { elTag: "span", elClasses: [
+            "fc-timegrid-axis-cushion",
+            "fc-scrollgrid-shrink-cushion",
+            "fc-scrollgrid-sync-inner"
+          ] })
+        ))
+      );
+    }, this.handleSlatCoords = (e) => {
+      this.setState({ slatCoords: e });
+    };
+  }
+  // rendering
+  // ----------------------------------------------------------------------------------------------------
+  renderSimpleLayout(e, t, i) {
+    let { context: s, props: r } = this, o = [], a = G(s.options);
+    return e && o.push({
+      type: "header",
+      key: "header",
+      isSticky: a,
+      chunk: {
+        elRef: this.headerElRef,
+        tableClassName: "fc-col-header",
+        rowContent: e
+      }
+    }), t && (o.push({
+      type: "body",
+      key: "all-day",
+      chunk: { content: t }
+    }), o.push({
+      type: "body",
+      key: "all-day-divider",
+      outerContent: (
+        // TODO: rename to cellContent so don't need to define <tr>?
+        l(
+          "tr",
+          { role: "presentation", className: "fc-scrollgrid-section" },
+          l("td", { className: "fc-timegrid-divider " + s.theme.getClass("tableCellShaded") })
+        )
+      )
+    })), o.push({
+      type: "body",
+      key: "body",
+      liquid: !0,
+      expandRows: !!s.options.expandRows,
+      chunk: {
+        scrollerElRef: this.scrollerElRef,
+        content: i
+      }
+    }), l(
+      j,
+      { elRef: this.rootElRef, elClasses: ["fc-timegrid"], viewSpec: s.viewSpec },
+      l(me, { liquid: !r.isHeightAuto && !r.forPrint, collapsibleWidth: r.forPrint, cols: [{ width: "shrink" }], sections: o })
+    );
+  }
+  renderHScrollLayout(e, t, i, s, r, o, a) {
+    let d = this.context.pluginHooks.scrollGridImpl;
+    if (!d)
+      throw new Error("No ScrollGrid implementation");
+    let { context: c, props: f } = this, u = !f.forPrint && G(c.options), g = !f.forPrint && pe(c.options), h = [];
+    e && h.push({
+      type: "header",
+      key: "header",
+      isSticky: u,
+      syncRowHeights: !0,
+      chunks: [
+        {
+          key: "axis",
+          rowContent: (m) => l("tr", { role: "presentation" }, this.renderHeadAxis("day", m.rowSyncHeights[0]))
+        },
+        {
+          key: "cols",
+          elRef: this.headerElRef,
+          tableClassName: "fc-col-header",
+          rowContent: e
+        }
+      ]
+    }), t && (h.push({
+      type: "body",
+      key: "all-day",
+      syncRowHeights: !0,
+      chunks: [
+        {
+          key: "axis",
+          rowContent: (m) => l("tr", { role: "presentation" }, this.renderTableRowAxis(m.rowSyncHeights[0]))
+        },
+        {
+          key: "cols",
+          content: t
+        }
+      ]
+    }), h.push({
+      key: "all-day-divider",
+      type: "body",
+      outerContent: (
+        // TODO: rename to cellContent so don't need to define <tr>?
+        l(
+          "tr",
+          { role: "presentation", className: "fc-scrollgrid-section" },
+          l("td", { colSpan: 2, className: "fc-timegrid-divider " + c.theme.getClass("tableCellShaded") })
+        )
+      )
+    }));
+    let p = c.options.nowIndicator;
+    return h.push({
+      type: "body",
+      key: "body",
+      liquid: !0,
+      expandRows: !!c.options.expandRows,
+      chunks: [
+        {
+          key: "axis",
+          content: (m) => (
+            // TODO: make this now-indicator arrow more DRY with TimeColsContent
+            l(
+              "div",
+              { className: "fc-timegrid-axis-chunk" },
+              l(
+                "table",
+                { "aria-hidden": !0, style: { height: m.expandRows ? m.clientHeight : "" } },
+                m.tableColGroupNode,
+                l(
+                  "tbody",
+                  null,
+                  l(je, { slatMetas: o })
+                )
+              ),
+              l(
+                "div",
+                { className: "fc-timegrid-now-indicator-container" },
+                l(X, {
+                  unit: p ? "minute" : "day"
+                  /* hacky */
+                }, (S) => {
+                  let x = p && a && a.safeComputeTop(S);
+                  return typeof x == "number" ? l(O, { elClasses: ["fc-timegrid-now-indicator-arrow"], elStyle: { top: x }, isAxis: !0, date: S }) : null;
+                })
+              )
+            )
+          )
+        },
+        {
+          key: "cols",
+          scrollerElRef: this.scrollerElRef,
+          content: i
+        }
+      ]
+    }), g && h.push({
+      key: "footer",
+      type: "footer",
+      isSticky: !0,
+      chunks: [
+        {
+          key: "axis",
+          content: q
+        },
+        {
+          key: "cols",
+          content: q
+        }
+      ]
+    }), l(
+      j,
+      { elRef: this.rootElRef, elClasses: ["fc-timegrid"], viewSpec: c.viewSpec },
+      l(d, { liquid: !f.isHeightAuto && !f.forPrint, forPrint: f.forPrint, collapsibleWidth: !1, colGroups: [
+        { width: "shrink", cols: [{ width: "shrink" }] },
+        { cols: [{ span: s, minWidth: r }] }
+      ], sections: h })
+    );
+  }
+  /* Dimensions
+  ------------------------------------------------------------------------------------------------------------------*/
+  getAllDayMaxEventProps() {
+    let { dayMaxEvents: e, dayMaxEventRows: t } = this.context.options;
+    return (e === !0 || t === !0) && (e = void 0, t = Ue), { dayMaxEvents: e, dayMaxEventRows: t };
+  }
+}
+function Ve(n) {
+  return n.text;
+}
+class Ke {
+  constructor(e, t, i) {
+    this.positions = e, this.dateProfile = t, this.slotDuration = i;
+  }
+  safeComputeTop(e) {
+    let { dateProfile: t } = this;
+    if (Re(t.currentRange, e)) {
+      let i = U(e), s = e.valueOf() - i.valueOf();
+      if (s >= C(t.slotMinTime) && s < C(t.slotMaxTime))
+        return this.computeTimeTop(M(s));
+    }
+    return null;
+  }
+  // Computes the top coordinate, relative to the bounds of the grid, of the given date.
+  // A `startOfDayDate` must be given for avoiding ambiguity over how to treat midnight.
+  computeDateTop(e, t) {
+    return t || (t = U(e)), this.computeTimeTop(M(e.valueOf() - t.valueOf()));
+  }
+  // Computes the top coordinate, relative to the bounds of the grid, of the given time (a Duration).
+  // This is a makeshify way to compute the time-top. Assumes all slatMetas dates are uniform.
+  // Eventually allow computation with arbirary slat dates.
+  computeTimeTop(e) {
+    let { positions: t, dateProfile: i } = this, s = t.els.length, r = (e.milliseconds - C(i.slotMinTime)) / C(this.slotDuration), o, a;
+    return r = Math.max(0, r), r = Math.min(s, r), o = Math.floor(r), o = Math.min(o, s - 1), a = r - o, t.tops[o] + t.getHeight(o) * a;
+  }
+}
+class Ye extends y {
+  render() {
+    let { props: e, context: t } = this, { options: i } = t, { slatElRefs: s } = e;
+    return l("tbody", null, e.slatMetas.map((r, o) => {
+      let a = {
+        time: r.time,
+        date: t.dateEnv.toDate(r.date),
+        view: t.viewApi
+      };
+      return l(
+        "tr",
+        { key: r.key, ref: s.createRef(r.key) },
+        e.axis && l(Q, Object.assign({}, r)),
+        l(L, { elTag: "td", elClasses: [
+          "fc-timegrid-slot",
+          "fc-timegrid-slot-lane",
+          !r.isLabeled && "fc-timegrid-slot-minor"
+        ], elAttrs: {
+          "data-time": r.isoTimeStr
+        }, renderProps: a, generatorName: "slotLaneContent", customGenerator: i.slotLaneContent, classNameGenerator: i.slotLaneClassNames, didMount: i.slotLaneDidMount, willUnmount: i.slotLaneWillUnmount })
+      );
+    }));
+  }
+}
+class Xe extends y {
+  constructor() {
+    super(...arguments), this.rootElRef = w(), this.slatElRefs = new Z();
+  }
+  render() {
+    let { props: e, context: t } = this;
+    return l(
+      "div",
+      { ref: this.rootElRef, className: "fc-timegrid-slots" },
+      l(
+        "table",
+        { "aria-hidden": !0, className: t.theme.getClass("table"), style: {
+          minWidth: e.tableMinWidth,
+          width: e.clientWidth,
+          height: e.minHeight
+        } },
+        e.tableColGroupNode,
+        l(Ye, { slatElRefs: this.slatElRefs, axis: e.axis, slatMetas: e.slatMetas })
+      )
+    );
+  }
+  componentDidMount() {
+    this.updateSizing();
+  }
+  componentDidUpdate() {
+    this.updateSizing();
+  }
+  componentWillUnmount() {
+    this.props.onCoords && this.props.onCoords(null);
+  }
+  updateSizing() {
+    let { context: e, props: t } = this;
+    t.onCoords && t.clientWidth !== null && this.rootElRef.current.offsetHeight && t.onCoords(new Ke(new $(this.rootElRef.current, Ze(this.slatElRefs.currentMap, t.slatMetas), !1, !0), this.props.dateProfile, e.options.slotDuration));
+  }
+}
+function Ze(n, e) {
+  return e.map((t) => n[t.key]);
+}
+function D(n, e) {
+  let t = [], i;
+  for (i = 0; i < e; i += 1)
+    t.push([]);
+  if (n)
+    for (i = 0; i < n.length; i += 1)
+      t[n[i].col].push(n[i]);
+  return t;
+}
+function _(n, e) {
+  let t = [];
+  if (n) {
+    for (let i = 0; i < e; i += 1)
+      t[i] = {
+        affectedInstances: n.affectedInstances,
+        isEvent: n.isEvent,
+        segs: []
+      };
+    for (let i of n.segs)
+      t[i.col].segs.push(i);
+  } else
+    for (let i = 0; i < e; i += 1)
+      t[i] = null;
+  return t;
+}
+class $e extends y {
+  render() {
+    let { props: e } = this;
+    return l(ze, { elClasses: ["fc-timegrid-more-link"], elStyle: {
+      top: e.top,
+      bottom: e.bottom
+    }, allDayDate: null, moreCnt: e.hiddenSegs.length, allSegs: e.hiddenSegs, hiddenSegs: e.hiddenSegs, extraDateSpan: e.extraDateSpan, dateProfile: e.dateProfile, todayRange: e.todayRange, popoverContent: () => te(e.hiddenSegs, e), defaultGenerator: Je, forceTimed: !0 }, (t) => l(t, { elTag: "div", elClasses: ["fc-timegrid-more-link-inner", "fc-sticky"] }));
+  }
+}
+function Je(n) {
+  return n.shortText;
+}
+function Qe(n, e, t) {
+  let i = new He();
+  e != null && (i.strictOrder = e), t != null && (i.maxStackCnt = t);
+  let s = i.addSegs(n), r = We(s), o = et(i);
+  return o = rt(o, 1), { segRects: nt(o), hiddenGroups: r };
+}
+function et(n) {
+  const { entriesByLevel: e } = n, t = B((i, s) => i + ":" + s, (i, s) => {
+    let r = st(n, i, s), o = V(r, t), a = e[i][s];
+    return [
+      Object.assign(Object.assign({}, a), { nextLevelNodes: o[0] }),
+      a.thickness + o[1]
+      // the pressure builds
+    ];
+  });
+  return V(e.length ? { level: 0, lateralStart: 0, lateralEnd: e[0].length } : null, t)[0];
+}
+function V(n, e) {
+  if (!n)
+    return [[], 0];
+  let { level: t, lateralStart: i, lateralEnd: s } = n, r = i, o = [];
+  for (; r < s; )
+    o.push(e(t, r)), r += 1;
+  return o.sort(tt), [
+    o.map(it),
+    o[0][1]
+    // first item's pressure
+  ];
+}
+function tt(n, e) {
+  return e[1] - n[1];
+}
+function it(n) {
+  return n[0];
+}
+function st(n, e, t) {
+  let { levelCoords: i, entriesByLevel: s } = n, r = s[e][t], o = i[e] + r.thickness, a = i.length, d = e;
+  for (; d < a && i[d] < o; d += 1)
+    ;
+  for (; d < a; d += 1) {
+    let c = s[d], f, u = Le(c, r.span.start, Oe), g = u[0] + u[1], h = g;
+    for (
+      ;
+      // loop through entries that horizontally intersect
+      (f = c[h]) && // but not past the whole seg list
+      f.span.start < r.span.end;
+    )
+      h += 1;
+    if (g < h)
+      return { level: d, lateralStart: g, lateralEnd: h };
+  }
+  return null;
+}
+function rt(n, e) {
+  const t = B((i, s, r) => J(i), (i, s, r) => {
+    let { nextLevelNodes: o, thickness: a } = i, d = a + r, c = a / d, f, u = [];
+    if (!o.length)
+      f = e;
+    else
+      for (let h of o)
+        if (f === void 0) {
+          let p = t(h, s, d);
+          f = p[0], u.push(p[1]);
+        } else {
+          let p = t(h, f, 0);
+          u.push(p[1]);
+        }
+    let g = (f - s) * c;
+    return [f - g, Object.assign(Object.assign({}, i), { thickness: g, nextLevelNodes: u })];
+  });
+  return n.map((i) => t(i, 0, 0)[1]);
+}
+function nt(n) {
+  let e = [];
+  const t = B((s, r, o) => J(s), (s, r, o) => {
+    let a = Object.assign(Object.assign({}, s), {
+      levelCoord: r,
+      stackDepth: o,
+      stackForward: 0
+    });
+    return e.push(a), a.stackForward = i(s.nextLevelNodes, r + s.thickness, o + 1) + 1;
+  });
+  function i(s, r, o) {
+    let a = 0;
+    for (let d of s)
+      a = Math.max(t(d, r, o), a);
+    return a;
+  }
+  return i(n, 0, 0), e;
+}
+function B(n, e) {
+  const t = {};
+  return (...i) => {
+    let s = n(...i);
+    return s in t ? t[s] : t[s] = e(...i);
+  };
+}
+function K(n, e, t = null, i = 0) {
+  let s = [];
+  if (t)
+    for (let r = 0; r < n.length; r += 1) {
+      let o = n[r], a = t.computeDateTop(o.start, e), d = Math.max(
+        a + (i || 0),
+        // :(
+        t.computeDateTop(o.end, e)
+      );
+      s.push({
+        start: Math.round(a),
+        end: Math.round(d)
+        //
+      });
+    }
+  return s;
+}
+function ot(n, e, t, i) {
+  let s = [], r = [];
+  for (let c = 0; c < n.length; c += 1) {
+    let f = e[c];
+    f ? s.push({
+      index: c,
+      thickness: 1,
+      span: f
+    }) : r.push(n[c]);
+  }
+  let { segRects: o, hiddenGroups: a } = Qe(s, t, i), d = [];
+  for (let c of o)
+    d.push({
+      seg: n[c.index],
+      rect: c
+    });
+  for (let c of r)
+    d.push({ seg: c, rect: null });
+  return { segPlacements: d, hiddenGroups: a };
+}
+const lt = k({
+  hour: "numeric",
+  minute: "2-digit",
+  meridiem: !1
+});
+class ee extends y {
+  render() {
+    return l(Ae, Object.assign({}, this.props, { elClasses: [
+      "fc-timegrid-event",
+      "fc-v-event",
+      this.props.isShort && "fc-timegrid-event-short"
+    ], defaultTimeFormat: lt }));
+  }
+}
+class at extends y {
+  constructor() {
+    super(...arguments), this.sortEventSegs = v(De);
+  }
+  // TODO: memoize event-placement?
+  render() {
+    let { props: e, context: t } = this, { options: i } = t, s = i.selectMirror, r = (
+      // yuck
+      e.eventDrag && e.eventDrag.segs || e.eventResize && e.eventResize.segs || s && e.dateSelectionSegs || []
+    ), o = (
+      // TODO: messy way to compute this
+      e.eventDrag && e.eventDrag.affectedInstances || e.eventResize && e.eventResize.affectedInstances || {}
+    ), a = this.sortEventSegs(e.fgEventSegs, i.eventOrder);
+    return l(Ee, { elTag: "td", elRef: e.elRef, elClasses: [
+      "fc-timegrid-col",
+      ...e.extraClassNames || []
+    ], elAttrs: Object.assign({ role: "gridcell" }, e.extraDataAttrs), date: e.date, dateProfile: e.dateProfile, todayRange: e.todayRange, extraRenderProps: e.extraRenderProps }, (d) => l(
+      "div",
+      { className: "fc-timegrid-col-frame" },
+      l(
+        "div",
+        { className: "fc-timegrid-col-bg" },
+        this.renderFillSegs(e.businessHourSegs, "non-business"),
+        this.renderFillSegs(e.bgEventSegs, "bg-event"),
+        this.renderFillSegs(e.dateSelectionSegs, "highlight")
+      ),
+      l("div", { className: "fc-timegrid-col-events" }, this.renderFgSegs(a, o, !1, !1, !1)),
+      l("div", { className: "fc-timegrid-col-events" }, this.renderFgSegs(r, {}, !!e.eventDrag, !!e.eventResize, !!s, "mirror")),
+      l("div", { className: "fc-timegrid-now-indicator-container" }, this.renderNowIndicator(e.nowIndicatorSegs)),
+      ke(i) && l(d, { elTag: "div", elClasses: ["fc-timegrid-col-misc"] })
+    ));
+  }
+  renderFgSegs(e, t, i, s, r, o) {
+    let { props: a } = this;
+    return a.forPrint ? te(e, a) : this.renderPositionedFgSegs(e, t, i, s, r, o);
+  }
+  renderPositionedFgSegs(e, t, i, s, r, o) {
+    let { eventMaxStack: a, eventShortHeight: d, eventOrderStrict: c, eventMinHeight: f } = this.context.options, { date: u, slatCoords: g, eventSelection: h, todayRange: p, nowDate: m } = this.props, S = i || s || r, x = K(e, u, g, f), { segPlacements: N, hiddenGroups: P } = ot(e, x, c, a);
+    return l(
+      T,
+      null,
+      this.renderHiddenGroups(P, e),
+      N.map((E) => {
+        let { seg: R, rect: b } = E, I = R.eventRange.instance.instanceId, ie = S || !!(!t[I] && b), se = z(b && b.span), re = !S && b ? this.computeSegHStyle(b) : { left: 0, right: 0 }, ne = !!b && b.stackForward > 0, oe = !!b && b.span.end - b.span.start < d;
+        return l(
+          "div",
+          { className: "fc-timegrid-event-harness" + (ne ? " fc-timegrid-event-harness-inset" : ""), key: o || I, style: Object.assign(Object.assign({ visibility: ie ? "" : "hidden" }, se), re) },
+          l(ee, Object.assign({ seg: R, isDragging: i, isResizing: s, isDateSelecting: r, isSelected: I === h, isShort: oe }, W(R, p, m)))
+        );
+      })
+    );
+  }
+  // will already have eventMinHeight applied because segInputs already had it
+  renderHiddenGroups(e, t) {
+    let { extraDateSpan: i, dateProfile: s, todayRange: r, nowDate: o, eventSelection: a, eventDrag: d, eventResize: c } = this.props;
+    return l(T, null, e.map((f) => {
+      let u = z(f.span), g = dt(f.entries, t);
+      return l($e, { key: Te(Me(g)), hiddenSegs: g, top: u.top, bottom: u.bottom, extraDateSpan: i, dateProfile: s, todayRange: r, nowDate: o, eventSelection: a, eventDrag: d, eventResize: c });
+    }));
+  }
+  renderFillSegs(e, t) {
+    let { props: i, context: s } = this, o = K(e, i.date, i.slatCoords, s.options.eventMinHeight).map((a, d) => {
+      let c = e[d];
+      return l("div", { key: Ie(c.eventRange), className: "fc-timegrid-bg-harness", style: z(a) }, t === "bg-event" ? l(Ne, Object.assign({ seg: c }, W(c, i.todayRange, i.nowDate))) : Pe(t));
+    });
+    return l(T, null, o);
+  }
+  renderNowIndicator(e) {
+    let { slatCoords: t, date: i } = this.props;
+    return t ? e.map((s, r) => l(
+      O,
+      {
+        // key doesn't matter. will only ever be one
+        key: r,
+        elClasses: ["fc-timegrid-now-indicator-line"],
+        elStyle: {
+          top: t.computeDateTop(s.start, i)
+        },
+        isAxis: !1,
+        date: i
+      }
+    )) : null;
+  }
+  computeSegHStyle(e) {
+    let { isRtl: t, options: i } = this.context, s = i.slotEventOverlap, r = e.levelCoord, o = e.levelCoord + e.thickness, a, d;
+    s && (o = Math.min(1, r + (o - r) * 2)), t ? (a = 1 - o, d = r) : (a = r, d = 1 - o);
+    let c = {
+      zIndex: e.stackDepth + 1,
+      left: a * 100 + "%",
+      right: d * 100 + "%"
+    };
+    return s && !e.stackForward && (c[t ? "marginLeft" : "marginRight"] = 10 * 2), c;
+  }
+}
+function te(n, { todayRange: e, nowDate: t, eventSelection: i, eventDrag: s, eventResize: r }) {
+  let o = (s ? s.affectedInstances : null) || (r ? r.affectedInstances : null) || {};
+  return l(T, null, n.map((a) => {
+    let d = a.eventRange.instance.instanceId;
+    return l(
+      "div",
+      { key: d, style: { visibility: o[d] ? "hidden" : "" } },
+      l(ee, Object.assign({ seg: a, isDragging: !1, isResizing: !1, isDateSelecting: !1, isSelected: d === i, isShort: !1 }, W(a, e, t)))
+    );
+  }));
+}
+function z(n) {
+  return n ? {
+    top: n.start,
+    bottom: -n.end
+  } : { top: "", bottom: "" };
+}
+function dt(n, e) {
+  return n.map((t) => e[t.index]);
+}
+class ct extends y {
+  constructor() {
+    super(...arguments), this.splitFgEventSegs = v(D), this.splitBgEventSegs = v(D), this.splitBusinessHourSegs = v(D), this.splitNowIndicatorSegs = v(D), this.splitDateSelectionSegs = v(D), this.splitEventDrag = v(_), this.splitEventResize = v(_), this.rootElRef = w(), this.cellElRefs = new Z();
+  }
+  render() {
+    let { props: e, context: t } = this, i = t.options.nowIndicator && e.slatCoords && e.slatCoords.safeComputeTop(e.nowDate), s = e.cells.length, r = this.splitFgEventSegs(e.fgEventSegs, s), o = this.splitBgEventSegs(e.bgEventSegs, s), a = this.splitBusinessHourSegs(e.businessHourSegs, s), d = this.splitNowIndicatorSegs(e.nowIndicatorSegs, s), c = this.splitDateSelectionSegs(e.dateSelectionSegs, s), f = this.splitEventDrag(e.eventDrag, s), u = this.splitEventResize(e.eventResize, s);
+    return l(
+      "div",
+      { className: "fc-timegrid-cols", ref: this.rootElRef },
+      l(
+        "table",
+        { role: "presentation", style: {
+          minWidth: e.tableMinWidth,
+          width: e.clientWidth
+        } },
+        e.tableColGroupNode,
+        l(
+          "tbody",
+          { role: "presentation" },
+          l(
+            "tr",
+            { role: "row" },
+            e.axis && l(
+              "td",
+              { "aria-hidden": !0, className: "fc-timegrid-col fc-timegrid-axis" },
+              l(
+                "div",
+                { className: "fc-timegrid-col-frame" },
+                l("div", { className: "fc-timegrid-now-indicator-container" }, typeof i == "number" && l(O, { elClasses: ["fc-timegrid-now-indicator-arrow"], elStyle: { top: i }, isAxis: !0, date: e.nowDate }))
+              )
+            ),
+            e.cells.map((g, h) => l(at, { key: g.key, elRef: this.cellElRefs.createRef(g.key), dateProfile: e.dateProfile, date: g.date, nowDate: e.nowDate, todayRange: e.todayRange, extraRenderProps: g.extraRenderProps, extraDataAttrs: g.extraDataAttrs, extraClassNames: g.extraClassNames, extraDateSpan: g.extraDateSpan, fgEventSegs: r[h], bgEventSegs: o[h], businessHourSegs: a[h], nowIndicatorSegs: d[h], dateSelectionSegs: c[h], eventDrag: f[h], eventResize: u[h], slatCoords: e.slatCoords, eventSelection: e.eventSelection, forPrint: e.forPrint }))
+          )
+        )
+      )
+    );
+  }
+  componentDidMount() {
+    this.updateCoords();
+  }
+  componentDidUpdate() {
+    this.updateCoords();
+  }
+  updateCoords() {
+    let { props: e } = this;
+    e.onColCoords && e.clientWidth !== null && e.onColCoords(new $(
+      this.rootElRef.current,
+      ft(this.cellElRefs.currentMap, e.cells),
+      !0,
+      // horizontal
+      !1
+    ));
+  }
+}
+function ft(n, e) {
+  return e.map((t) => n[t.key]);
+}
+class ht extends H {
+  constructor() {
+    super(...arguments), this.processSlotOptions = v(gt), this.state = {
+      slatCoords: null
+    }, this.handleRootEl = (e) => {
+      e ? this.context.registerInteractiveComponent(this, {
+        el: e,
+        isHitComboAllowed: this.props.isHitComboAllowed
+      }) : this.context.unregisterInteractiveComponent(this);
+    }, this.handleScrollRequest = (e) => {
+      let { onScrollTopRequest: t } = this.props, { slatCoords: i } = this.state;
+      if (t && i) {
+        if (e.time) {
+          let s = i.computeTimeTop(e.time);
+          s = Math.ceil(s), s && (s += 1), t(s);
+        }
+        return !0;
+      }
+      return !1;
+    }, this.handleColCoords = (e) => {
+      this.colCoords = e;
+    }, this.handleSlatCoords = (e) => {
+      this.setState({ slatCoords: e }), this.props.onSlatCoords && this.props.onSlatCoords(e);
+    };
+  }
+  render() {
+    let { props: e, state: t } = this;
+    return l(
+      "div",
+      { className: "fc-timegrid-body", ref: this.handleRootEl, style: {
+        // these props are important to give this wrapper correct dimensions for interactions
+        // TODO: if we set it here, can we avoid giving to inner tables?
+        width: e.clientWidth,
+        minWidth: e.tableMinWidth
+      } },
+      l(Xe, { axis: e.axis, dateProfile: e.dateProfile, slatMetas: e.slatMetas, clientWidth: e.clientWidth, minHeight: e.expandRows ? e.clientHeight : "", tableMinWidth: e.tableMinWidth, tableColGroupNode: e.axis ? e.tableColGroupNode : null, onCoords: this.handleSlatCoords }),
+      l(ct, { cells: e.cells, axis: e.axis, dateProfile: e.dateProfile, businessHourSegs: e.businessHourSegs, bgEventSegs: e.bgEventSegs, fgEventSegs: e.fgEventSegs, dateSelectionSegs: e.dateSelectionSegs, eventSelection: e.eventSelection, eventDrag: e.eventDrag, eventResize: e.eventResize, todayRange: e.todayRange, nowDate: e.nowDate, nowIndicatorSegs: e.nowIndicatorSegs, clientWidth: e.clientWidth, tableMinWidth: e.tableMinWidth, tableColGroupNode: e.tableColGroupNode, slatCoords: t.slatCoords, onColCoords: this.handleColCoords, forPrint: e.forPrint })
+    );
+  }
+  componentDidMount() {
+    this.scrollResponder = this.context.createScrollResponder(this.handleScrollRequest);
+  }
+  componentDidUpdate(e) {
+    this.scrollResponder.update(e.dateProfile !== this.props.dateProfile);
+  }
+  componentWillUnmount() {
+    this.scrollResponder.detach();
+  }
+  queryHit(e, t) {
+    let { dateEnv: i, options: s } = this.context, { colCoords: r } = this, { dateProfile: o } = this.props, { slatCoords: a } = this.state, { snapDuration: d, snapsPerSlot: c } = this.processSlotOptions(this.props.slotDuration, s.snapDuration), f = r.leftToIndex(e), u = a.positions.topToIndex(t);
+    if (f != null && u != null) {
+      let g = this.props.cells[f], h = a.positions.tops[u], p = a.positions.getHeight(u), m = (t - h) / p, S = Math.floor(m * c), x = u * c + S, N = this.props.cells[f].date, P = A(o.slotMinTime, xe(d, x)), E = i.add(N, P), R = i.add(E, d);
+      return {
+        dateProfile: o,
+        dateSpan: Object.assign({ range: { start: E, end: R }, allDay: !1 }, g.extraDateSpan),
+        dayEl: r.els[f],
+        rect: {
+          left: r.lefts[f],
+          right: r.rights[f],
+          top: h,
+          bottom: h + p
+        },
+        layer: 0
+      };
+    }
+    return null;
+  }
+}
+function gt(n, e) {
+  let t = e || n, i = F(n, t);
+  return i === null && (t = n, i = 1), { snapDuration: t, snapsPerSlot: i };
+}
+class ut extends Ce {
+  sliceRange(e, t) {
+    let i = [];
+    for (let s = 0; s < t.length; s += 1) {
+      let r = we(e, t[s]);
+      r && i.push({
+        start: r.start,
+        end: r.end,
+        isStart: r.start.valueOf() === e.start.valueOf(),
+        isEnd: r.end.valueOf() === e.end.valueOf(),
+        col: s
+      });
+    }
+    return i;
+  }
+}
+class mt extends H {
+  constructor() {
+    super(...arguments), this.buildDayRanges = v(pt), this.slicer = new ut(), this.timeColsRef = w();
+  }
+  render() {
+    let { props: e, context: t } = this, { dateProfile: i, dayTableModel: s } = e, { nowIndicator: r, nextDayThreshold: o } = t.options, a = this.buildDayRanges(s, i, t.dateEnv);
+    return l(X, { unit: r ? "minute" : "day" }, (d, c) => l(ht, Object.assign({ ref: this.timeColsRef }, this.slicer.sliceProps(e, i, null, t, a), { forPrint: e.forPrint, axis: e.axis, dateProfile: i, slatMetas: e.slatMetas, slotDuration: e.slotDuration, cells: s.cells[0], tableColGroupNode: e.tableColGroupNode, tableMinWidth: e.tableMinWidth, clientWidth: e.clientWidth, clientHeight: e.clientHeight, expandRows: e.expandRows, nowDate: d, nowIndicatorSegs: r && this.slicer.sliceNowDate(d, i, o, t, a), todayRange: c, onScrollTopRequest: e.onScrollTopRequest, onSlatCoords: e.onSlatCoords })));
+  }
+}
+function pt(n, e, t) {
+  let i = [];
+  for (let s of n.headerDates)
+    i.push({
+      start: t.add(s, e.slotMinTime),
+      end: t.add(s, e.slotMaxTime)
+    });
+  return i;
+}
+const Y = [
+  { hours: 1 },
+  { minutes: 30 },
+  { minutes: 15 },
+  { seconds: 30 },
+  { seconds: 15 }
+];
+function vt(n, e, t, i, s) {
+  let r = /* @__PURE__ */ new Date(0), o = n, a = M(0), d = t || bt(i), c = [];
+  for (; C(o) < C(e); ) {
+    let f = s.add(r, o), u = F(a, d) !== null;
+    c.push({
+      date: f,
+      time: o,
+      key: f.toISOString(),
+      isoTimeStr: ve(f),
+      isLabeled: u
+    }), o = A(o, i), a = A(a, i);
+  }
+  return c;
+}
+function bt(n) {
+  let e, t, i;
+  for (e = Y.length - 1; e >= 0; e -= 1)
+    if (t = M(Y[e]), i = F(t, n), i !== null && i > 1)
+      return t;
+  return n;
+}
+class Rt extends _e {
+  constructor() {
+    super(...arguments), this.buildTimeColsModel = v(St), this.buildSlatMetas = v(vt);
+  }
+  render() {
+    let { options: e, dateEnv: t, dateProfileGenerator: i } = this.context, { props: s } = this, { dateProfile: r } = s, o = this.buildTimeColsModel(r, i), a = this.allDaySplitter.splitProps(s), d = this.buildSlatMetas(r.slotMinTime, r.slotMaxTime, e.slotLabelInterval, e.slotDuration, t), { dayMinWidth: c } = e, f = !c, u = c, g = e.dayHeaders && l(ae, { dates: o.headerDates, dateProfile: r, datesRepDistinctDays: !0, renderIntro: f ? this.renderHeadAxis : null }), h = e.allDaySlot !== !1 && ((m) => l(le, Object.assign({}, a.allDay, { dateProfile: r, dayTableModel: o, nextDayThreshold: e.nextDayThreshold, tableMinWidth: m.tableMinWidth, colGroupNode: m.tableColGroupNode, renderRowIntro: f ? this.renderTableRowAxis : null, showWeekNumbers: !1, expandRows: !1, headerAlignElRef: this.headerElRef, clientWidth: m.clientWidth, clientHeight: m.clientHeight, forPrint: s.forPrint }, this.getAllDayMaxEventProps()))), p = (m) => l(mt, Object.assign({}, a.timed, { dayTableModel: o, dateProfile: r, axis: f, slotDuration: e.slotDuration, slatMetas: d, forPrint: s.forPrint, tableColGroupNode: m.tableColGroupNode, tableMinWidth: m.tableMinWidth, clientWidth: m.clientWidth, clientHeight: m.clientHeight, onSlatCoords: this.handleSlatCoords, expandRows: m.expandRows, onScrollTopRequest: this.handleScrollTopRequest }));
+    return u ? this.renderHScrollLayout(g, h, p, o.colCnt, c, d, this.state.slatCoords) : this.renderSimpleLayout(g, h, p);
+  }
+}
+function St(n, e) {
+  let t = new de(n.renderRange, e);
+  return new ce(t, !1);
+}
+var yt = '.fc-v-event{background-color:var(--fc-event-bg-color);border:1px solid var(--fc-event-border-color);display:block}.fc-v-event .fc-event-main{color:var(--fc-event-text-color);height:100%}.fc-v-event .fc-event-main-frame{display:flex;flex-direction:column;height:100%}.fc-v-event .fc-event-time{flex-grow:0;flex-shrink:0;max-height:100%;overflow:hidden}.fc-v-event .fc-event-title-container{flex-grow:1;flex-shrink:1;min-height:0}.fc-v-event .fc-event-title{bottom:0;max-height:100%;overflow:hidden;top:0}.fc-v-event:not(.fc-event-start){border-top-left-radius:0;border-top-right-radius:0;border-top-width:0}.fc-v-event:not(.fc-event-end){border-bottom-left-radius:0;border-bottom-right-radius:0;border-bottom-width:0}.fc-v-event.fc-event-selected:before{left:-10px;right:-10px}.fc-v-event .fc-event-resizer-start{cursor:n-resize}.fc-v-event .fc-event-resizer-end{cursor:s-resize}.fc-v-event:not(.fc-event-selected) .fc-event-resizer{height:var(--fc-event-resizer-thickness);left:0;right:0}.fc-v-event:not(.fc-event-selected) .fc-event-resizer-start{top:calc(var(--fc-event-resizer-thickness)/-2)}.fc-v-event:not(.fc-event-selected) .fc-event-resizer-end{bottom:calc(var(--fc-event-resizer-thickness)/-2)}.fc-v-event.fc-event-selected .fc-event-resizer{left:50%;margin-left:calc(var(--fc-event-resizer-dot-total-width)/-2)}.fc-v-event.fc-event-selected .fc-event-resizer-start{top:calc(var(--fc-event-resizer-dot-total-width)/-2)}.fc-v-event.fc-event-selected .fc-event-resizer-end{bottom:calc(var(--fc-event-resizer-dot-total-width)/-2)}.fc .fc-timegrid .fc-daygrid-body{z-index:2}.fc .fc-timegrid-divider{padding:0 0 2px}.fc .fc-timegrid-body{min-height:100%;position:relative;z-index:1}.fc .fc-timegrid-axis-chunk{position:relative}.fc .fc-timegrid-axis-chunk>table,.fc .fc-timegrid-slots{position:relative;z-index:1}.fc .fc-timegrid-slot{border-bottom:0;height:1.5em}.fc .fc-timegrid-slot:empty:before{content:"\\00a0"}.fc .fc-timegrid-slot-minor{border-top-style:dotted}.fc .fc-timegrid-slot-label-cushion{display:inline-block;white-space:nowrap}.fc .fc-timegrid-slot-label{vertical-align:middle}.fc .fc-timegrid-axis-cushion,.fc .fc-timegrid-slot-label-cushion{padding:0 4px}.fc .fc-timegrid-axis-frame-liquid{height:100%}.fc .fc-timegrid-axis-frame{align-items:center;display:flex;justify-content:flex-end;overflow:hidden}.fc .fc-timegrid-axis-cushion{flex-shrink:0;max-width:60px}.fc-direction-ltr .fc-timegrid-slot-label-frame{text-align:right}.fc-direction-rtl .fc-timegrid-slot-label-frame{text-align:left}.fc-liquid-hack .fc-timegrid-axis-frame-liquid{bottom:0;height:auto;left:0;position:absolute;right:0;top:0}.fc .fc-timegrid-col.fc-day-today{background-color:var(--fc-today-bg-color)}.fc .fc-timegrid-col-frame{min-height:100%;position:relative}.fc-media-screen.fc-liquid-hack .fc-timegrid-col-frame{bottom:0;height:auto;left:0;position:absolute;right:0;top:0}.fc-media-screen .fc-timegrid-cols{bottom:0;left:0;position:absolute;right:0;top:0}.fc-media-screen .fc-timegrid-cols>table{height:100%}.fc-media-screen .fc-timegrid-col-bg,.fc-media-screen .fc-timegrid-col-events,.fc-media-screen .fc-timegrid-now-indicator-container{left:0;position:absolute;right:0;top:0}.fc .fc-timegrid-col-bg{z-index:2}.fc .fc-timegrid-col-bg .fc-non-business{z-index:1}.fc .fc-timegrid-col-bg .fc-bg-event{z-index:2}.fc .fc-timegrid-col-bg .fc-highlight{z-index:3}.fc .fc-timegrid-bg-harness{left:0;position:absolute;right:0}.fc .fc-timegrid-col-events{z-index:3}.fc .fc-timegrid-now-indicator-container{bottom:0;overflow:hidden}.fc-direction-ltr .fc-timegrid-col-events{margin:0 2.5% 0 2px}.fc-direction-rtl .fc-timegrid-col-events{margin:0 2px 0 2.5%}.fc-timegrid-event-harness{position:absolute}.fc-timegrid-event-harness>.fc-timegrid-event{bottom:0;left:0;position:absolute;right:0;top:0}.fc-timegrid-event-harness-inset .fc-timegrid-event,.fc-timegrid-event.fc-event-mirror,.fc-timegrid-more-link{box-shadow:0 0 0 1px var(--fc-page-bg-color)}.fc-timegrid-event,.fc-timegrid-more-link{border-radius:3px;font-size:var(--fc-small-font-size)}.fc-timegrid-event{margin-bottom:1px}.fc-timegrid-event .fc-event-main{padding:1px 1px 0}.fc-timegrid-event .fc-event-time{font-size:var(--fc-small-font-size);margin-bottom:1px;white-space:nowrap}.fc-timegrid-event-short .fc-event-main-frame{flex-direction:row;overflow:hidden}.fc-timegrid-event-short .fc-event-time:after{content:"\\00a0-\\00a0"}.fc-timegrid-event-short .fc-event-title{font-size:var(--fc-small-font-size)}.fc-timegrid-more-link{background:var(--fc-more-link-bg-color);color:var(--fc-more-link-text-color);cursor:pointer;margin-bottom:1px;position:absolute;z-index:9999}.fc-timegrid-more-link-inner{padding:3px 2px;top:0}.fc-direction-ltr .fc-timegrid-more-link{right:0}.fc-direction-rtl .fc-timegrid-more-link{left:0}.fc .fc-timegrid-now-indicator-line{border-color:var(--fc-now-indicator-color);border-style:solid;border-width:1px 0 0;left:0;position:absolute;right:0;z-index:4}.fc .fc-timegrid-now-indicator-arrow{border-color:var(--fc-now-indicator-color);border-style:solid;margin-top:-5px;position:absolute;z-index:4}.fc-direction-ltr .fc-timegrid-now-indicator-arrow{border-bottom-color:transparent;border-top-color:transparent;border-width:5px 0 5px 6px;left:0}.fc-direction-rtl .fc-timegrid-now-indicator-arrow{border-bottom-color:transparent;border-top-color:transparent;border-width:5px 6px 5px 0;right:0}';
+fe(yt);
+export {
+  mt as DayTimeCols,
+  ut as DayTimeColsSlicer,
+  Rt as DayTimeColsView,
+  ht as TimeCols,
+  Ke as TimeColsSlatsCoords,
+  _e as TimeColsView,
+  pt as buildDayRanges,
+  vt as buildSlatMetas,
+  St as buildTimeColsModel
+};