@bynder/compact-view 5.2.0 → 5.2.2

package/useAutoHeight.js

@@ -0,0 +1,25 @@
+import { useRef as u, useLayoutEffect as c } from "react";
+import { normalizeRows as f } from "./normalizeRows.js";
+import { calculateNodeHeight as l } from "./calculateNodeHeight.js";
+import { getSizingData as g } from "./getSizingData.js";
+function z(i, n, a) {
+  const o = u(0), [s, m] = f(n, a);
+  c(() => {
+    const t = i.current;
+    if (!t)
+      return;
+    const r = g(t);
+    if (!r)
+      return;
+    const e = l({
+      sizingData: r,
+      value: t.value || t.placeholder || "x",
+      minRows: s,
+      maxRows: m
+    });
+    o.current !== e && (o.current = e, t.style.setProperty("height", `${e}px`, "important"));
+  });
+}
+export {
+  z as useAutoHeight
+};

package/useClickOutside.js

@@ -13,4 +13,3 @@ function d(e, n) {
 export {
   d as useClickOutside
 };
-//# sourceMappingURL=useClickOutside.js.map

package/useDatStore.js

@@ -1,62 +1,65 @@
-import { create as d } from "zustand";
-import { devtools as f } from "zustand/middleware";
+import { devtools as f } from "./middleware2.js";
 import { createSelectors as c } from "./createSelectors.js";
-const i = d()(
+import { create as l } from "./react.js";
+const i = l()(
   f(
-    (t, r, n) => ({
-      datUrl: "",
+    (t, r, s) => ({
+      assetId: "",
       assetName: "",
       datExtension: "",
+      datUrl: "",
       transformation: {},
-      openDat: (e, a, s) => {
+      openDat: (a, e, n) => {
         const o = r().transformation;
         t({
-          datUrl: e,
-          assetName: s,
-          datExtension: a.extensions[0] || "",
+          assetId: e.databaseId,
+          assetName: n,
+          datExtension: e.extensions[0] || "",
+          datUrl: a,
           transformation: {
-            url: e,
-            asset: a,
-            preset: o && o.asset?.id === a.id ? o.preset : void 0
+            url: a,
+            asset: e,
+            preset: o && o.asset?.id === e.id ? o.preset : void 0
           }
         });
       },
       closeDat: () => {
         t({ datUrl: "" });
       },
-      setTransformation: (e) => {
-        t({ transformation: e });
+      setTransformation: (a) => {
+        t({ transformation: a });
       },
-      reset: () => t(n.getInitialState())
+      reset: () => t(s.getInitialState())
     }),
     { name: "DatStore", enabled: !1 }
   )
 );
 c(i);
-const x = () => {
+const I = () => {
   const {
     datUrl: t,
     assetName: r,
-    datExtension: n,
-    transformation: e,
-    setTransformation: a,
-    closeDat: s,
+    datExtension: s,
+    transformation: a,
+    setTransformation: e,
+    closeDat: n,
     openDat: o,
-    reset: m
+    reset: d,
+    assetId: m
   } = i();
   return {
     datUrl: t,
     assetName: r,
-    datExtension: n,
-    transformation: e,
-    setTransformation: a,
-    closeDat: s,
+    datExtension: s,
+    transformation: a,
+    setTransformation: e,
+    closeDat: n,
     openDat: o,
-    reset: m
+    reset: d,
+    assetId: m
   };
 };
 export {
-  x as useDat,
+  I as useDat,
   i as useDatStore
 };
-//# sourceMappingURL=useDatStore.js.map

package/useDimensions.js

@@ -28,4 +28,3 @@ function f(r) {
 export {
   f as useDimensions
 };
-//# sourceMappingURL=useDimensions.js.map

package/useEffectEvent.js

@@ -0,0 +1,18 @@
+import { useLayoutEffect as f } from "./useLayoutEffect.js";
+import o, { useRef as u, useCallback as n } from "react";
+var a;
+const s = (a = o.useInsertionEffect) !== null && a !== void 0 ? a : f;
+function d(c) {
+  const t = u(null);
+  return s(() => {
+    t.current = c;
+  }, [
+    c
+  ]), n((...r) => {
+    const e = t.current;
+    return e?.(...r);
+  }, []);
+}
+export {
+  d as useEffectEvent
+};

package/useFocus.js

@@ -0,0 +1,30 @@
+import { useSyntheticBlurEvent as l } from "./utils5.js";
+import { useCallback as u } from "react";
+import { getActiveElement as a, getEventTarget as p } from "./DOMFunctions.js";
+import { getOwnerDocument as m } from "./domHelpers.js";
+function x(d) {
+  let { isDisabled: r, onFocus: n, onBlur: o, onFocusChange: t } = d;
+  const c = u((e) => {
+    if (e.target === e.currentTarget)
+      return o && o(e), t && t(!1), !0;
+  }, [
+    o,
+    t
+  ]), f = l(c), i = u((e) => {
+    const s = m(e.target), $ = s ? a(s) : a();
+    e.target === e.currentTarget && $ === p(e.nativeEvent) && (n && n(e), t && t(!0), f(e));
+  }, [
+    t,
+    n,
+    f
+  ]);
+  return {
+    focusProps: {
+      onFocus: !r && (n || t || o) ? i : void 0,
+      onBlur: !r && (o || t) ? c : void 0
+    }
+  };
+}
+export {
+  x as useFocus
+};

package/useFocusRing.js

@@ -0,0 +1,34 @@
+import { useFocus as $ } from "./useFocus.js";
+import { isFocusVisible as h, useFocusVisibleListener as x } from "./useFocusVisible.js";
+import { useFocusWithin as V } from "./useFocusWithin.js";
+import { useRef as m, useState as u, useCallback as c } from "react";
+function I(r = {}) {
+  let { autoFocus: a = !1, isTextInput: f, within: i } = r, s = m({
+    isFocused: !1,
+    isFocusVisible: a || h()
+  }), [n, b] = u(!1), [l, d] = u(() => s.current.isFocused && s.current.isFocusVisible), o = c(() => d(s.current.isFocused && s.current.isFocusVisible), []), t = c((e) => {
+    s.current.isFocused = e, b(e), o();
+  }, [
+    o
+  ]);
+  x((e) => {
+    s.current.isFocusVisible = e, o();
+  }, [], {
+    isTextInput: f
+  });
+  let { focusProps: F } = $({
+    isDisabled: i,
+    onFocusChange: t
+  }), { focusWithinProps: p } = V({
+    isDisabled: !i,
+    onFocusWithinChange: t
+  });
+  return {
+    isFocused: n,
+    isFocusVisible: l,
+    focusProps: i ? p : F
+  };
+}
+export {
+  I as useFocusRing
+};

package/useFocusVisible.js

@@ -0,0 +1,92 @@
+import { ignoreFocusEvent as T } from "./utils5.js";
+import { getOwnerWindow as o, getOwnerDocument as u } from "./domHelpers.js";
+import { isMac as k } from "./platform.js";
+import { isVirtualClick as M } from "./isVirtualEvent.js";
+import { useEffect as h } from "react";
+let f = null, b = /* @__PURE__ */ new Set(), d = /* @__PURE__ */ new Map(), a = !1, v = !1;
+const x = {
+  Tab: !0,
+  Escape: !0
+};
+function p(e, r) {
+  for (let t of b) t(e, r);
+}
+function H(e) {
+  return !(e.metaKey || !k() && e.altKey || e.ctrlKey || e.key === "Control" || e.key === "Shift" || e.key === "Meta");
+}
+function c(e) {
+  a = !0, H(e) && (f = "keyboard", p("keyboard", e));
+}
+function i(e) {
+  f = "pointer", (e.type === "mousedown" || e.type === "pointerdown") && (a = !0, p("pointer", e));
+}
+function E(e) {
+  M(e) && (a = !0, f = "virtual");
+}
+function m(e) {
+  e.target === window || e.target === document || T || !e.isTrusted || (!a && !v && (f = "virtual", p("virtual", e)), a = !1, v = !1);
+}
+function y() {
+  a = !1, v = !0;
+}
+function $(e) {
+  if (typeof window > "u" || d.get(o(e))) return;
+  const r = o(e), t = u(e);
+  let n = r.HTMLElement.prototype.focus;
+  r.HTMLElement.prototype.focus = function() {
+    a = !0, n.apply(this, arguments);
+  }, t.addEventListener("keydown", c, !0), t.addEventListener("keyup", c, !0), t.addEventListener("click", E, !0), r.addEventListener("focus", m, !0), r.addEventListener("blur", y, !1), typeof PointerEvent < "u" && (t.addEventListener("pointerdown", i, !0), t.addEventListener("pointermove", i, !0), t.addEventListener("pointerup", i, !0)), r.addEventListener("beforeunload", () => {
+    L(e);
+  }, {
+    once: !0
+  }), d.set(r, {
+    focus: n
+  });
+}
+const L = (e, r) => {
+  const t = o(e), n = u(e);
+  r && n.removeEventListener("DOMContentLoaded", r), d.has(t) && (t.HTMLElement.prototype.focus = d.get(t).focus, n.removeEventListener("keydown", c, !0), n.removeEventListener("keyup", c, !0), n.removeEventListener("click", E, !0), t.removeEventListener("focus", m, !0), t.removeEventListener("blur", y, !1), typeof PointerEvent < "u" && (n.removeEventListener("pointerdown", i, !0), n.removeEventListener("pointermove", i, !0), n.removeEventListener("pointerup", i, !0)), d.delete(t));
+};
+function F(e) {
+  const r = u(e);
+  let t;
+  return r.readyState !== "loading" ? $(e) : (t = () => {
+    $(e);
+  }, r.addEventListener("DOMContentLoaded", t)), () => L(e, t);
+}
+typeof document < "u" && F();
+function I() {
+  return f !== "pointer";
+}
+const K = /* @__PURE__ */ new Set([
+  "checkbox",
+  "radio",
+  "range",
+  "color",
+  "file",
+  "image",
+  "button",
+  "submit",
+  "reset"
+]);
+function O(e, r, t) {
+  let n = u(t?.target);
+  const s = typeof window < "u" ? o(t?.target).HTMLInputElement : HTMLInputElement, l = typeof window < "u" ? o(t?.target).HTMLTextAreaElement : HTMLTextAreaElement, w = typeof window < "u" ? o(t?.target).HTMLElement : HTMLElement, g = typeof window < "u" ? o(t?.target).KeyboardEvent : KeyboardEvent;
+  return e = e || n.activeElement instanceof s && !K.has(n.activeElement.type) || n.activeElement instanceof l || n.activeElement instanceof w && n.activeElement.isContentEditable, !(e && r === "keyboard" && t instanceof g && !x[t.key]);
+}
+function B(e, r, t) {
+  $(), h(() => {
+    let n = (s, l) => {
+      O(!!t?.isTextInput, s, l) && e(I());
+    };
+    return b.add(n), () => {
+      b.delete(n);
+    };
+  }, r);
+}
+export {
+  F as addWindowFocusTracking,
+  d as hasSetupGlobalListeners,
+  I as isFocusVisible,
+  B as useFocusVisibleListener
+};

package/useFocusWithin.js

@@ -0,0 +1,57 @@
+import { useSyntheticBlurEvent as F, setEventTarget as W, createSyntheticEvent as v } from "./utils5.js";
+import { useRef as x, useCallback as $ } from "react";
+import { getActiveElement as E, getEventTarget as T, nodeContains as B } from "./DOMFunctions.js";
+import { getOwnerDocument as G } from "./domHelpers.js";
+import { useGlobalListeners as L } from "./useGlobalListeners.js";
+function S(b) {
+  let { isDisabled: h, onBlurWithin: i, onFocusWithin: o, onFocusWithinChange: t } = b, r = x({
+    isFocusWithin: !1
+  }), { addGlobalListener: c, removeAllGlobalListeners: s } = L(), n = $((e) => {
+    e.currentTarget.contains(e.target) && r.current.isFocusWithin && !e.currentTarget.contains(e.relatedTarget) && (r.current.isFocusWithin = !1, s(), i && i(e), t && t(!1));
+  }, [
+    i,
+    t,
+    r,
+    s
+  ]), u = F(n), g = $((e) => {
+    if (!e.currentTarget.contains(e.target)) return;
+    const a = G(e.target), p = E(a);
+    if (!r.current.isFocusWithin && p === T(e.nativeEvent)) {
+      o && o(e), t && t(!0), r.current.isFocusWithin = !0, u(e);
+      let f = e.currentTarget;
+      c(a, "focus", (l) => {
+        if (r.current.isFocusWithin && !B(f, l.target)) {
+          let d = new a.defaultView.FocusEvent("blur", {
+            relatedTarget: l.target
+          });
+          W(d, f);
+          let m = v(d);
+          n(m);
+        }
+      }, {
+        capture: !0
+      });
+    }
+  }, [
+    o,
+    t,
+    u,
+    c,
+    n
+  ]);
+  return h ? {
+    focusWithinProps: {
+      // These cannot be null, that would conflict in mergeProps
+      onFocus: void 0,
+      onBlur: void 0
+    }
+  } : {
+    focusWithinProps: {
+      onFocus: g,
+      onBlur: n
+    }
+  };
+}
+export {
+  S as useFocusWithin
+};

package/useFonts.js

@@ -0,0 +1,118 @@
+import { useState as o, useCallback as c, useEffect as E, useMemo as O } from "react";
+import { produce as d } from "./immer.js";
+import { useDebouncedCallback as x } from "./index.module3.js";
+import { notify as P } from "./notify.js";
+import { useTranslate as B } from "./index6.js";
+import { API as T } from "./api2.js";
+import { filterFamilies as k, moveSelectedFamilyToTop as w, getFamilyAndSubfamily as U, getDefaultFont as H } from "./utils8.js";
+import { captureException as b } from "./exports3.js";
+const M = 500, Z = 20;
+function $(A) {
+  const {
+    fetchInitialSelectedFont: p = !0,
+    filterOutItalics: m,
+    initialFamilyId: D,
+    initialSubfamilyId: L,
+    batchSize: f = Z
+  } = A || {}, [S] = o(D), [g] = o(L), { translate: a } = B(), [v, I] = o(!1), [z, h] = o(!1), [C, u] = o({
+    portal: [],
+    global: [],
+    selectedFamily: null,
+    selectedSubfamily: null
+  }), n = c((t) => {
+    u(
+      d((e) => {
+        e.selectedFamily = t;
+      })
+    );
+  }, []), s = c((t) => {
+    u(
+      d((e) => {
+        e.selectedSubfamily = t;
+      })
+    );
+  }, []);
+  E(() => {
+    if (!p)
+      return;
+    async function t() {
+      try {
+        const e = await U(S, g);
+        n(e.family), s(e.subfamily);
+      } catch (e) {
+        const i = await H().catch((l) => (b(l), null));
+        i && (n(i.family), s(i.subfamily)), b(e), P({
+          title: a("fontmanager.picker.error.fetching.selected-family"),
+          variant: "error",
+          isPersistent: !1
+        });
+      } finally {
+        h(!0);
+      }
+    }
+    t();
+  }, [
+    p,
+    S,
+    g,
+    n,
+    s,
+    a
+  ]);
+  const r = c(
+    async (t) => {
+      I(!0);
+      try {
+        const e = await T.getPortalFonts(f, t), i = await T.getGlobalFonts(f, t);
+        u(
+          d((l) => {
+            let F = k(e, m), y = k(i, m);
+            l.selectedFamily && (l.selectedFamily.portal_id === null ? y = w(
+              y,
+              l.selectedFamily
+            ) : F = w(
+              F,
+              l.selectedFamily
+            )), l.portal = F, l.global = y;
+          })
+        );
+      } catch (e) {
+        b(e), P({
+          title: a("fontmanager.picker.error.fetching.families"),
+          variant: "error",
+          isPersistent: !1
+        });
+      } finally {
+        I(!1), h(!0);
+      }
+    },
+    [m, a, f]
+  ), _ = x((t) => {
+    r(t);
+  }, M), G = c(
+    (t) => {
+      _(t);
+    },
+    [_]
+  );
+  E(() => {
+    r();
+  }, [r]);
+  const N = () => {
+    r();
+  };
+  return {
+    ...O(() => C, [C]),
+    setSelectedFamily: n,
+    setSelectedSubfamily: s,
+    searchFonts: G,
+    isLoading: v,
+    refresh: N,
+    initialLoadComplete: z
+  };
+}
+export {
+  Z as FONT_BATCH_SIZE,
+  M as INPUT_DEBOUNCE,
+  $ as useFonts
+};

package/useGlobalListeners.js

@@ -0,0 +1,34 @@
+import { useRef as c, useCallback as f, useEffect as b } from "react";
+function L() {
+  let o = c(/* @__PURE__ */ new Map()), u = f((e, l, r, t) => {
+    let n = t?.once ? (...d) => {
+      o.current.delete(r), r(...d);
+    } : r;
+    o.current.set(r, {
+      type: l,
+      eventTarget: e,
+      fn: n,
+      options: t
+    }), e.addEventListener(l, n, t);
+  }, []), a = f((e, l, r, t) => {
+    var n;
+    let d = ((n = o.current.get(r)) === null || n === void 0 ? void 0 : n.fn) || r;
+    e.removeEventListener(l, d, t), o.current.delete(r);
+  }, []), s = f(() => {
+    o.current.forEach((e, l) => {
+      a(e.eventTarget, e.type, l, e.options);
+    });
+  }, [
+    a
+  ]);
+  return b(() => s, [
+    s
+  ]), {
+    addGlobalListener: u,
+    removeGlobalListener: a,
+    removeAllGlobalListeners: s
+  };
+}
+export {
+  L as useGlobalListeners
+};

package/useGroupContext.js

@@ -0,0 +1,10 @@
+import { createContext as t, useContext as e } from "react";
+const n = t(void 0);
+function u(o) {
+  if (!e(n))
+    throw new Error(`<Form.${o}> cannot be rendered outside the <Form.Group> component`);
+}
+export {
+  n as GroupContext,
+  u as useGroupParent
+};

package/useHover.js

@@ -0,0 +1,79 @@
+import { useState as T, useRef as y, useEffect as c, useMemo as b } from "react";
+let s = !1, f = 0;
+function g() {
+  s = !0, setTimeout(() => {
+    s = !1;
+  }, 50);
+}
+function m(a) {
+  a.pointerType === "touch" && g();
+}
+function P() {
+  if (!(typeof document > "u"))
+    return typeof PointerEvent < "u" ? document.addEventListener("pointerup", m) : document.addEventListener("touchend", g), f++, () => {
+      f--, !(f > 0) && (typeof PointerEvent < "u" ? document.removeEventListener("pointerup", m) : document.removeEventListener("touchend", g));
+    };
+}
+function L(a) {
+  let { onHoverStart: d, onHoverChange: i, onHoverEnd: v, isDisabled: r } = a, [H, p] = T(!1), t = y({
+    isHovered: !1,
+    ignoreEmulatedMouseEvents: !1,
+    pointerType: "",
+    target: null
+  }).current;
+  c(P, []);
+  let { hoverProps: h, triggerHoverEnd: $ } = b(() => {
+    let E = (e, n) => {
+      if (t.pointerType = n, r || n === "touch" || t.isHovered || !e.currentTarget.contains(e.target)) return;
+      t.isHovered = !0;
+      let u = e.currentTarget;
+      t.target = u, d && d({
+        type: "hoverstart",
+        target: u,
+        pointerType: n
+      }), i && i(!0), p(!0);
+    }, l = (e, n) => {
+      if (t.pointerType = "", t.target = null, n === "touch" || !t.isHovered) return;
+      t.isHovered = !1;
+      let u = e.currentTarget;
+      v && v({
+        type: "hoverend",
+        target: u,
+        pointerType: n
+      }), i && i(!1), p(!1);
+    }, o = {};
+    return typeof PointerEvent < "u" ? (o.onPointerEnter = (e) => {
+      s && e.pointerType === "mouse" || E(e, e.pointerType);
+    }, o.onPointerLeave = (e) => {
+      !r && e.currentTarget.contains(e.target) && l(e, e.pointerType);
+    }) : (o.onTouchStart = () => {
+      t.ignoreEmulatedMouseEvents = !0;
+    }, o.onMouseEnter = (e) => {
+      !t.ignoreEmulatedMouseEvents && !s && E(e, "mouse"), t.ignoreEmulatedMouseEvents = !1;
+    }, o.onMouseLeave = (e) => {
+      !r && e.currentTarget.contains(e.target) && l(e, "mouse");
+    }), {
+      hoverProps: o,
+      triggerHoverEnd: l
+    };
+  }, [
+    d,
+    i,
+    v,
+    r,
+    t
+  ]);
+  return c(() => {
+    r && $({
+      currentTarget: t.target
+    }, t.pointerType);
+  }, [
+    r
+  ]), {
+    hoverProps: h,
+    isHovered: H
+  };
+}
+export {
+  L as useHover
+};

package/useId.js

@@ -0,0 +1,8 @@
+import { useMemo as r } from "react";
+import { nanoid as m } from "./index.browser.js";
+function e(o) {
+  return r(() => o + "-" + m(), [o]);
+}
+export {
+  e as useId
+};

package/useId2.js

@@ -0,0 +1,17 @@
+import "react";
+let n = /* @__PURE__ */ new Map();
+typeof FinalizationRegistry < "u" && new FinalizationRegistry((e) => {
+  n.delete(e);
+});
+function o(e, t) {
+  if (e === t) return e;
+  let f = n.get(e);
+  if (f)
+    return f.forEach((r) => r.current = t), t;
+  let a = n.get(t);
+  return a ? (a.forEach((r) => r.current = e), e) : t;
+}
+export {
+  n as idsUpdaterMap,
+  o as mergeIds
+};

package/useKeyDown.js

@@ -0,0 +1,14 @@
+import { useEffect as t } from "react";
+function d(e, n) {
+  t(() => {
+    function o(r) {
+      r.key === e && n(r);
+    }
+    return window.addEventListener("keydown", o), () => {
+      window.removeEventListener("keydown", o);
+    };
+  }, [n, e]);
+}
+export {
+  d as useKeyDown
+};

package/useLayoutEffect.js

@@ -0,0 +1,6 @@
+import e from "react";
+const f = typeof document < "u" ? e.useLayoutEffect : () => {
+};
+export {
+  f as useLayoutEffect
+};