@cicctencent/tars2node-cli 0.0.1

package/lib/generator/ts/typing.js

@@ -0,0 +1,193 @@
+'use strict';
+
+const SuperTyping = require('../typing');
+
+/**
+  *
+  * 声明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} TarsStreamType
+  * @property {string} tafType
+  * @property {*} source
+  *
+ * @typedef {object} TypingOptions
+ * @property {'string'|'number'|'bigint'} long
+  */
+class Typing extends SuperTyping {
+  /**
+   * @typedef {import("../finder")} Finder
+   * @constructor
+   * @param {Finder} finder
+   * @param {TypingOptions} options
+   */
+  constructor(finder, options) {
+    super(finder, options);
+    this._tsMaping = new Map();
+    this.initTsType();
+  }
+
+  initTsType() {
+    let longType = '';
+    switch (this._options.long) {
+      case 'string':
+        longType = 'string';
+        break;
+      case 'bigint':
+        longType = 'bigint';
+        break;
+      case 'number':
+      default:
+        longType = 'number';
+    }
+    this._tsMaping = new Map([
+      ['byte', 'number'],
+      ['short', 'number'],
+      ['int', 'number'],
+      ['unsigned int', 'number'],
+      ['double', 'number'],
+      ['float', 'number'],
+      ['long', longType],
+      ['string', 'string'],
+      ['bool', 'boolean'],
+    ]);
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} current
+   * @return {string}
+   */
+  toTSType(type, current) {
+    const index = `TSType#${current}#${JSON.stringify(type)}`;
+
+    if (!this._memo.has(index)) {
+      let result;
+
+      if (this.isBaseType(type)) result = this._tsMaping.get(type);
+      else if (this.isRefType(type)) result = this._refTypeToTSType(type, current);
+      else if (this.isVector(type)) {
+        if (type.target === 'byte') {
+          result = 'TarsStream.BinBuffer';
+        } else {
+          const member = this.toTSType(type.target, current);
+          result = `TarsStream.List<${member}>`;
+        }
+      } else if (this.isMap(type)) {
+        const key = this.toTSType(type.key, current);
+        const value = this.toTSType(type.value, current);
+        result = `TarsStream.Map<${key}, ${value}>`;
+      }
+
+      this._memo.set(index, /** @type {string} */ (result));
+    }
+
+    return /** @type {string} */ (this._memo.get(index));
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} current
+   * @return {string}
+   */
+  toTSObjectType(type, current) {
+    const index = `TSObjectType#${current}#${JSON.stringify(type)}`;
+
+    if (!this._memo.has(index)) {
+      let result;
+
+      if (this.isBaseType(type)) result = this._tsMaping.get(type);
+      else if (this.isRefType(type)) result = this._refTypeToTSObjectType(type, current);
+      else if (this.isVector(type)) {
+        if (type.target === 'byte') {
+          result = 'Buffer';
+        } else {
+          const member = this.toTSObjectType(type.target, current);
+          result = `Array<${member}>`;
+        }
+      } else if (this.isMap(type)) {
+        const key = this.toTSObjectType(type.key, current);
+        const value = this.toTSObjectType(type.value, current);
+        result = key === 'string' || key === 'number' ? `{[key: ${key}]: ${value}}` : `{[key in keyof ${key}]: ${value}}`;
+      }
+
+      this._memo.set(index, /** @type {string} */ (result));
+    }
+
+    return /** @type {string} */ (this._memo.get(index));
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} current
+   * @return {TarsStreamType}
+   */
+  toTarsStreamType(type, current) {
+    const index = `TarsStream#${current}#${JSON.stringify(type)}`;
+    const prefix = 'TarsStream.';
+    if (!this._memo.has(index)) {
+      const result = { source: null, tafType: '' };
+
+      if (this.isVector(type) && type.target !== 'byte') {
+        const member = this.toTarsStreamType(type.target, current).tafType;
+        result.tafType = `${prefix}List(<any>${member})`;
+      } else if (this.isMap(type)) {
+        const key = this.toTarsStreamType(type.key, current).tafType;
+        const value = this.toTarsStreamType(type.value, current).tafType;
+        result.tafType = `${prefix}Map(${key}, ${value})`;
+      } else {
+        return super.toTarsStreamType(type, current);
+      }
+
+      this._memo.set(index, result);
+    }
+
+    return /** @type {TarsStreamType} */ (this._memo.get(index));
+  }
+
+  /**
+   * @private
+   * @param {refType} type
+   * @param {string} current
+   * @return {string}
+   */
+  _refTypeToTSType(type, current) {
+    const { refPath, namespace } = this._getRefPath(type, current);
+    if (namespace !== current && namespace) { 
+      refPath.unshift(`$${namespace}`)
+    };
+
+    return refPath.join('.');
+  }
+
+  /**
+   * @private
+   * @param {refType} type
+   * @param {string} current
+   * @return {string}
+   */
+  _refTypeToTSObjectType(type, current) {
+    const tmp = this._refTypeToTSType(type, current);
+    const result = this._finder.find(/** @type {refType} */ (type), current);
+    if(!result){
+      throw new Error(`${current}中的${type.target}未定义！`);
+    }
+    if (result.type === 'struct') return `${tmp}${this._options.mode !== 'web' ? '$OBJ' : ''}`;
+    return tmp;
+  }
+}
+
+module.exports = Typing;

