@quan-erp/shared-ui 1.0.0

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/components/AnimatePresence/PopChild.js

@@ -0,0 +1,85 @@
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { useId, useRef, useContext, useInsertionEffect } from "react";
+import { MotionConfigContext } from "../../context/MotionConfigContext.js";
+import { useComposedRefs } from "../../utils/use-composed-ref.js";
+import { isHTMLElement } from "../../../../../motion-dom/dist/es/utils/is-html-element.js";
+class PopChildMeasure extends React.Component {
+  getSnapshotBeforeUpdate(prevProps) {
+    const element = this.props.childRef.current;
+    if (isHTMLElement(element) && prevProps.isPresent && !this.props.isPresent && this.props.pop !== false) {
+      const parent = element.offsetParent;
+      const parentWidth = isHTMLElement(parent) ? parent.offsetWidth || 0 : 0;
+      const parentHeight = isHTMLElement(parent) ? parent.offsetHeight || 0 : 0;
+      const computedStyle = getComputedStyle(element);
+      const size = this.props.sizeRef.current;
+      size.height = parseFloat(computedStyle.height);
+      size.width = parseFloat(computedStyle.width);
+      size.top = element.offsetTop;
+      size.left = element.offsetLeft;
+      size.right = parentWidth - size.width - size.left;
+      size.bottom = parentHeight - size.height - size.top;
+      size.direction = computedStyle.direction;
+    }
+    return null;
+  }
+  /**
+   * Required with getSnapshotBeforeUpdate to stop React complaining.
+   */
+  componentDidUpdate() {
+  }
+  render() {
+    return this.props.children;
+  }
+}
+function PopChild({ children, isPresent, anchorX, anchorY, root, pop }) {
+  const id = useId();
+  const ref = useRef(null);
+  const size = useRef({
+    width: 0,
+    height: 0,
+    top: 0,
+    left: 0,
+    right: 0,
+    bottom: 0,
+    direction: "ltr"
+  });
+  const { nonce } = useContext(MotionConfigContext);
+  const childRef = children.props?.ref ?? children?.ref;
+  const composedRef = useComposedRefs(ref, childRef);
+  useInsertionEffect(() => {
+    const { width, height, top, left, right, bottom, direction } = size.current;
+    if (isPresent || pop === false || !ref.current || !width || !height)
+      return;
+    const isRTL = direction === "rtl";
+    const x = anchorX === "left" ? isRTL ? `right: ${right}` : `left: ${left}` : isRTL ? `left: ${left}` : `right: ${right}`;
+    const y = anchorY === "bottom" ? `bottom: ${bottom}` : `top: ${top}`;
+    ref.current.dataset.motionPopId = id;
+    const style = document.createElement("style");
+    if (nonce)
+      style.nonce = nonce;
+    const parent = root ?? document.head;
+    parent.appendChild(style);
+    if (style.sheet) {
+      style.sheet.insertRule(`
+          [data-motion-pop-id="${id}"] {
+            position: absolute !important;
+            width: ${width}px !important;
+            height: ${height}px !important;
+            ${x}px !important;
+            ${y}px !important;
+          }
+        `);
+    }
+    return () => {
+      ref.current?.removeAttribute("data-motion-pop-id");
+      if (parent.contains(style)) {
+        parent.removeChild(style);
+      }
+    };
+  }, [isPresent]);
+  return jsx(PopChildMeasure, { isPresent, childRef: ref, sizeRef: size, pop, children: pop === false ? children : React.cloneElement(children, { ref: composedRef }) });
+}
+export {
+  PopChild
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/components/AnimatePresence/PresenceChild.js

@@ -0,0 +1,49 @@
+import { jsx } from "react/jsx-runtime";
+import * as React from "react";
+import { useId, useMemo } from "react";
+import { PresenceContext } from "../../context/PresenceContext.js";
+import { useConstant } from "../../utils/use-constant.js";
+import { PopChild } from "./PopChild.js";
+const PresenceChild = ({ children, initial, isPresent, onExitComplete, custom, presenceAffectsLayout, mode, anchorX, anchorY, root }) => {
+  const presenceChildren = useConstant(newChildrenMap);
+  const id = useId();
+  let isReusedContext = true;
+  let context = useMemo(() => {
+    isReusedContext = false;
+    return {
+      id,
+      initial,
+      isPresent,
+      custom,
+      onExitComplete: (childId) => {
+        presenceChildren.set(childId, true);
+        for (const isComplete of presenceChildren.values()) {
+          if (!isComplete)
+            return;
+        }
+        onExitComplete && onExitComplete();
+      },
+      register: (childId) => {
+        presenceChildren.set(childId, false);
+        return () => presenceChildren.delete(childId);
+      }
+    };
+  }, [isPresent, presenceChildren, onExitComplete]);
+  if (presenceAffectsLayout && isReusedContext) {
+    context = { ...context };
+  }
+  useMemo(() => {
+    presenceChildren.forEach((_, key) => presenceChildren.set(key, false));
+  }, [isPresent]);
+  React.useEffect(() => {
+    !isPresent && !presenceChildren.size && onExitComplete && onExitComplete();
+  }, [isPresent]);
+  children = jsx(PopChild, { pop: mode === "popLayout", isPresent, anchorX, anchorY, root, children });
+  return jsx(PresenceContext.Provider, { value: context, children });
+};
+function newChildrenMap() {
+  return /* @__PURE__ */ new Map();
+}
+export {
+  PresenceChild
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/components/AnimatePresence/index.js

@@ -0,0 +1,86 @@
+import { jsx, Fragment } from "react/jsx-runtime";
+import { useMemo, useRef, useState, useContext } from "react";
+import { LayoutGroupContext } from "../../context/LayoutGroupContext.js";
+import { useConstant } from "../../utils/use-constant.js";
+import { useIsomorphicLayoutEffect } from "../../utils/use-isomorphic-effect.js";
+import { PresenceChild } from "./PresenceChild.js";
+import { usePresence } from "./use-presence.js";
+import { onlyElements, getChildKey } from "./utils.js";
+const AnimatePresence = ({ children, custom, initial = true, onExitComplete, presenceAffectsLayout = true, mode = "sync", propagate = false, anchorX = "left", anchorY = "top", root }) => {
+  const [isParentPresent, safeToRemove] = usePresence(propagate);
+  const presentChildren = useMemo(() => onlyElements(children), [children]);
+  const presentKeys = propagate && !isParentPresent ? [] : presentChildren.map(getChildKey);
+  const isInitialRender = useRef(true);
+  const pendingPresentChildren = useRef(presentChildren);
+  const exitComplete = useConstant(() => /* @__PURE__ */ new Map());
+  const exitingComponents = useRef(/* @__PURE__ */ new Set());
+  const [diffedChildren, setDiffedChildren] = useState(presentChildren);
+  const [renderedChildren, setRenderedChildren] = useState(presentChildren);
+  useIsomorphicLayoutEffect(() => {
+    isInitialRender.current = false;
+    pendingPresentChildren.current = presentChildren;
+    for (let i = 0; i < renderedChildren.length; i++) {
+      const key = getChildKey(renderedChildren[i]);
+      if (!presentKeys.includes(key)) {
+        if (exitComplete.get(key) !== true) {
+          exitComplete.set(key, false);
+        }
+      } else {
+        exitComplete.delete(key);
+        exitingComponents.current.delete(key);
+      }
+    }
+  }, [renderedChildren, presentKeys.length, presentKeys.join("-")]);
+  const exitingChildren = [];
+  if (presentChildren !== diffedChildren) {
+    let nextChildren = [...presentChildren];
+    for (let i = 0; i < renderedChildren.length; i++) {
+      const child = renderedChildren[i];
+      const key = getChildKey(child);
+      if (!presentKeys.includes(key)) {
+        nextChildren.splice(i, 0, child);
+        exitingChildren.push(child);
+      }
+    }
+    if (mode === "wait" && exitingChildren.length) {
+      nextChildren = exitingChildren;
+    }
+    setRenderedChildren(onlyElements(nextChildren));
+    setDiffedChildren(presentChildren);
+    return null;
+  }
+  if (process.env.NODE_ENV !== "production" && mode === "wait" && renderedChildren.length > 1) {
+    console.warn(`You're attempting to animate multiple children within AnimatePresence, but its mode is set to "wait". This will lead to odd visual behaviour.`);
+  }
+  const { forceRender } = useContext(LayoutGroupContext);
+  return jsx(Fragment, { children: renderedChildren.map((child) => {
+    const key = getChildKey(child);
+    const isPresent = propagate && !isParentPresent ? false : presentChildren === renderedChildren || presentKeys.includes(key);
+    const onExit = () => {
+      if (exitingComponents.current.has(key)) {
+        return;
+      }
+      if (exitComplete.has(key)) {
+        exitingComponents.current.add(key);
+        exitComplete.set(key, true);
+      } else {
+        return;
+      }
+      let isEveryExitComplete = true;
+      exitComplete.forEach((isExitComplete) => {
+        if (!isExitComplete)
+          isEveryExitComplete = false;
+      });
+      if (isEveryExitComplete) {
+        forceRender?.();
+        setRenderedChildren(pendingPresentChildren.current);
+        propagate && safeToRemove?.();
+        onExitComplete && onExitComplete();
+      }
+    };
+    return jsx(PresenceChild, { isPresent, initial: !isInitialRender.current || initial ? void 0 : false, custom, presenceAffectsLayout, mode, root, onExitComplete: isPresent ? void 0 : onExit, anchorX, anchorY, children: child }, key);
+  }) });
+};
+export {
+  AnimatePresence
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/components/AnimatePresence/use-presence.js

@@ -0,0 +1,19 @@
+import { useContext, useId, useEffect, useCallback } from "react";
+import { PresenceContext } from "../../context/PresenceContext.js";
+function usePresence(subscribe = true) {
+  const context = useContext(PresenceContext);
+  if (context === null)
+    return [true, null];
+  const { isPresent, onExitComplete, register } = context;
+  const id = useId();
+  useEffect(() => {
+    if (subscribe) {
+      return register(id);
+    }
+  }, [subscribe]);
+  const safeToRemove = useCallback(() => subscribe && onExitComplete && onExitComplete(id), [id, onExitComplete, subscribe]);
+  return !isPresent && onExitComplete ? [false, safeToRemove] : [true];
+}
+export {
+  usePresence
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/components/AnimatePresence/utils.js

@@ -0,0 +1,14 @@
+import { Children, isValidElement } from "react";
+const getChildKey = (child) => child.key || "";
+function onlyElements(children) {
+  const filtered = [];
+  Children.forEach(children, (child) => {
+    if (isValidElement(child))
+      filtered.push(child);
+  });
+  return filtered;
+}
+export {
+  getChildKey,
+  onlyElements
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/context/LayoutGroupContext.js

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const LayoutGroupContext = createContext({});
+export {
+  LayoutGroupContext
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/context/LazyContext.js

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const LazyContext = createContext({ strict: false });
+export {
+  LazyContext
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/context/MotionConfigContext.js

@@ -0,0 +1,9 @@
+import { createContext } from "react";
+const MotionConfigContext = createContext({
+  transformPagePoint: (p) => p,
+  isStatic: false,
+  reducedMotion: "never"
+});
+export {
+  MotionConfigContext
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/context/MotionContext/create.js

@@ -0,0 +1,13 @@
+import { useContext, useMemo } from "react";
+import { MotionContext } from "./index.js";
+import { getCurrentTreeVariants } from "./utils.js";
+function useCreateMotionContext(props) {
+  const { initial, animate } = getCurrentTreeVariants(props, useContext(MotionContext));
+  return useMemo(() => ({ initial, animate }), [variantLabelsAsDependency(initial), variantLabelsAsDependency(animate)]);
+}
+function variantLabelsAsDependency(prop) {
+  return Array.isArray(prop) ? prop.join(" ") : prop;
+}
+export {
+  useCreateMotionContext
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/context/MotionContext/index.js

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const MotionContext = /* @__PURE__ */ createContext({});
+export {
+  MotionContext
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/context/MotionContext/utils.js

@@ -0,0 +1,15 @@
+import { isControllingVariants } from "../../../../../motion-dom/dist/es/render/utils/is-controlling-variants.js";
+import { isVariantLabel } from "../../../../../motion-dom/dist/es/render/utils/is-variant-label.js";
+function getCurrentTreeVariants(props, context) {
+  if (isControllingVariants(props)) {
+    const { initial, animate } = props;
+    return {
+      initial: initial === false || isVariantLabel(initial) ? initial : void 0,
+      animate: isVariantLabel(animate) ? animate : void 0
+    };
+  }
+  return props.inherit !== false ? context : {};
+}
+export {
+  getCurrentTreeVariants
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/context/PresenceContext.js

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const PresenceContext = /* @__PURE__ */ createContext(null);
+export {
+  PresenceContext
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/context/SwitchLayoutGroupContext.js

@@ -0,0 +1,5 @@
+import { createContext } from "react";
+const SwitchLayoutGroupContext = createContext({});
+export {
+  SwitchLayoutGroupContext
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/events/add-pointer-event.js

@@ -0,0 +1,8 @@
+import { addPointerInfo } from "./event-info.js";
+import { addDomEvent } from "../../../../motion-dom/dist/es/events/add-dom-event.js";
+function addPointerEvent(target, eventName, handler, options) {
+  return addDomEvent(target, eventName, addPointerInfo(handler), options);
+}
+export {
+  addPointerEvent
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/events/event-info.js

@@ -0,0 +1,14 @@
+import { isPrimaryPointer } from "../../../../motion-dom/dist/es/gestures/utils/is-primary-pointer.js";
+function extractEventInfo(event) {
+  return {
+    point: {
+      x: event.pageX,
+      y: event.pageY
+    }
+  };
+}
+const addPointerInfo = (handler) => (event) => isPrimaryPointer(event) && handler(event, extractEventInfo(event));
+export {
+  addPointerInfo,
+  extractEventInfo
+};