@merkaly/nuxt 0.6.0 → 0.6.4

package/dist/runtime/components/format/FormatNumber.vue

@@ -0,0 +1,38 @@
+<script setup>
+import { computed, toRef } from "vue";
+import { useCounterUp } from "../../composables/useCounterUp";
+const props = defineProps({
+  currency: { type: String, default: () => "USD" },
+  tag: { type: String, default: "span" },
+  value: { type: Number, default: 0 },
+  type: { type: String, default: void 0 },
+  maxFractionDigits: {
+    type: Number,
+    default: void 0
+  }
+});
+const counter = useCounterUp(toRef(props, "value"), {
+  decimals: props.maxFractionDigits ?? 0
+});
+const number = computed(
+  () => Intl.NumberFormat("en-US", {
+    currency: props.currency,
+    maximumFractionDigits: props.maxFractionDigits,
+    notation: "compact",
+    style: props.type
+  }).format(counter.value)
+);
+</script>
+
+<template>
+  <component :is="tag" class="format-number">
+    <span v-text="number" />
+  </component>
+</template>
+
+<style scoped>
+.format-number {
+  font-variant-numeric: tabular-nums;
+  font-feature-settings: "tnum";
+}
+</style>

package/dist/runtime/components/format/FormatNumber.vue.d.ts

