@quan-erp/shared-ui 1.0.0

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

@@ -0,0 +1,30 @@
+const lowercaseSVGElements = [
+  "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 {
+  lowercaseSVGElements
+};

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

@@ -0,0 +1,24 @@
+import { useMemo } from "react";
+import { copyRawValuesOnly } from "../html/use-props.js";
+import { createSvgRenderState } from "./utils/create-render-state.js";
+import { buildSVGAttrs } from "../../../../../motion-dom/dist/es/render/svg/utils/build-attrs.js";
+import { isSVGTag } from "../../../../../motion-dom/dist/es/render/svg/utils/is-svg-tag.js";
+function useSVGProps(props, visualState, _isStatic, Component) {
+  const visualProps = useMemo(() => {
+    const state = createSvgRenderState();
+    buildSVGAttrs(state, visualState, isSVGTag(Component), props.transformTemplate, props.style);
+    return {
+      ...state.attrs,
+      style: { ...state.style }
+    };
+  }, [visualState]);
+  if (props.style) {
+    const rawStyles = {};
+    copyRawValuesOnly(rawStyles, props.style, props);
+    visualProps.style = { ...rawStyles, ...visualProps.style };
+  }
+  return visualProps;
+}
+export {
+  useSVGProps
+};

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

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

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

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

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

@@ -0,0 +1,10 @@
+const distance = (a, b) => Math.abs(a - b);
+function distance2D(a, b) {
+  const xDelta = distance(a.x, b.x);
+  const yDelta = distance(a.y, b.y);
+  return Math.sqrt(xDelta ** 2 + yDelta ** 2);
+}
+export {
+  distance,
+  distance2D
+};

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

@@ -0,0 +1,6 @@
+const getContextWindow = ({ current }) => {
+  return current ? current.ownerDocument.defaultView : null;
+};
+export {
+  getContextWindow
+};

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

@@ -0,0 +1,4 @@
+const isBrowser = typeof window !== "undefined";
+export {
+  isBrowser
+};

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

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

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

@@ -0,0 +1,38 @@
+import * as React from "react";
+function setRef(ref, value) {
+  if (typeof ref === "function") {
+    return ref(value);
+  } else if (ref !== null && ref !== void 0) {
+    ref.current = value;
+  }
+}
+function composeRefs(...refs) {
+  return (node) => {
+    let hasCleanup = false;
+    const cleanups = refs.map((ref) => {
+      const cleanup = setRef(ref, node);
+      if (!hasCleanup && typeof cleanup === "function") {
+        hasCleanup = true;
+      }
+      return cleanup;
+    });
+    if (hasCleanup) {
+      return () => {
+        for (let i = 0; i < cleanups.length; i++) {
+          const cleanup = cleanups[i];
+          if (typeof cleanup === "function") {
+            cleanup();
+          } else {
+            setRef(refs[i], null);
+          }
+        }
+      };
+    }
+  };
+}
+function useComposedRefs(...refs) {
+  return React.useCallback(composeRefs(...refs), refs);
+}
+export {
+  useComposedRefs
+};

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

@@ -0,0 +1,11 @@
+import { useRef } from "react";
+function useConstant(init) {
+  const ref = useRef(null);
+  if (ref.current === null) {
+    ref.current = init();
+  }
+  return ref.current;
+}
+export {
+  useConstant
+};

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

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

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

