@fluidattacks/design 8.1.0 → 8.2.0

package/dist/node_modules/motion-dom/dist/es/render/html/utils/build-transform.js

@@ -0,0 +1,38 @@
+import { getValueAsType as c } from "../../../value/types/utils/get-as-type.js";
+import { numberValueTypes as p } from "../../../value/types/maps/number.js";
+import { transformPropOrder as m } from "../../utils/keys-transform.js";
+const y = {
+  x: "translateX",
+  y: "translateY",
+  z: "translateZ",
+  transformPerspective: "perspective"
+}, d = m.length;
+function A(f, l, n) {
+  let t = "", o = !0;
+  for (let i = 0; i < d; i++) {
+    const e = m[i], r = f[e];
+    if (r === void 0)
+      continue;
+    let a = !0;
+    if (typeof r == "number")
+      a = r === (e.startsWith("scale") ? 1 : 0);
+    else {
+      const s = parseFloat(r);
+      a = e.startsWith("scale") ? s === 1 : s === 0;
+    }
+    if (!a || n) {
+      const s = c(r, p[e]);
+      if (!a) {
+        o = !1;
+        const h = y[e] || e;
+        t += `${h}(${s}) `;
+      }
+      n && (l[e] = s);
+    }
+  }
+  const u = f.pathRotation;
+  return u && (o = !1, t += `rotate(${c(u, p.pathRotation)}) `), t = t.trim(), n ? t = n(l, o ? "" : t) : o && (t = "none"), t;
+}
+export {
+  A as buildTransform
+};

package/dist/node_modules/motion-dom/dist/es/render/html/utils/render.js

@@ -0,0 +1,12 @@
+function i(r, { style: n, vars: o }, l, y) {
+  const t = r.style;
+  let e;
+  for (e in n)
+    t[e] = n[e];
+  y?.applyProjectionStyles(t, l);
+  for (e in o)
+    t.setProperty(e, o[e]);
+}
+export {
+  i as renderHTML
+};

package/dist/node_modules/motion-dom/dist/es/render/html/utils/scrape-motion-values.js

@@ -0,0 +1,13 @@
+import { isMotionValue as i } from "../../../value/utils/is-motion-value.js";
+import { isForcedMotionValue as u } from "../../utils/is-forced-motion-value.js";
+function a(n, s, l) {
+  const o = n.style, r = s?.style, t = {};
+  if (!o)
+    return t;
+  for (const e in o)
+    (i(o[e]) || r && i(r[e]) || u(e, n) || l?.getValue(e)?.liveStyle !== void 0) && (t[e] = o[e]);
+  return t;
+}
+export {
+  a as scrapeMotionValuesFromProps
+};

package/dist/node_modules/motion-dom/dist/es/render/store.js

@@ -0,0 +1,4 @@
+const e = /* @__PURE__ */ new WeakMap();
+export {
+  e as visualElementStore
+};

package/dist/node_modules/motion-dom/dist/es/render/svg/SVGVisualElement.js

@@ -0,0 +1,40 @@
+import { transformProps as s } from "../utils/keys-transform.js";
+import { getDefaultValueType as a } from "../../value/types/maps/defaults.js";
+import { createBox as m } from "../../projection/geometry/models.js";
+import { DOMVisualElement as i } from "../dom/DOMVisualElement.js";
+import { camelToDash as u } from "../dom/utils/camel-to-dash.js";
+import { buildSVGAttrs as n } from "./utils/build-attrs.js";
+import { camelCaseAttributes as p } from "./utils/camel-case-attrs.js";
+import { isSVGTag as l } from "./utils/is-svg-tag.js";
+import { renderSVG as f } from "./utils/render.js";
+import { scrapeMotionValuesFromProps as V } from "./utils/scrape-motion-values.js";
+class A extends i {
+  constructor() {
+    super(...arguments), this.type = "svg", this.isSVGTag = !1, this.measureInstanceViewportBox = m;
+  }
+  getBaseTargetFromProps(t, r) {
+    return t[r];
+  }
+  readValueFromInstance(t, r) {
+    if (s.has(r)) {
+      const e = a(r);
+      return e && e.default || 0;
+    }
+    return r = p.has(r) ? r : u(r), t.getAttribute(r);
+  }
+  scrapeMotionValuesFromProps(t, r, e) {
+    return V(t, r, e);
+  }
+  build(t, r, e) {
+    n(t, r, this.isSVGTag, e.transformTemplate, e.style);
+  }
+  renderInstance(t, r, e, o) {
+    f(t, r, e, o);
+  }
+  mount(t) {
+    this.isSVGTag = l(t.tagName), super.mount(t);
+  }
+}
+export {
+  A as SVGVisualElement
+};

