@airpower/transformer 0.0.1

package/dist/main.js

@@ -0,0 +1,408 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+class DecoratorUtil {
+  /**
+   * ### 设置一个类配置项
+   * @param target 目标实体类
+   * @param classConfigKey 配置项索引键值
+   * @param classConfig 配置的参数
+   */
+  static setClassConfig(target, classConfigKey, classConfig) {
+    this.setProperty(target.prototype, classConfigKey, classConfig);
+  }
+  /**
+   * ### 递归获取指定类的配置项
+   * @param target 目标类
+   * @param classConfigKey 配置项的Key
+   * @param defaultValue `可选` 类装饰器请传入配置项实例
+   * @param isObject `可选` 是否是对象配置
+   */
+  static getClassConfig(target, classConfigKey, defaultValue = void 0, isObject = false) {
+    let classConfig = Reflect.get(target, classConfigKey);
+    if (!isObject) {
+      if (classConfig) {
+        return classConfig;
+      }
+      const superClass2 = Reflect.getPrototypeOf(target);
+      if (!superClass2 || superClass2.constructor.name === Transformer.name) {
+        return void 0;
+      }
+      return this.getClassConfig(superClass2, classConfigKey);
+    }
+    classConfig = classConfig || {};
+    const superClass = Reflect.getPrototypeOf(target);
+    if (!superClass || superClass.constructor.name === Transformer.name) {
+      return defaultValue;
+    }
+    return {
+      ...this.getClassConfig(superClass, classConfigKey, defaultValue, isObject),
+      ...classConfig
+    };
+  }
+  /**
+   * ### 设置一个属性配置项
+   * @param target 目标类
+   * @param key 属性
+   * @param fieldConfigKey 配置项索引键值
+   * @param fieldConfig 配置的参数
+   * @param fieldListKey `可选` 类配置项列表索引值
+   */
+  static setFieldConfig(target, key, fieldConfigKey, fieldConfig, fieldListKey) {
+    if (fieldListKey) {
+      this.addFieldDecoratorKey(target, key, fieldListKey);
+    }
+    this.setProperty(target, `${fieldConfigKey}[${key}]`, fieldConfig);
+  }
+  /**
+   * ### 获取类指定属性的指定类型的配置
+   * @param target 目标类
+   * @param key 属性
+   * @param fieldConfigKey FieldConfigKey
+   * @param isObject `可选` 是否对象配置
+   */
+  static getFieldConfig(target, key, fieldConfigKey, isObject = false) {
+    if (typeof target !== "object") {
+      target = target.prototype;
+    }
+    let fieldConfig = Reflect.get(target, `${fieldConfigKey}[${key}]`);
+    if (!isObject) {
+      if (fieldConfig !== void 0) {
+        return fieldConfig;
+      }
+      const superClass2 = Reflect.getPrototypeOf(target);
+      if (!superClass2 || superClass2.constructor.name === Transformer.name) {
+        return void 0;
+      }
+      return this.getFieldConfig(superClass2, key, fieldConfigKey);
+    }
+    fieldConfig = fieldConfig || {};
+    const superClass = Reflect.getPrototypeOf(target);
+    if (!superClass || superClass.constructor.name === Transformer.name) {
+      return {};
+    }
+    return {
+      ...this.getFieldConfig(superClass, key, fieldConfigKey, true),
+      ...fieldConfig
+    };
+  }
+  /**
+   * ### 获取类标记了装饰器的属性列表
+   * @param target 目标类
+   * @param fieldConfigKey FieldConfigKey
+   * @param list `递归参数` 无需传入
+   */
+  static getFieldList(target, fieldConfigKey, list = []) {
+    const fieldList = Reflect.get(target, fieldConfigKey) || [];
+    fieldList.forEach((item) => list.includes(item) || list.push(item));
+    const superClass = Reflect.getPrototypeOf(target);
+    if (!superClass || superClass.constructor.name === Transformer.name) {
+      return list;
+    }
+    return this.getFieldList(superClass, fieldConfigKey, list);
+  }
+  /**
+   * ### 反射添加属性
+   * @param target 目标类
+   * @param key 配置key
+   * @param value 配置值
+   */
+  static setProperty(target, key, value) {
+    Reflect.defineProperty(target, key, {
+      enumerable: false,
+      value,
+      writable: false,
+      configurable: true
+    });
+  }
+  /**
+   * ### 设置一个属性的包含装饰器索引
+   * @param target 目标类
+   * @param key 属性
+   * @param fieldListKey 类配置项列表索引值
+   */
+  static addFieldDecoratorKey(target, key, fieldListKey) {
+    const list = Reflect.get(target, fieldListKey) || [];
+    list.push(key);
+    this.setProperty(target, fieldListKey, list);
+  }
+}
+/**
+ * ### 装饰器前缀
+ */
+__publicField(DecoratorUtil, "DecoratorKeyPrefix", "[AirPower]");
+class Transformer {
+  /**
+   * ### 从 `JSON` 转换到当前类的对象
+   * 会自动进行数据别名转换
+   * @param json `JSON`
+   */
+  static fromJson(json = {}) {
+    const instance = new this();
+    return Transformer.parse(instance, json);
+  }
+  /**
+   * ### 从 `JSON` 数组转换到当前类的对象数组
+   * 会自动进行数据别名转换
+   * @param jsonArray `JSON`数组
+   */
+  static fromJsonArray(jsonArray = []) {
+    const instanceList = [];
+    if (Array.isArray(jsonArray)) {
+      for (let i = 0; i < jsonArray.length; i += 1) {
+        const instance = new this();
+        instanceList.push(Transformer.parse(instance, jsonArray[i]));
+      }
+    } else {
+      const instance = new this();
+      instanceList.push(Transformer.parse(instance, jsonArray));
+    }
+    return instanceList;
+  }
+  /**
+   * ### 创建一个当前类的实例
+   * @param recoverBy `可选` 初始化用于覆盖对象实例的 `JSON`
+   */
+  static newInstance(recoverBy) {
+    const instance = new this();
+    if (recoverBy) {
+      return instance.recoverBy(recoverBy);
+    }
+    return instance;
+  }
+  /**
+   * ### 转换 `JSON` 为实体
+   * 会自动进行数据别名转换
+   * @param instance 实体
+   * @param json `JSON`
+   */
+  static parse(instance, json = {}) {
+    const fieldList = Object.keys(instance);
+    for (const field of fieldList) {
+      const jsonKey = this.getJsonKey(instance, field);
+      const fieldData = json[jsonKey];
+      instance[field] = fieldData;
+      const toClass = getToClass(instance, field);
+      if (toClass !== void 0) {
+        try {
+          ;
+          instance[field] = toClass(json);
+        } catch (e) {
+          console.warn("ToClass Function Error", e);
+          continue;
+        }
+      }
+      const FieldTypeClass = getType(instance, field);
+      const isArray = getArray(instance, field);
+      if (isArray) {
+        const fieldValueList = [];
+        if (typeof fieldData === "object" && Array.isArray(fieldData)) {
+          for (let i = 0; i < fieldData.length; i += 1) {
+            if (FieldTypeClass) {
+              fieldValueList[i] = this.parse(new FieldTypeClass(), fieldData[i]);
+            }
+          }
+        }
+        instance[field] = fieldValueList;
+        continue;
+      }
+      if (fieldData === void 0 || fieldData === null) {
+        continue;
+      }
+      if (!FieldTypeClass) {
+        continue;
+      }
+      switch (FieldTypeClass.name) {
+        case "String":
+          instance[field] = fieldData.toString();
+          break;
+        case "Number":
+          instance[field] = Number.isNaN(Number.parseFloat(fieldData)) ? void 0 : Number.parseFloat(fieldData);
+          break;
+        case "Boolean":
+          instance[field] = !!fieldData;
+          break;
+        default:
+          instance[field] = this.parse(new FieldTypeClass(), fieldData);
+      }
+    }
+    for (const fieldKey of fieldList) {
+      const alias = getAlias(instance, fieldKey) || fieldKey;
+      if (alias === fieldKey) {
+        continue;
+      }
+      delete instance[alias];
+    }
+    return instance;
+  }
+  /**
+   * ### 获取 JSON 的 key
+   * @param instance 目标实例
+   * @param field 属性 key
+   */
+  static getJsonKey(instance, field) {
+    const alias = getAlias(instance, field);
+    if (alias) {
+      return alias;
+    }
+    const prefix = getPrefix(instance);
+    if (!prefix) {
+      return field;
+    }
+    const ignorePrefix = getIgnorePrefix(instance, field);
+    if (!ignorePrefix) {
+      return prefix + field;
+    }
+    return field;
+  }
+  /**
+   * ### 将当前实例复制到一个新实例上
+   */
+  copy() {
+    const instance = Object.create(Object.getPrototypeOf(this));
+    return Object.assign(instance, this);
+  }
+  /**
+   * ### 暴露部分类的属性
+   * @param fields 属性列表
+   */
+  expose(...fields) {
+    const fieldList = Object.keys(this);
+    for (const field of fieldList) {
+      if (!fields.includes(field)) {
+        this[field] = void 0;
+      }
+    }
+    return this;
+  }
+  /**
+   * ### 排除部分类的属性
+   * @param fields 属性列表
+   */
+  exclude(...fields) {
+    const fieldList = Object.keys(this);
+    for (const field of fieldList) {
+      if (fields.includes(field)) {
+        this[field] = void 0;
+      }
+    }
+    return this;
+  }
+  /**
+   * ### 用指定的数据对当前实例进行覆盖
+   * 相同属性才会覆盖上去
+   * @param obj 覆盖对象
+   */
+  recoverBy(obj) {
+    return Object.assign(this, obj);
+  }
+  /**
+   * ### 转换到 `JSON`
+   * 会自动进行数据别名转换
+   */
+  toJson() {
+    const fieldList = Object.keys(this);
+    const json = {};
+    for (const field of fieldList) {
+      const data = this[field];
+      if (data === null || data === void 0) {
+        continue;
+      }
+      const jsonKey = Transformer.getJsonKey(this, field);
+      json[jsonKey] = data;
+      const toJson = getToJson(this, field);
+      if (toJson !== void 0) {
+        try {
+          json[jsonKey] = toJson(this);
+        } catch (e) {
+          console.warn("ToJson Function Error", e);
+        }
+        continue;
+      }
+      if (typeof data === "object") {
+        if (Array.isArray(data)) {
+          const jsonArray = [];
+          for (let i = 0; i < data.length; i += 1) {
+            if (typeof data[i] === "object") {
+              jsonArray[i] = data[i].toJson();
+              continue;
+            }
+            jsonArray[i] = data[i];
+          }
+          json[jsonKey || field] = jsonArray;
+          continue;
+        }
+        json[jsonKey || field] = data.toJson();
+      }
+    }
+    return json;
+  }
+}
+const KEY$5 = `${DecoratorUtil.DecoratorKeyPrefix}[Alias]`;
+function Alias(alias) {
+  return (target, key) => DecoratorUtil.setFieldConfig(target, key, KEY$5, alias);
+}
+function getAlias(target, key) {
+  return (DecoratorUtil.getFieldConfig(target, key, KEY$5) || "").toString();
+}
+const KEY$4 = `${DecoratorUtil.DecoratorKeyPrefix}[IgnorePrefix]`;
+function IgnorePrefix() {
+  return (target, key) => DecoratorUtil.setFieldConfig(target, key, KEY$4, true);
+}
+function getIgnorePrefix(target, key) {
+  return !!DecoratorUtil.getFieldConfig(target, key, KEY$4);
+}
+const KEY$3 = `${DecoratorUtil.DecoratorKeyPrefix}[Prefix]`;
+function Prefix(prefix) {
+  return (target) => DecoratorUtil.setClassConfig(target, KEY$3, prefix);
+}
+function getPrefix(target) {
+  return DecoratorUtil.getClassConfig(target, KEY$3, "");
+}
+const KEY$2 = `${DecoratorUtil.DecoratorKeyPrefix}[ToClass]`;
+function ToClass(func) {
+  return (target, key) => DecoratorUtil.setFieldConfig(target, key, KEY$2, func);
+}
+function getToClass(target, key) {
+  return DecoratorUtil.getFieldConfig(target, key, KEY$2);
+}
+const KEY$1 = `${DecoratorUtil.DecoratorKeyPrefix}[ToJson]`;
+function ToJson(func) {
+  return (target, key) => DecoratorUtil.setFieldConfig(target, key, KEY$1, func);
+}
+function getToJson(target, key) {
+  return DecoratorUtil.getFieldConfig(target, key, KEY$1);
+}
+const KEY = `${DecoratorUtil.DecoratorKeyPrefix}[Type]`;
+const KEY_ARRAY = `${DecoratorUtil.DecoratorKeyPrefix}[Array]`;
+function Type(type, array = false) {
+  return (target, key) => {
+    DecoratorUtil.setFieldConfig(target, key, KEY, type);
+    if (array) {
+      DecoratorUtil.setFieldConfig(target, key, KEY_ARRAY, array);
+    }
+  };
+}
+function getType(target, key) {
+  return DecoratorUtil.getFieldConfig(target, key, KEY) || void 0;
+}
+function getArray(target, key) {
+  return !!DecoratorUtil.getFieldConfig(target, key, KEY_ARRAY);
+}
+export {
+  Alias,
+  DecoratorUtil,
+  IgnorePrefix,
+  Prefix,
+  ToClass,
+  ToJson,
+  Transformer,
+  Type,
+  getAlias,
+  getArray,
+  getIgnorePrefix,
+  getPrefix,
+  getToClass,
+  getToJson,
+  getType
+};

