@merkaly/nuxt 0.1.4 → 0.1.7

package/dist/module.d.mts

@@ -1,2 +1,26 @@
-export * from "/Users/kronhyx/www/merkaly/src/nuxt/src/module.js";
-export { default } from "/Users/kronhyx/www/merkaly/src/nuxt/src/module.js";
+import * as _nuxt_schema from '@nuxt/schema';
+import { ClientAuthorizationParams } from '@auth0/auth0-spa-js';
+
+interface MerkalyModuleOptions {
+    auth0: {
+        audience: string;
+        callbackUrl: string;
+        client: string;
+        domain: string;
+        logoutUrl?: string;
+        params?: Omit<ClientAuthorizationParams, 'redirect_uri'>;
+        requiresAuth: boolean;
+    };
+    plausible?: {
+        domain: string;
+        localhost: string;
+    };
+    api: {
+        url: string;
+        prefix?: string;
+    };
+}
+declare const _default: _nuxt_schema.NuxtModule<MerkalyModuleOptions, MerkalyModuleOptions, false>;
+
+export { _default as default };
+export type { MerkalyModuleOptions };

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "0.1.4",
+  "version": "0.1.7",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,18 +1,73 @@
-import { createJiti } from "file:///Users/kronhyx/www/merkaly/src/nuxt/node_modules/.pnpm/jiti@2.6.1/node_modules/jiti/lib/jiti.mjs";
+import { defineNuxtModule, createResolver, addPlugin, addRouteMiddleware, addImportsDir, addComponentsDir } from '@nuxt/kit';
+import { defu } from 'defu';
+import { existsSync } from 'node:fs';
 
