@manapotion/vue/dist/index.js

// src/Listeners.vue.ts
import { defineComponent as defineComponent12, h } from "vue";

// src/listeners/DeviceTypeListener.vue.ts
import { defineComponent, onMounted, onUnmounted } from "vue";
import { mountDeviceTypeListener } from "@manapotion/core";
var DeviceTypeListener = defineComponent({
  emits: { deviceTypeChange: (payload) => payload },
  setup: (_, { emit }) => {
    onMounted(() => {
      const unsub = mountDeviceTypeListener({
        onDeviceTypeChange: (payload) => emit("deviceTypeChange", payload)
      });
      onUnmounted(unsub);
    });
  },
  render: () => null
});

// src/listeners/FullscreenListener.vue.ts
import { defineComponent as defineComponent2, onMounted as onMounted2, onUnmounted as onUnmounted2 } from "vue";
import { mountFullscreenListener } from "@manapotion/core";
var FullscreenListener = defineComponent2({
  emits: { fullscreenChange: (payload) => payload },
  setup: (_, { emit }) => {
    onMounted2(() => {
      const unsub = mountFullscreenListener({
        onFullscreenChange: (payload) => emit("fullscreenChange", payload)
      });
      onUnmounted2(unsub);
    });
  },
  render: () => null
});

// src/listeners/KeyboardListener.vue.ts
import { defineComponent as defineComponent3, onMounted as onMounted3, onUnmounted as onUnmounted3 } from "vue";
import { mountKeyboardListener } from "@manapotion/core";
var KeyboardListener = defineComponent3({
  emits: {
    keyDown: (payload) => payload,
    keyUp: (payload) => payload
  },
  setup: (_, { emit }) => {
    onMounted3(() => {
      const unsub = mountKeyboardListener({
        onKeyDown: (payload) => emit("keyDown", payload),
        onKeyUp: (payload) => emit("keyUp", payload)
      });
      onUnmounted3(unsub);
    });
  },
  render: () => null
});

// src/listeners/MouseButtonsListener.vue.ts
import { defineComponent as defineComponent4, onMounted as onMounted4, onUnmounted as onUnmounted4 } from "vue";
import { mountMouseButtonsListener } from "@manapotion/core";
var MouseButtonsListener = defineComponent4({
  emits: {
    leftMouseButtonDown: (payload) => payload,
    middleMouseButtonDown: (payload) => payload,
    rightMouseButtonDown: (payload) => payload,
    leftMouseButtonUp: (payload) => payload,
    middleMouseButtonUp: (payload) => payload,
    rightMouseButtonUp: (payload) => payload
  },
  setup: (_, { emit }) => {
    onMounted4(() => {
      const unsub = mountMouseButtonsListener({
        onLeftMouseButtonDown: (payload) => emit("leftMouseButtonDown", payload),
        onMiddleMouseButtonDown: (payload) => emit("middleMouseButtonDown", payload),
        onRightMouseButtonDown: (payload) => emit("rightMouseButtonDown", payload),
        onLeftMouseButtonUp: (payload) => emit("leftMouseButtonUp", payload),
        onMiddleMouseButtonUp: (payload) => emit("middleMouseButtonUp", payload),
        onRightMouseButtonUp: (payload) => emit("rightMouseButtonUp", payload)
      });
      onUnmounted4(unsub);
    });
  },
  render: () => null
});

// src/listeners/MouseMoveListener.vue.ts
import { defineComponent as defineComponent5, onMounted as onMounted5, onUnmounted as onUnmounted5, watch } from "vue";
import { mountMouseMoveListener } from "@manapotion/core";
var MouseMoveListener = defineComponent5({
  // eslint-disable-next-line vue/require-default-prop
  props: { mouseMovementResetDelay: { type: Number } },
  emits: { mouseMove: (payload) => payload },
  setup: (props, { emit }) => {
    onMounted5(() => {
      let unsub = mountMouseMoveListener({
        onMouseMove: (payload) => emit("mouseMove", payload),
        mouseMovementResetDelay: props.mouseMovementResetDelay
      });
      watch(
        () => props.mouseMovementResetDelay,
        (newDelay) => {
          unsub();
          unsub = mountMouseMoveListener({
            onMouseMove: (payload) => emit("mouseMove", payload),
            mouseMovementResetDelay: newDelay
          });
        }
      );
      onUnmounted5(unsub);
    });
  },
  render: () => null
});

// src/listeners/MouseScrollListener.vue.ts
import { defineComponent as defineComponent6, onMounted as onMounted6, onUnmounted as onUnmounted6, watch as watch2 } from "vue";
import { mountMouseScrollListener } from "@manapotion/core";
var MouseScrollListener = defineComponent6({
  // eslint-disable-next-line vue/require-default-prop
  props: { mouseScrollResetDelay: { type: Number } },
  emits: { scroll: (payload) => payload },
  setup: (props, { emit }) => {
    onMounted6(() => {
      let unsub = mountMouseScrollListener({
        onScroll: (payload) => emit("scroll", payload),
        mouseScrollResetDelay: props.mouseScrollResetDelay
      });
      watch2(
        () => props.mouseScrollResetDelay,
        (newDelay) => {
          unsub();
          unsub = mountMouseScrollListener({
            onScroll: (payload) => emit("scroll", payload),
            mouseScrollResetDelay: newDelay
          });
        }
      );
      onUnmounted6(unsub);
    });
  },
  render: () => null
});