package/dist/node_modules/motion-dom/dist/es/render/svg/utils/build-attrs.js

@@ -0,0 +1,32 @@
+import { buildHTMLStyles as y } from "../../html/utils/build-styles.js";
+import { buildSVGPath as c } from "./path.js";
+const B = [
+  "offsetDistance",
+  "offsetPath",
+  "offsetRotate",
+  "offsetAnchor"
+];
+function P(r, {
+  attrX: e,
+  attrY: n,
+  attrScale: s,
+  pathLength: t,
+  pathSpacing: d = 1,
+  pathOffset: m = 0,
+  // This is object creation, which we try to avoid per-frame.
+  ...l
+}, a, u, x) {
+  if (y(r, l, u), a) {
+    r.style.viewBox && (r.attrs.viewBox = r.style.viewBox);
+    return;
+  }
+  r.attrs = r.style, r.style = {};
+  const { attrs: f, style: o } = r;
+  f.transform && (o.transform = f.transform, delete f.transform), (o.transform || f.transformOrigin) && (o.transformOrigin = f.transformOrigin ?? "50% 50%", delete f.transformOrigin), o.transform && (o.transformBox = x?.transformBox ?? "fill-box", delete f.transformBox);
+  for (const i of B)
+    f[i] !== void 0 && (o[i] = f[i], delete f[i]);
+  e !== void 0 && (f.x = e), n !== void 0 && (f.y = n), s !== void 0 && (f.scale = s), t !== void 0 && c(f, t, d, m, !1);
+}
+export {
+  P as buildSVGAttrs
+};

package/dist/node_modules/motion-dom/dist/es/render/svg/utils/camel-case-attrs.js

@@ -0,0 +1,28 @@
+const e = /* @__PURE__ */ new Set([
+  "baseFrequency",
+  "diffuseConstant",
+  "kernelMatrix",
+  "kernelUnitLength",
+  "keySplines",
+  "keyTimes",
+  "limitingConeAngle",
+  "markerHeight",
+  "markerWidth",
+  "numOctaves",
+  "targetX",
+  "targetY",
+  "surfaceScale",
+  "specularConstant",
+  "specularExponent",
+  "stdDeviation",
+  "tableValues",
+  "viewBox",
+  "gradientTransform",
+  "pathLength",
+  "startOffset",
+  "textLength",
+  "lengthAdjust"
+]);
+export {
+  e as camelCaseAttributes
+};

package/dist/node_modules/motion-dom/dist/es/render/svg/utils/is-svg-tag.js

@@ -0,0 +1,4 @@
+const s = (o) => typeof o == "string" && o.toLowerCase() === "svg";
+export {
+  s as isSVGTag
+};

package/dist/node_modules/motion-dom/dist/es/render/svg/utils/path.js

@@ -0,0 +1,15 @@
+const f = {
+  offset: "stroke-dashoffset",
+  array: "stroke-dasharray"
+}, h = {
+  offset: "strokeDashoffset",
+  array: "strokeDasharray"
+};
+function y(s, e, o = 1, r = 0, t = !0) {
+  s.pathLength = 1;
+  const a = t ? f : h;
+  s[a.offset] = `${-r}`, s[a.array] = `${e} ${o}`;
+}
+export {
+  y as buildSVGPath
+};

package/dist/node_modules/motion-dom/dist/es/render/svg/utils/render.js

