@airpower/transformer 0.1.3 → 0.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/dist/decorator/Alias.d.ts +5 -5
  2. package/dist/decorator/IgnorePrefix.d.ts +5 -5
  3. package/dist/decorator/Prefix.d.ts +3 -4
  4. package/dist/decorator/ToClass.d.ts +4 -4
  5. package/dist/decorator/ToJson.d.ts +5 -5
  6. package/dist/decorator/Type.d.ts +8 -8
  7. package/dist/main.js +87 -100
  8. package/dist/transformer/DecoratorUtil.d.ts +19 -18
  9. package/dist/transformer/Transformer.d.ts +1 -1
  10. package/package.json +1 -1
package/dist/decorator/Alias.d.ts CHANGED
@@ -1,14 +1,14 @@
1
1
  import { ITransformerConstructor, Transformer } from '../transformer';
2
- import { DecoratorTarget, TransformerField } from '../type';
2
+ import { TransformerField } from '../type';
3
3
  /**
4
4
  * ### 为属性配置别名
5
5
  * @param alias 别名
6
6
  */
7
- export declare function Alias(alias: string): (target: DecoratorTarget, key: string) => void;
7
+ export declare function Alias<T extends Transformer>(alias: string): (instance: T, field: keyof T) => void;
8
8
  /**
9
9
  * ### 获取属性的别名
10
10
  * @returns 别名
11
- * @param target 目标类
12
- * @param key 属性名
11
+ * @param Class 目标类
12
+ * @param field 属性名
13
13
  */
14
- export declare function getAlias<T extends Transformer>(target: ITransformerConstructor<T> | T, key: TransformerField<T>): string;
14
+ export declare function getAlias<T extends Transformer>(Class: ITransformerConstructor<T>, field: TransformerField<T>): string;
package/dist/decorator/IgnorePrefix.d.ts CHANGED
@@ -1,13 +1,13 @@
1
1
  import { ITransformerConstructor, Transformer } from '../transformer';
2
- import { DecoratorTarget, TransformerField } from '../type';
2
+ import { TransformerField } from '../type';
3
3
  /**
4
4
  * ### 属性忽略前缀
5
5
  */
6
- export declare function IgnorePrefix(): (target: DecoratorTarget, key: string) => void;
6
+ export declare function IgnorePrefix<T extends Transformer>(): (instance: T, field: keyof T) => void;
7
7
  /**
8
8
  * ### 获取属性是否忽略前缀
9
9
  * @returns 布尔
10
- * @param target 目标类
11
- * @param key 属性名
10
+ * @param Class 目标类
11
+ * @param field 属性名
12
12
  */
13
- export declare function getIgnorePrefix<T extends Transformer>(target: ITransformerConstructor<T> | T, key: TransformerField<T>): boolean;
13
+ export declare function getIgnorePrefix<T extends Transformer>(Class: ITransformerConstructor<T>, field: TransformerField<T>): boolean;
package/dist/decorator/Prefix.d.ts CHANGED
@@ -1,12 +1,11 @@
1
1
  import { ITransformerConstructor, Transformer } from '../transformer';
2
- import { DecoratorTarget } from '../type';
3
2
  /**
4
3
  * ### 标记类转换的前缀
5
4
  * @param prefix 转换前缀
6
5
  */
7
- export declare function Prefix(prefix: string): (target: DecoratorTarget) => void;
6
+ export declare function Prefix<T extends Transformer>(prefix: string): (Class: ITransformerConstructor<T>) => void;
8
7
  /**
9
8
  * ### 获取类转换的前缀
10
- * @param target 目标类
9
+ * @param Class 目标类
11
10
  */
12
- export declare function getPrefix<T extends Transformer>(target: ITransformerConstructor<T> | T): string;
11
+ export declare function getPrefix<T extends Transformer>(Class: ITransformerConstructor<T>): string;
package/dist/decorator/ToClass.d.ts CHANGED
@@ -1,13 +1,13 @@
1
1
  import { IJson, ITransformerConstructor, Transformer } from '../transformer';
2
- import { DecoratorTarget, TransformerField } from '../type';
2
+ import { TransformerField } from '../type';
3
3
  /**
4
4
  * ### 自定义转换到 `Class` 的方法
5
5
  * @param func 方法
6
6
  */
