@ginjou/nuxt 0.1.0-beta.2 → 0.1.0-beta.4

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) zhong666 <hi@zhong666.me> and bouzu contributors
+Copyright (c) zhong666 <hi@zhong666.me>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/module.cjs

@@ -1,5 +1,154 @@
-module.exports = function(...args) {
-  return import('./module.mjs').then(m => m.default.call(this, ...args))
+'use strict';
+
+const kit = require('@nuxt/kit');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const composables$2 = [
+  // Query
+  {
+    from: "./runtime/composables/get-one",
+    name: "useAsyncGetOne"
+  },
+  {
+    from: "./runtime/composables/get-many",
+    name: "useAsyncGetMany"
+  },
+  {
+    from: "./runtime/composables/get-list",
+    name: "useAsyncGetList"
+  },
+  {
+    from: "./runtime/composables/get-infinite-list",
+    name: "useAsyncGetInfiniteList"
+  },
+  // Controllers
+  {
+    from: "./runtime/composables/show",
+    name: "useAsyncShow"
+  },
+  {
+    from: "./runtime/composables/list",
+    name: "useAsyncList"
+  },
+  {
+    from: "./runtime/composables/form",
+    name: "useAsyncForm"
+  },
+  {
+    from: "./runtime/composables/select",
+    name: "useAsyncSelect"
+  },
+  {
+    from: "./runtime/composables/infinite-list",
+    name: "useAsyncInfiniteList"
+  }
+];
+function ImportListForAsync(resolve) {
+  return composables$2.map(
+    (item) => ({
+      from: resolve(item.from),
+      name: item.name
+    })
+  );
 }
-const _meta = module.exports.meta = require('./module.json')
-module.exports.getMeta = () => Promise.resolve(_meta)
+
+const composables$1 = [
+  "useAccessContext",
+  "useAuthContext",
+  "useAuthenticated",
+  "useBack",
+  "useCheckError",
+  "useCreate",
+  "useCreateMany",
+  "useCustom",
+  "useCustomMutation",
+  "useDelete",
+  "useDeleteMany",
+  "useFetchersContext",
+  "useForm",
+  "useGetIdentity",
+  "useGetInfiniteList",
+  "useGetList",
+  "useGetMany",
+  "useGetOne",
+  "useGo",
+  "useI18nContext",
+  "useInfiniteList",
+  "useList",
+  "useLocale",
+  "useLocation",
+  "useLogin",
+  "useLogout",
+  "useNavigateTo",
+  "useNotificationContext",
+  "useNotify",
+  "usePermissions",
+  "usePublish",
+  "useQueryClientContext",
+  "useRealtimeContext",
+  "useRealtimeOptions",
+  "useResolvePath",
+  "useResource",
+  "useResourceContext",
+  "useResourcePath",
+  "useRouterContext",
+  "useSelect",
+  "useShow",
+  "useSubscribe",
+  "useTranslate",
+  "useUpdate",
+  "useUpdateMany"
+];
+const ImportListForGinjou = composables$1.map(
+  (name) => ({
+    name,
+    from: "@ginjou/vue"
+  })
+);
+
+const composables = [
+  "useQuery",
+  "useQueries",
+  "useInfiniteQuery",
+  "useMutation",
+  "useIsFetching",
+  "useIsMutating",
+  "useQueryClient"
+];
+const ImportListForTanstackQuery = composables.map(
+  (name) => ({
+    name,
+    from: "@tanstack/vue-query"
+  })
+);
+
+const module$1 = kit.defineNuxtModule({
+  meta: {
+    name: "ginjou",
+    configKey: "ginjou"
+  },
+  defaults: {
+    router: true
+  },
+  setup: async (options, nuxt) => {
+    const { resolve } = kit.createResolver((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('module.cjs', document.baseURI).href)));
+    nuxt.hook("vite:extend", ({ config }) => {
+      config.optimizeDeps ??= {};
+      config.optimizeDeps.exclude ??= [];
+      config.optimizeDeps.exclude.push(...[
+        "@ginjou/core",
+        "@ginjou/vue",
+        "@ginjou/with-vue-router",
+        "@ginjou/with-vue-i18n"
+      ]);
+    });
+    kit.addImports(ImportListForTanstackQuery);
+    kit.addImports(ImportListForGinjou);
+    kit.addImports(ImportListForAsync(resolve));
+    kit.addPlugin(resolve("./runtime/query-hydrate-plugin"));
+    if (options.router)
+      kit.addPlugin(resolve("./runtime/router-plugin"));
+  }
+});
+
+module.exports = module$1;

