@anweb/nuxt-ancore 1.9.3 → 1.10.0

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "AnCore",
   "configKey": "ancore",
-  "version": "1.9.3",
+  "version": "1.10.0",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

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

@@ -1,19 +1,19 @@
 import type { NitroFetchOptions, NitroFetchRequest } from 'nitropack';
 import { type Ref, type ComputedRef } from 'vue';
-import type { KeysOf, PickFrom } from '#app/composables/asyncData';
-import { useAsyncData } from '#app';
+import { type AsyncDataRequestStatus } from '#app';
 interface TConfig {
     request: NitroFetchRequest;
     apiConfig?: NitroFetchOptions<string>;
+    params?: Record<string, unknown>;
 }
 interface TUseAnData<TData, TError> {
     init: () => Promise<void>;
     set: (data: TData) => void;
+    config: Ref<TConfig>;
+    data: ComputedRef<TData | undefined>;
+    status: ComputedRef<AsyncDataRequestStatus>;
     loading: ComputedRef<boolean>;
-    request: Ref<NitroFetchRequest>;
-    data: Ref<PickFrom<TData, KeysOf<TData>> | undefined, PickFrom<TData, KeysOf<TData>> | undefined>;
-    error: ComputedRef<TError>;
-    status: ReturnType<typeof useAsyncData>['status'];
+    error: ComputedRef<TError | undefined>;
 }
-export declare const useAnData: <TData = unknown, TError = unknown>(config: TConfig) => TUseAnData<TData, TError>;
+export declare const useAnData: <TData = unknown, TError = unknown>(initConfig: TConfig) => TUseAnData<TData, TError>;
 export {};

package/dist/runtime/composables/useAnData.js

@@ -1,34 +1,45 @@
-import { computed, ref } from "vue";
+import { computed, ref, watch } from "vue";
 import { useAsyncData } from "#app";
