mm_machine 3.6.0 → 5.0.0

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/README.md CHANGED
@@ -496,7 +496,11 @@ mm_machine 模块系统基于以下核心设计理念:
496
496
 
497
497
  #### 目录监听与热重载
498
498
 
499
- `update(dir)` 完成后会对检索目录开启一次递归监听(底层为 mm_scanner,同一实例同时扫描配置文件与 `.js` 脚本,变更按扩展名分流):
499
+ `update(dir)` 完成后会对检索目录开启一次递归监听(经 mm_loader 的 `Loader.watch`,配置文件与 `.js` 脚本的变更按扩展名分流):
500
+
501
+ - 所有管理器默认共享 mm_loader 的同一个加载器实例(`loadAdmin(config.use_scope || 'os')`),避免重复扫描、重复监听与重复加载
502
+ - 管理器把自己的清单文件名登记为加载器类型:类型键为文件名去掉 `.json` 后缀(`manager.json` → `manager`),已存在的类型不覆盖
503
+ - 需要独立加载器时,用 `use_scope` 指定另一共享作用域(按 `scope@目录` 派生独立实例)
500
504
 
501
505
  | 变更 | 模式要求 | 行为 |
502
506
  | --- | --- | --- |
@@ -504,10 +508,11 @@ mm_machine 模块系统基于以下核心设计理念:
504
508
  | 配置文件修改 | `mode >= 2`(热更新配置) | 同步配置快照并应用到模块(触发 `_onConfigChange` 钩子与 `config:change` 事件),`main` 指向变化时重载脚本 |
505
509
  | 配置文件删除 | 任意 | 注销模块(停止 → 卸载 → 移除记录) |
506
510
  | 配置文件修改 | `mode < 2` | 注销后重新注册模块 |
507
- | 脚本文件删除 | `mode = 3 / 4`(热重载脚本) | 注销该脚本所属模块,脚本已无法运行 |
508
- | 脚本新增/重建 | `mode = 3 / 4` | 同目录存在配置文件时补注册,非懒加载时立即加载 |
509
- | 脚本内容修改 | `mode = 3 / 4` | 管理器重载脚本(清 require 缓存后重新加载并重挂方法) |
511
+ | 脚本文件删除 | `mode = 3 / 4`(热重载脚本) | 是受管模块的入口:注销模块并失效自身 require 缓存;非入口:仅失效自身 require 缓存 |
512
+ | 脚本新增/重建 | `mode = 3 / 4` | 同目录存在同名配置文件时补注册,非懒加载时立即加载 |
513
+ | 脚本内容修改 | `mode = 3 / 4` | 是受管模块的入口:管理器重载脚本(清 require 缓存后重新加载并重挂方法);非入口:仅失效自身 require 缓存 |
510
514
 
515
+ - 脚本变更按**入口精确匹配**:只有变更文件是某个受管模块的入口脚本才触发重载/注销;公共脚本(com/lib 等)变化只失效自身的 require 缓存,不追溯引用方,引用方下次加载即拿到新代码
511
516
  - 脚本事件只在热重载模式(`MODE.HOT_RELOAD` / `MODE.HOT_BOTH`)下纳入监听,生产与仅热更新配置模式不扫描脚本,避免无谓开销
512
517
  - 热更新不依赖 `mm_hot_reload`:配置与脚本的变化均由管理器的目录监听(mm_loader)统一接管;`mm_hot_reload` 仅供函数自行应用其他模块时选用
513
518
  - 调用 `unwatch()` 可关闭全部目录监听
@@ -571,6 +576,22 @@ mm_machine 模块系统基于以下核心设计理念:
571
576
 
572
577
  ## 更新日志
573
578
 
