@gardenfi/garden-book 0.2.31 → 0.3.0-beta.2

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.dom.js

@@ -0,0 +1,136 @@
+function u() {
+  return typeof window < "u";
+}
+function a(t) {
+  return m(t) ? (t.nodeName || "").toLowerCase() : "#document";
+}
+function i(t) {
+  var n;
+  return (t == null || (n = t.ownerDocument) == null ? void 0 : n.defaultView) || window;
+}
+function L(t) {
+  var n;
+  return (n = (m(t) ? t.ownerDocument : t.document) || window.document) == null ? void 0 : n.documentElement;
+}
+function m(t) {
+  return u() ? t instanceof Node || t instanceof i(t).Node : !1;
+}
+function h(t) {
+  return u() ? t instanceof Element || t instanceof i(t).Element : !1;
+}
+function g(t) {
+  return u() ? t instanceof HTMLElement || t instanceof i(t).HTMLElement : !1;
+}
+function p(t) {
+  return !u() || typeof ShadowRoot > "u" ? !1 : t instanceof ShadowRoot || t instanceof i(t).ShadowRoot;
+}
+function y(t) {
+  const {
+    overflow: n,
+    overflowX: r,
+    overflowY: c,
+    display: e
+  } = b(t);
+  return /auto|scroll|overlay|hidden|clip/.test(n + c + r) && e !== "inline" && e !== "contents";
+}
+function _(t) {
+  return /^(table|td|th)$/.test(a(t));
+}
+function T(t) {
+  try {
+    if (t.matches(":popover-open"))
+      return !0;
+  } catch {
+  }
+  try {
+    return t.matches(":modal");
+  } catch {
+    return !1;
+  }
+}
+const v = /transform|translate|scale|rotate|perspective|filter/, C = /paint|layout|strict|content/, o = (t) => !!t && t !== "none";
+let s;
+function D(t) {
+  const n = h(t) ? b(t) : t;
+  return o(n.transform) || o(n.translate) || o(n.scale) || o(n.rotate) || o(n.perspective) || !R() && (o(n.backdropFilter) || o(n.filter)) || v.test(n.willChange || "") || C.test(n.contain || "");
+}
+function W(t) {
+  let n = f(t);
+  for (; g(n) && !N(n); ) {
+    if (D(n))
+      return n;
+    if (T(n))
+      return null;
+    n = f(n);
+  }
+  return null;
+}
+function R() {
+  return s == null && (s = typeof CSS < "u" && CSS.supports && CSS.supports("-webkit-backdrop-filter", "none")), s;
+}
+function N(t) {
+  return /^(html|body|#document)$/.test(a(t));
+}
+function b(t) {
+  return i(t).getComputedStyle(t);
+}
+function $(t) {
+  return h(t) ? {
+    scrollLeft: t.scrollLeft,
+    scrollTop: t.scrollTop
+  } : {
+    scrollLeft: t.scrollX,
+    scrollTop: t.scrollY
+  };
+}
+function f(t) {
+  if (a(t) === "html")
+    return t;
+  const n = (
+    // Step into the shadow DOM of the parent of a slotted node.
+    t.assignedSlot || // DOM Element detected.
+    t.parentNode || // ShadowRoot detected.
+    p(t) && t.host || // Fallback.
+    L(t)
+  );
+  return p(n) ? n.host : n;
+}
+function S(t) {
+  const n = f(t);
+  return N(n) ? t.ownerDocument ? t.ownerDocument.body : t.body : g(n) && y(n) ? n : S(n);
+}
+function w(t, n, r) {
+  var c;
+  n === void 0 && (n = []), r === void 0 && (r = !0);
+  const e = S(t), E = e === ((c = t.ownerDocument) == null ? void 0 : c.body), l = i(e);
+  if (E) {
+    const d = k(l);
+    return n.concat(l, l.visualViewport || [], y(e) ? e : [], d && r ? w(d) : []);
+  } else
+    return n.concat(e, w(e, [], r));
+}
+function k(t) {
+  return t.parent && Object.getPrototypeOf(t.parent) ? t.frameElement : null;
+}
+export {
+  b as getComputedStyle,
+  W as getContainingBlock,
+  L as getDocumentElement,
+  k as getFrameElement,
+  S as getNearestOverflowAncestor,
+  a as getNodeName,
+  $ as getNodeScroll,
+  w as getOverflowAncestors,
+  f as getParentNode,
+  i as getWindow,
+  D as isContainingBlock,
+  h as isElement,
+  g as isHTMLElement,
+  N as isLastTraversableNode,
+  m as isNode,
+  y as isOverflowElement,
+  p as isShadowRoot,
+  _ as isTableElement,
+  T as isTopLayer,
+  R as isWebKit
+};

package/dist/node_modules/@floating-ui/utils/dist/floating-ui.utils.js

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

package/dist/node_modules/@radix-ui/react-arrow/dist/index.js

@@ -0,0 +1,24 @@
+import * as n from "react";
+import { Primitive as p } from "../../react-primitive/dist/index.js";
+import { jsx as o } from "react/jsx-runtime";
+var v = "Arrow", e = n.forwardRef((r, i) => {
+  const { children: t, width: a = 10, height: s = 5, ...m } = r;
+  return /* @__PURE__ */ o(
+    p.svg,
+    {
+      ...m,
+      ref: i,
+      width: a,
+      height: s,
+      viewBox: "0 0 30 10",
+      preserveAspectRatio: "none",
+      children: r.asChild ? t : /* @__PURE__ */ o("polygon", { points: "0,0 30,0 15,10" })
+    }
+  );
+});
+e.displayName = v;
+var h = e;
+export {
+  e as Arrow,
+  h as Root
+};

package/dist/node_modules/@radix-ui/react-checkbox/dist/index.js

@@ -0,0 +1,251 @@
+import * as s from "react";
+import { useComposedRefs as B } from "../../react-compose-refs/dist/index.js";
+import { createContextScope as L } from "../../react-context/dist/index.js";
+import { composeEventHandlers as S } from "../../primitive/dist/index.js";
+import { useControllableState as O } from "../../react-use-controllable-state/dist/index.js";
+import { usePrevious as j } from "../../react-use-previous/dist/index.js";
+import { useSize as H } from "../../react-use-size/dist/index.js";
+import { Presence as z } from "../../react-presence/dist/index.js";
+import { Primitive as P } from "../../react-primitive/dist/index.js";
+import { jsx as b, jsxs as G, Fragment as K } from "react/jsx-runtime";
+var g = "Checkbox", [U] = L(g), [X, E] = U(g);
+function J(t) {
+  const {
+    __scopeCheckbox: a,
+    checked: c,
+    children: u,
+    defaultChecked: r,
+    disabled: e,
+    form: p,
+    name: f,
+    onCheckedChange: i,
+    required: m,
+    value: C = "on",
+    // @ts-expect-error
+    internal_do_not_use_render: d
+  } = t, [l, v] = O({
+    prop: c,
+    defaultProp: r ?? !1,
+    onChange: i,
+    caller: g
+  }), [k, x] = s.useState(null), [_, o] = s.useState(null), n = s.useRef(!1), I = k ? !!p || !!k.closest("form") : (
+    // We set this to true by default so that events bubble to forms without JS (SSR)
+    !0
+  ), R = {
+    checked: l,
+    disabled: e,
+    setChecked: v,
+    control: k,
+    setControl: x,
+    name: f,
+    form: p,
+    value: C,
+    hasConsumerStoppedPropagationRef: n,
+    required: m,
+    defaultChecked: h(r) ? !1 : r,
+    isFormControl: I,
+    bubbleInput: _,
+    setBubbleInput: o
+  };
+  return /* @__PURE__ */ b(
+    X,
+    {
+      scope: a,
+      ...R,
+      children: W(d) ? d(R) : u
+    }
+  );
+}
+var N = "CheckboxTrigger", w = s.forwardRef(
+  ({ __scopeCheckbox: t, onKeyDown: a, onClick: c, ...u }, r) => {
+    const {
+      control: e,
+      value: p,
+      disabled: f,
+      checked: i,
+      required: m,
+      setControl: C,
+      setChecked: d,
+      hasConsumerStoppedPropagationRef: l,
+      isFormControl: v,
+      bubbleInput: k
+    } = E(N, t), x = B(r, C), _ = s.useRef(i);
+    return s.useEffect(() => {
+      const o = e == null ? void 0 : e.form;
+      if (o) {
+        const n = () => d(_.current);
+        return o.addEventListener("reset", n), () => o.removeEventListener("reset", n);
+      }
+    }, [e, d]), /* @__PURE__ */ b(
+      P.button,
+      {
+        type: "button",
+        role: "checkbox",
+        "aria-checked": h(i) ? "mixed" : i,
+        "aria-required": m,
+        "data-state": A(i),
+        "data-disabled": f ? "" : void 0,
+        disabled: f,
+        value: p,
+        ...u,
+        ref: x,
+        onKeyDown: S(a, (o) => {
+          o.key === "Enter" && o.preventDefault();
+        }),
+        onClick: S(c, (o) => {
+          d((n) => h(n) ? !0 : !n), k && v && (l.current = o.isPropagationStopped(), l.current || o.stopPropagation());
+        })
+      }
+    );
+  }
+);
+w.displayName = N;
+var Q = s.forwardRef(
+  (t, a) => {
+    const {
+      __scopeCheckbox: c,
+      name: u,
+      checked: r,
+      defaultChecked: e,
+      required: p,
+      disabled: f,
+      value: i,
+      onCheckedChange: m,
+      form: C,
+      ...d
+    } = t;
+    return /* @__PURE__ */ b(
+      J,
+      {
+        __scopeCheckbox: c,
+        checked: r,
+        defaultChecked: e,
+        disabled: f,
+        required: p,
+        onCheckedChange: m,
+        name: u,
+        form: C,
+        value: i,
+        internal_do_not_use_render: ({ isFormControl: l }) => /* @__PURE__ */ G(K, { children: [
+          /* @__PURE__ */ b(
+            w,
+            {
+              ...d,
+              ref: a,
+              __scopeCheckbox: c
+            }
+          ),
+          l && /* @__PURE__ */ b(
+            q,
+            {
+              __scopeCheckbox: c
+            }
+          )
+        ] })
+      }
+    );
+  }
+);
+Q.displayName = g;
+var T = "CheckboxIndicator", V = s.forwardRef(
+  (t, a) => {
+    const { __scopeCheckbox: c, forceMount: u, ...r } = t, e = E(T, c);
+    return /* @__PURE__ */ b(
+      z,
+      {
+        present: u || h(e.checked) || e.checked === !0,
+        children: /* @__PURE__ */ b(
+          P.span,
+          {
+            "data-state": A(e.checked),
+            "data-disabled": e.disabled ? "" : void 0,
+            ...r,
+            ref: a,
+            style: { pointerEvents: "none", ...t.style }
+          }
+        )
+      }
+    );
+  }
+);
+V.displayName = T;
+var M = "CheckboxBubbleInput", q = s.forwardRef(
+  ({ __scopeCheckbox: t, ...a }, c) => {
+    const {
+      control: u,
+      hasConsumerStoppedPropagationRef: r,
+      checked: e,
+      defaultChecked: p,
+      required: f,
+      disabled: i,
+      name: m,
+      value: C,
+      form: d,
+      bubbleInput: l,
+      setBubbleInput: v
+    } = E(M, t), k = B(c, v), x = j(e), _ = H(u);
+    s.useEffect(() => {
+      const n = l;
+      if (!n) return;
+      const I = window.HTMLInputElement.prototype, y = Object.getOwnPropertyDescriptor(
+        I,
+        "checked"
+      ).set, D = !r.current;
+      if (x !== e && y) {
+        const F = new Event("click", { bubbles: D });
+        n.indeterminate = h(e), y.call(n, h(e) ? !1 : e), n.dispatchEvent(F);
+      }
+    }, [l, x, e, r]);
+    const o = s.useRef(h(e) ? !1 : e);
+    return /* @__PURE__ */ b(
+      P.input,
+      {
+        type: "checkbox",
+        "aria-hidden": !0,
+        defaultChecked: p ?? o.current,
+        required: f,
+        disabled: i,
+        name: m,
+        value: C,
+        form: d,
+        ...a,
+        tabIndex: -1,
+        ref: k,
+        style: {
+          ...a.style,
+          ..._,
+          position: "absolute",
+          pointerEvents: "none",
+          opacity: 0,
+          margin: 0,
+          // We transform because the input is absolutely positioned but we have
+          // rendered it **after** the button. This pulls it back to sit on top
+          // of the button.
+          transform: "translateX(-100%)"
+        }
+      }
+    );
+  }
+);
+q.displayName = M;
+function W(t) {
+  return typeof t == "function";
+}
+function h(t) {
+  return t === "indeterminate";
+}
+function A(t) {
+  return h(t) ? "indeterminate" : t ? "checked" : "unchecked";
+}
+export {
+  Q as Checkbox,
+  V as CheckboxIndicator,
+  V as Indicator,
+  Q as Root,
+  q as unstable_BubbleInput,
+  q as unstable_CheckboxBubbleInput,
+  J as unstable_CheckboxProvider,
+  w as unstable_CheckboxTrigger,
+  J as unstable_Provider,
+  w as unstable_Trigger
+};

package/dist/node_modules/@radix-ui/react-collection/dist/index.js

@@ -0,0 +1,48 @@
+import r from "react";
+import { createContextScope as y } from "../../react-context/dist/index.js";
+import { useComposedRefs as M } from "../../react-compose-refs/dist/index.js";
+import { createSlot as x } from "../node_modules/@radix-ui/react-slot/dist/index.js";
+import { jsx as u } from "react/jsx-runtime";
+function g(s) {
+  const m = s + "CollectionProvider", [A, N] = y(m), [_, f] = A(
+    m,
+    { collectionRef: { current: null }, itemMap: /* @__PURE__ */ new Map() }
+  ), p = (c) => {
+    const { scope: e, children: l } = c, o = r.useRef(null), t = r.useRef(/* @__PURE__ */ new Map()).current;
+    return /* @__PURE__ */ u(_, { scope: e, itemMap: t, collectionRef: o, children: l });
+  };
+  p.displayName = m;
+  const a = s + "CollectionSlot", E = x(a), C = r.forwardRef(
+    (c, e) => {
+      const { scope: l, children: o } = c, t = f(a, l), n = M(e, t.collectionRef);
+      return /* @__PURE__ */ u(E, { ref: n, children: o });
+    }
+  );
+  C.displayName = a;
+  const d = s + "CollectionItemSlot", R = "data-radix-collection-item", T = x(d), I = r.forwardRef(
+    (c, e) => {
+      const { scope: l, children: o, ...t } = c, n = r.useRef(null), S = M(e, n), i = f(d, l);
+      return r.useEffect(() => (i.itemMap.set(n, { ref: n, ...t }), () => void i.itemMap.delete(n))), /* @__PURE__ */ u(T, { [R]: "", ref: S, children: o });
+    }
+  );
+  I.displayName = d;
+  function O(c) {
+    const e = f(s + "CollectionConsumer", c);
+    return r.useCallback(() => {
+      const o = e.collectionRef.current;
+      if (!o) return [];
+      const t = Array.from(o.querySelectorAll(`[${R}]`));
+      return Array.from(e.itemMap.values()).sort(
+        (i, v) => t.indexOf(i.ref.current) - t.indexOf(v.ref.current)
+      );
+    }, [e.collectionRef, e.itemMap]);
+  }
+  return [
+    { Provider: p, Slot: C, ItemSlot: I },
+    O,
+    N
+  ];
+}
+export {
+  g as createCollection
+};

package/dist/node_modules/@radix-ui/{react-slot → react-collection/node_modules/@radix-ui/react-slot}/dist/index.js

@@ -1,5 +1,5 @@
 import * as l from "react";
-import { composeRefs as m } from "../../react-compose-refs/dist/index.js";
+import { composeRefs as m } from "../../../../../react-compose-refs/dist/index.js";
 import { jsx as u } from "react/jsx-runtime";
 // @__NO_SIDE_EFFECTS__
 function b(e) {

package/dist/node_modules/@radix-ui/react-dialog/dist/index.js

@@ -12,7 +12,7 @@ import { Primitive as m } from "../../react-primitive/dist/index.js";
 import { useFocusGuards as K } from "../../react-focus-guards/dist/index.js";
 import { RemoveScroll as U } from "react-remove-scroll";
 import { hideOthers as Y } from "../../../aria-hidden/dist/es2015/index.js";
-import { createSlot as Z } from "../../react-slot/dist/index.js";
+import { createSlot as Z } from "../node_modules/@radix-ui/react-slot/dist/index.js";
 import { jsx as i, jsxs as P, Fragment as O } from "react/jsx-runtime";
 var v = "Dialog", [I] = $(v), [z, u] = I(v), x = (e) => {
   const {

package/dist/node_modules/@radix-ui/react-dialog/node_modules/@radix-ui/react-slot/dist/index.js

@@ -0,0 +1,50 @@
+import * as l from "react";
+import { composeRefs as m } from "../../../../../react-compose-refs/dist/index.js";
+import { jsx as u } from "react/jsx-runtime";
+// @__NO_SIDE_EFFECTS__
+function b(e) {
+  const n = /* @__PURE__ */ y(e), o = l.forwardRef((t, r) => {
+    const { children: i, ...c } = t, s = l.Children.toArray(i), a = s.find(E);
+    if (a) {
+      const f = a.props.children, d = s.map((p) => p === a ? l.Children.count(f) > 1 ? l.Children.only(null) : l.isValidElement(f) ? f.props.children : null : p);
+      return /* @__PURE__ */ u(n, { ...c, ref: r, children: l.isValidElement(f) ? l.cloneElement(f, void 0, d) : null });
+    }
+    return /* @__PURE__ */ u(n, { ...c, ref: r, children: i });
+  });
+  return o.displayName = `${e}.Slot`, o;
+}
+// @__NO_SIDE_EFFECTS__
+function y(e) {
+  const n = l.forwardRef((o, t) => {
+    const { children: r, ...i } = o;
+    if (l.isValidElement(r)) {
+      const c = S(r), s = C(i, r.props);
+      return r.type !== l.Fragment && (s.ref = t ? m(t, c) : c), l.cloneElement(r, s);
+    }
+    return l.Children.count(r) > 1 ? l.Children.only(null) : null;
+  });
+  return n.displayName = `${e}.SlotClone`, n;
+}
+var g = Symbol("radix.slottable");
+function E(e) {
+  return l.isValidElement(e) && typeof e.type == "function" && "__radixId" in e.type && e.type.__radixId === g;
+}
+function C(e, n) {
+  const o = { ...n };
+  for (const t in n) {
+    const r = e[t], i = n[t];
+    /^on[A-Z]/.test(t) ? r && i ? o[t] = (...s) => {
+      const a = i(...s);
+      return r(...s), a;
+    } : r && (o[t] = r) : t === "style" ? o[t] = { ...r, ...i } : t === "className" && (o[t] = [r, i].filter(Boolean).join(" "));
+  }
+  return { ...e, ...o };
+}
+function S(e) {
+  var t, r;
+  let n = (t = Object.getOwnPropertyDescriptor(e.props, "ref")) == null ? void 0 : t.get, o = n && "isReactWarning" in n && n.isReactWarning;
+  return o ? e.ref : (n = (r = Object.getOwnPropertyDescriptor(e, "ref")) == null ? void 0 : r.get, o = n && "isReactWarning" in n && n.isReactWarning, o ? e.props.ref : e.props.ref || e.ref);
+}
+export {
+  b as createSlot
+};

package/dist/node_modules/@radix-ui/react-direction/dist/index.js

@@ -0,0 +1,10 @@
+import * as t from "react";
+import "react/jsx-runtime";
+var r = t.createContext(void 0);
+function n(o) {
+  const e = t.useContext(r);
+  return o || e || "ltr";
+}
+export {
+  n as useDirection
+};