@pibit.ai/cure-design-system 0.3.8 → 0.3.11

package/dist/node_modules/framer-motion/dist/es/motion/utils/use-visual-element.js

@@ -0,0 +1,66 @@
+import { useContext as s, useRef as l, useInsertionEffect as k, useEffect as S } from "react";
+import { LazyContext as L } from "../../context/LazyContext.js";
+import { MotionConfigContext as O } from "../../context/MotionConfigContext.js";
+import { MotionContext as R } from "../../context/MotionContext/index.js";
+import { PresenceContext as b } from "../../context/PresenceContext.js";
+import { SwitchLayoutGroupContext as H } from "../../context/SwitchLayoutGroupContext.js";
+import { isRefObject as z } from "../../utils/is-ref-object.js";
+import { useIsomorphicLayoutEffect as P } from "../../utils/use-isomorphic-effect.js";
+import { optimizedAppearDataAttribute as B } from "../../../../../motion-dom/dist/es/animation/optimized-appear/data-id.js";
+function W(o, u, n, e, f, a) {
+  var w, h;
+  const { visualElement: C } = s(R), c = s(L), i = s(b), d = s(O), y = d.reducedMotion, j = d.skipAnimations, r = l(null), M = l(!1);
+  e = e || c.renderer, !r.current && e && (r.current = e(o, {
+    visualState: u,
+    parent: C,
+    props: n,
+    presenceContext: i,
+    blockInitialAnimation: i ? i.initial === !1 : !1,
+    reducedMotionConfig: y,
+    skipAnimations: j,
+    isSVG: a
+  }), M.current && r.current && (r.current.manuallyAnimateOnMount = !0));
+  const t = r.current, I = s(H);
+  t && !t.projection && f && (t.type === "html" || t.type === "svg") && G(r.current, n, f, I);
+  const g = l(!1);
+  k(() => {
+    t && g.current && t.update(n, i);
+  });
+  const m = n[B], p = l(!!m && !((w = window.MotionHandoffIsComplete) != null && w.call(window, m)) && ((h = window.MotionHasOptimisedAnimation) == null ? void 0 : h.call(window, m)));
+  return P(() => {
+    M.current = !0, t && (g.current = !0, window.MotionIsMounted = !0, t.updateFeatures(), t.scheduleRenderMicrotask(), p.current && t.animationState && t.animationState.animateChanges());
+  }), S(() => {
+    t && (!p.current && t.animationState && t.animationState.animateChanges(), p.current && (queueMicrotask(() => {
+      var x;
+      (x = window.MotionHandoffMarkAsComplete) == null || x.call(window, m);
+    }), p.current = !1), t.enteringChildren = void 0);
+  }), t;
+}
+function G(o, u, n, e) {
+  const { layoutId: f, layout: a, drag: C, dragConstraints: c, layoutScroll: i, layoutRoot: d, layoutCrossfade: y } = u;
+  o.projection = new n(o.latestValues, u["data-framer-portal-id"] ? void 0 : A(o.parent)), o.projection.setOptions({
+    layoutId: f,
+    layout: a,
+    alwaysMeasureLayout: !!C || c && z(c),
+    visualElement: o,
+    /**
+     * TODO: Update options in an effect. This could be tricky as it'll be too late
+     * to update by the time layout animations run.
+     * We also need to fix this safeToRemove by linking it up to the one returned by usePresence,
+     * ensuring it gets called if there's no potential layout animations.
+     *
+     */
+    animationType: typeof a == "string" ? a : "both",
+    initialPromotionConfig: e,
+    crossfade: y,
+    layoutScroll: i,
+    layoutRoot: d
+  });
+}
+function A(o) {
+  if (o)
+    return o.options.allowProjection !== !1 ? o.projection : A(o.parent);
+}
+export {
+  W as useVisualElement
+};

package/dist/node_modules/framer-motion/dist/es/motion/utils/use-visual-state.js