// src/listeners/PageFocusListener.vue.ts
import { defineComponent as defineComponent7, onMounted as onMounted7, onUnmounted as onUnmounted7 } from "vue";
import { mountPageFocusListener } from "@manapotion/core";
var PageFocusListener = defineComponent7({
  emits: { pageFocusChange: (payload) => payload },
  setup: (_, { emit }) => {
    onMounted7(() => {
      const unsub = mountPageFocusListener({
        onPageFocusChange: (payload) => emit("pageFocusChange", payload)
      });
      onUnmounted7(unsub);
    });
  },
  render: () => null
});

// src/listeners/PageVisibilityListener.vue.ts
import { defineComponent as defineComponent8, onMounted as onMounted8, onUnmounted as onUnmounted8 } from "vue";
import { mountPageVisibilityListener } from "@manapotion/core";
var PageVisibilityListener = defineComponent8({
  emits: { pageVisibilityChange: (payload) => payload },
  setup: (_, { emit }) => {
    onMounted8(() => {
      const unsub = mountPageVisibilityListener({
        onPageVisibilityChange: (payload) => emit("pageVisibilityChange", payload)
      });
      onUnmounted8(unsub);
    });
  },
  render: () => null
});

// src/listeners/PointerLockListener.vue.ts
import { defineComponent as defineComponent9, onMounted as onMounted9, onUnmounted as onUnmounted9 } from "vue";
import { mountPointerLockListener } from "@manapotion/core";
var PointerLockListener = defineComponent9({
  emits: { pointerLockChange: (payload) => payload },
  setup: (_, { emit }) => {
    onMounted9(() => {
      const unsub = mountPointerLockListener({
        onPointerLockChange: (payload) => emit("pointerLockChange", payload)
      });
      onUnmounted9(unsub);
    });
  },
  render: () => null
});

// src/listeners/ResizeListener.vue.ts
import { defineComponent as defineComponent10, onMounted as onMounted10, onUnmounted as onUnmounted10 } from "vue";
import { mountResizeListener } from "@manapotion/core";
var ResizeListener = defineComponent10({
  emits: { resize: (payload) => payload },
  setup: (_, { emit }) => {
    onMounted10(() => {
      const unsub = mountResizeListener({
        onResize: (payload) => emit("resize", payload)
      });
      onUnmounted10(unsub);
    });
  },
  render: () => null
});

// src/listeners/ScreenOrientationListener.vue.ts
import { defineComponent as defineComponent11, onMounted as onMounted11, onUnmounted as onUnmounted11 } from "vue";
import { mountScreenOrientationListener } from "@manapotion/core";
var ScreenOrientationListener = defineComponent11({
  emits: { screenOrientationChange: (payload) => payload },
  setup: (_, { emit }) => {
    onMounted11(() => {
      const unsub = mountScreenOrientationListener({
        onScreenOrientationChange: (payload) => emit("screenOrientationChange", payload)
      });
      onUnmounted11(unsub);
    });
  },
  render: () => null
});

// src/Listeners.vue.ts
var Listeners = defineComponent12({
  props: {
    // eslint-disable-next-line vue/require-default-prop
    mouseMovementResetDelay: { type: Number },
    // eslint-disable-next-line vue/require-default-prop
    mouseScrollResetDelay: { type: Number }
  },
  emits: {
    mouseMove: (payload) => payload,
    pointerLockChange: (payload) => payload,
    pageVisibilityChange: (payload) => payload,
    fullscreenChange: (payload) => payload,
    deviceTypeChange: (payload) => payload,
    resize: (payload) => payload,
    screenOrientationChange: (payload) => payload,
    pageFocusChange: (payload) => payload,
    scroll: (payload) => payload,
    keyDown: (payload) => payload,
    keyUp: (payload) => payload,
    leftMouseDown: (payload) => payload,
    middleMouseDown: (payload) => payload,
    rightMouseDown: (payload) => payload,
    leftMouseUp: (payload) => payload,
    middleMouseUp: (payload) => payload,
    rightMouseUp: (payload) => payload
  },
  setup: (props, { emit }) => () => [
    h(FullscreenListener, { onFullscreenChange: (payload) => emit("fullscreenChange", payload) }),
    h(PointerLockListener, {
      onPointerLockChange: (payload) => emit("pointerLockChange", payload)
    }),
    h(MouseMoveListener, {
      onMouseMove: (payload) => emit("mouseMove", payload),
      mouseMovementResetDelay: props.mouseMovementResetDelay
    }),
    h(PageVisibilityListener, {
      onPageVisibilityChange: (payload) => emit("pageVisibilityChange", payload)
    }),
    h(PageFocusListener, { onPageFocusChange: (payload) => emit("pageFocusChange", payload) }),
    h(ResizeListener, { onResize: (payload) => emit("resize", payload) }),
    h(DeviceTypeListener, { onDeviceTypeChange: (payload) => emit("deviceTypeChange", payload) }),
    h(ScreenOrientationListener, {
      onScreenOrientationChange: (payload) => emit("screenOrientationChange", payload)
    }),
    h(MouseButtonsListener, {
      onLeftMouseButtonDown: (payload) => emit("leftMouseDown", payload),
      onMiddleMouseButtonDown: (payload) => emit("middleMouseDown", payload),
      onRightMouseButtonDown: (payload) => emit("rightMouseDown", payload),
      onLeftMouseButtonUp: (payload) => emit("leftMouseUp", payload),
      onMiddleMouseButtonUp: (payload) => emit("middleMouseUp", payload),
      onRightMouseButtonUp: (payload) => emit("rightMouseUp", payload)
    }),
    h(KeyboardListener, {
      onKeyDown: (payload) => emit("keyDown", payload),
      onKeyUp: (payload) => emit("keyUp", payload)
    }),
    h(MouseScrollListener, {
      onScroll: (payload) => emit("scroll", payload),
      mouseScrollResetDelay: props.mouseScrollResetDelay
    })
  ]
});

