@cicctencent/tars2node-cli 0.0.1

package/lib/generator/ts/def/struct.js

@@ -0,0 +1,383 @@
+'use strict';
+
+const BaseDef = require('./base');
+const util = require('../util');
+
+class StructDef extends BaseDef {
+  /**
+   *
+   * 声明JCE-Struct节点类型
+   * @typedef { refType | vecType | string | mapType } tarsType
+   *
+   * @typedef {object} refType
+   * @property {string} target
+   * @property {string[]} nested
+   *
+   * @typedef {object} vecType
+   * @property {'vector'} type
+   * @property {tarsType} target
+   *
+   * @typedef {object} mapType
+   * @property {'map'} type
+   * @property {tarsType} key
+   * @property {tarsType} value
+   *
+   * @typedef {object} member
+   * @property {number} index
+   * @property {string} id
+   * @property {boolean} require
+   * @property {tarsType} type
+   * @property {null|string} init
+   *
+   * @typedef {object} TarsStructNode
+   * @property {string} id
+   * @property {'struct'} type
+   * @property {member[]} members
+   *
+   * 工具类类型
+   * @typedef {import("../printer")} Printer
+   * @typedef {import("../typing")} Typing
+   *
+   * @typedef {object} CompilerOptions
+   * @property {'all'|'client'|'service'} mode
+   * @property {'string'|'number'|'bigint'} long
+   * @property {boolean} withReturn
+   * @property {boolean} gather
+   * @property {boolean} interface
+   * @property {string} [output]
+   *
+   * 创建Struct解析实例
+   * @constructor
+   * @param {Printer} printer - print类实例
+   * @param {Typing} typing - Typing类实例
+   * @param {CompilerOptions} options - 编译配置选项
+   */
+  constructor(printer, typing, options) {
+    super('', printer, typing, options);
+    this._id = '';
+    this._chainName = '';
+    /** @type {member[]} */
+    this._members = [];
+    this._beforeComment = '';
+  }
+
+  /**
+   * @param {string} name
+   */
+  setModuleName(name) {
+    super.setModuleName(name);
+    this._chainName = `${name}.${this._id}`;
+  }
+
+  /**
+   * @param {TarsStructNode} node
+   */
+  setNode({ id, members, beforeComment = '' }) {
+    this._members = members;
+    this._id = id;
+    this._chainName = `${this._moduleName}.${id}`;
+    this._beforeComment = beforeComment;
+  }
+
+  /**
+   * @param {string} name
+   * @param {TarsStructNode} node
+   */
+  reset(name, node) {
+    this.setModuleName(name);
+    this.setNode(node);
+
+    return this;
+  }
+
+  build() {
+    this._interface();
+    if (this._options.mode !== 'web') {
+      this._class();
+    }
+  }
+
+  _interface() {
+    this
+      ._printer
+      .word(this._beforeComment)
+      .newline()
+      .word('export', 'R')
+      .word('interface', 'R')
+      .word(`${this._id}${this._options.mode !== 'web' ? '$OBJ' : ''}`, 'R')
+      .word('{')
+      .indent();
+    this._members.forEach(this._interfaceItem.bind(this));
+    this._printer.dedent().newline().word('}');
+  }
+
+  /**
+   * @param {member} member
+   */
+  _interfaceItem({
+    id, type, require, comment = '',
+  }) {
+    const tsType = this._typing.toTSObjectType(type, this._moduleName);
+    const item = `${util.toMultilineComment(comment)}${id}${require ? '' : '?'}: ${tsType};`;
+    this._printer.newline().word(item);
+  }
+
+  /**
+ * 类的处理
+ */
+  _class() {
+    this
+      ._printer
+      .newline()
+      .word('export', 'R')
+      .word('class', 'R')
+      .word(this._id, 'R')
+      .word('{')
+      .indent();
+    this._classProps();
+    this._classConstructor();
+    this._classMethods();
+    this
+      ._printer
+      .dedent()
+      .line('}');
+  }
+
+  _classProps() {
+    this._members.forEach(({ id, type, require }) => {
+      const tsType = this._typing.toTSType(type, this._moduleName);
+      const item = `${id}${require ? '' : '?'}: ${tsType};`;
+      this._printer.newline().word(item);
+    });
+    // this._members.forEach(this._interfaceItem.bind(this));
+  }
+
+  /** 给类成员赋初值
+   * @param {member} member
+   * @return {string}
+   */
+  _getInitValue({ type, init }) {
+    if (init !== undefined && init !== null && typeof init !== 'object') return init;
+
+    if (!this._typing.isNotObjectType(type, this._moduleName)) {
+      return this._typing.toTarsStreamType(type, this._moduleName).tafType;
+    }
+
+    const { tafType, source } = this._typing.toTarsStreamType(type, this._moduleName);
+
+    if (source && source.type === 'enum') {
+      // @ts-ignore
+      if (init && init.target) {
+        // @ts-ignore
+        return `${tafType}.${init.target}`;
+      }
+      return `${tafType}.${source.value[0].id}`;
+    }
+
+    return /** @type {string} */ (this._typing.toDefaultValue(/** @type {string} */ (type)));
+  }
+
+  /** 生成 _readFrom 默认值
+   * @param {member} member
+   * @return {string}
+   */
+  _getIOValue({ type, init }) {
+    if (init !== undefined && init !== null && typeof init !== 'object') return init;
+
+    if (!this._typing.isNotObjectType(type, this._moduleName)) {
+      return this._typing.toTarsStreamType(type, this._moduleName).tafType;
+    }
+
+    const { tafType, source } = this._typing.toTarsStreamType(type, this._moduleName);
+
+
+    if (source && source.type === 'enum') {
+      // @ts-ignore
+      if (init && init.target) {
+        // @ts-ignore
+        return `${tafType}.${init.target}`;
+      }
+      return `${tafType}.${source.value[0].id}`;
+    }
+
+    return /** @type {string} */ (this._typing.toIOValue(/** @type {string} */ (type)));
+  }
+
+  _classConstructor() {
+    this._printer
+      .classMethod({
+        name: 'constructor',
+        params: [],
+        callback: () => {
+          this._members.map(this._classConstructorMemberInit.bind(this));
+          this._printer.line(`this._classname = "${this._chainName}";`);
+        },
+      });
+  }
+
+  /**
+   * @param {member} member
+   */
+  _classConstructorMemberInit(member) {
+    const { id, type } = member;
+    const needNew = this._typing.isNotObjectType(type, this._moduleName) ? '' : 'new ';
+    /** @type {(value: string) => Printer} */
+    const generate = value => this._printer.line(`this.${id} = ${needNew}${value};`);
+
+    generate(this._getInitValue(member));
+  }
+
+  _classMethods() {
+    this._printer
+      .classProps({
+        name: '_classname',
+        valueType: 'string',
+        value: "''",
+        type: 'protected',
+      })
+      .classProps({
+        name: '_proto_struct_name_',
+        valueType: 'string',
+        value: "''",
+        type: 'protected',
+      })
+      .classProps({
+        name: '_classname',
+        valueType: 'string',
+        value: `"${this._chainName}"`,
+        type: 'protected static',
+      })
+      .classMethod({
+        name: '_write',
+        params: [['os', 'TarsStream.TarsOutputStream'], ['tag', 'number'], ['value', 'any']],
+        type: 'protected static',
+        callback: () => {
+          this._printer.line('os.writeStruct(tag, value);');
+        },
+      })
+      .classMethod({
+        name: '_read',
+        params: [['is', 'TarsStream.TarsInputStream'], ['tag', 'number'], ['def', 'any']],
+        type: 'protected static',
+        callback: () => {
+          this._printer.line('return is.readStruct(tag, true, def);');
+        },
+      })
+      .classMethod({
+        name: '_readFrom',
+        params: [['is', 'TarsStream.TarsInputStream']],
+        type: 'protected static',
+        returnType: this._id,
+        callback: () => {
+          this._printer.line(`const tmp = new ${this._chainName};`);
+          this._members.forEach(this._readerMemberInit.bind(this));
+          this._printer.line('return tmp;');
+        },
+      })
+      .classMethod({
+        name: '_writeTo',
+        params: [['os', 'TarsStream.TarsOutputStream']],
+        type: 'protected',
+        callback: () => {
+          this._printer.line(`const that: Required<${this._id}> = <Required<${this._id}>>this;`);
+          this._members.forEach(({ index, id, type }) => {
+            const ioType = this._typing.toIOType(type, this._moduleName);
+            this._printer.line(`os.write${ioType}(${index}, that.${id});`);
+          });
+        },
+      })
+      .classMethod({
+        name: 'toObject',
+        params: [],
+        returnType: `${this._id}$OBJ`,
+        callback: () => {
+          this._printer.line(`const that: Required<${this._id}> = <Required<${this._id}>>this;`);
+          this._printer.line('return').space(1).scope(() => {
+            this._members.forEach(({ id, type }) => {
+              const suffix = this._typing.isNotObjectType(type, this._moduleName)
+                ? '' : '.toObject()';
+              this._printer.line(`"${id}": that.${id}${suffix},`);
+            });
+          }).semicolon();
+        },
+      })
+      .classMethod({
+        name: 'readFromObject',
+        params: [['json', `${this._id}$OBJ`]],
+        returnType: this._id,
+        callback: () => {
+          this._printer
+            .line(`const tmp: Required<${this._id}$OBJ> = <Required<${this._id}$OBJ>>json;`)
+            .line(`const that: Required<${this._id}> = <Required<${this._id}>>this;`);
+          this._members.forEach(({ id, type }) => {
+            this._printer.newline();
+            const suffix = this._typing.isNotObjectType(type, this._moduleName)
+              ? `that.${id} = tmp.${id}`
+              : `that.${id}.readFromObject(tmp.${id})`;
+            this._printer.word(`_hasOwnProperty.call(json, "${id}") && (${suffix});`);
+          });
+          this._printer.line('return this;');
+        },
+      })
+      .classMethod({
+        name: 'toBinBuffer',
+        params: [],
+        returnType: 'TarsStream.BinBuffer',
+        callback: () => {
+          this._printer
+            .line('const os = new TarsStream.TarsOutputStream();')
+            .line('this._writeTo(os);')
+            .line('return os.getBinBuffer();');
+        },
+      })
+      .classMethod({
+        name: 'new',
+        params: [],
+        type: 'static',
+        returnType: this._id,
+        callback: () => {
+          this._printer.line(`return new ${this._chainName}();`);
+        },
+      })
+      .classMethod({
+        name: 'create',
+        params: [['is', 'TarsStream.TarsInputStream']],
+        type: 'static',
+        returnType: this._id,
+        callback: () => {
+          this._printer.line(`return ${this._chainName}._readFrom(is);`);
+        },
+      });
+  }
+
+  /** 生成_readFrom函数
+   * @param {member} member
+   */
+  _readerMemberInit(member) {
+    const {
+      id,
+      index,
+      require,
+      type,
+    } = member;
+    const tsType = this._typing.toTSType(type, this._moduleName);
+    const ioType = this._typing.toIOType(type, this._moduleName);
+    /** @type {(value: string) => void} */
+    const generate = (value) => {
+      this
+        ._printer
+        .newline()
+        .word(`tmp.${id} = <${tsType}>is.read${ioType}`)
+        .word(`(${index}, ${require}, ${value}`);
+
+      const longLastParam = type === 'long' && this.generateLastParamForLong();
+      if (longLastParam) {
+        this._printer.word(`, ${longLastParam}`);
+      }
+      this._printer.word(')').semicolon();
+    };
+    generate(this._getIOValue(member));
+  }
+}
+
+module.exports = StructDef;