@@ -0,0 +1,52 @@
+import { useContext as C } from "react";
+import { MotionContext as x } from "../../context/MotionContext/index.js";
+import { PresenceContext as S } from "../../context/PresenceContext.js";
+import { useConstant as h } from "../../utils/use-constant.js";
+import { resolveMotionValue as M } from "../../../../../motion-dom/dist/es/value/utils/resolve-motion-value.js";
+import { isControllingVariants as N, isVariantNode as P } from "../../../../../motion-dom/dist/es/render/utils/is-controlling-variants.js";
+import { isAnimationControls as T } from "../../../../../motion-dom/dist/es/render/utils/is-animation-controls.js";
+import { resolveVariantFromProps as $ } from "../../../../../motion-dom/dist/es/render/utils/resolve-variants.js";
+function b({ scrapeMotionValuesFromProps: t, createRenderState: i }, e, s, n) {
+  return {
+    latestValues: p(e, s, n, t),
+    renderState: i()
+  };
+}
+function p(t, i, e, s) {
+  const n = {}, o = s(t, {});
+  for (const l in o)
+    n[l] = M(o[l]);
+  let { initial: m, animate: u } = t;
+  const g = N(t), v = P(t);
+  i && v && !g && t.inherit !== !1 && (m === void 0 && (m = i.initial), u === void 0 && (u = i.animate));
+  let c = e ? e.initial === !1 : !1;
+  c = c || m === !1;
+  const a = c ? u : m;
+  if (a && typeof a != "boolean" && !T(a)) {
+    const l = Array.isArray(a) ? a : [a];
+    for (let d = 0; d < l.length; d++) {
+      const V = $(t, l[d]);
+      if (V) {
+        const { transitionEnd: k, transition: B, ...y } = V;
+        for (const f in y) {
+          let r = y[f];
+          if (Array.isArray(r)) {
+            const A = c ? r.length - 1 : 0;
+            r = r[A];
+          }
+          r !== null && (n[f] = r);
+        }
+        for (const f in k)
+          n[f] = k[f];
+      }
+    }
+  }
+  return n;
+}
+const z = (t) => (i, e) => {
+  const s = C(x), n = C(S), o = () => b(t, i, s, n);
+  return e ? o() : h(o);
+};
+export {
+  z as makeUseVisualState
+};

package/dist/node_modules/framer-motion/dist/es/motion/utils/valid-prop.js

@@ -0,0 +1,38 @@
+const a = /* @__PURE__ */ new Set([
+  "animate",
+  "exit",
+  "variants",
+  "initial",
+  "style",
+  "values",
+  "variants",
+  "transition",
+  "transformTemplate",
+  "custom",
+  "inherit",
+  "onBeforeLayoutMeasure",
+  "onAnimationStart",
+  "onAnimationComplete",
+  "onUpdate",
+  "onDragStart",
+  "onDrag",
+  "onDragEnd",
+  "onMeasureDragConstraints",
+  "onDirectionLock",
+  "onDragTransitionEnd",
+  "_dragX",
+  "_dragY",
+  "onHoverStart",
+  "onHoverEnd",
+  "onViewportEnter",
+  "onViewportLeave",
+  "globalTapTarget",
+  "ignoreStrict",
+  "viewport"
+]);
+function n(t) {
+  return t.startsWith("while") || t.startsWith("drag") && t !== "draggable" || t.startsWith("layout") || t.startsWith("onTap") || t.startsWith("onPan") || t.startsWith("onLayout") || a.has(t);
+}
+export {
+  n as isValidMotionProp
+};

package/dist/node_modules/framer-motion/dist/es/render/components/create-proxy.js

