@blogmcp/mdx-render-vue 0.1.0

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

@@ -0,0 +1,258 @@
+import { computed, toValue, onMounted, onBeforeUnmount, nextTick } from "vue";
+import { bindable } from "./bindable.js";
+import { useRefs } from "./refs.js";
+import { useTrack } from "./track.js";
+import { createScope } from "../../core/dist/scope.js";
+import { MachineStatus, INIT_STATE } from "../../core/dist/types.js";
+import { findTransition, resolveStateValue, getExitEnterStates, hasTag, matchesState } from "../../core/dist/state.js";
+import { compact } from "../../utils/dist/object.js";
+import { ensure, warn } from "../../utils/dist/warning.js";
+import { isFunction, isString } from "../../utils/dist/guard.js";
+import { toArray } from "../../utils/dist/array.js";
+function useMachine(machine, userProps = {}) {
+  const scope = computed(() => {
+    const { id, ids, getRootNode } = toValue(userProps);
+    return createScope({ id, ids, getRootNode });
+  });
+  const debug = (...args) => {
+    if (machine.debug) console.log(...args);
+  };
+  const props = computed(
+    () => machine.props?.({
+      props: compact(toValue(userProps)),
+      get scope() {
+        return scope.value;
+      }
+    }) ?? toValue(userProps)
+  );
+  const prop = useProp(props);
+  const context = machine.context?.({
+    prop,
+    bindable,
+    get scope() {
+      return scope.value;
+    },
+    flush,
+    getContext() {
+      return ctx;
+    },
+    getComputed() {
+      return computed$1;
+    },
+    getRefs() {
+      return refs;
+    },
+    getEvent() {
+      return getEvent();
+    }
+  });
+  const ctx = {
+    get(key) {
+      return context[key]?.get();
+    },
+    set(key, value) {
+      context[key]?.set(value);
+    },
+    initial(key) {
+      return context[key]?.initial;
+    },
+    hash(key) {
+      const current = context[key]?.get();
+      return context[key]?.hash(current);
+    }
+  };
+  let effects = /* @__PURE__ */ new Map();
+  let transitionRef = null;
+  let previousEventRef = { current: null };
+  let eventRef = { current: { type: "" } };
+  const getEvent = () => ({
+    ...eventRef.current,
+    current() {
+      return eventRef.current;
+    },
+    previous() {
+      return previousEventRef.current;
+    }
+  });
+  const getState = () => ({
+    ...state,
+    matches(...values) {
+      const currentState = state.get();
+      return values.some((value) => matchesState(currentState, value));
+    },
+    hasTag(tag) {
+      const currentState = state.get();
+      return hasTag(machine, currentState, tag);
+    }
+  });
+  const refs = useRefs(machine.refs?.({ prop, context: ctx }) ?? {});
+  const getParams = () => ({
+    state: getState(),
+    context: ctx,
+    event: getEvent(),
+    prop,
+    send,
+    action,
+    guard,
+    track: useTrack,
+    refs,
+    computed: computed$1,
+    flush,
+    get scope() {
+      return scope.value;
+    },
+    choose
+  });
+  const action = (keys) => {
+    const strs = isFunction(keys) ? keys(getParams()) : keys;
+    if (!strs) return;
+    const fns = strs.map((s) => {
+      const fn = machine.implementations?.actions?.[s];
+      if (!fn) warn(`[zag-js] No implementation found for action "${JSON.stringify(s)}"`);
+      return fn;
+    });
+    for (const fn of fns) {
+      fn?.(getParams());
+    }
+  };
+  const guard = (str) => {
+    if (isFunction(str)) return str(getParams());
+    return machine.implementations?.guards?.[str](getParams());
+  };
+  const effect = (keys) => {
+    const strs = isFunction(keys) ? keys(getParams()) : keys;
+    if (!strs) return;
+    const fns = strs.map((s) => {
+      const fn = machine.implementations?.effects?.[s];
+      if (!fn) warn(`[zag-js] No implementation found for effect "${JSON.stringify(s)}"`);
+      return fn;
+    });
+    const cleanups = [];
+    for (const fn of fns) {
+      const cleanup = fn?.(getParams());
+      if (cleanup) cleanups.push(cleanup);
+    }
+    return () => cleanups.forEach((fn) => fn?.());
+  };
+  const choose = (transitions) => {
+    return toArray(transitions).find((t) => {
+      let result = !t.guard;
+      if (isString(t.guard)) result = !!guard(t.guard);
+      else if (isFunction(t.guard)) result = t.guard(getParams());
+      return result;
+    });
+  };
+  const computed$1 = (key) => {
+    ensure(machine.computed, () => `[zag-js] No computed object found on machine`);
+    const fn = machine.computed[key];
+    return fn({
+      context: ctx,
+      event: getEvent(),
+      prop,
+      refs,
+      get scope() {
+        return scope.value;
+      },
+      computed: computed$1
+    });
+  };
+  const state = bindable(() => ({
+    defaultValue: resolveStateValue(machine, machine.initialState({ prop })),
+    onChange(nextState, prevState) {
+      const { exiting, entering } = getExitEnterStates(machine, prevState, nextState, transitionRef?.reenter);
+      exiting.forEach((item) => {
+        const exitEffects = effects.get(item.path);
+        exitEffects?.();
+        effects.delete(item.path);
+      });
+      exiting.forEach((item) => {
+        action(item.state?.exit);
+      });
+      action(transitionRef?.actions);
+      entering.forEach((item) => {
+        const cleanup = effect(item.state?.effects);
+        if (cleanup) effects.set(item.path, cleanup);
+      });
+      if (prevState === INIT_STATE) {
+        action(machine.entry);
+        const cleanup = effect(machine.effects);
+        if (cleanup) effects.set(INIT_STATE, cleanup);
+      }
+      entering.forEach((item) => {
+        action(item.state?.entry);
+      });
+    }
+  }));
+  let status = MachineStatus.NotStarted;
+  let pendingEvents = [];
+  onMounted(() => {
+    const started = status === MachineStatus.Started;
+    status = MachineStatus.Started;
+    debug(started ? "rehydrating..." : "initializing...");
+    state.invoke(state.initial, INIT_STATE);
+    const events = pendingEvents;
+    pendingEvents = [];
+    for (const event of events) {
+      send(event);
+    }
+  });
+  onBeforeUnmount(() => {
+    status = MachineStatus.Stopped;
+    pendingEvents = [];
+    debug("unmounting...");
+    const fns = effects.values();
+    for (const fn of fns) fn?.();
+    effects = /* @__PURE__ */ new Map();
+    action(machine.exit);
+  });
+  const send = (event) => {
+    if (status !== MachineStatus.Started) {
+      pendingEvents.push(event);
+      return;
+    }
+    previousEventRef.current = eventRef.current;
+    eventRef.current = event;
+    let currentState = state.get();
+    const { transitions, source } = findTransition(machine, currentState, event.type);
+    const transition = choose(transitions);
+    if (!transition) return;
+    transitionRef = transition;
+    const target = resolveStateValue(machine, transition.target ?? currentState, source);
+    debug("transition", event.type, transition.target || currentState, `(${transition.actions})`);
+    const changed = target !== currentState;
+    if (changed) {
+      state.set(target);
+    } else if (transition.reenter) {
+      state.invoke(currentState, currentState);
+    } else {
+      action(transition.actions);
+    }
+  };
+  machine.watch?.(getParams());
+  return {
+    state: getState(),
+    send,
+    context: ctx,
+    prop,
+    get scope() {
+      return scope.value;
+    },
+    refs,
+    computed: computed$1,
+    event: getEvent(),
+    getStatus: () => status
+  };
+}
+function useProp(valueRef) {
+  return function get(key) {
+    return valueRef.value[key];
+  };
+}
+var flush = (fn) => {
+  nextTick().then(() => {
+    fn();
+  });
+};
+export {
+  useMachine
+};

