@annotorious/react 3.0.0-rc.9 → 3.0.1

package/dist/annotorious-react.es27.js

@@ -0,0 +1,129 @@
+const l = Math.min, a = Math.max, P = Math.round, M = Math.floor, O = (t) => ({
+  x: t,
+  y: t
+}), m = {
+  left: "right",
+  right: "left",
+  bottom: "top",
+  top: "bottom"
+}, p = {
+  start: "end",
+  end: "start"
+};
+function S(t, n, e) {
+  return a(t, l(n, e));
+}
+function w(t, n) {
+  return typeof t == "function" ? t(n) : t;
+}
+function f(t) {
+  return t.split("-")[0];
+}
+function g(t) {
+  return t.split("-")[1];
+}
+function h(t) {
+  return t === "x" ? "y" : "x";
+}
+function x(t) {
+  return t === "y" ? "height" : "width";
+}
+function b(t) {
+  return ["top", "bottom"].includes(f(t)) ? "y" : "x";
+}
+function d(t) {
+  return h(b(t));
+}
+function j(t, n, e) {
+  e === void 0 && (e = !1);
+  const r = g(t), o = d(t), i = x(o);
+  let c = o === "x" ? r === (e ? "end" : "start") ? "right" : "left" : r === "start" ? "bottom" : "top";
+  return n.reference[i] > n.floating[i] && (c = u(c)), [c, u(c)];
+}
+function C(t) {
+  const n = u(t);
+  return [s(t), n, s(n)];
+}
+function s(t) {
+  return t.replace(/start|end/g, (n) => p[n]);
+}
+function A(t, n, e) {
+  const r = ["left", "right"], o = ["right", "left"], i = ["top", "bottom"], c = ["bottom", "top"];
+  switch (t) {
+    case "top":
+    case "bottom":
+      return e ? n ? o : r : n ? r : o;
+    case "left":
+    case "right":
+      return n ? i : c;
+    default:
+      return [];
+  }
+}
+function L(t, n, e, r) {
+  const o = g(t);
+  let i = A(f(t), e === "start", r);
+  return o && (i = i.map((c) => c + "-" + o), n && (i = i.concat(i.map(s)))), i;
+}
+function u(t) {
+  return t.replace(/left|right|bottom|top/g, (n) => m[n]);
+}
+function y(t) {
+  return {
+    top: 0,
+    right: 0,
+    bottom: 0,
+    left: 0,
+    ...t
+  };
+}
+function E(t) {
+  return typeof t != "number" ? y(t) : {
+    top: t,
+    right: t,
+    bottom: t,
+    left: t
+  };
+}
+function R(t) {
+  const {
+    x: n,
+    y: e,
+    width: r,
+    height: o
+  } = t;
+  return {
+    width: r,
+    height: o,
+    top: e,
+    left: n,
+    right: n + r,
+    bottom: e + o,
+    x: n,
+    y: e
+  };
+}
+export {
+  S as clamp,
+  O as createCoords,
+  w as evaluate,
+  y as expandPaddingObject,
+  M as floor,
+  g as getAlignment,
+  d as getAlignmentAxis,
+  j as getAlignmentSides,
+  x as getAxisLength,
+  C as getExpandedPlacements,
+  s as getOppositeAlignmentPlacement,
+  h as getOppositeAxis,
+  L as getOppositeAxisPlacements,
+  u as getOppositePlacement,
+  E as getPaddingObject,
+  f as getSide,
+  b as getSideAxis,
+  a as max,
+  l as min,
+  R as rectToClientRect,
+  P as round
+};
+//# sourceMappingURL=annotorious-react.es27.js.map

