zzz-pc-view 0.0.1

package/src/decorators/DeclareType.d.ts

@@ -0,0 +1,35 @@
+import { WithPrototype } from '../utils';
+/**
+ * 定义一个接口，用于描述基本属性配置。
+ * 该接口包含一个属性：
+ * - `propertyKey`：属性键，类型为字符串或符号。
+ */
+export interface BasePropertyConfig {
+    propertyKey: string | symbol;
+}
+/**
+ * 定义一个类型别名，用于描述带有原型的类型。
+ * 该类型别名是`WithPrototype`类型的类型。
+ */
+export type TypeWithPrototype = typeof WithPrototype;
+/**
+ * 定义一个类型别名，用于描述带有原型的类型，但不包括`new`操作符。
+ * 该类型别名通过`Omit`类型工具从`TypeWithPrototype`类型中移除`new`属性。
+ * @type {TypeWithPrototypeWithoutNew}
+ * @description 这个类型别名通常用于在不允许使用`new`操作符的上下文中使用带有原型的类型。
+ */
+export type TypeWithPrototypeWithoutNew = Omit<TypeWithPrototype, 'new'>;
+/**
+ * 定义一个类型别名，用于描述组件属性。
+ * 该类型别名是一个记录类型，键为属性键，值为未知类型。
+ */
+export type ComponentProps = Record<PropertyKey, unknown>;
+/**
+ * 定义一个类型别名，用于描述事件处理函数映射。
+ * 该类型别名是一个记录类型，键为字符串，值为函数类型，函数接受任意数量的未知类型参数，并且不返回任何值。
+ */
+export type EventHandlerMap = Record<string, (...args: unknown[]) => void>;
+/**
+ * 导出一个空对象，用于确保该模块有一个默认导出。
+ */
+export {};

package/src/decorators/Decorators.d.ts

@@ -0,0 +1,5 @@
+export * as NameKey from './NameKey';
+export * as PrimaryKey from './PrimaryKey';
+export * as Loader from './Loader';
+export * as FilterKey from './FilterKey';
+export * as CurdKey from './CurdKey';

package/src/decorators/FilterKey/index.d.ts