579
+ ### v4.1.0
580
+
581
+ - 配置加载器改为共享:`_getLoader()` 默认取 mm_loader 实例池中的同一个 `Loader`(`loadAdmin(config.use_scope || 'os')`),不再为每个管理器各建实例
582
+ - 清单类型按文件名推导登记:`manager.json` → `manager`,通过 `addType` 幂等注册进共享实例,已存在的类型不覆盖
583
+ - `_getLoader()` 直接取 mm_loader 实例池中的 `Loader`,不再自行缓存引用;需要独立实例时用 `config.use_scope` 指定另一共享作用域
584
+ - `_watchDir` 保存回调引用,`unwatch` 按回调从共享实例上摘除,不影响其他调用方的监听
585
+ - `_findFiles` 改用 `Loader.scan`(物理扫描唯一入口),保证 `update` 能看到新增/删除的文件
586
+ - 依赖 mm_loader ^3.0.0
587
+
588
+ ### v4.0.0
589
+
590
+ - 热更新收敛到管理器:mm_loader 移除脚本变更总线与缓存树工具(`subscribeScriptChanges` / `findImporters` / `clearScriptTree` 等),管理器直接监听 `Loader.watch` 的脚本回调
591
+ - 脚本变更改为入口精确匹配:只有变更文件是受管模块入口才触发重载/注销,公共脚本变化仅失效自身 require 缓存
592
+ - `_watchDir` 复用同一个 Loader:配置回调与脚本回调一次 watch 分流,删除独立的脚本订阅路径
593
+ - 依赖 mm_loader ^2.0.0
594
+
574
595
  ### v3.6.0
575
596
 
576
597
  - 移除对 `mm_hot_reload` 的依赖:配置与脚本热更新全部由管理器目录监听(mm_loader)接管,`mm_hot_reload` 回归为函数自行应用其他模块时的可选工具
@@ -598,7 +619,7 @@ mm_machine 模块系统基于以下核心设计理念:
598
619
 
599
620
  - mm_config: ^2.5.3
600
621
  - mm_helper: ^1.0.3
601
- - mm_loader: ^1.4.0(目录监听与配置/脚本热更新)
622
+ - mm_loader: ^3.0.0(目录监听与配置/脚本热更新)
602
623
  - mm_mod: ^1.0.6
603
624
  - mm_tpl: ^2.7.3
604
625
 
package/index.js CHANGED
@@ -1,7 +1,7 @@
1
- const { Mod, addModMethods } = require('./lib/mod.js');
1
+ const { Mod, addMethods } = require('./lib/mod.js');
2
2
  const { Drive, MODE } = require('./lib/drive.js');
3
3
  const Manager = require('./lib/manager.js');
4
4
 
5
5
  module.exports = {
6
- Mod, Drive, Manager, MODE, addModMethods
6
+ Mod, Drive, Manager, MODE, addMethods
7
7
  };
