@quan-erp/shared-ui 1.0.0

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

@@ -0,0 +1,20 @@
+import { hasReducedMotionListener, prefersReducedMotion } from "./state.js";
+const isBrowser = typeof window !== "undefined";
+function initPrefersReducedMotion() {
+  hasReducedMotionListener.current = true;
+  if (!isBrowser)
+    return;
+  if (window.matchMedia) {
+    const motionMediaQuery = window.matchMedia("(prefers-reduced-motion)");
+    const setReducedMotionPreferences = () => prefersReducedMotion.current = motionMediaQuery.matches;
+    motionMediaQuery.addEventListener("change", setReducedMotionPreferences);
+    setReducedMotionPreferences();
+  } else {
+    prefersReducedMotion.current = false;
+  }
+}
+export {
+  hasReducedMotionListener,
+  initPrefersReducedMotion,
+  prefersReducedMotion
+};

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

@@ -0,0 +1,6 @@
+const prefersReducedMotion = { current: null };
+const hasReducedMotionListener = { current: false };
+export {
+  hasReducedMotionListener,
+  prefersReducedMotion
+};

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

@@ -0,0 +1,8 @@
+import { resolveVariantFromProps } from "./resolve-variants.js";
+function resolveVariant(visualElement, definition, custom) {
+  const props = visualElement.getProps();
+  return resolveVariantFromProps(props, definition, custom !== void 0 ? custom : props.custom, visualElement);
+}
+export {
+  resolveVariant
+};

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

@@ -0,0 +1,25 @@
+function getValueState(visualElement) {
+  const state = [{}, {}];
+  visualElement?.values.forEach((value, key) => {
+    state[0][key] = value.get();
+    state[1][key] = value.getVelocity();
+  });
+  return state;
+}
+function resolveVariantFromProps(props, definition, custom, visualElement) {
+  if (typeof definition === "function") {
+    const [current, velocity] = getValueState(visualElement);
+    definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
+  }
+  if (typeof definition === "string") {
+    definition = props.variants && props.variants[definition];
+  }
+  if (typeof definition === "function") {
+    const [current, velocity] = getValueState(visualElement);
+    definition = definition(custom !== void 0 ? custom : props.custom, current, velocity);
+  }
+  return definition;
+}
+export {
+  resolveVariantFromProps
+};

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

@@ -0,0 +1,25 @@
+import { motionValue } from "../../value/index.js";
+import { resolveVariant } from "./resolve-dynamic-variants.js";
+import { isKeyframesTarget } from "./is-keyframes-target.js";
+function setMotionValue(visualElement, key, value) {
+  if (visualElement.hasValue(key)) {
+    visualElement.getValue(key).set(value);
+  } else {
+    visualElement.addValue(key, motionValue(value));
+  }
+}
+function resolveFinalValueInKeyframes(v) {
+  return isKeyframesTarget(v) ? v[v.length - 1] || 0 : v;
+}
+function setTarget(visualElement, definition) {
+  const resolved = resolveVariant(visualElement, definition);
+  let { transitionEnd = {}, transition = {}, ...target } = resolved || {};
+  target = { ...target, ...transitionEnd };
+  for (const key in target) {
+    const value = resolveFinalValueInKeyframes(target[key]);
+    setMotionValue(visualElement, key, value);
+  }
+}
+export {
+  setTarget
+};

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

@@ -0,0 +1,15 @@
+function shallowCompare(next, prev) {
+  if (!Array.isArray(prev))
+    return false;
+  const prevLength = prev.length;
+  if (prevLength !== next.length)
+    return false;
+  for (let i = 0; i < prevLength; i++) {
+    if (prev[i] !== next[i])
+      return false;
+  }
+  return true;
+}
+export {
+  shallowCompare
+};

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

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

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