@@ -0,0 +1,283 @@
+import { Reactive } from 'vue';
+import { CombineClass, CombineInstanceType } from '../../utils';
+import { BasePropertyConfig, ComponentProps, EventHandlerMap, TypeWithPrototype } from '../DeclareType';
+import { ConfigsCreator } from '../util';
+/**
+ * 定义一个枚举，用于表示过滤器的位置。
+ */
+export declare enum PositionEnum {
+    /**
+     * 顶部位置。
+     */
+    TOP = 0,
+    /**
+     * 右侧位置。
+     */
+    RIGHT = 1,
+    /**
+     * 底部位置。
+     */
+    BOTTOM = 2,
+    /**
+     * 左侧位置。
+     */
+    LEFT = 3
+}
+/**
+ * 定义一个接口，用于描述映射的配置。
+ * 该接口是一个泛型接口，接受两个类型参数 `Q` 和 `T`，分别表示查询对象的类型和目标对象的类型。
+ * 该接口包含两个属性，分别是目标对象和获取查询的函数。
+ * @template Q - 查询对象的类型。
+ * @template T - 目标对象的类型。
+ */
+interface Mapping<Q extends object = object, T extends TypeWithPrototype | void = void> {
+    /**
+     * 映射的目标。
+     */
+    Target: T;
+    /**
+     * 获取查询的函数。
+     * 该函数是一个可选的函数，接受一个查询对象作为参数，并返回任何类型的值。
+     * @param query - 查询对象。
+     * @returns 返回任何类型的值。
+     */
+    getQuery?(query: Q): unknown;
+}
+/**
+ * 定义一个接口，用于描述过滤器的响应参数。
+ * 该接口是一个泛型接口，接受两个类型参数 `Q` 和 `T`，分别表示查询对象的类型和目标对象的类型。
+ * 该接口包含多个可选属性，用于配置过滤器的行为和外观。
+ * @template Q - 查询对象的类型。
+ * @template T - 目标对象的类型。
+ */
+export interface ResponseParam<Q extends object = object, T extends TypeWithPrototype | void = void> {
+    /**
+     * 过滤器的标签，用于显示在用户界面上。
+     */
+    label?: string;
+    /**
+     * 过滤器的顺序号，用于确定过滤器在用户界面上的显示顺序。
+     */
+    orderNo?: number;
+    /**
+     * 一个布尔值，指示过滤器是否应该显示在用户界面上。
+     */
+    show?: boolean;
+    /**
+     * 过滤器在用户界面上的位置。
+     */
+    position?: PositionEnum;
+    /**
+     * 定义一个可选的验证器函数，用于验证过滤器的值。
+     * 该函数可以返回一个 Promise，该 Promise 解析为字符串或 Error 对象，或者返回 void。
+     * 如果返回的是字符串或 Error 对象，则表示验证失败，否则表示验证成功。
+     * @returns 返回一个 Promise，该 Promise 解析为字符串或 Error 对象，或者返回 void。
+     */
+    validator?(): string | Error | Promise<string | Error> | void;
+    /**
+     * 过滤器组件的属性。
+     */
+    itemProps?: ComponentProps;
+    /**
+     * 过滤器组件的类型。
+     */
+    component?: unknown;
+    /**
+     * 过滤器组件的属性。
+     */
+    componentProps?: ComponentProps;
+    /**
+     * 过滤器组件的事件处理程序。
+     */
+    componentOn?: EventHandlerMap;
+    /**
+     * 一个映射对象，用于将查询对象映射到目标对象。
+     */
+    mapping?: T extends TypeWithPrototype ? Mapping<Q, T> : void;
+    /**
+     * 一个函数，用于设置过滤器的默认值。
+     * 该函数接受两个参数，分别是查询对象和选项数组。
+     * 如果目标对象是 `CombineClass` 类型，则选项数组是 `CombineInstanceType<T>[]` 类型，否则为 `void` 类型。
+     * @param query - 查询对象。
+     * @param options - 选项数组。
+     */
+    setDefaultValue?(query: Q, options: T extends CombineClass ? CombineInstanceType<T>[] : void): void;
+}
+/**
+ * 定义一个接口，用于描述装饰器的参数。
+ * 该接口是一个泛型接口，接受两个类型参数 `Q` 和 `T`，分别表示查询对象的类型和目标对象的类型。
+ * 该接口包含一个方法，该方法返回一个 `ResponseParam` 类型的对象。
+ * @template Q - 查询对象的类型。
+ * @template T - 目标对象的类型。
+ */
+export interface Param<Q extends object = object, T extends TypeWithPrototype | void = void> {
+    /**
+     * 一个方法，返回一个 `ResponseParam` 类型的对象。
+     * 该方法没有参数。
+     * @returns 返回一个 `ResponseParam` 类型的对象。
+     */
+    (this: FilterHandler<Q>): ResponseParam<Q, T>;
+}
+/**
+ * 定义一个接口，用于描述配置对象。
+ * 该接口继承自 `BasePropertyConfig` 和 `Param` 接口。
+ */
+export interface Config extends BasePropertyConfig {
+    creator: Param;
+}
+/**
+ * 定义一个接口，用于描述视图处理程序的配置。
+ * 该接口继承自 `BasePropertyConfig` 和 `Param` 接口的返回类型。
+ */
+interface HandlerConfig extends BasePropertyConfig, ReturnType<Param> {
+}
+/**
+ * 定义一个抽象类 `FilterHandler`，用于处理视图的配置和加载选项。
+ * 该类继承自 `ConfigsCreator`，并使用泛型 `Q` 表示查询对象的类型。
+ * @template Q - 查询对象的类型。
+ */
+export declare abstract class FilterHandler<Q extends object> extends ConfigsCreator {
+    readonly filterOption?: {
+        autoLoadOptions?: boolean;
+    } | undefined;
+    /**
+     * 定义一个属性 `FilterTarget`，用于存储查询对象的原型。
+     */
+    protected readonly FilterTarget: TypeWithPrototype;
+    /**
+     * 定义一个只读属性 `query`，用于存储查询对象的响应式副本。
+     */
+    readonly query: Reactive<Q>;
+    /**
+     * 使用 `shallowRef` 创建一个浅引用，用于存储过滤器配置的数组。
+     * `shallowRef` 用于创建一个浅层的响应式引用，它不会递归地将对象转换为响应式。
+     */
+    protected readonly filterConfigsRef: import('vue').ShallowRef<HandlerConfig[] | undefined, HandlerConfig[] | undefined>;
+    /**
+     * 定义一个只读的计算属性 `filterConfigMapComputed`，用于计算过滤器配置的映射。
+     * 该计算属性基于 `filterConfigsRef` 的值，将过滤器配置数组转换为一个以 `propertyKey` 为键的对象。
+     * 如果 `filterConfigsRef` 没有值，则返回一个空对象。
+     * @returns 返回一个以 `propertyKey` 为键的对象，或者一个空对象。
+     */
+    protected readonly filterConfigMapComputed: import('vue').ComputedRef<Record<PropertyKey, HandlerConfig>>;
+    /**
+     * 获取过滤器配置的映射。
+     * 该方法返回 `filterConfigMapComputed` 的值，即过滤器配置的映射。
+     * @returns 返回一个以 `propertyKey` 为键的对象，或者一个空对象。
+     */
+    get filterConfigMap(): Record<PropertyKey, HandlerConfig>;
+    /**
+     * 定义一个只读的计算属性 `displayFilterConfigMapComputed`，用于计算过滤器配置的位置映射。
+     * 该计算属性基于 `filterConfigsRef` 的值，将过滤器配置数组转换为一个以 `PositionEnum` 为键的对象。
+     * 如果 `filterConfigsRef` 没有值，则返回一个空对象。
+     * @returns 返回一个以 `PositionEnum` 为键的对象，或者一个空对象。
+     */
+    private readonly displayFilterConfigMapComputed;
+    /**
+     * 获取过滤器配置的位置映射。
+     * 该方法返回 `displayFilterConfigMapComputed` 的值，即过滤器配置的位置映射。
+     * @returns 返回一个以 `PositionEnum` 为键的对象，或者一个空对象。
+     */
+    get displayFilterConfigMap(): Record<PositionEnum, HandlerConfig[]>;
+    /**
+     * 定义一个计算属性 `positionKeysComputed`，用于获取过滤器配置的位置键。
+     * 该计算属性基于 `displayFilterConfigMap` 的键，将其转换为 `PositionEnum` 数组。
+     * @returns 返回一个 `PositionEnum` 数组。
+     */
+    private readonly positionKeysComputed;
+    /**
+     * 获取过滤器配置的位置键。
+     * 该方法返回 `positionKeysComputed` 的值，即过滤器配置的位置键。
+     * @returns 返回一个 `PositionEnum` 数组。
+     */
+    get positionKeys(): PositionEnum[];
+    /**
+     * 当查询验证成功时调用的抽象方法。
+     * 子类必须实现此方法以定义在查询验证成功时应执行的操作。
+     */
+    protected abstract onValidateQuerySuccess(): void;
+    /**
+     * 当查询验证失败时调用的抽象方法。
+     * 子类必须实现此方法以定义在查询验证失败时应执行的操作。
+     * @param error - 验证失败时抛出的错误对象。
+     */
+    protected abstract onValidateQueryFail(error: Error): void;
+    /**
+     * 定义一个受保护的异步方法 `validateQuery`，用于验证查询。
+     * 该方法遍历过滤器配置数组，对每个配置执行验证器函数。
+     * 如果验证器函数返回一个值，则抛出该值作为错误。
+     * @returns 返回一个 Promise，该 Promise 在所有验证完成后解析。
+     */
+    protected validateQuery(): Promise<void>;
+    /**
+     * 定义一个受保护的方法 `search`，用于执行搜索操作。
+     * 该方法首先调用 `validateQuery` 方法来验证查询。
+     * 如果验证成功，则调用 `onValidateQuerySuccess` 方法。
+     * 如果验证失败，则调用 `onValidateQueryFail` 方法，并传递错误对象。
+     */
+    protected search(): void;
+    /**
+     * 获取查询加载状态存储对象。
+     * 该方法返回全局的加载状态存储对象 `loadStore`。
+     * @returns 返回全局的加载状态存储对象 `loadStore`。
+     */
+    get queryLoadStore(): import('..').LoadUtilResponse;
+    /**
+     * 获取查询加载状态。
+     * 该方法返回全局的加载状态存储对象 `loadStore` 中的 `loadStatus` 属性。
+     * @returns 返回全局的加载状态存储对象 `loadStore` 中的 `loadStatus` 属性。
+     */
+    get queryLoadStatus(): boolean;
+    /**
+     * 定义一个私有方法 `loadOption`，用于加载选项。
+     * 该方法接受一个 `ResponseParam` 类型的参数 `config`，并根据配置加载选项。
+     * @param config - 包含映射信息的过滤器配置。
+     * @returns 返回一个 Promise，该 Promise 在选项加载完成后解析。
+     */
+    private loadOption;
+    /**
+     * 定义一个公共方法 `loadOptionByProp`，用于根据属性名加载选项。
+     * 该方法接受一个字符串参数 `prop`，表示属性名，并根据该属性名加载选项。
+     * @param prop - 要加载选项的属性名。
+     * @returns 返回一个 Promise，该 Promise 在选项加载完成后解析。
+     */
+    loadOptionByProp(prop: string): Promise<void>;
+    /**
+     * 定义一个公共方法 `processFilterConfigs`，用于处理过滤器配置。
+     * 该方法遍历过滤器配置数组，根据配置加载选项或设置默认值。
+     * @returns 返回一个 Promise，该 Promise 在所有配置处理完成后解析。
+     */
+    processFilterConfigs(): Promise<void>;
+    /**
+     * 构造函数，用于初始化过滤器处理程序。
+     * @param query - 查询对象，用于初始化过滤器处理程序。
+     */
+    constructor(query: Q, filterOption?: {
+        autoLoadOptions?: boolean;
+    } | undefined);
+}
+/**
+ * 定义一个装饰器，用于将配置对象存储在目标对象的原型上。
+ * 该装饰器接受一个参数对象，其中包含要装饰的类。
+ * 当装饰器应用于一个属性时，它会将配置对象存储在目标对象的原型上。
+ * 配置对象包含目标对象、属性键以及从参数对象继承的所有属性描述符。
+ * @param {Param<Q, T>} param - 装饰器的参数对象，包含要装饰的类。
+ * @returns {PropertyDecorator} 返回一个属性装饰器函数。
+ */
+export declare const decorator: <Q extends object, T extends TypeWithPrototype | void>(param: Param<Q, T>) => ((target: Q, propertyKey: string | symbol) => void);
+/**
+ * 根据对象的原型获取所有配置。
+ * 该函数首先调用 `getConfigByPrototypeAndKey` 函数并传递对象的原型和键作为参数。
+ * 然后将返回的结果转换为 `Config` 数组或 `undefined`。
+ * @param {object} target - 要获取配置的对象的原型。
+ * @returns {undefined | Config[]} 返回配置数组，如果没有找到配置，则返回 undefined。
+ */
+export declare const getConfigsByPrototype: (target: object) => undefined | Config[];
+/**
+ * 根据类获取所有配置。
+ * 该函数首先获取类的原型，然后调用 `getConfigsByPrototype` 函数并传递类的原型作为参数。
+ * @param {ClassType} Class - 要获取配置的类。
+ * @returns {undefined | Config[]} 返回配置数组，如果没有找到配置，则返回 undefined。
+ */
+export declare const getConfigsByClass: (Class: TypeWithPrototype) => Config[] | undefined;
+export {};