package/dist/transformer/DecoratorUtil.d.ts

@@ -0,0 +1,65 @@
+import { DecoratorData, DecoratorTarget } from '../type/type';
+/**
+ * # 装饰器工具类
+ *
+ * @author Hamm.cn
+ */
+export declare class DecoratorUtil {
+    /**
+     * ### 装饰器前缀
+     */
+    static readonly DecoratorKeyPrefix = "[AirPower]";
+    /**
+     * ### 设置一个类配置项
+     * @param target 目标实体类
+     * @param classConfigKey 配置项索引键值
+     * @param classConfig 配置的参数
+     */
+    static setClassConfig(target: DecoratorTarget, classConfigKey: string, classConfig: unknown): void;
+    /**
+     * ### 递归获取指定类的配置项
+     * @param target 目标类
+     * @param classConfigKey 配置项的Key
+     * @param defaultValue `可选` 类装饰器请传入配置项实例
+     * @param isObject `可选` 是否是对象配置
+     */
+    static getClassConfig(target: DecoratorTarget, classConfigKey: string, defaultValue?: unknown, isObject?: boolean): DecoratorData;
+    /**
+     * ### 设置一个属性配置项
+     * @param target 目标类
+     * @param key 属性
+     * @param fieldConfigKey 配置项索引键值
+     * @param fieldConfig 配置的参数
+     * @param fieldListKey `可选` 类配置项列表索引值
+     */
+    static setFieldConfig(target: DecoratorTarget, key: string, fieldConfigKey: string, fieldConfig: unknown, fieldListKey?: string): void;
+    /**
+     * ### 获取类指定属性的指定类型的配置
+     * @param target 目标类
+     * @param key 属性
+     * @param fieldConfigKey FieldConfigKey
+     * @param isObject `可选` 是否对象配置
+     */
+    static getFieldConfig(target: DecoratorTarget, key: string, fieldConfigKey: string, isObject?: boolean): DecoratorData;
+    /**
+     * ### 获取类标记了装饰器的属性列表
+     * @param target 目标类
+     * @param fieldConfigKey FieldConfigKey
+     * @param list `递归参数` 无需传入
+     */
+    static getFieldList(target: DecoratorTarget, fieldConfigKey: string, list?: string[]): string[];
+    /**
+     * ### 反射添加属性
+     * @param target 目标类
+     * @param key 配置key
+     * @param value 配置值
+     */
+    private static setProperty;
+    /**
+     * ### 设置一个属性的包含装饰器索引
+     * @param target 目标类
+     * @param key 属性
+     * @param fieldListKey 类配置项列表索引值
+     */
+    private static addFieldDecoratorKey;
+}