package/dist/node_modules/@zag-js/vue/dist/normalize-props.js

@@ -0,0 +1,42 @@
+import { createNormalizer } from "../../types/dist/prop-types.js";
+function toCase(txt) {
+  return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+}
+var propMap = {
+  htmlFor: "for",
+  className: "class",
+  onDoubleClick: "onDblclick",
+  onChange: "onInput",
+  onFocus: "onFocusin",
+  onBlur: "onFocusout",
+  defaultValue: "value",
+  defaultChecked: "checked"
+};
+var preserveKeys = "viewBox,className,preserveAspectRatio,fillRule,clipPath,clipRule,strokeWidth,strokeLinecap,strokeLinejoin,strokeDasharray,strokeDashoffset,strokeMiterlimit".split(
+  ","
+);
+function toVueProp(prop) {
+  if (prop in propMap) return propMap[prop];
+  if (prop.startsWith("on")) return `on${toCase(prop.substr(2))}`;
+  if (preserveKeys.includes(prop)) return prop;
+  return prop.toLowerCase();
+}
+var normalizeProps = createNormalizer((props) => {
+  const normalized = {};
+  for (const key in props) {
+    const value = props[key];
+    if (key === "children") {
+      if (typeof value === "string") {
+        normalized["innerHTML"] = value;
+      } else if (process.env.NODE_ENV !== "production" && value != null) {
+        console.warn("[Vue Normalize Prop] : avoid passing non-primitive value as `children`");
+      }
+    } else {
+      normalized[toVueProp(key)] = props[key];
+    }
+  }
+  return normalized;
+});
+export {
+  normalizeProps
+};

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

@@ -0,0 +1,14 @@
+function useRefs(refs) {
+  const ref = { current: refs };
+  return {
+    get(key) {
+      return ref.current[key];
+    },
+    set(key, value) {
+      ref.current[key] = value;
+    }
+  };
+}
+export {
+  useRefs
+};

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

@@ -0,0 +1,22 @@
+import { watch, toValue } from "vue";
+import { isEqual } from "../../utils/dist/equal.js";
+var useTrack = (deps, effect) => {
+  watch(
+    () => [...deps.map((d) => d())],
+    (current, previous) => {
+      let changed = false;
+      for (let i = 0; i < current.length; i++) {
+        if (!isEqual(previous[i], toValue(current[i]))) {
+          changed = true;
+          break;
+        }
+      }
+      if (changed) {
+        effect();
+      }
+    }
+  );
+};
+export {
+  useTrack
+};