package/src/decorators/Loader/index.d.ts

@@ -0,0 +1,179 @@
+import { ComputedRef, Ref } from 'vue';
+import { CombineInstanceType, KeyMatch, KeyValType } from '../../utils';
+import { HttpRequestPromise } from '../../utils/httpRequest';
+import { TypeWithPrototype } from '../DeclareType';
+/**
+ * Loader 的存储接口，包含一个列表引用和一个计算属性
+ * @template T 类的类型
+ */
+export interface Store<T extends TypeWithPrototype = TypeWithPrototype> {
+    listRef: Ref<CombineInstanceType<T>[]>;
+    mapComputed: ComputedRef<Record<KeyValType, CombineInstanceType<T>>>;
+}
+/**
+ * 定义一个唯一的 Symbol 作为 Loader 存储的键名
+ */
+declare const storeKey: unique symbol;
+/**
+ * Loader 存储类型的接口，包含一个存储对象
+ * @template T 类的类型
+ */
+interface StoreType<T extends TypeWithPrototype = TypeWithPrototype> {
+    [storeKey]: Store<T>;
+}
+/**
+ * API 列表的接口，包含一个获取列表的方法
+ * @template T 列表项的类型
+ */
+export interface ApiList<T extends TypeWithPrototype = TypeWithPrototype> {
+    getList(query?: any): HttpRequestPromise<CombineInstanceType<T>[]>;
+}
+/**
+ * Loader 的参数接口，包含 API 列表、全局标志、子键和加载完成的回调函数
+ */
+export interface Param<T extends TypeWithPrototype = TypeWithPrototype> {
+    api: ApiList<T>;
+    query?: any;
+    global?: boolean;
+    childrenKey?: KeyMatch<CombineInstanceType<T>, undefined | CombineInstanceType<T>[]>;
+    onLoaded?: (list: CombineInstanceType<T>[]) => CombineInstanceType<T>[];
+}
+/**
+ * Loader 类类型的类型别名，包含类、存储类型和原型类型
+ * @template T 类的类型
+ */
+export type LoaderClassType<T extends TypeWithPrototype = TypeWithPrototype> = T & StoreType<T> & TypeWithPrototype;
+/**
+ * Loader 的配置类，实现了 Param 接口
+ * @template T 类的类型
+ */
+declare class LoaderConfig<T extends TypeWithPrototype = TypeWithPrototype> implements Param<T> {
+    readonly target: LoaderClassType<T>;
+    api: ApiList<T>;
+    query: any;
+    global: boolean;
+    childrenKey?: KeyMatch<CombineInstanceType<T>, undefined | CombineInstanceType<T>[]>;
+    onLoaded?: (list: CombineInstanceType<T>[]) => CombineInstanceType<T>[];
+    /**
+     * 构造函数
+     * @param target - 目标类
+     * @param param - 配置参数
+     */
+    constructor(target: LoaderClassType<T>, param: Param<T>);
+}
+/**
+ * 定义一个类型别名 `Config`，用于表示 `LoaderConfig` 类型，该类型接受一个泛型参数 `T`，`T` 必须是一个类类型。
+ * 这个类型别名主要用于简化代码，使得在使用 `LoaderConfig` 类型时可以直接使用 `Config`，而不需要每次都指定泛型参数。
+ * @template T 一个类类型，用于指定 `LoaderConfig` 类型的泛型参数。
+ */
+export type Config<T extends TypeWithPrototype = TypeWithPrototype> = LoaderConfig<T>;
+/**
+ * 定义一个装饰器函数 `decorator`，用于装饰类。
+ * 该装饰器接受一个参数 `param`，类型为 `Param`，并返回一个类装饰器。
+ * @param param - 一个 `Param` 类型的对象，包含 API 列表、全局标志、子键和加载完成的回调函数。
+ * @returns 返回一个类装饰器，该装饰器将配置信息存储在类的原型上。
+ *
+ * @example
+    @Loader.decorator({
+      api: {
+        getList: () => api<MyClass[]>({
+          url: '/myclass',
+          method: 'GET',
+        }),
+      },
+      // global: true, // 是否为全局配置（只加载一次），默认值为 false
+      // onLoaded: (list) => list.map(item => new MyClass(item)), // 可选参数，用于数据返回后格式化数据
+    })
+    class MyClass {
+      @PrimaryKey.decorator()
+      declare id: KeyValType
+
+      @NameKey.decorator()
+      declare name: string
+    }
+ */
+export declare const decorator: <T extends TypeWithPrototype>(param: Param<T>) => ((target: T) => T | void);
+/**
+ * 加载全局配置中的所有列表数据。
+ *
+ * 该函数遍历全局配置数组 `globalConfigs`，并为每个配置调用 `setList` 函数，
+ * 该函数会异步获取列表数据并将其设置到配置的目标类上。
+ *
+ * @returns {Promise<void>} 返回一个 Promise，当所有配置的列表数据都加载完成时，Promise 会被 resolve。
+ */
+export declare const loadGlobal: () => Promise<void>;
+/**
+ * 加载数据的函数。
+ *
+ * 该函数接受一个目标类作为参数，根据配置信息加载数据。
+ * 如果配置为全局加载，则直接返回存储在目标类中的数据；否则，调用API获取数据并设置到目标类中。
+ *
+ * @template T 目标类的类型，必须是一个类类型。
+ * @param {T} target 目标类的实例。
+ * @returns {Promise<CombineInstanceType<T>[]>} 返回一个Promise，当数据加载完成时，Promise会被resolve，返回加载的数据。
+ *
+ * @throws {Error} 如果找不到与目标类关联的配置信息，则抛出错误。
+ *
+ * @example
+ * @Loader.decorator({
+      api: {
+        getList: () => api<MyClass[]>({
+          url: '/myclass',
+          method: 'GET',
+        }),
+      },
+      // onLoaded: (list) => list.map(item => new MyClass(item)), // 可选参数，用于数据返回后格式化数据
+    })
+    class MyClass {
+      @PrimaryKey.decorator()
+      declare id: KeyValType
+
+      @NameKey.decorator()
+      declare name: string
+    }
+
+    Loader.loadData(MyClass).then(dataList => {
+      console.log(dataList)
+    })
+ */
+export declare const loadData: <T extends TypeWithPrototype>(target: T, query?: any) => Promise<CombineInstanceType<T>[]>;
+/**
+ * 获取目标类的存储对象。
+ *
+ * 该函数接受一个目标类作为参数，并尝试从该类中获取存储对象。
+ * 如果目标类是一个 `LoaderClassType`，则返回其存储对象；否则返回 `undefined`。
+ *
+ * @template T 目标类的类型，必须是一个类类型。
+ * @param {T} target 目标类的实例。
+ * @returns {undefined | Store<T>} 返回目标类的存储对象，如果目标类不是 `LoaderClassType`，则返回 `undefined`。
+ *
+ * @example
+    @Loader.decorator({
+      api: {
+        getList: () => api<MyClass[]>({
+          url: '/myclass',
+          method: 'GET',
+        }),
+      },
+      global: true, // 是否为全局配置（只加载一次），默认值为 false
+      // onLoaded: (list) => list.map(item => new MyClass(item)), // 可选参数，用于数据返回后格式化数据
+    })
+    class MyClass {
+      @PrimaryKey.decorator()
+      declare id: KeyValType
+
+      @NameKey.decorator()
+      declare name: string
+    }
+
+    Loader.getData(MyClass)
+    const store = Loader.getData(MyClass)
+
+    // 输出
+    {
+      listRef: shallowRef<MyClass[]>([]),
+      mapComputed: computed<Record<KeyValType, MyClass>>(() => {})
+    }
+ */
+export declare const getData: <T extends TypeWithPrototype = typeof import('../../utils').WithPrototype>(target: T) => undefined | Store<T>;
+export {};

