@maas/vue-equipment 1.0.0-beta.3 → 1.0.0-beta.31

package/dist/plugins/MagicCommand/src/components/MagicCommandItem.vue.d.ts

@@ -3,33 +3,21 @@ interface MagicCommandItemProps {
     initial?: boolean;
     disabled?: boolean;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {
-            itemActive: any;
-            itemDisabled: boolean;
-        }): any;
-    };
-    refs: {
-        elRef: any;
-    };
-    rootEl: any;
+declare var __VLS_1: {
+    itemActive: boolean;
+    itemDisabled: boolean;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCommandItemProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any, string, import("vue").PublicProps, any, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
-export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
 };
-type __VLS_WithTemplateSlots<T, S> = T & {
+declare const __VLS_component: import("vue").DefineComponent<MagicCommandItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    click: (event: MouseEvent) => any;
+}, string, import("vue").PublicProps, Readonly<MagicCommandItemProps> & Readonly<{
+    onClick?: ((event: MouseEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicCommand/src/components/MagicCommandModal.vue

@@ -1,6 +1,15 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { unref as _unref, renderSlot as _renderSlot, resolveComponent as _resolveComponent, mergeProps as _mergeProps, withCtx as _withCtx, openBlock as _openBlock, createBlock as _createBlock } from "vue";
+<template>
+  <magic-modal
+    :id="instanceId"
+    class="magic-command-modal"
+    :options="options"
+    v-bind="$attrs"
+  >
+    <slot />
+  </magic-modal>
+</template>
+
+<script setup>
 import { inject, watch, onBeforeUnmount } from "vue";
 import {
   useMagicModal,
@@ -8,50 +17,31 @@ import {
 } from "@maas/vue-equipment/plugins";
 import { useMagicCommand } from "../composables/useMagicCommand";
 import { MagicCommandInstanceId } from "../symbols";
-export default /* @__PURE__ */ _defineComponent({
-  ...{
-    inheritAttrs: false
-  },
-  __name: "MagicCommandModal",
-  props: {
-    options: { type: null, required: false }
-  },
-  setup(__props) {
-    const instanceId = inject(MagicCommandInstanceId, "");
-    const emitter = useMagicEmitter();
-    function afterLeaveCallback(payload) {
-      if (typeof payload === "string" && payload === instanceId) {
-        close();
-      }
-    }
-    const { close, isActive } = useMagicCommand(instanceId);
-    const modalApi = useMagicModal(instanceId);
-    watch(isActive, (value) => {
-      if (value) {
-        modalApi.open();
-      } else {
-        modalApi.close();
-      }
-    });
-    emitter.on("afterLeave", afterLeaveCallback);
-    onBeforeUnmount(() => {
-      emitter.off("afterLeave", afterLeaveCallback);
-      close();
-    });
-    return (_ctx, _cache) => {
-      const _component_magic_modal = _resolveComponent("magic-modal");
-      return _openBlock(), _createBlock(_component_magic_modal, _mergeProps({
-        id: _unref(instanceId),
-        class: "magic-command-modal",
-        options: _ctx.options
-      }, _ctx.$attrs), {
-        default: _withCtx(() => [
-          _renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-        /* FORWARDED */
-      }, 16, ["id", "options"]);
-    };
+defineOptions({
+  inheritAttrs: false
+});
+defineProps({
+  options: { type: null, required: false }
+});
+const instanceId = inject(MagicCommandInstanceId, "");
+const emitter = useMagicEmitter();
+function afterLeaveCallback(payload) {
+  if (typeof payload === "string" && payload === instanceId) {
+    close();
   }
+}
+const { close, isActive } = useMagicCommand(instanceId);
+const modalApi = useMagicModal(instanceId);
+watch(isActive, (value) => {
+  if (value) {
+    modalApi.open();
+  } else {
+    modalApi.close();
+  }
+});
+emitter.on("afterLeave", afterLeaveCallback);
+onBeforeUnmount(() => {
+  emitter.off("afterLeave", afterLeaveCallback);
+  close();
 });
 </script>

package/dist/plugins/MagicCommand/src/components/MagicCommandModal.vue.d.ts

@@ -2,28 +2,14 @@ import type { MagicCommandModalOptions } from '../types/index.js';
 interface MagicCommandProps {
     options?: MagicCommandModalOptions;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {}): any;
-    };
-    refs: {};
-    rootEl: any;
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCommandProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCommandProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+declare const __VLS_component: import("vue").DefineComponent<MagicCommandProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicCommandProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicCommand/src/components/MagicCommandProvider.vue

@@ -1,7 +1,11 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { renderSlot as _renderSlot, unref as _unref, withCtx as _withCtx, openBlock as _openBlock, createBlock as _createBlock } from "vue";
-import { ref, provide, watch, onBeforeUnmount } from "vue";
+<template>
+  <primitive :data-id="id" :as-child="asChild" class="magic-command-provider">
+    <slot />
+  </primitive>
+</template>
+
+<script setup>
+import { shallowRef, provide, watch, onBeforeUnmount } from "vue";
 import { useMagicKeys, usePointer } from "@vueuse/core";
 import { Primitive } from "@maas/vue-primitive";
 import { createDefu } from "defu";
@@ -9,85 +13,65 @@ import { useCommandState } from "../composables/private/useCommandState";
 import { useMagicCommand } from "../composables/useMagicCommand";
 import { defaultOptions } from "../utils/defaultOptions";
 import { MagicCommandInstanceId, MagicCommandProviderOptions } from "../symbols";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicCommandProvider",
-  props: {
-    id: { type: null, required: true },
-    asChild: { type: Boolean, required: false },
-    options: { type: Object, required: false, default: () => ({}) }
-  },
-  setup(__props) {
-    const elRef = ref(void 0);
-    const customDefu = createDefu((obj, key, value) => {
-      if (key === "open" || key === "close" || key === "next" || key === "prev") {
-        obj[key] = value;
-        return true;
-      }
-    });
-    const mappedOptions = customDefu(__props.options, defaultOptions);
-    const { initializeState, deleteState } = useCommandState(__props.id);
-    const state = initializeState(mappedOptions);
-    const lastX = ref(0);
-    const lastY = ref(0);
-    const { x, y } = usePointer();
-    watch(
-      () => state?.input.type,
-      (value) => {
-        if (value === "keyboard") {
-          lastX.value = x.value;
-          lastY.value = y.value;
-        }
-      }
-    );
-    watch([x, y], ([x2, y2]) => {
-      if (x2 !== lastX.value || y2 !== lastY.value) {
-        if (state) {
-          state.input.type = "pointer";
-        }
+const { id, options = {} } = defineProps({
+  id: { type: null, required: true },
+  asChild: { type: Boolean, required: false },
+  options: { type: Object, required: false }
+});
+const customDefu = createDefu((obj, key, value) => {
+  if (key === "open" || key === "close" || key === "next" || key === "prev") {
+    obj[key] = value;
+    return true;
+  }
+});
+const mappedOptions = customDefu(options, defaultOptions);
+const { initializeState, deleteState } = useCommandState(id);
+const state = initializeState(mappedOptions);
+const lastX = shallowRef(0);
+const lastY = shallowRef(0);
+const { x, y } = usePointer();
+watch(
+  () => state?.input.type,
+  (value) => {
+    if (value === "keyboard") {
+      lastX.value = x.value;
+      lastY.value = y.value;
+    }
+  }
+);
+watch([x, y], ([x2, y2]) => {
+  if (x2 !== lastX.value || y2 !== lastY.value) {
+    if (state) {
+      state.input.type = "pointer";
+    }
+  }
+});
+const keys = useMagicKeys();
+const commandApi = useMagicCommand(id);
+const { open, close } = commandApi;
+if (mappedOptions.keyListener?.open) {
+  for (const key of mappedOptions.keyListener.open) {
+    watch(keys[key], (value) => {
+      if (value) {
+        open();
       }
     });
-    const keys = useMagicKeys();
-    const commandApi = useMagicCommand(__props.id);
-    const { open, close } = commandApi;
-    if (mappedOptions.keyListener?.open) {
-      for (const key of mappedOptions.keyListener.open) {
-        watch(keys[key], (value) => {
-          if (value) {
-            open();
-          }
-        });
-      }
-    }
-    if (mappedOptions.keyListener?.close) {
-      for (const key of mappedOptions.keyListener.close) {
-        watch(keys[key], (value) => {
-          if (value) {
-            close();
-          }
-        });
+  }
+}
+if (mappedOptions.keyListener?.close) {
+  for (const key of mappedOptions.keyListener.close) {
+    watch(keys[key], (value) => {
+      if (value) {
+        close();
       }
-    }
-    onBeforeUnmount(() => {
-      deleteState();
     });
-    provide(MagicCommandInstanceId, __props.id);
-    provide(MagicCommandProviderOptions, mappedOptions);
-    return (_ctx, _cache) => {
-      return _openBlock(), _createBlock(_unref(Primitive), {
-        ref_key: "elRef",
-        ref: elRef,
-        "as-child": _ctx.asChild,
-        class: "magic-command-provider"
-      }, {
-        default: _withCtx(() => [
-          _renderSlot(_ctx.$slots, "default")
-        ]),
-        _: 3
-        /* FORWARDED */
-      }, 8, ["as-child"]);
-    };
   }
+}
+onBeforeUnmount(() => {
+  deleteState();
 });
+provide(MagicCommandInstanceId, id);
+provide(MagicCommandProviderOptions, mappedOptions);
 </script>
 
 <style>

package/dist/plugins/MagicCommand/src/components/MagicCommandProvider.vue.d.ts

@@ -5,30 +5,14 @@ interface MagicCommandProviderProps {
     asChild?: boolean;
     options?: MagicCommandOptions;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {}): any;
-    };
-    refs: {
-        elRef: any;
-    };
-    rootEl: any;
+declare var __VLS_6: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_6) => any;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCommandProviderProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCommandProviderProps>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
-declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+declare const __VLS_component: import("vue").DefineComponent<MagicCommandProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicCommandProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
 export default _default;
-type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
-type __VLS_TypePropsToOption<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? {
-        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
-    } : {
-        type: import('vue').PropType<T[K]>;
-        required: true;
-    };
-};
-type __VLS_WithTemplateSlots<T, S> = T & {
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicCommand/src/components/MagicCommandRenderer.vue

@@ -1,48 +1,32 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
-import { ref, inject, onBeforeUnmount } from "vue";
+<template>
+  <div ref="el" class="magic-command-renderer" />
+</template>
+
+<script setup>
+import { inject, onBeforeUnmount, useTemplateRef } from "vue";
 import {
   useMagicEmitter
 } from "@maas/vue-equipment/plugins";
 import { MagicCommandInstanceId } from "./../symbols";
 import { useCommandState } from "../composables/private/useCommandState";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicCommandRenderer",
-  setup(__props) {
-    const instanceId = inject(MagicCommandInstanceId, "");
-    const emitter = useMagicEmitter();
-    if (!instanceId) {
-      throw new Error(
-        "MagicCommandRenderer must be nested inside MagicCommandProvider"
-      );
-    }
-    const elRef = ref(void 0);
-    const { initializeState } = useCommandState(instanceId);
-    const state = initializeState();
-    function enterCallback(payload) {
-      if (typeof payload === "string" && payload === instanceId) {
-        state.renderer = elRef.value;
-      }
-    }
-    emitter.on("enter", enterCallback);
-    onBeforeUnmount(() => {
-      emitter.off("enter", enterCallback);
-    });
-    return (_ctx, _cache) => {
-      return _openBlock(), _createElementBlock(
-        "div",
-        {
-          ref_key: "elRef",
-          ref: elRef,
-          class: "magic-command-renderer"
-        },
-        null,
-        512
-        /* NEED_PATCH */
-      );
-    };
+const instanceId = inject(MagicCommandInstanceId, "");
+const emitter = useMagicEmitter();
+if (!instanceId) {
+  throw new Error(
+    "MagicCommandRenderer must be nested inside MagicCommandProvider"
+  );
+}
+const elRef = useTemplateRef("el");
+const { initializeState } = useCommandState(instanceId);
+const state = initializeState();
+function enterCallback(payload) {
+  if (typeof payload === "string" && payload === instanceId) {
+    state.renderer = elRef.value;
   }
+}
+emitter.on("enter", enterCallback);
+onBeforeUnmount(() => {
+  emitter.off("enter", enterCallback);
 });
 </script>
 

package/dist/plugins/MagicCommand/src/components/MagicCommandTrigger.vue

@@ -1,7 +1,20 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { unref as _unref, renderSlot as _renderSlot, withCtx as _withCtx, openBlock as _openBlock, createBlock as _createBlock } from "vue";
-import { computed, inject, ref, toValue, watch } from "vue";
+<template>
+  <primitive
+    ref="el"
+    :data-id="`${mappedViewId}-trigger`"
+    :data-active="mappedActive"
+    :data-disabled="mappedDisabled"
+    :as-child="asChild"
+    class="magic-command-trigger"
+    @click="onClick"
+    @mouseenter="onMouseenter"
+  >
+    <slot :view-active="view?.active" :trigger-disabled="mappedDisabled" />
+  </primitive>
+</template>
+
+<script setup>
+import { computed, inject, useTemplateRef, toValue, watch } from "vue";
 import { Primitive } from "@maas/vue-primitive";
 import { useCommandView } from "../composables/private/useCommandView";
 import { useCommandTrigger } from "../composables/private/useCommandTrigger";
@@ -13,90 +26,71 @@ import {
   MagicCommandProviderOptions
 } from "../symbols";
 import { useMagicKeys } from "@vueuse/core";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicCommandTrigger",
-  props: {
-    viewId: { type: String, required: false },
-    active: { type: Boolean, required: false, default: () => void 0 },
-    disabled: { type: Boolean, required: false, default: () => void 0 },
-    action: { type: String, required: false, default: "open" },
-    trigger: { type: Array, required: false, default: () => ["click"] },
-    asChild: { type: Boolean, required: false }
-  },
-  setup(__props) {
-    const elRef = ref(void 0);
-    const instanceId = inject(MagicCommandInstanceId, void 0);
-    const itemActive = inject(MagicCommandItemActive, void 0);
-    const itemDisabled = inject(MagicCommandItemDisabled, void 0);
-    const injectedViewId = inject(MagicCommandViewId, void 0);
-    const mappedViewId = computed(() => __props.viewId ?? injectedViewId);
-    if (!instanceId) {
-      throw new Error(
-        "MagicCommandTrigger must be nested inside MagicCommandProvider"
-      );
-    }
-    if (!mappedViewId.value) {
-      throw new Error("MagicCommandTrigger must be nested inside MagicCommandView");
+const {
+  viewId,
+  active = void 0,
+  disabled = void 0,
+  action = "open",
+  trigger = ["click"]
+} = defineProps({
+  viewId: { type: String, required: false },
+  active: { type: Boolean, required: false },
+  disabled: { type: Boolean, required: false },
+  action: { type: String, required: false },
+  trigger: { type: Array, required: false },
+  asChild: { type: Boolean, required: false }
+});
+const elRef = useTemplateRef("el");
+const instanceId = inject(MagicCommandInstanceId, void 0);
+const itemActive = inject(MagicCommandItemActive, void 0);
+const itemDisabled = inject(MagicCommandItemDisabled, void 0);
+const injectedViewId = inject(MagicCommandViewId, void 0);
+const mappedViewId = computed(() => viewId ?? injectedViewId);
+if (!instanceId) {
+  throw new Error(
+    "MagicCommandTrigger must be nested inside MagicCommandProvider"
+  );
+}
+if (!mappedViewId.value) {
+  throw new Error(
+    "MagicCommandTrigger must be nested inside MagicCommandView or a viewId must be provided"
+  );
+}
+const { getView } = useCommandView(instanceId);
+const view = getView(mappedViewId.value);
+const mappedActive = computed(() => active ?? toValue(itemActive) ?? false);
+const mappedDisabled = computed(
+  () => disabled ?? toValue(itemDisabled) ?? false
+);
+const options = inject(MagicCommandProviderOptions, void 0);
+const { onMouseenter, onClick, onKeypress } = useCommandTrigger({
+  instanceId,
+  viewId: mappedViewId.value,
+  mappedActive,
+  mappedDisabled,
+  trigger,
+  action,
+  elRef
+});
+watch(
+  () => view?.active,
+  async (value) => {
+    if (value) {
+      await new Promise((resolve) => requestAnimationFrame(resolve));
+      toValue(elRef)?.$el?.blur();
     }
-    const { getView } = useCommandView(instanceId);
-    const view = getView(mappedViewId.value);
-    const mappedActive = computed(() => __props.active ?? toValue(itemActive) ?? false);
-    const mappedDisabled = computed(
-      () => __props.disabled ?? toValue(itemDisabled) ?? false
-    );
-    const options = inject(MagicCommandProviderOptions, void 0);
-    const { onMouseenter, onClick, onEnter } = useCommandTrigger({
-      instanceId,
-      viewId: mappedViewId.value,
-      mappedActive,
-      mappedDisabled,
-      trigger: __props.trigger,
-      action: __props.action,
-      elRef
-    });
-    watch(
-      () => view?.active,
-      async (value) => {
-        if (value) {
-          await new Promise((resolve) => requestAnimationFrame(resolve));
-          toValue(elRef)?.$el?.blur();
-        }
-      }
-    );
-    const keys = useMagicKeys();
-    if (options?.keyListener?.enter) {
-      for (const key of options.keyListener.enter) {
-        watch(keys[key], (value) => {
-          if (value) {
-            onEnter();
-          }
-        });
+  }
+);
+const keys = useMagicKeys();
+if (options?.keyListener?.enter) {
+  for (const key of options.keyListener.enter) {
+    watch(keys[key], (value) => {
+      if (value) {
+        onKeypress();
       }
-    }
-    return (_ctx, _cache) => {
-      return _openBlock(), _createBlock(_unref(Primitive), {
-        ref_key: "elRef",
-        ref: elRef,
-        "data-id": `${mappedViewId.value}-trigger`,
-        "data-active": mappedActive.value,
-        "data-disabled": mappedDisabled.value,
-        "as-child": _ctx.asChild,
-        class: "magic-command-trigger",
-        onClick: _unref(onClick),
-        onMouseenter: _unref(onMouseenter)
-      }, {
-        default: _withCtx(() => [
-          _renderSlot(_ctx.$slots, "default", {
-            viewActive: _unref(view)?.active,
-            triggerDisabled: mappedDisabled.value
-          })
-        ]),
-        _: 3
-        /* FORWARDED */
-      }, 8, ["data-id", "data-active", "data-disabled", "as-child", "onClick", "onMouseenter"]);
-    };
+    });
   }
-});
+}
 </script>
 
 <style>
@@ -104,7 +98,7 @@ export default /* @__PURE__ */ _defineComponent({
   cursor: var(--magic-command-trigger-cursor, pointer);
 }
 
-.magic-menu-trigger.-disabled {
+.magic-menu-trigger[data-disabled='true'] {
   pointer-events: none;
 }
 </style>