@blogmcp/mdx-render-vue 0.1.0

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

@@ -0,0 +1,416 @@
+import { trackFocusVisible } from "../../focus-visible/dist/index.js";
+import { getPlacement } from "../../popper/dist/get-placement.js";
+import { getActiveTriggerEl, getPositionerEl } from "./tooltip.dom.js";
+import { store } from "./tooltip.store.js";
+import { getOverflowAncestors } from "../../dom-query/dist/overflow.js";
+import { createMachine, createGuards } from "../../core/dist/create-machine.js";
+import { addDomEvent, isComposingEvent } from "../../dom-query/dist/event.js";
+import { ensureProps } from "../../utils/dist/warning.js";
+var { and, not } = createGuards();
+var machine = createMachine({
+  initialState: ({ prop }) => {
+    const open = prop("open") || prop("defaultOpen");
+    return open ? "open" : "closed";
+  },
+  props({ props }) {
+    ensureProps(props, ["id"]);
+    const closeOnClick = props.closeOnClick ?? true;
+    const closeOnPointerDown = props.closeOnPointerDown ?? closeOnClick;
+    return {
+      openDelay: 400,
+      closeDelay: 150,
+      closeOnEscape: true,
+      interactive: false,
+      closeOnScroll: true,
+      disabled: false,
+      ...props,
+      closeOnPointerDown,
+      closeOnClick,
+      positioning: {
+        placement: "bottom",
+        ...props.positioning
+      }
+    };
+  },
+  effects: ["trackFocusVisible", "trackStore"],
+  context: ({ bindable, prop, scope }) => ({
+    currentPlacement: bindable(() => ({ defaultValue: void 0 })),
+    hasPointerMoveOpened: bindable(() => ({ defaultValue: null })),
+    triggerValue: bindable(() => ({
+      defaultValue: prop("defaultTriggerValue") ?? null,
+      value: prop("triggerValue"),
+      onChange(value) {
+        const onTriggerValueChange = prop("onTriggerValueChange");
+        if (!onTriggerValueChange) return;
+        const triggerElement = getActiveTriggerEl(scope, value);
+        onTriggerValueChange({ value, triggerElement });
+      }
+    }))
+  }),
+  watch({ track, action, prop }) {
+    track([() => prop("disabled")], () => {
+      action(["closeIfDisabled"]);
+    });
+    track([() => prop("open")], () => {
+      action(["toggleVisibility"]);
+    });
+    track([() => prop("triggerValue")], () => {
+      action(["repositionImmediate"]);
+    });
+  },
+  on: {
+    "triggerValue.set": {
+      actions: ["setTriggerValue", "repositionImmediate"]
+    }
+  },
+  states: {
+    closed: {
+      entry: ["clearGlobalId"],
+      on: {
+        "controlled.open": {
+          target: "open"
+        },
+        open: [
+          {
+            guard: "isOpenControlled",
+            actions: ["setTriggerValue", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setTriggerValue", "invokeOnOpen"]
+          }
+        ],
+        "pointer.leave": {
+          actions: ["clearPointerMoveOpened"]
+        },
+        "pointer.move": [
+          {
+            guard: and("noVisibleTooltip", not("hasPointerMoveOpened")),
+            target: "opening",
+            actions: ["setTriggerValue"]
+          },
+          {
+            guard: not("hasPointerMoveOpened"),
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen", "setTriggerValue"]
+          }
+        ]
+      }
+    },
+    opening: {
+      effects: ["trackScroll", "trackPointerlockChange", "waitForOpenDelay"],
+      on: {
+        "after.openDelay": [
+          {
+            guard: "isOpenControlled",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setPointerMoveOpened", "invokeOnOpen"]
+          }
+        ],
+        "controlled.open": {
+          target: "open"
+        },
+        "controlled.close": {
+          target: "closed"
+        },
+        open: [
+          {
+            guard: "isOpenControlled",
+            actions: ["setTriggerValue", "invokeOnOpen"]
+          },
+          {
+            target: "open",
+            actions: ["setTriggerValue", "invokeOnOpen"]
+          }
+        ],
+        "pointer.leave": [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["clearPointerMoveOpened", "invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          }
+        ],
+        close: [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["invokeOnClose", "toggleVisibility"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ]
+      }
+    },
+    open: {
+      effects: ["trackEscapeKey", "trackScroll", "trackPointerlockChange", "trackPositioning"],
+      entry: ["setGlobalId"],
+      on: {
+        "controlled.close": {
+          target: "closed"
+        },
+        close: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "pointer.leave": [
+          {
+            guard: "isVisible",
+            target: "closing",
+            actions: ["clearPointerMoveOpened"]
+          },
+          // == group ==
+          {
+            guard: "isOpenControlled",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["clearPointerMoveOpened", "invokeOnClose"]
+          }
+        ],
+        "content.pointer.leave": {
+          guard: "isInteractive",
+          target: "closing"
+        },
+        "positioning.set": {
+          actions: ["reposition"]
+        },
+        "triggerValue.set": {
+          // Transition to closing (which cleans up trackPositioning) then immediately back to open
+          // This re-creates the positioning effect with the new trigger
+          target: "closing",
+          actions: ["setTriggerValue", "immediateReopen"]
+        }
+      }
+    },
+    closing: {
+      effects: ["trackPositioning", "waitForCloseDelay"],
+      on: {
+        "after.closeDelay": [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "controlled.close": {
+          target: "closed"
+        },
+        "controlled.open": {
+          target: "open"
+        },
+        close: [
+          {
+            guard: "isOpenControlled",
+            actions: ["invokeOnClose"]
+          },
+          {
+            target: "closed",
+            actions: ["invokeOnClose"]
+          }
+        ],
+        "pointer.move": [
+          {
+            guard: "isOpenControlled",
+            // We trigger toggleVisibility manually since the `ctx.open` has not changed yet (at this point)
+            actions: ["setPointerMoveOpened", "setTriggerValue", "invokeOnOpen", "toggleVisibility"]
+          },
+          {
+            target: "open",
+            actions: ["setPointerMoveOpened", "setTriggerValue", "invokeOnOpen"]
+          }
+        ],
+        "triggerValue.set": {
+          target: "open",
+          actions: ["setTriggerValue", "repositionImmediate"]
+        },
+        reopen: {
+          target: "open"
+        },
+        "content.pointer.move": {
+          guard: "isInteractive",
+          target: "open"
+        },
+        "positioning.set": {
+          actions: ["reposition"]
+        }
+      }
+    }
+  },
+  implementations: {
+    guards: {
+      noVisibleTooltip: () => store.get("id") === null,
+      isVisible: ({ prop }) => prop("id") === store.get("id"),
+      isInteractive: ({ prop }) => !!prop("interactive"),
+      hasPointerMoveOpened: ({ context }) => !!context.get("hasPointerMoveOpened"),
+      isOpenControlled: ({ prop }) => prop("open") !== void 0
+    },
+    actions: {
+      setGlobalId: ({ prop }) => {
+        const prevId = store.get("id");
+        const isInstant = prevId !== null && prevId !== prop("id");
+        store.update({ id: prop("id"), prevId: isInstant ? prevId : null, instant: isInstant });
+      },
+      clearGlobalId: ({ prop }) => {
+        if (prop("id") === store.get("id")) {
+          store.update({ id: null, prevId: null, instant: false });
+        }
+      },
+      invokeOnOpen: ({ prop }) => {
+        prop("onOpenChange")?.({ open: true });
+      },
+      invokeOnClose: ({ prop }) => {
+        prop("onOpenChange")?.({ open: false });
+      },
+      closeIfDisabled: ({ prop, send }) => {
+        if (!prop("disabled")) return;
+        send({ type: "close", src: "disabled.change" });
+      },
+      reposition: ({ context, event, prop, scope }) => {
+        if (event.type !== "positioning.set") return;
+        const getPositionerEl2 = () => getPositionerEl(scope);
+        const getTriggerEl = () => getActiveTriggerEl(scope, context.get("triggerValue"));
+        getPlacement(getTriggerEl, getPositionerEl2, {
+          ...prop("positioning"),
+          ...event.options,
+          listeners: false,
+          onComplete(data) {
+            context.set("currentPlacement", data.placement);
+          }
+        });
+      },
+      repositionImmediate: ({ context, event, prop, scope }) => {
+        const triggerValue = event.value ?? context.get("triggerValue");
+        const getPositionerEl2 = () => getPositionerEl(scope);
+        const getTriggerEl = () => getActiveTriggerEl(scope, triggerValue);
+        return getPlacement(getTriggerEl, getPositionerEl2, {
+          ...prop("positioning"),
+          onComplete(data) {
+            context.set("currentPlacement", data.placement);
+          }
+        });
+      },
+      toggleVisibility: ({ prop, event, send }) => {
+        queueMicrotask(() => {
+          send({
+            type: prop("open") ? "controlled.open" : "controlled.close",
+            previousEvent: event
+          });
+        });
+      },
+      setPointerMoveOpened: ({ context, event }) => {
+        const triggerId = event.triggerId ?? event.previousEvent?.triggerId;
+        context.set("hasPointerMoveOpened", triggerId ?? null);
+      },
+      clearPointerMoveOpened: ({ context }) => {
+        context.set("hasPointerMoveOpened", null);
+      },
+      setTriggerValue: ({ context, event }) => {
+        if (event.value === void 0) return;
+        context.set("triggerValue", event.value);
+      },
+      immediateReopen: ({ send }) => {
+        queueMicrotask(() => {
+          send({ type: "reopen" });
+        });
+      }
+    },
+    effects: {
+      trackFocusVisible: ({ scope }) => {
+        return trackFocusVisible({ root: scope.getRootNode?.() });
+      },
+      trackPositioning: ({ context, prop, scope }) => {
+        if (!context.get("currentPlacement")) {
+          context.set("currentPlacement", prop("positioning").placement);
+        }
+        const getPositionerEl2 = () => getPositionerEl(scope);
+        const getTriggerEl = () => getActiveTriggerEl(scope, context.get("triggerValue"));
+        return getPlacement(getTriggerEl, getPositionerEl2, {
+          ...prop("positioning"),
+          defer: true,
+          onComplete(data) {
+            context.set("currentPlacement", data.placement);
+          }
+        });
+      },
+      trackPointerlockChange: ({ send, scope }) => {
+        const doc = scope.getDoc();
+        const onChange = () => send({ type: "close", src: "pointerlock:change" });
+        return addDomEvent(doc, "pointerlockchange", onChange, false);
+      },
+      trackScroll: ({ send, prop, scope, context }) => {
+        if (!prop("closeOnScroll")) return;
+        const triggerValue = context.get("triggerValue");
+        const triggerEl = getActiveTriggerEl(scope, triggerValue);
+        if (!triggerEl) return;
+        const overflowParents = getOverflowAncestors(triggerEl);
+        const cleanups = overflowParents.map((overflowParent) => {
+          const onScroll = () => {
+            send({ type: "close", src: "scroll" });
+          };
+          return addDomEvent(overflowParent, "scroll", onScroll, {
+            passive: true,
+            capture: true
+          });
+        });
+        return () => {
+          cleanups.forEach((fn) => fn?.());
+        };
+      },
+      trackStore: ({ prop, send }) => {
+        let cleanup;
+        queueMicrotask(() => {
+          cleanup = store.subscribe(() => {
+            if (store.get("id") !== prop("id")) {
+              send({ type: "close", src: "id.change" });
+            }
+          });
+        });
+        return () => cleanup?.();
+      },
+      trackEscapeKey: ({ send, prop }) => {
+        if (!prop("closeOnEscape")) return;
+        const onKeyDown = (event) => {
+          if (isComposingEvent(event)) return;
+          if (event.key !== "Escape") return;
+          event.stopPropagation();
+          send({ type: "close", src: "keydown.escape" });
+        };
+        return addDomEvent(document, "keydown", onKeyDown, true);
+      },
+      waitForOpenDelay: ({ send, prop, event }) => {
+        const id = setTimeout(() => {
+          send({ type: "after.openDelay", previousEvent: event });
+        }, prop("openDelay"));
+        return () => clearTimeout(id);
+      },
+      waitForCloseDelay: ({ send, prop, event }) => {
+        const id = setTimeout(() => {
+          send({ type: "after.closeDelay", previousEvent: event });
+        }, prop("closeDelay"));
+        return () => clearTimeout(id);
+      }
+    }
+  }
+});
+export {
+  machine
+};

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

@@ -0,0 +1,9 @@
+import { createStore } from "../../utils/dist/store.js";
+var store = createStore({
+  id: null,
+  prevId: null,
+  instant: false
+});
+export {
+  store
+};

package/dist/node_modules/@zag-js/types/dist/prop-types.js

@@ -0,0 +1,14 @@
+function createNormalizer(fn) {
+  return new Proxy({}, {
+    get(_target, key) {
+      if (key === "style")
+        return (props) => {
+          return fn({ style: props }).style;
+        };
+      return fn;
+    }
+  });
+}
+export {
+  createNormalizer
+};

package/dist/node_modules/@zag-js/utils/dist/array.js

@@ -0,0 +1,7 @@
+function toArray(v) {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+export {
+  toArray
+};

package/dist/node_modules/@zag-js/utils/dist/equal.js

@@ -0,0 +1,36 @@
+var isArrayLike = (value) => value?.constructor.name === "Array";
+var isArrayEqual = (a, b) => {
+  if (a.length !== b.length) return false;
+  for (let i = 0; i < a.length; i++) {
+    if (!isEqual(a[i], b[i])) return false;
+  }
+  return true;
+};
+var isEqual = (a, b) => {
+  if (Object.is(a, b)) return true;
+  if (a == null && b != null || a != null && b == null) return false;
+  if (typeof a?.isEqual === "function" && typeof b?.isEqual === "function") {
+    return a.isEqual(b);
+  }
+  if (typeof a === "function" && typeof b === "function") {
+    return a.toString() === b.toString();
+  }
+  if (isArrayLike(a) && isArrayLike(b)) {
+    return isArrayEqual(Array.from(a), Array.from(b));
+  }
+  if (!(typeof a === "object") || !(typeof b === "object")) return false;
+  const keys = Object.keys(b ?? /* @__PURE__ */ Object.create(null));
+  const length = keys.length;
+  for (let i = 0; i < length; i++) {
+    const hasKey = Reflect.has(a, keys[i]);
+    if (!hasKey) return false;
+  }
+  for (let i = 0; i < length; i++) {
+    const key = keys[i];
+    if (!isEqual(a[key], b[key])) return false;
+  }
+  return true;
+};
+export {
+  isEqual
+};

package/dist/node_modules/@zag-js/utils/dist/functions.js

@@ -0,0 +1,11 @@
+var noop = () => {
+};
+var callAll = (...fns) => (...a) => {
+  fns.forEach(function(fn) {
+    fn?.(...a);
+  });
+};
+export {
+  callAll,
+  noop
+};

package/dist/node_modules/@zag-js/utils/dist/guard.js

@@ -0,0 +1,26 @@
+var isObjectLike = (v) => v != null && typeof v === "object";
+var isString = (v) => typeof v === "string";
+var isFunction = (v) => typeof v === "function";
+var isNull = (v) => v == null;
+var hasProp = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop);
+var baseGetTag = (v) => Object.prototype.toString.call(v);
+var fnToString = Function.prototype.toString;
+var objectCtorString = fnToString.call(Object);
+var isPlainObject = (v) => {
+  if (!isObjectLike(v) || baseGetTag(v) != "[object Object]" || isFrameworkElement(v)) return false;
+  const proto = Object.getPrototypeOf(v);
+  if (proto === null) return true;
+  const Ctor = hasProp(proto, "constructor") && proto.constructor;
+  return typeof Ctor == "function" && Ctor instanceof Ctor && fnToString.call(Ctor) == objectCtorString;
+};
+var isReactElement = (x) => typeof x === "object" && x !== null && "$$typeof" in x && "props" in x;
+var isVueElement = (x) => typeof x === "object" && x !== null && "__v_isVNode" in x;
+var isFrameworkElement = (x) => isReactElement(x) || isVueElement(x);
+export {
+  hasProp,
+  isFunction,
+  isNull,
+  isObjectLike,
+  isPlainObject,
+  isString
+};

package/dist/node_modules/@zag-js/utils/dist/object.js

@@ -0,0 +1,16 @@
+import { isPlainObject } from "./guard.js";
+function compact(obj) {
+  if (!isPlainObject(obj) || obj === void 0) return obj;
+  const keys = Reflect.ownKeys(obj).filter((key) => typeof key === "string");
+  const filtered = {};
+  for (const key of keys) {
+    const value = obj[key];
+    if (value !== void 0) {
+      filtered[key] = compact(value);
+    }
+  }
+  return filtered;
+}
+export {
+  compact
+};

package/dist/node_modules/@zag-js/utils/dist/store.js

@@ -0,0 +1,44 @@
+function createStore(initialState, compare = Object.is) {
+  let state = { ...initialState };
+  const listeners = /* @__PURE__ */ new Set();
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const publish = () => {
+    listeners.forEach((listener) => listener());
+  };
+  const get = (key) => {
+    return state[key];
+  };
+  const set = (key, value) => {
+    if (!compare(state[key], value)) {
+      state[key] = value;
+      publish();
+    }
+  };
+  const update = (updates) => {
+    let hasChanges = false;
+    for (const key in updates) {
+      const value = updates[key];
+      if (value !== void 0 && !compare(state[key], value)) {
+        state[key] = value;
+        hasChanges = true;
+      }
+    }
+    if (hasChanges) {
+      publish();
+    }
+  };
+  const snapshot = () => ({ ...state });
+  return {
+    subscribe,
+    get,
+    set,
+    update,
+    snapshot
+  };
+}
+export {
+  createStore
+};

package/dist/node_modules/@zag-js/utils/dist/warning.js

@@ -0,0 +1,31 @@
+function warn(...a) {
+  const m = a.length === 1 ? a[0] : a[1];
+  const c = a.length === 2 ? a[0] : true;
+  if (c && process.env.NODE_ENV !== "production") {
+    console.warn(m);
+  }
+}
+function invariant(...a) {
+  const m = a.length === 1 ? a[0] : a[1];
+  const c = a.length === 2 ? a[0] : true;
+  if (c && process.env.NODE_ENV !== "production") {
+    throw new Error(m);
+  }
+}
+function ensure(c, m) {
+  if (c == null) throw new Error(m());
+}
+function ensureProps(props, keys, scope) {
+  let missingKeys = [];
+  for (const key of keys) {
+    if (props[key] == null) missingKeys.push(key);
+  }
+  if (missingKeys.length > 0)
+    throw new Error(`[zag-js${""}] missing required props: ${missingKeys.join(", ")}`);
+}
+export {
+  ensure,
+  ensureProps,
+  invariant,
+  warn
+};

package/dist/node_modules/@zag-js/vue/dist/bindable.js

@@ -0,0 +1,48 @@
+import { shallowRef, computed, onUnmounted } from "vue";
+import { isFunction } from "../../utils/dist/guard.js";
+function bindable(props) {
+  const initial = props().defaultValue ?? props().value;
+  const eq = props().isEqual ?? Object.is;
+  const v = shallowRef(initial);
+  const controlled = computed(() => props().value !== void 0);
+  const valueRef = shallowRef(controlled.value ? props().value : v.value);
+  return {
+    initial,
+    ref: valueRef,
+    get() {
+      return controlled.value ? props().value : v.value;
+    },
+    set(val) {
+      const prev = controlled.value ? props().value : v.value;
+      const next = isFunction(val) ? val(prev) : val;
+      if (props().debug) {
+        console.log(`[bindable > ${props().debug}] setValue`, { next, prev });
+      }
+      if (!controlled.value) v.value = next;
+      if (!eq(next, prev)) {
+        props().onChange?.(next, prev);
+      }
+    },
+    invoke(nextValue, prevValue) {
+      props().onChange?.(nextValue, prevValue);
+    },
+    hash(value) {
+      return props().hash?.(value) ?? String(value);
+    }
+  };
+}
+bindable.cleanup = (fn) => {
+  onUnmounted(() => fn());
+};
+bindable.ref = (defaultValue) => {
+  let value = defaultValue;
+  return {
+    get: () => value,
+    set: (next) => {
+      value = next;
+    }
+  };
+};
+export {
+  bindable
+};