package/src/decorators/NameKey/index.d.ts

@@ -0,0 +1,68 @@
+import { ClassType, KeyMatch, KeyValType } from './../../utils';
+/**
+ * 定义一个泛型接口，用于描述主键配置。
+ * 该接口接受一个泛型类型参数 `T`，表示目标对象的类型。
+ * 接口包含一个属性 `propertyKey`，表示主键的属性名。
+ * `propertyKey` 的类型是 `KeyMatch<T, KeyValType>`，表示它必须是 `T` 类型的键，并且键值类型是 `KeyValType`。
+ * @template T - 目标对象的类型。
+ */
+export interface Config<T extends object> {
+    /**
+     * 主键的属性名。
+     * 该属性是一个泛型类型 `KeyMatch<T, KeyValType>`，表示它必须是 `T` 类型的键，并且键值类型是 `KeyValType`。
+     */
+    propertyKey: KeyMatch<T, KeyValType>;
+}
+/**
+ * 创建一个装饰器函数，用于为类的属性添加元数据。
+ * 该装饰器函数接受一个泛型类型参数 `T`，表示目标对象的类型。
+ * 装饰器函数返回一个函数，该函数接受两个参数：`target` 和 `propertyKey`。
+ * `target` 是目标对象的原型，`propertyKey` 是要装饰的属性名。
+ * 装饰器函数将属性名存储在目标对象原型的元数据中。
+ * @template T - 目标对象的类型。
+ * @returns 返回一个装饰器函数，该函数接受 `target` 和 `propertyKey` 作为参数。
+ *
+ * @example
+    class Test {
+      @NameKey.decorator()
+      name: string
+    }
+ */
+export declare const decorator: <T extends object>() => ((target: T, propertyKey: KeyMatch<T, string>) => void);
+/**
+ * 根据目标对象的原型获取 NameKey 的配置。
+ * 该函数接受一个泛型类型参数 `T`，表示目标对象的类型。
+ * 函数返回一个 NameKey 配置对象，或者 `undefined`。
+ * @template T - 目标对象的类型。
+ * @param target - 目标对象的原型。
+ * @returns 返回 NameKey 配置对象，或者 `undefined`。
+ *
+ * @example
+ * class Test {
+ *   @NameKey.decorator()
+ *   name: string
+ * }
+ *
+ * const config = NameKey.getByPrototype(Test.prototype)
+ * // config 可能是 { propertyKey: 'name' }，或者 undefined
+ */
+export declare const getByPrototype: <T extends object>(target: T) => undefined | Config<T>;
+/**
+ * 根据类获取 NameKey 的配置
+ * @param Class - 目标类
+ * @returns 返回 NameKey 的配置，如果不存在则返回 undefined
+ *
+ * @example
+    class Test {
+      @NameKey.decorator()
+      name: string
+    }
+
+    NameKey.getByClass(Test)
+
+    // 输出
+    {
+      propertyKey: 'name'
+    }
+ */
+export declare const getByClass: (Class: ClassType) => Config<any> | undefined;