package/lib/generator/ts/util.js

@@ -0,0 +1,21 @@
+'use strict';
+
+
+function toMultilineComment(comment) {
+  let newComment = comment;
+  if (newComment) {
+    const arr = newComment.split(/\/\//);
+    // 把行注释变成段注释
+    if (arr.length > 1 && !/\/\*|\*\//.test(newComment)) {
+      newComment = `/** ${arr
+        .slice(1)
+        .join(" ")
+        .trim()} */\n\t\t${arr[0].trim()}`;
+    }
+  }
+  return newComment;
+}
+
+module.exports = {
+  toMultilineComment,
+};

package/lib/generator/typing.js

@@ -0,0 +1,351 @@
+'use strict';
+
+const BASE_TYPE_MAPPING = new Map([
+  ['byte', 'Int8'],
+  ['short', 'Int16'],
+  ['int', 'Int32'],
+  ['unsigned int', 'Int64'],
+  ['enum', 'Int32'],
+  ['string', 'String'],
+  ['bool', 'Boolean'],
+  ['long', 'Int64'],
+  ['float', 'Float'],
+  ['double', 'Double'],
+  ['struct', 'Struct'],
+  ['vector', 'List'],
+  ['map', 'Map'],
+  ['void', 'void'],
+]);
+
+/**
+ *
+ * 声明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} ByteType
+ * @property {'vector'} type
+ * @property {'byte'} target
+ *
+ * @typedef {object} TarsStreamType
+ * @property {string} tafType
+ * @property {*} source
+ *
+ * @typedef {object} TypingOptions
+ * @property {'string'|'number'|'bigint'} long
+ */
+class Typing {
+  /**
+   * @typedef {import("./finder")} Finder
+   * @constructor
+   * @param {Finder} finder
+   * @param {TypingOptions} options
+   */
+  constructor(finder, options) {
+    this._finder = finder;
+    this._options = options;
+    /** @type {Map<string, string | TarsStreamType>} */
+    this._memo = new Map();
+    this._initValue = new Map();
+    this._ioValue = new Map();
+    this.initTarsType();
+  }
+
+  initTarsType() {
+    let longInitValue = '';
+    let longIoValue = '';
+    switch (this._options.long) {
+      case 'string':
+        longInitValue = '"0"';
+        longIoValue = '"0"';
+        break;
+      case 'bigint':
+        longInitValue = '0n';
+        longIoValue = '0n';
+        break;
+      case 'number':
+      default:
+        longInitValue = '0';
+        longIoValue = '0';
+    }
+    this._initValue = new Map([
+      ['byte', '0'],
+      ['short', '0'],
+      ['int', '0'],
+      ['unsigned int', '0'],
+      ['double', '0'],
+      ['float', '0'],
+      ['bool', 'true'],
+      ['string', '""'],
+      ['long', longInitValue],
+    ]);
+    this._ioValue = new Map([
+      ['byte', '0'],
+      ['short', '0'],
+      ['int', '0'],
+      ['unsigned int', '0'],
+      ['double', '0'],
+      ['float', '0'],
+      ['bool', 'true'],
+      ['string', '""'],
+      ['long', longIoValue],
+    ]);
+  }
+
+  refresh() {
+    this._memo.clear();
+  }
+
+  /**
+   * @param {tarsType} type
+   * @return {type is string}
+   */
+  isBaseType(type) { return typeof type === 'string'; }
+
+  /**
+   * @param {tarsType} type
+   * @return {type is refType}
+   */
+  isRefType(type) { return /** @type {refType} */ (type).nested !== undefined; }
+
+  /**
+   * @param {tarsType} type
+   * @return {type is vecType}
+   */
+  isVector(type) { return /** @type {vecType} */ (type).type === 'vector'; }
+
+  /**
+   * @param {tarsType} type
+   * @return {type is mapType}
+   */
+  isMap(type) { return /** @type {mapType} */ (type).type === 'map'; }
+
+  /**
+   * @param {tarsType} type
+   * @return {type is ByteType}
+   */
+  isBytes(type) { return this.isVector(type) && type.target === 'byte'; }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} current
+   * @return {type is string}
+   */
+  isNotObjectType(type, current) {
+    if (typeof type === 'string') return true;
+    if (this.isVector(type)
+      || this.isMap(type)
+      || this.isBytes(type)) return false;
+    const { type: t } = this._finder.find(/** @type {refType} */ (type), current);
+    return t !== 'struct';
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} current
+   * @return {string}
+   */
+  toString(type, current) {
+    const index = `String#${current}#${JSON.stringify(type)}`;
+
+    if (!this._memo.has(index)) {
+      let result;
+
+      if (this.isBaseType(type) && BASE_TYPE_MAPPING.has(type)) {
+        result = /** @type {string} */ (BASE_TYPE_MAPPING.get(type)).toLowerCase();
+      } else if (this.isRefType(type)) result = this._refTypeToString(type, current);
+      else if (this.isVector(type)) {
+        const member = this.toString(type.target, current);
+        result = `list(${member})`;
+      } else if (this.isMap(type)) {
+        const key = this.toString(type.key, current);
+        const value = this.toString(type.value, current);
+        result = `map(${key}, ${value})`;
+      } else throw new Error(`Type: ${JSON.stringify(type)} is not a tars type`);
+
+      this._memo.set(index, result);
+    }
+
+    return /** @type {string} */ (this._memo.get(index));
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} current
+   * @return {TarsStreamType}
+   */
+  toTarsStreamType(type, current) {
+    const index = `TarsStream#${current}#${JSON.stringify(type)}`;
+    const prefix = 'TarsStream.';
+    if (!this._memo.has(index)) {
+      let result = { source: null, tafType: '' };
+
+      if (this.isBaseType(type)) result.tafType = `${prefix}${BASE_TYPE_MAPPING.get(type)}`;
+      else if (this.isRefType(type)) result = this._refTypeToTarsStreamType(type, current);
+      else if (this.isVector(type)) {
+        if (type.target === 'byte') {
+          result.tafType = `${prefix}BinBuffer`;
+        } else {
+          const member = this.toTarsStreamType(type.target, current).tafType;
+          result.tafType = `${prefix}List(${member})`;
+        }
+      } else if (this.isMap(type)) {
+        const key = this.toTarsStreamType(type.key, current).tafType;
+        const value = this.toTarsStreamType(type.value, current).tafType;
+        result.tafType = `${prefix}Map(${key}, ${value})`;
+      }
+
+      this._memo.set(index, result);
+    }
+
+    return /** @type {TarsStreamType} */ (this._memo.get(index));
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} current
+   * @return {string}
+   */
+  toIOType(type, current) {
+    const index = `IO#${current}#${JSON.stringify(type)}`;
+
+    if (!this._memo.has(index)) {
+      let result = null;
+      let key = type;
+
+      if (type === 'unsigned int') result = 'UInt32';
+      else if (this.isRefType(type)) key = this._finder.find(type, current).type;
+      else if (this.isBytes(type)) result = 'Bytes';
+      else if (this.isVector(type)) key = type.type;
+      else if (this.isMap(type)) key = type.type;
+
+      if (result === null) result = BASE_TYPE_MAPPING.get(/** @type {string} */(key));
+
+      if (result === null) throw new Error(`Type: ${JSON.stringify(type)} is not a tars type`);
+
+      this._memo.set(index, /** @type {string} */ (result));
+    }
+
+    return /** @type {string} */ (this._memo.get(index));
+  }
+
+  /**
+   * @param {string} type
+   * @return {string|undefined}
+   */
+  toDefaultValue(type) {
+    return this._initValue.get(type);
+  }
+
+  /**
+   * @param {string} type
+   * @return {string|undefined}
+   */
+  toIOValue(type) {
+    return this._ioValue.get(type);
+  }
+
+  /**
+   * @param {tarsType} type
+   * @param {string} current
+   * @param {boolean} [isTup = false]
+   * @return {string}
+   */
+  toTarsValue(type, current, isTup = false) {
+    const index = `TarsValue#${current}#${JSON.stringify(type)}`;
+
+    if (!this._memo.has(index)) {
+      let result;
+
+      if (typeof type === 'string') {
+        result = /** @type {string} */ (this.toIOValue(type));
+      } else {
+        const target = this.toTarsStreamType(type, current);
+        if (target.source || /** @type {vecType|mapType} */ (type).type) {
+          if (target.source && target.source.type === 'enum') {
+            result = `${target.tafType}.${target.source.value[0].id}`;
+          } else if (isTup) {
+            result = `${target.tafType}, new ${target.tafType}`;
+          } else result = target.tafType;
+        } else {
+          throw new Error(`Cannot convert type: ${type} to string`);
+        }
+      }
+
+      this._memo.set(index, /** @type {string} */ (result));
+    }
+
+    return /** @type {string} */ (this._memo.get(index));
+  }
+
+  /**
+   * @param {refType} type
+   * @param {string} current
+   * @return {{refPath: string[], namespace: string}}
+   */
+  _getRefPath(type, current) {
+    const refPath = this._options.useNameSpace ? [...type.nested, type.target] : [type.target];
+    let [namespace] = type.nested;
+    if (this._options.useNameSpace && !namespace) {
+      refPath.unshift(current);
+      namespace = current;
+    }
+    return { refPath, namespace };
+  }
+
+  /**
+   * @param {refType} type
+   * @param {string} current
+   * @return {string}
+   */
+  _refTypeToString(type, current) {
+    const { type: refType } = this._finder.find(type, current);
+
+    switch (refType) {
+      case 'struct': {
+        const { refPath } = this._getRefPath(type, current);
+        return refPath.join('.');
+      }
+      case 'enum':
+        return 'int32';
+      default:
+        throw new Error(`Type: ${JSON.stringify(type)} is not a ref type`);
+    }
+  }
+
+  /**
+   * @param {refType} type
+   * @param {string} current
+   * @return {TarsStreamType}
+   */
+  _refTypeToTarsStreamType(type, current) {
+    const result = { source: null, tafType: '' };
+    const refTarget = this._finder.find(type, current);
+
+    result.source = refTarget;
+
+    if (refTarget.type === 'struct' || refTarget.type === 'enum') {
+      const { refPath, namespace } = this._getRefPath(type, current);
+
+      if (namespace !== current) refPath.unshift(`$${namespace}`);
+
+      result.tafType = refPath.join('.');
+    }
+
+    return result;
+  }
+}
+
+module.exports = Typing;