mm_os 4.0.1 → 4.0.3

package/core/plugin/index.js

@@ -82,6 +82,15 @@ Plugin.prototype._initCore = async function (app, eventer, logger) {
   this._initOptions();
 };
 
+/**
+ * 获取应用实例
+ * @returns {object} 应用实例
+ */
+Plugin.prototype.getApp = function () {
+  // 初始化资源
+  return this.getParent();
+};
+
 /**
  * 获取插件配置
  * @returns {object} 插件配置

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "mm_os",
 	"description": "MM_OS服务端架构，用于快速构建应用程序，支持网站建设、小程序后台、AI应用、物联网(IOT/AIOT)、游戏服务端等多种场景。",
-	"version": "4.0.1",
+	"version": "4.0.3",
 	"main": "index.js",
 	"keywords": [
 		"AI",
@@ -52,12 +52,12 @@
 		"mm_statics": "^1.8.4",
 		"mm_xml": "^1.1.7",
 		"mqtt": "^5.15.1",
-		"openai": "^6.39.0"
+		"openai": "^6.42.0"
 	},
 	"devDependencies": {
 		"@types/jest": "^30.0.0",
 		"eslint-formatter-table": "^7.32.1",
-		"eslint-plugin-jsdoc": "^63.0.0",
+		"eslint-plugin-jsdoc": "^63.0.1",
 		"jest": "^30.4.2",
 		"mm_eslint": "^1.7.1"
 	},
@@ -76,6 +76,7 @@
 		"adapter/",
 		"com/",
 		"common/",
-		"core/"
+		"core/",
+		"ulits/"
 	]
 }

package/ulits/id_gen.js

@@ -0,0 +1,134 @@
+/**
+ * ID生成器
+ * 基于雪花算法实现，生成唯一ID
+ */
+class IdGen {
+  /**
+   * 构造函数
+   * @param {object} config 配置参数
+   * @param {number} config.worker_id 工作机器ID (0-31)
+   * @param {number} config.dc_id 数据中心ID (0-31)
+   * @param {number} config.sequence 序列号
+   */
+  constructor(config = {}) {
+    this.worker_id = config.worker_id || 0;
+    this.dc_id = config.dc_id || 0;
+    this.sequence = config.sequence || 0;
+
+    this.worker_id_bits = 5;
+    this.dc_id_bits = 5;
+    this.max_worker_id = -1 ^ (-1 << this.worker_id_bits);
+    this.max_dc_id = -1 ^ (-1 << this.dc_id_bits);
+    this.sequence_bits = 12;
+
+    this.worker_id_shift = this.sequence_bits;
+    this.dc_id_shift = this.sequence_bits + this.worker_id_bits;
+    this.timestamp_left_shift = this.sequence_bits + this.worker_id_bits + this.dc_id_bits;
+    this.sequence_mask = -1 ^ (-1 << this.sequence_bits);
+
+    this.last_timestamp = -1;
+
+    this.twepoch = 1288834974657;
+
+    if (this.worker_id > this.max_worker_id || this.worker_id < 0) {
+      throw new TypeError(`工作机器ID必须在0-${this.max_worker_id}之间`);
+    }
+    if (this.dc_id > this.max_dc_id || this.dc_id < 0) {
+      throw new TypeError(`数据中心ID必须在0-${this.max_dc_id}之间`);
+    }
+  }
+}
+
+/**
+ * 获取当前时间戳
+ * @returns {number} 当前时间戳
+ */
+IdGen.prototype._timeGen = function () {
+  return Date.now();
+};
+
+/**
+ * 等待下一毫秒
+ * @param {number} last_timestamp 上次时间戳
+ * @returns {number} 新的时间戳
+ */
+IdGen.prototype._tilNextMillis = function (last_timestamp) {
+  var timestamp = this._timeGen();
+  while (timestamp <= last_timestamp) {
+    timestamp = this._timeGen();
+  }
+  return timestamp;
+};
+
+/**
+ * 生成下一个ID
+ * @returns {string} 唯一ID
+ */
+IdGen.prototype.nextId = function () {
+  var timestamp = this._timeGen();
+
+  if (timestamp < this.last_timestamp) {
+    throw new Error('时钟回拨，拒绝生成ID');
+  }
+
+  if (this.last_timestamp === timestamp) {
+    this.sequence = (this.sequence + 1) & this.sequence_mask;
+    if (this.sequence === 0) {
+      timestamp = this._tilNextMillis(this.last_timestamp);
+    }
+  } else {
+    this.sequence = 0;
+  }
+
+  this.last_timestamp = timestamp;
+
+  var id = (BigInt(timestamp - this.twepoch) << BigInt(this.timestamp_left_shift))
+    | (BigInt(this.dc_id) << BigInt(this.dc_id_shift))
+    | (BigInt(this.worker_id) << BigInt(this.worker_id_shift))
+    | BigInt(this.sequence);
+
+  return id.toString();
+};
+
+/**
+ * 生成带前缀的ID
+ * @param {string} prefix 前缀
+ * @returns {string} 带前缀的唯一ID
+ */
+IdGen.prototype.genId = function (prefix) {
+  if (typeof prefix !== 'string') {
+    throw new TypeError('前缀必须是字符串');
+  }
+  return prefix + '_' + this.nextId();
+};
+
+/**
+ * 解析ID信息
+ * @param {string} id ID字符串
+ * @returns {object} ID信息对象
+ */
+IdGen.prototype.parseId = function (id) {
+  if (typeof id !== 'string') {
+    throw new TypeError('ID必须是字符串');
+  }
+  var num = BigInt(id.replace(/^[a-zA-Z_]+_/, ''));
+  var timestamp = Number((num >> 22n) + BigInt(this.twepoch));
+  var dc_id = Number((num >> 17n) & 31n);
+  var worker_id = Number((num >> 12n) & 31n);
+  var sequence = Number(num & 4095n);
+
+  return {
+    timestamp: timestamp,
+    datetime: new Date(timestamp).toISOString(),
+    dc_id: dc_id,
+    worker_id: worker_id,
+    sequence: sequence
+  };
+};
+
+var idGen = new IdGen();
+
+module.exports = {
+  IdGen,
+  idGen
+};