package/src/decorators/PrimaryKey/index.d.ts

@@ -0,0 +1,68 @@
+import { ClassType, KeyMatch, KeyValType } from './../../utils';
+/**
+ * 定义一个接口，用于描述主键配置。
+ * 该接口是一个泛型接口，接受一个类型参数 `T`，表示目标对象的类型。
+ * 接口包含一个属性 `propertyKey`，表示主键的属性名。
+ * `propertyKey` 的类型是 `KeyMatch<T, KeyValType>`，表示它必须是 `T` 类型的键，并且键值类型是 `KeyValType`。
+ * @template T - 目标对象的类型。
+ */
+export interface Config<T extends object> {
+    /**
+     * 主键的属性名。
+     * 该属性是一个泛型类型 `KeyMatch<T, KeyValType>`，表示它必须是 `T` 类型的键，并且键值类型是 `KeyValType`。
+     */
+    propertyKey: KeyMatch<T, KeyValType>;
+}
+/**
+ * 创建一个装饰器函数，用于为类的属性添加元数据。
+ * 该装饰器函数接受一个泛型类型参数 `T`，表示目标对象的类型。
+ * 装饰器函数返回一个函数，该函数接受两个参数：`target` 和 `propertyKey`。
+ * `target` 是目标对象的原型，`propertyKey` 是要装饰的属性名。
+ * 装饰器函数将属性名存储在目标对象原型的元数据中。
+ * @template T - 目标对象的类型。
+ * @returns 返回一个装饰器函数，该函数接受 `target` 和 `propertyKey` 作为参数。
+ *
+ * @example
+    class Test {
+      @PrimaryKey.decorator()
+      id: number
+    }
+ */
+export declare const decorator: <T extends object>() => ((target: T, propertyKey: KeyMatch<T, KeyValType>) => void);
+/**
+ * 根据目标对象的原型获取主键配置。
+ * 该函数接受一个泛型类型参数 `T`，表示目标对象的类型。
+ * 函数返回一个主键配置对象，或者 `undefined`。
+ * @template T - 目标对象的类型。
+ * @param target - 目标对象的原型。
+ * @returns 返回主键配置对象，或者 `undefined`。
+ *
+ * @example
+ * class Test {
+ *   @PrimaryKey.decorator()
+ *   id: number
+ * }
+ *
+ * const config = PrimaryKey.getByPrototype(Test.prototype)
+ * // config 可能是 { propertyKey: 'id' }，或者 undefined
+ */
+export declare const getByPrototype: <T extends object>(target: T) => undefined | Config<T>;
+/**
+ * 根据类获取主键配置
+ * @param Class - 目标类
+ * @returns 返回主键配置，如果不存在则返回 undefined
+ *
+ * @example
+    class Test {
+      @PrimaryKey.decorator()
+      id: number
+    }
+
+    PrimaryKey.getByPrototype(Test)
+
+    // 输出
+    {
+      propertyKey: 'id'
+    }
+ */
+export declare const getByClass: <T extends ClassType>(Class: T) => undefined | Config<InstanceType<T>>;