package/lib/drive.js CHANGED
@@ -359,12 +359,10 @@ Drive.prototype._remove = function () {
359
359
  if (!file) return;
360
360
 
361
361
  try {
362
- // 移除模块缓存,重新加载时会读取最新脚本
362
+ // 先 resolve:文件不存在时保留原有的报错语义,且不抛出
363
363
  let file_name = require.resolve(file);
364
- if (require.cache[file_name]) {
365
- require.cache[file_name] = null;
366
- delete require.cache[file_name];
367
- }
364
+ // 失效入口自身的 require 缓存,重新加载时读到新代码
365
+ delete require.cache[file_name];
368
366
  } catch (err) {
369
367
  this.log('error', `移除加载的脚本模块失败`, err);
370
368
  }
package/lib/manager.js CHANGED
@@ -1,9 +1,35 @@
1
1
  const path = require('path');
2
2
  const { Manager: Core } = require('mm_mod');
3
3
  const { hasDir, hasFile, fullname, basename, dirname, string } = require('mm_helper');
4
- const { Loader } = require('mm_loader');
5
- const { Mod, addModMethods } = require('./mod.js');
4
+ const { loadAdmin } = require('mm_loader');
5
+ const { Mod, addMethods } = require('./mod.js');
6
6
  const { Drive, MODE } = require('./drive.js');
7
+ const { resolveScriptFile, reloadScript } = require('./script_protocol.js');
8
+
9
+ /**
10
+ * 归一化文件路径为可比较键(绝对路径 + 小写)
11
+ * @param {string} file 文件路径
12
+ * @returns {string} 可比较键
13
+ * @private
14
+ */
15
+ function _normPath(file) {
16
+ return path.resolve(String(file)).toLowerCase();
17
+ }
18
+
19
+ /**
20
+ * 失效单个脚本文件的 require 缓存
21
+ * @description 文件不存在或从未加载时静默跳过
22
+ * @param {string} file 脚本文件路径
23
+ * @returns {void}
24
+ * @private
25
+ */
26
+ function _clearScriptCache(file) {
27
+ try {
28
+ delete require.cache[require.resolve(file)];
29
+ } catch {
30
+ // 无法解析的模块本就不在缓存中
31
+ }
32
+ }
7
33
 
8
34
  /**
9
35
  * 管理器类
@@ -80,6 +106,11 @@ class Manager extends Core {
80
106
  * @type {string}
81
107
  */
82
108
  scope: 'server',
109
+ /**
110
+ * 共享实例作用域,取用其他模块 xxxAdmin 实例时使用(loadAdmin 等),缺省 'os'
111
+ * @type {string}
112
+ */
113
+ use_scope: '',
83
114
  /**
84
115
  * 忽略目录数组
85
116
  * @type {Array}
@@ -192,22 +223,30 @@ Manager.prototype.getTplDir = function () {
192
223
 
193
224
  /**
194
225
  * 获取配置加载器
195
- * @param {boolean} [watch_scripts] 是否把脚本文件纳入目录监听
226
+ * @description 直接取 mm_loader 实例池中的共享 Loader(键为 use_scope@目录,缺省 'os'),
227
+ * 同目录同作用域天然是同一个实例,本管理器不再另存一份引用;
228
+ * 一个加载器只负责一个目录,不同目录由实例池各自派生;
229
+ * use_scope 一并写入加载器配置,使加载器下传的扫描器与监听器落在同一作用域。
230
+ * 并把本管理器清单类型登记进该实例:类型键为 filename 去掉 .json 后缀
231
+ * (manager.json → manager,与默认 app → app.json 同构),已存在的类型不覆盖;
232
+ * 脚本监听由 _watchDir 是否传 script_callback 决定(回调驱动),不再配置实例
233
+ * @param {string} [dir] 检索目录,缺省回退 config.dir
196
234
  * @returns {Loader} 配置加载器
197
235
  * @private
198
236
  */
199
- Manager.prototype._getLoader = function (watch_scripts = false) {
200
- return new Loader({
201
- resources: {
202
- mod: {
203
- ext: this.config.filename,
204
- hot: false
205
- }
206
- },
207
- ignores: this.config.ignore,
208
- // 只有目录监听且处于热重载模式时才扫描脚本,其余场景保持只扫配置文件
209
- scripts: { hot: !!watch_scripts }
210
- });
237
+ Manager.prototype._getLoader = function (dir) {
238
+ const scope = this.config.use_scope || 'os';
239
+ const target = dir || this.config.dir || '';
240
+ const key = target ? path.resolve(target) : '';
241
+ const loader = loadAdmin(scope, { dir: key, use_scope: scope });
242
+ const filename = this.config.filename;
243
+ if (filename) {
244
+ const type = filename.replace(/\.json$/i, '');
245
+ if (type && !loader.config.resources[type]) {
246
+ loader.addType(type, filename, false);
247
+ }
248
+ }
249
+ return loader;
211
250
  };
212
251
 
213
252
  /**
@@ -518,7 +557,7 @@ Manager.prototype.update = async function (dir, clear = true) {
518
557
  }
519
558
 
520
559
  await this.updateAfter(search_dir);
521
- // 检索目录开启监听,配置文件变化后增量维护模块
560
+ // 检索目录开启监听:配置文件变化增量维护模块,脚本变化重载归属驱动(热重载模式)
522
561
  this._watchDir(search_dir);
523
562
  } catch (err) {
524
563
  this.log('error', '更新配置失败', err);
@@ -539,7 +578,9 @@ Manager.prototype._findFiles = async function (dir) {
539
578
  if (!hasDir(dir)) {
540
579
  return [];
541
580
  }
542
- let files = this._getLoader().search(dir);
581
+ // scan 是物理扫描唯一入口:每次都拿最新清单(mm_scanner 缓存无变化时不重复遍历),
582
+ // update 语义要求看到新增/删除的文件
583
+ let files = this._getLoader(dir).scan();
543
584
  let filename = this.config.filename;
544
585
  if (!filename) {
545
586
  return files;
@@ -550,28 +591,30 @@ Manager.prototype._findFiles = async function (dir) {
550
591
  // ==== 目录监听 ====
551
592
  /**
552
593
  * 监听目录中配置文件与脚本文件的变化
553
- * @description 只扫描一次,之后由文件事件增量维护模块;脚本事件仅在热重载模式下响应
594
+ * @description 只扫描一次,之后由文件事件增量维护模块:配置变更走 _applyChanges,
595
+ * 脚本变更走 _applyScriptChanges(仅热重载模式订阅)。
596
+ * 监听由 mm_loader 提供,底层 Scanner 按目录共享句柄并自带防抖,
597
+ * 多个管理器监听同一目录不会重复挂句柄
554
598
  * @param {string} dir 目录路径
555
599
  * @private
556
600
  */
557
601
  Manager.prototype._watchDir = function (dir) {
558
602
  if (!dir || this._dir_watchers.has(dir)) return;
559
603
  if (!hasDir(dir)) return;
560
- let script_hot = this._isScriptHot();
561
- let loader = this._getLoader(script_hot);
562
- let success = loader.watch(
563
- dir,
564
- (changes) => {
565
- this._applyChanges(changes);
566
- },
567
- script_hot
568
- ? (changes) => {
569
- this._applyScriptChanges(changes);
570
- }
571
- : undefined
572
- );
604
+ let hot = this._isScriptHot();
605
+ let loader = this._getLoader(dir);
606
+ let config_callback = (changes) => {
607
+ this._applyChanges(changes);
608
+ };
609
+ let script_callback = hot
610
+ ? (changes) => {
611
+ this._applyScriptChanges(changes);
612
+ }
613
+ : undefined;
614
+ let success = loader.watch(config_callback, script_callback);
573
615
  if (success) {
574
- this._dir_watchers.set(dir, loader);
616
+ // 保存回调引用:unwatch 时只摘本管理器的监听,不影响共享实例上其他调用方
617
+ this._dir_watchers.set(dir, { loader, config_callback, script_callback });
575
618
  }
576
619
  };
577
620
 
@@ -663,15 +706,18 @@ Manager.prototype._applyScriptChanges = function (changes) {
663
706
 
664
707
  /**
665
708
  * 按变更列表增量维护脚本所属模块
666
- * @description 脚本删除时注销模块(脚本已无法运行),脚本重建或新增时按同目录配置文件补注册;
667
- * 脚本内容变化时重载脚本(清缓存后重新 require 并重挂方法)
709
+ * @description 脚本删除时注销模块;脚本内容变化时按「入口精确匹配」重载:
710
+ * 变更文件就是某个受管模块的入口脚本才重载该模块,其余文件
711
+ * (com/lib 等公共脚本)只失效自身缓存,不追溯引用方。
712
+ * 入口形态与重载协议见 script_protocol.js
668
713
  * @param {object[]} changes 变更列表,每项含 type 与 file
669
- * @returns {Promise<void>} 无返回值
714
+ * @returns {Promise<number>} 本次重载的驱动数量
670
715
  * @private
671
716
  */
672
717
  Manager.prototype._applyScriptChangesAsync = async function (changes) {
673
- if (!this._isScriptHot()) return;
718
+ if (!this._isScriptHot()) return 0;
674
719
  let lazy = this.config.lazy_load;
720
+ let hits = 0;
675
721
 
676
722
  for (let change of changes) {
677
723
  try {
@@ -682,18 +728,24 @@ Manager.prototype._applyScriptChangesAsync = async function (changes) {
682
728
  this.log('warn', `脚本已删除,注销模块 ${info.name}: ${change.file}`);
683
729
  await this.unregMod(info.name);
684
730
  }
731
+ // 文件已删,缓存里的旧模块也要失效,避免下次 require 命中幽灵代码
732
+ _clearScriptCache(change.file);
685
733
  continue;
686
734
  }
687
735
 
688
- // 已注册模块的脚本内容变化:重载脚本并重挂方法
736
+ // 入口精确命中:重载该模块并更新存储的 mod 与 config
689
737
  if (info) {
690
738
  let mod = this.getMod(info.name);
691
- if (mod && typeof mod.reloadScript === 'function') {
692
- mod.reloadScript();
739
+ if (mod) {
740
+ reloadScript(mod, resolveScriptFile(mod));
741
+ hits += 1;
693
742
  }
694
743
  continue;
695
744
  }
696
745
 
746
+ // 非入口文件(公共脚本等):只失效自身缓存
747
+ _clearScriptCache(change.file);
748
+
697
749
  // 脚本重建或新增:同目录存在配置文件时补注册
698
750
  let config_file = this._getConfigByScript(change.file);
699
751
  if (!config_file) continue;
@@ -707,6 +759,7 @@ Manager.prototype._applyScriptChangesAsync = async function (changes) {
707
759
  }
708
760
 
709
761
  this._sort();
762
+ return hits;
710
763
  };
711
764
 
712
765
  /**
@@ -716,10 +769,11 @@ Manager.prototype._applyScriptChangesAsync = async function (changes) {
716
769
  * @private
717
770
  */
718
771
  Manager.prototype._getInfoByScript = function (file) {
719
- let target = path.resolve(file);
772
+ let target = _normPath(file);
720
773
  for (let info of this.configs) {
721
774
  let mod = this.getMod(info.name);
722
- if (mod && mod.script_file && path.resolve(mod.script_file) === target) {
775
+ let entry = mod ? resolveScriptFile(mod) : '';
776
+ if (entry && _normPath(entry) === target) {
723
777
  return info;
724
778
  }
725
779
  }
@@ -742,12 +796,13 @@ Manager.prototype._getConfigByScript = function (file) {
742
796
  };
743
797
 
744
798
  /**
745
- * 关闭全部目录监听
799
+ * 关闭本管理器的全部目录监听
800
+ * @description 按保存的回调引用从共享 Loader 上摘除,不影响其他调用方的监听
746
801
  * @returns {void}
747
802
  */
748
803
  Manager.prototype.unwatch = function () {
749
- for (let loader of this._dir_watchers.values()) {
750
- loader.unwatch();
804
+ for (let [dir, entry] of this._dir_watchers) {
805
+ entry.loader.unwatch(entry.config_callback, entry.script_callback);
751
806
  }
752
807
  this._dir_watchers.clear();
753
808
  };
@@ -1313,6 +1368,6 @@ Manager.prototype._logModError = function (name, method, error) {
1313
1368
  * 复用模块类的调度与生命周期能力
1314
1369
  * @description Manager 继承 mm_mod.Manager,需要将 mm_machine 的 Mod 原型成员复制到 Manager 原型
1315
1370
  */
1316
- addModMethods(Manager);
1371
+ addMethods(Manager);
1317
1372
 
1318
1373
  module.exports = Manager;
package/lib/mod.js CHANGED
@@ -1049,7 +1049,7 @@ Mod.prototype.getDir = function () {
1049
1049
  * @param {Function} cs 目标类
1050
1050
  * @returns {Function} 目标类
1051
1051
  */
1052
- function addModMethods(cs) {
1052
+ function addMethods(cs) {
1053
1053
  if (typeof cs !== 'function') {
1054
1054
  throw new TypeError('参数(cs)必须是类');
1055
1055
  }
@@ -1064,5 +1064,5 @@ function addModMethods(cs) {
1064
1064
 
1065
1065
  module.exports = {
1066
1066
  Mod,
1067
- addModMethods
1067
+ addMethods
1068
1068
  };
@@ -0,0 +1,150 @@
1
+ 'use strict';
2
+
3
+ /**
4
+ * 驱动脚本入口解析与重载协议
5
+ *
6
+ * @description mm_machine 的受管驱动有两套形态:
7
+ * - Drive 系(Drive / App / Plugin / Cmd):script_file、reloadScript()
8
+ * - Mod 系脚本驱动(Api / Event / Service / Pendant):_getScriptFile()、
9
+ * load() 把脚本方法挂到实例 this.main 上
10
+ * 管理器判断「某个脚本属于哪个驱动」以及「如何让它生效」时走本模块,
11
+ * 新增一种驱动类型只需注册适配器,不必修改管理器或宿主。
12
+ */
13
+
14
+ const path = require('path');
15
+
16
+ /**
17
+ * 入口解析器:从驱动实例推导入口脚本路径,取不到返回空串
18
+ * @type {Array<function(object): string>}
19
+ */
20
+ const ENTRY_RESOLVERS = [
21
+ (drive) => drive.file || '',
22
+ (drive) => drive.script_file || '',
23
+ (drive) => {
24
+ if (typeof drive._getScriptFile !== 'function') return '';
25
+ try {
26
+ return drive._getScriptFile() || '';
27
+ } catch {
28
+ return '';
29
+ }
30
+ },
31
+ // Pendant 等驱动 getDir() 返回空串,目录只保存在 config.dir;
32
+ // 直接用 getDir() 会把入口误解析到进程 cwd 下的同名文件
33
+ (drive) => {
34
+ const main = drive.config && drive.config.main;
35
+ if (!main) return '';
36
+ let dir = (drive.config && drive.config.dir) || '';
37
+ if (!dir && typeof drive.getDir === 'function') {
38
+ try {
39
+ dir = drive.getDir() || '';
40
+ } catch {
41
+ return '';
42
+ }
43
+ }
44
+ return dir ? path.resolve(dir, main) : '';
45
+ }
46
+ ];
47
+
48
+ /**
49
+ * 重载器:命中条件 + 执行动作,按注册顺序取第一个匹配
50
+ * @type {Array<{test: function(object): boolean, run: function(object): *}>}
51
+ */
52
+ const RELOADERS = [
53
+ { test: (d) => typeof d.reloadScript === 'function', run: (d) => d.reloadScript() },
54
+ // 普通 Mod 的 load 是生命周期方法,额外要求 _setMainMethod 避免误触
55
+ {
56
+ test: (d) => typeof d._setMainMethod === 'function' && typeof d.load === 'function',
57
+ run: (d) => d.load()
58
+ }
59
+ ];
60
+
61
+ const DEFAULT_ENTRY_RESOLVERS = [...ENTRY_RESOLVERS];
62
+ const DEFAULT_RELOADERS = [...RELOADERS];
63
+
64
+ /**
65
+ * 注册入口解析器(扩展点)
66
+ * @param {function(object): string} resolver 返回入口路径或空串
67
+ * @param {boolean} [first=false] 插到队首优先匹配
68
+ * @returns {boolean} 注册成功返回 true
69
+ */
70
+ function registerEntryResolver(resolver, first = false) {
71
+ if (typeof resolver !== 'function') return false;
72
+ if (first) ENTRY_RESOLVERS.unshift(resolver);
73
+ else ENTRY_RESOLVERS.push(resolver);
74
+ return true;
75
+ }
76
+
77
+ /**
78
+ * 注册重载器(扩展点)
79
+ * @param {function(object): boolean} test 是否适用于该驱动
80
+ * @param {function(object): *} run 执行重载
81
+ * @param {boolean} [first=false] 插到队首优先匹配
82
+ * @returns {boolean} 注册成功返回 true
83
+ */
84
+ function registerReloader(test, run, first = false) {
85
+ if (typeof test !== 'function' || typeof run !== 'function') return false;
86
+ const item = { test, run };
87
+ if (first) RELOADERS.unshift(item);
88
+ else RELOADERS.push(item);
89
+ return true;
90
+ }
91
+
92
+ /**
93
+ * 恢复默认适配器
94
+ * @returns {void}
95
+ */
96
+ function resetAdapters() {
97
+ ENTRY_RESOLVERS.splice(0, ENTRY_RESOLVERS.length, ...DEFAULT_ENTRY_RESOLVERS);
98
+ RELOADERS.splice(0, RELOADERS.length, ...DEFAULT_RELOADERS);
99
+ }
100
+
101
+ /**
102
+ * 取驱动入口脚本的绝对路径
103
+ * @param {object} drive 驱动实例
104
+ * @returns {string} 绝对路径,取不到返回空串
105
+ */
106
+ function resolveScriptFile(drive) {
107
+ if (!drive) return '';
108
+ for (const resolve of ENTRY_RESOLVERS) {
109
+ let file = '';
110
+ try {
111
+ file = resolve(drive) || '';
112
+ } catch {
113
+ file = '';
114
+ }
115
+ if (file) return path.resolve(file);
116
+ }
117
+ return '';
118
+ }
119
+
120
+ /**
121
+ * 重载驱动脚本
122
+ * @description 失效入口自身的 require 缓存后重新加载;只清 require.cache 不够,
123
+ * Mod 系驱动把方法挂在实例上,必须重新 load 才能换掉旧函数引用
124
+ * @param {object} drive 驱动实例
125
+ * @param {string} file 入口绝对路径
126
+ * @returns {*} 驱动重载结果
127
+ */
128
+ function reloadScript(drive, file) {
129
+ try {
130
+ delete require.cache[require.resolve(file)];
131
+ } catch {
132
+ // 缓存清理失败不阻断重载,驱动自身仍会重新 require
133
+ }
134
+ for (const item of RELOADERS) {
135
+ try {
136
+ if (item.test(drive)) return item.run(drive);
137
+ } catch {
138
+ return null;
139
+ }
140
+ }
141
+ return null;
142
+ }
143
+
144
+ module.exports = {
145
+ resolveScriptFile,
146
+ reloadScript,
147
+ registerEntryResolver,
148
+ registerReloader,
149
+ resetAdapters
150
+ };
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "mm_machine",
3
- "version": "3.6.0",
3
+ "version": "5.0.0",
4
4
  "description": "A flexible Node.js plugin mechanism system for dynamic loading, management and execution of modules. Supports hot reload, lifecycle management, and modern JavaScript features.",
5
5
  "main": "index.js",
6
6
  "scripts": {
@@ -42,7 +42,7 @@
42
42
  "@prettier/sync": "^0.6.1",
43
43
  "mm_config": "^2.5.3",
44
44
  "mm_helper": "^1.0.3",
45
- "mm_loader": "^1.4.0",
45
+ "mm_loader": "^4.0.0",
46
46
  "mm_mod": "^1.0.6",
47
47
  "mm_tpl": "^2.7.3"
48
48
  },