@quan-erp/shared-ui 1.0.0

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/node/state.js

@@ -0,0 +1,15 @@
+const globalProjectionState = {
+  /**
+   * Global flag as to whether the tree has animated since the last time
+   * we resized the window
+   */
+  hasAnimatedSinceResize: true,
+  /**
+   * We set this to true once, on the first update. Any nodes added to the tree beyond that
+   * update will be given a `data-projection-id` attribute.
+   */
+  hasEverUpdated: false
+};
+export {
+  globalProjectionState
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/shared/stack.js

@@ -0,0 +1,83 @@
+import { addUniqueItem, removeItem } from "../../../../../motion-utils/dist/es/array.js";
+class NodeStack {
+  constructor() {
+    this.members = [];
+  }
+  add(node) {
+    addUniqueItem(this.members, node);
+    for (let i = this.members.length - 1; i >= 0; i--) {
+      const member = this.members[i];
+      if (member === node || member === this.lead || member === this.prevLead)
+        continue;
+      const inst = member.instance;
+      if ((!inst || inst.isConnected === false) && !member.snapshot) {
+        removeItem(this.members, member);
+        member.unmount();
+      }
+    }
+    node.scheduleRender();
+  }
+  remove(node) {
+    removeItem(this.members, node);
+    if (node === this.prevLead)
+      this.prevLead = void 0;
+    if (node === this.lead) {
+      const prevLead = this.members[this.members.length - 1];
+      if (prevLead)
+        this.promote(prevLead);
+    }
+  }
+  relegate(node) {
+    for (let i = this.members.indexOf(node) - 1; i >= 0; i--) {
+      const member = this.members[i];
+      if (member.isPresent !== false && member.instance?.isConnected !== false) {
+        this.promote(member);
+        return true;
+      }
+    }
+    return false;
+  }
+  promote(node, preserveFollowOpacity) {
+    const prevLead = this.lead;
+    if (node === prevLead)
+      return;
+    this.prevLead = prevLead;
+    this.lead = node;
+    node.show();
+    if (prevLead) {
+      prevLead.updateSnapshot();
+      node.scheduleRender();
+      const { layoutDependency: prevDep } = prevLead.options;
+      const { layoutDependency: nextDep } = node.options;
+      if (prevDep === void 0 || prevDep !== nextDep) {
+        node.resumeFrom = prevLead;
+        if (preserveFollowOpacity)
+          prevLead.preserveOpacity = true;
+        if (prevLead.snapshot) {
+          node.snapshot = prevLead.snapshot;
+          node.snapshot.latestValues = prevLead.animationValues || prevLead.latestValues;
+        }
+        if (node.root?.isUpdating)
+          node.isLayoutDirty = true;
+      }
+      if (node.options.crossfade === false)
+        prevLead.hide();
+    }
+  }
+  exitAnimationComplete() {
+    this.members.forEach((member) => {
+      member.options.onExitComplete?.();
+      member.resumingFrom?.options.onExitComplete?.();
+    });
+  }
+  scheduleRender() {
+    this.members.forEach((member) => member.instance && member.scheduleRender(false));
+  }
+  removeLeadSnapshot() {
+    if (this.lead?.snapshot)
+      this.lead.snapshot = void 0;
+  }
+}
+export {
+  NodeStack
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/styles/scale-border-radius.js

@@ -0,0 +1,26 @@
+import { px } from "../../value/types/numbers/units.js";
+function pixelsToPercent(pixels, axis) {
+  if (axis.max === axis.min)
+    return 0;
+  return pixels / (axis.max - axis.min) * 100;
+}
+const correctBorderRadius = {
+  correct: (latest, node) => {
+    if (!node.target)
+      return latest;
+    if (typeof latest === "string") {
+      if (px.test(latest)) {
+        latest = parseFloat(latest);
+      } else {
+        return latest;
+      }
+    }
+    const x = pixelsToPercent(latest, node.target.x);
+    const y = pixelsToPercent(latest, node.target.y);
+    return `${x}% ${y}%`;
+  }
+};
+export {
+  correctBorderRadius,
+  pixelsToPercent
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/styles/scale-box-shadow.js

@@ -0,0 +1,25 @@
+import { complex } from "../../value/types/complex/index.js";
+import { mixNumber } from "../../utils/mix/number.js";
+const correctBoxShadow = {
+  correct: (latest, { treeScale, projectionDelta }) => {
+    const original = latest;
+    const shadow = complex.parse(latest);
+    if (shadow.length > 5)
+      return original;
+    const template = complex.createTransformer(latest);
+    const offset = typeof shadow[0] !== "number" ? 1 : 0;
+    const xScale = projectionDelta.x.scale * treeScale.x;
+    const yScale = projectionDelta.y.scale * treeScale.y;
+    shadow[0 + offset] /= xScale;
+    shadow[1 + offset] /= yScale;
+    const averageScale = mixNumber(xScale, yScale, 0.5);
+    if (typeof shadow[2 + offset] === "number")
+      shadow[2 + offset] /= averageScale;
+    if (typeof shadow[3 + offset] === "number")
+      shadow[3 + offset] /= averageScale;
+    return template(shadow);
+  }
+};
+export {
+  correctBoxShadow
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/styles/scale-correction.js

@@ -0,0 +1,21 @@
+import { correctBorderRadius } from "./scale-border-radius.js";
+import { correctBoxShadow } from "./scale-box-shadow.js";
+const scaleCorrectors = {
+  borderRadius: {
+    ...correctBorderRadius,
+    applyTo: [
+      "borderTopLeftRadius",
+      "borderTopRightRadius",
+      "borderBottomLeftRadius",
+      "borderBottomRightRadius"
+    ]
+  },
+  borderTopLeftRadius: correctBorderRadius,
+  borderTopRightRadius: correctBorderRadius,
+  borderBottomLeftRadius: correctBorderRadius,
+  borderBottomRightRadius: correctBorderRadius,
+  boxShadow: correctBoxShadow
+};
+export {
+  scaleCorrectors
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/styles/transform.js

@@ -0,0 +1,38 @@
+function buildProjectionTransform(delta, treeScale, latestTransform) {
+  let transform = "";
+  const xTranslate = delta.x.translate / treeScale.x;
+  const yTranslate = delta.y.translate / treeScale.y;
+  const zTranslate = latestTransform?.z || 0;
+  if (xTranslate || yTranslate || zTranslate) {
+    transform = `translate3d(${xTranslate}px, ${yTranslate}px, ${zTranslate}px) `;
+  }
+  if (treeScale.x !== 1 || treeScale.y !== 1) {
+    transform += `scale(${1 / treeScale.x}, ${1 / treeScale.y}) `;
+  }
+  if (latestTransform) {
+    const { transformPerspective, rotate, pathRotation, rotateX, rotateY, skewX, skewY } = latestTransform;
+    if (transformPerspective)
+      transform = `perspective(${transformPerspective}px) ${transform}`;
+    if (rotate)
+      transform += `rotate(${rotate}deg) `;
+    if (pathRotation)
+      transform += `rotate(${pathRotation}deg) `;
+    if (rotateX)
+      transform += `rotateX(${rotateX}deg) `;
+    if (rotateY)
+      transform += `rotateY(${rotateY}deg) `;
+    if (skewX)
+      transform += `skewX(${skewX}deg) `;
+    if (skewY)
+      transform += `skewY(${skewY}deg) `;
+  }
+  const elementScaleX = delta.x.scale * treeScale.x;
+  const elementScaleY = delta.y.scale * treeScale.y;
+  if (elementScaleX !== 1 || elementScaleY !== 1) {
+    transform += `scale(${elementScaleX}, ${elementScaleY})`;
+  }
+  return transform || "none";
+}
+export {
+  buildProjectionTransform
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/utils/compare-by-depth.js

@@ -0,0 +1,4 @@
+const compareByDepth = (a, b) => a.depth - b.depth;
+export {
+  compareByDepth
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/utils/each-axis.js

@@ -0,0 +1,6 @@
+function eachAxis(callback) {
+  return [callback("x"), callback("y")];
+}
+export {
+  eachAxis
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/utils/flat-tree.js

@@ -0,0 +1,24 @@
+import { compareByDepth } from "./compare-by-depth.js";
+import { addUniqueItem, removeItem } from "../../../../../motion-utils/dist/es/array.js";
+class FlatTree {
+  constructor() {
+    this.children = [];
+    this.isDirty = false;
+  }
+  add(child) {
+    addUniqueItem(this.children, child);
+    this.isDirty = true;
+  }
+  remove(child) {
+    removeItem(this.children, child);
+    this.isDirty = true;
+  }
+  forEach(callback) {
+    this.isDirty && this.children.sort(compareByDepth);
+    this.isDirty = false;
+    this.children.forEach(callback);
+  }
+}
+export {
+  FlatTree
+};

package/dist/es/shared-ui/node_modules/motion-dom/dist/es/projection/utils/has-transform.js

@@ -0,0 +1,20 @@
+function isIdentityScale(scale) {
+  return scale === void 0 || scale === 1;
+}
+function hasScale({ scale, scaleX, scaleY }) {
+  return !isIdentityScale(scale) || !isIdentityScale(scaleX) || !isIdentityScale(scaleY);
+}
+function hasTransform(values) {
+  return hasScale(values) || has2DTranslate(values) || values.z || values.rotate || values.rotateX || values.rotateY || values.skewX || values.skewY;
+}
+function has2DTranslate(values) {
+  return is2DTranslate(values.x) || is2DTranslate(values.y);
+}
+function is2DTranslate(value) {
+  return value && value !== "0%";
+}
+export {
+  has2DTranslate,
+  hasScale,
+  hasTransform
+};

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

@@ -0,0 +1,18 @@
+import { convertBoundingBoxToBox, transformBoxPoints } from "../geometry/conversion.js";
+import { translateAxis } from "../geometry/delta-apply.js";
+function measureViewportBox(instance, transformPoint) {
+  return convertBoundingBoxToBox(transformBoxPoints(instance.getBoundingClientRect(), transformPoint));
+}
+function measurePageBox(element, rootProjectionNode, transformPagePoint) {
+  const viewportBox = measureViewportBox(element, transformPagePoint);
+  const { scroll } = rootProjectionNode;
+  if (scroll) {
+    translateAxis(viewportBox.x, scroll.offset.x);
+    translateAxis(viewportBox.y, scroll.offset.y);
+  }
+  return viewportBox;
+}
+export {
+  measurePageBox,
+  measureViewportBox
+};

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

@@ -0,0 +1,11 @@
+class Feature {
+  constructor(node) {
+    this.isMounted = false;
+    this.node = node;
+  }
+  update() {
+  }
+}
+export {
+  Feature
+};