package/src/decorators/api.d.ts

@@ -0,0 +1,21 @@
+import { httpRequest } from '../utils';
+/**
+ * 导出一个变量 `api`，它是一个 `HttpRequestLoader` 类型的实例。
+ * 这个实例用于发送 HTTP 请求。
+ */
+export declare let api: httpRequest.HttpRequestLoader;
+/**
+ * 导出一个函数 `setApi`，用于设置 `api` 变量的值。
+ * 这个函数接受可变数量的参数，这些参数将被传递给 `httpRequest.create` 函数。
+ * @param args - 传递给 `httpRequest.create` 函数的参数。
+ */
+export declare const setApi: (option: {
+    axiosOptions: import('axios').CreateAxiosDefaults;
+    errorDataCode: httpRequest.HttpRequestError["code"];
+    requestIntercept?(requestConfig: import('axios').InternalAxiosRequestConfig): import('axios').InternalAxiosRequestConfig | Promise<import('axios').InternalAxiosRequestConfig>;
+    errorHandler?(error: httpRequest.HttpRequestError): Promise<httpRequest.HttpRequestError>;
+    dataCodeProp?: string | number;
+    dataSuccessCodeRanges?: ([number, number] | number | string)[];
+    dataMsgProp?: string | number;
+    dataDataProp?: string | number;
+}) => void;