@@ -0,0 +1,18 @@
+import { createMotionComponent as e } from "../../motion/index.js";
+import { warnOnce as a } from "../../../../../motion-utils/dist/es/warn-once.js";
+function u(r, c) {
+  if (typeof Proxy > "u")
+    return e;
+  const o = /* @__PURE__ */ new Map(), i = (n, t) => e(n, t, r, c), f = (n, t) => (process.env.NODE_ENV !== "production" && a(!1, "motion() is deprecated. Use motion.create() instead."), i(n, t));
+  return new Proxy(f, {
+    /**
+     * Called when `motion` is referenced with a prop: `motion.div`, `motion.input` etc.
+     * The prop name is passed through as `key` and we can use that to generate a `motion`
+     * DOM component with that name.
+     */
+    get: (n, t) => t === "create" ? i : (o.has(t) || o.set(t, e(t, void 0, r, c)), o.get(t))
+  });
+}
+export {
+  u as createMotionProxy
+};

package/dist/node_modules/framer-motion/dist/es/render/components/motion/feature-bundle.js

@@ -0,0 +1,13 @@
+import { animations as o } from "../../../motion/features/animations.js";
+import { drag as r } from "../../../motion/features/drag.js";
+import { gestureAnimations as t } from "../../../motion/features/gestures.js";
+import { layout as m } from "../../../motion/features/layout.js";
+const f = {
+  ...o,
+  ...t,
+  ...r,
+  ...m
+};
+export {
+  f as featureBundle
+};

package/dist/node_modules/framer-motion/dist/es/render/components/motion/proxy.js

@@ -0,0 +1,7 @@
+import { createDomVisualElement as o } from "../../dom/create-visual-element.js";
+import { createMotionProxy as r } from "../create-proxy.js";
+import { featureBundle as t } from "./feature-bundle.js";
+const n = /* @__PURE__ */ r(t, o);
+export {
+  n as motion
+};

package/dist/node_modules/framer-motion/dist/es/render/dom/create-visual-element.js

@@ -0,0 +1,10 @@
+import { Fragment as m } from "react";
+import { isSVGComponent as t } from "./utils/is-svg-component.js";
+import { SVGVisualElement as o } from "../../../../../motion-dom/dist/es/render/svg/SVGVisualElement.js";
+import { HTMLVisualElement as i } from "../../../../../motion-dom/dist/es/render/html/HTMLVisualElement.js";
+const G = (r, e) => e.isSVG ?? t(r) ? new o(e) : new i(e, {
+  allowProjection: r !== m
+});
+export {
+  G as createDomVisualElement
+};

package/dist/node_modules/framer-motion/dist/es/render/dom/use-render.js

@@ -0,0 +1,16 @@
+import { Fragment as p, useMemo as P, createElement as a } from "react";
+import { useHTMLProps as d } from "../html/use-props.js";
+import { useSVGProps as V } from "../svg/use-props.js";
+import { filterProps as g } from "./utils/filter-props.js";
+import { isSVGComponent as h } from "./utils/is-svg-component.js";
+import { isMotionValue as M } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+function H(r, s, o, { latestValues: t }, i, m = !1, n) {
+  const l = (n ?? h(r) ? V : d)(s, t, i, r), u = g(s, typeof r == "string", m), f = r !== p ? { ...u, ...l, ref: o } : {}, { children: e } = s, c = P(() => M(e) ? e.get() : e, [e]);
+  return a(r, {
+    ...f,
+    children: c
+  });
+}
+export {
+  H as useRender
+};

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

@@ -0,0 +1,20 @@
+import { isValidMotionProp as e } from "../../../motion/utils/valid-prop.js";
+let i = (t) => !e(t);
+function f(t) {
+  typeof t == "function" && (i = (o) => o.startsWith("on") ? !e(o) : t(o));
+}
+try {
+  f(require("@emotion/is-prop-valid").default);
+} catch {
+}
+function l(t, o, a) {
+  const n = {};
+  for (const r in t)
+    r === "values" && typeof t.values == "object" || (i(r) || a === !0 && e(r) || !o && !e(r) || // If trying to use native HTML drag events, forward drag listeners
+    t.draggable && r.startsWith("onDrag")) && (n[r] = t[r]);
+  return n;
+}
+export {
+  l as filterProps,
+  f as loadExternalIsValidProp
+};

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

