@blogmcp/mdx-render-vue 0.1.0

package/dist/node_modules/@zag-js/presence/dist/presence.machine.js

@@ -0,0 +1,175 @@
+import { createMachine } from "../../core/dist/create-machine.js";
+import { setStyle } from "../../dom-query/dist/set.js";
+import { nextTick, raf } from "../../dom-query/dist/raf.js";
+import { getComputedStyle } from "../../dom-query/dist/computed-style.js";
+import { getWindow } from "../../dom-query/dist/node.js";
+import { getEventTarget } from "../../dom-query/dist/event.js";
+var machine = createMachine({
+  props({ props }) {
+    return { ...props, present: !!props.present };
+  },
+  initialState({ prop }) {
+    return prop("present") ? "mounted" : "unmounted";
+  },
+  refs() {
+    return {
+      node: null,
+      styles: null
+    };
+  },
+  context({ bindable }) {
+    return {
+      unmountAnimationName: bindable(() => ({ defaultValue: null })),
+      prevAnimationName: bindable(() => ({ defaultValue: null })),
+      present: bindable(() => ({ defaultValue: false })),
+      initial: bindable(() => ({
+        sync: true,
+        defaultValue: false
+      }))
+    };
+  },
+  exit: ["cleanupNode"],
+  watch({ track, prop, send }) {
+    track([() => prop("present")], () => {
+      send({ type: "PRESENCE.CHANGED" });
+    });
+  },
+  on: {
+    "NODE.SET": {
+      actions: ["setupNode"]
+    },
+    "PRESENCE.CHANGED": {
+      actions: ["setInitial", "syncPresence"]
+    }
+  },
+  states: {
+    mounted: {
+      on: {
+        UNMOUNT: {
+          target: "unmounted",
+          actions: ["clearPrevAnimationName", "invokeOnExitComplete"]
+        },
+        "UNMOUNT.SUSPEND": {
+          target: "unmountSuspended"
+        }
+      }
+    },
+    unmountSuspended: {
+      effects: ["trackAnimationEvents"],
+      on: {
+        MOUNT: {
+          target: "mounted",
+          actions: ["setPrevAnimationName"]
+        },
+        UNMOUNT: {
+          target: "unmounted",
+          actions: ["clearPrevAnimationName", "invokeOnExitComplete"]
+        }
+      }
+    },
+    unmounted: {
+      on: {
+        MOUNT: {
+          target: "mounted",
+          actions: ["setPrevAnimationName"]
+        }
+      }
+    }
+  },
+  implementations: {
+    actions: {
+      setInitial: ({ context }) => {
+        if (context.get("initial")) return;
+        queueMicrotask(() => {
+          context.set("initial", true);
+        });
+      },
+      invokeOnExitComplete: ({ prop, refs }) => {
+        prop("onExitComplete")?.();
+        const node = refs.get("node");
+        if (!node) return;
+        const win = getWindow(node);
+        const event = new win.CustomEvent("exitcomplete", { bubbles: false });
+        node.dispatchEvent(event);
+      },
+      setupNode: ({ refs, event }) => {
+        if (refs.get("node") === event.node) return;
+        refs.set("node", event.node);
+        refs.set("styles", getComputedStyle(event.node));
+      },
+      cleanupNode: ({ refs }) => {
+        refs.set("node", null);
+        refs.set("styles", null);
+      },
+      syncPresence: ({ context, refs, send, prop }) => {
+        const presentProp = prop("present");
+        if (presentProp) {
+          return send({ type: "MOUNT", src: "presence.changed" });
+        }
+        const node = refs.get("node");
+        if (!presentProp && node?.ownerDocument.visibilityState === "hidden") {
+          return send({ type: "UNMOUNT", src: "visibilitychange" });
+        }
+        raf(() => {
+          if (prop("present")) return;
+          const animationName = getAnimationName(refs.get("styles"));
+          context.set("unmountAnimationName", animationName);
+          if (animationName === "none" || animationName === context.get("prevAnimationName") || refs.get("styles")?.display === "none" || refs.get("styles")?.animationDuration === "0s") {
+            send({ type: "UNMOUNT", src: "presence.changed" });
+          } else {
+            send({ type: "UNMOUNT.SUSPEND" });
+          }
+        });
+      },
+      setPrevAnimationName: ({ context, refs }) => {
+        raf(() => {
+          context.set("prevAnimationName", getAnimationName(refs.get("styles")));
+        });
+      },
+      clearPrevAnimationName: ({ context }) => {
+        context.set("prevAnimationName", null);
+      }
+    },
+    effects: {
+      trackAnimationEvents: ({ context, refs, send, prop }) => {
+        const node = refs.get("node");
+        if (!node) return;
+        const onStart = (event) => {
+          const target = event.composedPath?.()?.[0] ?? event.target;
+          if (target === node) {
+            context.set("prevAnimationName", getAnimationName(refs.get("styles")));
+          }
+        };
+        const onEnd = (event) => {
+          const animationName = getAnimationName(refs.get("styles"));
+          const target = getEventTarget(event);
+          if (target === node && animationName === context.get("unmountAnimationName") && !prop("present")) {
+            send({ type: "UNMOUNT", src: "animationend" });
+          }
+        };
+        const onCancel = (event) => {
+          const target = getEventTarget(event);
+          if (target === node && !prop("present")) {
+            send({ type: "UNMOUNT", src: "animationcancel" });
+          }
+        };
+        node.addEventListener("animationstart", onStart);
+        node.addEventListener("animationcancel", onCancel);
+        node.addEventListener("animationend", onEnd);
+        const cleanupStyles = setStyle(node, { animationFillMode: "forwards" });
+        return () => {
+          node.removeEventListener("animationstart", onStart);
+          node.removeEventListener("animationcancel", onCancel);
+          node.removeEventListener("animationend", onEnd);
+          nextTick(() => cleanupStyles());
+        };
+      }
+    }
+  }
+});
+function getAnimationName(styles) {
+  return styles?.animationName || "none";
+}
+export {
+  machine
+};

