@manapotion/vue/dist/index.cjs

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  DeviceTypeListener: () => DeviceTypeListener,
  FullscreenListener: () => FullscreenListener,
  JoystickArea: () => JoystickArea,
  KeyboardListener: () => KeyboardListener,
  Listeners: () => Listeners,
  MouseButtonsListener: () => MouseButtonsListener,
  MouseMoveListener: () => MouseMoveListener,
  MouseScrollListener: () => MouseScrollListener,
  PageFocusListener: () => PageFocusListener,
  PageVisibilityListener: () => PageVisibilityListener,
  PointerLockListener: () => PointerLockListener,
  ResizeListener: () => ResizeListener,
  ScreenOrientationListener: () => ScreenOrientationListener,
  browser: () => browser,
  joysticks: () => joysticks,
  keyboard: () => keyboard,
  mouse: () => mouse,
  useMainLoop: () => useMainLoop
});
module.exports = __toCommonJS(src_exports);

// src/Listeners.vue.ts
var import_vue12 = require("vue");

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

// src/listeners/FullscreenListener.vue.ts
var import_vue2 = require("vue");
var import_core2 = require("@manapotion/core");
var FullscreenListener = (0, import_vue2.defineComponent)({
  emits: { fullscreenChange: (payload) => payload },
  setup: (_, { emit }) => {
    (0, import_vue2.onMounted)(() => {
      const unsub = (0, import_core2.mountFullscreenListener)({
        onFullscreenChange: (payload) => emit("fullscreenChange", payload)
      });
      (0, import_vue2.onUnmounted)(unsub);
    });
  },
  render: () => null
});

// src/listeners/KeyboardListener.vue.ts
var import_vue3 = require("vue");
var import_core3 = require("@manapotion/core");
var KeyboardListener = (0, import_vue3.defineComponent)({
  emits: {
    keyDown: (payload) => payload,
    keyUp: (payload) => payload
  },
  setup: (_, { emit }) => {
    (0, import_vue3.onMounted)(() => {
      const unsub = (0, import_core3.mountKeyboardListener)({
        onKeyDown: (payload) => emit("keyDown", payload),
        onKeyUp: (payload) => emit("keyUp", payload)
      });
      (0, import_vue3.onUnmounted)(unsub);
    });
  },
  render: () => null
});

// src/listeners/MouseButtonsListener.vue.ts
var import_vue4 = require("vue");
var import_core4 = require("@manapotion/core");
var MouseButtonsListener = (0, import_vue4.defineComponent)({
  emits: {
    leftMouseButtonDown: (payload) => payload,
    middleMouseButtonDown: (payload) => payload,
    rightMouseButtonDown: (payload) => payload,
    leftMouseButtonUp: (payload) => payload,
    middleMouseButtonUp: (payload) => payload,
    rightMouseButtonUp: (payload) => payload
  },
  setup: (_, { emit }) => {
    (0, import_vue4.onMounted)(() => {
      const unsub = (0, import_core4.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)
      });
      (0, import_vue4.onUnmounted)(unsub);
    });
  },
  render: () => null
});

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

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

// src/listeners/PageFocusListener.vue.ts
var import_vue7 = require("vue");
var import_core7 = require("@manapotion/core");
var PageFocusListener = (0, import_vue7.defineComponent)({
  emits: { pageFocusChange: (payload) => payload },
  setup: (_, { emit }) => {
    (0, import_vue7.onMounted)(() => {
      const unsub = (0, import_core7.mountPageFocusListener)({
        onPageFocusChange: (payload) => emit("pageFocusChange", payload)
      });
      (0, import_vue7.onUnmounted)(unsub);
    });
  },
  render: () => null
});

// src/listeners/PageVisibilityListener.vue.ts
var import_vue8 = require("vue");
var import_core8 = require("@manapotion/core");
var PageVisibilityListener = (0, import_vue8.defineComponent)({
  emits: { pageVisibilityChange: (payload) => payload },
  setup: (_, { emit }) => {
    (0, import_vue8.onMounted)(() => {
      const unsub = (0, import_core8.mountPageVisibilityListener)({
        onPageVisibilityChange: (payload) => emit("pageVisibilityChange", payload)
      });
      (0, import_vue8.onUnmounted)(unsub);
    });
  },
  render: () => null
});

// src/listeners/PointerLockListener.vue.ts
var import_vue9 = require("vue");
var import_core9 = require("@manapotion/core");
var PointerLockListener = (0, import_vue9.defineComponent)({
  emits: { pointerLockChange: (payload) => payload },
  setup: (_, { emit }) => {
    (0, import_vue9.onMounted)(() => {
      const unsub = (0, import_core9.mountPointerLockListener)({
        onPointerLockChange: (payload) => emit("pointerLockChange", payload)
      });
      (0, import_vue9.onUnmounted)(unsub);
    });
  },
  render: () => null
});

