mm_machine 2.9.7 → 2.9.9

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.
package/index.js CHANGED
@@ -1,1526 +1,76 @@
1
- /**
2
- * Manager 管理器类
3
- * 负责模块注册、检索、执行,支持注册表协同和多种执行模式
4
- * @class Manager
5
- * @augments Drive
6
- */
7
- var path = require('path');
8
- var { Drive } = require('./drive');
9
- var { Registry } = require('./registry');
10
-
11
- /**
12
- * 生命周期状态优先级
13
- * 用于 reload 时状态恢复
14
- */
15
- var statePriority = {
16
- created: 0,
17
- loaded: 1,
18
- inited: 2,
19
- started: 3,
20
- paused: 4,
21
- ended: 5,
22
- destroyed: 6
23
- };
1
+ const { Mod } = require('./mod');
2
+ const { Drive } = require('./drive.js');
3
+ const { Scanner } = require('./scanner.js');
4
+ const { Registry } = require('./registry.js');
5
+ const { Manager } = require('./manager.js');
24
6
 
25
7
  /**
26
- * 静态配置默认值
8
+ * 索引类 - 唯一入口
9
+ * 作为模块系统的顶层入口,内部持有 Registry(注册表)和 Manager(运行时管理器)
27
10
  */
28
- var defaultConfig = {
29
- name: 'manager',
30
- title: '管理器',
31
- description: '模块管理器',
32
- dir: '',
33
- use_registry: false,
34
- registry_file: 'cache/registry.json',
35
- lazy_load: 'auto',
36
- exec_mode: 1,
37
- sort: 100
38
- };
39
-
40
- class Manager extends Drive {
11
+ class Index {
41
12
  /**
42
13
  * 构造函数
43
- * @param {object} cfg 配置参数
44
- * @param {string} [cfg.dir] 模块存放目录
45
- * @param {boolean} [cfg.use_registry=false] 是否启用注册表
46
- * @param {string} [cfg.registry_file='cache/registry.json'] 注册表文件路径
47
- * @param {string|boolean} [cfg.lazy_load='auto'] 全局懒加载策略
48
- * @param {number} [cfg.exec_mode=1] 事件执行模式
49
- * @param parent
50
- * @param mods
51
- * @param DriveClass
14
+ * @param {object} config 配置对象
15
+ * @param {object} parent 父对象
52
16
  */
53
- constructor(cfg, parent, mods, DriveClass) {
54
- // 兼容旧签名:new Manager(config, parent, mods, Drive)
55
- if (parent !== undefined || mods !== undefined) {
56
- var config = { ...defaultConfig, ...cfg };
57
- // 合并旧 config 中的静态配置
58
- if (Manager.config) {
59
- config = { ...Manager.config, ...config };
60
- }
61
- super(config, parent);
62
- this._mods = mods || {};
63
- this._infos = [];
64
- this.registry = null;
65
- this.dir = config.dir || '';
66
- if (DriveClass) {
67
- this.Drive = DriveClass;
68
- }
69
- } else {
70
- var config = { ...defaultConfig, ...cfg };
71
- super(config);
72
- this._mods = {};
73
- this._infos = [];
74
- this.registry = null;
75
- this.dir = config.dir || '';
76
- }
77
- }
78
- }
79
-
80
- // ==================== 注册表管理 ====================
81
-
82
- /**
83
- * 关联注册表实例
84
- * @param {object} registry Registry 实例
85
- */
86
- Manager.prototype.setRegistry = function (registry) {
87
- this.registry = registry;
88
- };
89
-
90
- /**
91
- * 获取注册表实例
92
- * @returns {object|null} Registry 实例
93
- */
94
- Manager.prototype.getRegistry = function () {
95
- return this.registry;
96
- };
97
-
98
- // ==================== 模块查询 ====================
99
-
100
- /**
101
- * 获取模块
102
- * @param {string} name 模块名称
103
- * @returns {object|null} 模块实例,不存在返回 null
104
- */
105
- Manager.prototype.getMod = function (name) {
106
- return this._mods[name];
107
- };
108
-
109
- /**
110
- * 获取所有模块
111
- * @returns {object} 模块对象 { name: Drive }
112
- */
113
- Manager.prototype.getMods = function () {
114
- return this._mods;
115
- };
116
-
117
- /**
118
- * 获取模块列表
119
- * @param {string} [keyword] 模糊匹配关键词,匹配 name 和 title
120
- * @returns {Array<object>} 模块实例数组
121
- */
122
- Manager.prototype.getList = function (keyword) {
123
- var list = [];
124
- for (var i = 0; i < this._infos.length; i++) {
125
- var info = this._infos[i];
126
- var mod = this.getMod(info.name);
127
- if (!mod) {
128
- continue;
129
- }
130
- // 合并状态信息
131
- mod.config.state = info.state;
132
- list.push(mod);
133
- }
134
- if (keyword) {
135
- list = list.filter((o) => {
136
- return (o.config.name && o.config.name.indexOf(keyword) !== -1) ||
137
- (o.config.title && o.config.title.indexOf(keyword) !== -1) ||
138
- (o.config.description && o.config.description.indexOf(keyword) !== -1);
139
- });
140
- }
141
- return list;
142
- };
143
-
144
- /**
145
- * 获取模块信息列表
146
- * @returns {Array<object>} 模块信息数组
147
- */
148
- Manager.prototype.getInfos = function () {
149
- return this._infos;
150
- };
151
-
152
- /**
153
- * 设置模块
154
- * @param {string} name 模块名称
155
- * @param {object} mod 模块实例
156
- * @returns {object|null} 设置的模块实例
157
- */
158
- Manager.prototype.setMod = function (name, mod) {
159
- this._mods[name] = mod;
160
- return this.getMod(name);
161
- };
162
-
163
- /**
164
- * 更新模块信息
165
- * 部分合并,只覆盖 info 中存在的字段
166
- * @param {string} name 模块名称
167
- * @param {object} info 要更新的信息字段
168
- */
169
- Manager.prototype.setInfo = function (name, info) {
170
- // 兼容旧签名:setInfo({ name, sort, state, ... })
171
- var info_name = name;
172
- var info_data = info;
173
- if (typeof name === 'object' && name !== null) {
174
- info_data = name;
175
- info_name = info_data.name;
176
- }
177
- if (!info_data || !info_name) {
178
- return;
179
- }
180
- for (var i = 0; i < this._infos.length; i++) {
181
- if (this._infos[i].name === info_name) {
182
- for (var k in info_data) {
183
- this._infos[i][k] = info_data[k];
184
- }
185
- return;
186
- }
187
- }
188
- // 不存在则追加
189
- this._infos.push(info_data);
190
- };
191
-
192
- /**
193
- * 删除模块(仅内存,不删除文件)
194
- * @param {string} name 模块名称
195
- * @returns {object|null} 删除的模块实例
196
- */
197
- Manager.prototype.delMod = function (name) {
198
- var mod = this._mods[name];
199
- if (mod) {
200
- delete this._mods[name];
201
- }
202
- return mod;
203
- };
17
+ constructor(config, parent) {
18
+ this.config = Object.assign(
19
+ {
20
+ name: 'default'
21
+ },
22
+ config
23
+ );
204
24
 
205
- /**
206
- * 清除所有模块
207
- * 先遍历调用所有模块的 end() 和 destroy() 清理,再清空内存
208
- */
209
- Manager.prototype.clearMods = function () {
210
- for (var name in this._mods) {
211
- var mod = this._mods[name];
212
- try {
213
- if (mod.lifecycle_state === 'started' || mod.lifecycle_state === 'paused') {
214
- mod.end();
215
- }
216
- if (mod.lifecycle_state === 'ended') {
217
- mod.destroy();
218
- }
219
- } catch {
220
- // 清理异常不影响其他模块
25
+ if (parent) {
26
+ this.getParent = function () {
27
+ return parent;
28
+ };
221
29
  }
222
- }
223
- this._mods = {};
224
- this._infos = [];
225
- };
226
-
227
- // ==================== 模块注册/创建 ====================
228
-
229
- /**
230
- * 创建并注册模块
231
- * 根据 type 决定实例化类
232
- * @param {string} config_file 配置文件路径
233
- * @param {object} [cfg] 配置对象,不传则从文件读取
234
- * @param {object|string} [script] 脚本内容,不传则从文件读取
235
- * @returns {object} 模块实例
236
- */
237
- Manager.prototype.registerMod = function (config_file, cfg, script) {
238
- var config = cfg || {};
239
30
 
240
- // 未提供 cfg 时从文件读取
241
- if (!config.name && config_file) {
242
- try {
243
- var content = require(config_file);
244
- config = { ...config, ...content };
245
- } catch {
246
- // 文件读取失败,使用传入的 cfg
31
+ // 注册表:管理类注册、模块配置持久化、模块实例懒加载
32
+ if (!$.registry) {
33
+ $.registry = new Registry({
34
+ name: this.constructor.name + '_' + this.config.name
35
+ });
247
36
  }
248
- }
249
-
250
- // 创建模块实例
251
- var mod = this._createModInstance(config);
252
- mod.config_file = config_file;
253
- mod.mode = config.mode || 3;
254
-
255
- // 注册脚本方法
256
- this._regScriptMethods(mod, script);
257
37
 
258
- this._mods[config.name] = mod;
259
- return mod;
260
- };
261
-
262
- /**
263
- * 根据类型创建模块实例
264
- * @param {object} config 配置对象
265
- * @returns {object} 模块实例
266
- * @private
267
- */
268
- Manager.prototype._createModInstance = function (config) {
269
- var mod_type = config.type || 'plugin';
270
- if (mod_type === 'manager') {
271
- return new Manager(config);
272
- }
273
- return new Drive(config);
274
- };
275
-
276
- /**
277
- * 注册脚本方法到模块
278
- * @param {object} mod 模块实例
279
- * @param {object|string} script 脚本内容
280
- * @private
281
- */
282
- Manager.prototype._regScriptMethods = function (mod, script) {
283
- if (!script || typeof script !== 'object') {
284
- return;
285
- }
286
- for (var key in script) {
287
- var val = script[key];
288
- if (typeof val === 'function') {
289
- mod.setMethod(key, val);
290
- }
38
+ // 运行时管理器:管理模块生命周期和方法派发
39
+ this._manager = new Manager({}, this);
291
40
  }
292
41
  }
293
42
 
294
- // 向后兼容:infos 和 mods 通过 getter/setter 暴露
295
- Object.defineProperty(Manager.prototype, 'infos', {
296
- get: function () { return this._infos; },
297
- set: function (val) { this._infos = val; }
298
- });
299
- Object.defineProperty(Manager.prototype, 'mods', {
300
- get: function () { return this._mods; },
301
- set: function (val) { this._mods = val; }
302
- });
303
-
304
- /**
305
- * 从注册表数据直接创建模块实例(轻量版,0 IO)
306
- * 已存在的模块跳过(不重复创建)
307
- * @param {object} data 注册表数据
308
- * @param {string} data.name 模块名称
309
- * @param {string} data.config_file 配置文件路径
310
- * @param {string} [data.type] 模块类型
311
- * @returns {object|null} 创建的模块实例,已存在返回 null
312
- */
313
- Manager.prototype.registerModEx = function (data) {
314
- if (!data || !data.name) {
315
- return null;
316
- }
317
-
318
- // 去重检查
319
- if (this.getMod(data.name)) {
320
- return null;
321
- }
322
-
323
- // 根据 type 选择实例化类
324
- var mod_type = data.type || 'plugin';
325
- var mod;
326
- if (mod_type === 'manager') {
327
- mod = new Manager(data);
328
- } else {
329
- mod = new Drive(data);
330
- }
331
-
332
- mod.config_file = data.config_file || '';
333
- this._mods[data.name] = mod;
334
- return mod;
335
- };
336
-
337
- /**
338
- * 创建文件模块并注册
339
- * @param {object} cfg 模块配置
340
- * @param {string} [file] 目标文件路径,不传则按规则生成
341
- * @returns {object} 模块实例
342
- */
343
- Manager.prototype.create = function (cfg, file) {
344
- if (!cfg || !cfg.name) {
345
- throw new TypeError('模块配置必须包含 name 字段');
346
- }
347
-
348
- var new_cfg = { ...cfg };
349
- var config_file = file || this._resolveConfigFile(new_cfg.name);
350
- new_cfg.config_file = config_file;
351
-
352
- // 创建配置文件到磁盘
353
- Drive.prototype.createConfigFile(config_file, new_cfg);
354
-
355
- return this.registerMod(config_file, new_cfg);
356
- };
357
-
358
- /**
359
- * 构建模块信息对象
360
- * @param {object} mod 模块实例
361
- * @returns {object} 模块信息
362
- * @private
363
- */
364
- // eslint-disable-next-line complexity
365
- Manager.prototype._buildInfo = function (mod) {
366
- var cfg = mod.config || {};
367
- return {
368
- name: cfg.name || '',
369
- title: cfg.title || '',
370
- main: cfg.main || '',
371
- func_name: cfg.func_name || 'main',
372
- scope: cfg.scope || 0,
373
- sort: cfg.sort || 100,
374
- mode: cfg.mode || 3,
375
- exec_mode: cfg.exec_mode || 1,
376
- dir: mod.getDir ? mod.getDir() : '',
377
- config_file: mod.config_file || '',
378
- script_file: mod._script || '',
379
- // eslint-disable-next-line mm_eslint/variable-name
380
- lifecycle_state: mod.lifecycle_state || 'created',
381
- is_loaded: !!mod.is_loaded,
382
- enabled: cfg.enabled !== false
383
- };
384
- };
385
-
386
- /**
387
- * 解析配置文件路径
388
- * @param {string} name 模块名称
389
- * @returns {string} 配置文件路径
390
- * @private
391
- */
392
- Manager.prototype._resolveConfigFile = function (name) {
393
- var base_dir = this.dir || process.cwd();
394
- return path.join(base_dir, name, name + '.json');
395
- };
396
-
397
- // ==================== 模块调用 ====================
398
-
399
- /**
400
- * 调用模块方法
401
- * @param {string} name 模块名称,传 null 遍历所有已启用模块
402
- * @param {string} [method] 方法名,默认 'main'
403
- * @param {*} [params] 参数
404
- * @returns {Promise<*|Array>} 执行结果
405
- */
406
- Manager.prototype.main = async function (name, method, params) {
407
- var method_name = method || 'main';
408
-
409
- if (name) {
410
- // 指定模块
411
- var mod = this.getMod(name);
412
- if (!mod) {
413
- return null;
414
- }
415
- return this._runMod(mod, method_name, params);
416
- }
417
-
418
- // 遍历所有已启用模块
419
- var results = [];
420
- var mods = this._getSortedMods();
421
- for (var i = 0; i < mods.length; i++) {
422
- var mod = mods[i];
423
- var cfg = mod.config || {};
424
- if (cfg.enabled === false) {
425
- continue;
426
- }
427
- try {
428
- var result = await this._runMod(mod, method_name, params);
429
- results.push({ name: mod.config.name, result: result });
430
- } catch (err) {
431
- results.push({ name: mod.config.name, error: err });
432
- }
433
- }
434
- return results;
435
- };
436
-
437
- /**
438
- * 运行模块方法(自动推进生命周期)
439
- * @param {object} mod 模块实例
440
- * @param {string} method 方法名
441
- * @param {*} params 参数
442
- * @returns {Promise<*>} 执行结果
443
- * @private
444
- */
445
- Manager.prototype._runMod = async function (mod, method, params) {
446
- var state = mod.lifecycle_state;
447
-
448
- try {
449
- await this._advanceToStarted(mod, state);
450
- } catch (err) {
451
- // 生命周期推进失败,透传错误
452
- throw err;
453
- }
454
-
455
- return mod.call(method, params);
456
- };
457
-
458
- /**
459
- * 推进模块到 started 状态
460
- * @param {object} mod 模块实例
461
- * @param {string} state 当前状态
462
- * @returns {Promise<void>}
463
- * @private
464
- */
465
- Manager.prototype._advanceToStarted = async function (mod, state) {
466
- var mod_name = mod.config.name || '';
467
-
468
- switch (state) {
469
- case 'created':
470
- await mod.load();
471
- await mod.init();
472
- await mod.start();
473
- break;
474
- case 'loaded':
475
- await mod.init();
476
- await mod.start();
477
- break;
478
- case 'inited':
479
- await mod.start();
480
- break;
481
- case 'started':
482
- break;
483
- case 'paused':
484
- throw new Error('模块 [' + mod_name + '] 已暂停,无法执行');
485
- case 'ended':
486
- await mod.load();
487
- await mod.init();
488
- await mod.start();
489
- break;
490
- case 'destroyed':
491
- throw new Error('模块 [' + mod_name + '] 已销毁,无法执行');
492
- default:
493
- throw new Error('模块 [' + mod_name + '] 状态异常');
494
- }
495
- };
496
-
497
- /**
498
- * 获取按 sort 排序的模块列表
499
- * @returns {Array<object>} 排序后的模块数组
500
- * @private
501
- */
502
- Manager.prototype._getSortedMods = function () {
503
- var list = [];
504
- for (var name in this._mods) {
505
- list.push(this._mods[name]);
506
- }
507
- list.sort((a, b) => {
508
- var sort_a = (a.config && a.config.sort) || 100;
509
- var sort_b = (b.config && b.config.sort) || 100;
510
- return sort_a - sort_b;
511
- });
512
- return list;
513
- };
514
-
515
- // ==================== 模块注销/删除 ====================
516
-
517
- /**
518
- * 注销模块
519
- * 先 end() 卸载,再 delMod 删除内存
520
- * @param {string} name 模块名称
521
- * @returns {object|null} 注销的模块实例
522
- */
523
- Manager.prototype.unreMod = function (name) {
524
- var mod = this.getMod(name);
525
- if (!mod) {
526
- return null;
527
- }
528
-
529
- try {
530
- if (mod.lifecycle_state === 'started' || mod.lifecycle_state === 'paused') {
531
- mod.end();
532
- }
533
- } catch {
534
- // 忽略
535
- }
536
-
537
- this.delMod(name);
538
- this._removeInfo(name);
539
- return mod;
540
- };
541
-
542
- /**
543
- * 删除模块(先注销,再删除配置文件+脚本文件)
544
- * @param {string} name 模块名称
545
- */
546
- Manager.prototype.remove = function (name) {
547
- var mod = this.unreMod(name);
548
- if (!mod) {
549
- return;
550
- }
551
-
552
- // 删除配置文件
553
- try {
554
- if (mod.config_file && require('fs').existsSync(mod.config_file)) {
555
- require('fs').unlinkSync(mod.config_file);
556
- }
557
- } catch {
558
- // 忽略
559
- }
560
-
561
- // 删除脚本文件
562
- try {
563
- if (mod._script && require('fs').existsSync(mod._script)) {
564
- require('fs').unlinkSync(mod._script);
565
- }
566
- } catch {
567
- // 忽略
568
- }
569
- };
570
-
571
- /**
572
- * 移除模块信息
573
- * @param {string} name 模块名称
574
- * @private
575
- */
576
- Manager.prototype._removeInfo = function (name) {
577
- for (var i = 0; i < this._infos.length; i++) {
578
- if (this._infos[i].name === name) {
579
- this._infos.splice(i, 1);
580
- return;
581
- }
582
- }
583
- };
584
-
585
- // ==================== 重载模块 ====================
586
-
587
- /**
588
- * 重载模块
589
- * 清除缓存 → 重新执行生命周期到原状态
590
- * @param {string} name 模块名称
591
- * @returns {Promise<object>} 重载后的模块状态
592
- */
593
- Manager.prototype.reload = async function (name) {
594
- var mod = this.getMod(name);
595
- if (!mod) {
596
- throw new Error('模块 [' + name + '] 不存在');
597
- }
598
-
599
- var current_state = mod.lifecycle_state;
600
- var priority = statePriority[current_state] !== undefined ? statePriority[current_state] : 0;
601
-
602
- // 清理:优先级 >= 3 时先 end()
603
- if (priority >= 3) {
604
- try {
605
- await mod.end();
606
- } catch {
607
- // 忽略
608
- }
609
- }
610
-
611
- // 清除 require.cache
612
- this._clearModCache(mod);
613
-
614
- // 重新执行生命周期到原状态
615
- try {
616
- await this._restoreModState(mod, priority);
617
- } catch (err) {
618
- throw err;
619
- }
620
-
621
- return mod.lifecycle_state;
622
- };
623
-
624
- /**
625
- * 清除模块的 require 缓存
626
- * @param {object} mod 模块实例
627
- * @private
628
- */
629
- Manager.prototype._clearModCache = function (mod) {
630
- if (!mod._script) {
631
- return;
632
- }
633
- try {
634
- var resolved = require.resolve(mod._script);
635
- if (require.cache[resolved]) {
636
- delete require.cache[resolved];
637
- }
638
- } catch {
639
- // 忽略
640
- }
641
- };
642
-
643
- /**
644
- * 恢复模块到指定优先级状态
645
- * @param {object} mod 模块实例
646
- * @param {number} priority 目标优先级
647
- * @returns {Promise<void>}
648
- * @private
649
- */
650
- Manager.prototype._restoreModState = async function (mod, priority) {
651
- if (priority >= 1) {
652
- await mod.load();
653
- }
654
- if (priority >= 2) {
655
- await mod.init();
656
- }
657
- if (priority >= 3) {
658
- await mod.start();
659
- }
660
- if (priority >= 4) {
661
- await mod.pause();
662
- }
663
- };
664
-
665
- // ==================== 扫描注册 ====================
666
-
667
- /**
668
- * 扫描目录并注册新模块
669
- * @param {object} scanner DirScanner 实例
670
- * @param {string[]} dirs 要扫描的目录列表
671
- * @returns {Promise<number>} 成功注册的模块数量
672
- */
673
- Manager.prototype.scanAndRegister = async function (scanner, dirs) {
674
- if (!scanner || typeof scanner.scanAndParse !== 'function') {
675
- throw new TypeError('scanner 必须包含 scanAndParse 方法');
676
- }
677
- if (!dirs || !Array.isArray(dirs)) {
678
- return 0;
679
- }
680
-
681
- var count = 0;
682
-
683
- for (var i = 0; i < dirs.length; i++) {
684
- count += this._scanDirModules(scanner, dirs[i]);
685
- }
686
-
687
- return count;
688
- };
689
-
690
- /**
691
- * 扫描单个目录并注册模块
692
- * @param {object} scanner DirScanner 实例
693
- * @param {string} dir 目录路径
694
- * @returns {number} 成功注册的模块数量
695
- * @private
696
- */
697
- Manager.prototype._scanDirModules = function (scanner, dir) {
698
- var count = 0;
699
-
700
- try {
701
- var entries = scanner.scanAndParse(dir, '*.json');
702
- for (var j = 0; j < entries.length; j++) {
703
- var entry = entries[j];
704
- var cfg = entry.config;
705
- if (cfg && cfg.name && !this.getMod(cfg.name)) {
706
- this.registerMod(entry.file, cfg);
707
- count++;
708
- }
709
- }
710
- } catch {
711
- // 单个目录扫描失败不影响其他目录
712
- }
713
-
714
- return count;
715
- };
716
-
717
- // ==================== 启动引导 ====================
718
-
719
- /**
720
- * 启动引导
721
- * 外部入口,根据 use_registry 决定走注册表路径还是旧路径
722
- * @returns {Promise<void>}
723
- */
724
- Manager.prototype.boot = async function () {
725
- if (this.config.use_registry) {
726
- await this._bootWithRegistry();
727
- } else {
728
- await this._bootWithoutRegistry();
729
- }
730
- };
731
-
732
- /**
733
- * 注册表路径启动引导
734
- * @returns {Promise<void>}
735
- * @private
736
- */
737
- Manager.prototype._bootWithRegistry = async function () {
738
- if (!this.registry) {
739
- this.registry = new Registry(this, {});
740
- }
741
- await this.registry.boot();
742
-
743
- // 注册表为空时,扫描文件系统
744
- if (this.registry.getEntryCount() === 0 && this.dir) {
745
- await this._scanAndFillRegistry();
746
- }
747
- };
748
-
749
- /**
750
- * 旧路径启动引导(直接扫描目录)
751
- * @returns {Promise<void>}
752
- * @private
753
- */
754
- Manager.prototype._bootWithoutRegistry = async function () {
755
- if (!this.dir) {
756
- return;
757
- }
758
-
759
- var { DirScanner } = require('./dir_scanner');
760
- var scanner = new DirScanner();
761
- var entries = scanner.scanAndParse(this.dir, '*.json');
762
-
763
- for (var i = 0; i < entries.length; i++) {
764
- var entry = entries[i];
765
- if (entry.config && entry.config.name) {
766
- this.registerMod(entry.file, entry.config);
767
- }
768
- }
769
-
770
- // 启动自启动模块
771
- await this._startAutoModules();
772
- };
773
-
774
- /**
775
- * 扫描文件系统并填充注册表
776
- * @returns {Promise<void>}
777
- * @private
778
- */
779
- Manager.prototype._scanAndFillRegistry = async function () {
780
- var { DirScanner } = require('./dir_scanner');
781
- var scanner = new DirScanner();
782
- var entries = scanner.scanAndParse(this.dir, '*.json');
783
- if (entries.length > 0) {
784
- this.registry.registerAll(entries);
785
- }
786
- };
787
-
788
- /**
789
- * 启动所有自启动模块
790
- * @returns {Promise<void>}
791
- * @private
792
- */
793
- Manager.prototype._startAutoModules = async function () {
794
- var mods = this._getSortedMods();
795
- for (var j = 0; j < mods.length; j++) {
796
- var mod = mods[j];
797
- if (mod.config && mod.config.auto_start) {
798
- try {
799
- await mod.load();
800
- await mod.init();
801
- await mod.start();
802
- } catch {
803
- // 单个模块启动失败不影响其他模块
804
- }
805
- }
806
- }
807
- };
808
-
809
- // ==================== 生命周期传播 ====================
810
-
811
- /**
812
- * 启动核心
813
- * 先调用父类逻辑,再传播到子模块
814
- * @returns {Promise<void>}
815
- * @private
816
- * @override
817
- */
818
- Manager.prototype._startCore = async function () {
819
- if (this.lifecycle_state !== 'inited') {
820
- if (this.lifecycle_state === 'started') {
821
- return;
822
- }
823
- throw new Error('模块未初始化,无法启动');
824
- }
825
-
826
- this.emit('start:before');
827
-
828
- try {
829
- var start_hook = this.getMethod('_start');
830
- if (start_hook) {
831
- var result = start_hook(this);
832
- if (result instanceof Promise) {
833
- await result;
834
- }
835
- }
836
-
837
- // 传播到子模块
838
- await this._propToChildren('start');
839
-
840
- this.lifecycle_state = 'started';
841
- this.emit('start:success');
842
- } catch (err) {
843
- this.emit('start:error', err);
844
- throw err;
845
- }
846
- };
847
-
848
- /**
849
- * 暂停核心
850
- * 先调用父类逻辑,再传播到子模块
851
- * @returns {Promise<void>}
852
- * @private
853
- * @override
854
- */
855
- Manager.prototype._pauseCore = async function () {
856
- if (this.lifecycle_state !== 'started') {
857
- throw new Error('模块未启动,无法暂停');
858
- }
859
-
860
- this.emit('pause:before');
861
-
862
- try {
863
- var pause_hook = this.getMethod('_pause');
864
- if (pause_hook) {
865
- pause_hook(this);
866
- }
867
-
868
- // 传播到子模块
869
- this._propToChildren('pause');
870
-
871
- this.lifecycle_state = 'paused';
872
- this.emit('pause:success');
873
- } catch (err) {
874
- this.emit('pause:error', err);
875
- throw err;
876
- }
877
- };
878
-
879
- /**
880
- * 恢复核心
881
- * 先调用父类逻辑,再传播到子模块
882
- * @returns {Promise<void>}
883
- * @private
884
- * @override
885
- */
886
- Manager.prototype._resumeCore = async function () {
887
- if (this.lifecycle_state !== 'paused') {
888
- throw new Error('模块未暂停,无法恢复');
889
- }
890
-
891
- this.emit('resume:before');
892
-
893
- try {
894
- var resume_hook = this.getMethod('_resume');
895
- if (resume_hook) {
896
- resume_hook(this);
897
- }
898
-
899
- // 传播到子模块
900
- await this._propToChildren('resume');
901
-
902
- this.lifecycle_state = 'started';
903
- this.emit('resume:success');
904
- } catch (err) {
905
- this.emit('resume:error', err);
906
- throw err;
907
- }
908
- };
909
-
910
- /**
911
- * 结束核心
912
- * 先调用父类逻辑,再传播到子模块
913
- * @returns {Promise<void>}
914
- * @private
915
- * @override
916
- */
917
- Manager.prototype._endCore = async function () {
918
- if (this.lifecycle_state !== 'started' && this.lifecycle_state !== 'paused') {
919
- throw new Error('模块未启动或暂停,无法结束');
920
- }
921
-
922
- this.emit('end:before');
923
-
924
- try {
925
- var end_hook = this.getMethod('_end');
926
- if (end_hook) {
927
- end_hook(this);
928
- }
929
-
930
- // 传播到子模块
931
- this._propToChildren('end');
932
-
933
- // 卸载脚本
934
- this.unloadScript();
935
- this.lifecycle_state = 'ended';
936
- this.emit('end:success');
937
- } catch (err) {
938
- this.emit('end:error', err);
939
- throw err;
940
- }
941
- };
942
-
943
- /**
944
- * 销毁核心
945
- * 先调用父类逻辑,再传播到子模块
946
- * @returns {Promise<void>}
947
- * @private
948
- * @override
949
- */
950
- Manager.prototype._destroyCore = async function () {
951
- if (this.lifecycle_state !== 'ended') {
952
- throw new Error('模块未结束,无法销毁');
953
- }
954
-
955
- this.emit('destroy:before');
956
-
957
- try {
958
- var destroy_hook = this.getMethod('_onDestroy');
959
- if (destroy_hook) {
960
- destroy_hook(this);
961
- }
962
-
963
- // 传播到子模块
964
- this._propToChildren('destroy');
965
-
966
- this._methods = {};
967
- this.lifecycle_state = 'destroyed';
968
- this.emit('destroy:success');
969
- } catch (err) {
970
- this.emit('destroy:error', err);
971
- throw err;
972
- }
973
- };
974
-
975
- /**
976
- * 传播生命周期操作到子模块
977
- * 最多 3 层深度,异常隔离
978
- * @param {string} action 操作名称(start/pause/resume/end/destroy)
979
- * @param {number} [cur_depth] 当前深度
980
- * @returns {Promise<void>}
981
- * @private
982
- */
983
- Manager.prototype._propToChildren = async function (action, cur_depth) {
984
- var depth = cur_depth || 0;
985
-
986
- // 3 层深度限制
987
- if (depth >= 3) {
988
- return;
989
- }
990
-
991
- var method_map = {
992
- start: 'start',
993
- pause: 'pause',
994
- resume: 'resume',
995
- end: 'end',
996
- destroy: 'destroy'
997
- };
998
-
999
- var method_name = method_map[action];
1000
- if (!method_name) {
1001
- return;
1002
- }
1003
-
1004
- for (var name in this._mods) {
1005
- var mod = this._mods[name];
1006
- if (typeof mod[method_name] !== 'function') {
1007
- continue;
1008
- }
1009
-
1010
- try {
1011
- await mod[method_name]();
1012
- } catch {
1013
- // 单个模块异常不影响其他模块
1014
- }
1015
- }
1016
- };
1017
-
1018
- // ==================== 基础API兼容(旧接口) ====================
1019
-
1020
43
  /**
1021
- * 默认驱动类
44
+ * 加载
45
+ * 读取注册数据并初始化
1022
46
  */
1023
- Manager.prototype.Drive = Drive;
1024
-
1025
- /**
1026
- * 创建模块信息对象
1027
- * 兼容旧接口 newInfo(name, sort, state, file)
1028
- * @param {string} name 模块名
1029
- * @param {number} sort 排序值
1030
- * @param {boolean} state 状态
1031
- * @param {string} [file] 文件路径
1032
- * @returns {object} 模块信息对象
1033
- */
1034
- Manager.prototype.newInfo = function (name, sort, state, file) {
1035
- return {
1036
- name: name,
1037
- sort: sort,
1038
- state: state,
1039
- enabled: true,
1040
- file: file || '',
1041
- get available() {
1042
- return this.state == true && this.enabled;
1043
- }
1044
- };
1045
- };
1046
-
1047
- /**
1048
- * 更新模块信息列表
1049
- * 从 _mods 重新构建 _infos
1050
- */
1051
- Manager.prototype.updateInfo = function () {
1052
- this._infos = [];
1053
- for (var name in this._mods) {
1054
- var o = this._mods[name];
1055
- var info = this.newInfo(name, o.config.sort, o.config.state, o.config_file);
1056
- this._infos.push(info);
1057
- }
1058
- this._sort();
47
+ Index.prototype.load = function () {
48
+ $.registry.load();
1059
49
  };
1060
50
 
1061
51
  /**
1062
- * 内部排序
1063
- * 按 sort_key 排序 _infos
1064
- * @private
1065
- */
1066
- Manager.prototype._sort = function () {
1067
- var sort_key = this.config.sort_key || 'sort';
1068
- this._infos.sort((o1, o2) => {
1069
- var p1 = o1[sort_key] || 100;
1070
- var p2 = o2[sort_key] || 100;
1071
- return p1 - p2;
1072
- });
1073
- };
1074
-
1075
- /**
1076
- * 排序
1077
- */
1078
- Manager.prototype.sort = function () {
1079
- this._sort();
1080
- };
1081
-
1082
- /**
1083
- * 获取基础目录
1084
- * @returns {string} 基础目录
1085
- */
1086
- Manager.prototype.getBaseDir = function () {
1087
- return this.config.base_dir || '';
1088
- };
1089
-
1090
- /**
1091
- * 获取模板目录
1092
- * @returns {string} 模板目录
1093
- */
1094
- Manager.prototype.getTplDir = function () {
1095
- return this.config.tpl_dir || '';
1096
- };
1097
-
1098
- /**
1099
- * 获取目录名
1100
- * 前缀为当前类名小写,后缀为配置项名称
1101
- * @returns {string} 目录名
1102
- */
1103
- Manager.prototype.getDirName = function () {
1104
- var prefix = this.constructor.name.toLowerCase();
1105
- var name = this.config.name.toLowerCase();
1106
- return prefix + '_' + name;
1107
- };
1108
-
1109
- // ==================== 模块生命周期管理 ====================
1110
-
1111
- /**
1112
- * 加载模块
1113
- * @param {string} name 模块名
1114
- * @returns {Promise<*>} 加载结果
1115
- */
1116
- Manager.prototype.loadMod = async function (name) {
1117
- var mod = this.getMod(name);
1118
- if (mod) {
1119
- return await mod.load();
1120
- }
1121
- return null;
1122
- };
1123
-
1124
- /**
1125
- * 卸载模块(旧接口 unloadMod -> end)
52
+ * 获取模块实例(懒加载)
1126
53
  * @param {string} name 模块名
1127
- * @returns {Promise<*>} 卸载结果
54
+ * @returns {object|null} 模块实例
1128
55
  */
1129
- Manager.prototype.unloadMod = async function (name) {
1130
- var mod = this.getMod(name);
1131
- if (mod) {
1132
- try {
1133
- if (mod.lifecycle_state === 'started' || mod.lifecycle_state === 'paused') {
1134
- await mod.end();
1135
- }
1136
- } catch {
1137
- // 忽略
1138
- }
1139
- return mod;
1140
- }
1141
- return null;
56
+ Index.prototype.getModule = function (name) {
57
+ return $.registry.getModule(name);
1142
58
  };
1143
59
 
1144
60
  /**
1145
- * 重载模块(旧接口 reloadMod)
1146
- * @param {string} name 模块名
1147
- * @returns {Promise<*>} 重载结果
61
+ * 按类名获取模块实例列表
62
+ * @param {string} class_name 模块类名
63
+ * @returns {Array} 模块实例数组
1148
64
  */
1149
- Manager.prototype.reloadMod = async function (name) {
1150
- var mod = this.getMod(name);
1151
- if (mod) {
1152
- return await mod.reload();
1153
- }
1154
- return null;
1155
- };
1156
-
1157
- /**
1158
- * 注销模块
1159
- * 兼容旧接口 unregisterMod
1160
- * @param {string} name 模块名称
1161
- * @returns {object|null} 注销的模块实例
1162
- */
1163
- Manager.prototype.unregisterMod = function (name) {
1164
- // 先卸载
1165
- this.unloadMod(name);
1166
- // 再删除
1167
- var mod = this.delMod(name);
1168
- this._removeInfo(name);
1169
- return mod;
1170
- };
1171
-
1172
- /**
1173
- * 批量注册模块
1174
- * @param {string[]} files 配置文件路径数组
1175
- * @param {object} [cfg] 配置对象
1176
- * @param {object} [script] 脚本对象
1177
- */
1178
- Manager.prototype.registerMods = function (files, cfg, script) {
1179
- if (!files || !Array.isArray(files)) {
1180
- return;
1181
- }
1182
- for (var i = 0; i < files.length; i++) {
1183
- this.registerMod(files[i], cfg, script);
1184
- }
1185
- };
1186
-
1187
- /**
1188
- * 加载所有模块的脚本
1189
- */
1190
- Manager.prototype.loadScripts = async function () {
1191
- var promises = [];
1192
- for (var name in this._mods) {
1193
- var mod = this._mods[name];
1194
- if (typeof mod.loadScript === 'function') {
1195
- promises.push(mod.loadScript());
1196
- }
1197
- }
1198
- await Promise.all(promises);
1199
- };
1200
-
1201
- /**
1202
- * 加载所有模块
1203
- */
1204
- Manager.prototype.loadMods = async function () {
1205
- var promises = [];
1206
- for (var name in this._mods) {
1207
- var mod = this._mods[name];
1208
- promises.push(mod.load());
1209
- }
1210
- await Promise.all(promises);
1211
- };
1212
-
1213
- /**
1214
- * 构建文件集合
1215
- * @param {object} dirs 目录到模块条目的映射
1216
- * @returns {object} 文件集合 { file: true }
1217
- * @private
1218
- */
1219
- Manager.prototype._buildSet = function (dirs) {
1220
- var set = {};
1221
- for (var dir in dirs) {
1222
- var entries = dirs[dir];
1223
- for (var i = 0; i < entries.length; i++) {
1224
- set[entries[i].file] = true;
1225
- }
1226
- }
1227
- return set;
1228
- };
1229
-
1230
- /**
1231
- * 构建配置映射
1232
- * @returns {object} 文件到配置的映射
1233
- * @private
1234
- */
1235
- Manager.prototype._buildConfigMap = function () {
1236
- var map = {};
1237
- for (var name in this._mods) {
1238
- var mod = this._mods[name];
1239
- if (mod.config_file) {
1240
- map[mod.config_file] = mod.config;
1241
- }
1242
- }
1243
- return map;
1244
- };
1245
-
1246
- /**
1247
- * 构建模块条目列表
1248
- * @param {string[]} files 文件路径数组
1249
- * @param {object} config_dict 文件到配置的映射
1250
- * @returns {Array<{file: string, config: object}>} 模块条目数组
1251
- * @private
1252
- */
1253
- Manager.prototype._buildEntries = function (files, config_dict) {
1254
- var entries = [];
1255
- for (var i = 0; i < files.length; i++) {
1256
- var f = files[i];
1257
- var config = config_dict[f];
1258
- if (config) {
1259
- entries.push({ file: f, config: config });
1260
- }
1261
- }
1262
- return entries;
1263
- };
1264
-
1265
- /**
1266
- * 更新前的钩子
1267
- */
1268
- Manager.prototype.updateBefore = function () {
1269
- // 空实现,子类可重写
1270
- };
1271
-
1272
- /**
1273
- * 更新后的钩子
1274
- */
1275
- Manager.prototype.updateAfter = function () {
1276
- // 空实现,子类可重写
1277
- };
1278
-
1279
- /**
1280
- * 更新配置
1281
- * @param {string} dir 检索的目录
1282
- * @param {boolean} [clear] 是否清除缓存
1283
- */
1284
- Manager.prototype.update = async function (dir, clear) {
1285
- var do_clear = clear !== false;
1286
- if (do_clear) {
1287
- this.clearMods();
1288
- }
1289
-
1290
- var search_dir = dir || this.dir;
1291
- if (!search_dir) {
1292
- return;
1293
- }
1294
-
1295
- // 查找所有 json 文件
1296
- var { DirScanner } = require('./dir_scanner');
1297
- var scanner = new DirScanner();
1298
- var entries = scanner.scanAndParse(search_dir, '*.json');
1299
-
1300
- for (var i = 0; i < entries.length; i++) {
1301
- var entry = entries[i];
1302
- if (entry.config && entry.config.name) {
1303
- this.registerMod(entry.file, entry.config);
1304
- }
1305
- }
1306
-
1307
- this.updateInfo();
1308
- if (!this.config.lazy_load) {
1309
- await this.loadScripts();
1310
- }
1311
- this.is_loaded = true;
1312
- };
1313
-
1314
- // ==================== 执行方法 ====================
1315
-
1316
- /**
1317
- * 执行模块方法
1318
- * @param {object} mod 模块对象
1319
- * @param {string} method 方法名称
1320
- * @param {...any} params 参数列表
1321
- * @returns {Promise<*>} 执行结果
1322
- * @private
1323
- */
1324
- Manager.prototype._exec = async function (mod, method) {
1325
- var params = Array.prototype.slice.call(arguments, 2);
1326
- if (mod[method]) {
1327
- return await mod[method].apply(mod, params);
1328
- } else {
1329
- throw new Error('方法' + method + '不存在');
1330
- }
1331
- };
1332
-
1333
- /**
1334
- * 执行模块方法
1335
- * @param {string} name 模块名
1336
- * @param {string} method 方法名称
1337
- * @param {...any} params 参数列表
1338
- * @returns {Promise<*>} 执行结果
1339
- */
1340
- Manager.prototype.exec = async function (name, method) {
1341
- var params = Array.prototype.slice.call(arguments, 2);
1342
- try {
1343
- var mod = this.getMod(name);
1344
- if (!mod) {
1345
- throw new Error('模块' + name + '不存在');
1346
- }
1347
- return await this._exec.apply(this, [mod, method].concat(params));
1348
- } catch (error) {
1349
- this.log('error', method + '方法执行失败!', error);
1350
- return null;
1351
- }
1352
- };
1353
-
1354
- /**
1355
- * 异步触发事件,按顺序执行等待完成
1356
- * @param {string} method 方法名称
1357
- * @param {...any} params 事件参数
1358
- * @returns {Promise<*>} 事件触发结果
1359
- */
1360
- Manager.prototype.runWait = async function (method) {
1361
- if (typeof method !== 'string') {
1362
- throw new TypeError('方法名称必须是字符串');
1363
- }
1364
- var params = Array.prototype.slice.call(arguments, 1);
1365
- var result;
1366
- var infos = this.getInfos();
1367
-
1368
- for (var i = 0; i < infos.length; i++) {
1369
- var info = infos[i];
1370
- var mod = this.getMod(info.name);
1371
- if (!mod) {
1372
- continue;
1373
- }
1374
- if (!mod.isLoaded()) {
1375
- try {
1376
- await mod.call('loadScript');
1377
- } catch (error) {
1378
- this.log('error', '模块' + info.name + '加载失败', error);
1379
- continue;
1380
- }
1381
- }
1382
- try {
1383
- var ret = await mod.call.apply(mod, [method].concat(params));
1384
- if (ret !== null && ret !== undefined) {
1385
- result = ret;
1386
- }
1387
- } catch (error) {
1388
- this.log('error', '模块' + info.name + '执行' + method + '方法失败', error);
1389
- }
1390
- }
1391
-
1392
- return result;
1393
- };
1394
-
1395
- /**
1396
- * 异步触发事件,并发执行不等待
1397
- * @param {string} method 方法名称
1398
- * @param {...any} params 事件参数
1399
- * @returns {boolean} 是否成功触发事件
1400
- */
1401
- Manager.prototype.runAsync = async function (method) {
1402
- if (typeof method !== 'string') {
1403
- throw new TypeError('方法名称必须是字符串');
1404
- }
1405
- var params = Array.prototype.slice.call(arguments, 1);
1406
- var infos = this.getInfos();
1407
-
1408
- for (var i = 0; i < infos.length; i++) {
1409
- var info = infos[i];
1410
- var mod = this.getMod(info.name);
1411
- try {
1412
- mod.call.apply(mod, [method].concat(params));
1413
- } catch (error) {
1414
- this.log('error', '模块' + info.name + '执行' + method + '方法失败', error);
1415
- }
1416
- }
1417
-
1418
- return true;
1419
- };
1420
-
1421
- /**
1422
- * 异步触发事件,并发执行等待完成
1423
- * @param {string} method 方法名称
1424
- * @param {...any} params 事件参数
1425
- * @returns {Promise<Array>} 事件触发结果数组
1426
- */
1427
- Manager.prototype.runAll = async function (method) {
1428
- if (typeof method !== 'string') {
1429
- throw new TypeError('方法名称必须是字符串');
1430
- }
1431
- var params = Array.prototype.slice.call(arguments, 1);
1432
- var promises = [];
1433
- var infos = this.getInfos();
1434
-
1435
- for (var i = 0; i < infos.length; i++) {
1436
- var info = infos[i];
1437
- var mod = this.getMod(info.name);
1438
- promises.push(
1439
- mod.call.apply(mod, [method].concat(params)).catch(() => {
1440
- return null;
1441
- })
1442
- );
1443
- }
1444
-
1445
- return await Promise.all(promises);
1446
- };
1447
-
1448
- /**
1449
- * 异步触发事件,竞争执行
1450
- * @param {string} method 方法名称
1451
- * @param {...any} params 事件参数
1452
- * @returns {Promise<*>} 第一个完成的结果
1453
- */
1454
- Manager.prototype.runRace = async function (method) {
1455
- if (typeof method !== 'string') {
1456
- throw new TypeError('方法名称必须是字符串');
1457
- }
1458
- var params = Array.prototype.slice.call(arguments, 1);
1459
- var promises = [];
1460
- var infos = this.getInfos();
1461
-
1462
- for (var i = 0; i < infos.length; i++) {
1463
- var info = infos[i];
1464
- var mod = this.getMod(info.name);
1465
- promises.push(
1466
- mod.call.apply(mod, [method].concat(params))
1467
- );
1468
- }
1469
-
1470
- return await Promise.race(promises);
1471
- };
1472
-
1473
- /**
1474
- * 异步触发事件,瀑布流执行
1475
- * @param {string} method 方法名称
1476
- * @param {*} result 初始值
1477
- * @param {...any} params 事件参数
1478
- * @returns {Promise<*>} 最后一个事件监听者的结果
1479
- */
1480
- Manager.prototype.runWaterfall = async function (method, result) {
1481
- if (typeof method !== 'string') {
1482
- throw new TypeError('方法名称必须是字符串');
1483
- }
1484
- var params = Array.prototype.slice.call(arguments, 2);
1485
- var infos = this.getInfos();
1486
- var final_result = result;
1487
-
1488
- for (var i = 0; i < infos.length; i++) {
1489
- var info = infos[i];
1490
- var mod = this.getMod(info.name);
1491
- if (!mod) {
1492
- continue;
1493
- }
1494
- try {
1495
- var ret = await mod.call.apply(mod, [method, final_result].concat(params));
1496
- if (ret !== null && ret !== undefined) {
1497
- final_result = ret;
1498
- }
1499
- } catch (error) {
1500
- this.log('error', '模块' + info.name + '执行' + method + '方法失败', error);
1501
- }
1502
- }
1503
-
1504
- return final_result;
1505
- };
1506
-
1507
- /**
1508
- * 移除事件监听
1509
- * @param {string} event 事件名
1510
- */
1511
- Manager.prototype.offEvent = function (event) {
1512
- var eventer = this.getEventer();
1513
- if (eventer && eventer.off) {
1514
- eventer.off(event);
1515
- }
65
+ Index.prototype.getModules = function (class_name) {
66
+ return $.registry.getModules(class_name);
1516
67
  };
1517
68
 
1518
69
  module.exports = {
1519
- Manager,
70
+ Index,
71
+ Mod,
1520
72
  Drive,
1521
- // eslint-disable-next-line mm_eslint/variable-name
1522
- Mod: require('./mod').Mod,
1523
- // 向后兼容
1524
- Index: Manager,
1525
- Item: Drive
1526
- };
73
+ Scanner,
74
+ Registry,
75
+ Manager
76
+ };