@@ -0,0 +1,52 @@
+import type { PropType } from 'vue';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    currency: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+    type: {
+        type: PropType<Intl.NumberFormatOptions["style"]>;
+        default: undefined;
+    };
+    maxFractionDigits: {
+        type: PropType<Intl.NumberFormatOptions["maximumFractionDigits"]>;
+        default: undefined;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    currency: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+    type: {
+        type: PropType<Intl.NumberFormatOptions["style"]>;
+        default: undefined;
+    };
+    maxFractionDigits: {
+        type: PropType<Intl.NumberFormatOptions["maximumFractionDigits"]>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    type: keyof Intl.NumberFormatOptionsStyleRegistry | undefined;
+    value: number;
+    currency: string;
+    tag: string;
+    maxFractionDigits: number | undefined;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/format/FormatText.d.vue.ts

@@ -1,3 +1,4 @@
+import type { PropType } from 'vue';
 declare var __VLS_9: string, __VLS_10: {};
 type __VLS_Slots = {} & {
     [K in NonNullable<typeof __VLS_9>]?: (props: typeof __VLS_10) => any;
@@ -6,6 +7,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     fallback: {
         type: StringConstructor;
         required: false;
+        default: () => undefined;
     };
     tag: {
         type: StringConstructor;
@@ -16,13 +18,15 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     values: {
-        type: PropType<Record<string, unknown>>;
+        type: PropType<object>;
         required: false;
+        default: () => {};
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     fallback: {
         type: StringConstructor;
         required: false;
+        default: () => undefined;
     };
     tag: {
         type: StringConstructor;
@@ -33,12 +37,14 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     values: {
-        type: PropType<Record<string, unknown>>;
+        type: PropType<object>;
         required: false;
+        default: () => {};
     };
 }>> & Readonly<{}>, {
-    values: any;
+    values: object;
     tag: string;
+    fallback: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/format/FormatText.vue

@@ -1,10 +1,10 @@
 <script setup>
 import { computed, useSlots } from "vue";
 const props = defineProps({
-  fallback: { type: String, required: false },
+  fallback: { type: String, required: false, default: () => void 0 },
   tag: { type: String, default: () => "span" },
   template: { type: String, required: true },
-  values: { type: Object, required: false }
+  values: { type: Object, required: false, default: () => ({}) }
 });
 const slots = useSlots();
 const contentParts = computed(() => {

package/dist/runtime/components/format/FormatText.vue.d.ts

@@ -1,3 +1,4 @@
+import type { PropType } from 'vue';
 declare var __VLS_9: string, __VLS_10: {};
 type __VLS_Slots = {} & {
     [K in NonNullable<typeof __VLS_9>]?: (props: typeof __VLS_10) => any;
@@ -6,6 +7,7 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
     fallback: {
         type: StringConstructor;
         required: false;
+        default: () => undefined;
     };
     tag: {
         type: StringConstructor;
@@ -16,13 +18,15 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     values: {
-        type: PropType<Record<string, unknown>>;
+        type: PropType<object>;
         required: false;
+        default: () => {};
     };
 }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
     fallback: {
         type: StringConstructor;
         required: false;
+        default: () => undefined;
     };
     tag: {
         type: StringConstructor;
@@ -33,12 +37,14 @@ declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPro
         required: true;
     };
     values: {
-        type: PropType<Record<string, unknown>>;
+        type: PropType<object>;
         required: false;
+        default: () => {};
     };
 }>> & Readonly<{}>, {
-    values: any;
+    values: object;
     tag: string;
+    fallback: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
 declare const _default: typeof __VLS_export;

package/dist/runtime/components/input/InputAddress.d.vue.ts

@@ -81,8 +81,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>, {
     mode: PlaceTypes;
     disabled: boolean;
-    placeholder: string;
     countries: string[];
+    placeholder: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/input/InputAddress.vue.d.ts

@@ -81,8 +81,8 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>, {
     mode: PlaceTypes;
     disabled: boolean;
-    placeholder: string;
     countries: string[];
+    placeholder: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
 declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/input/InputDateRange.vue

@@ -15,10 +15,10 @@ const presets = [
   { key: "lastMonth", label: "Last month", icon: "calendar-xmark" }
 ];
 const selectedPreset = ref(model.value?.preset || props.preset);
-const getDateRange = (preset) => {
+const getDateRange = (key) => {
   const now = /* @__PURE__ */ new Date();
   const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
-  switch (preset) {
+  switch (key) {
     case "today":
       return { start: today, end: today };
     case "yesterday": {
@@ -81,11 +81,11 @@ onBeforeMount(() => selectPreset(props.preset));
       <span class="fs-7 fw-bold text-gray-800">Date Range</span>
     </div>
 
-    <template v-for="preset in presets" :key="preset.key">
-      <BDropdownItem :active="selectedPreset === preset.key" @click="selectPreset(preset.key)">
+    <template v-for="item in presets" :key="item.key">
+      <BDropdownItem :active="selectedPreset === item.key" @click="selectPreset(item.key)">
         <div class="d-flex align-items-center gap-2">
-          <FormatIcon :name="preset.icon" class="text-gray-500" />
-          <span v-text="preset.label" />
+          <FormatIcon :name="item.icon" class="text-gray-500" />
+          <span v-text="item.label" />
         </div>
       </BDropdownItem>
     </template>

package/dist/runtime/components/input/InputDropzone.vue

@@ -41,7 +41,7 @@ function handleFileChange(files) {
         class="d-none"
         type="file"
         @change="(e) => handleFileChange(e.target.files)"
-    />
+    >
 
     <div class="dz-message needsclick" @click="triggerInput">
       <i class="ki-duotone ki-file-up text-primary fs-3x">

package/dist/runtime/components/input/InputMoney.d.vue.ts

@@ -74,9 +74,9 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: Numberish) => any) | undefined;
 }>, {
-    decimal: string;
     min: number;
     max: number;
+    decimal: string;
     placeholder: string;
     precision: number;
     prefix: string;

package/dist/runtime/components/input/InputMoney.vue

@@ -4,7 +4,7 @@ import { Money3Component } from "v-money3";
 const money = defineModel({ type: null, ...{
   default: () => 0,
   get: (v) => v / 100,
-  set: (v) => v * 100,
+  set: (v) => Math.trunc(v * 100),
   type: [String, Number]
 } });
 const props = defineProps({

package/dist/runtime/components/input/InputMoney.vue.d.ts

@@ -74,9 +74,9 @@ declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractP
 }>> & Readonly<{
     "onUpdate:modelValue"?: ((value: Numberish) => any) | undefined;
 }>, {
-    decimal: string;
     min: number;
     max: number;
+    decimal: string;
     placeholder: string;
     precision: number;
     prefix: string;

package/dist/runtime/components/input/InputSelect.d.vue.ts

@@ -14,18 +14,19 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         };
         fieldDisabled: {
             type: PropType<(item: T) => boolean>;
+            default: undefined;
         };
         fieldSort: {
             type: PropType<(item: T) => string>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         fieldText: {
             type: PropType<(item: T) => string>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         fieldValue: {
             type: PropType<(item: T) => unknown>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         filterable: {
             type: BooleanConstructor;
@@ -53,15 +54,16 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         };
         placeholder: {
             type: StringConstructor;
-        };
-        selectedItem: {
-            type: PropType<T>;
-            default: undefined;
+            default: () => undefined;
         };
         required: {
             type: BooleanConstructor;
             default: () => boolean;
         };
+        selectedItem: {
+            type: PropType<T>;
+            default: undefined;
+        };
         size: {
             type: PropType<Size>;
             default: () => undefined;
@@ -82,10 +84,7 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
             selectedOption: boolean;
         }) => any;
     };
-    emit: {
-        (e: "search", v: string): any;
-        (e: "request:selected", v: string): any;
-    } & ((evt: "update:modelValue", value: any) => void);
+    emit: ((e: "request:selected" | "search", v: string) => unknown) & ((event: "update:modelValue", value: any) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/runtime/components/input/InputSelect.vue

@@ -3,11 +3,11 @@ import { computed, onBeforeMount } from "vue";
 import { useDebounceFn } from "@vueuse/core";
 import VSelect from "vue-select";
 import FormatIcon from "../format/FormatIcon.vue";
-const emit = defineEmits(["search", "request:selected"]);
+const emit = defineEmits(["request:selected", "search"]);
 const props = defineProps({
   debounce: { type: Number, default: () => 250 },
   disabled: { type: Boolean, default: () => false },
-  fieldDisabled: { type: Function },
+  fieldDisabled: { type: Function, default: void 0 },
   fieldSort: { type: Function, default: (it) => it.fieldText },
   fieldText: { type: Function, default: ((it) => it.name) },
   fieldValue: { type: Function, default: ((it) => it._id) },
@@ -17,12 +17,12 @@ const props = defineProps({
   noClear: { type: Boolean, default: () => false },
   noCloseOnSelect: { type: Boolean, default: () => false },
   options: { type: Array, default: () => [] },
-  placeholder: { type: String },
-  selectedItem: { type: Object, default: void 0 },
+  placeholder: { type: String, default: () => void 0 },
   required: { type: Boolean, default: () => false },
+  selectedItem: { type: Object, default: void 0 },
   size: { type: String, default: () => void 0 }
 });
-const model = defineModel({ type: null, ...{ type: [String, Object, Number, Boolean, Array], default: null } });
+const model = defineModel({ type: [String, Object, Number, Boolean, Array], default: null });
 onBeforeMount(() => {
   if (props.selectedItem) return;
   if (model.value) {
@@ -79,17 +79,25 @@ const bindAttrs = computed(() => ({
 }));
 const bindOn = {
   search: (value) => {
-    value && debouncedFn(value);
+    if (value) debouncedFn(value);
     return value;
   }
 };
 const debouncedFn = useDebounceFn((value) => emit("search", value), props.debounce);
+const isRequired = computed(() => {
+  const isEmpty = props.multiple ? !model.value?.length : !model.value;
+  return props.required && isEmpty ? true : void 0;
+});
 </script>
 
 <template>
   <VSelect v-model="model" v-bind="bindAttrs" v-on="bindOn">
     <template #search="scope">
-      <input class="vs__search" v-bind="scope.attributes" v-on="scope.events" />
+      <input
+        :required="isRequired"
+        class="vs__search"
+        v-bind="scope.attributes"
+        v-on="scope.events">
     </template>
 
     <template #option="scope">
@@ -108,12 +116,12 @@ const debouncedFn = useDebounceFn((value) => emit("search", value), props.deboun
       <span :required="props.required || void 0" />
     </template>
 
-    <template #spinner="{ loading }">
-      <BSpinner v-if="loading" class="spinner" variant="primary" />
+    <template #spinner="{ loading: isLoading }">
+      <BSpinner v-if="isLoading" class="spinner" variant="primary" />
     </template>
 
-    <template #no-options="{ search, searching, loading }">
-      <span v-if="loading">Searching for "{{ search }}"</span>
+    <template #no-options="{ search, searching, loading: isLoading }">
+      <span v-if="isLoading">Searching for "{{ search }}"</span>
       <span v-else-if="searching">No results for "{{ search }}"</span>
       <span v-else>Type to search</span>
     </template>

package/dist/runtime/components/input/InputSelect.vue.d.ts

@@ -14,18 +14,19 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         };
         fieldDisabled: {
             type: PropType<(item: T) => boolean>;
+            default: undefined;
         };
         fieldSort: {
             type: PropType<(item: T) => string>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         fieldText: {
             type: PropType<(item: T) => string>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         fieldValue: {
             type: PropType<(item: T) => unknown>;
-            default: (it: any) => any;
+            default: (it: Record<string, unknown>) => unknown;
         };
         filterable: {
             type: BooleanConstructor;
@@ -53,15 +54,16 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
         };
         placeholder: {
             type: StringConstructor;
-        };
-        selectedItem: {
-            type: PropType<T>;
-            default: undefined;
+            default: () => undefined;
         };
         required: {
             type: BooleanConstructor;
             default: () => boolean;
         };
+        selectedItem: {
+            type: PropType<T>;
+            default: undefined;
+        };
         size: {
             type: PropType<Size>;
             default: () => undefined;
@@ -82,10 +84,7 @@ declare const __VLS_export: <T extends Record<string, any>>(__VLS_props: NonNull
             selectedOption: boolean;
         }) => any;
     };
-    emit: {
-        (e: "search", v: string): any;
-        (e: "request:selected", v: string): any;
-    } & ((evt: "update:modelValue", value: any) => void);
+    emit: ((e: "request:selected" | "search", v: string) => unknown) & ((event: "update:modelValue", value: any) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/runtime/components/table/TableDatagrid.d.vue.ts

@@ -76,7 +76,7 @@ declare const __VLS_export: <G>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     emit: {
         (e: "fetch", reason: "sort" | "filter" | "search" | "paginate" | "refresh"): void;
         (e: "toggle:item", item: G, expanded: boolean): void;
-    } & ((evt: "update:modelValue", value: DataGrid<G>) => void);
+    } & ((event: "update:modelValue", value: DataGrid<G>) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/runtime/components/table/TableDatagrid.vue

@@ -21,7 +21,9 @@ const canFilter = Boolean(slots.filters);
 const hasDetailsSlot = computed(() => Boolean(slots["details"]));
 const hasActionsSlot = computed(() => Boolean(slots["actions"]));
 const hasBulkSlot = computed(() => Boolean(slots["bulk"]));
-const visibleColumns = computed(() => Object.entries($datagrid.value.columns));
+const visibleColumns = computed(() => Object.entries($datagrid.value.columns).filter(({ 1: column }) => {
+  return column.visible !== false;
+}));
 const tableColspan = computed(() => {
   const baseColumns = 2;
   const selectColumn = props.hideSelect ? 0 : 1;
@@ -172,8 +174,8 @@ function getRowAttrs(item, idx) {
         v-if="$datagrid.loading"
         :value="100"
         animated
-        height="5px"
         class="rounded-0 position-absolute w-100 start-0"
+        height="5px"
         style="bottom: -6px; z-index: 10" />
     </BCardHeader>
 
@@ -200,7 +202,7 @@ function getRowAttrs(item, idx) {
           </BTh>
 
           <template v-for="[key, column] in visibleColumns" :key="key">
-            <BTh :class="[column.class, column.thClass]">
+            <BTh :class="[column.class, column.thClass, 'text-nowrap']">
               <slot :name="`head[${key}]`" v-bind="{ column, key }">
                 <span v-text="column.title ?? sentenceCase(key)" />
               </slot>
@@ -219,7 +221,7 @@ function getRowAttrs(item, idx) {
         </BTd>
       </BTbody>
 
-      <BTbody v-else class="fw-semibold text-gray-600">
+      <BTbody v-else class="fw-semibold text-nowrap">
         <template v-for="(item, idx) in visibleItems" :key="getRowKey(item, idx)">
           <BTr v-bind="getRowAttrs(item, idx)">
             <BTd v-if="hasDetailsSlot" class="p-0 w-25px">
@@ -247,7 +249,7 @@ function getRowAttrs(item, idx) {
             </template>
 
             <BTd v-if="hasActionsSlot" class="text-end px-3">
-              <DropdownIcon toggle-class="border border-secondary-subtle border-dashed text-body py-1 px-3">
+              <DropdownIcon icon="caret-down" text="Actions" toggle-class="py-1 px-3" variant="light-dark">
                 <slot :index="idx" :item="item" name="actions" />
               </DropdownIcon>
             </BTd>

package/dist/runtime/components/table/TableDatagrid.vue.d.ts

@@ -76,7 +76,7 @@ declare const __VLS_export: <G>(__VLS_props: NonNullable<Awaited<typeof __VLS_se
     emit: {
         (e: "fetch", reason: "sort" | "filter" | "search" | "paginate" | "refresh"): void;
         (e: "toggle:item", item: G, expanded: boolean): void;
-    } & ((evt: "update:modelValue", value: DataGrid<G>) => void);
+    } & ((event: "update:modelValue", value: DataGrid<G>) => void);
 }>) => import("vue").VNode & {
     __ctx?: Awaited<typeof __VLS_setup>;
 };

package/dist/runtime/composables/useCounterUp.d.ts

@@ -0,0 +1,8 @@
+import type { MaybeRefOrGetter } from 'vue';
+type UseCounterUpOptions = {
+    duration?: number;
+    decimals?: number;
+    ease?: string;
+};
+export declare function useCounterUp(target: MaybeRefOrGetter<number>, options?: UseCounterUpOptions): import("vue").ComputedRef<number>;
+export {};

package/dist/runtime/composables/useCounterUp.js

@@ -0,0 +1,30 @@
+import { watchImmediate } from "@vueuse/core";
+import gsap from "gsap";
+import { computed, onBeforeUnmount, reactive, toValue } from "vue";
+export function useCounterUp(target, options = {}) {
+  const { duration = 0.8, decimals = 0, ease = "power2.out" } = options;
+  const counter = reactive({
+    value: toValue(target) || 0
+  });
+  let tween;
+  let initialized = false;
+  watchImmediate(
+    () => toValue(target),
+    (value) => {
+      const nextValue = Number(value) || 0;
+      if (!initialized) {
+        counter.value = nextValue;
+        initialized = true;
+        return;
+      }
+      tween?.kill();
+      tween = gsap.to(counter, {
+        value: nextValue,
+        duration,
+        ease
+      });
+    }
+  );
+  onBeforeUnmount(() => tween?.kill());
+  return computed(() => Number(counter.value.toFixed(decimals)));
+}

package/dist/runtime/composables/useDatagrid.d.ts

@@ -5,20 +5,25 @@ export interface ColumnDefinition<C = unknown> {
     thClass?: string;
     title?: string;
     type?: unknown;
+    visible?: boolean;
 }
 export type DataGridItem<C> = C;
+export type DataGridAddItemMode = 'append' | 'prepend';
+export interface DataGridAddItemOptions {
+    mode?: DataGridAddItemMode;
+}
 export type DataGridRowAttrs = Record<string, unknown>;
 export type DataGridRowKey = string | number;
 export interface DataGridRowDefinition {
     attrs?: DataGridRowAttrs;
-    class?: string;
+    class?: string | Record<string, unknown>;
     key?: DataGridRowKey;
 }
 export interface DataGrid<C = unknown> {
     columns: Record<string, ColumnDefinition<C>>;
     error: unknown;
     fn: {
-        addItem: (item: C) => DataGridItem<C>[];
+        addItem: (item: C, options?: DataGridAddItemOptions) => DataGridItem<C>[];
         removeItem: (predicate: (item: DataGridItem<C>, index: number) => boolean) => number;
     };
     items: DataGridItem<C>[];

package/dist/runtime/composables/useDatagrid.js

@@ -4,8 +4,13 @@ export function useDatagrid(params) {
     columns: params.columns,
     error: params.error ?? null,
     fn: {
-      addItem(item) {
-        state.items.push(item);
+      addItem(item, options = {}) {
+        const mode = options.mode ?? "append";
+        if (mode === "prepend") {
+          state.items.unshift(item);
+        } else if (mode === "append") {
+          state.items.push(item);
+        }
         return state.items;
       },
       removeItem(predicate) {

package/dist/runtime/composables/useNotify.d.ts

@@ -0,0 +1,19 @@
+export interface NotifyOptions {
+    title?: string;
+    message?: string;
+    variant: 'success' | 'danger' | 'warning' | 'info';
+}
+export interface NotifyConfirmOptions extends NotifyOptions {
+    cancelText?: string;
+    confirmText?: string;
+    onConfirm?: () => void;
+}
+export interface NotifyAlertOptions extends NotifyOptions {
+    okText?: string;
+}
+export interface NotifyApi {
+    alert(options: NotifyAlertOptions): void;
+    confirm(options: NotifyConfirmOptions): void;
+    toast(options: NotifyOptions): unknown;
+}
+export declare function useNotify(): NotifyApi;