package/dist/node_modules/@zag-js/tooltip/dist/tooltip.anatomy.js

@@ -0,0 +1,7 @@
+import { createAnatomy } from "../../anatomy/dist/create-anatomy.js";
+var anatomy = createAnatomy("tooltip").parts("trigger", "arrow", "arrowTip", "positioner", "content");
+var parts = anatomy.build();
+export {
+  anatomy,
+  parts
+};

package/dist/node_modules/@zag-js/tooltip/dist/tooltip.connect.js

@@ -0,0 +1,155 @@
+import { isLeftClick } from "../../dom-query/dist/event.js";
+import { dataAttr } from "../../dom-query/dist/shared.js";
+import { isFocusVisible } from "../../focus-visible/dist/index.js";
+import { getPlacementStyles } from "../../popper/dist/get-styles.js";
+import { parts } from "./tooltip.anatomy.js";
+import { getContentId, getPositionerId, getArrowId, getTriggerId } from "./tooltip.dom.js";
+import { store } from "./tooltip.store.js";
+function connect(service, normalize) {
+  const { state, context, send, scope, prop } = service;
+  const id = prop("id");
+  const hasAriaLabel = !!prop("aria-label");
+  const open = state.matches("open", "closing");
+  const triggerValue = context.get("triggerValue");
+  const contentId = getContentId(scope);
+  const disabled = prop("disabled");
+  const popperStyles = getPlacementStyles({
+    ...prop("positioning"),
+    placement: context.get("currentPlacement")
+  });
+  return {
+    open,
+    setOpen(nextOpen) {
+      const open2 = state.matches("open", "closing");
+      if (open2 === nextOpen) return;
+      send({ type: nextOpen ? "open" : "close" });
+    },
+    triggerValue,
+    setTriggerValue(value) {
+      send({ type: "triggerValue.set", value: value ?? void 0 });
+    },
+    reposition(options = {}) {
+      send({ type: "positioning.set", options });
+    },
+    getTriggerProps(props = {}) {
+      const { value } = props;
+      const current = value == null ? false : triggerValue === value;
+      const triggerId = getTriggerId(scope, value);
+      return normalize.button({
+        ...parts.trigger.attrs,
+        id: triggerId,
+        "data-ownedby": scope.id,
+        "data-value": value,
+        "data-current": dataAttr(current),
+        dir: prop("dir"),
+        "data-expanded": dataAttr(open),
+        "data-state": open ? "open" : "closed",
+        "aria-describedby": open ? contentId : void 0,
+        onClick(event) {
+          if (event.defaultPrevented) return;
+          if (disabled) return;
+          if (!prop("closeOnClick")) return;
+          const shouldSwitch = open && value != null && !current;
+          send({ type: shouldSwitch ? "triggerValue.set" : "close", src: "trigger.click", value, triggerId });
+        },
+        onFocus(event) {
+          if (event.defaultPrevented) return;
+          if (disabled) return;
+          if (!isFocusVisible()) return;
+          const shouldSwitch = open && value != null && !current;
+          send({ type: shouldSwitch ? "triggerValue.set" : "open", src: "trigger.focus", value, triggerId });
+        },
+        onBlur(event) {
+          if (event.defaultPrevented) return;
+          if (disabled) return;
+          if (id !== store.get("id")) return;
+          const activeEl = event.relatedTarget ?? scope.getDoc().activeElement;
+          const focusedAnotherTrigger = activeEl?.closest(`[data-ownedby="${scope.id}"]`) != null;
+          if (!focusedAnotherTrigger) {
+            send({ type: "close", src: "trigger.blur", value, triggerId });
+          }
+        },
+        onPointerDown(event) {
+          if (event.defaultPrevented) return;
+          if (disabled) return;
+          if (!isLeftClick(event)) return;
+          if (!prop("closeOnPointerDown")) return;
+          if (id === store.get("id")) {
+            send({ type: "close", src: "trigger.pointerdown", value, triggerId });
+          }
+        },
+        onPointerMove(event) {
+          if (event.defaultPrevented) return;
+          if (disabled) return;
+          if (event.pointerType === "touch") return;
+          const shouldSwitch = open && value != null && !current;
+          send({ type: shouldSwitch ? "triggerValue.set" : "pointer.move", value, triggerId });
+        },
+        onPointerOver(event) {
+          if (event.defaultPrevented) return;
+          if (disabled) return;
+          if (event.pointerType === "touch") return;
+          send({ type: "pointer.move", value, triggerId });
+        },
+        onPointerLeave() {
+          if (disabled) return;
+          send({ type: "pointer.leave" });
+        },
+        onPointerCancel() {
+          if (disabled) return;
+          send({ type: "pointer.leave" });
+        }
+      });
+    },
+    getArrowProps() {
+      return normalize.element({
+        id: getArrowId(scope),
+        ...parts.arrow.attrs,
+        dir: prop("dir"),
+        style: popperStyles.arrow
+      });
+    },
+    getArrowTipProps() {
+      return normalize.element({
+        ...parts.arrowTip.attrs,
+        dir: prop("dir"),
+        style: popperStyles.arrowTip
+      });
+    },
+    getPositionerProps() {
+      return normalize.element({
+        id: getPositionerId(scope),
+        ...parts.positioner.attrs,
+        dir: prop("dir"),
+        style: popperStyles.floating
+      });
+    },
+    getContentProps() {
+      const isCurrentTooltip = store.get("id") === id;
+      const isPrevTooltip = store.get("prevId") === id;
+      const instant = store.get("instant") && (open && isCurrentTooltip || isPrevTooltip);
+      return normalize.element({
+        ...parts.content.attrs,
+        dir: prop("dir"),
+        hidden: !open,
+        "data-state": open ? "open" : "closed",
+        "data-instant": dataAttr(instant),
+        role: hasAriaLabel ? void 0 : "tooltip",
+        id: hasAriaLabel ? void 0 : contentId,
+        "data-placement": context.get("currentPlacement"),
+        onPointerEnter() {
+          send({ type: "content.pointer.move" });
+        },
+        onPointerLeave() {
+          send({ type: "content.pointer.leave" });
+        },
+        style: {
+          pointerEvents: prop("interactive") ? "auto" : "none"
+        }
+      });
+    }
+  };
+}
+export {
+  connect
+};

