@merkaly/nuxt 0.1.4 → 0.1.8

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.8",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,18 +1,128 @@
-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 { existsSync } from 'node:fs';
 
-const jiti = createJiti(import.meta.url, {
-  "interopDefault": true,
-  "alias": {
-    "@merkaly/nuxt": "/Users/kronhyx/www/merkaly/src/nuxt"
-  },
-  "transformOptions": {
-    "babel": {
-      "plugins": []
+function isPlainObject(value) {
+  if (value === null || typeof value !== "object") {
+    return false;
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== null && prototype !== Object.prototype && Object.getPrototypeOf(prototype) !== null) {
+    return false;
+  }
+  if (Symbol.iterator in value) {
+    return false;
+  }
+  if (Symbol.toStringTag in value) {
+    return Object.prototype.toString.call(value) === "[object Module]";
+  }
+  return true;
+}
+
+function _defu(baseObject, defaults, namespace = ".", merger) {
+  if (!isPlainObject(defaults)) {
+    return _defu(baseObject, {}, namespace, merger);
+  }
+  const object = Object.assign({}, defaults);
+  for (const key in baseObject) {
+    if (key === "__proto__" || key === "constructor") {
+      continue;
+    }
+    const value = baseObject[key];
+    if (value === null || value === void 0) {
+      continue;
+    }
+    if (merger && merger(object, key, value, namespace)) {
+      continue;
+    }
+    if (Array.isArray(value) && Array.isArray(object[key])) {
+      object[key] = [...value, ...object[key]];
+    } else if (isPlainObject(value) && isPlainObject(object[key])) {
+      object[key] = _defu(
+        value,
+        object[key],
+        (namespace ? `${namespace}.` : "") + key.toString(),
+        merger
+      );
+    } else {
+      object[key] = value;
     }
   }
-})
+  return object;
+}
+function createDefu(merger) {
+  return (...arguments_) => (
+    // eslint-disable-next-line unicorn/no-array-reduce
+    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
+  );
+}
+const defu = createDefu();
 
-/** @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");
+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": {}
+  },
+  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")()] });
+  }
+});
 
-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>