@quan-erp/shared-ui 1.0.0

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/motion/features/viewport/index.js

@@ -0,0 +1,64 @@
+import { observeIntersection } from "./observers.js";
+import { Feature } from "../../../../../../motion-dom/dist/es/render/Feature.js";
+const thresholdNames = {
+  some: 0,
+  all: 1
+};
+class InViewFeature extends Feature {
+  constructor() {
+    super(...arguments);
+    this.hasEnteredView = false;
+    this.isInView = false;
+  }
+  startObserver() {
+    this.stopObserver?.();
+    const { viewport = {} } = this.node.getProps();
+    const { root, margin: rootMargin, amount = "some", once } = viewport;
+    const options = {
+      root: root ? root.current : void 0,
+      rootMargin,
+      threshold: typeof amount === "number" ? amount : thresholdNames[amount]
+    };
+    const onIntersectionUpdate = (entry) => {
+      const { isIntersecting } = entry;
+      if (this.isInView === isIntersecting)
+        return;
+      this.isInView = isIntersecting;
+      if (once && !isIntersecting && this.hasEnteredView) {
+        return;
+      } else if (isIntersecting) {
+        this.hasEnteredView = true;
+      }
+      if (this.node.animationState) {
+        this.node.animationState.setActive("whileInView", isIntersecting);
+      }
+      const { onViewportEnter, onViewportLeave } = this.node.getProps();
+      const callback = isIntersecting ? onViewportEnter : onViewportLeave;
+      callback && callback(entry);
+    };
+    this.stopObserver = observeIntersection(this.node.current, options, onIntersectionUpdate);
+  }
+  mount() {
+    this.startObserver();
+  }
+  update() {
+    if (typeof IntersectionObserver === "undefined")
+      return;
+    const { props, prevProps } = this.node;
+    const hasOptionsChanged = ["amount", "margin", "root"].some(hasViewportOptionChanged(props, prevProps));
+    if (hasOptionsChanged) {
+      this.startObserver();
+    }
+  }
+  unmount() {
+    this.stopObserver?.();
+    this.hasEnteredView = false;
+    this.isInView = false;
+  }
+}
+function hasViewportOptionChanged({ viewport = {} }, { viewport: prevViewport = {} } = {}) {
+  return (name) => viewport[name] !== prevViewport[name];
+}
+export {
+  InViewFeature
+};

package/dist/es/shared-ui/node_modules/framer-motion/dist/es/motion/features/viewport/observers.js

@@ -0,0 +1,33 @@
+const observerCallbacks = /* @__PURE__ */ new WeakMap();
+const observers = /* @__PURE__ */ new WeakMap();
+const fireObserverCallback = (entry) => {
+  const callback = observerCallbacks.get(entry.target);
+  callback && callback(entry);
+};
+const fireAllObserverCallbacks = (entries) => {
+  entries.forEach(fireObserverCallback);
+};
+function initIntersectionObserver({ root, ...options }) {
+  const lookupRoot = root || document;
+  if (!observers.has(lookupRoot)) {
+    observers.set(lookupRoot, {});
+  }
+  const rootObservers = observers.get(lookupRoot);
+  const key = JSON.stringify(options);
+  if (!rootObservers[key]) {
+    rootObservers[key] = new IntersectionObserver(fireAllObserverCallbacks, { root, ...options });
+  }
+  return rootObservers[key];
+}
+function observeIntersection(element, options, callback) {
+  const rootInteresectionObserver = initIntersectionObserver(options);
+  observerCallbacks.set(element, callback);
+  rootInteresectionObserver.observe(element);
+  return () => {
+    observerCallbacks.delete(element);
+    rootInteresectionObserver.unobserve(element);
+  };
+}
+export {
+  observeIntersection
+};

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