-import { userApi } from "../utils/index.js";
-export const useAnData = (config) => {
-  const request = ref(config.request);
+import { toQuery, userApi } from "../utils/index.js";
+export const useAnData = (initConfig) => {
+  const config = ref({ ...initConfig });
+  const data = ref(void 0);
+  const error = ref(void 0);
+  const status = ref("idle");
+  const init = async () => {
+    const Data = await useAsyncData(
+      key,
+      () => userApi(
+        config.value.request,
+        { method: "GET", ...config.value.apiConfig || {} }
+      )
+    );
+    watch(Data.data, () => data.value = Data.data.value, { immediate: true });
+    watch(Data.error, () => error.value = Data.error.value, { immediate: true });
+    watch(Data.status, () => error.value = Data.status.value, { immediate: true });
+  };
   const set = (value) => {
     data.value = value;
   };
-  const loading = computed(() => {
-    return status.value === "pending";
-  });
   const key = computed(() => {
-    return request.value.toString();
+    let url = config.value.request.toString();
+    for (const key2 in config.value.params) {
+      url.replace(`:${key2}`, encodeURIComponent(String(config.value.params[key2])));
+    }
+    let query = "";
+    if (config.value.apiConfig?.query) {
+      query = "?" + toQuery(config.value.apiConfig.query);
+    }
+    return url + query;
   });
-  const {
-    data,
-    error,
-    execute,
-    status
-  } = useAsyncData(
-    key,
-    () => userApi(request.value, { method: "GET", ...config.apiConfig || {} }),
-    { immediate: false }
-  );
+  const loading = computed(() => status.value === "pending");
   return {
-    init: execute,
+    init,
     set,
-    loading,
-    request,
     data,
-    error,
-    status
+    config,
+    status,
+    loading,
+    error
   };
 };

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

@@ -1,16 +1,19 @@
-import type { Rules } from 'async-validator';
+import type { RuleItem } from 'async-validator';
 import { type UseAsyncValidatorExecuteReturn } from '@vueuse/integrations/useAsyncValidator';
-interface TFormParams<T> {
-    rules?: Rules;
-    empty: Record<keyof T, unknown>;
-    data?: Partial<T> | null;
+interface TStructureItem<TData> {
+    default: TData;
+    rules?: RuleItem[];
 }
-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;
+interface TFormParams<TForm> {
+    structure: Record<keyof TForm, TStructureItem<TForm[keyof TForm]>>;
+    data?: Partial<TForm> | null;
+}
+export declare const useAnForm: <TForm extends Record<string, unknown>>(params: TFormParams<TForm>) => {
+    state: [TForm] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<TForm, import("vue").Ref<TForm, TForm>, TForm> : import("vue").Ref<import("vue").UnwrapRef<TForm>, TForm | import("vue").UnwrapRef<TForm>>;
+    merge: (data: TForm) => void;
     validator: {
         check: () => Promise<UseAsyncValidatorExecuteReturn>;
-        errors: import("vue").Ref<Record<string, import("async-validator").ValidateError[]> | undefined, Record<string, import("async-validator").ValidateError[]> | undefined>;
+        errors: [Partial<Record<keyof TForm, string>>] extends [import("vue").Ref<any, any>] ? import("@vue/shared").IfAny<import("vue").Ref<any, any> & Partial<Record<keyof TForm, string>>, import("vue").Ref<import("vue").Ref<any, any> & Partial<Record<keyof TForm, string>>, import("vue").Ref<any, any> & Partial<Record<keyof TForm, string>>>, import("vue").Ref<any, any> & Partial<Record<keyof TForm, string>>> : import("vue").Ref<import("vue").UnwrapRef<Partial<Record<keyof TForm, string>>>, Partial<Record<keyof TForm, string>> | import("vue").UnwrapRef<Partial<Record<keyof TForm, string>>>>;
     };
     history: {
         isChanged: import("vue").ComputedRef<boolean>;
@@ -18,4 +21,4 @@ declare const _default: <T = unknown>(params: TFormParams<T>) => {
         commit: () => void;
     };
 };
-export default _default;
+export {};

package/dist/runtime/composables/useAnForm.js

@@ -1,17 +1,17 @@
+import { computed, ref, nextTick, watch } from "vue";
+import { useRefHistory } from "@vueuse/core";
 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);
+export const useAnForm = (params) => {
+  const state = ref(Object.fromEntries(Object.entries(params.structure).map(([k, v]) => [k, params.data?.[k] ?? v.default])));
+  const keys = Object.keys(state.value);
   let validatorExecute;
-  const validatorErrors = ref();
   const History = useRefHistory(state, { deep: true });
+  const errors = ref({});
   const init = () => {
     if (params.data) merge(params.data);
-    if (params.rules) initValidate();
+    initValidate();
     void nextTick(History.clear);
   };
   const merge = (data) => {
@@ -20,15 +20,25 @@ export default (params) => {
     }
   };
   const initValidate = () => {
-    if (!params.rules) return;
+    const rules = {};
+    for (const key of keys) {
+      if (!params.structure[key].rules) continue;
+      rules[key] = params.structure[key].rules;
+    }
     const validator = useAsyncValidator(
       state,
-      params.rules,
+      rules,
       { manual: true }
     );
     validatorExecute = validator.execute;
-    watchEffect(() => {
-      validatorErrors.value = validator.errorFields.value;
+    watch(validator.errorFields, () => {
+      errors.value = {};
+      for (const key in validator.errorFields.value) {
+        const fieldErrors = validator.errorFields.value[key];
+        if (fieldErrors?.[0]) {
+          errors.value[key] = fieldErrors[0].message;
+        }
+      }
     });
   };
   const first = computed(() => {
@@ -41,9 +51,7 @@ export default (params) => {
     return firstOne !== last;
   });
   watch(state, () => {
-    if (validatorErrors.value) {
-      validatorErrors.value = void 0;
-    }
+    errors.value = {};
   }, { deep: true });
   init();
   return {
@@ -55,7 +63,7 @@ export default (params) => {
       check: () => {
         return validatorExecute();
       },
-      errors: validatorErrors
+      errors
     },
     history: {
       isChanged,

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

@@ -1,6 +1,5 @@
-declare const _default: (resources?: Record<string, any>) => {
+export declare const useAnI18n: (resources?: Record<string, any>) => {
     t: import("i18next").TFunction<["translation", ...string[]], undefined>;
 } | {
     t: (key: string, options?: {}) => string;
 };
-export default _default;

package/dist/runtime/composables/useAnI18n.js

@@ -1,6 +1,6 @@
 import i18next from "i18next";
 import { getJSONHash } from "../utils/index.js";
-export default (resources) => {
+export const useAnI18n = (resources) => {
   if (!resources) return { t: i18next.t };
   const ns = getJSONHash(resources);
   for (const lang in resources) {

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

@@ -1,18 +1,21 @@
 import type { NitroFetchOptions, NitroFetchRequest } from 'nitropack';
 interface TConfig<TFilter> {
     request: NitroFetchRequest;
+    apiConfig?: NitroFetchOptions<string>;
     filter?: TFilter;
+    params?: Record<string, unknown>;
+    skipField?: string;
     reverse?: boolean;
-    apiConfig?: NitroFetchOptions<string>;
 }
-declare const _default: <TData, TFilter = unknown>(config: TConfig<TFilter>) => {
-    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>;
+export declare const useAnList: <TData, TFilter extends object = {}>(initConfig: TConfig<TFilter>) => {
+    init: () => Promise<void>;
+    filter: TFilter;
+    params: Record<string, unknown> | undefined;
     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>;
+    inited: import("vue").ComputedRef<boolean>;
+    status: import("vue").ComputedRef<import("nuxt/app").AsyncDataRequestStatus>;
+    loading: import("vue").ComputedRef<boolean>;
+    error: import("vue").ComputedRef<unknown>;
 };
-export default _default;
+export {};

package/dist/runtime/composables/useAnList.js

@@ -1,65 +1,49 @@
-import { computed, ref, reactive, watch } from "vue";
-import { useAsyncData } from "#app";
-import { userApi, toQuery } from "../utils/index.js";
-export default (config) => {
-  const inited = ref(false);
-  const filter = ref(config.filter || {});
+import { ref, reactive, watch, computed } from "vue";
+import { useAnData } from "./useAnData.js";
+export const useAnList = (initConfig) => {
+  const config = ref(initConfig);
   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();
+  const init = async () => {
+    await data.init();
     refresh();
-    inited.value = true;
   };
   const refresh = () => {
-    if (!data.value) return;
-    if (!filter.value.skip) {
+    if (!data.data.value) return;
+    if (!config.value.apiConfig?.query?.[config.value.skipField || "skip"]) {
       setCount(null);
       items.length = 0;
     }
-    if (config.reverse) {
-      items.unshift(...data.value.items);
+    if (config.value.reverse) {
+      items.unshift(...data.data.value.items);
     } else {
-      items.push(...data.value.items);
+      items.push(...data.data.value.items);
     }
-    setCount(data.value.count);
+    setCount(data.data.value.count);
   };
   const setCount = (value) => {
     count.value = value;
   };
-  const key = computed(() => {
-    return config.request + "?" + toQuery(filter.value);
-  });
-  const loading = computed(() => {
-    return status.value === "pending";
+  const inited = computed(() => data.status.value !== "idle");
+  if (!config.value.apiConfig) {
+    config.value.apiConfig = {};
+  }
+  config.value.apiConfig.query = config.value.filter;
+  const data = useAnData({
+    request: config.value.request,
+    apiConfig: config.value.apiConfig,
+    params: config.value.params
   });
-  const {
-    data,
-    error,
-    execute,
-    status
-  } = useAsyncData(
-    key,
-    () => userApi(
-      config.request,
-      { method: "GET", query: filter.value, ...config.apiConfig || {} }
-    ),
-    { immediate: false }
-  );
-  watch(data, refresh);
+  watch(data.data, refresh);
   return {
     init,
-    inited,
-    filter,
-    loading,
+    filter: config.value.filter,
+    params: config.value.params,
     items,
     count,
-    error,
-    status
+    inited,
+    status: data.status,
+    loading: data.loading,
+    error: data.error
   };
 };

package/dist/runtime/utils/getJSONHash.js

@@ -1,4 +1,8 @@
-import { sha256 } from "js-sha256";
+import { sha256 } from "@noble/hashes/sha2";
+import { utf8ToBytes, bytesToHex } from "@noble/hashes/utils";
 export const getJSONHash = (obj) => {
-  return sha256(JSON.stringify(obj));
+  const s = JSON.stringify(obj);
+  const bytes = utf8ToBytes(s);
+  const digest = sha256(bytes);
+  return bytesToHex(digest);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@anweb/nuxt-ancore",
-	"version": "1.9.3",
+	"version": "1.10.0",
 	"description": "AnCore Nuxt module",
 	"repository": "https://github.com/ANLTD/ancore",
 	"license": "MIT",
@@ -27,25 +27,25 @@
 		"dev": "npm run dev:prepare && nuxi dev playground",
 		"dev:build": "nuxi build playground",
 		"dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
-		"release:patch": "npm run prepack && changelogen --bump patch --release && npm publish --access public && git push --follow-tags",
-		"release:minor": "npm run prepack && changelogen --bump minor --release && npm publish --access public && git push --follow-tags",
-		"release:major": "npm run prepack && changelogen --bump major --release && npm publish --access public && git push --follow-tags"
+		"release:patch": "npm run prepack && changelogen --patch --release && npm publish --access public && git push --follow-tags",
+		"release:minor": "npm run prepack && changelogen --minor --release && npm publish --access public && git push --follow-tags",
+		"release:major": "npm run prepack && changelogen --major --release && npm publish --access public && git push --follow-tags"
 	},
 	"dependencies": {
-		"@nuxt/kit": "^4.1.0",
+		"@noble/hashes": "^2.0.0",
+		"@nuxt/kit": "^4.1.2",
 		"@vueuse/core": "^13.9.0",
 		"@vueuse/integrations": "^13.9.0",
 		"async-validator": "^4.2.5",
-		"i18next": "^25.5.0",
-		"js-sha256": "^0.11.1"
+		"i18next": "^25.5.2"
 	},
 	"devDependencies": {
 		"@nuxt/devtools": "^2.6.3",
 		"@nuxt/module-builder": "^1.0.2",
-		"@nuxt/schema": "^4.1.0",
+		"@nuxt/schema": "^4.1.2",
 		"@types/node": "latest",
 		"changelogen": "^0.6.2",
-		"nuxt": "^4.1.0",
+		"nuxt": "^4.1.2",
 		"typescript": "~5.9.2"
 	}
 }