package/dist/module.d.cts

@@ -0,0 +1,13 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface Options {
+    router?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<{
+    router: boolean;
+}, {
+    router: boolean;
+}, false>;
+
+export = _default;
+export type { Options };

package/dist/module.d.mts

@@ -1,16 +1,13 @@
 import * as _nuxt_schema from '@nuxt/schema';
 
 interface Options {
-    query?: string;
-    router?: boolean | string;
-    i18n?: string;
-    resource?: string;
-    auth?: string;
-    access?: string;
-    fetcher?: string;
-    realtime?: string;
-    notification?: string;
+    router?: boolean;
 }
-declare const _default: _nuxt_schema.NuxtModule<Options, Options, false>;
+declare const _default: _nuxt_schema.NuxtModule<{
+    router: boolean;
+}, {
+    router: boolean;
+}, false>;
 
-export { type Options, _default as default };
+export { _default as default };
+export type { Options };

package/dist/module.json

@@ -1,9 +1,9 @@
 {
   "name": "ginjou",
   "configKey": "ginjou",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.4",
   "builder": {
-    "@nuxt/module-builder": "0.8.4",
-    "unbuild": "2.0.0"
+    "@nuxt/module-builder": "1.0.1",
+    "unbuild": "3.5.0"
   }
 }

package/dist/module.mjs

@@ -1,6 +1,53 @@
-import { defineNuxtModule, createResolver, addTemplate, updateTemplates, addImports, addPlugin } from '@nuxt/kit';
-import { existsSync } from 'node:fs';
-import { readFile } from 'node:fs/promises';
+import { defineNuxtModule, createResolver, addImports, addPlugin } from '@nuxt/kit';
+
+const composables$2 = [
+  // Query
+  {
+    from: "./runtime/composables/get-one",
+    name: "useAsyncGetOne"
+  },
+  {
+    from: "./runtime/composables/get-many",
+    name: "useAsyncGetMany"
+  },
+  {
+    from: "./runtime/composables/get-list",
+    name: "useAsyncGetList"
+  },
+  {
+    from: "./runtime/composables/get-infinite-list",
+    name: "useAsyncGetInfiniteList"
+  },
+  // Controllers
+  {
+    from: "./runtime/composables/show",
+    name: "useAsyncShow"
+  },
+  {
+    from: "./runtime/composables/list",
+    name: "useAsyncList"
+  },
+  {
+    from: "./runtime/composables/form",
+    name: "useAsyncForm"
+  },
+  {
+    from: "./runtime/composables/select",
+    name: "useAsyncSelect"
+  },
+  {
+    from: "./runtime/composables/infinite-list",
+    name: "useAsyncInfiniteList"
+  }
+];
+function ImportListForAsync(resolve) {
+  return composables$2.map(
+    (item) => ({
+      from: resolve(item.from),
+      name: item.name
+    })
+  );
+}
 
 const composables$1 = [
   "useAccessContext",
@@ -23,6 +70,7 @@ const composables$1 = [
   "useGetOne",
   "useGo",
   "useI18nContext",
+  "useInfiniteList",
   "useList",
   "useLocale",
   "useLocation",
@@ -71,147 +119,16 @@ const ImportListForTanstackQuery = composables.map(
   })
 );
 
-function createConfigTemplate(props) {
-  const opt = props.options[props.key];
-  const paths = typeof opt === "string" ? {
-    src: props.resolve(props.nuxt.options.srcDir, opt),
-    nitro: toNitroPath(props.nuxt.options.rootDir, props.resolve(props.nuxt.options.buildDir, props.filename))
-  } : void 0;
-  return {
-    paths,
-    template: {
-      filename: props.filename,
-      getContents: async () => {
-        if (opt === false)
-          return `export default undefined`;
-        if (typeof opt === "string" && paths != null) {
-          const content = await loadContent(paths.src);
-          if (content)
-            return content;
-        }
-        return props.fallback ?? `export default undefined`;
-      },
-      write: true
-    }
-  };
-}
-async function loadContent(path) {
-  if (existsSync(path))
-    return (await readFile(path)).toString();
-}
-function toNitroPath(base, full) {
-  return full.replace(base, "root").replaceAll("/", ":");
-}
-
-function createRouterTemplate(props) {
-  return createConfigTemplate({
-    ...props,
-    key: "router",
-    filename: "ginjou-router.ts",
-    fallback: `
-		import { createRouterBinding } from '@ginjou/with-vue-router'
-		export default createRouterBinding
-		`
-  });
-}
-
 const module = defineNuxtModule({
   meta: {
     name: "ginjou",
     configKey: "ginjou"
   },
   defaults: {
-    query: "ginjou/query.ts",
-    router: "ginjou/router.ts",
-    i18n: "ginjou/i18n.ts",
-    resource: "ginjou/resource.ts",
-    auth: "ginjou/auth.ts",
-    access: "ginjou/access.ts",
-    fetcher: "ginjou/fetcher.ts",
-    realtime: "ginjou/realtime.ts",
-    notification: "ginjou/notification.ts"
+    router: true
   },
   setup: async (options, nuxt) => {
     const { resolve } = createResolver(import.meta.url);
-    const templates = [
-      createRouterTemplate({
-        nuxt,
-        resolve,
-        options
-      }),
-      createConfigTemplate({
-        key: "query",
-        filename: "ginjou-query.ts",
-        nuxt,
-        resolve,
-        options
-      }),
-      createConfigTemplate({
-        key: "i18n",
-        filename: "ginjou-i18n.ts",
-        nuxt,
-        resolve,
-        options
-      }),
-      createConfigTemplate({
-        key: "resource",
-        filename: "ginjou-resource.ts",
-        nuxt,
-        resolve,
-        options
-      }),
-      createConfigTemplate({
-        key: "auth",
-        filename: "ginjou-auth.ts",
-        nuxt,
-        resolve,
-        options
-      }),
-      createConfigTemplate({
-        key: "access",
-        filename: "ginjou-access.ts",
-        nuxt,
-        resolve,
-        options
-      }),
-      createConfigTemplate({
-        key: "fetcher",
-        filename: "ginjou-fetcher.ts",
-        nuxt,
-        resolve,
-        options
-      }),
-      createConfigTemplate({
-        key: "realtime",
-        filename: "ginjou-realtime.ts",
-        nuxt,
-        resolve,
-        options
-      }),
-      createConfigTemplate({
-        key: "notification",
-        filename: "ginjou-notification.ts",
-        nuxt,
-        resolve,
-        options
-      })
-    ];
-    for (const { template } of templates) {
-      addTemplate(template);
-    }
-    nuxt.hook("builder:watch", async (event, relativePath) => {
-      if (!["add", "unlink", "change"].includes(event)) {
-        return;
-      }
-      const path = resolve(nuxt.options.srcDir, relativePath);
-      const target = templates.find((item) => item.paths?.src === path);
-      if (!target)
-        return;
-      await updateTemplates({
-        filter: (template) => template.filename === target.template.filename
-      });
-      await nuxt.hooks.callHook("restart", { hard: true });
-    });
     nuxt.hook("vite:extend", ({ config }) => {
       config.optimizeDeps ??= {};
       config.optimizeDeps.exclude ??= [];
@@ -224,7 +141,10 @@ const module = defineNuxtModule({
     });
     addImports(ImportListForTanstackQuery);
     addImports(ImportListForGinjou);
-    addPlugin(resolve("./runtime/plugin"));
+    addImports(ImportListForAsync(resolve));
+    addPlugin(resolve("./runtime/query-hydrate-plugin"));
+    if (options.router)
+      addPlugin(resolve("./runtime/router-plugin"));
   }
 });
 

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

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseFormContext, UseFormProps, UseFormResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncForm<TQueryData extends BaseRecord = BaseRecord, TMutationParams = unknown, TQueryError = unknown, TQueryResultData extends BaseRecord = TQueryData, TMutationData extends BaseRecord = TQueryResultData, TMutationError = unknown>(props?: UseFormProps<TQueryData, TMutationParams, TQueryError, TQueryResultData, TMutationData, TMutationError>, context?: UseFormContext): AsyncResult<UseFormResult<TMutationParams, TQueryError, TQueryResultData, TMutationData, TMutationError>>;

package/dist/runtime/composables/form.js

@@ -0,0 +1,8 @@
+import { useForm } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncForm(props, context) {
+  const result = useForm(props, context);
+  return withAsync(result, async () => {
+    await result.query.suspense();
+  });
+}

package/dist/runtime/composables/get-infinite-list.d.ts

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseGetInfiniteListContext, UseGetInfiniteListProps, UseGetInfiniteListResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncGetInfiniteList<TData extends BaseRecord = BaseRecord, TError = unknown, TResultData extends BaseRecord = TData, TPageParam = number>(props: UseGetInfiniteListProps<TData, TError, TResultData, TPageParam>, context?: UseGetInfiniteListContext): AsyncResult<UseGetInfiniteListResult<TError, TResultData, TPageParam>>;

package/dist/runtime/composables/get-infinite-list.js

@@ -0,0 +1,8 @@
+import { useGetInfiniteList } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncGetInfiniteList(props, context) {
+  const query = useGetInfiniteList(props, context);
+  return withAsync(query, async () => {
+    await query.suspense();
+  });
+}

package/dist/runtime/composables/get-list.d.ts

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseGetListContext, UseGetListProps, UseGetListResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncGetList<TData extends BaseRecord = BaseRecord, TError = unknown, TResultData extends BaseRecord = TData, TPageParam = number>(props: UseGetListProps<TData, TError, TResultData, TPageParam>, context?: UseGetListContext): AsyncResult<UseGetListResult<TError, TResultData, TPageParam>>;

package/dist/runtime/composables/get-list.js

@@ -0,0 +1,8 @@
+import { useGetList } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncGetList(props, context) {
+  const query = useGetList(props, context);
+  return withAsync(query, async () => {
+    await query.suspense();
+  });
+}

package/dist/runtime/composables/get-many.d.ts

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseGetManyContext, UseGetManyProps, UseGetManyResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncGetMany<TData extends BaseRecord = BaseRecord, TError = unknown, TResultData extends BaseRecord = TData>(props: UseGetManyProps<TData, TError, TResultData>, context?: UseGetManyContext): AsyncResult<UseGetManyResult<TData, TError, TResultData>>;

package/dist/runtime/composables/get-many.js

@@ -0,0 +1,8 @@
+import { useGetMany } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncGetMany(props, context) {
+  const query = useGetMany(props, context);
+  return withAsync(query, async () => {
+    await query.suspense();
+  });
+}

package/dist/runtime/composables/get-one.d.ts

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseGetOneContext, UseGetOneProps, UseGetOneResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncGetOne<TData extends BaseRecord = BaseRecord, TError = unknown, TResultData extends BaseRecord = TData>(props: UseGetOneProps<TData, TError, TResultData>, context?: UseGetOneContext): AsyncResult<UseGetOneResult<TError, TResultData>>;

package/dist/runtime/composables/get-one.js

@@ -0,0 +1,8 @@
+import { useGetOne } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncGetOne(props, context) {
+  const query = useGetOne(props, context);
+  return withAsync(query, async () => {
+    await query.suspense();
+  });
+}

package/dist/runtime/composables/infinite-list.d.ts

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseInfiniteListContext, UseInfiniteListProps, UseInfiniteListResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncInfiniteList<TData extends BaseRecord = BaseRecord, TError = unknown, TResultData extends BaseRecord = TData, TPageParam = number>(props?: UseInfiniteListProps<TData, TError, TResultData, TPageParam>, context?: UseInfiniteListContext): AsyncResult<UseInfiniteListResult<TError, TResultData, TPageParam>>;

package/dist/runtime/composables/infinite-list.js

@@ -0,0 +1,8 @@
+import { useInfiniteList } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncInfiniteList(props, context) {
+  const query = useInfiniteList(props, context);
+  return withAsync(query, async () => {
+    await query.suspense();
+  });
+}

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

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseListContext, UseListProps, UseListResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncList<TData extends BaseRecord = BaseRecord, TError = unknown, TResultData extends BaseRecord = TData>(props?: UseListProps<TData, TError, TResultData>, context?: UseListContext): AsyncResult<UseListResult<TError, TResultData>>;

package/dist/runtime/composables/list.js

@@ -0,0 +1,8 @@
+import { useList } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncList(props, context) {
+  const query = useList(props, context);
+  return withAsync(query, async () => {
+    await query.suspense();
+  });
+}

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

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseSelectContext, UseSelectProps, UseSelectResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncSelect<TData extends BaseRecord = BaseRecord, TError = unknown, TResultData extends BaseRecord = TData, TPageParam = number>(props?: UseSelectProps<TData, TError, TResultData, TPageParam>, context?: UseSelectContext): AsyncResult<UseSelectResult<TError, TResultData, TPageParam>>;

package/dist/runtime/composables/select.js

@@ -0,0 +1,8 @@
+import { useSelect } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncSelect(props, context) {
+  const result = useSelect(props, context);
+  return withAsync(result, async () => {
+    await result.suspense();
+  });
+}

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

@@ -0,0 +1,4 @@
+import type { BaseRecord } from '@ginjou/core';
+import type { UseShowContext, UseShowProps, UseShowResult } from '@ginjou/vue';
+import type { AsyncResult } from '../utils/async.js';
+export declare function useAsyncShow<TData extends BaseRecord = BaseRecord, TError = unknown, TResultData extends BaseRecord = TData>(props?: UseShowProps<TData, TError, TResultData>, context?: UseShowContext): AsyncResult<UseShowResult<TError, TResultData>>;

package/dist/runtime/composables/show.js

@@ -0,0 +1,8 @@
+import { useShow } from "@ginjou/vue";
+import { withAsync } from "../utils/async.js";
+export function useAsyncShow(props, context) {
+  const query = useShow(props, context);
+  return withAsync(query, async () => {
+    await query.suspense();
+  });
+}

package/dist/runtime/query-hydrate-plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/query-hydrate-plugin.js

@@ -0,0 +1,22 @@
+import { defineNuxtPlugin, useState } from "#imports";
+import { getQueryClients, setQueryClientDehydrateState } from "@ginjou/vue";
+import { dehydrate } from "@tanstack/vue-query";
+export default defineNuxtPlugin({
+  name: "ginjou/query-hydrate-plugin",
+  setup: (nuxt) => {
+    const dehydratedStateMap = useState("ginjou-query/dehydrated-state-map");
+    if (import.meta.server) {
+      nuxt.hooks.hook("app:rendered", () => {
+        const clients = getQueryClients();
+        dehydratedStateMap.value = Object.fromEntries(
+          [...clients].map(([key, client]) => [key, dehydrate(client)])
+        );
+      });
+    }
+    if (import.meta.client && dehydratedStateMap.value != null) {
+      for (const [key, value] of Object.entries(dehydratedStateMap.value)) {
+        setQueryClientDehydrateState(key, value);
+      }
+    }
+  }
+});

package/dist/runtime/router-plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt/app").Plugin<Record<string, unknown>> & import("nuxt/app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/router-plugin.js

@@ -0,0 +1,11 @@
+import { defineNuxtPlugin } from "#imports";
+import { defineRouterContext } from "@ginjou/vue";
+import { createRouterBinding } from "@ginjou/with-vue-router";
+export default defineNuxtPlugin({
+  name: "ginjou/router-plugin",
+  setup: (nuxt) => {
+    nuxt.hook("vue:setup", () => {
+      defineRouterContext(createRouterBinding());
+    });
+  }
+});

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

@@ -0,0 +1,2 @@
+export type AsyncResult<T extends Record<string, unknown>> = T & Promise<T>;
+export declare function withAsync<T extends Record<string, unknown>>(value: T, wait: () => Promise<void>): AsyncResult<T>;

package/dist/runtime/utils/async.js

@@ -0,0 +1,18 @@
+import { useNuxtApp } from "#imports";
+import { getCurrentInstance, onServerPrefetch } from "vue";
+export function withAsync(value, wait) {
+  const nuxtApp = useNuxtApp();
+  if (import.meta.server) {
+    const instance = getCurrentInstance();
+    const handler = async () => {
+      await wait();
+    };
+    if (instance)
+      onServerPrefetch(handler);
+    else
+      nuxtApp.hook("app:created", handler);
+  }
+  const promise = Promise.resolve(wait()).then(() => value);
+  Object.assign(promise, value);
+  return promise;
+}

package/dist/types.d.mts

@@ -1,7 +1,9 @@
 import type { NuxtModule } from '@nuxt/schema'
 
-import type { default as Module } from './module.js'
+import type { default as Module } from './module.mjs'
 
 export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
 
-export { type Options, default } from './module.js'
+export { default } from './module.mjs'
+
+export { type Options } from './module.mjs'

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@ginjou/nuxt",
   "type": "module",
-  "version": "0.1.0-beta.2",
+  "version": "0.1.0-beta.4",
   "author": "zhong666 <hi@zhong666.me>",
   "license": "MIT",
+  "homepage": "https://github.com/aa900031/ginjou#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/aa900031/ginjou"
+    "url": "git+https://github.com/aa900031/ginjou.git",
+    "directory": "packages/nuxt"
   },
   "bugs": {
     "url": "https://github.com/aa900031/ginjou/issues"
@@ -14,13 +16,20 @@
   "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/module.d.ts",
+      "types": "./dist/types.d.mts",
       "import": "./dist/module.mjs",
       "require": "./dist/module.cjs"
     }
   },
   "main": "./dist/module.mjs",
-  "types": "./dist/module.d.ts",
+  "types": "./dist/types.d.mts",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types.d.mts"
+      ]
+    }
+  },
   "files": [
     "dist"
   ],