@@ -0,0 +1,69 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { forwardRef, useContext } from "react";
+import { LayoutGroupContext } from "../context/LayoutGroupContext.js";
+import { LazyContext } from "../context/LazyContext.js";
+import { MotionConfigContext } from "../context/MotionConfigContext.js";
+import { MotionContext } from "../context/MotionContext/index.js";
+import { useCreateMotionContext } from "../context/MotionContext/create.js";
+import { useRender } from "../render/dom/use-render.js";
+import { isSVGComponent } from "../render/dom/utils/is-svg-component.js";
+import { useHTMLVisualState } from "../render/html/use-html-visual-state.js";
+import { useSVGVisualState } from "../render/svg/use-svg-visual-state.js";
+import { getInitializedFeatureDefinitions } from "./features/definitions.js";
+import { loadFeatures } from "./features/load-features.js";
+import { motionComponentSymbol } from "./utils/symbol.js";
+import { useMotionRef } from "./utils/use-motion-ref.js";
+import { useVisualElement } from "./utils/use-visual-element.js";
+import { warning, invariant } from "../../../../motion-utils/dist/es/errors.js";
+function createMotionComponent(Component, { forwardMotionProps = false, type } = {}, preloadedFeatures, createVisualElement) {
+  preloadedFeatures && loadFeatures(preloadedFeatures);
+  const isSVG = type ? type === "svg" : isSVGComponent(Component);
+  const useVisualState = isSVG ? useSVGVisualState : useHTMLVisualState;
+  function MotionDOMComponent(props, externalRef) {
+    let MeasureLayout;
+    const configAndProps = {
+      ...useContext(MotionConfigContext),
+      ...props,
+      layoutId: useLayoutId(props)
+    };
+    const { isStatic } = configAndProps;
+    const context = useCreateMotionContext(props);
+    const visualState = useVisualState(props, isStatic);
+    if (!isStatic && typeof window !== "undefined") {
+      useStrictMode(configAndProps, preloadedFeatures);
+      const layoutProjection = getProjectionFunctionality(configAndProps);
+      MeasureLayout = layoutProjection.MeasureLayout;
+      context.visualElement = useVisualElement(Component, visualState, configAndProps, createVisualElement, layoutProjection.ProjectionNode, isSVG);
+    }
+    return jsxs(MotionContext.Provider, { value: context, children: [MeasureLayout && context.visualElement ? jsx(MeasureLayout, { visualElement: context.visualElement, ...configAndProps }) : null, useRender(Component, props, useMotionRef(visualState, context.visualElement, externalRef), visualState, isStatic, forwardMotionProps, isSVG)] });
+  }
+  MotionDOMComponent.displayName = `motion.${typeof Component === "string" ? Component : `create(${Component.displayName ?? Component.name ?? ""})`}`;
+  const ForwardRefMotionComponent = forwardRef(MotionDOMComponent);
+  ForwardRefMotionComponent[motionComponentSymbol] = Component;
+  return ForwardRefMotionComponent;
+}
+function useLayoutId({ layoutId }) {
+  const layoutGroupId = useContext(LayoutGroupContext).id;
+  return layoutGroupId && layoutId !== void 0 ? layoutGroupId + "-" + layoutId : layoutId;
+}
+function useStrictMode(configAndProps, preloadedFeatures) {
+  const isStrict = useContext(LazyContext).strict;
+  if (process.env.NODE_ENV !== "production" && preloadedFeatures && isStrict) {
+    const strictMessage = "You have rendered a `motion` component within a `LazyMotion` component. This will break tree shaking. Import and render a `m` component instead.";
+    configAndProps.ignoreStrict ? warning(false, strictMessage, "lazy-strict-mode") : invariant(false, strictMessage, "lazy-strict-mode");
+  }
+}
+function getProjectionFunctionality(props) {
+  const featureDefinitions = getInitializedFeatureDefinitions();
+  const { drag, layout } = featureDefinitions;
+  if (!drag && !layout)
+    return {};
+  const combined = { ...drag, ...layout };
+  return {
+    MeasureLayout: drag?.isEnabled(props) || layout?.isEnabled(props) ? combined.MeasureLayout : void 0,
+    ProjectionNode: combined.ProjectionNode
+  };
+}
+export {
+  createMotionComponent
+};

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

