@merkaly/nuxt 0.1.4 → 0.1.8

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.8",
   "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:stub": "nuxt-module-build build --stub",
+    "dev": "pnpm dev:prepare && cd playground && pnpm storybook",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "pnpm build:stub && nuxi prepare playground",
+    "lint": "eslint .",
+    "prepack": "pnpm build",
+    "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",
@@ -66,16 +80,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";