7
- export declare function ToClass(func: (json: IJson) => unknown): (target: DecoratorTarget, key: string) => void;
7
+ export declare function ToClass<T extends Transformer>(func: (json: IJson) => unknown): (instance: T, field: keyof T) => void;
8
8
  /**
9
9
  * ### 获取自定义转换到 `Class` 的方法
10
10
  * @param target 目标类
11
- * @param key 属性名
11
+ * @param field 属性名
12
12
  */
13
- export declare function getToClass<T extends Transformer>(target: ITransformerConstructor<T> | T, key: TransformerField<T>): (json: IJson) => unknown;
13
+ export declare function getToClass<T extends Transformer>(target: ITransformerConstructor<T>, field: TransformerField<T>): (json: IJson) => unknown;
package/dist/decorator/ToJson.d.ts CHANGED
@@ -1,13 +1,13 @@
1
1
  import { ITransformerConstructor, Transformer } from '../transformer';
2
- import { DecoratorTarget, TransformerField } from '../type';
2
+ import { TransformerField } from '../type';
3
3
  /**
4
4
  * ### 自定义转换到 `JSON` 的方法
5
5
  * @param func 方法
6
6
  */
7
- export declare function ToJson<M extends Transformer>(func: (instance: M) => unknown): (target: DecoratorTarget, key: string) => void;
7
+ export declare function ToJson<T extends Transformer>(func: (instance: T) => unknown): (instance: T, key: keyof T) => void;
8
8
  /**
9
9
  * ### 获取自定义转换到 `JSON` 的方法
10
- * @param target 目标类
11
- * @param key 属性名
10
+ * @param Class 目标类
11
+ * @param field 属性名
12
12
  */
13
- export declare function getToJson<T extends Transformer>(target: ITransformerConstructor<T> | T, key: TransformerField<T>): (instance: T) => unknown;
13
+ export declare function getToJson<T extends Transformer>(Class: ITransformerConstructor<T>, field: TransformerField<T>): (instance: T) => unknown;
package/dist/decorator/Type.d.ts CHANGED
@@ -1,22 +1,22 @@
1
1
  import { ITransformerConstructor, Transformer } from '../transformer';
2
- import { DecoratorTarget, TransformerField } from '../type';
2
+ import { TransformerField } from '../type';
3
3
  /**
4
4
  * ### 为属性配置强制类型
5
5
  * @param type 强制转换的类型
6
6
  * @param array 是否固定数组
7
7
  */
8
- export declare function Type<T extends Transformer>(type: ITransformerConstructor<T>, array?: boolean): (target: DecoratorTarget, key: string) => void;
8
+ export declare function Type<T extends Transformer, TO extends Transformer>(type: ITransformerConstructor<TO>, array?: boolean): (instance: T, field: keyof T) => void;
9
9
  /**
10
10
  * ### 获取属性的强制类型
11
11
  * @returns 别名
12
- * @param target 目标类
13
- * @param key 属性名
12
+ * @param Class 目标类
13
+ * @param field 属性名
14
14
  */
15
- export declare function getType<T extends Transformer>(target: ITransformerConstructor<T> | T, key: TransformerField<T>): ITransformerConstructor<T> | undefined;
15
+ export declare function getType<T extends Transformer, TO extends Transformer>(Class: ITransformerConstructor<T>, field: TransformerField<T>): ITransformerConstructor<TO> | undefined;
16
16
  /**
17
17
  * ### 获取属性是否强制数组
18
18
  * @returns 别名
19
- * @param target 目标类
20
- * @param key 属性名
19
+ * @param Class 目标类
20
+ * @param field 属性名
21
21
  */