-const jiti = createJiti(import.meta.url, {
-  "interopDefault": true,
-  "alias": {
-    "@merkaly/nuxt": "/Users/kronhyx/www/merkaly/src/nuxt"
+const module = defineNuxtModule({
+  defaults: {
+    auth0: {
+      audience: "",
+      callbackUrl: "/auth",
+      client: "",
+      domain: "",
+      logoutUrl: "/",
+      params: {},
+      requiresAuth: false
+    },
+    plausible: {
+      domain: "",
+      localhost: ""
+    },
+    api: {
+      url: "/",
+      prefix: "/"
+    }
+  },
+  meta: { name: "@merkaly/nuxt", configKey: "merkaly", compatibility: { nuxt: ">=3.0.0" } },
+  moduleDependencies: {
+    "@bootstrap-vue-next/nuxt": {},
+    "@nuxt/eslint": {},
+    "@nuxt/fonts": {},
+    "@nuxt/image": {},
+    "@nuxtjs/plausible": {},
+    "@vueuse/nuxt": {}
   },
-  "transformOptions": {
-    "babel": {
-      "plugins": []
+  async setup(options, nuxt) {
+    const moduleResolver = createResolver(import.meta.url);
+    const rootResolver = createResolver(nuxt.options.rootDir);
+    nuxt.options.runtimeConfig.public.merkaly = defu(options, nuxt.options.runtimeConfig.public.merkaly || {});
+    nuxt.options.plausible = defu({
+      apiHost: "https://analytics.merkaly.io",
+      domain: options.plausible?.domain,
+      enableAutoOutboundTracking: true,
+      enableAutoPageviews: true,
+      enabled: process.env.NODE_ENV === "production",
+      // ✅ Solo en producción
+      ignoredHostnames: ["localhost"].concat(options.plausible?.localhost || "").filter(Boolean)
+    }, nuxt.options.plausible || {});
+    const bootstrapConfigPath = rootResolver.resolve("bootstrap.config.ts");
+    let BootstrapConfig;
+    if (existsSync(bootstrapConfigPath)) {
+      BootstrapConfig = await import(bootstrapConfigPath) || {};
     }
+    if (!BootstrapConfig) {
+      BootstrapConfig = {};
+    }
+    nuxt.options["bootstrapVueNext"] = defu(nuxt.options["bootstrapVueNext"] || {}, { plugin: { components: BootstrapConfig } });
+    addPlugin({ src: moduleResolver.resolve("./runtime/plugins/api.global") });
+    addPlugin({ src: moduleResolver.resolve("./runtime/plugins/auth0.client"), mode: "client" });
+    addRouteMiddleware({
+      global: options.auth0.requiresAuth,
+      name: "auth",
+      path: moduleResolver.resolve("./runtime/middleware/auth")
+    });
+    addImportsDir(moduleResolver.resolve("./runtime/composables"));
+    addImportsDir(moduleResolver.resolve("./runtime/utils"));
+    addComponentsDir({
+      path: moduleResolver.resolve("./runtime/components"),
+      prefix: "MK"
+    });
+    nuxt.options["vite"] = defu(nuxt.options["vite"] || {}, { plugins: [require("vite-svg-loader")()] });
   }
-})
-
-/** @type {import("/Users/kronhyx/www/merkaly/src/nuxt/src/module.js")} */
-const _module = await jiti.import("/Users/kronhyx/www/merkaly/src/nuxt/src/module.ts");
+});
 
-export default _module?.default ?? _module;
+export { module as default };

package/dist/runtime/components/app.d.vue.ts

@@ -0,0 +1,15 @@
+declare var __VLS_11: {}, __VLS_13: {};
+type __VLS_Slots = {} & {
+    loading?: (props: typeof __VLS_11) => any;
+} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/runtime/components/app.vue

@@ -0,0 +1,23 @@
+<script setup>
+import { useRoute } from "#app";
+import { useAuth, watchOnce } from "#imports";
+import AuthMiddleware from "../middleware/auth";
+const $route = useRoute();
+const { isLoading } = useAuth();
+watchOnce(isLoading, () => AuthMiddleware($route, $route));
+</script>
+
+<template>
+  <main>
+    <NuxtRouteAnnouncer />
+    <BOrchestrator />
+
+    <!-- Mostramos spinner mientras auth se carga -->
+    <slot v-if="isLoading" name="loading" />
+
+    <!-- Renderizamos páginas solo cuando isLoading = false -->
+    <slot v-else>
+      <NuxtPage />
+    </slot>
+  </main>
+</template>

package/dist/runtime/components/app.vue.d.ts

@@ -0,0 +1,15 @@
+declare var __VLS_11: {}, __VLS_13: {};
+type __VLS_Slots = {} & {
+    loading?: (props: typeof __VLS_11) => any;
+} & {
+    default?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, 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/runtime/components/auth.d.vue.ts

@@ -0,0 +1,9 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    error: (reason: string) => any;
+    success: () => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onError?: ((reason: string) => any) | undefined;
+    onSuccess?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/auth.vue

@@ -0,0 +1,44 @@
+<script setup>
+import { useNuxtApp, showError } from "#app";
+import { callOnce } from "#imports";
+const { $auth0 } = useNuxtApp();
+const emit = defineEmits(["success", "error"]);
+const params = new URLSearchParams(window.location.search);
+const code = params.get("code");
+const error = params.get("error");
+const invitation = params.get("invitation");
+const organization = params.get("organization");
+function handleInvite() {
+  return $auth0.loginWithRedirect({ authorizationParams: { organization, invitation } });
+}
+function handleError() {
+  const errorDescription = params.get("error_description") ?? "Auth error";
+  emit("error", errorDescription);
+  return showError({
+    statusCode: 400,
+    statusMessage: errorDescription
+  });
+}
+function handleCode() {
+  return void $auth0.handleRedirectCallback().then(() => emit("success"));
+}
+callOnce(async () => {
+  if (invitation && organization) {
+    return handleInvite();
+  }
+  if (error) {
+    return handleError();
+  }
+  if (code) {
+    return handleCode();
+  }
+  return $auth0.loginWithRedirect();
+});
+</script>
+
+<template>
+  <div class="d-flex gap-3 justify-content-center align-items-center h-100">
+    <BSpinner variant="primary" />
+    <span v-text="'Loading...'" />
+  </div>
+</template>

package/dist/runtime/components/auth.vue.d.ts

@@ -0,0 +1,9 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    error: (reason: string) => any;
+    success: () => any;
+}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{
+    onError?: ((reason: string) => any) | undefined;
+    onSuccess?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,97 @@
+import type { ColorVariant } from 'bootstrap-vue-next';
+import type { PropType } from '#imports';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    mode: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    opacity: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: () => string;
+    };
+    provider: {
+        type: StringConstructor;
+        default: string;
+    };
+    reversed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    spin: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tag: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    text: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    variant: {
+        type: PropType<ColorVariant | string>;
+        default: () => string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    mode: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    opacity: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: () => string;
+    };
+    provider: {
+        type: StringConstructor;
+        default: string;
+    };
+    reversed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    spin: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tag: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    text: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    variant: {
+        type: PropType<ColorVariant | string>;
+        default: () => string;
+    };
+}>> & Readonly<{}>, {
+    text: string;
+    mode: string;
+    size: string;
+    tag: string;
+    variant: string;
+    opacity: string | number;
+    provider: string;
+    reversed: boolean;
+    spin: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,40 @@
+<script setup>
+import { computed } from "#imports";
+const props = defineProps({
+  mode: { type: String, default: "duotone" },
+  name: { type: String, required: true },
+  opacity: { type: [String, Number], default: () => "" },
+  provider: { type: String, default: "fa" },
+  reversed: { type: Boolean, default: false },
+  size: { type: String, default: () => "" },
+  spin: { type: Boolean, default: false },
+  tag: { type: String, default: () => "i" },
+  text: { type: String, default: () => "" },
+  variant: { type: String, default: () => "" }
+});
+const iconName = computed(() => `${props.provider}-${props.name}`);
+const iconMode = computed(() => `${props.provider}-${props.mode}`);
+const animateSpin = computed(() => props.spin ? `${props.provider}-spin` : void 0);
+const iconOpacity = computed(() => props.opacity ? `opacity-${props.opacity}` : void 0);
+const fontSize = computed(() => props.size ? `fs-${props.size}` : void 0);
+const fontColor = computed(() => props.variant ? `text-${props.variant}` : void 0);
+const classList = computed(() => [
+  iconName.value,
+  iconMode.value,
+  animateSpin.value,
+  iconOpacity.value,
+  fontSize.value,
+  fontColor.value
+].filter(Boolean));
+</script>
+
+<template>
+  <template v-if="props.text">
+    <span :class="{ 'flex-row-reverse': props.reversed }" class="d-flex align-items-center">
+      <component :is="props.tag" :class="classList" />
+      <span class="ps-1" v-text="props.text" />
+    </span>
+  </template>
+
+  <component :is="props.tag" v-else :class="classList" />
+</template>

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

@@ -0,0 +1,97 @@
+import type { ColorVariant } from 'bootstrap-vue-next';
+import type { PropType } from '#imports';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    mode: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    opacity: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: () => string;
+    };
+    provider: {
+        type: StringConstructor;
+        default: string;
+    };
+    reversed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    spin: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tag: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    text: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    variant: {
+        type: PropType<ColorVariant | string>;
+        default: () => string;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    mode: {
+        type: StringConstructor;
+        default: string;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    opacity: {
+        type: (NumberConstructor | StringConstructor)[];
+        default: () => string;
+    };
+    provider: {
+        type: StringConstructor;
+        default: string;
+    };
+    reversed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    spin: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tag: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    text: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    variant: {
+        type: PropType<ColorVariant | string>;
+        default: () => string;
+    };
+}>> & Readonly<{}>, {
+    text: string;
+    mode: string;
+    size: string;
+    tag: string;
+    variant: string;
+    opacity: string | number;
+    provider: string;
+    reversed: boolean;
+    spin: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,70 @@
+import type { PropType } from '#imports';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    base: {
+        type: NumberConstructor;
+        default: number;
+    };
+    currency: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    hideDecimal: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    locale: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    mode: {
+        type: PropType<Intl.NumberFormatOptionsStyle>;
+        default: string;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    base: {
+        type: NumberConstructor;
+        default: number;
+    };
+    currency: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    hideDecimal: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    locale: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    mode: {
+        type: PropType<Intl.NumberFormatOptionsStyle>;
+        default: string;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    value: number;
+    mode: keyof Intl.NumberFormatOptionsStyleRegistry;
+    base: number;
+    tag: string;
+    currency: string;
+    hideDecimal: boolean;
+    locale: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,39 @@
+<script setup>
+import { computed } from "#imports";
+const props = defineProps({
+  base: { type: Number, default: 100 },
+  currency: { type: String, default: () => "USD" },
+  hideDecimal: { type: Boolean, default: () => false },
+  locale: { type: String, default: () => "en-US" },
+  mode: { type: String, default: "currency" },
+  tag: { type: String, default: "span" },
+  value: { type: Number, default: 0 }
+});
+const price = computed(() => {
+  const price2 = props.value / props.base;
+  const money = price2.toLocaleString(props.locale, {
+    style: props.mode,
+    currency: props.currency
+  });
+  return {
+    currency: money[0],
+    value: money.slice(1, -3),
+    digits: money.slice(-3)
+  };
+});
+</script>
+
+<template>
+  <component :is="tag" class="format-money">
+    <span class="currency" v-text="price.currency" />
+    <span class="value" v-text="price.value" />
+    <sup v-if="!props.hideDecimal" class="digits" v-text="price.digits" />
+  </component>
+</template>
+
+<style scoped>
+.format-money {
+  font-variant-numeric: tabular-nums;
+  font-feature-settings: "tnum";
+}
+</style>

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

@@ -0,0 +1,70 @@
+import type { PropType } from '#imports';
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    base: {
+        type: NumberConstructor;
+        default: number;
+    };
+    currency: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    hideDecimal: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    locale: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    mode: {
+        type: PropType<Intl.NumberFormatOptionsStyle>;
+        default: string;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    base: {
+        type: NumberConstructor;
+        default: number;
+    };
+    currency: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    hideDecimal: {
+        type: BooleanConstructor;
+        default: () => boolean;
+    };
+    locale: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    mode: {
+        type: PropType<Intl.NumberFormatOptionsStyle>;
+        default: string;
+    };
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    value: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    value: number;
+    mode: keyof Intl.NumberFormatOptionsStyleRegistry;
+    base: number;
+    tag: string;
+    currency: string;
+    hideDecimal: boolean;
+    locale: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,88 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    decimal: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    thousands: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    precision: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    prefix: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    suffix: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    min: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | number>;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    decimal: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    thousands: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    precision: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    prefix: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    suffix: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    min: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | number>;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {
+    prefix: string;
+    decimal: string;
+    thousands: string;
+    precision: number;
+    suffix: string;
+    min: number;
+    max: number;
+    placeholder: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,35 @@
+<script setup>
+import { computed } from "#imports";
+import { Money3Component } from "v-money3";
+const model = defineModel({ type: [String, Number], ...{
+  default: () => 0,
+  get: (v) => v / 100,
+  set: (v) => v * 100,
+  type: [String, Number]
+} });
+const props = defineProps({
+  decimal: { type: String, default: () => "." },
+  thousands: { type: String, default: () => "," },
+  precision: { type: Number, default: () => 2 },
+  prefix: { type: String, default: () => "" },
+  suffix: { type: String, default: () => "" },
+  min: { type: Number, default: void 0 },
+  max: { type: Number, default: void 0 },
+  placeholder: { type: String, default: () => "0.00" }
+});
+const config = computed(() => ({
+  class: "form-control",
+  decimal: props.decimal,
+  max: props.max,
+  min: props.min,
+  placeholder: props.placeholder,
+  precision: props.precision,
+  prefix: props.prefix ? `${props.prefix} ` : "",
+  suffix: props.suffix,
+  thousands: props.thousands
+}));
+</script>
+
+<template>
+  <Money3Component v-model="model" v-bind="config" />
+</template>

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

@@ -0,0 +1,88 @@
+declare const __VLS_export: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    decimal: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    thousands: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    precision: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    prefix: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    suffix: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    min: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | number>;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:modelValue": (value: string | number) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    decimal: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    thousands: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    precision: {
+        type: NumberConstructor;
+        default: () => number;
+    };
+    prefix: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    suffix: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    min: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: () => string;
+    };
+    modelValue: {
+        type: import("vue").PropType<string | number>;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | number) => any) | undefined;
+}>, {
+    prefix: string;
+    decimal: string;
+    thousands: string;
+    precision: number;
+    suffix: string;
+    min: number;
+    max: number;
+    placeholder: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,18 @@
+import type { ApiOptions } from '../plugins/api.global.js';
+export interface ComposableOptions extends ApiOptions {
+    immediate?: boolean;
+    uri: string;
+}
+export type CallbackArgs<T extends object> = (args: T) => ComposableOptions;
+declare function useApi<D extends object>(callback: CallbackArgs<D>): {
+    abort: {
+        (reason?: any): void;
+        (reason?: any): void;
+    };
+    data: import("vue").Ref<unknown, unknown>;
+    error: import("vue").Ref<Error | undefined, Error | undefined>;
+    execute: (args?: Partial<D>) => any;
+    loading: import("vue").Ref<boolean, boolean>;
+    meta: import("vue").Ref<{}, {}>;
+};
+export { useApi };

package/dist/runtime/composables/useApi.js

@@ -0,0 +1,42 @@
+import { ref, reactive, useNuxtApp } from "#imports";
+function useApi(callback) {
+  const { $api } = useNuxtApp();
+  const controller = new AbortController();
+  const params = reactive({});
+  const getOptions = (currentParams) => {
+    const options = callback(currentParams);
+    options.method ||= "GET";
+    options.immediate ??= options.method === "GET";
+    return options;
+  };
+  const initialOptions = getOptions(params);
+  const loading = ref(false);
+  const data = ref(initialOptions.default?.());
+  const meta = ref({});
+  const error = ref();
+  const execute = (args = {}) => {
+    Object.assign(params, args);
+    const currentOptions = getOptions(params);
+    return $api(currentOptions.uri, {
+      ...currentOptions,
+      controller,
+      data,
+      default: currentOptions.default,
+      error,
+      loading,
+      meta
+    });
+  };
+  if (initialOptions.immediate) {
+    void execute();
+  }
+  return {
+    abort: controller.abort,
+    data,
+    error,
+    execute,
+    loading,
+    meta
+  };
+}
+export { useApi };

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

@@ -0,0 +1,8 @@
+import type { User } from '@auth0/auth0-spa-js';
+export declare const useAuth: () => {
+    isAuthenticated: import("vue").ComputedRef<boolean>;
+    isLoading: import("vue").Ref<boolean, boolean>;
+    tenant: import("vue").ComputedRef<any>;
+    token: import("vue").Ref<string | null, string | null>;
+    user: import("vue").Ref<User | null, User | null>;
+};

package/dist/runtime/composables/useAuth.js

@@ -0,0 +1,15 @@
+import { useState, computed } from "#imports";
+export const useAuth = () => {
+  const user = useState("auth:user", () => null);
+  const token = useState("auth:token", () => null);
+  const isLoading = useState("auth:loading", () => true);
+  const tenant = computed(() => user.value?.org_id);
+  const isAuthenticated = computed(() => Boolean(user.value?.sub));
+  return {
+    isAuthenticated,
+    isLoading,
+    tenant,
+    token,
+    user
+  };
+};

package/dist/runtime/middleware/auth.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").RouteMiddleware;
+export default _default;

package/dist/runtime/middleware/auth.js

@@ -0,0 +1,20 @@
+import { defineNuxtRouteMiddleware, navigateTo, useRuntimeConfig } from "#app";
+import { useAuth } from "../composables/useAuth.js";
+export default defineNuxtRouteMiddleware((to) => {
+  const { isLoading, isAuthenticated } = useAuth();
+  const { public: { merkaly } } = useRuntimeConfig();
+  if (isLoading.value) {
+    return;
+  }
+  if (to.path === merkaly.auth0.callbackUrl) {
+    return;
+  }
+  const requiresAuth = typeof to.meta.requiresAuth === "boolean" ? to.meta.requiresAuth : merkaly.auth0.requiresAuth;
+  if (!requiresAuth) {
+    return;
+  }
+  if (isAuthenticated.value) {
+    return;
+  }
+  return navigateTo(merkaly.auth0.callbackUrl);
+});

package/dist/runtime/plugins/api.global.d.ts

@@ -0,0 +1,47 @@
+import type { Ref } from '#imports';
+import type { FetchOptions, FetchResponse } from 'ofetch';
+type OnBeforeSendArgs = {
+    query: FetchOptions['query'];
+    body: FetchOptions['body'];
+    headers: FetchOptions['headers'];
+};
+type OnResponseArgs = {
+    response: FetchResponse<unknown>;
+    request: RequestInfo;
+};
+type OnSuccessArgs = {
+    data: unknown;
+    meta: Record<string, unknown>;
+    headers: FetchOptions['headers'];
+};
+type OnCompleteArgs = {
+    response?: FetchResponse<unknown>;
+    request: RequestInfo;
+};
+export interface RefOptions {
+    data?: Ref<unknown>;
+    error?: Ref<unknown>;
+    loading?: Ref<boolean>;
+    meta?: Ref<Record<string, unknown>>;
+}
+export interface HooksOptions {
+    onBeforeSend?(args: OnBeforeSendArgs): Promise<unknown> | unknown;
+    onComplete?(args: OnCompleteArgs): Promise<unknown> | unknown;
+    onError?(reason: Error): Promise<unknown> | unknown;
+    onFatal?(reason: Error): Promise<unknown> | unknown;
+    onResponse?(args: OnResponseArgs): Promise<unknown> | unknown;
+    onSuccess?(args: OnSuccessArgs): Promise<unknown> | unknown;
+}
+export interface ParamsOptions {
+    body?: FetchOptions['body'];
+    controller?: AbortController;
+    default?: () => unknown;
+    headers?: FetchOptions['headers'];
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    prefix?: string;
+    query?: FetchOptions['query'];
+    timeout?: FetchOptions['timeout'];
+}
+export type ApiOptions = ParamsOptions & HooksOptions & RefOptions;
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/api.global.js

@@ -0,0 +1,54 @@
+import { defineNuxtPlugin, useRuntimeConfig } from "#app";
+import { useAuth } from "#imports";
+export default defineNuxtPlugin(({ provide }) => provide("api", async (url, options = {}) => {
+  const { public: $config } = useRuntimeConfig();
+  const { tenant, token } = useAuth();
+  $fetch(url, {
+    // Determine the base URL
+    baseURL: new URL(options.prefix || $config.merkaly.api.prefix || "/", $config.merkaly.api.url).href,
+    body: options?.body,
+    headers: {
+      authorization: token.value ? `Bearer ${token.value}` : "",
+      identity: tenant.value,
+      ...options?.headers
+    },
+    method: options?.method,
+    onRequest: async () => {
+      if (options.data) options.data.value = options.default?.();
+      if (options.meta) options.meta.value = {};
+      if (options.error) options.error.value = void 0;
+      if (options.loading) options.loading.value = true;
+      const result = await Promise.resolve(options?.onBeforeSend?.({ body: options.body, headers: options.headers, query: options.query })).then((res) => res).catch(() => false);
+      if (result === false) {
+        options.controller?.abort?.("Request aborted by onBeforeSend");
+      }
+    },
+    onRequestError: async ({ error, response, request }) => {
+      await options.onFatal?.(error);
+      if (options.error) options.error.value = error;
+      await options?.onComplete?.({ response, request });
+      if (options.loading) options.loading.value = false;
+    },
+    onResponse: async ({ response, request }) => {
+      const { status, _data, headers } = response;
+      const { data, meta } = _data || {};
+      await options?.onResponse?.({ response, request });
+      if (status >= 400) return;
+      await options?.onSuccess?.({ data, meta, headers });
+      if (options.data) options.data.value = data;
+      if (options.meta) options.meta.value = meta;
+      await options?.onComplete?.({ response, request });
+      if (options.loading) options.loading.value = false;
+    },
+    onResponseError: async ({ response, request }) => {
+      const { _data } = response;
+      await options.onError?.(_data);
+      if (options.error) options.error.value = _data;
+      await options?.onComplete?.({ response, request });
+      if (options.loading) options.loading.value = false;
+    },
+    query: options?.query,
+    retry: false,
+    signal: options.controller?.signal
+  }).catch((reason) => reason);
+}));

package/dist/runtime/plugins/auth0.client.d.ts

@@ -0,0 +1,6 @@
+declare const _default: import("nuxt/app").Plugin<{
+    auth0: import("@auth0/auth0-spa-js").Auth0Client;
+}> & import("nuxt/app").ObjectPlugin<{
+    auth0: import("@auth0/auth0-spa-js").Auth0Client;
+}>;
+export default _default;

package/dist/runtime/plugins/auth0.client.js

@@ -0,0 +1,34 @@
+import { createAuth0Client } from "@auth0/auth0-spa-js";
+import { defineNuxtPlugin, useRuntimeConfig } from "#imports";
+import { navigateTo } from "#app";
+import { defu } from "defu";
+import { useAuth } from "../composables/useAuth.js";
+export default defineNuxtPlugin(async () => {
+  const { public: $config } = useRuntimeConfig();
+  const auth0 = await createAuth0Client({
+    cacheLocation: "localstorage",
+    clientId: $config.merkaly.auth0.client,
+    domain: $config.merkaly.auth0.domain,
+    useRefreshTokens: true
+  });
+  const { isLoading, user, token } = useAuth();
+  const self0 = Object.assign(Object.create(Object.getPrototypeOf(auth0)), auth0);
+  auth0.getUser = () => self0.getUser().then((result) => user.value = result).catch((reason) => console.error("[Auth0] getUser failed", reason));
+  auth0.getTokenSilently = (options = {}) => self0.getTokenSilently(defu({ authorizationParams: { audience: $config.merkaly.auth0.audience } }, options)).then((result) => token.value = result).catch((err) => console.warn("[Auth0] getTokenSilently failed \u2013 fallback, user logged in?", err));
+  auth0.handleRedirectCallback = () => self0.handleRedirectCallback().then(({ appState }) => Promise.allSettled([auth0.getUser(), auth0.getTokenSilently()]).then(() => void navigateTo(appState?.target || "/"))).catch(() => navigateTo("/"));
+  auth0.loginWithRedirect = () => self0.loginWithRedirect({
+    authorizationParams: {
+      audience: $config.merkaly.auth0.audience,
+      redirect_uri: URL.canParse($config.merkaly.auth0.callbackUrl) ? $config.merkaly.auth0.callbackUrl : location.origin.concat($config.merkaly.auth0.callbackUrl),
+      scope: "openid profile email offline_access"
+      // necesario aquí para API
+    }
+  });
+  auth0.logout = () => self0.logout({
+    logoutParams: {
+      returnTo: URL.canParse($config.merkaly.auth0.logoutUrl) ? $config.merkaly.auth0.logoutUrl : location.origin.concat($config.merkaly.auth0.logoutUrl)
+    }
+  });
+  Promise.allSettled([auth0.getUser(), auth0.getTokenSilently()]).catch(() => void 0).finally(() => isLoading.value = false);
+  return { provide: { auth0 } };
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/types/nuxt.d.ts

@@ -0,0 +1,16 @@
+import type { Auth0Client } from '@auth0/auth0-spa-js';
+import type { ApiOptions } from '../plugins/api.global';
+
+declare module '#app' {
+  interface NuxtApp {
+    $auth0: Auth0Client;
+    $api: (url: string, options?: ApiOptions) => Promise<unknown>;
+  }
+}
+
+declare module 'vue' {
+  interface ComponentCustomProperties {
+    $auth0: Auth0Client;
+    $api: (url: string, options?: ApiOptions) => Promise<unknown>;
+  }
+}

package/dist/runtime/utils/withAdapter.d.ts

@@ -0,0 +1,22 @@
+import type { ComposableOptions } from '../composables/useApi.js';
+import type { HooksOptions } from '../plugins/api.global.js';
+type ReturnParams<T extends AdapterOptions> = () => {
+    params?: T['params'];
+} & HooksOptions;
+export interface AdapterOptions {
+    data: unknown;
+    meta: Record<string, object>;
+    params: object;
+}
+export declare const withAdapter: <T extends AdapterOptions>(callback: (params: T["params"]) => ComposableOptions) => (args?: ReturnParams<T>) => {
+    abort: {
+        (reason?: any): void;
+        (reason?: any): void;
+    };
+    data: import("vue").Ref<unknown, unknown>;
+    error: import("vue").Ref<Error | undefined, Error | undefined>;
+    execute: (args?: Partial<T["params"]>) => any;
+    loading: import("vue").Ref<boolean, boolean>;
+    meta: import("vue").Ref<{}, {}>;
+};
+export {};

package/dist/runtime/utils/withAdapter.js

@@ -0,0 +1,9 @@
+import { useApi } from "../composables/useApi.js";
+import { defu } from "defu";
+export const withAdapter = (callback) => (args) => useApi((executionParams) => {
+  const initialConfig = args?.() || {};
+  const { params: initialParams = {}, ...hooks } = initialConfig;
+  const mergedParams = defu(executionParams, initialParams);
+  const adapterResult = callback(mergedParams);
+  return defu(hooks, adapterResult);
+});

package/dist/types.d.mts

@@ -1,13 +1,9 @@
-import type { ModuleHooks, ModuleRuntimeHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module.mjs'
+import type { NuxtModule } from '@nuxt/schema'
 
-declare module '#app' {
-  interface RuntimeNuxtHooks extends ModuleRuntimeHooks {}
-}
+import type { default as Module } from './module.mjs'
 
-declare module '@nuxt/schema' {
-  interface NuxtHooks extends ModuleHooks {}
-  interface RuntimeConfig extends ModuleRuntimeConfig {}
-  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
-}
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
-export * from "./module.mjs"
+export { default } from './module.mjs'
+
+export { type MerkalyModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merkaly/nuxt",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/merkaly-io/nuxt.git"
@@ -27,6 +27,20 @@
   "files": [
     "dist"
   ],
+  "scripts": {
+    "build": "nuxt-module-build build",
+    "build:dev": "pnpm build --stub",
+    "dev": "pnpm dev:prepare && cd playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "pnpm build && pnpm -C playground install && nuxi prepare playground",
+    "lint": "eslint .",
+    "prepack": "pnpm dev:prepare",
+    "prepare": "nuxt-module-build prepare",
+    "release": "pnpm lint && pnpm test && pnpm build && changelogen --release && npm publish --access public && git push --follow-tags",
+    "test": "vitest run",
+    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
+    "test:watch": "vitest watch"
+  },
   "dependencies": {
     "@auth0/auth0-spa-js": "^2.11.0",
     "@bootstrap-vue-next/nuxt": "^0.42.0",
@@ -45,6 +59,7 @@
     "@vueuse/nuxt": "^14.1.0",
     "bootstrap": "^5.3.8",
     "bootstrap-vue-next": "^0.42.0",
+    "defu": "^6.1.4",
     "eslint": "^9.39.1",
     "nuxt": "^4.2.0",
     "sass": "^1.97.0",
@@ -59,6 +74,7 @@
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "^4.2.0",
     "@nuxt/test-utils": "^3.23.0",
+    "baseline-browser-mapping": "^2.9.14",
     "changelogen": "^0.6.2",
     "eslint-plugin-storybook": "^10.1.11",
     "vitest": "^4.0.6",
@@ -66,16 +82,5 @@
   },
   "engines": {
     "node": ">=20.0.0"
-  },
-  "scripts": {
-    "build": "nuxt-module-build build --stub",
-    "dev": "pnpm dev:prepare && cd playground && pnpm storybook",
-    "dev:build": "nuxi build playground",
-    "dev:prepare": "pnpm build && nuxi prepare playground",
-    "lint": "eslint .",
-    "release": "pnpm lint && pnpm test && pnpm build && changelogen --release && npm publish --access public && git push --follow-tags",
-    "test": "vitest run",
-    "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit",
-    "test:watch": "vitest watch"
   }
-}
+}

package/dist/module.d.cts

@@ -1,2 +0,0 @@
-export * from "/Users/kronhyx/www/merkaly/src/nuxt/src/module.js";
-export { default } from "/Users/kronhyx/www/merkaly/src/nuxt/src/module.js";