package/dist/node_modules/@zag-js/tooltip/dist/tooltip.dom.js

@@ -0,0 +1,24 @@
+import { isFunction } from "../../utils/dist/guard.js";
+import { queryAll } from "../../dom-query/dist/query.js";
+var getTriggerId = (scope, value) => {
+  const customId = scope.ids?.trigger;
+  if (customId != null) return isFunction(customId) ? customId(value) : customId;
+  return value ? `tooltip:${scope.id}:trigger:${value}` : `tooltip:${scope.id}:trigger`;
+};
+var getContentId = (scope) => scope.ids?.content ?? `tooltip:${scope.id}:content`;
+var getArrowId = (scope) => scope.ids?.arrow ?? `tooltip:${scope.id}:arrow`;
+var getPositionerId = (scope) => scope.ids?.positioner ?? `tooltip:${scope.id}:popper`;
+var getPositionerEl = (scope) => scope.getById(getPositionerId(scope));
+var getTriggerEls = (scope) => queryAll(scope.getDoc(), `[data-scope="tooltip"][data-part="trigger"][data-ownedby="${scope.id}"]`);
+var getActiveTriggerEl = (scope, value) => {
+  return value == null ? getTriggerEls(scope)[0] : scope.getById(getTriggerId(scope, value));
+};
+export {
+  getActiveTriggerEl,
+  getArrowId,
+  getContentId,
+  getPositionerEl,
+  getPositionerId,
+  getTriggerEls,
+  getTriggerId
+};