@@ -0,0 +1,153 @@
+import { time } from "../frameloop/sync-time.js";
+import { JSAnimation } from "./JSAnimation.js";
+import { getFinalKeyframe } from "./keyframes/get-final.js";
+import { KeyframeResolver, flushKeyframeResolvers } from "./keyframes/KeyframesResolver.js";
+import { NativeAnimationExtended } from "./NativeAnimationExtended.js";
+import { canAnimate } from "./utils/can-animate.js";
+import { makeAnimationInstant } from "./utils/make-animation-instant.js";
+import { WithPromise } from "./utils/WithPromise.js";
+import { supportsBrowserAnimation } from "./waapi/supports/waapi.js";
+import { MotionGlobalConfig } from "../../../../motion-utils/dist/es/global-config.js";
+import { noop } from "../../../../motion-utils/dist/es/noop.js";
+const MAX_RESOLVE_DELAY = 40;
+class AsyncMotionValueAnimation extends WithPromise {
+  constructor({ autoplay = true, delay = 0, type = "keyframes", repeat = 0, repeatDelay = 0, repeatType = "loop", keyframes, name, motionValue, element, ...options }) {
+    super();
+    this.stop = () => {
+      if (this._animation) {
+        this._animation.stop();
+        this.stopTimeline?.();
+      }
+      this.keyframeResolver?.cancel();
+    };
+    this.createdAt = time.now();
+    const optionsWithDefaults = {
+      autoplay,
+      delay,
+      type,
+      repeat,
+      repeatDelay,
+      repeatType,
+      name,
+      motionValue,
+      element,
+      ...options
+    };
+    const KeyframeResolver$1 = element?.KeyframeResolver || KeyframeResolver;
+    this.keyframeResolver = new KeyframeResolver$1(keyframes, (resolvedKeyframes, finalKeyframe, forced) => this.onKeyframesResolved(resolvedKeyframes, finalKeyframe, optionsWithDefaults, !forced), name, motionValue, element);
+    this.keyframeResolver?.scheduleResolve();
+  }
+  onKeyframesResolved(keyframes, finalKeyframe, options, sync) {
+    this.keyframeResolver = void 0;
+    const { name, type, velocity, delay, isHandoff, onUpdate } = options;
+    this.resolvedAt = time.now();
+    let canAnimateValue = true;
+    if (!canAnimate(keyframes, name, type, velocity)) {
+      canAnimateValue = false;
+      if (MotionGlobalConfig.instantAnimations || !delay) {
+        onUpdate?.(getFinalKeyframe(keyframes, options, finalKeyframe));
+      }
+      keyframes[0] = keyframes[keyframes.length - 1];
+      makeAnimationInstant(options);
+      options.repeat = 0;
+    }
+    const startTime = sync ? !this.resolvedAt ? this.createdAt : this.resolvedAt - this.createdAt > MAX_RESOLVE_DELAY ? this.resolvedAt : this.createdAt : void 0;
+    const resolvedOptions = {
+      startTime,
+      finalKeyframe,
+      ...options,
+      keyframes
+    };
+    const useWaapi = canAnimateValue && !isHandoff && supportsBrowserAnimation(resolvedOptions);
+    const element = resolvedOptions.motionValue?.owner?.current;
+    let animation;
+    if (useWaapi) {
+      try {
+        animation = new NativeAnimationExtended({
+          ...resolvedOptions,
+          element
+        });
+      } catch {
+        animation = new JSAnimation(resolvedOptions);
+      }
+    } else {
+      animation = new JSAnimation(resolvedOptions);
+    }
+    animation.finished.then(() => {
+      this.notifyFinished();
+    }).catch(noop);
+    if (this.pendingTimeline) {
+      this.stopTimeline = animation.attachTimeline(this.pendingTimeline);
+      this.pendingTimeline = void 0;
+    }
+    this._animation = animation;
+  }
+  get finished() {
+    if (!this._animation) {
+      return this._finished;
+    } else {
+      return this.animation.finished;
+    }
+  }
+  then(onResolve, _onReject) {
+    return this.finished.finally(onResolve).then(() => {
+    });
+  }
+  get animation() {
+    if (!this._animation) {
+      this.keyframeResolver?.resume();
+      flushKeyframeResolvers();
+    }
+    return this._animation;
+  }
+  get duration() {
+    return this.animation.duration;
+  }
+  get iterationDuration() {
+    return this.animation.iterationDuration;
+  }
+  get time() {
+    return this.animation.time;
+  }
+  set time(newTime) {
+    this.animation.time = newTime;
+  }
+  get speed() {
+    return this.animation.speed;
+  }
+  get state() {
+    return this.animation.state;
+  }
+  set speed(newSpeed) {
+    this.animation.speed = newSpeed;
+  }
+  get startTime() {
+    return this.animation.startTime;
+  }
+  attachTimeline(timeline) {
+    if (this._animation) {
+      this.stopTimeline = this.animation.attachTimeline(timeline);
+    } else {
+      this.pendingTimeline = timeline;
+    }
+    return () => this.stop();
+  }
+  play() {
+    this.animation.play();
+  }
+  pause() {
+    this.animation.pause();
+  }
+  complete() {
+    this.animation.complete();
+  }
+  cancel() {
+    if (this._animation) {
+      this.animation.cancel();
+    }
+    this.keyframeResolver?.cancel();
+  }
+}
+export {
+  AsyncMotionValueAnimation
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/animation/JSAnimation.js

@@ -0,0 +1,294 @@
+import { time } from "../frameloop/sync-time.js";
+import { mix } from "../utils/mix/index.js";
+import { frameloopDriver } from "./drivers/frame.js";
+import { inertia } from "./generators/inertia.js";
+import { keyframes } from "./generators/keyframes.js";
+import { calcGeneratorDuration } from "./generators/utils/calc-duration.js";
+import { getGeneratorVelocity } from "./generators/utils/velocity.js";
+import { getFinalKeyframe } from "./keyframes/get-final.js";
+import { replaceTransitionType } from "./utils/replace-transition-type.js";
+import { WithPromise } from "./utils/WithPromise.js";
+import { invariant } from "../../../../motion-utils/dist/es/errors.js";
+import { pipe } from "../../../../motion-utils/dist/es/pipe.js";
+import { millisecondsToSeconds, secondsToMilliseconds } from "../../../../motion-utils/dist/es/time-conversion.js";
+import { clamp } from "../../../../motion-utils/dist/es/clamp.js";
+const percentToProgress = (percent) => percent / 100;
+class JSAnimation extends WithPromise {
+  constructor(options) {
+    super();
+    this.state = "idle";
+    this.startTime = null;
+    this.isStopped = false;
+    this.currentTime = 0;
+    this.holdTime = null;
+    this.playbackSpeed = 1;
+    this.delayState = {
+      done: false,
+      value: void 0
+    };
+    this.stop = () => {
+      const { motionValue } = this.options;
+      if (motionValue && motionValue.updatedAt !== time.now()) {
+        this.tick(time.now());
+      }
+      this.isStopped = true;
+      if (this.state === "idle")
+        return;
+      this.teardown();
+      this.options.onStop?.();
+    };
+    this.options = options;
+    this.initAnimation();
+    this.play();
+    if (options.autoplay === false)
+      this.pause();
+  }
+  initAnimation() {
+    const { options } = this;
+    replaceTransitionType(options);
+    const { type = keyframes, repeat = 0, repeatDelay = 0, repeatType, velocity = 0 } = options;
+    let { keyframes: keyframes$1 } = options;
+    const generatorFactory = type || keyframes;
+    if (process.env.NODE_ENV !== "production" && generatorFactory !== keyframes) {
+      invariant(keyframes$1.length <= 2, `Only two keyframes currently supported with spring and inertia animations. Trying to animate ${keyframes$1}`, "spring-two-frames");
+    }
+    if (generatorFactory !== keyframes && typeof keyframes$1[0] !== "number") {
+      this.mixKeyframes = pipe(percentToProgress, mix(keyframes$1[0], keyframes$1[1]));
+      keyframes$1 = [0, 100];
+    }
+    const generator = generatorFactory({ ...options, keyframes: keyframes$1 });
+    if (repeatType === "mirror") {
+      this.mirroredGenerator = generatorFactory({
+        ...options,
+        keyframes: [...keyframes$1].reverse(),
+        velocity: -velocity
+      });
+    }
+    if (generator.calculatedDuration === null) {
+      generator.calculatedDuration = calcGeneratorDuration(generator);
+    }
+    const { calculatedDuration } = generator;
+    this.calculatedDuration = calculatedDuration;
+    this.resolvedDuration = calculatedDuration + repeatDelay;
+    this.totalDuration = this.resolvedDuration * (repeat + 1) - repeatDelay;
+    this.generator = generator;
+  }
+  updateTime(timestamp) {
+    const animationTime = Math.round(timestamp - this.startTime) * this.playbackSpeed;
+    if (this.holdTime !== null) {
+      this.currentTime = this.holdTime;
+    } else {
+      this.currentTime = animationTime;
+    }
+  }
+  tick(timestamp, sample = false) {
+    const { generator, totalDuration, mixKeyframes, mirroredGenerator, resolvedDuration, calculatedDuration } = this;
+    if (this.startTime === null)
+      return generator.next(0);
+    const { delay = 0, keyframes: keyframes2, repeat, repeatType, repeatDelay, type, onUpdate, finalKeyframe } = this.options;
+    if (this.speed > 0) {
+      this.startTime = Math.min(this.startTime, timestamp);
+    } else if (this.speed < 0) {
+      this.startTime = Math.min(timestamp - totalDuration / this.speed, this.startTime);
+    }
+    if (sample) {
+      this.currentTime = timestamp;
+    } else {
+      this.updateTime(timestamp);
+    }
+    const timeWithoutDelay = this.currentTime - delay * (this.playbackSpeed >= 0 ? 1 : -1);
+    const isInDelayPhase = this.playbackSpeed >= 0 ? timeWithoutDelay < 0 : timeWithoutDelay > totalDuration;
+    this.currentTime = Math.max(timeWithoutDelay, 0);
+    if (this.state === "finished" && this.holdTime === null) {
+      this.currentTime = totalDuration;
+    }
+    let elapsed = this.currentTime;
+    let frameGenerator = generator;
+    if (repeat) {
+      const progress = Math.min(this.currentTime, totalDuration) / resolvedDuration;
+      let currentIteration = Math.floor(progress);
+      let iterationProgress = progress % 1;
+      if (!iterationProgress && progress >= 1) {
+        iterationProgress = 1;
+      }
+      iterationProgress === 1 && currentIteration--;
+      currentIteration = Math.min(currentIteration, repeat + 1);
+      const isOddIteration = Boolean(currentIteration % 2);
+      if (isOddIteration) {
+        if (repeatType === "reverse") {
+          iterationProgress = 1 - iterationProgress;
+          if (repeatDelay) {
+            iterationProgress -= repeatDelay / resolvedDuration;
+          }
+        } else if (repeatType === "mirror") {
+          frameGenerator = mirroredGenerator;
+        }
+      }
+      elapsed = clamp(0, 1, iterationProgress) * resolvedDuration;
+    }
+    let state;
+    if (isInDelayPhase) {
+      this.delayState.value = keyframes2[0];
+      state = this.delayState;
+    } else {
+      state = frameGenerator.next(elapsed);
+    }
+    if (mixKeyframes && !isInDelayPhase) {
+      state.value = mixKeyframes(state.value);
+    }
+    let { done } = state;
+    if (!isInDelayPhase && calculatedDuration !== null) {
+      done = this.playbackSpeed >= 0 ? this.currentTime >= totalDuration : this.currentTime <= 0;
+    }
+    const isAnimationFinished = this.holdTime === null && (this.state === "finished" || this.state === "running" && done);
+    if (isAnimationFinished && type !== inertia) {
+      state.value = getFinalKeyframe(keyframes2, this.options, finalKeyframe, this.speed);
+    }
+    if (onUpdate) {
+      onUpdate(state.value);
+    }
+    if (isAnimationFinished) {
+      this.finish();
+    }
+    return state;
+  }
+  /**
+   * Allows the returned animation to be awaited or promise-chained. Currently
+   * resolves when the animation finishes at all but in a future update could/should
+   * reject if its cancels.
+   */
+  then(resolve, reject) {
+    return this.finished.then(resolve, reject);
+  }
+  get duration() {
+    return millisecondsToSeconds(this.calculatedDuration);
+  }
+  get iterationDuration() {
+    const { delay = 0 } = this.options || {};
+    return this.duration + millisecondsToSeconds(delay);
+  }
+  get time() {
+    return millisecondsToSeconds(this.currentTime);
+  }
+  set time(newTime) {
+    newTime = secondsToMilliseconds(newTime);
+    this.currentTime = newTime;
+    if (this.startTime === null || this.holdTime !== null || this.playbackSpeed === 0) {
+      this.holdTime = newTime;
+    } else if (this.driver) {
+      this.startTime = this.driver.now() - newTime / this.playbackSpeed;
+    }
+    if (this.driver) {
+      this.driver.start(false);
+    } else {
+      this.startTime = 0;
+      this.state = "paused";
+      this.holdTime = newTime;
+      this.tick(newTime);
+    }
+  }
+  /**
+   * Returns the generator's velocity at the current time in units/second.
+   * Uses the analytical derivative when available (springs), avoiding
+   * the MotionValue's frame-dependent velocity estimation.
+   */
+  getGeneratorVelocity() {
+    const t = this.currentTime;
+    if (t <= 0)
+      return this.options.velocity || 0;
+    if (this.generator.velocity) {
+      return this.generator.velocity(t);
+    }
+    const current = this.generator.next(t).value;
+    return getGeneratorVelocity((s) => this.generator.next(s).value, t, current);
+  }
+  get speed() {
+    return this.playbackSpeed;
+  }
+  set speed(newSpeed) {
+    const hasChanged = this.playbackSpeed !== newSpeed;
+    if (hasChanged && this.driver) {
+      this.updateTime(time.now());
+    }
+    this.playbackSpeed = newSpeed;
+    if (hasChanged && this.driver) {
+      this.time = millisecondsToSeconds(this.currentTime);
+    }
+  }
+  play() {
+    if (this.isStopped)
+      return;
+    const { driver = frameloopDriver, startTime } = this.options;
+    if (!this.driver) {
+      this.driver = driver((timestamp) => this.tick(timestamp));
+    }
+    this.options.onPlay?.();
+    const now = this.driver.now();
+    if (this.state === "finished") {
+      this.updateFinished();
+      this.startTime = now;
+    } else if (this.holdTime !== null) {
+      this.startTime = now - this.holdTime;
+    } else if (!this.startTime) {
+      this.startTime = startTime ?? now;
+    }
+    if (this.state === "finished" && this.speed < 0) {
+      this.startTime += this.calculatedDuration;
+    }
+    this.holdTime = null;
+    this.state = "running";
+    this.driver.start();
+  }
+  pause() {
+    this.state = "paused";
+    this.updateTime(time.now());
+    this.holdTime = this.currentTime;
+  }
+  complete() {
+    if (this.state !== "running") {
+      this.play();
+    }
+    this.state = "finished";
+    this.holdTime = null;
+  }
+  finish() {
+    this.notifyFinished();
+    this.teardown();
+    this.state = "finished";
+    this.options.onComplete?.();
+  }
+  cancel() {
+    this.holdTime = null;
+    this.startTime = 0;
+    this.tick(0);
+    this.teardown();
+    this.options.onCancel?.();
+  }
+  teardown() {
+    this.state = "idle";
+    this.stopDriver();
+    this.startTime = this.holdTime = null;
+  }
+  stopDriver() {
+    if (!this.driver)
+      return;
+    this.driver.stop();
+    this.driver = void 0;
+  }
+  sample(sampleTime) {
+    this.startTime = 0;
+    return this.tick(sampleTime, true);
+  }
+  attachTimeline(timeline) {
+    if (this.options.allowFlatten) {
+      this.options.type = "keyframes";
+      this.options.ease = "linear";
+      this.initAnimation();
+    }
+    this.driver?.stop();
+    return timeline.observe(this);
+  }
+}
+export {
+  JSAnimation
+};