@maas/vue-equipment 1.0.0-beta.4 → 1.0.0-beta.40

package/dist/plugins/MagicCommand/src/composables/private/useCommandItem.mjs

@@ -30,7 +30,9 @@ export function useCommandItem(args) {
     return item;
   }
   function deleteItem(id) {
-    if (!view?.items) return;
+    if (!view?.items) {
+      return;
+    }
     view.items = view.items.filter((x) => x.id !== id);
   }
   function getItem(id) {
@@ -49,12 +51,10 @@ export function useCommandItem(args) {
     const index = view?.items.findIndex(
       (item) => item.id === activeItem.value?.id
     );
-    if (index !== void 0) {
-      const hasNext = view?.items[index + 1] !== void 0;
-      if (hasNext) {
-        selectItem(view?.items[index + 1].id);
-      } else if (view && loop) {
-        selectItem(view.items[0].id);
+    if (index !== void 0 && view) {
+      const nextItem = view.items[index + 1] ?? (loop ? view.items[0] : void 0);
+      if (nextItem) {
+        selectItem(nextItem.id);
       }
     }
   }
@@ -62,12 +62,10 @@ export function useCommandItem(args) {
     const index = view?.items.findIndex(
       (item) => item.id === activeItem.value?.id
     );
-    if (index !== void 0) {
-      const hasPrev = view?.items[index - 1] !== void 0;
-      if (hasPrev) {
-        selectItem(view?.items[index - 1].id);
-      } else if (view && loop) {
-        selectItem(view.items[view.items.length - 1].id);
+    if (index !== void 0 && view) {
+      const prevItem = view.items[index - 1] ?? (loop ? view.items[view.items.length - 1] : void 0);
+      if (prevItem) {
+        selectItem(prevItem.id);
       }
     }
   }

package/dist/plugins/MagicCommand/src/composables/private/useCommandScroll.d.ts

@@ -1,4 +1,4 @@
-import { type MaybeRef } from 'vue';
+import { type MaybeRef, type Ref } from 'vue';
 interface IsElementAboveArgs {
     element: MaybeRef<HTMLElement>;
     ancestor?: HTMLElement;
@@ -15,7 +15,7 @@ interface ScrollInFromBottomArgs {
     element: MaybeRef<HTMLElement>;
     ancestor?: HTMLElement;
 }
-export declare function useCommandScroll(parent: MaybeRef<HTMLElement | undefined>): {
+export declare function useCommandScroll(parent: Ref<HTMLElement | null>): {
     findElement: (id: string) => HTMLElement | null;
     findScrollableAncestor: (element: HTMLElement | null) => HTMLElement | undefined;
     isElementAbove: (args: IsElementAboveArgs) => boolean;

package/dist/plugins/MagicCommand/src/composables/private/useCommandState.mjs

@@ -9,7 +9,7 @@ export function useCommandState(instanceId) {
       id,
       options: { ...defaultOptions },
       views: [],
-      renderer: void 0,
+      renderer: null,
       active: false,
       input: {
         type: "pointer",

package/dist/plugins/MagicCommand/src/composables/private/useCommandTrigger.d.ts

@@ -8,11 +8,11 @@ type UseCommandTriggerArgs = {
     mappedActive?: ComputedRef<boolean>;
     trigger: Interaction[];
     action: Action;
-    elRef: Ref<InstanceType<typeof Primitive> | undefined>;
+    elRef: Ref<InstanceType<typeof Primitive> | null>;
 };
 export declare function useCommandTrigger(args: UseCommandTriggerArgs): {
     onMouseenter: () => Promise<void>;
     onClick: (e: MouseEvent) => Promise<void>;
-    onEnter: (e?: KeyboardEvent) => Promise<void>;
+    onKeypress: (e?: KeyboardEvent) => Promise<void>;
 };
 export {};

package/dist/plugins/MagicCommand/src/composables/private/useCommandTrigger.mjs

@@ -1,4 +1,5 @@
 import { nextTick } from "vue";
+import { Primitive } from "@maas/vue-primitive";
 import { useFocus } from "@vueuse/core";
 import { useCommandView } from "./useCommandView.mjs";
 import { useCommandState } from "./useCommandState.mjs";
@@ -17,7 +18,7 @@ export function useCommandTrigger(args) {
   const { initializeState } = useCommandState(instanceId);
   const state = initializeState();
   const { focused } = useFocus(elRef);
-  async function onEnter(e) {
+  async function onKeypress(e) {
     if ((focused.value || mappedActive?.value) && !mappedDisabled.value && !view?.active) {
       e?.preventDefault();
       e?.stopPropagation();
@@ -71,6 +72,6 @@ export function useCommandTrigger(args) {
   return {
     onMouseenter,
     onClick,
-    onEnter
+    onKeypress
   };
 }

package/dist/plugins/MagicCommand/src/composables/private/useCommandView.d.ts

@@ -1,7 +1,7 @@
 import { type MaybeRef } from 'vue';
 import type { CommandView } from '../../types/index.js';
 type InitializeViewArgs = Pick<CommandView, 'id' | 'parent' | 'initial'>;
-export declare function useCommandView(instanceId: MaybeRef<string>): {
+export declare function useCommandView(id: MaybeRef<string>): {
     currentView: import("vue").ComputedRef<CommandView | undefined>;
     initializeView: (args: InitializeViewArgs) => CommandView;
     deleteView: (id: string) => void;

package/dist/plugins/MagicCommand/src/composables/private/useCommandView.mjs

@@ -1,28 +1,37 @@
 import { reactive, computed, toValue } from "vue";
+import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
 import { useCommandState } from "./useCommandState.mjs";
 function isAbortError(error) {
   return error instanceof DOMException && error.name === "AbortError";
 }
-export function useCommandView(instanceId) {
-  const { initializeState } = useCommandState(instanceId);
+const { logWarning } = useMagicError({
+  prefix: "MagicCommand",
+  source: "useCommandView"
+});
+export function useCommandView(id) {
+  const { initializeState } = useCommandState(id);
   const state = initializeState();
-  const currentInstanceId = toValue(instanceId);
+  const currentInstanceId = toValue(id);
   const currentView = computed(() => {
     const activeViews = state.views.filter((view) => view.active);
-    if (activeViews.length === 0) return void 0;
-    if (activeViews.length === 1) return activeViews[0];
+    if (activeViews.length === 0) {
+      return void 0;
+    }
+    if (activeViews.length === 1) {
+      return activeViews[0];
+    }
     return activeViews.reduce(
       (a, b) => a.parent.views.length >= b.parent.views.length ? a : b
     );
   });
   const viewMap = /* @__PURE__ */ new Map();
   function createView(args) {
-    const { id, parent, initial } = args;
+    const { id: id2, parent, initial } = args;
     if (parent.views.length === 0) {
       parent.views.push(currentInstanceId);
     }
     const view = reactive({
-      id,
+      id: id2,
       parent,
       initial,
       active: false,
@@ -33,7 +42,7 @@ export function useCommandView(instanceId) {
         unselectAbortController: new AbortController()
       }
     });
-    viewMap.set(id, view);
+    viewMap.set(id2, view);
     return view;
   }
   function addView(args) {
@@ -55,35 +64,37 @@ export function useCommandView(instanceId) {
     const view = state?.views.findLast((view2) => view2.active)?.id;
     state.input.view = view;
   }
-  function getView(id) {
-    let view = viewMap.get(id);
+  function getView(id2) {
+    let view = viewMap.get(id2);
     if (!view) {
-      view = state.views.find((v) => v.id === id);
-      if (view) viewMap.set(id, view);
+      view = state.views.find((v) => v.id === id2);
+      if (view) viewMap.set(id2, view);
     }
     return view;
   }
-  function deleteView(id) {
-    const index = state.views.findIndex((view) => view.id === id);
+  function deleteView(id2) {
+    const index = state.views.findIndex((view) => view.id === id2);
     if (index !== -1) {
       state.views.splice(index, 1);
-      viewMap.delete(id);
+      viewMap.delete(id2);
     }
   }
-  function getRelativeViewIndex(id) {
-    const view = getView(id);
-    if (!view) return -1;
+  function getRelativeViewIndex(id2) {
+    const view = getView(id2);
+    if (!view) {
+      return -1;
+    }
     const nestingLevel = view.parent.views.length;
     return state.views.findIndex(
-      (v) => v.parent.views.length === nestingLevel && v.id === id
+      (v) => v.parent.views.length === nestingLevel && v.id === id2
     );
   }
-  function getNextView(id) {
-    const index = state.views.findIndex((view) => view.id === id);
+  function getNextView(id2) {
+    const index = state.views.findIndex((view) => view.id === id2);
     return index !== -1 ? state.views[index + 1] : void 0;
   }
-  function getPreviousView(id) {
-    const index = state.views.findIndex((view) => view.id === id);
+  function getPreviousView(id2) {
+    const index = state.views.findIndex((view) => view.id === id2);
     return index > 0 ? state.views[index - 1] : void 0;
   }
   function getTopLevelView() {
@@ -92,21 +103,27 @@ export function useCommandView(instanceId) {
   function getNestedView(itemId) {
     return state.views.find((view) => view.parent.item === itemId);
   }
-  function getParentView(id) {
-    const view = getView(id);
-    if (!view) return void 0;
+  function getParentView(id2) {
+    const view = getView(id2);
+    if (!view) {
+      return void 0;
+    }
     const parentId = view.parent.views[view.parent.views.length - 1];
     return parentId ? getView(parentId) : void 0;
   }
-  function getUnrelatedViews(id) {
-    const view = getView(id);
-    if (!view) return [];
+  function getUnrelatedViews(id2) {
+    const view = getView(id2);
+    if (!view) {
+      return [];
+    }
     const parentViewsSet = new Set(view.parent.views);
-    return state.views.filter((v) => v.id !== id && !parentViewsSet.has(v.id));
+    return state.views.filter((v) => v.id !== id2 && !parentViewsSet.has(v.id));
   }
-  async function selectView(id, delayMs = 0) {
-    const view = getView(id);
-    if (!view) return;
+  async function selectView(id2, delayMs = 0) {
+    const view = getView(id2);
+    if (!view) {
+      return;
+    }
     if (view.state.unselectAbortController) {
       view.state.unselectAbortController.abort();
     }
@@ -120,7 +137,7 @@ export function useCommandView(instanceId) {
       activateView();
     } catch (error) {
       if (isAbortError(error) && state.options.debug) {
-        console.log("selectView() was interrupted by a call to unselectView()");
+        logWarning("selectView() was interrupted by a call to unselectView()");
       }
     }
   }
@@ -131,9 +148,11 @@ export function useCommandView(instanceId) {
       activateView();
     }
   }
-  async function unselectView(id, delayMs = 0) {
-    const view = getView(id);
-    if (!view) return;
+  async function unselectView(id2, delayMs = 0) {
+    const view = getView(id2);
+    if (!view) {
+      return;
+    }
     if (view.state.selectAbortController) {
       view.state.selectAbortController.abort();
     }
@@ -147,12 +166,12 @@ export function useCommandView(instanceId) {
       activateView();
     } catch (error) {
       if (isAbortError(error) && state.options.debug) {
-        console.log("unselectView() was interrupted by a call to selectView()");
+        logWarning("unselectView() was interrupted by a call to selectView()");
       }
     }
   }
-  function unselectUnrelatedViews(id) {
-    const views = getUnrelatedViews(id);
+  function unselectUnrelatedViews(id2) {
+    const views = getUnrelatedViews(id2);
     for (const view of views) {
       view.active = false;
     }
@@ -163,8 +182,8 @@ export function useCommandView(instanceId) {
     }
   }
   function initializeView(args) {
-    const { id } = args;
-    const view = getView(id) ?? addView(args);
+    const { id: id2 } = args;
+    const view = getView(id2) ?? addView(args);
     return view;
   }
   function sortViewItems(viewId) {
@@ -173,8 +192,8 @@ export function useCommandView(instanceId) {
     const elements = Array.from(
       parent?.querySelectorAll(".magic-command-item") ?? []
     );
-    function getIndex(id) {
-      return elements.findIndex((el) => el.dataset.id === id);
+    function getIndex(id2) {
+      return elements.findIndex((el) => el.dataset.id === id2);
     }
     view?.items?.sort((a, b) => getIndex(a.id) - getIndex(b.id));
   }

package/dist/plugins/MagicCommand/src/composables/useMagicCommand.mjs

@@ -1,7 +1,12 @@
 import { computed, nextTick } from "vue";
+import { useMagicError } from "@maas/vue-equipment/plugins/MagicError";
 import { useCommandState } from "./private/useCommandState.mjs";
 import { useCommandItem } from "./private/useCommandItem.mjs";
 import { useCommandView } from "./private/useCommandView.mjs";
+const { throwError } = useMagicError({
+  prefix: "MagicCommand",
+  source: "useMagicCommand"
+});
 export function useMagicCommand(id) {
   const { initializeState } = useCommandState(id);
   const state = initializeState();
@@ -20,10 +25,16 @@ export function useMagicCommand(id) {
   function selectItem(args) {
     const { id: id2, viewId } = args;
     if (!viewId) {
-      throw new Error("viewId is required to select an item");
+      throwError({
+        message: "viewId is required to select an item",
+        errorCode: "view_id_required"
+      });
     }
     if (!id2) {
-      throw new Error("id is required to select an item");
+      throwError({
+        message: "id is required to select an item",
+        errorCode: "id_required"
+      });
     }
     const { selectItem: selectItem2 } = useCommandItem({
       instanceId: id2,
@@ -34,10 +45,16 @@ export function useMagicCommand(id) {
   function unselectItem(args) {
     const { id: id2, viewId } = args;
     if (!viewId) {
-      throw new Error("viewId is required to select an item");
+      throwError({
+        message: "viewId is required to select an item",
+        errorCode: "view_id_required"
+      });
     }
     if (!id2) {
-      throw new Error("id is required to select an item");
+      throwError({
+        message: "id is required to select an item",
+        errorCode: "id_required"
+      });
     }
     const { unselectItem: unselectItem2 } = useCommandItem({
       instanceId: id2,

package/dist/plugins/MagicCommand/src/symbols/index.d.ts

@@ -1,12 +1,12 @@
-import type { InjectionKey, MaybeRef } from 'vue';
+import type { InjectionKey, MaybeRef, Ref } from 'vue';
 import type { MagicCommandOptions } from '../types/index.js';
 declare const MagicCommandInstanceId: InjectionKey<MaybeRef<string>>;
 declare const MagicCommandParentTree: InjectionKey<string[]>;
 declare const MagicCommandViewId: InjectionKey<string>;
-declare const MagicCommandViewActive: InjectionKey<MaybeRef<boolean>>;
+declare const MagicCommandViewActive: InjectionKey<Ref<boolean>>;
 declare const MagicCommandContentId: InjectionKey<string>;
 declare const MagicCommandItemId: InjectionKey<string>;
-declare const MagicCommandItemActive: InjectionKey<MaybeRef<boolean>>;
-declare const MagicCommandItemDisabled: InjectionKey<MaybeRef<boolean>>;
+declare const MagicCommandItemActive: InjectionKey<Ref<boolean>>;
+declare const MagicCommandItemDisabled: InjectionKey<Ref<boolean>>;
 declare const MagicCommandProviderOptions: InjectionKey<MagicCommandOptions>;
 export { MagicCommandInstanceId, MagicCommandParentTree, MagicCommandViewId, MagicCommandViewActive, MagicCommandContentId, MagicCommandItemId, MagicCommandItemActive, MagicCommandItemDisabled, MagicCommandProviderOptions, };

package/dist/plugins/MagicCommand/src/types/index.d.ts

@@ -46,14 +46,14 @@ export interface CommandState {
     id: string;
     active: boolean;
     views: CommandView[];
-    renderer: HTMLElement | undefined;
+    renderer: HTMLElement | null;
     options: MagicCommandOptions;
     input: {
         type: 'keyboard' | 'pointer';
         view: string | undefined;
     };
 }
-export type CommandEvents = {
+export interface CommandEvents {
     beforeEnter: {
         id: string;
         viewId: string;
@@ -78,6 +78,6 @@ export type CommandEvents = {
         id: string;
         viewId: string;
     };
-};
+}
 export type { MagicModalOptions as MagicCommandModalOptions };
 export type { MagicDrawerOptions as MagicCommandDrawerOptions };

package/dist/plugins/MagicCookie/nuxt.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("@nuxt/schema").NuxtModule<import("@nuxt/schema").ModuleOptions, import("@nuxt/schema").ModuleOptions, false>;
+declare const _default: import("nuxt/schema").NuxtModule<import("nuxt/schema").ModuleOptions, import("nuxt/schema").ModuleOptions, false>;
 export default _default;

package/dist/plugins/MagicCookie/src/components/MagicCookieItem.d.vue.ts

@@ -0,0 +1,20 @@
+interface MagicCookieItemProps {
+    id?: string;
+    optional?: boolean;
+    maxAge?: number;
+}
+declare var __VLS_1: {
+    item: import("../types/index.js").CookieItem;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicCookieItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicCookieItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/plugins/MagicCookie/src/components/MagicCookieItem.vue

@@ -1,51 +1,53 @@
-<script>
-import { defineComponent as _defineComponent } from "vue";
-import { unref as _unref, renderSlot as _renderSlot, openBlock as _openBlock, createElementBlock as _createElementBlock } from "vue";
-const _hoisted_1 = ["data-optional", "data-active"];
+<template>
+  <div
+    class="magic-cookie-item"
+    :data-id="mappedId"
+    :data-optional="item.optional"
+    :data-active="item.active"
+  >
+    <slot :item="item" />
+  </div>
+</template>
+
+<script setup>
 import { computed, inject, provide, onBeforeUnmount, useId } from "vue";
+import {
+  useMagicError
+} from "@maas/vue-equipment/plugins/MagicError";
 import { useCookieItem } from "../composables/private/useCookieItem";
 import {
   MagicCookieInstanceId,
   MagicCookieItemId,
   MagicCookieItemActive
 } from "../symbols";
-export default /* @__PURE__ */ _defineComponent({
-  __name: "MagicCookieItem",
-  props: {
-    id: { type: String, required: false },
-    optional: { type: Boolean, required: false },
-    maxAge: { type: Number, required: false }
-  },
-  setup(__props) {
-    const instanceId = inject(MagicCookieInstanceId, void 0);
-    if (!instanceId) {
-      throw new Error("MagicCookieItem must be nested inside MagicCookieProvider");
-    }
-    const mappedId = computed(() => __props.id ?? `magic-cookie-item-${useId()}`);
-    const mappedActive = computed(() => item.active);
-    const { initializeItem, deleteItem } = useCookieItem({
-      instanceId
-    });
-    const item = initializeItem({
-      id: mappedId.value,
-      optional: __props.optional,
-      maxAge: __props.maxAge
-    });
-    provide(MagicCookieItemId, mappedId.value);
-    provide(MagicCookieItemActive, mappedActive);
-    onBeforeUnmount(() => {
-      deleteItem(mappedId.value);
-    });
-    return (_ctx, _cache) => {
-      return _openBlock(), _createElementBlock("div", {
-        class: "magic-cookie-item",
-        "data-optional": _unref(item).optional,
-        "data-active": _unref(item).active
-      }, [
-        _renderSlot(_ctx.$slots, "default", { item: _unref(item) })
-      ], 8, _hoisted_1);
-    };
-  }
+const { id, optional, maxAge } = defineProps({
+  id: { type: String, required: false },
+  optional: { type: Boolean, required: false },
+  maxAge: { type: Number, required: false }
+});
+const magicError = useMagicError({
+  prefix: "MagicCookie",
+  source: "MagicCookieItem"
+});
+const instanceId = inject(MagicCookieInstanceId, void 0);
+magicError.assert(instanceId, {
+  message: "MagicCookieItem must be nested inside MagicCookieProvider",
+  errorCode: "missing_instance_id"
+});
+const mappedId = computed(() => id ?? `magic-cookie-item-${useId()}`);
+const mappedActive = computed(() => item.active);
+const { initializeItem, deleteItem } = useCookieItem({
+  instanceId
+});
+const item = initializeItem({
+  id: mappedId.value,
+  optional,
+  maxAge
+});
+provide(MagicCookieItemId, mappedId.value);
+provide(MagicCookieItemActive, mappedActive);
+onBeforeUnmount(() => {
+  deleteItem(mappedId.value);
 });
 </script>
 

package/dist/plugins/MagicCookie/src/components/MagicCookieItem.vue.d.ts

@@ -3,30 +3,17 @@ interface MagicCookieItemProps {
     optional?: boolean;
     maxAge?: number;
 }
-declare function __VLS_template(): {
-    attrs: Partial<{}>;
-    slots: {
-        default?(_: {
-            item: import("../types").CookieItem;
-        }): any;
-    };
-    refs: {};
-    rootEl: HTMLDivElement;
+declare var __VLS_1: {
+    item: import("../types/index.js").CookieItem;
 };
-type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
-declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCookieItemProps>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<MagicCookieItemProps>>> & Readonly<{}>, {}, {}, {}, {}, 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_base: import("vue").DefineComponent<MagicCookieItemProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicCookieItemProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
     new (): {
         $slots: S;
     };

package/dist/plugins/MagicCookie/src/components/MagicCookieProvider.d.vue.ts

@@ -0,0 +1,19 @@
+import { type MaybeRef } from 'vue';
+import type { MagicCookieOptions } from '../types/index.js';
+type MagicCookieProviderProps = {
+    id: MaybeRef<string>;
+    options?: MagicCookieOptions;
+};
+declare var __VLS_7: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_7) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<MagicCookieProviderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<MagicCookieProviderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};