22
- export declare function getArray<T extends Transformer>(target: ITransformerConstructor<T> | T, key: TransformerField<T>): boolean;
22
+ export declare function getArray<T extends Transformer>(Class: ITransformerConstructor<T>, field: TransformerField<T>): boolean;
package/dist/main.js CHANGED
@@ -4,120 +4,107 @@ var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "sy
4
4
  class DecoratorUtil {
5
5
  /**
6
6
  * ### 设置一个类配置项
7
- * @param target 目标实体类
7
+ * @param Class 目标类
8
8
  * @param classConfigKey 配置项索引键值
9
9
  * @param classConfig 配置的参数
10
10
  */
11
- static setClassConfig(target, classConfigKey, classConfig) {
12
- this.setProperty(target.prototype, classConfigKey, classConfig);
11
+ static setClassConfig(Class, classConfigKey, classConfig) {
12
+ this.setProperty(Class.prototype, classConfigKey, classConfig);
13
13
  }
14
14
  /**
15
15
  * ### 递归获取指定类的配置项
16
- * @param target 目标类
16
+ * @param Class 目标类
17
17
  * @param classConfigKey 配置项的Key
18
18
  * @param defaultValue `可选` 类装饰器请传入配置项实例
19
19
  * @param isObject `可选` 是否是对象配置
20
20
  */
21
- static getClassConfig(target, classConfigKey, defaultValue = void 0, isObject = false) {
22
- if (typeof target !== "object") {
23
- target = target.prototype;
24
- }
25
- let classConfig = Reflect.get(target, classConfigKey);
21
+ static getClassConfig(Class, classConfigKey, defaultValue = void 0, isObject = false) {
22
+ let classConfig = Reflect.get(Class, classConfigKey);
26
23
  if (!isObject) {
27
24
  if (classConfig) {
28
25
  return classConfig;
29
26
  }
30
- const superClass2 = Reflect.getPrototypeOf(target);
31
- if (!superClass2 || superClass2.constructor.name === Transformer.name) {
27
+ const SuperClass2 = Reflect.getPrototypeOf(Class);
28
+ if (!SuperClass2 || SuperClass2.prototype.constructor.name === Transformer.name) {
32
29
  return void 0;
33
30
  }
34
- return this.getClassConfig(superClass2, classConfigKey);
31
+ return this.getClassConfig(SuperClass2, classConfigKey);
35
32
  }
36
33
  classConfig = classConfig || {};
37
- const superClass = Reflect.getPrototypeOf(target);
38
- if (!superClass || superClass.constructor.name === Transformer.name) {
34
+ const SuperClass = Reflect.getPrototypeOf(Class);
35
+ if (!SuperClass || SuperClass.constructor.name === Transformer.name) {
39
36
  return defaultValue;
40
37
  }
41
38
  return {
42
- ...this.getClassConfig(superClass, classConfigKey, defaultValue, isObject),
39
+ ...this.getClassConfig(SuperClass, classConfigKey, defaultValue, isObject),
43
40
  ...classConfig
44
41
  };
45
42
  }
46
43
  /**
47
44
  * ### 设置一个属性配置项
48
- * @param target 目标类
49
- * @param key 属性
45
+ * @param instance 目标实例
46
+ * @param field 属性
50
47
  * @param fieldConfigKey 配置项索引键值
51
48
  * @param fieldConfig 配置的参数
52
49
  * @param fieldListKey `可选` 类配置项列表索引值
53
50
  */
54
- static setFieldConfig(target, key, fieldConfigKey, fieldConfig, fieldListKey) {
51
+ static setFieldConfig(instance, field, fieldConfigKey, fieldConfig, fieldListKey) {
55
52
  if (fieldListKey) {
56
- this.addFieldDecoratorKey(target, key, fieldListKey);
53
+ this.addFieldDecoratorKey(instance, field, fieldListKey);
57
54
  }
58
- this.setProperty(target, `${fieldConfigKey}[${key}]`, fieldConfig);
55
+ this.setProperty(instance, `${fieldConfigKey}[${field.toString()}]`, fieldConfig);
59
56
  }
60
57
  /**
61
58
  * ### 获取类指定属性的指定类型的配置
62
- * @param target 目标类
63
- * @param key 属性
59
+ * @param Class 目标类
60
+ * @param field 属性
64
61
  * @param fieldConfigKey FieldConfigKey
65
62
  * @param isObject `可选` 是否对象配置
66
63
  */
67
- static getFieldConfig(target, key, fieldConfigKey, isObject = false) {
68
- if (typeof target !== "object") {
69
- target = target.prototype;
70
- }
71
- let fieldConfig = Reflect.get(target, `${fieldConfigKey}[${key}]`);
64
+ static getFieldConfig(Class, field, fieldConfigKey, isObject = false) {
65
+ let fieldConfig = Reflect.get(Class.prototype, `${fieldConfigKey}[${field.toString()}]`);
66
+ const SuperClass = Reflect.getPrototypeOf(Class);
72
67
  if (!isObject) {
73
68
  if (fieldConfig !== void 0) {
74
69
  return fieldConfig;
75
70
  }
76
- const superClass2 = Reflect.getPrototypeOf(target);
77
- if (!superClass2 || superClass2.constructor.name === Transformer.name) {
71
+ if (!SuperClass || SuperClass.prototype.constructor.name === Transformer.name) {
78
72
  return void 0;
79
73
  }
80
- return this.getFieldConfig(superClass2, key, fieldConfigKey);
74
+ return this.getFieldConfig(SuperClass, field, fieldConfigKey);
81
75
  }
82
76
  fieldConfig = fieldConfig || {};
83
- const superClass = Reflect.getPrototypeOf(target);
84
- if (!superClass || superClass.constructor.name === Transformer.name) {
77
+ if (!SuperClass || SuperClass.prototype.constructor.name === Transformer.name) {
85
78
  return {};
86
79
  }
87
80
  return {
88
- ...this.getFieldConfig(superClass, key, fieldConfigKey, true),
81
+ ...this.getFieldConfig(SuperClass, field, fieldConfigKey, true),
89
82
  ...fieldConfig
90
83
  };
91
84
  }
92
85
  /**
93
86
  * ### 获取类标记了装饰器的属性列表
94
- * @param target 目标类
87
+ * @param Class 目标类
95
88
  * @param fieldConfigKey FieldConfigKey
96
89
  * @param list `递归参数` 无需传入
97
90
  */
98
- static getFieldList(target, fieldConfigKey, list = []) {
99
- if (typeof target !== "object") {
100
- target = target.prototype;
101
- }
102
- const fieldList = Reflect.get(target, fieldConfigKey) || [];
91
+ static getFieldList(Class, fieldConfigKey, list = []) {
92
+ const fieldList = Reflect.get(Class.prototype, fieldConfigKey) || [];
103
93
  fieldList.forEach((item) => list.includes(item) || list.push(item));
104
- const superClass = Reflect.getPrototypeOf(target);
105
- if (!superClass || superClass.constructor.name === Transformer.name) {
94
+ const SuperClass = Reflect.getPrototypeOf(Class);
95
+ if (!SuperClass || SuperClass.prototype.constructor.name === Transformer.name) {
106
96
  return list;
107
97
  }
108
- return this.getFieldList(superClass, fieldConfigKey, list);
98
+ return this.getFieldList(SuperClass, fieldConfigKey, list);
109
99
  }
110
100
  /**
111
101
  * ### 反射添加属性
112
- * @param target 目标类
113
- * @param key 配置key
102
+ * @param instance 目标属性
103
+ * @param propertyKey 配置key
114
104
  * @param value 配置值
115
105
  */
116
- static setProperty(target, key, value) {
117
- if (typeof target !== "object") {
118
- target = target.prototype;
119
- }
120
- Reflect.defineProperty(target, key, {
106
+ static setProperty(instance, propertyKey, value) {
107
+ Reflect.defineProperty(instance, propertyKey, {
121
108
  enumerable: false,
122
109
  value,
123
110
  writable: false,
@@ -126,17 +113,14 @@ class DecoratorUtil {
126
113
  }
127
114
  /**
128
115
  * ### 设置一个属性的包含装饰器索引
129
- * @param target 目标类
130
- * @param key 属性
131
- * @param fieldListKey 类配置项列表索引值
116
+ * @param instance 目标类
117
+ * @param field 属性
118
+ * @param propertyKey 类配置项列表索引值
132
119
  */
133
- static addFieldDecoratorKey(target, key, fieldListKey) {
134
- if (typeof target !== "object") {
135
- target = target.prototype;
136
- }
137
- const list = Reflect.get(target, fieldListKey) || [];
138
- list.push(key);
139
- this.setProperty(target, fieldListKey, list);
120
+ static addFieldDecoratorKey(instance, field, propertyKey) {
121
+ const list = Reflect.get(instance, propertyKey) || [];
122
+ list.push(field);
123
+ this.setProperty(instance, propertyKey, list);
140
124
  }
141
125
  }
142
126
  /**
@@ -190,10 +174,10 @@ class Transformer {
190
174
  const instance = new Class();
191
175
  const fieldList = Object.keys(instance);
192
176
  for (const field of fieldList) {
193
- const jsonKey = this.getJsonKey(instance, field);
177
+ const jsonKey = this.getJsonKey(Class, field);
194
178
  const fieldData = json[jsonKey];
195
179
  instance[field] = fieldData;
196
- const toClass = getToClass(instance, field);
180
+ const toClass = getToClass(Class, field);
197
181
  if (toClass !== void 0) {
198
182
  try {
199
183
  ;
@@ -203,8 +187,8 @@ class Transformer {
203
187
  continue;
204
188
  }
205
189
  }
206
- const FieldTypeClass = getType(instance, field);
207
- const isArray = getArray(instance, field);
190
+ const FieldTypeClass = getType(Class, field);
191
+ const isArray = getArray(Class, field);
208
192
  if (isArray) {
209
193
  const fieldValueList = [];
210
194
  if (typeof fieldData === "object" && Array.isArray(fieldData)) {
@@ -238,7 +222,7 @@ class Transformer {
238
222
  }
239
223
  }
240
224
  for (const fieldKey of fieldList) {
241
- const alias = getAlias(instance, fieldKey) || fieldKey;
225
+ const alias = getAlias(Class, fieldKey) || fieldKey;
242
226
  if (alias === fieldKey) {
243
227
  continue;
244
228
  }
@@ -248,19 +232,19 @@ class Transformer {
248
232
  }
249
233
  /**
250
234
  * ### 获取 JSON 的 key
251
- * @param instance 目标实例
235
+ * @param Class 目标实例
252
236
  * @param field 属性 key
253
237
  */
254
- static getJsonKey(instance, field) {
255
- const alias = getAlias(instance, field);
238
+ static getJsonKey(Class, field) {
239
+ const alias = getAlias(Class, field);
256
240
  if (alias) {
257
241
  return alias;
258
242
  }
259
- const prefix = getPrefix(instance);
243
+ const prefix = getPrefix(Class);
260
244
  if (!prefix) {
261
245
  return field;
262
246
  }
263
- const ignorePrefix = getIgnorePrefix(instance, field);
247
+ const ignorePrefix = getIgnorePrefix(Class, field);
264
248
  if (!ignorePrefix) {
265
249
  return prefix + field;
266
250
  }
@@ -312,6 +296,7 @@ class Transformer {
312
296
  * 会自动进行数据别名转换
313
297
  */
314
298
  toJson() {
299
+ const Class = this.constructor;
315
300
  const fieldList = Object.keys(this);
316
301
  const json = {};
317
302
  for (const field of fieldList) {
@@ -319,9 +304,9 @@ class Transformer {
319
304
  if (data === null || data === void 0) {
320
305
  continue;
321
306
  }
322
- const jsonKey = Transformer.getJsonKey(this, field);
307
+ const jsonKey = Transformer.getJsonKey(Class, field);
323
308
  json[jsonKey] = data;
324
- const toJson = getToJson(this, field);
309
+ const toJson = getToJson(Class, field);
325
310
  if (toJson !== void 0) {
326
311
  try {
327
312
  json[jsonKey] = toJson(this);
@@ -349,56 +334,58 @@ class Transformer {
349
334
  return json;
350
335
  }
351
336
  }
352
- const KEY$5 = `${DecoratorUtil.DecoratorKeyPrefix}[Alias]`;
337
+ const KEY$5 = "[Alias]";
353
338
  function Alias(alias) {
354
- return (target, key) => DecoratorUtil.setFieldConfig(target, key, KEY$5, alias);
339
+ return (instance, field) => {
340
+ DecoratorUtil.setFieldConfig(instance, field, KEY$5, alias);
341
+ };
355
342
  }
356
- function getAlias(target, key) {
357
- return (DecoratorUtil.getFieldConfig(target, key.toString(), KEY$5) || "").toString();
343
+ function getAlias(Class, field) {
344
+ return (DecoratorUtil.getFieldConfig(Class, field, KEY$5) || "").toString();
358
345
  }
359
- const KEY$4 = `${DecoratorUtil.DecoratorKeyPrefix}[IgnorePrefix]`;
346
+ const KEY$4 = "[IgnorePrefix]";
360
347
  function IgnorePrefix() {
361
- return (target, key) => DecoratorUtil.setFieldConfig(target, key, KEY$4, true);
348
+ return (instance, field) => DecoratorUtil.setFieldConfig(instance, field, KEY$4, true);
362
349
  }
363
- function getIgnorePrefix(target, key) {
364
- return !!DecoratorUtil.getFieldConfig(target, key.toString(), KEY$4);
350
+ function getIgnorePrefix(Class, field) {
351
+ return !!DecoratorUtil.getFieldConfig(Class, field, KEY$4);
365
352
  }
366
- const KEY$3 = `${DecoratorUtil.DecoratorKeyPrefix}[Prefix]`;
353
+ const KEY$3 = "[Prefix]";
367
354
  function Prefix(prefix) {
368
- return (target) => DecoratorUtil.setClassConfig(target, KEY$3, prefix);
355
+ return (Class) => DecoratorUtil.setClassConfig(Class, KEY$3, prefix);
369
356
  }
370
- function getPrefix(target) {
371
- return DecoratorUtil.getClassConfig(target, KEY$3, "");
357
+ function getPrefix(Class) {
358
+ return DecoratorUtil.getClassConfig(Class, KEY$3, "");
372
359
  }
373
- const KEY$2 = `${DecoratorUtil.DecoratorKeyPrefix}[ToClass]`;
360
+ const KEY$2 = "[ToClass]";
374
361
  function ToClass(func) {
375
- return (target, key) => DecoratorUtil.setFieldConfig(target, key, KEY$2, func);
362
+ return (instance, field) => DecoratorUtil.setFieldConfig(instance, field, KEY$2, func);
376
363
  }
377
- function getToClass(target, key) {
378
- return DecoratorUtil.getFieldConfig(target, key.toString(), KEY$2);
364
+ function getToClass(target, field) {
365
+ return DecoratorUtil.getFieldConfig(target, field, KEY$2);
379
366
  }
380
- const KEY$1 = `${DecoratorUtil.DecoratorKeyPrefix}[ToJson]`;
367
+ const KEY$1 = "[ToJson]";
381
368
  function ToJson(func) {
382
- return (target, key) => DecoratorUtil.setFieldConfig(target, key, KEY$1, func);
369
+ return (instance, key) => DecoratorUtil.setFieldConfig(instance, key, KEY$1, func);
383
370
  }
384
- function getToJson(target, key) {
385
- return DecoratorUtil.getFieldConfig(target, key.toString(), KEY$1);
371
+ function getToJson(Class, field) {
372
+ return DecoratorUtil.getFieldConfig(Class, field, KEY$1);
386
373
  }
387
- const KEY = `${DecoratorUtil.DecoratorKeyPrefix}[Type]`;
388
- const KEY_ARRAY = `${DecoratorUtil.DecoratorKeyPrefix}[Array]`;
374
+ const KEY = "[Type]";
375
+ const KEY_ARRAY = "[Array]";
389
376
  function Type(type, array = false) {
390
- return (target, key) => {
391
- DecoratorUtil.setFieldConfig(target, key, KEY, type);
377
+ return (instance, field) => {
378
+ DecoratorUtil.setFieldConfig(instance, field, KEY, type);
392
379
  if (array) {
393
- DecoratorUtil.setFieldConfig(target, key, KEY_ARRAY, array);
380
+ DecoratorUtil.setFieldConfig(instance, field, KEY_ARRAY, array);
394
381
  }
395
382
  };
396
383
  }
397
- function getType(target, key) {
398
- return DecoratorUtil.getFieldConfig(target, key.toString(), KEY) || void 0;
384
+ function getType(Class, field) {
385
+ return DecoratorUtil.getFieldConfig(Class, field, KEY) || void 0;
399
386
  }
400
- function getArray(target, key) {
401
- return !!DecoratorUtil.getFieldConfig(target, key.toString(), KEY_ARRAY);
387
+ function getArray(Class, field) {
388
+ return !!DecoratorUtil.getFieldConfig(Class, field, KEY_ARRAY);
402
389
  }
403
390
  export {
404
391
  Alias,
package/dist/transformer/DecoratorUtil.d.ts CHANGED
@@ -1,4 +1,5 @@
1
- import { DecoratorData, DecoratorTarget } from '../type';
1
+ import { DecoratorData, TransformerField } from '../type';
2
+ import { ITransformerConstructor, Transformer } from './index';
2
3
  /**
3
4
  * # 装饰器工具类
4
5
  *
@@ -11,55 +12,55 @@ export declare class DecoratorUtil {
11
12
  static readonly DecoratorKeyPrefix = "[AirPower]";
12
13
  /**
13
14
  * ### 设置一个类配置项
14
- * @param target 目标实体类
15
+ * @param Class 目标类
15
16
  * @param classConfigKey 配置项索引键值
16
17
  * @param classConfig 配置的参数
17
18
  */
18
- static setClassConfig(target: DecoratorTarget, classConfigKey: string, classConfig: unknown): void;
19
+ static setClassConfig<T extends Transformer>(Class: ITransformerConstructor<T>, classConfigKey: string, classConfig: unknown): void;
19
20
  /**
20
21
  * ### 递归获取指定类的配置项
21
- * @param target 目标类
22
+ * @param Class 目标类
22
23
  * @param classConfigKey 配置项的Key
23
24
  * @param defaultValue `可选` 类装饰器请传入配置项实例
24
25
  * @param isObject `可选` 是否是对象配置
25
26
  */
26
- static getClassConfig(target: DecoratorTarget, classConfigKey: string, defaultValue?: unknown, isObject?: boolean): DecoratorData;
27
+ static getClassConfig<T extends Transformer>(Class: ITransformerConstructor<T>, classConfigKey: string, defaultValue?: unknown, isObject?: boolean): DecoratorData;
27
28
  /**
28
29
  * ### 设置一个属性配置项
29
- * @param target 目标类
30
- * @param key 属性
30
+ * @param instance 目标实例
31
+ * @param field 属性
31
32
  * @param fieldConfigKey 配置项索引键值
32
33
  * @param fieldConfig 配置的参数
33
34
  * @param fieldListKey `可选` 类配置项列表索引值
34
35
  */
35
- static setFieldConfig(target: DecoratorTarget, key: string, fieldConfigKey: string, fieldConfig: unknown, fieldListKey?: string): void;
36
+ static setFieldConfig<T extends Transformer>(instance: T, field: keyof T, fieldConfigKey: string, fieldConfig: unknown, fieldListKey?: string): void;
36
37
  /**
37
38
  * ### 获取类指定属性的指定类型的配置
38
- * @param target 目标类
39
- * @param key 属性
39
+ * @param Class 目标类
40
+ * @param field 属性
40
41
  * @param fieldConfigKey FieldConfigKey
41
42
  * @param isObject `可选` 是否对象配置
42
43
  */
43
- static getFieldConfig(target: DecoratorTarget, key: string, fieldConfigKey: string, isObject?: boolean): DecoratorData;
44
+ static getFieldConfig<T extends Transformer>(Class: ITransformerConstructor<T>, field: TransformerField<T>, fieldConfigKey: string, isObject?: boolean): DecoratorData;
44
45
  /**
45
46
  * ### 获取类标记了装饰器的属性列表
46
- * @param target 目标类
47
+ * @param Class 目标类
47
48
  * @param fieldConfigKey FieldConfigKey
48
49
  * @param list `递归参数` 无需传入
49
50
  */
50
- static getFieldList(target: DecoratorTarget, fieldConfigKey: string, list?: string[]): string[];
51
+ static getFieldList<T extends Transformer>(Class: ITransformerConstructor<T>, fieldConfigKey: string, list?: string[]): string[];
51
52
  /**
52
53
  * ### 反射添加属性
53
- * @param target 目标类
54
- * @param key 配置key
54
+ * @param instance 目标属性
55
+ * @param propertyKey 配置key
55
56
  * @param value 配置值
56
57
  */
57
58
  private static setProperty;
58
59
  /**
59
60
  * ### 设置一个属性的包含装饰器索引
60
- * @param target 目标类
61
- * @param key 属性
62
- * @param fieldListKey 类配置项列表索引值
61
+ * @param instance 目标类
62
+ * @param field 属性
63
+ * @param propertyKey 类配置项列表索引值
63
64
  */
64
65
  private static addFieldDecoratorKey;
65
66
  }
package/dist/transformer/Transformer.d.ts CHANGED
@@ -32,7 +32,7 @@ export declare class Transformer {
32
32
  static parse<T extends Transformer>(json: IJson | undefined, Class: ITransformerConstructor<T>): T;
33
33
  /**
34
34
  * ### 获取 JSON 的 key
35
- * @param instance 目标实例
35
+ * @param Class 目标实例
36
36
  * @param field 属性 key
37
37
  */
38
38
  private static getJsonKey;
package/package.json CHANGED
@@ -1,7 +1,7 @@
1
1
  {
2
2
  "name": "@airpower/transformer",
3
3
  "type": "module",
4
- "version": "0.1.3",
4
+ "version": "0.1.5",
5
5
  "description": "AirPower-Transformer 是一个基于 TypeScript 的数据转换器，提供了从 JSON 对象到 类实例 对象之间互相转换的系列装饰器和方法。",
6
6
  "author": {
7
7
  "name": "Hamm",