@@ -0,0 +1,24 @@
+import { lowercaseSVGElements as r } from "../../svg/lowercase-elements.js";
+function s(e) {
+  return (
+    /**
+     * If it's not a string, it's a custom React component. Currently we only support
+     * HTML custom React components.
+     */
+    typeof e != "string" || /**
+     * If it contains a dash, the element is a custom HTML webcomponent.
+     */
+    e.includes("-") ? !1 : (
+      /**
+       * If it's in our list of lowercase SVG tags, it's an SVG component
+       */
+      !!(r.indexOf(e) > -1 || /**
+       * If it contains a capital letter, it's an SVG component
+       */
+      /[A-Z]/u.test(e))
+    )
+  );
+}
+export {
+  s as isSVGComponent
+};

package/dist/node_modules/framer-motion/dist/es/render/html/use-html-visual-state.js

@@ -0,0 +1,10 @@
+import { makeUseVisualState as e } from "../../motion/utils/use-visual-state.js";
+import { createHtmlRenderState as t } from "./utils/create-render-state.js";
+import { scrapeMotionValuesFromProps as r } from "../../../../../motion-dom/dist/es/render/html/utils/scrape-motion-values.js";
+const m = /* @__PURE__ */ e({
+  scrapeMotionValuesFromProps: r,
+  createRenderState: t
+});
+export {
+  m as useHTMLVisualState
+};

package/dist/node_modules/framer-motion/dist/es/render/html/use-props.js

@@ -0,0 +1,27 @@
+import { useMemo as i } from "react";
+import { createHtmlRenderState as a } from "./utils/create-render-state.js";
+import { isMotionValue as r } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+import { isForcedMotionValue as l } from "../../../../../motion-dom/dist/es/render/utils/is-forced-motion-value.js";
+import { buildHTMLStyles as s } from "../../../../../motion-dom/dist/es/render/html/utils/build-styles.js";
+function u(t, o, n) {
+  for (const e in o)
+    !r(o[e]) && !l(e, n) && (t[e] = o[e]);
+}
+function c({ transformTemplate: t }, o) {
+  return i(() => {
+    const n = a();
+    return s(n, o, t), Object.assign({}, n.vars, n.style);
+  }, [o]);
+}
+function f(t, o) {
+  const n = t.style || {}, e = {};
+  return u(e, n, t), Object.assign(e, c(t, o)), e;
+}
+function M(t, o) {
+  const n = {}, e = f(t, o);
+  return t.drag && t.dragListener !== !1 && (n.draggable = !1, e.userSelect = e.WebkitUserSelect = e.WebkitTouchCallout = "none", e.touchAction = t.drag === !0 ? "none" : `pan-${t.drag === "x" ? "y" : "x"}`), t.tabIndex === void 0 && (t.onTap || t.onTapStart || t.whileTap) && (n.tabIndex = 0), n.style = e, n;
+}
+export {
+  u as copyRawValuesOnly,
+  M as useHTMLProps
+};

package/dist/node_modules/framer-motion/dist/es/render/html/utils/create-render-state.js