// src/vue-store.ts
import { reactive } from "vue";
import { browserStore, joysticksStore, keyboardStore, mouseStore } from "@manapotion/core";
var browser = reactive(browserStore.getInitialState());
browserStore.subscribe((state) => Object.assign(browser, state));
var mouse = reactive(mouseStore.getInitialState());
mouseStore.subscribe((state) => Object.assign(mouse, state));
var keyboard = reactive(keyboardStore.getInitialState());
keyboardStore.subscribe((state) => Object.assign(keyboard, state));
var joysticks = reactive(joysticksStore.getInitialState());
joysticksStore.subscribe((state) => Object.assign(joysticks, state));

// src/vue-loops.ts
import { onMounted as onMounted12, onUnmounted as onUnmounted12 } from "vue";
import { addMainLoopEffect } from "@manapotion/core";
var useMainLoop = (callback, options) => {
  onMounted12(() => {
    const unsub = addMainLoopEffect(callback, options);
    onUnmounted12(unsub);
  });
};

// src/JoystickArea.vue.ts
import { defineComponent as defineComponent13, h as h2, onMounted as onMounted13, onUnmounted as onUnmounted13, ref, watch as watch3 } from "vue";
import { mountJoystickArea } from "@manapotion/core";
var JoystickArea = defineComponent13({
  name: "JoystickArea",
  props: {
    mode: {
      type: String,
      default: "follow"
    },
    joystick: {
      type: Object,
      required: true
    },
    // eslint-disable-next-line vue/require-default-prop
    maxFollowDistance: { type: Number },
    // eslint-disable-next-line vue/require-default-prop
    maxOriginDistance: { type: Number },
    // eslint-disable-next-line vue/require-default-prop
    onEnd: { type: Function },
    // eslint-disable-next-line vue/require-default-prop
    onMove: { type: Function },
    // eslint-disable-next-line vue/require-default-prop
    onStart: { type: Function },
    // eslint-disable-next-line vue/require-default-prop
    containerProps: { type: Object }
  },
  setup(props, { slots, attrs }) {
    const localRef = ref(null);
    onMounted13(() => {
      let unsub = mountJoystickArea({
        mode: props.mode,
        joystick: props.joystick,
        maxFollowDistance: props.maxFollowDistance,
        maxOriginDistance: props.maxOriginDistance,
        onEnd: props.onEnd,
        onMove: props.onMove,
        onStart: props.onStart,
        element: localRef.value
      });
      watch3(
        () => props.mode,
        (newMode) => {
          unsub();
          unsub = mountJoystickArea({
            mode: newMode,
            joystick: props.joystick,
            maxFollowDistance: props.maxFollowDistance,
            maxOriginDistance: props.maxOriginDistance,
            onEnd: props.onEnd,
            onMove: props.onMove,
            onStart: props.onStart,
            element: localRef.value
          });
        }
      );
      onUnmounted13(() => {
        unsub();
      });
    });
    return () => h2(
      "div",
      {
        ...props.containerProps,
        ref: localRef,
        ...attrs
      },
      slots.default ? slots.default() : []
    );
  }
});

// src/index.ts
export * from "@manapotion/core";
export {
  DeviceTypeListener,
  FullscreenListener,
  JoystickArea,
  KeyboardListener,
  Listeners,
  MouseButtonsListener,
  MouseMoveListener,
  MouseScrollListener,
  PageFocusListener,
  PageVisibilityListener,
  PointerLockListener,
  ResizeListener,
  ScreenOrientationListener,
  browser,
  joysticks,
  keyboard,
  mouse,
  useMainLoop
};