@@ -0,0 +1,4 @@
+const motionComponentSymbol = /* @__PURE__ */ Symbol.for("motionComponentSymbol");
+export {
+  motionComponentSymbol
+};

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

@@ -0,0 +1,35 @@
+import { useRef, useInsertionEffect, useCallback } from "react";
+function useMotionRef(visualState, visualElement, externalRef) {
+  const externalRefContainer = useRef(externalRef);
+  useInsertionEffect(() => {
+    externalRefContainer.current = externalRef;
+  });
+  const refCleanup = useRef(null);
+  return useCallback((instance) => {
+    if (instance) {
+      visualState.onMount?.(instance);
+    }
+    if (visualElement) {
+      instance ? visualElement.mount(instance) : visualElement.unmount();
+    }
+    const ref = externalRefContainer.current;
+    if (typeof ref === "function") {
+      if (instance) {
+        const cleanup = ref(instance);
+        if (typeof cleanup === "function") {
+          refCleanup.current = cleanup;
+        }
+      } else if (refCleanup.current) {
+        refCleanup.current();
+        refCleanup.current = null;
+      } else {
+        ref(instance);
+      }
+    } else if (ref) {
+      ref.current = instance;
+    }
+  }, [visualElement]);
+}
+export {
+  useMotionRef
+};

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