package/ulits/word.js

@@ -0,0 +1,206 @@
+/**
+ * 单词工具类
+ * @class Word
+ */
+class Word {
+  /**
+   * 构造函数
+   */
+  constructor() {
+
+  }
+}
+
+/**
+ * 分割单词
+ * @param {string} name 名称
+ * @returns {Array} 单词数组
+ */
+Word.prototype.splitWords = function (name) {
+  if (!name || name.length === 0) {
+    return [];
+  }
+
+  var words = [];
+  var current_word = '';
+  var last_char_type = null;
+
+  for (var i = 0; i < name.length; i++) {
+    var char = name[i];
+    var char_info = this._getCharInfo(char);
+
+    // 处理下划线和数字
+    if (char_info.is_under || char_info.is_digit) {
+      last_char_type = this._handleSepa(words, current_word, char, char_info);
+      current_word = '';
+      continue;
+    }
+
+    // 处理第一个字符
+    if (current_word.length === 0) {
+      current_word = char;
+      last_char_type = char_info.type;
+      continue;
+    }
+
+    // 处理字符转换
+    var result = this._handleCharTran(words, current_word, char, last_char_type, char_info.type);
+    words = result.words;
+    current_word = result.current_word;
+    last_char_type = char_info.type;
+  }
+
+  // 添加最后一个单词
+  if (current_word.length > 0) {
+    words.push(current_word);
+  }
+
+  return words;
+};
+
+/**
+ * 获取字符信息
+ * @param {string} char 字符
+ * @returns {object} 字符信息
+ * @private
+ */
+Word.prototype._getCharInfo = function (char) {
+  var is_upper = char >= 'A' && char <= 'Z';
+  var is_lower = char >= 'a' && char <= 'z';
+  var is_digit = char >= '0' && char <= '9';
+  var type = is_upper ? 'upper' : (is_lower ? 'lower' : (is_digit ? 'digit' : 'other'));
+  return { is_upper, is_lower, is_digit, is_under: char === '_', type };
+};
+
+/**
+ * 处理分隔符
+ * @param {Array} words 单词数组
+ * @param {string} current_word 当前单词
+ * @param {string} char 字符
+ * @param {object} char_info 字符信息
+ * @returns {string} 新的字符类型
+ * @private
+ */
+Word.prototype._handleSepa = function (words, current_word, char, char_info) {
+  if (current_word.length > 0) {
+    words.push(current_word);
+  }
+  if (char_info.is_digit) {
+    words.push(char);
+    return 'digit';
+  }
+  return 'underscore';
+};
+
+/**
+ * 处理字符转换
+ * @param {Array} words 单词数组
+ * @param {string} current_word 当前单词
+ * @param {string} char 字符
+ * @param {string} last_type 上一个字符类型
+ * @param {string} current_type 当前字符类型
+ * @returns {object} 处理结果
+ * @private
+ */
+Word.prototype._handleCharTran = function (
+  words, current_word, char, last_type, current_type
+) {
+  var is_last_letter = last_type === 'upper' || last_type === 'lower';
+  var is_current_letter = current_type === 'upper' || current_type === 'lower';
+
+  if (!is_last_letter || !is_current_letter) {
+    return { words, current_word: current_word + char };
+  }
+
+  if (last_type === 'upper' && current_type === 'lower') {
+    // 大写转小写
+    if (current_word.length > 1) {
+      var last_char = current_word[current_word.length - 1];
+      words.push(current_word.substring(0, current_word.length - 1));
+      return { words, current_word: last_char + char };
+    }
+    return { words, current_word: current_word + char };
+  }
+
+  if (last_type === 'lower' && current_type === 'upper') {
+    // 小写转大写
+    words.push(current_word);
+    return { words, current_word: char };
+  }
+
+  // 相同类型
+  return { words, current_word: current_word + char };
+};
+
+/**
+ * 将名称改为帕斯卡命名法
+ * @param {string} name 名称
+ * @returns {string} 帕斯卡命名法的名称
+ */
+Word.prototype.toPascalCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toLowerCase();
+    words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1);
+  }
+  return words.join('');
+};
+
+/**
+ * 将名称改为驼峰命名法
+ * @param {string} name 名称
+ * @returns {string} 驼峰命名法的名称
+ */
+Word.prototype.toCamelCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toLowerCase();
+    if (i > 0) {
+      words[i] = words[i].charAt(0).toUpperCase() + words[i].substring(1);
+    }
+  }
+  return words.join('');
+};
+
+/**
+ * 将名称改为小写蛇形(下划线)命名法
+ * @param {string} name 名称
+ * @returns {string} 小写蛇形(下划线)命名法的名称
+ */
+Word.prototype.toSnakeCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toLowerCase();
+  }
+  return words.join('_');
+};
+
+/**
+ * 将名称改为大写蛇形(下划线)命名法
+ * @param {string} name 名称
+ * @returns {string} 大写蛇形(下划线)命名法的名称
+ */
+Word.prototype.toUpperSnakeCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toUpperCase();
+  }
+  return words.join('_');
+};
+
+/**
+ * 将名称改为小写短横线(短横线)命名法
+ * @param {string} name 名称
+ * @returns {string} 小写短横线(短横线)命名法的名称
+ */
+Word.prototype.toKebabCase = function (name) {
+  var words = this.splitWords(name);
+  for (let i = 0; i < words.length; i++) {
+    words[i] = words[i].toLowerCase();
+  }
+  return words.join('-');
+};
+
+module.exports = {
+  Word
+};