// src/listeners/ResizeListener.vue.ts
var import_vue10 = require("vue");
var import_core10 = require("@manapotion/core");
var ResizeListener = (0, import_vue10.defineComponent)({
  emits: { resize: (payload) => payload },
  setup: (_, { emit }) => {
    (0, import_vue10.onMounted)(() => {
      const unsub = (0, import_core10.mountResizeListener)({
        onResize: (payload) => emit("resize", payload)
      });
      (0, import_vue10.onUnmounted)(unsub);
    });
  },
  render: () => null
});

// src/listeners/ScreenOrientationListener.vue.ts
var import_vue11 = require("vue");
var import_core11 = require("@manapotion/core");
var ScreenOrientationListener = (0, import_vue11.defineComponent)({
  emits: { screenOrientationChange: (payload) => payload },
  setup: (_, { emit }) => {
    (0, import_vue11.onMounted)(() => {
      const unsub = (0, import_core11.mountScreenOrientationListener)({
        onScreenOrientationChange: (payload) => emit("screenOrientationChange", payload)
      });
      (0, import_vue11.onUnmounted)(unsub);
    });
  },
  render: () => null
});

// src/Listeners.vue.ts
var Listeners = (0, import_vue12.defineComponent)({
  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 }) => () => [
    (0, import_vue12.h)(FullscreenListener, { onFullscreenChange: (payload) => emit("fullscreenChange", payload) }),
    (0, import_vue12.h)(PointerLockListener, {
      onPointerLockChange: (payload) => emit("pointerLockChange", payload)
    }),
    (0, import_vue12.h)(MouseMoveListener, {
      onMouseMove: (payload) => emit("mouseMove", payload),
      mouseMovementResetDelay: props.mouseMovementResetDelay
    }),
    (0, import_vue12.h)(PageVisibilityListener, {
      onPageVisibilityChange: (payload) => emit("pageVisibilityChange", payload)
    }),
    (0, import_vue12.h)(PageFocusListener, { onPageFocusChange: (payload) => emit("pageFocusChange", payload) }),
    (0, import_vue12.h)(ResizeListener, { onResize: (payload) => emit("resize", payload) }),
    (0, import_vue12.h)(DeviceTypeListener, { onDeviceTypeChange: (payload) => emit("deviceTypeChange", payload) }),
    (0, import_vue12.h)(ScreenOrientationListener, {
      onScreenOrientationChange: (payload) => emit("screenOrientationChange", payload)
    }),
    (0, import_vue12.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)
    }),
    (0, import_vue12.h)(KeyboardListener, {
      onKeyDown: (payload) => emit("keyDown", payload),
      onKeyUp: (payload) => emit("keyUp", payload)
    }),
    (0, import_vue12.h)(MouseScrollListener, {
      onScroll: (payload) => emit("scroll", payload),
      mouseScrollResetDelay: props.mouseScrollResetDelay
    })
  ]
});

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

// src/vue-loops.ts
var import_vue14 = require("vue");
var import_core13 = require("@manapotion/core");
var useMainLoop = (callback, options) => {
  (0, import_vue14.onMounted)(() => {
    const unsub = (0, import_core13.addMainLoopEffect)(callback, options);
    (0, import_vue14.onUnmounted)(unsub);
  });
};

// src/JoystickArea.vue.ts
var import_vue15 = require("vue");
var import_core14 = require("@manapotion/core");
var JoystickArea = (0, import_vue15.defineComponent)({
  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 = (0, import_vue15.ref)(null);
    (0, import_vue15.onMounted)(() => {
      let unsub = (0, import_core14.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
      });
      (0, import_vue15.watch)(
        () => props.mode,
        (newMode) => {
          unsub();
          unsub = (0, import_core14.mountJoystickArea)({
            mode: newMode,
            joystick: props.joystick,
            maxFollowDistance: props.maxFollowDistance,
            maxOriginDistance: props.maxOriginDistance,
            onEnd: props.onEnd,
            onMove: props.onMove,
            onStart: props.onStart,
            element: localRef.value
          });
        }
      );
      (0, import_vue15.onUnmounted)(() => {
        unsub();
      });
    });
    return () => (0, import_vue15.h)(
      "div",
      {
        ...props.containerProps,
        ref: localRef,
        ...attrs
      },
      slots.default ? slots.default() : []
    );
  }
});

// src/index.ts
__reExport(src_exports, require("@manapotion/core"), module.exports);
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  DeviceTypeListener,
  FullscreenListener,
  JoystickArea,
  KeyboardListener,
  Listeners,
  MouseButtonsListener,
  MouseMoveListener,
  MouseScrollListener,
  PageFocusListener,
  PageVisibilityListener,
  PointerLockListener,
  ResizeListener,
  ScreenOrientationListener,
  browser,
  joysticks,
  keyboard,
  mouse,
  useMainLoop,
  ...require("@manapotion/core")
});