@@ -0,0 +1,9 @@
+const r = () => ({
+  style: {},
+  transform: {},
+  transformOrigin: {},
+  vars: {}
+});
+export {
+  r as createHtmlRenderState
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/lowercase-elements.js

@@ -0,0 +1,30 @@
+const e = [
+  "animate",
+  "circle",
+  "defs",
+  "desc",
+  "ellipse",
+  "g",
+  "image",
+  "line",
+  "filter",
+  "marker",
+  "mask",
+  "metadata",
+  "path",
+  "pattern",
+  "polygon",
+  "polyline",
+  "rect",
+  "stop",
+  "switch",
+  "symbol",
+  "svg",
+  "text",
+  "tspan",
+  "use",
+  "view"
+];
+export {
+  e as lowercaseSVGElements
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/use-props.js

@@ -0,0 +1,22 @@
+import { useMemo as m } from "react";
+import { copyRawValuesOnly as l } from "../html/use-props.js";
+import { createSvgRenderState as i } from "./utils/create-render-state.js";
+import { buildSVGAttrs as a } from "../../../../../motion-dom/dist/es/render/svg/utils/build-attrs.js";
+import { isSVGTag as n } from "../../../../../motion-dom/dist/es/render/svg/utils/is-svg-tag.js";
+function G(e, s, y, o) {
+  const r = m(() => {
+    const t = i();
+    return a(t, s, n(o), e.transformTemplate, e.style), {
+      ...t.attrs,
+      style: { ...t.style }
+    };
+  }, [s]);
+  if (e.style) {
+    const t = {};
+    l(t, e.style, e), r.style = { ...t, ...r.style };
+  }
+  return r;
+}
+export {
+  G as useSVGProps
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/use-svg-visual-state.js

@@ -0,0 +1,10 @@
+import { makeUseVisualState as e } from "../../motion/utils/use-visual-state.js";
+import { createSvgRenderState as r } from "./utils/create-render-state.js";
+import { scrapeMotionValuesFromProps as t } from "../../../../../motion-dom/dist/es/render/svg/utils/scrape-motion-values.js";
+const m = /* @__PURE__ */ e({
+  scrapeMotionValuesFromProps: t,
+  createRenderState: r
+});
+export {
+  m as useSVGVisualState
+};

package/dist/node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.js

@@ -0,0 +1,8 @@
+import { createHtmlRenderState as t } from "../../html/utils/create-render-state.js";
+const r = () => ({
+  ...t(),
+  attrs: {}
+});
+export {
+  r as createSvgRenderState
+};

package/dist/node_modules/framer-motion/dist/es/utils/distance.js

@@ -0,0 +1,9 @@
+const s = (t, n) => Math.abs(t - n);
+function e(t, n) {
+  const a = s(t.x, n.x), c = s(t.y, n.y);
+  return Math.sqrt(a ** 2 + c ** 2);
+}
+export {
+  s as distance,
+  e as distance2D
+};

package/dist/node_modules/framer-motion/dist/es/utils/get-context-window.js

@@ -0,0 +1,4 @@
+const t = ({ current: e }) => e ? e.ownerDocument.defaultView : null;
+export {
+  t as getContextWindow
+};

package/dist/node_modules/framer-motion/dist/es/utils/is-browser.js

@@ -0,0 +1,4 @@
+const e = typeof window < "u";
+export {
+  e as isBrowser
+};

package/dist/node_modules/framer-motion/dist/es/utils/is-ref-object.js

@@ -0,0 +1,6 @@
+function e(t) {
+  return t && typeof t == "object" && Object.prototype.hasOwnProperty.call(t, "current");
+}
+export {
+  e as isRefObject
+};

package/dist/node_modules/framer-motion/dist/es/utils/use-composed-ref.js

@@ -0,0 +1,28 @@
+import * as l from "react";
+function f(n, u) {
+  if (typeof n == "function")
+    return n(u);
+  n != null && (n.current = u);
+}
+function i(...n) {
+  return (u) => {
+    let o = !1;
+    const c = n.map((e) => {
+      const t = f(e, u);
+      return !o && typeof t == "function" && (o = !0), t;
+    });
+    if (o)
+      return () => {
+        for (let e = 0; e < c.length; e++) {
+          const t = c[e];
+          typeof t == "function" ? t() : f(n[e], null);
+        }
+      };
+  };
+}
+function s(...n) {
+  return l.useCallback(i(...n), n);
+}
+export {
+  s as useComposedRefs
+};

package/dist/node_modules/framer-motion/dist/es/utils/use-constant.js

@@ -0,0 +1,8 @@
+import { useRef as t } from "react";
+function u(n) {
+  const r = t(null);
+  return r.current === null && (r.current = n()), r.current;
+}
+export {
+  u as useConstant
+};

package/dist/node_modules/framer-motion/dist/es/utils/use-isomorphic-effect.js

@@ -0,0 +1,6 @@
+import { useLayoutEffect as o, useEffect as t } from "react";
+import { isBrowser as e } from "./is-browser.js";
+const s = e ? o : t;
+export {
+  s as useIsomorphicLayoutEffect
+};

package/dist/node_modules/motion-dom/dist/es/animation/AsyncMotionValueAnimation.js

@@ -0,0 +1,106 @@
+import { time as A } from "../frameloop/sync-time.js";
+import { JSAnimation as y } from "./JSAnimation.js";
+import { getFinalKeyframe as g } from "./keyframes/get-final.js";
+import { KeyframeResolver as R, flushKeyframeResolvers as T } from "./keyframes/KeyframesResolver.js";
+import { NativeAnimationExtended as _ } from "./NativeAnimationExtended.js";
+import { canAnimate as w } from "./utils/can-animate.js";
+import { makeAnimationInstant as K } from "./utils/make-animation-instant.js";
+import { WithPromise as D } from "./utils/WithPromise.js";
+import { supportsBrowserAnimation as E } from "./waapi/supports/waapi.js";
+import { MotionGlobalConfig as k } from "../../../../motion-utils/dist/es/global-config.js";
+import { noop as x } from "../../../../motion-utils/dist/es/noop.js";
+const M = 40;
+class I extends D {
+  constructor({ autoplay: i = !0, delay: a = 0, type: n = "keyframes", repeat: f = 0, repeatDelay: d = 0, repeatType: c = "loop", keyframes: p, name: r, motionValue: m, element: t, ...v }) {
+    var h;
+    super(), this.stop = () => {
+      var e, s;
+      this._animation && (this._animation.stop(), (e = this.stopTimeline) == null || e.call(this)), (s = this.keyframeResolver) == null || s.cancel();
+    }, this.createdAt = A.now();
+    const o = {
+      autoplay: i,
+      delay: a,
+      type: n,
+      repeat: f,
+      repeatDelay: d,
+      repeatType: c,
+      name: r,
+      motionValue: m,
+      element: t,
+      ...v
+    }, u = (t == null ? void 0 : t.KeyframeResolver) || R;
+    this.keyframeResolver = new u(p, (e, s, l) => this.onKeyframesResolved(e, s, o, !l), r, m, t), (h = this.keyframeResolver) == null || h.scheduleResolve();
+  }
+  onKeyframesResolved(i, a, n, f) {
+    var s, l;
+    this.keyframeResolver = void 0;
+    const { name: d, type: c, velocity: p, delay: r, isHandoff: m, onUpdate: t } = n;
+    this.resolvedAt = A.now(), w(i, d, c, p) || ((k.instantAnimations || !r) && (t == null || t(g(i, n, a))), i[0] = i[i.length - 1], K(n), n.repeat = 0);
+    const o = {
+      startTime: f ? this.resolvedAt ? this.resolvedAt - this.createdAt > M ? this.resolvedAt : this.createdAt : this.createdAt : void 0,
+      finalKeyframe: a,
+      ...n,
+      keyframes: i
+    }, u = !m && E(o), h = (l = (s = o.motionValue) == null ? void 0 : s.owner) == null ? void 0 : l.current, e = u ? new _({
+      ...o,
+      element: h
+    }) : new y(o);
+    e.finished.then(() => {
+      this.notifyFinished();
+    }).catch(x), this.pendingTimeline && (this.stopTimeline = e.attachTimeline(this.pendingTimeline), this.pendingTimeline = void 0), this._animation = e;
+  }
+  get finished() {
+    return this._animation ? this.animation.finished : this._finished;
+  }
+  then(i, a) {
+    return this.finished.finally(i).then(() => {
+    });
+  }
+  get animation() {
+    var i;
+    return this._animation || ((i = this.keyframeResolver) == null || i.resume(), T()), this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(i) {
+    this.animation.time = i;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(i) {
+    this.animation.speed = i;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(i) {
+    return this._animation ? this.stopTimeline = this.animation.attachTimeline(i) : this.pendingTimeline = i, () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    var i;
+    this._animation && this.animation.cancel(), (i = this.keyframeResolver) == null || i.cancel();
+  }
+}
+export {
+  I as AsyncMotionValueAnimation
+};