@merkaly/nuxt 0.1.9 → 0.1.11

package/dist/module.d.mts

@@ -1,5 +1,7 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { ClientAuthorizationParams } from '@auth0/auth0-spa-js';
+export { AdapterArgs, AdapterOptions } from '../dist/runtime/utils/withAdapter.js';
+export { ApiOptions, HooksOptions, ParamsOptions, RefOptions } from '../dist/runtime/plugins/api.global.js';
 
 interface MerkalyModuleOptions {
     auth0: {

package/dist/module.json

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

package/dist/module.mjs

@@ -103,7 +103,7 @@ const module = defineNuxtModule({
     const bootstrapConfigPath = rootResolver.resolve("bootstrap.config.ts");
     let BootstrapConfig;
     if (existsSync(bootstrapConfigPath)) {
-      BootstrapConfig = await import(bootstrapConfigPath) || {};
+      await import(bootstrapConfigPath).then((result) => BootstrapConfig = result.default).catch(() => BootstrapConfig = {});
     }
     if (!BootstrapConfig) {
       BootstrapConfig = {};

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

@@ -1,18 +1,17 @@
+import type { Ref } from 'vue';
 import type { ApiOptions } from '../plugins/api.global.js';
-export interface ComposableOptions extends ApiOptions {
+export interface ComposableOptions<TData = unknown, TMeta = Record<string, unknown>> extends ApiOptions<TData, TMeta> {
     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 interface UseApiReturn<TData, TMeta, TParams> {
+    abort: () => void;
+    data: Ref<TData | undefined>;
+    error: Ref<Error | undefined>;
+    execute: (args?: Partial<TParams>) => Promise<void>;
+    loading: Ref<boolean>;
+    meta: Ref<TMeta>;
+    params: TParams;
+}
+declare function useApi<TData = unknown, TMeta = Record<string, unknown>, TParams extends object = object>(callback: (params: TParams) => ComposableOptions<TData, TMeta>): UseApiReturn<TData, TMeta, TParams>;
 export { useApi };

package/dist/runtime/composables/useApi.js

@@ -14,10 +14,12 @@ function useApi(callback) {
   const data = ref(initialOptions.default?.());
   const meta = ref({});
   const error = ref();
-  const execute = (args = {}) => {
-    Object.assign(params, args);
+  const execute = async (args = {}) => {
+    Object.keys(args).forEach((key) => {
+      params[key] = args[key];
+    });
     const currentOptions = getOptions(params);
-    return $api(currentOptions.uri, {
+    await $api(currentOptions.uri, {
       ...currentOptions,
       controller,
       data,
@@ -31,12 +33,13 @@ function useApi(callback) {
     void execute();
   }
   return {
-    abort: controller.abort,
+    abort: () => controller.abort(),
     data,
     error,
     execute,
     loading,
-    meta
+    meta,
+    params
   };
 }
 export { useApi };

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

@@ -9,9 +9,9 @@ type OnResponseArgs = {
     response: FetchResponse<unknown>;
     request: RequestInfo;
 };
-type OnSuccessArgs = {
-    data: unknown;
-    meta: Record<string, unknown>;
+type OnSuccessArgs<TData = unknown, TMeta = Record<string, unknown>> = {
+    data: TData;
+    meta: TMeta;
     headers: FetchOptions['headers'];
 };
 type OnCompleteArgs = {
@@ -24,13 +24,13 @@ export interface RefOptions {
     loading?: Ref<boolean>;
     meta?: Ref<Record<string, unknown>>;
 }
-export interface HooksOptions {
+export interface HooksOptions<TData = unknown, TMeta = Record<string, unknown>> {
     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;
+    onSuccess?(args: OnSuccessArgs<TData, TMeta>): Promise<unknown> | unknown;
 }
 export interface ParamsOptions {
     body?: FetchOptions['body'];
@@ -42,6 +42,6 @@ export interface ParamsOptions {
     query?: FetchOptions['query'];
     timeout?: FetchOptions['timeout'];
 }
-export type ApiOptions = ParamsOptions & HooksOptions & RefOptions;
+export type ApiOptions<TData = unknown, TMeta = Record<string, unknown>> = ParamsOptions & HooksOptions<TData, TMeta> & RefOptions;
 declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
 export default _default;

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

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

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

@@ -1,22 +1,13 @@
-import type { ComposableOptions } from '../composables/useApi.js';
+import type { ComposableOptions, UseApiReturn } 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>;
+    meta: Record<string, unknown>;
     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 interface AdapterArgs<TData, TMeta, TParams> extends HooksOptions<TData, TMeta> {
+    params?: Partial<TParams>;
+}
+type AdapterCallback<T extends AdapterOptions> = (args: T['params']) => AdapterArgs<T['data'], T['meta'], T['params']>;
+export declare const withAdapter: <T extends AdapterOptions>(callback: (params: T["params"]) => ComposableOptions<T["data"], T["meta"]>) => (args?: AdapterCallback<T>) => UseApiReturn<T["data"], T["meta"], T["params"]>;
 export {};

package/dist/runtime/utils/withAdapter.js

@@ -1,9 +1,11 @@
 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);
-});
+export const withAdapter = (callback) => (args) => {
+  return useApi((executionParams) => {
+    const config = args?.(executionParams) || {};
+    const { params: initialParams = {}, ...hooks } = config;
+    const mergedParams = defu(executionParams, initialParams);
+    const adapterResult = callback(mergedParams);
+    return defu(hooks, adapterResult);
+  });
+};

package/dist/types.d.mts

@@ -4,6 +4,10 @@ import type { default as Module } from './module.mjs'
 
 export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
+export { type AdapterArgs, type AdapterOptions } from '../dist/runtime/utils/withAdapter.js'
+
+export { type ApiOptions, type HooksOptions, type ParamsOptions, type RefOptions } from '../dist/runtime/plugins/api.global.js'
+
 export { default } from './module.mjs'
 
 export { type MerkalyModuleOptions } from './module.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@merkaly/nuxt",
-  "version": "0.1.9",
+  "version": "0.1.11",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/merkaly-io/nuxt.git"
@@ -27,20 +27,6 @@
   "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",
@@ -80,5 +66,17 @@
   },
   "engines": {
     "node": ">=20.0.0"
+  },
+  "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 .",
+    "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"
   }
-}
+}