package/dist/transformer/IJson.d.ts

@@ -0,0 +1,11 @@
+/**
+ * # 标准的 `JSON` 数据
+ *
+ * @author Hamm.cn
+ */
+export interface IJson<V = any> {
+    /**
+     * ### `JSON` 的键
+     */
+    [x: string]: V;
+}

package/dist/transformer/ITransformerConstructor.d.ts

@@ -0,0 +1,9 @@
+import { Transformer } from './Transformer';
+/**
+ * # 类构造接口
+ *
+ * @author Hamm.cn
+ */
+export interface ITransformerConstructor<T extends Transformer = Transformer> {
+    new (): T;
+}

package/dist/transformer/Transformer.d.ts

@@ -0,0 +1,63 @@
+import { IJson, ITransformerConstructor } from './index.ts';
+/**
+ * # 转换器
+ *
+ * @author Hamm.cn
+ */
+export declare class Transformer {
+    /**
+     * ### 从 `JSON` 转换到当前类的对象
+     * 会自动进行数据别名转换
+     * @param json `JSON`
+     */
+    static fromJson<T extends Transformer>(this: ITransformerConstructor<T>, json?: IJson): T;
+    /**
+     * ### 从 `JSON` 数组转换到当前类的对象数组
+     * 会自动进行数据别名转换
+     * @param jsonArray `JSON`数组
+     */
+    static fromJsonArray<T extends Transformer>(this: ITransformerConstructor<T>, jsonArray?: IJson | IJson[]): T[];
+    /**
+     * ### 创建一个当前类的实例
+     * @param recoverBy `可选` 初始化用于覆盖对象实例的 `JSON`
+     */
+    static newInstance<T extends Transformer>(this: ITransformerConstructor<T>, recoverBy?: IJson): T;
+    /**
+     * ### 转换 `JSON` 为实体
+     * 会自动进行数据别名转换
+     * @param instance 实体
+     * @param json `JSON`
+     */
+    private static parse;
+    /**
+     * ### 获取 JSON 的 key
+     * @param instance 目标实例
+     * @param field 属性 key
+     */
+    private static getJsonKey;
+    /**
+     * ### 将当前实例复制到一个新实例上
+     */
+    copy(): this;
+    /**
+     * ### 暴露部分类的属性
+     * @param fields 属性列表
+     */
+    expose(...fields: string[]): this;
+    /**
+     * ### 排除部分类的属性
+     * @param fields 属性列表
+     */
+    exclude(...fields: string[]): this;
+    /**
+     * ### 用指定的数据对当前实例进行覆盖
+     * 相同属性才会覆盖上去
+     * @param obj 覆盖对象
+     */
+    recoverBy(obj: IJson | Transformer): this;
+    /**
+     * ### 转换到 `JSON`
+     * 会自动进行数据别名转换
+     */
+    toJson(): IJson;
+}