@@ -28,17 +37,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@nuxt/kit": "^3.9.0",
-    "@ginjou/vue": "^0.1.0-beta.6",
-    "@ginjou/with-vue-router": "^0.1.0-beta.1"
+    "@nuxt/kit": "^3.17.1",
+    "@ginjou/vue": "^0.1.0-beta.8",
+    "@ginjou/with-vue-router": "^0.1.0-beta.2"
   },
   "devDependencies": {
-    "@nuxt/module-builder": "^0.8.4",
-    "@nuxt/schema": "^3.9.0",
-    "@nuxt/test-utils": "^3.14.4",
-    "npm-run-all2": "^6.2.6",
-    "nuxt": "^3.14.1592",
-    "@ginjou/vue": "^0.1.0-beta.6"
+    "@nuxt/module-builder": "^1.0.1",
+    "@nuxt/schema": "^3.17.1",
+    "@nuxt/test-utils": "^3.17.2",
+    "nuxt": "^3.17.1"
   },
   "scripts": {
     "build": "run-s build:prepare build:bundle",

package/dist/module.d.ts

@@ -1,16 +0,0 @@
-import * as _nuxt_schema from '@nuxt/schema';
-
-interface Options {
-    query?: string;
-    router?: boolean | string;
-    i18n?: string;
-    resource?: string;
-    auth?: string;
-    access?: string;
-    fetcher?: string;
-    realtime?: string;
-    notification?: string;
-}
-declare const _default: _nuxt_schema.NuxtModule<Options, Options, false>;
-
-export { type Options, _default as default };

package/dist/runtime/plugin.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/runtime/plugin.js

@@ -1,41 +0,0 @@
-import GinjouAccess from "#build/ginjou-access";
-import GinjouAuth from "#build/ginjou-auth";
-import GinjouFetcher from "#build/ginjou-fetcher";
-import GinjouI18n from "#build/ginjou-i18n";
-import GinjouNotification from "#build/ginjou-notification";
-import GinjouQuery from "#build/ginjou-query";
-import GinjouRealtime from "#build/ginjou-realtime";
-import GinjouResource from "#build/ginjou-resource";
-import GinjouRouter from "#build/ginjou-router";
-import { defineNuxtPlugin, useState } from "#imports";
-import VuePlugin from "@ginjou/vue/plugin";
-import { dehydrate, hydrate, QueryClient } from "@tanstack/vue-query";
-export default defineNuxtPlugin({
-  setup: (nuxt) => {
-    const queryState = useState("ginjou-query-key");
-    const queryClient = getQueryClient(GinjouQuery);
-    nuxt.vueApp.use(VuePlugin, {
-      query: GinjouQuery,
-      router: GinjouRouter,
-      i18n: GinjouI18n,
-      resource: GinjouResource,
-      auth: GinjouAuth,
-      access: GinjouAccess,
-      fetcher: GinjouFetcher,
-      realtime: GinjouRealtime,
-      notification: GinjouNotification
-    });
-    if (import.meta.server) {
-      nuxt.hooks.hook("app:rendered", () => {
-        queryState.value = dehydrate(queryClient);
-      });
-    }
-    if (import.meta.client)
-      hydrate(queryClient, queryState.value);
-  }
-});
-function getQueryClient(options) {
-  const client = "queryClient" in options && options.queryClient != null ? options.queryClient : new QueryClient("queryClientConfig" in options ? options.queryClientConfig : void 0);
-  options.queryClient = client;
-  return client;
-}

package/dist/types.d.ts

@@ -1,7 +0,0 @@
-import type { NuxtModule } from '@nuxt/schema'
-
-import type { default as Module } from './module'
-
-export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
-
-export { type Options, default } from './module'