@@ -0,0 +1,11 @@
+import { camelToDash as i } from "../../dom/utils/camel-to-dash.js";
+import { renderHTML as m } from "../../html/utils/render.js";
+import { camelCaseAttributes as e } from "./camel-case-attrs.js";
+function c(o, t, f, s) {
+  m(o, t, void 0, s);
+  for (const r in t.attrs)
+    o.setAttribute(e.has(r) ? r : i(r), t.attrs[r]);
+}
+export {
+  c as renderSVG
+};

package/dist/node_modules/motion-dom/dist/es/render/svg/utils/scrape-motion-values.js

@@ -0,0 +1,15 @@
+import { isMotionValue as n } from "../../../value/utils/is-motion-value.js";
+import { transformPropOrder as i } from "../../utils/keys-transform.js";
+import { scrapeMotionValuesFromProps as m } from "../../html/utils/scrape-motion-values.js";
+function l(r, t, s) {
+  const e = m(r, t, s);
+  for (const o in r)
+    if (n(r[o]) || n(t[o])) {
+      const a = i.indexOf(o) !== -1 ? "attr" + o.charAt(0).toUpperCase() + o.substring(1) : o;
+      e[a] = r[o];
+    }
+  return e;
+}
+export {
+  l as scrapeMotionValuesFromProps
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/animation-state.js

@@ -0,0 +1,143 @@
+import { animateVisualElement as N } from "../../animation/interfaces/visual-element.js";
+import { calcChildStagger as Q } from "../../animation/utils/calc-child-stagger.js";
+import { getVariantContext as U } from "./get-variant-context.js";
+import { isAnimationControls as W } from "./is-animation-controls.js";
+import { isKeyframesTarget as k } from "./is-keyframes-target.js";
+import { isVariantLabel as X } from "./is-variant-label.js";
+import { resolveVariant as K } from "./resolve-dynamic-variants.js";
+import { shallowCompare as H } from "./shallow-compare.js";
+import { variantPriorityOrder as L } from "./variant-props.js";
+const Y = [...L].reverse(), Z = L.length;
+function _(e) {
+  return (f) => Promise.all(f.map(({ animation: c, options: p }) => N(e, c, p)));
+}
+function fe(e) {
+  let f = _(e), c = B(), p = !0, V = !1;
+  const z = (s) => (n, y) => {
+    const l = K(e, y, s === "exit" ? e.presenceContext?.custom : void 0);
+    if (l) {
+      const { transition: m, transitionEnd: d, ...C } = l;
+      n = { ...n, ...C, ...d };
+    }
+    return n;
+  };
+  function j(s) {
+    f = s(e);
+  }
+  function b(s) {
+    const { props: n } = e, y = U(e.parent) || {}, l = [], m = /* @__PURE__ */ new Set();
+    let d = {}, C = 1 / 0;
+    for (let u = 0; u < Z; u++) {
+      const t = Y[u], i = c[t], o = n[t] !== void 0 ? n[t] : y[t], S = X(o), w = t === s ? i.isActive : null;
+      w === !1 && (C = u);
+      let P = o === y[t] && o !== n[t] && S;
+      if (P && (p || V) && e.manuallyAnimateOnMount && (P = !1), i.protectedKeys = { ...d }, // If it isn't active and hasn't *just* been set as inactive
+      !i.isActive && w === null || // If we didn't and don't have any defined prop for this animation type
+      !o && !i.prevProp || // Or if the prop doesn't define an animation
+      W(o) || typeof o == "boolean")
+        continue;
+      if (t === "exit" && i.isActive && w !== !0) {
+        i.prevResolvedValues && (d = {
+          ...d,
+          ...i.prevResolvedValues
+        });
+        continue;
+      }
+      const R = $(i.prevProp, o);
+      let T = R || // If we're making this variant active, we want to always make it active
+      t === s && i.isActive && !P && S || // If we removed a higher-priority variant (i is in reverse order)
+      u > C && S, x = !1;
+      const O = Array.isArray(o) ? o : [o];
+      let v = O.reduce(z(t), {});
+      w === !1 && (v = {});
+      const { prevResolvedValues: D = {} } = i, G = {
+        ...D,
+        ...v
+      }, F = (r) => {
+        T = !0, m.has(r) && (x = !0, m.delete(r)), i.needsAnimating[r] = !0;
+        const a = e.getValue(r);
+        a && (a.liveStyle = !1);
+      };
+      for (const r in G) {
+        const a = v[r], A = D[r];
+        if (d.hasOwnProperty(r))
+          continue;
+        let g = !1;
+        k(a) && k(A) ? g = !H(a, A) || R : g = a !== A, g ? a != null ? F(r) : m.add(r) : a !== void 0 && m.has(r) ? F(r) : i.protectedKeys[r] = !0;
+      }
+      i.prevProp = o, i.prevResolvedValues = v, i.isActive && (d = { ...d, ...v }), (p || V) && e.blockInitialAnimation && (T = !1);
+      const M = P && R;
+      T && (!M || x) && l.push(...O.map((r) => {
+        const a = { type: t };
+        if (typeof r == "string" && (p || V) && !M && e.manuallyAnimateOnMount && e.parent) {
+          const { parent: A } = e, g = K(A, r);
+          if (A.enteringChildren && g) {
+            const { delayChildren: J } = g.transition || {};
+            a.delay = Q(A.enteringChildren, e, J);
+          }
+        }
+        return {
+          animation: r,
+          options: a
+        };
+      }));
+    }
+    if (m.size) {
+      const u = {};
+      if (typeof n.initial != "boolean") {
+        const t = K(e, Array.isArray(n.initial) ? n.initial[0] : n.initial);
+        t && t.transition && (u.transition = t.transition);
+      }
+      m.forEach((t) => {
+        const i = e.getBaseTarget(t), o = e.getValue(t);
+        o && (o.liveStyle = !0), u[t] = i ?? null;
+      }), l.push({ animation: u });
+    }
+    let I = !!l.length;
+    return p && (n.initial === !1 || n.initial === n.animate) && !e.manuallyAnimateOnMount && (I = !1), p = !1, V = !1, I ? f(l) : Promise.resolve();
+  }
+  function q(s, n) {
+    if (c[s].isActive === n)
+      return Promise.resolve();
+    e.variantChildren?.forEach((l) => l.animationState?.setActive(s, n)), c[s].isActive = n;
+    const y = b(s);
+    for (const l in c)
+      c[l].protectedKeys = {};
+    return y;
+  }
+  return {
+    animateChanges: b,
+    setActive: q,
+    setAnimateFunction: j,
+    getState: () => c,
+    reset: () => {
+      c = B(), V = !0;
+    }
+  };
+}
+function $(e, f) {
+  return typeof f == "string" ? f !== e : Array.isArray(f) ? !H(f, e) : !1;
+}
+function h(e = !1) {
+  return {
+    isActive: e,
+    protectedKeys: {},
+    needsAnimating: {},
+    prevResolvedValues: {}
+  };
+}
+function B() {
+  return {
+    animate: h(!0),
+    whileInView: h(),
+    whileHover: h(),
+    whileTap: h(),
+    whileDrag: h(),
+    whileFocus: h(),
+    exit: h()
+  };
+}
+export {
+  $ as checkVariantsDidChange,
+  fe as createAnimationState
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/get-variant-context.js

@@ -0,0 +1,20 @@
+import { isVariantLabel as a } from "./is-variant-label.js";
+import { variantProps as p } from "./variant-props.js";
+const f = p.length;
+function c(n) {
+  if (!n)
+    return;
+  if (!n.isControllingVariants) {
+    const r = n.parent ? c(n.parent) || {} : {};
+    return n.props.initial !== void 0 && (r.initial = n.props.initial), r;
+  }
+  const o = {};
+  for (let r = 0; r < f; r++) {
+    const i = p[r], t = n.props[i];
+    (a(t) || t === !1) && (o[i] = t);
+  }
+  return o;
+}
+export {
+  c as getVariantContext
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/is-animation-controls.js

@@ -0,0 +1,6 @@
+function n(t) {
+  return t !== null && typeof t == "object" && typeof t.start == "function";
+}
+export {
+  n as isAnimationControls
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/is-controlling-variants.js

@@ -0,0 +1,13 @@
+import { isAnimationControls as o } from "./is-animation-controls.js";
+import { isVariantLabel as r } from "./is-variant-label.js";
+import { variantProps as t } from "./variant-props.js";
+function a(i) {
+  return o(i.animate) || t.some((n) => r(i[n]));
+}
+function f(i) {
+  return !!(a(i) || i.variants);
+}
+export {
+  a as isControllingVariants,
+  f as isVariantNode
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/is-forced-motion-value.js

@@ -0,0 +1,9 @@
+import { transformProps as i } from "./keys-transform.js";
+import { scaleCorrectors as n } from "../../projection/styles/scale-correction.js";
+function c(r, { layout: o, layoutId: t }) {
+  return i.has(r) || r.startsWith("origin") || (o || t !== void 0) && (!!n[r] || r === "opacity");
+}
+export {
+  c as isForcedMotionValue,
+  n as scaleCorrectors
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/is-keyframes-target.js

@@ -0,0 +1,4 @@
+const e = (r) => Array.isArray(r);
+export {
+  e as isKeyframesTarget
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/is-variant-label.js

@@ -0,0 +1,6 @@
+function t(r) {
+  return typeof r == "string" || Array.isArray(r);
+}
+export {
+  t as isVariantLabel
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/keys-position.js

@@ -0,0 +1,13 @@
+import { transformPropOrder as t } from "./keys-transform.js";
+const r = /* @__PURE__ */ new Set([
+  "width",
+  "height",
+  "top",
+  "left",
+  "right",
+  "bottom",
+  ...t
+]);
+export {
+  r as positionalKeys
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/keys-transform.js

@@ -0,0 +1,23 @@
+const t = [
+  "transformPerspective",
+  "x",
+  "y",
+  "z",
+  "translateX",
+  "translateY",
+  "translateZ",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ",
+  "skew",
+  "skewX",
+  "skewY"
+], e = /* @__PURE__ */ new Set([...t, "pathRotation"]);
+export {
+  t as transformPropOrder,
+  e as transformProps
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/motion-values.js

@@ -0,0 +1,25 @@
+import { motionValue as r } from "../../value/index.js";
+import { isMotionValue as f } from "../../value/utils/is-motion-value.js";
+function d(a, e, s) {
+  for (const o in e) {
+    const i = e[o], t = s[o];
+    if (f(i))
+      a.addValue(o, i);
+    else if (f(t))
+      a.addValue(o, r(i, { owner: a }));
+    else if (t !== i)
+      if (a.hasValue(o)) {
+        const u = a.getValue(o);
+        u.liveStyle === !0 ? u.jump(i) : u.hasAnimated || u.set(i);
+      } else {
+        const u = a.getStaticValue(o);
+        a.addValue(o, r(u !== void 0 ? u : i, { owner: a }));
+      }
+  }
+  for (const o in s)
+    e[o] === void 0 && a.removeValue(o);
+  return e;
+}
+export {
+  d as updateMotionValuesFromProps
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/reduced-motion/index.js

@@ -0,0 +1,15 @@
+import { hasReducedMotionListener as t, prefersReducedMotion as r } from "./state.js";
+const o = typeof window < "u";
+function d() {
+  if (t.current = !0, !!o)
+    if (window.matchMedia) {
+      const e = window.matchMedia("(prefers-reduced-motion)"), n = () => r.current = e.matches;
+      e.addEventListener("change", n), n();
+    } else
+      r.current = !1;
+}
+export {
+  t as hasReducedMotionListener,
+  d as initPrefersReducedMotion,
+  r as prefersReducedMotion
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/reduced-motion/state.js

@@ -0,0 +1,5 @@
+const e = { current: null }, n = { current: !1 };
+export {
+  n as hasReducedMotionListener,
+  e as prefersReducedMotion
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/resolve-dynamic-variants.js

@@ -0,0 +1,8 @@
+import { resolveVariantFromProps as t } from "./resolve-variants.js";
+function s(r, n, o) {
+  const e = r.getProps();
+  return t(e, n, o !== void 0 ? o : e.custom, r);
+}
+export {
+  s as resolveVariant
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/resolve-variants.js

@@ -0,0 +1,20 @@
+function o(c) {
+  const t = [{}, {}];
+  return c?.values.forEach((r, e) => {
+    t[0][e] = r.get(), t[1][e] = r.getVelocity();
+  }), t;
+}
+function s(c, t, r, e) {
+  if (typeof t == "function") {
+    const [a, u] = o(e);
+    t = t(r !== void 0 ? r : c.custom, a, u);
+  }
+  if (typeof t == "string" && (t = c.variants && c.variants[t]), typeof t == "function") {
+    const [a, u] = o(e);
+    t = t(r !== void 0 ? r : c.custom, a, u);
+  }
+  return t;
+}
+export {
+  s as resolveVariantFromProps
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/setters.js

@@ -0,0 +1,21 @@
+import { motionValue as s } from "../../value/index.js";
+import { resolveVariant as f } from "./resolve-dynamic-variants.js";
+import { isKeyframesTarget as l } from "./is-keyframes-target.js";
+function u(t, o, e) {
+  t.hasValue(o) ? t.getValue(o).set(e) : t.addValue(o, s(e));
+}
+function V(t) {
+  return l(t) ? t[t.length - 1] || 0 : t;
+}
+function p(t, o) {
+  const e = f(t, o);
+  let { transitionEnd: a = {}, transition: c = {}, ...r } = e || {};
+  r = { ...r, ...a };
+  for (const n in r) {
+    const i = V(r[n]);
+    u(t, n, i);
+  }
+}
+export {
+  p as setTarget
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/shallow-compare.js

@@ -0,0 +1,14 @@
+function f(t, e) {
+  if (!Array.isArray(e))
+    return !1;
+  const n = e.length;
+  if (n !== t.length)
+    return !1;
+  for (let r = 0; r < n; r++)
+    if (e[r] !== t[r])
+      return !1;
+  return !0;
+}
+export {
+  f as shallowCompare
+};

package/dist/node_modules/motion-dom/dist/es/render/utils/variant-props.js

@@ -0,0 +1,13 @@
+const i = [
+  "animate",
+  "whileInView",
+  "whileFocus",
+  "whileHover",
+  "whileTap",
+  "whileDrag",
+  "exit"
+], e = ["initial", ...i];
+export {
+  i as variantPriorityOrder,
+  e as variantProps
+};

package/dist/node_modules/motion-dom/dist/es/resize/handle-element.js

@@ -0,0 +1,39 @@
+import { isSVGElement as c } from "../utils/is-svg-element.js";
+import { resolveElements as l } from "../utils/resolve-elements.js";
+const r = /* @__PURE__ */ new WeakMap();
+let o;
+const f = (n, i, s) => (e, t) => t && t[0] ? t[0][n + "Size"] : c(e) && "getBBox" in e ? e.getBBox()[i] : e[s], h = /* @__PURE__ */ f("inline", "width", "offsetWidth"), u = /* @__PURE__ */ f("block", "height", "offsetHeight");
+function g({ target: n, borderBoxSize: i }) {
+  r.get(n)?.forEach((s) => {
+    s(n, {
+      get width() {
+        return h(n, i);
+      },
+      get height() {
+        return u(n, i);
+      }
+    });
+  });
+}
+function d(n) {
+  n.forEach(g);
+}
+function m() {
+  typeof ResizeObserver > "u" || (o = new ResizeObserver(d));
+}
+function a(n, i) {
+  o || m();
+  const s = l(n);
+  return s.forEach((e) => {
+    let t = r.get(e);
+    t || (t = /* @__PURE__ */ new Set(), r.set(e, t)), t.add(i), o?.observe(e);
+  }), () => {
+    s.forEach((e) => {
+      const t = r.get(e);
+      t?.delete(i), t?.size || o?.unobserve(e);
+    });
+  };
+}
+export {
+  a as resizeElement
+};