@anweb/nuxt-ancore 1.1.2 → 1.3.0

package/dist/index.d.mts

@@ -1 +1 @@
-export { default as api } from '../dist/runtime/utils/api.js';
+export * from '../dist/runtime/utils/index.js';

package/dist/index.d.ts

@@ -1 +1 @@
-export { default as api } from '../dist/runtime/utils/api.js';
+export * from '../dist/runtime/utils/index.js';

package/dist/index.mjs

@@ -1 +1 @@
-export { default as api } from '../dist/runtime/utils/api.js';
+export * from '../dist/runtime/utils/index.js';

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "AnCore",
   "configKey": "ancore",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "builder": {
     "@nuxt/module-builder": "1.0.1",
     "unbuild": "3.5.0"

package/dist/module.mjs

@@ -1,14 +1,17 @@
-import { defineNuxtModule, createResolver } from '@nuxt/kit';
+import { defineNuxtModule, createResolver, addImportsDir } from '@nuxt/kit';
 
 const module = defineNuxtModule({
   meta: {
     name: "AnCore",
     configKey: "ancore"
   },
-  // Default configuration options of the Nuxt module
   defaults: {},
-  setup(_options, _nuxt) {
-    createResolver(import.meta.url);
+  async setup(_options, _nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    _nuxt.options.runtimeConfig.public.ancore = {};
+    _nuxt.options.alias["#ancore/utils"] = resolve("./runtime/utils");
+    _nuxt.options.alias["#ancore/types"] = resolve("./runtime/types");
+    addImportsDir(resolve("./runtime/composables"));
   }
 });
 

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

@@ -0,0 +1,16 @@
+import type { NitroFetchRequest } from 'nitropack';
+import { type Ref, type ComputedRef } from 'vue';
+import { useAsyncData } from '#app';
+interface TConfig {
+    request: NitroFetchRequest;
+}
+interface TUseData<TData, TError> {
+    init: () => Promise<void>;
+    loading: ComputedRef<boolean>;
+    request: Ref<NitroFetchRequest>;
+    data: ComputedRef<TData>;
+    error: ComputedRef<TError>;
+    status: ReturnType<typeof useAsyncData>['status'];
+}
+export declare const useData: <TData = unknown, TError = unknown>(config: TConfig) => TUseData<TData, TError>;
+export {};

package/dist/runtime/composables/useData.js

@@ -0,0 +1,30 @@
+import { computed, ref } from "vue";
+import { useAsyncData } from "#app";
+import { userApi } from "#ancore/utils";
+export const useData = (config) => {
+  const request = ref(config.request);
+  const loading = computed(() => {
+    return status.value === "pending";
+  });
+  const key = computed(() => {
+    return request.value.toString();
+  });
+  const {
+    data,
+    error,
+    execute,
+    status
+  } = useAsyncData(
+    key,
+    () => userApi(request.value, { method: "GET" }),
+    { immediate: false }
+  );
+  return {
+    init: execute,
+    loading,
+    request,
+    data,
+    error,
+    status
+  };
+};

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

@@ -0,0 +1,20 @@
+import type { Rules } from 'async-validator';
+import { type UseAsyncValidatorExecuteReturn } from '@vueuse/integrations/useAsyncValidator';
+interface TFormParams<T> {
+    rules?: Rules;
+    empty: Record<keyof T, unknown>;
+    data?: Partial<T> | null;
+}
+declare const _default: <T = unknown>(params: TFormParams<T>) => {
+    state: [T] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<T, import("vue").Ref<T, T>, T> : import("vue").Ref<import("vue").UnwrapRef<T>, T | import("vue").UnwrapRef<T>>;
+    merge: (data: T) => void;
+    validator: {
+        check: () => Promise<UseAsyncValidatorExecuteReturn>;
+        errors: import("vue").Ref<Record<string, import("async-validator").ValidateError[]> | undefined, Record<string, import("async-validator").ValidateError[]> | undefined>;
+    };
+    history: {
+        isChanged: import("vue").ComputedRef<boolean>;
+        reset: () => void;
+    };
+};
+export default _default;

package/dist/runtime/composables/useForm.js

@@ -0,0 +1,68 @@
+import {
+  useAsyncValidator
+} from "@vueuse/integrations/useAsyncValidator";
+import { useRefHistory } from "@vueuse/core";
+import { computed, ref, nextTick, watchEffect, watch } from "vue";
+export default (params) => {
+  const state = ref(params.empty ? { ...params.empty } : {});
+  const keys = Object.keys(params.empty);
+  let validatorExecute;
+  const validatorErrors = ref();
+  const History = useRefHistory(state, { deep: true });
+  const init = () => {
+    if (params.data) merge(params.data);
+    if (params.rules) initValidate();
+    void nextTick(History.clear);
+  };
+  const merge = (data) => {
+    for (const key of keys) {
+      state.value[key] = data[key];
+    }
+  };
+  const initValidate = () => {
+    if (!params.rules) return;
+    const validator = useAsyncValidator(
+      state,
+      params.rules,
+      { manual: true }
+    );
+    validatorExecute = validator.execute;
+    watchEffect(() => {
+      validatorErrors.value = validator.errorFields.value;
+    });
+  };
+  const first = computed(() => {
+    return History.history.value.at(-1)?.snapshot;
+  });
+  const isChanged = computed(() => {
+    if (History.history.value.length === 1) return false;
+    const firstOne = JSON.stringify(first.value);
+    const last = JSON.stringify(History.last.value.snapshot);
+    return firstOne !== last;
+  });
+  watch(state, () => {
+    if (validatorErrors.value) {
+      validatorErrors.value = void 0;
+    }
+  }, { deep: true });
+  init();
+  return {
+    state,
+    merge: (data) => {
+      merge(data);
+    },
+    validator: {
+      check: () => {
+        return validatorExecute();
+      },
+      errors: validatorErrors
+    },
+    history: {
+      isChanged,
+      reset: () => {
+        state.value = first.value;
+        void nextTick(History.clear);
+      }
+    }
+  };
+};

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

@@ -0,0 +1,27 @@
+import type { NitroFetchRequest } from 'nitropack';
+import { type UseEventBusReturn } from '@vueuse/core';
+import type { TWS as TWSDefault } from '#ancore/types';
+interface TConfig<TData, TFilter, TWS extends TWSDefault> {
+    request: NitroFetchRequest;
+    filter?: TFilter;
+    reverse?: boolean;
+    events?: {
+        bus: UseEventBusReturn<any, any>;
+        callback: (list: TData[], count: number, data: any) => number | void;
+    }[];
+    ws?: {
+        type: TWS['type'];
+        callback: (list: TData[], count: number, data: any) => number | void;
+    }[];
+}
+declare const _default: <TData, TFilter = unknown, TWS extends TWSDefault = TWSDefault>(config: TConfig<TData, TFilter, TWS>) => {
+    init: (newFilter?: TFilter) => Promise<void>;
+    inited: import("vue").Ref<boolean, boolean>;
+    filter: [Partial<TFilter>] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & Partial<TFilter>, import("vue").Ref<import("vue").Ref<any, any> & Partial<TFilter>, import("vue").Ref<any, any> & Partial<TFilter>>, import("vue").Ref<any, any> & Partial<TFilter>> : import("vue").Ref<import("vue").UnwrapRef<Partial<TFilter>>, Partial<TFilter> | import("vue").UnwrapRef<Partial<TFilter>>>;
+    loading: import("vue").ComputedRef<boolean>;
+    items: TData[];
+    count: import("vue").Ref<number | null, number | null>;
+    error: import("vue").Ref<import("#app").NuxtError<unknown> | undefined, import("#app").NuxtError<unknown> | undefined>;
+    status: import("vue").Ref<import("#app").AsyncDataRequestStatus, import("#app").AsyncDataRequestStatus>;
+};
+export default _default;

package/dist/runtime/composables/useList.js

@@ -0,0 +1,82 @@
+import { useEventBus } from "@vueuse/core";
+import { computed, ref, reactive, watch } from "vue";
+import { useAsyncData } from "#app";
+import { userApi, toQuery } from "#ancore/utils";
+export default (config) => {
+  const busWS = useEventBus("ws");
+  const inited = ref(false);
+  const filter = ref(config.filter || {});
+  const items = reactive([]);
+  const count = ref(null);
+  const init = async (newFilter) => {
+    if (newFilter) {
+      filter.value = { ...newFilter };
+    } else if (config.filter) {
+      filter.value = { ...config.filter };
+    }
+    await execute();
+    refresh();
+    if (config.events) {
+      for (const event of config.events) {
+        event.bus.on((data2) => {
+          const newCount = event.callback(items, count.value || 0, data2);
+          if (newCount || newCount === 0) {
+            count.value = newCount;
+          }
+        });
+      }
+    }
+    if (config.ws) {
+      busWS.on((data2) => {
+        const event = config.ws?.find((item) => item.type === data2.type);
+        if (event) {
+          const newCount = event.callback(items, count.value || 0, data2.data);
+          if (newCount || newCount === 0) {
+            count.value = newCount;
+          }
+        }
+      });
+    }
+    inited.value = true;
+  };
+  const refresh = () => {
+    if (!data.value) return;
+    if (!filter.value.skip) {
+      count.value = null;
+      items.length = 0;
+    }
+    if (config.reverse) {
+      items.unshift(...data.value.items);
+    } else {
+      items.push(...data.value.items);
+    }
+    count.value = data.value.count;
+  };
+  const key = computed(() => {
+    return config.request + "?" + toQuery(filter.value);
+  });
+  const loading = computed(() => {
+    return status.value === "pending";
+  });
+  const {
+    data,
+    error,
+    execute,
+    status
+  } = useAsyncData(
+    key,
+    () => userApi(config.request, { method: "GET", query: filter.value }),
+    { immediate: false }
+  );
+  watch(data, refresh);
+  return {
+    init,
+    inited,
+    filter,
+    loading,
+    items,
+    count,
+    error,
+    status
+  };
+};

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

@@ -0,0 +1,3 @@
+export * from './nuxt.js';
+export * from './ws.js';
+export * from './responseList.js';

package/dist/runtime/types/index.js

@@ -0,0 +1,3 @@
+export * from "./nuxt";
+export * from "./ws.js";
+export * from "./responseList.js";

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

@@ -0,0 +1,8 @@
+import type { TApi } from '#ancore/utils'
+
+
+declare module '#app' {
+	interface NuxtApp {
+		$api: TApi
+	}
+}

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

@@ -0,0 +1,4 @@
+export interface TResponseList<TData> {
+    items: TData[];
+    count: number;
+}

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

@@ -0,0 +1,4 @@
+export interface TWS {
+    type: string;
+    data: unknown;
+}

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

@@ -1,3 +1,3 @@
 import type { NitroFetchOptions, NitroFetchRequest } from 'nitropack';
-declare const _default: <TData = unknown, TError = unknown>(request: NitroFetchRequest, opts: NitroFetchOptions<string>) => Promise<import("nitropack").TypedInternalResponse<NitroFetchRequest, TData, "get">>;
-export default _default;
+export declare const api: <TData = unknown, TError = unknown>(request: NitroFetchRequest, opts: NitroFetchOptions<string>) => Promise<TData>;
+export type TApi = typeof api;

package/dist/runtime/utils/api.js

@@ -1,6 +1,6 @@
-export default async (request, opts) => {
+export const api = (request, opts) => {
   try {
-    return await $fetch(
+    return $fetch(
       request,
       { ...opts }
     );

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

@@ -0,0 +1 @@
+export declare const asyncInit: (fInit: () => Promise<void>) => Promise<void>;

package/dist/runtime/utils/asyncInit.js

@@ -0,0 +1,9 @@
+import { useNuxtApp } from "#app";
+export const asyncInit = async (fInit) => {
+  const nuxtApp = useNuxtApp();
+  if (!!nuxtApp.vueApp._instance?.isMounted) {
+    void fInit();
+  } else {
+    await fInit();
+  }
+};

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

@@ -0,0 +1,4 @@
+export * from './api.js';
+export * from './asyncInit.js';
+export * from './userApi.js';
+export * from './toQuery.js';

package/dist/runtime/utils/index.js

@@ -0,0 +1,4 @@
+export * from "./api.js";
+export * from "./asyncInit.js";
+export * from "./userApi.js";
+export * from "./toQuery.js";

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

@@ -0,0 +1,4 @@
+type TValue = string | number | boolean | undefined | null;
+export type TQueryObject = Record<string, TValue | TValue[]>;
+export declare const toQuery: (params: TQueryObject) => string;
+export {};

package/dist/runtime/utils/toQuery.js

@@ -0,0 +1,3 @@
+export const toQuery = (params) => {
+  return Object.entries(params).filter(([, value]) => value != null).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`).join("&");
+};

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

@@ -0,0 +1,2 @@
+import type { NitroFetchOptions, NitroFetchRequest } from 'nitropack';
+export declare const userApi: <TData = unknown, TError = unknown>(request: NitroFetchRequest, opts: NitroFetchOptions<string>) => Promise<TData>;

package/dist/runtime/utils/userApi.js

@@ -0,0 +1,10 @@
+import { useNuxtApp } from "#app";
+import { api as coreApi } from "#ancore/utils";
+export const userApi = (request, opts) => {
+  const { $api } = useNuxtApp();
+  if ($api) {
+    return $api(request, opts);
+  } else {
+    return coreApi(request, opts);
+  }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@anweb/nuxt-ancore",
-	"version": "1.1.2",
+	"version": "1.3.0",
 	"description": "AnCore Nuxt module",
 	"repository": "https://github.com/ANLTD/ancore",
 	"license": "MIT",
@@ -13,7 +13,8 @@
 		"./module": {
 			"types": "./dist/types.d.mts",
 			"import": "./dist/module.mjs"
-		}
+		},
+		"./composables/*": "./dist/runtime/composables/*"
 	},
 	"main": "./dist/module.mjs",
 	"typesVersions": {
@@ -36,7 +37,10 @@
 		"release:major": "npm run prepack && changelogen --bump major --release && npm publish --access public && git push --follow-tags"
 	},
 	"dependencies": {
-		"@nuxt/kit": "^4.0.0"
+		"@nuxt/kit": "^4.0.0",
+		"@vueuse/core": "^13.5.0",
+		"@vueuse/integrations": "^13.5.0",
+		"async-validator": "^4.2.5"
 	},
 	"devDependencies": {
 		"@nuxt/devtools": "^2.6.2",
@@ -47,4 +51,4 @@
 		"nuxt": "^4.0.0",
 		"typescript": "~5.8.3"
 	}
-}
+}