package/dist/transformer/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DecoratorUtil';
+export * from './IJson';
+export * from './ITransformerConstructor';
+export * from './Transformer';

package/dist/type/type.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ### 装饰器目标类
+ */
+export type DecoratorTarget = any;
+/**
+ * ### 装饰器存储的数据类型
+ */
+export type DecoratorData = any;

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@airpower/transformer",
+  "type": "module",
+  "version": "0.0.1",
+  "description": "AirPower-Transformer 是一个基于 TypeScript 的数据转换器，提供了从 JSON 对象到 类实例 对象之间互相转换的系列装饰器和方法。",
+  "author": {
+    "name": "Hamm",
+    "email": "admin@hamm.cn",
+    "url": "https://github.com/HammCn"
+  },
+  "license": "MIT",
+  "homepage": "https://github.com/AirPowerTeam/AirPower-Transformer#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/AirPowerTeam/AirPower-Transformer.git"
+  },
+  "bugs": {
+    "url": "https://github.com/AirPowerTeam/AirPower-Transformer/issues"
+  },
+  "keywords": [
+    "AirPower",
+    "class-transformer",
+    "typescript",
+    "transformer",
+    "bean",
+    "bean-copy",
+    "oop",
+    "class"
+  ],
+  "main": "dist/main.js",
+  "module": "dist/main.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "assets"
+  ],
+  "scripts": {
+    "build": "tsc && vite build",
+    "lint": "eslint src --ext .ts",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "crypto-js": "^4.2.0"
+  },
+  "devDependencies": {
+    "@antfu/eslint-config": "^4.11.0",
+    "@types/node": "^22.13.14",
+    "eslint": "^9.23.0",
+    "typescript": "^5.8.2",
+    "vite": "^6.2.0",
+    "vite-plugin-dts": "^4.5.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}