@@ -0,0 +1,61 @@
+import { isSVGElement } from "../utils/is-svg-element.js";
+import { resolveElements } from "../utils/resolve-elements.js";
+const resizeHandlers = /* @__PURE__ */ new WeakMap();
+let observer;
+const getSize = (borderBoxAxis, svgAxis, htmlAxis) => (target, borderBoxSize) => {
+  if (borderBoxSize && borderBoxSize[0]) {
+    return borderBoxSize[0][borderBoxAxis + "Size"];
+  } else if (isSVGElement(target) && "getBBox" in target) {
+    return target.getBBox()[svgAxis];
+  } else {
+    return target[htmlAxis];
+  }
+};
+const getWidth = /* @__PURE__ */ getSize("inline", "width", "offsetWidth");
+const getHeight = /* @__PURE__ */ getSize("block", "height", "offsetHeight");
+function notifyTarget({ target, borderBoxSize }) {
+  resizeHandlers.get(target)?.forEach((handler) => {
+    handler(target, {
+      get width() {
+        return getWidth(target, borderBoxSize);
+      },
+      get height() {
+        return getHeight(target, borderBoxSize);
+      }
+    });
+  });
+}
+function notifyAll(entries) {
+  entries.forEach(notifyTarget);
+}
+function createResizeObserver() {
+  if (typeof ResizeObserver === "undefined")
+    return;
+  observer = new ResizeObserver(notifyAll);
+}
+function resizeElement(target, handler) {
+  if (!observer)
+    createResizeObserver();
+  const elements = resolveElements(target);
+  elements.forEach((element) => {
+    let elementHandlers = resizeHandlers.get(element);
+    if (!elementHandlers) {
+      elementHandlers = /* @__PURE__ */ new Set();
+      resizeHandlers.set(element, elementHandlers);
+    }
+    elementHandlers.add(handler);
+    observer?.observe(element);
+  });
+  return () => {
+    elements.forEach((element) => {
+      const elementHandlers = resizeHandlers.get(element);
+      elementHandlers?.delete(handler);
+      if (!elementHandlers?.size) {
+        observer?.unobserve(element);
+      }
+    });
+  };
+}
+export {
+  resizeElement
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/resize/handle-window.js

@@ -0,0 +1,31 @@
+const windowCallbacks = /* @__PURE__ */ new Set();
+let windowResizeHandler;
+function createWindowResizeHandler() {
+  windowResizeHandler = () => {
+    const info = {
+      get width() {
+        return window.innerWidth;
+      },
+      get height() {
+        return window.innerHeight;
+      }
+    };
+    windowCallbacks.forEach((callback) => callback(info));
+  };
+  window.addEventListener("resize", windowResizeHandler);
+}
+function resizeWindow(callback) {
+  windowCallbacks.add(callback);
+  if (!windowResizeHandler)
+    createWindowResizeHandler();
+  return () => {
+    windowCallbacks.delete(callback);
+    if (!windowCallbacks.size && typeof windowResizeHandler === "function") {
+      window.removeEventListener("resize", windowResizeHandler);
+      windowResizeHandler = void 0;
+    }
+  };
+}
+export {
+  resizeWindow
+};

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

@@ -0,0 +1,8 @@
+import { resizeElement } from "./handle-element.js";
+import { resizeWindow } from "./handle-window.js";
+function resize(a, b) {
+  return typeof a === "function" ? resizeWindow(a) : resizeElement(a, b);
+}
+export {
+  resize
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/delay.js

@@ -0,0 +1,17 @@
+import { time } from "../frameloop/sync-time.js";
+import { frame, cancelFrame } from "../frameloop/frame.js";
+function delay(callback, timeout) {
+  const start = time.now();
+  const checkElapsed = ({ timestamp }) => {
+    const elapsed = timestamp - start;
+    if (elapsed >= timeout) {
+      cancelFrame(checkElapsed);
+      callback(elapsed - timeout);
+    }
+  };
+  frame.setup(checkElapsed, true);
+  return () => cancelFrame(checkElapsed);
+}
+export {
+  delay
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/interpolate.js

@@ -0,0 +1,53 @@
+import { mix } from "./mix/index.js";
+import { invariant } from "../../../../motion-utils/dist/es/errors.js";
+import { clamp } from "../../../../motion-utils/dist/es/clamp.js";
+import { noop } from "../../../../motion-utils/dist/es/noop.js";
+import { pipe } from "../../../../motion-utils/dist/es/pipe.js";
+import { progress } from "../../../../motion-utils/dist/es/progress.js";
+import { MotionGlobalConfig } from "../../../../motion-utils/dist/es/global-config.js";
+function createMixers(output, ease, customMixer) {
+  const mixers = [];
+  const mixerFactory = customMixer || MotionGlobalConfig.mix || mix;
+  const numMixers = output.length - 1;
+  for (let i = 0; i < numMixers; i++) {
+    let mixer = mixerFactory(output[i], output[i + 1]);
+    if (ease) {
+      const easingFunction = Array.isArray(ease) ? ease[i] || noop : ease;
+      mixer = pipe(easingFunction, mixer);
+    }
+    mixers.push(mixer);
+  }
+  return mixers;
+}
+function interpolate(input, output, { clamp: isClamp = true, ease, mixer } = {}) {
+  const inputLength = input.length;
+  invariant(inputLength === output.length, "Both input and output ranges must be the same length", "range-length");
+  if (inputLength === 1)
+    return () => output[0];
+  if (inputLength === 2 && output[0] === output[1])
+    return () => output[1];
+  const isZeroDeltaRange = input[0] === input[1];
+  if (input[0] > input[inputLength - 1]) {
+    input = [...input].reverse();
+    output = [...output].reverse();
+  }
+  const mixers = createMixers(output, ease, mixer);
+  const numMixers = mixers.length;
+  const interpolator = (v) => {
+    if (isZeroDeltaRange && v < input[0])
+      return output[0];
+    let i = 0;
+    if (numMixers > 1) {
+      for (; i < input.length - 2; i++) {
+        if (v < input[i + 1])
+          break;
+      }
+    }
+    const progressInRange = progress(input[i], input[i + 1], v);
+    return mixers[i](progressInRange);
+  };
+  return isClamp ? (v) => interpolator(clamp(input[0], input[inputLength - 1], v)) : interpolator;
+}
+export {
+  interpolate
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/is-html-element.js

@@ -0,0 +1,7 @@
+import { isObject } from "../../../../motion-utils/dist/es/is-object.js";
+function isHTMLElement(element) {
+  return isObject(element) && "offsetHeight" in element && !("ownerSVGElement" in element);
+}
+export {
+  isHTMLElement
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/is-svg-element.js

@@ -0,0 +1,7 @@
+import { isObject } from "../../../../motion-utils/dist/es/is-object.js";
+function isSVGElement(element) {
+  return isObject(element) && "ownerSVGElement" in element;
+}
+export {
+  isSVGElement
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/is-svg-svg-element.js

@@ -0,0 +1,7 @@
+import { isSVGElement } from "./is-svg-element.js";
+function isSVGSVGElement(element) {
+  return isSVGElement(element) && element.tagName === "svg";
+}
+export {
+  isSVGSVGElement
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/mix/color.js

@@ -0,0 +1,44 @@
+import { hex } from "../../value/types/color/hex.js";
+import { hsla } from "../../value/types/color/hsla.js";
+import { hslaToRgba } from "../../value/types/color/hsla-to-rgba.js";
+import { rgba } from "../../value/types/color/rgba.js";
+import { mixImmediate } from "./immediate.js";
+import { mixNumber } from "./number.js";
+import { warning } from "../../../../../motion-utils/dist/es/errors.js";
+const mixLinearColor = (from, to, v) => {
+  const fromExpo = from * from;
+  const expo = v * (to * to - fromExpo) + fromExpo;
+  return expo < 0 ? 0 : Math.sqrt(expo);
+};
+const colorTypes = [hex, rgba, hsla];
+const getColorType = (v) => colorTypes.find((type) => type.test(v));
+function asRGBA(color) {
+  const type = getColorType(color);
+  warning(Boolean(type), `'${color}' is not an animatable color. Use the equivalent color code instead.`, "color-not-animatable");
+  if (!Boolean(type))
+    return false;
+  let model = type.parse(color);
+  if (type === hsla) {
+    model = hslaToRgba(model);
+  }
+  return model;
+}
+const mixColor = (from, to) => {
+  const fromRGBA = asRGBA(from);
+  const toRGBA = asRGBA(to);
+  if (!fromRGBA || !toRGBA) {
+    return mixImmediate(from, to);
+  }
+  const blended = { ...fromRGBA };
+  return (v) => {
+    blended.red = mixLinearColor(fromRGBA.red, toRGBA.red, v);
+    blended.green = mixLinearColor(fromRGBA.green, toRGBA.green, v);
+    blended.blue = mixLinearColor(fromRGBA.blue, toRGBA.blue, v);
+    blended.alpha = mixNumber(fromRGBA.alpha, toRGBA.alpha, v);
+    return rgba.transform(blended);
+  };
+};
+export {
+  mixColor,
+  mixLinearColor
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/mix/complex.js

@@ -0,0 +1,83 @@
+import { isCSSVariableToken } from "../../animation/utils/is-css-variable.js";
+import { color } from "../../value/types/color/index.js";
+import { complex, analyseComplexValue } from "../../value/types/complex/index.js";
+import { mixColor } from "./color.js";
+import { mixImmediate } from "./immediate.js";
+import { mixNumber as mixNumber$1 } from "./number.js";
+import { invisibleValues, mixVisibility } from "./visibility.js";
+import { pipe } from "../../../../../motion-utils/dist/es/pipe.js";
+import { warning } from "../../../../../motion-utils/dist/es/errors.js";
+function mixNumber(a, b) {
+  return (p) => mixNumber$1(a, b, p);
+}
+function getMixer(a) {
+  if (typeof a === "number") {
+    return mixNumber;
+  } else if (typeof a === "string") {
+    return isCSSVariableToken(a) ? mixImmediate : color.test(a) ? mixColor : mixComplex;
+  } else if (Array.isArray(a)) {
+    return mixArray;
+  } else if (typeof a === "object") {
+    return color.test(a) ? mixColor : mixObject;
+  }
+  return mixImmediate;
+}
+function mixArray(a, b) {
+  const output = [...a];
+  const numValues = output.length;
+  const blendValue = a.map((v, i) => getMixer(v)(v, b[i]));
+  return (p) => {
+    for (let i = 0; i < numValues; i++) {
+      output[i] = blendValue[i](p);
+    }
+    return output;
+  };
+}
+function mixObject(a, b) {
+  const output = { ...a, ...b };
+  const blendValue = {};
+  for (const key in output) {
+    if (a[key] !== void 0 && b[key] !== void 0) {
+      blendValue[key] = getMixer(a[key])(a[key], b[key]);
+    }
+  }
+  return (v) => {
+    for (const key in blendValue) {
+      output[key] = blendValue[key](v);
+    }
+    return output;
+  };
+}
+function matchOrder(origin, target) {
+  const orderedOrigin = [];
+  const pointers = { color: 0, var: 0, number: 0 };
+  for (let i = 0; i < target.values.length; i++) {
+    const type = target.types[i];
+    const originIndex = origin.indexes[type][pointers[type]];
+    const originValue = origin.values[originIndex] ?? 0;
+    orderedOrigin[i] = originValue;
+    pointers[type]++;
+  }
+  return orderedOrigin;
+}
+const mixComplex = (origin, target) => {
+  const template = complex.createTransformer(target);
+  const originStats = analyseComplexValue(origin);
+  const targetStats = analyseComplexValue(target);
+  const canInterpolate = originStats.indexes.var.length === targetStats.indexes.var.length && originStats.indexes.color.length === targetStats.indexes.color.length && originStats.indexes.number.length >= targetStats.indexes.number.length;
+  if (canInterpolate) {
+    if (invisibleValues.has(origin) && !targetStats.values.length || invisibleValues.has(target) && !originStats.values.length) {
+      return mixVisibility(origin, target);
+    }
+    return pipe(mixArray(matchOrder(originStats, targetStats), targetStats.values), template);
+  } else {
+    warning(true, `Complex values '${origin}' and '${target}' too different to mix. Ensure all colors are of the same type, and that each contains the same quantity of number and color values. Falling back to instant transition.`, "complex-values-different");
+    return mixImmediate(origin, target);
+  }
+};
+export {
+  getMixer,
+  mixArray,
+  mixComplex,
+  mixObject
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/mix/immediate.js

@@ -0,0 +1,6 @@
+function mixImmediate(a, b) {
+  return (p) => p > 0 ? b : a;
+}
+export {
+  mixImmediate
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/mix/index.js

@@ -0,0 +1,12 @@
+import { getMixer } from "./complex.js";
+import { mixNumber } from "./number.js";
+function mix(from, to, p) {
+  if (typeof from === "number" && typeof to === "number" && typeof p === "number") {
+    return mixNumber(from, to, p);
+  }
+  const mixer = getMixer(from);
+  return mixer(from, to);
+}
+export {
+  mix
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/mix/number.js

@@ -0,0 +1,6 @@
+const mixNumber = (from, to, progress) => {
+  return from + (to - from) * progress;
+};
+export {
+  mixNumber
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/mix/visibility.js

@@ -0,0 +1,12 @@
+const invisibleValues = /* @__PURE__ */ new Set(["none", "hidden"]);
+function mixVisibility(origin, target) {
+  if (invisibleValues.has(origin)) {
+    return (p) => p <= 0 ? origin : target;
+  } else {
+    return (p) => p >= 1 ? target : origin;
+  }
+}
+export {
+  invisibleValues,
+  mixVisibility
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/resolve-elements.js

@@ -0,0 +1,16 @@
+function resolveElements(elementOrSelector, scope, selectorCache) {
+  if (elementOrSelector == null) {
+    return [];
+  }
+  if (elementOrSelector instanceof EventTarget) {
+    return [elementOrSelector];
+  } else if (typeof elementOrSelector === "string") {
+    let root = document;
+    const elements = selectorCache?.[elementOrSelector] ?? root.querySelectorAll(elementOrSelector);
+    return elements ? Array.from(elements) : [];
+  }
+  return Array.from(elementOrSelector).filter((element) => element != null);
+}
+export {
+  resolveElements
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/supports/flags.js

@@ -0,0 +1,4 @@
+const supportsFlags = {};
+export {
+  supportsFlags
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/supports/linear-easing.js

@@ -0,0 +1,12 @@
+import { memoSupports } from "./memo.js";
+const supportsLinearEasing = /* @__PURE__ */ memoSupports(() => {
+  try {
+    document.createElement("div").animate({ opacity: 0 }, { easing: "linear(0, 1)" });
+  } catch (e) {
+    return false;
+  }
+  return true;
+}, "linearEasing");
+export {
+  supportsLinearEasing
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/supports/memo.js

@@ -0,0 +1,9 @@
+import { supportsFlags } from "./flags.js";
+import { memo } from "../../../../../motion-utils/dist/es/memo.js";
+function memoSupports(callback, supportsFlag) {
+  const memoized = memo(callback);
+  return () => supportsFlags[supportsFlag] ?? memoized();
+}
+export {
+  memoSupports
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/utils/supports/scroll-timeline.js

@@ -0,0 +1,5 @@
+import { memoSupports } from "./memo.js";
+const supportsScrollTimeline = /* @__PURE__ */ memoSupports(() => window.ScrollTimeline !== void 0, "scrollTimeline");
+export {
+  supportsScrollTimeline
+};