package/dist/annotorious-react.es27.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotorious-react.es27.js","sources":["../../../node_modules/@floating-ui/utils/dist/floating-ui.utils.mjs"],"sourcesContent":["/**\n * Custom positioning reference element.\n * @see https://floating-ui.com/docs/virtual-elements\n */\n\nconst sides = ['top', 'right', 'bottom', 'left'];\nconst alignments = ['start', 'end'];\nconst placements = /*#__PURE__*/sides.reduce((acc, side) => acc.concat(side, side + \"-\" + alignments[0], side + \"-\" + alignments[1]), []);\nconst min = Math.min;\nconst max = Math.max;\nconst round = Math.round;\nconst floor = Math.floor;\nconst createCoords = v => ({\n  x: v,\n  y: v\n});\nconst oppositeSideMap = {\n  left: 'right',\n  right: 'left',\n  bottom: 'top',\n  top: 'bottom'\n};\nconst oppositeAlignmentMap = {\n  start: 'end',\n  end: 'start'\n};\nfunction clamp(start, value, end) {\n  return max(start, min(value, end));\n}\nfunction evaluate(value, param) {\n  return typeof value === 'function' ? value(param) : value;\n}\nfunction getSide(placement) {\n  return placement.split('-')[0];\n}\nfunction getAlignment(placement) {\n  return placement.split('-')[1];\n}\nfunction getOppositeAxis(axis) {\n  return axis === 'x' ? 'y' : 'x';\n}\nfunction getAxisLength(axis) {\n  return axis === 'y' ? 'height' : 'width';\n}\nfunction getSideAxis(placement) {\n  return ['top', 'bottom'].includes(getSide(placement)) ? 'y' : 'x';\n}\nfunction getAlignmentAxis(placement) {\n  return getOppositeAxis(getSideAxis(placement));\n}\nfunction getAlignmentSides(placement, rects, rtl) {\n  if (rtl === void 0) {\n    rtl = false;\n  }\n  const alignment = getAlignment(placement);\n  const alignmentAxis = getAlignmentAxis(placement);\n  const length = getAxisLength(alignmentAxis);\n  let mainAlignmentSide = alignmentAxis === 'x' ? alignment === (rtl ? 'end' : 'start') ? 'right' : 'left' : alignment === 'start' ? 'bottom' : 'top';\n  if (rects.reference[length] > rects.floating[length]) {\n    mainAlignmentSide = getOppositePlacement(mainAlignmentSide);\n  }\n  return [mainAlignmentSide, getOppositePlacement(mainAlignmentSide)];\n}\nfunction getExpandedPlacements(placement) {\n  const oppositePlacement = getOppositePlacement(placement);\n  return [getOppositeAlignmentPlacement(placement), oppositePlacement, getOppositeAlignmentPlacement(oppositePlacement)];\n}\nfunction getOppositeAlignmentPlacement(placement) {\n  return placement.replace(/start|end/g, alignment => oppositeAlignmentMap[alignment]);\n}\nfunction getSideList(side, isStart, rtl) {\n  const lr = ['left', 'right'];\n  const rl = ['right', 'left'];\n  const tb = ['top', 'bottom'];\n  const bt = ['bottom', 'top'];\n  switch (side) {\n    case 'top':\n    case 'bottom':\n      if (rtl) return isStart ? rl : lr;\n      return isStart ? lr : rl;\n    case 'left':\n    case 'right':\n      return isStart ? tb : bt;\n    default:\n      return [];\n  }\n}\nfunction getOppositeAxisPlacements(placement, flipAlignment, direction, rtl) {\n  const alignment = getAlignment(placement);\n  let list = getSideList(getSide(placement), direction === 'start', rtl);\n  if (alignment) {\n    list = list.map(side => side + \"-\" + alignment);\n    if (flipAlignment) {\n      list = list.concat(list.map(getOppositeAlignmentPlacement));\n    }\n  }\n  return list;\n}\nfunction getOppositePlacement(placement) {\n  return placement.replace(/left|right|bottom|top/g, side => oppositeSideMap[side]);\n}\nfunction expandPaddingObject(padding) {\n  return {\n    top: 0,\n    right: 0,\n    bottom: 0,\n    left: 0,\n    ...padding\n  };\n}\nfunction getPaddingObject(padding) {\n  return typeof padding !== 'number' ? expandPaddingObject(padding) : {\n    top: padding,\n    right: padding,\n    bottom: padding,\n    left: padding\n  };\n}\nfunction rectToClientRect(rect) {\n  const {\n    x,\n    y,\n    width,\n    height\n  } = rect;\n  return {\n    width,\n    height,\n    top: y,\n    left: x,\n    right: x + width,\n    bottom: y + height,\n    x,\n    y\n  };\n}\n\nexport { alignments, clamp, createCoords, evaluate, expandPaddingObject, floor, getAlignment, getAlignmentAxis, getAlignmentSides, getAxisLength, getExpandedPlacements, getOppositeAlignmentPlacement, getOppositeAxis, getOppositeAxisPlacements, getOppositePlacement, getPaddingObject, getSide, getSideAxis, max, min, placements, rectToClientRect, round, sides };\n"],"names":["min","max","round","floor","createCoords","v","oppositeSideMap","oppositeAlignmentMap","clamp","start","value","end","evaluate","param","getSide","placement","getAlignment","getOppositeAxis","axis","getAxisLength","getSideAxis","getAlignmentAxis","getAlignmentSides","rects","rtl","alignment","alignmentAxis","length","mainAlignmentSide","getOppositePlacement","getExpandedPlacements","oppositePlacement","getOppositeAlignmentPlacement","getSideList","side","isStart","lr","rl","tb","bt","getOppositeAxisPlacements","flipAlignment","direction","list","expandPaddingObject","padding","getPaddingObject","rectToClientRect","rect","x","y","width","height"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/annotorious-react.es28.js

@@ -0,0 +1,466 @@
+import { evaluate as Y, getSide as F, getSideAxis as M, getOppositePlacement as Q, getExpandedPlacements as U, getOppositeAxisPlacements as Z, getAlignmentSides as tt, rectToClientRect as $, getPaddingObject as H, clamp as _, getAlignmentAxis as q, getAlignment as I, min as X, max as z, getOppositeAxis as et, getAxisLength as G } from "./annotorious-react.es27.js";
+function W(i, s, l) {
+  let {
+    reference: e,
+    floating: o
+  } = i;
+  const t = M(s), f = q(s), a = G(f), d = F(s), g = t === "y", u = e.x + e.width / 2 - o.width / 2, c = e.y + e.height / 2 - o.height / 2, m = e[a] / 2 - o[a] / 2;
+  let n;
+  switch (d) {
+    case "top":
+      n = {
+        x: u,
+        y: e.y - o.height
+      };
+      break;
+    case "bottom":
+      n = {
+        x: u,
+        y: e.y + e.height
+      };
+      break;
+    case "right":
+      n = {
+        x: e.x + e.width,
+        y: c
+      };
+      break;
+    case "left":
+      n = {
+        x: e.x - o.width,
+        y: c
+      };
+      break;
+    default:
+      n = {
+        x: e.x,
+        y: e.y
+      };
+  }
+  switch (I(s)) {
+    case "start":
+      n[f] -= m * (l && g ? -1 : 1);
+      break;
+    case "end":
+      n[f] += m * (l && g ? -1 : 1);
+      break;
+  }
+  return n;
+}
+const st = async (i, s, l) => {
+  const {
+    placement: e = "bottom",
+    strategy: o = "absolute",
+    middleware: t = [],
+    platform: f
+  } = l, a = t.filter(Boolean), d = await (f.isRTL == null ? void 0 : f.isRTL(s));
+  let g = await f.getElementRects({
+    reference: i,
+    floating: s,
+    strategy: o
+  }), {
+    x: u,
+    y: c
+  } = W(g, e, d), m = e, n = {}, r = 0;
+  for (let h = 0; h < a.length; h++) {
+    const {
+      name: x,
+      fn: w
+    } = a[h], {
+      x: b,
+      y,
+      data: R,
+      reset: p
+    } = await w({
+      x: u,
+      y: c,
+      initialPlacement: e,
+      placement: m,
+      strategy: o,
+      middlewareData: n,
+      rects: g,
+      platform: f,
+      elements: {
+        reference: i,
+        floating: s
+      }
+    });
+    u = b ?? u, c = y ?? c, n = {
+      ...n,
+      [x]: {
+        ...n[x],
+        ...R
+      }
+    }, p && r <= 50 && (r++, typeof p == "object" && (p.placement && (m = p.placement), p.rects && (g = p.rects === !0 ? await f.getElementRects({
+      reference: i,
+      floating: s,
+      strategy: o
+    }) : p.rects), {
+      x: u,
+      y: c
+    } = W(g, m, d)), h = -1);
+  }
+  return {
+    x: u,
+    y: c,
+    placement: m,
+    strategy: o,
+    middlewareData: n
+  };
+};
+async function J(i, s) {
+  var l;
+  s === void 0 && (s = {});
+  const {
+    x: e,
+    y: o,
+    platform: t,
+    rects: f,
+    elements: a,
+    strategy: d
+  } = i, {
+    boundary: g = "clippingAncestors",
+    rootBoundary: u = "viewport",
+    elementContext: c = "floating",
+    altBoundary: m = !1,
+    padding: n = 0
+  } = Y(s, i), r = H(n), x = a[m ? c === "floating" ? "reference" : "floating" : c], w = $(await t.getClippingRect({
+    element: (l = await (t.isElement == null ? void 0 : t.isElement(x))) == null || l ? x : x.contextElement || await (t.getDocumentElement == null ? void 0 : t.getDocumentElement(a.floating)),
+    boundary: g,
+    rootBoundary: u,
+    strategy: d
+  })), b = c === "floating" ? {
+    x: e,
+    y: o,
+    width: f.floating.width,
+    height: f.floating.height
+  } : f.reference, y = await (t.getOffsetParent == null ? void 0 : t.getOffsetParent(a.floating)), R = await (t.isElement == null ? void 0 : t.isElement(y)) ? await (t.getScale == null ? void 0 : t.getScale(y)) || {
+    x: 1,
+    y: 1
+  } : {
+    x: 1,
+    y: 1
+  }, p = $(t.convertOffsetParentRelativeRectToViewportRelativeRect ? await t.convertOffsetParentRelativeRectToViewportRelativeRect({
+    elements: a,
+    rect: b,
+    offsetParent: y,
+    strategy: d
+  }) : b);
+  return {
+    top: (w.top - p.top + r.top) / R.y,
+    bottom: (p.bottom - w.bottom + r.bottom) / R.y,
+    left: (w.left - p.left + r.left) / R.x,
+    right: (p.right - w.right + r.right) / R.x
+  };
+}
+const ct = (i) => ({
+  name: "arrow",
+  options: i,
+  async fn(s) {
+    const {
+      x: l,
+      y: e,
+      placement: o,
+      rects: t,
+      platform: f,
+      elements: a,
+      middlewareData: d
+    } = s, {
+      element: g,
+      padding: u = 0
+    } = Y(i, s) || {};
+    if (g == null)
+      return {};
+    const c = H(u), m = {
+      x: l,
+      y: e
+    }, n = q(o), r = G(n), h = await f.getDimensions(g), x = n === "y", w = x ? "top" : "left", b = x ? "bottom" : "right", y = x ? "clientHeight" : "clientWidth", R = t.reference[r] + t.reference[n] - m[n] - t.floating[r], p = m[n] - t.reference[n], C = await (f.getOffsetParent == null ? void 0 : f.getOffsetParent(g));
+    let k = C ? C[y] : 0;
+    (!k || !await (f.isElement == null ? void 0 : f.isElement(C))) && (k = a.floating[y] || t.floating[r]);
+    const j = R / 2 - p / 2, T = k / 2 - h[r] / 2 - 1, v = X(c[w], T), L = X(c[b], T), S = v, B = k - h[r] - L, A = k / 2 - h[r] / 2 + j, D = _(S, A, B), P = !d.arrow && I(o) != null && A !== D && t.reference[r] / 2 - (A < S ? v : L) - h[r] / 2 < 0, O = P ? A < S ? A - S : A - B : 0;
+    return {
+      [n]: m[n] + O,
+      data: {
+        [n]: D,
+        centerOffset: A - D - O,
+        ...P && {
+          alignmentOffset: O
+        }
+      },
+      reset: P
+    };
+  }
+}), lt = function(i) {
+  return i === void 0 && (i = {}), {
+    name: "flip",
+    options: i,
+    async fn(s) {
+      var l, e;
+      const {
+        placement: o,
+        middlewareData: t,
+        rects: f,
+        initialPlacement: a,
+        platform: d,
+        elements: g
+      } = s, {
+        mainAxis: u = !0,
+        crossAxis: c = !0,
+        fallbackPlacements: m,
+        fallbackStrategy: n = "bestFit",
+        fallbackAxisSideDirection: r = "none",
+        flipAlignment: h = !0,
+        ...x
+      } = Y(i, s);
+      if ((l = t.arrow) != null && l.alignmentOffset)
+        return {};
+      const w = F(o), b = M(a), y = F(a) === a, R = await (d.isRTL == null ? void 0 : d.isRTL(g.floating)), p = m || (y || !h ? [Q(a)] : U(a)), C = r !== "none";
+      !m && C && p.push(...Z(a, h, r, R));
+      const k = [a, ...p], j = await J(s, x), T = [];
+      let v = ((e = t.flip) == null ? void 0 : e.overflows) || [];
+      if (u && T.push(j[w]), c) {
+        const A = tt(o, f, R);
+        T.push(j[A[0]], j[A[1]]);
+      }
+      if (v = [...v, {
+        placement: o,
+        overflows: T
+      }], !T.every((A) => A <= 0)) {
+        var L, S;
+        const A = (((L = t.flip) == null ? void 0 : L.index) || 0) + 1, D = k[A];
+        if (D)
+          return {
+            data: {
+              index: A,
+              overflows: v
+            },
+            reset: {
+              placement: D
+            }
+          };
+        let P = (S = v.filter((O) => O.overflows[0] <= 0).sort((O, E) => O.overflows[1] - E.overflows[1])[0]) == null ? void 0 : S.placement;
+        if (!P)
+          switch (n) {
+            case "bestFit": {
+              var B;
+              const O = (B = v.filter((E) => {
+                if (C) {
+                  const V = M(E.placement);
+                  return V === b || // Create a bias to the `y` side axis due to horizontal
+                  // reading directions favoring greater width.
+                  V === "y";
+                }
+                return !0;
+              }).map((E) => [E.placement, E.overflows.filter((V) => V > 0).reduce((V, N) => V + N, 0)]).sort((E, V) => E[1] - V[1])[0]) == null ? void 0 : B[0];
+              O && (P = O);
+              break;
+            }
+            case "initialPlacement":
+              P = a;
+              break;
+          }
+        if (o !== P)
+          return {
+            reset: {
+              placement: P
+            }
+          };
+      }
+      return {};
+    }
+  };
+};
+function K(i) {
+  const s = X(...i.map((t) => t.left)), l = X(...i.map((t) => t.top)), e = z(...i.map((t) => t.right)), o = z(...i.map((t) => t.bottom));
+  return {
+    x: s,
+    y: l,
+    width: e - s,
+    height: o - l
+  };
+}
+function nt(i) {
+  const s = i.slice().sort((o, t) => o.y - t.y), l = [];
+  let e = null;
+  for (let o = 0; o < s.length; o++) {
+    const t = s[o];
+    !e || t.y - e.y > e.height / 2 ? l.push([t]) : l[l.length - 1].push(t), e = t;
+  }
+  return l.map((o) => $(K(o)));
+}
+const at = function(i) {
+  return i === void 0 && (i = {}), {
+    name: "inline",
+    options: i,
+    async fn(s) {
+      const {
+        placement: l,
+        elements: e,
+        rects: o,
+        platform: t,
+        strategy: f
+      } = s, {
+        padding: a = 2,
+        x: d,
+        y: g
+      } = Y(i, s), u = Array.from(await (t.getClientRects == null ? void 0 : t.getClientRects(e.reference)) || []), c = nt(u), m = $(K(u)), n = H(a);
+      function r() {
+        if (c.length === 2 && c[0].left > c[1].right && d != null && g != null)
+          return c.find((x) => d > x.left - n.left && d < x.right + n.right && g > x.top - n.top && g < x.bottom + n.bottom) || m;
+        if (c.length >= 2) {
+          if (M(l) === "y") {
+            const v = c[0], L = c[c.length - 1], S = F(l) === "top", B = v.top, A = L.bottom, D = S ? v.left : L.left, P = S ? v.right : L.right, O = P - D, E = A - B;
+            return {
+              top: B,
+              bottom: A,
+              left: D,
+              right: P,
+              width: O,
+              height: E,
+              x: D,
+              y: B
+            };
+          }
+          const x = F(l) === "left", w = z(...c.map((v) => v.right)), b = X(...c.map((v) => v.left)), y = c.filter((v) => x ? v.left === b : v.right === w), R = y[0].top, p = y[y.length - 1].bottom, C = b, k = w, j = k - C, T = p - R;
+          return {
+            top: R,
+            bottom: p,
+            left: C,
+            right: k,
+            width: j,
+            height: T,
+            x: C,
+            y: R
+          };
+        }
+        return m;
+      }
+      const h = await t.getElementRects({
+        reference: {
+          getBoundingClientRect: r
+        },
+        floating: e.floating,
+        strategy: f
+      });
+      return o.reference.x !== h.reference.x || o.reference.y !== h.reference.y || o.reference.width !== h.reference.width || o.reference.height !== h.reference.height ? {
+        reset: {
+          rects: h
+        }
+      } : {};
+    }
+  };
+};
+async function it(i, s) {
+  const {
+    placement: l,
+    platform: e,
+    elements: o
+  } = i, t = await (e.isRTL == null ? void 0 : e.isRTL(o.floating)), f = F(l), a = I(l), d = M(l) === "y", g = ["left", "top"].includes(f) ? -1 : 1, u = t && d ? -1 : 1, c = Y(s, i);
+  let {
+    mainAxis: m,
+    crossAxis: n,
+    alignmentAxis: r
+  } = typeof c == "number" ? {
+    mainAxis: c,
+    crossAxis: 0,
+    alignmentAxis: null
+  } : {
+    mainAxis: 0,
+    crossAxis: 0,
+    alignmentAxis: null,
+    ...c
+  };
+  return a && typeof r == "number" && (n = a === "end" ? r * -1 : r), d ? {
+    x: n * u,
+    y: m * g
+  } : {
+    x: m * g,
+    y: n * u
+  };
+}
+const rt = function(i) {
+  return i === void 0 && (i = 0), {
+    name: "offset",
+    options: i,
+    async fn(s) {
+      var l, e;
+      const {
+        x: o,
+        y: t,
+        placement: f,
+        middlewareData: a
+      } = s, d = await it(s, i);
+      return f === ((l = a.offset) == null ? void 0 : l.placement) && (e = a.arrow) != null && e.alignmentOffset ? {} : {
+        x: o + d.x,
+        y: t + d.y,
+        data: {
+          ...d,
+          placement: f
+        }
+      };
+    }
+  };
+}, ft = function(i) {
+  return i === void 0 && (i = {}), {
+    name: "shift",
+    options: i,
+    async fn(s) {
+      const {
+        x: l,
+        y: e,
+        placement: o
+      } = s, {
+        mainAxis: t = !0,
+        crossAxis: f = !1,
+        limiter: a = {
+          fn: (x) => {
+            let {
+              x: w,
+              y: b
+            } = x;
+            return {
+              x: w,
+              y: b
+            };
+          }
+        },
+        ...d
+      } = Y(i, s), g = {
+        x: l,
+        y: e
+      }, u = await J(s, d), c = M(F(o)), m = et(c);
+      let n = g[m], r = g[c];
+      if (t) {
+        const x = m === "y" ? "top" : "left", w = m === "y" ? "bottom" : "right", b = n + u[x], y = n - u[w];
+        n = _(b, n, y);
+      }
+      if (f) {
+        const x = c === "y" ? "top" : "left", w = c === "y" ? "bottom" : "right", b = r + u[x], y = r - u[w];
+        r = _(b, r, y);
+      }
+      const h = a.fn({
+        ...s,
+        [m]: n,
+        [c]: r
+      });
+      return {
+        ...h,
+        data: {
+          x: h.x - l,
+          y: h.y - e
+        }
+      };
+    }
+  };
+};
+export {
+  ct as arrow,
+  st as computePosition,
+  J as detectOverflow,
+  lt as flip,
+  at as inline,
+  rt as offset,
+  $ as rectToClientRect,
+  ft as shift
+};
+//# sourceMappingURL=annotorious-react.es28.js.map