@ginjou/nuxt 0.1.0-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) zhong666 <hi@zhong666.me> and bouzu contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,16 @@
+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/module.d.ts

@@ -0,0 +1,16 @@
+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/module.json

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

package/dist/module.mjs

@@ -0,0 +1,231 @@
+import { defineNuxtModule, createResolver, addTemplate, updateTemplates, addImports, addPlugin } from '@nuxt/kit';
+import { existsSync } from 'node:fs';
+import { readFile } from 'node:fs/promises';
+
+const composables$1 = [
+  "useAccessContext",
+  "useAuthContext",
+  "useAuthenticated",
+  "useBack",
+  "useCheckError",
+  "useCreate",
+  "useCreateMany",
+  "useCustom",
+  "useCustomMutation",
+  "useDelete",
+  "useDeleteMany",
+  "useFetchersContext",
+  "useForm",
+  "useGetIdentity",
+  "useGetInfiniteList",
+  "useGetList",
+  "useGetMany",
+  "useGetOne",
+  "useGo",
+  "useI18nContext",
+  "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"
+  })
+);
+
+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"
+  },
+  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 ??= [];
+      config.optimizeDeps.exclude.push(...[
+        "@ginjou/core",
+        "@ginjoy/vue",
+        "@ginjou/with-vue-router",
+        "@ginjou/with-vue-i18n"
+      ]);
+    });
+    addImports(ImportListForTanstackQuery);
+    addImports(ImportListForGinjou);
+    addPlugin(resolve("./runtime/plugin"));
+  }
+});
+
+export { module as default };

package/dist/runtime/plugin.d.ts

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

package/dist/runtime/plugin.js

@@ -0,0 +1,41 @@
+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.mts

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

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+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'

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@ginjou/nuxt",
+  "type": "module",
+  "version": "0.1.0-beta.1",
+  "author": "zhong666 <hi@zhong666.me>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/aa900031/ginjou"
+  },
+  "bugs": {
+    "url": "https://github.com/aa900031/ginjou/issues"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/module.d.ts",
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.mjs",
+  "types": "./dist/module.d.ts",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@nuxt/kit": "^3.9.0",
+    "@ginjou/vue": "^0.1.0-beta.6",
+    "@ginjou/with-vue-router": "^0.1.0-beta.1"
+  },
+  "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"
+  },
+  "scripts": {
+    "build": "run-s build:prepare build:bundle",
+    "build:bundle": "nuxt-module-build build",
+    "build:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare",
+    "dev:playground": "nuxi dev playground",
+    "dev": "run-s build:prepare dev:playground",
+    "release": "release-it --ci"
+  }
+}