@@ -0,0 +1,106 @@
+import { useContext, useRef, useInsertionEffect, useEffect } from "react";
+import { LazyContext } from "../../context/LazyContext.js";
+import { MotionConfigContext } from "../../context/MotionConfigContext.js";
+import { MotionContext } from "../../context/MotionContext/index.js";
+import { PresenceContext } from "../../context/PresenceContext.js";
+import { SwitchLayoutGroupContext } from "../../context/SwitchLayoutGroupContext.js";
+import { isRefObject } from "../../utils/is-ref-object.js";
+import { useIsomorphicLayoutEffect } from "../../utils/use-isomorphic-effect.js";
+import { optimizedAppearDataAttribute } from "../../../../../motion-dom/dist/es/animation/optimized-appear/data-id.js";
+function useVisualElement(Component, visualState, props, createVisualElement, ProjectionNodeConstructor, isSVG) {
+  const { visualElement: parent } = useContext(MotionContext);
+  const lazyContext = useContext(LazyContext);
+  const presenceContext = useContext(PresenceContext);
+  const motionConfig = useContext(MotionConfigContext);
+  const reducedMotionConfig = motionConfig.reducedMotion;
+  const skipAnimations = motionConfig.skipAnimations;
+  const visualElementRef = useRef(null);
+  const hasMountedOnce = useRef(false);
+  createVisualElement = createVisualElement || lazyContext.renderer;
+  if (!visualElementRef.current && createVisualElement) {
+    visualElementRef.current = createVisualElement(Component, {
+      visualState,
+      parent,
+      props,
+      presenceContext,
+      blockInitialAnimation: presenceContext ? presenceContext.initial === false : false,
+      reducedMotionConfig,
+      skipAnimations,
+      isSVG
+    });
+    if (hasMountedOnce.current && visualElementRef.current) {
+      visualElementRef.current.manuallyAnimateOnMount = true;
+    }
+  }
+  const visualElement = visualElementRef.current;
+  const initialLayoutGroupConfig = useContext(SwitchLayoutGroupContext);
+  if (visualElement && !visualElement.projection && ProjectionNodeConstructor && (visualElement.type === "html" || visualElement.type === "svg")) {
+    createProjectionNode(visualElementRef.current, props, ProjectionNodeConstructor, initialLayoutGroupConfig);
+  }
+  const isMounted = useRef(false);
+  useInsertionEffect(() => {
+    if (visualElement && isMounted.current) {
+      visualElement.update(props, presenceContext);
+    }
+  });
+  const optimisedAppearId = props[optimizedAppearDataAttribute];
+  const wantsHandoff = useRef(Boolean(optimisedAppearId) && typeof window !== "undefined" && !window.MotionHandoffIsComplete?.(optimisedAppearId) && window.MotionHasOptimisedAnimation?.(optimisedAppearId));
+  useIsomorphicLayoutEffect(() => {
+    hasMountedOnce.current = true;
+    if (!visualElement)
+      return;
+    isMounted.current = true;
+    window.MotionIsMounted = true;
+    visualElement.updateFeatures();
+    visualElement.scheduleRenderMicrotask();
+    if (wantsHandoff.current && visualElement.animationState) {
+      visualElement.animationState.animateChanges();
+    }
+  });
+  useEffect(() => {
+    if (!visualElement)
+      return;
+    if (!wantsHandoff.current && visualElement.animationState) {
+      visualElement.animationState.animateChanges();
+    }
+    if (wantsHandoff.current) {
+      queueMicrotask(() => {
+        window.MotionHandoffMarkAsComplete?.(optimisedAppearId);
+      });
+      wantsHandoff.current = false;
+    }
+    visualElement.enteringChildren = void 0;
+  });
+  return visualElement;
+}
+function createProjectionNode(visualElement, props, ProjectionNodeConstructor, initialPromotionConfig) {
+  const { layoutId, layout, drag, dragConstraints, layoutScroll, layoutRoot, layoutAnchor, layoutCrossfade } = props;
+  visualElement.projection = new ProjectionNodeConstructor(visualElement.latestValues, props["data-framer-portal-id"] ? void 0 : getClosestProjectingNode(visualElement.parent));
+  visualElement.projection.setOptions({
+    layoutId,
+    layout,
+    alwaysMeasureLayout: Boolean(drag) || dragConstraints && isRefObject(dragConstraints),
+    visualElement,
+    /**
+     * 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 layout === "string" ? layout : "both",
+    initialPromotionConfig,
+    crossfade: layoutCrossfade,
+    layoutScroll,
+    layoutRoot,
+    layoutAnchor
+  });
+}
+function getClosestProjectingNode(visualElement) {
+  if (!visualElement)
+    return void 0;
+  return visualElement.options.allowProjection !== false ? visualElement.projection : getClosestProjectingNode(visualElement.parent);
+}
+export {
+  useVisualElement
+};

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

@@ -0,0 +1,66 @@
+import { useContext } from "react";
+import { MotionContext } from "../../context/MotionContext/index.js";
+import { PresenceContext } from "../../context/PresenceContext.js";
+import { useConstant } from "../../utils/use-constant.js";
+import { resolveMotionValue } from "../../../../../motion-dom/dist/es/value/utils/resolve-motion-value.js";
+import { isControllingVariants, isVariantNode } from "../../../../../motion-dom/dist/es/render/utils/is-controlling-variants.js";
+import { isAnimationControls } from "../../../../../motion-dom/dist/es/render/utils/is-animation-controls.js";
+import { resolveVariantFromProps } from "../../../../../motion-dom/dist/es/render/utils/resolve-variants.js";
+function makeState({ scrapeMotionValuesFromProps, createRenderState }, props, context, presenceContext) {
+  const state = {
+    latestValues: makeLatestValues(props, context, presenceContext, scrapeMotionValuesFromProps),
+    renderState: createRenderState()
+  };
+  return state;
+}
+function makeLatestValues(props, context, presenceContext, scrapeMotionValues) {
+  const values = {};
+  const motionValues = scrapeMotionValues(props, {});
+  for (const key in motionValues) {
+    values[key] = resolveMotionValue(motionValues[key]);
+  }
+  let { initial, animate } = props;
+  const isControllingVariants$1 = isControllingVariants(props);
+  const isVariantNode$1 = isVariantNode(props);
+  if (context && isVariantNode$1 && !isControllingVariants$1 && props.inherit !== false) {
+    if (initial === void 0)
+      initial = context.initial;
+    if (animate === void 0)
+      animate = context.animate;
+  }
+  let isInitialAnimationBlocked = presenceContext ? presenceContext.initial === false : false;
+  isInitialAnimationBlocked = isInitialAnimationBlocked || initial === false;
+  const variantToSet = isInitialAnimationBlocked ? animate : initial;
+  if (variantToSet && typeof variantToSet !== "boolean" && !isAnimationControls(variantToSet)) {
+    const list = Array.isArray(variantToSet) ? variantToSet : [variantToSet];
+    for (let i = 0; i < list.length; i++) {
+      const resolved = resolveVariantFromProps(props, list[i]);
+      if (resolved) {
+        const { transitionEnd, transition, ...target } = resolved;
+        for (const key in target) {
+          let valueTarget = target[key];
+          if (Array.isArray(valueTarget)) {
+            const index = isInitialAnimationBlocked ? valueTarget.length - 1 : 0;
+            valueTarget = valueTarget[index];
+          }
+          if (valueTarget !== null) {
+            values[key] = valueTarget;
+          }
+        }
+        for (const key in transitionEnd) {
+          values[key] = transitionEnd[key];
+        }
+      }
+    }
+  }
+  return values;
+}
+const makeUseVisualState = (config) => (props, isStatic) => {
+  const context = useContext(MotionContext);
+  const presenceContext = useContext(PresenceContext);
+  const make = () => makeState(config, props, context, presenceContext);
+  return isStatic ? make() : useConstant(make);
+};
+export {
+  makeUseVisualState
+};

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

@@ -0,0 +1,39 @@
+const validMotionProps = /* @__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",
+  "propagate",
+  "ignoreStrict",
+  "viewport"
+]);
+function isValidMotionProp(key) {
+  return key.startsWith("while") || key.startsWith("drag") && key !== "draggable" || key.startsWith("layout") || key.startsWith("onTap") || key.startsWith("onPan") || key.startsWith("onLayout") || validMotionProps.has(key);
+}
+export {
+  isValidMotionProp
+};

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

@@ -0,0 +1,35 @@
+import { createMotionComponent } from "../../motion/index.js";
+import { warnOnce } from "../../../../../motion-utils/dist/es/warn-once.js";
+function createMotionProxy(preloadedFeatures, createVisualElement) {
+  if (typeof Proxy === "undefined") {
+    return createMotionComponent;
+  }
+  const componentCache = /* @__PURE__ */ new Map();
+  const factory = (Component, options) => {
+    return createMotionComponent(Component, options, preloadedFeatures, createVisualElement);
+  };
+  const deprecatedFactoryFunction = (Component, options) => {
+    if (process.env.NODE_ENV !== "production") {
+      warnOnce(false, "motion() is deprecated. Use motion.create() instead.");
+    }
+    return factory(Component, options);
+  };
+  return new Proxy(deprecatedFactoryFunction, {
+    /**
+     * 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: (_target, key) => {
+      if (key === "create")
+        return factory;
+      if (!componentCache.has(key)) {
+        componentCache.set(key, createMotionComponent(key, void 0, preloadedFeatures, createVisualElement));
+      }
+      return componentCache.get(key);
+    }
+  });
+}
+export {
+  createMotionProxy
+};

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

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

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

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

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

@@ -0,0 +1,13 @@
+import { Fragment } from "react";
+import { isSVGComponent } from "./utils/is-svg-component.js";
+import { SVGVisualElement } from "../../../../../motion-dom/dist/es/render/svg/SVGVisualElement.js";
+import { HTMLVisualElement } from "../../../../../motion-dom/dist/es/render/html/HTMLVisualElement.js";
+const createDomVisualElement = (Component, options) => {
+  const isSVG = options.isSVG ?? isSVGComponent(Component);
+  return isSVG ? new SVGVisualElement(options) : new HTMLVisualElement(options, {
+    allowProjection: Component !== Fragment
+  });
+};
+export {
+  createDomVisualElement
+};

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

@@ -0,0 +1,21 @@
+import { Fragment, useMemo, createElement } from "react";
+import { useHTMLProps } from "../html/use-props.js";
+import { useSVGProps } from "../svg/use-props.js";
+import { filterProps } from "./utils/filter-props.js";
+import { isSVGComponent } from "./utils/is-svg-component.js";
+import { isMotionValue } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+function useRender(Component, props, ref, { latestValues }, isStatic, forwardMotionProps = false, isSVG) {
+  const useVisualProps = isSVG ?? isSVGComponent(Component) ? useSVGProps : useHTMLProps;
+  const visualProps = useVisualProps(props, latestValues, isStatic, Component);
+  const filteredProps = filterProps(props, typeof Component === "string", forwardMotionProps);
+  const elementProps = Component !== Fragment ? { ...filteredProps, ...visualProps, ref } : {};
+  const { children } = props;
+  const renderedChildren = useMemo(() => isMotionValue(children) ? children.get() : children, [children]);
+  return createElement(Component, {
+    ...elementProps,
+    children: renderedChildren
+  });
+}
+export {
+  useRender
+};

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

@@ -0,0 +1,31 @@
+import { isValidMotionProp } from "../../../motion/utils/valid-prop.js";
+import { isMotionValue } from "../../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+let shouldForward = (key) => !isValidMotionProp(key);
+function loadExternalIsValidProp(isValidProp) {
+  if (typeof isValidProp !== "function")
+    return;
+  shouldForward = (key) => key.startsWith("on") ? !isValidMotionProp(key) : isValidProp(key);
+}
+try {
+  const emotionPkg = "@emotion/is-prop-valid";
+  loadExternalIsValidProp(require(emotionPkg).default);
+} catch {
+}
+function filterProps(props, isDom, forwardMotionProps) {
+  const filteredProps = {};
+  for (const key in props) {
+    if (key === "values" && typeof props.values === "object")
+      continue;
+    if (isMotionValue(props[key]))
+      continue;
+    if (shouldForward(key) || forwardMotionProps === true && isValidMotionProp(key) || !isDom && !isValidMotionProp(key) || // If trying to use native HTML drag events, forward drag listeners
+    props["draggable"] && key.startsWith("onDrag")) {
+      filteredProps[key] = props[key];
+    }
+  }
+  return filteredProps;
+}
+export {
+  filterProps,
+  loadExternalIsValidProp
+};

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

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

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

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

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

@@ -0,0 +1,44 @@
+import { useMemo } from "react";
+import { createHtmlRenderState } from "./utils/create-render-state.js";
+import { isMotionValue } from "../../../../../motion-dom/dist/es/value/utils/is-motion-value.js";
+import { isForcedMotionValue } from "../../../../../motion-dom/dist/es/render/utils/is-forced-motion-value.js";
+import { buildHTMLStyles } from "../../../../../motion-dom/dist/es/render/html/utils/build-styles.js";
+function copyRawValuesOnly(target, source, props) {
+  for (const key in source) {
+    if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {
+      target[key] = source[key];
+    }
+  }
+}
+function useInitialMotionValues({ transformTemplate }, visualState) {
+  return useMemo(() => {
+    const state = createHtmlRenderState();
+    buildHTMLStyles(state, visualState, transformTemplate);
+    return Object.assign({}, state.vars, state.style);
+  }, [visualState]);
+}
+function useStyle(props, visualState) {
+  const styleProp = props.style || {};
+  const style = {};
+  copyRawValuesOnly(style, styleProp, props);
+  Object.assign(style, useInitialMotionValues(props, visualState));
+  return style;
+}
+function useHTMLProps(props, visualState) {
+  const htmlProps = {};
+  const style = useStyle(props, visualState);
+  if (props.drag && props.dragListener !== false) {
+    htmlProps.draggable = false;
+    style.userSelect = style.WebkitUserSelect = style.WebkitTouchCallout = "none";
+    style.touchAction = props.drag === true ? "none" : `pan-${props.drag === "x" ? "y" : "x"}`;
+  }
+  if (props.tabIndex === void 0 && (props.onTap || props.onTapStart || props.whileTap)) {
+    htmlProps.tabIndex = 0;
+  }
+  htmlProps.style = style;
+  return htmlProps;
+}
+export {
+  copyRawValuesOnly,
+  useHTMLProps
+};

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

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