DependencyManager

函数签名

typescript

function DependencyManager() { ... }

点击查看源码

jsts

/**
 * 将值或值数组转换为数组。
 *
 * @type {<T>(value: T | T[]) => T[]}
 * @param {T | T[]} value - 要转换的值或值数组。
 * @returns {T[]} 转换后的数组。
 */
function toArray(value) {
  return Array.isArray(value) ? value : [value];
}
/**
 * 函数包装式依赖管理器
 * 通过包装函数的方式管理依赖关系，确保在执行某个操作前所需的依赖都已完成
 */
export class DependencyManager {
  /**
   * 存储依赖状态的Map
   * @private
   */
  dependencies;
  /**
   * 存储依赖完成的Promise resolve函数的Map
   * @private
   */
  resolvers;
  /**
   * 创建依赖管理器实例
   */
  constructor() {
    this.dependencies = new Map();
    this.resolvers = new Map();
  }
  /**
   * 创建依赖提供者函数，执行后自动标记依赖完成
   *
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string} depName - 依赖名称，用于标识该依赖
   * @param {AnyFunction} fn - 要包装的原始函数
   * @returns {AsyncFunction<T, R>} 包装后的异步函数，执行完成后会自动标记依赖完成
   */
  createProvider(depName, fn) {
    return this._createProviderWrapper(depName, fn);
  }
  /**
   * 立即执行依赖提供者函数，执行后自动标记依赖完成
   *
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string} depName - 依赖名称，用于标识该依赖
   * @param {AnyFunction} fn - 要执行的原始函数
   * @param {...T} args - 函数参数
   * @returns {Promise<R>} 函数执行结果，执行完成后会自动标记依赖完成
   */
  async provider(depName, fn, ...args) {
    const wrapper = this._createProviderWrapper(depName, fn);
    return wrapper(...args);
  }
  /**
   * 创建等待依赖执行函数，执行前等待指定依赖完成
   *
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string | string[]} requiredDeps - 需要等待的依赖名称或依赖名称数组
   * @param {AnyFunction} fn - 要包装的原始函数
   * @param {DependencyOptions} [options={}] - 配置选项
   * @returns {AsyncFunction<T, R>} 包装后的异步函数，会在依赖满足后执行
   */
  createAwaitDepExec(requiredDeps, fn, options = {}) {
    return this._createAwaitDepExecWrapper(requiredDeps, fn, options);
  }
  async awaitDepExec(requiredDeps, fn, optionsOrFirstArg, ...restArgs) {
    let options = {};
    let args;
    // 判断第三个参数是否为选项对象
    if (
      optionsOrFirstArg !== undefined &&
      typeof optionsOrFirstArg === "object" &&
      optionsOrFirstArg !== null &&
      "timeout" in optionsOrFirstArg
    ) {
      options = optionsOrFirstArg;
      args = restArgs;
    } else {
      args = [optionsOrFirstArg, ...restArgs];
    }
    const wrapper = this._createAwaitDepExecWrapper(requiredDeps, fn, options);
    return wrapper(...args);
  }
  /**
   * 检查指定依赖是否已完成
   *
   * @param {string} depName - 依赖名称
   * @returns {boolean} 如果依赖已完成返回true，否则返回false
   */
  isComplete(depName) {
    return this.dependencies.get(depName) === true;
  }
  /**
   * 手动标记依赖完成（用于非函数依赖或外部触发）
   *
   * @param {string} depName - 要标记完成的依赖名称
   * @returns {DependencyManager} 返回当前实例，支持链式调用
   */
  complete(depName) {
    this._complete(depName);
    return this;
  }
  /**
   * 等待指定依赖完成
   *
   * @param {string | string[]} deps - 要等待的依赖名称或依赖名称数组
   * @param {number} [timeout] - 可选的超时时间（毫秒）
   * @returns {Promise<void>} 当所有指定依赖完成时resolve的Promise
   * @throws {Error} 当超时时抛出错误
   */
  async waitFor(deps, timeout) {
    const depArray = Array.isArray(deps) ? deps : [deps];
    return this._waitForAll(depArray, timeout);
  }
  /**
   * 获取所有依赖的当前状态
   *
   * @returns {DependencyStatus} 包含所有依赖名称和完成状态的对象
   */
  getStatus() {
    const status = {};
    for (const [key, value] of this.dependencies.entries()) {
      if (!key.endsWith("_promise")) {
        status[key] = value;
      }
    }
    return status;
  }
  /**
   * 重置所有依赖状态，清空所有已注册的依赖
   *
   * @returns {DependencyManager} 返回当前实例，支持链式调用
   */
  reset() {
    this.dependencies.clear();
    this.resolvers.clear();
    return this;
  }
  /**
   * 创建依赖提供者包装函数的通用逻辑
   *
   * @private
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string} depName - 依赖名称
   * @param {AnyFunction} fn - 要包装的原始函数
   * @returns {AsyncFunction<T, R>} 包装后的异步函数
   */
  _createProviderWrapper(depName, fn) {
    this._register(depName);
    return async (...args) => {
      try {
        const result = await fn(...args);
        this._complete(depName);
        return result;
      } catch (error) {
        this._complete(depName);
        throw error;
      }
    };
  }
  /**
   * 创建等待依赖执行包装函数的通用逻辑
   *
   * @private
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string | string[]} requiredDeps - 需要等待的依赖名称或依赖名称数组
   * @param {AnyFunction} fn - 要包装的原始函数
   * @param {DependencyOptions} options - 配置选项
   * @returns {AsyncFunction<T, R>} 包装后的异步函数
   */
  _createAwaitDepExecWrapper(requiredDeps, fn, options) {
    const deps = toArray(requiredDeps);
    deps.forEach((dep) => this._register(dep));
    return async (...args) => {
      await this._waitForAll(deps, options.timeout);
      return await fn(...args);
    };
  }
  /**
   * 注册一个依赖项到管理器中
   *
   * @private
   * @param {string} depName - 要注册的依赖名称
   */
  _register(depName) {
    if (this.dependencies.has(depName)) return;
    this.dependencies.set(depName, false);
    const promise = new Promise((resolve) => {
      this.resolvers.set(depName, resolve);
    });
    this.dependencies.set(`${depName}_promise`, promise);
  }
  /**
   * 标记指定依赖为已完成状态
   *
   * @private
   * @param {string} depName - 要标记完成的依赖名称
   */
  _complete(depName) {
    if (!this.dependencies.has(depName)) return;
    this.dependencies.set(depName, true);
    const resolver = this.resolvers.get(depName);
    if (resolver) {
      resolver();
      this.resolvers.delete(depName);
    }
  }
  /**
   * 等待所有指定的依赖完成
   *
   * @private
   * @param {string[]} deps - 要等待的依赖名称数组
   * @param {number} [timeout] - 可选的超时时间（毫秒）
   * @returns {Promise<void>} 当所有依赖完成时resolve的Promise
   * @throws {Error} 当超时时抛出错误
   */
  async _waitForAll(deps, timeout) {
    const promises = deps.map((dep) => {
      if (this.isComplete(dep)) {
        return Promise.resolve();
      }
      return this.dependencies.get(`${dep}_promise`);
    });
    const waitPromise = Promise.all(promises);
    if (timeout) {
      const timeoutPromise = new Promise((_, reject) => {
        setTimeout(() => {
          reject(new Error(`依赖等待超时 (${timeout}ms)`));
        }, timeout);
      });
      await Promise.race([waitPromise, timeoutPromise]);
    } else {
      await waitPromise;
    }
  }
}

export type AnyFunction = (...args: any) => any;

/**
 * 异步函数类型
 */
type AsyncFunction<T extends any[] = any[], R = any> = (
  ...args: T
) => Promise<R>;

/**
 * 函数包装式依赖管理器选项接口
 */
interface DependencyOptions {
  /** 超时时间（毫秒） */
  timeout?: number;
}

/**
 * 依赖状态类型
 */
type DependencyStatus = Record<string, boolean>;

/**
 * 将值或值数组转换为数组。
 *
 * @type {<T>(value: T | T[]) => T[]}
 * @param {T | T[]} value - 要转换的值或值数组。
 * @returns {T[]} 转换后的数组。
 */
function toArray<T>(value: T | T[]): T[] {
  return Array.isArray(value) ? value : [value];
}

/**
 * 函数包装式依赖管理器
 * 通过包装函数的方式管理依赖关系，确保在执行某个操作前所需的依赖都已完成
 */
export class DependencyManager {
  /**
   * 存储依赖状态的Map
   * @private
   */
  private readonly dependencies: Map<string, boolean>;

  /**
   * 存储依赖完成的Promise resolve函数的Map
   * @private
   */
  private readonly resolvers: Map<string, () => void>;

  /**
   * 创建依赖管理器实例
   */
  constructor() {
    this.dependencies = new Map<string, boolean>();
    this.resolvers = new Map<string, () => void>();
  }

  /**
   * 创建依赖提供者函数，执行后自动标记依赖完成
   *
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string} depName - 依赖名称，用于标识该依赖
   * @param {AnyFunction} fn - 要包装的原始函数
   * @returns {AsyncFunction<T, R>} 包装后的异步函数，执行完成后会自动标记依赖完成
   */
  createProvider<T extends any[] = any[], R = any>(
    depName: string,
    fn: AnyFunction,
  ): AsyncFunction<T, R> {
    return this._createProviderWrapper(depName, fn);
  }

  /**
   * 立即执行依赖提供者函数，执行后自动标记依赖完成
   *
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string} depName - 依赖名称，用于标识该依赖
   * @param {AnyFunction} fn - 要执行的原始函数
   * @param {...T} args - 函数参数
   * @returns {Promise<R>} 函数执行结果，执行完成后会自动标记依赖完成
   */
  async provider<T extends any[] = any[], R = any>(
    depName: string,
    fn: AnyFunction,
    ...args: T
  ): Promise<R> {
    const wrapper = this._createProviderWrapper<T, R>(depName, fn);
    return wrapper(...args);
  }

  /**
   * 创建等待依赖执行函数，执行前等待指定依赖完成
   *
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string | string[]} requiredDeps - 需要等待的依赖名称或依赖名称数组
   * @param {AnyFunction} fn - 要包装的原始函数
   * @param {DependencyOptions} [options={}] - 配置选项
   * @returns {AsyncFunction<T, R>} 包装后的异步函数，会在依赖满足后执行
   */
  createAwaitDepExec<T extends any[] = any[], R = any>(
    requiredDeps: string | string[],
    fn: AnyFunction,
    options: DependencyOptions = {},
  ): AsyncFunction<T, R> {
    return this._createAwaitDepExecWrapper(requiredDeps, fn, options);
  }

  /**
   * 立即等待依赖并执行函数
   *
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string | string[]} requiredDeps - 需要等待的依赖名称或依赖名称数组
   * @param {AnyFunction} fn - 要执行的原始函数
   * @param {DependencyOptions} options - 配置选项
   * @param {...T} args - 函数参数
   * @returns {Promise<R>} 函数执行结果，会在依赖满足后执行
   */
  async awaitDepExec<T extends any[] = any[], R = any>(
    requiredDeps: string | string[],
    fn: AnyFunction,
    options: DependencyOptions,
    ...args: T
  ): Promise<R>;
  async awaitDepExec<T extends any[] = any[], R = any>(
    requiredDeps: string | string[],
    fn: AnyFunction,
    ...args: T
  ): Promise<R>;
  async awaitDepExec<T extends any[] = any[], R = any>(
    requiredDeps: string | string[],
    fn: AnyFunction,
    optionsOrFirstArg?: DependencyOptions | T[0],
    ...restArgs: T extends [any, ...infer Rest] ? Rest : never[]
  ): Promise<R> {
    let options: DependencyOptions = {};
    let args: T;

    // 判断第三个参数是否为选项对象
    if (
      optionsOrFirstArg !== undefined &&
      typeof optionsOrFirstArg === "object" &&
      optionsOrFirstArg !== null &&
      "timeout" in optionsOrFirstArg
    ) {
      options = optionsOrFirstArg as DependencyOptions;
      args = restArgs as unknown as T;
    } else {
      args = [optionsOrFirstArg, ...restArgs] as T;
    }

    const wrapper = this._createAwaitDepExecWrapper<T, R>(
      requiredDeps,
      fn,
      options,
    );
    return wrapper(...args);
  }

  /**
   * 检查指定依赖是否已完成
   *
   * @param {string} depName - 依赖名称
   * @returns {boolean} 如果依赖已完成返回true，否则返回false
   */
  isComplete(depName: string): boolean {
    return this.dependencies.get(depName) === true;
  }

  /**
   * 手动标记依赖完成（用于非函数依赖或外部触发）
   *
   * @param {string} depName - 要标记完成的依赖名称
   * @returns {DependencyManager} 返回当前实例，支持链式调用
   */
  complete(depName: string): DependencyManager {
    this._complete(depName);
    return this;
  }

  /**
   * 等待指定依赖完成
   *
   * @param {string | string[]} deps - 要等待的依赖名称或依赖名称数组
   * @param {number} [timeout] - 可选的超时时间（毫秒）
   * @returns {Promise<void>} 当所有指定依赖完成时resolve的Promise
   * @throws {Error} 当超时时抛出错误
   */
  async waitFor(deps: string | string[], timeout?: number): Promise<void> {
    const depArray = Array.isArray(deps) ? deps : [deps];
    return this._waitForAll(depArray, timeout);
  }

  /**
   * 获取所有依赖的当前状态
   *
   * @returns {DependencyStatus} 包含所有依赖名称和完成状态的对象
   */
  getStatus(): DependencyStatus {
    const status: DependencyStatus = {};
    for (const [key, value] of this.dependencies.entries()) {
      if (!key.endsWith("_promise")) {
        status[key] = value;
      }
    }
    return status;
  }

  /**
   * 重置所有依赖状态，清空所有已注册的依赖
   *
   * @returns {DependencyManager} 返回当前实例，支持链式调用
   */
  reset(): DependencyManager {
    this.dependencies.clear();
    this.resolvers.clear();
    return this;
  }

  /**
   * 创建依赖提供者包装函数的通用逻辑
   *
   * @private
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string} depName - 依赖名称
   * @param {AnyFunction} fn - 要包装的原始函数
   * @returns {AsyncFunction<T, R>} 包装后的异步函数
   */
  private _createProviderWrapper<T extends any[] = any[], R = any>(
    depName: string,
    fn: AnyFunction,
  ): AsyncFunction<T, R> {
    this._register(depName);

    return async (...args: T): Promise<R> => {
      try {
        const result = await fn(...args);
        this._complete(depName);
        return result;
      } catch (error) {
        this._complete(depName);
        throw error;
      }
    };
  }

  /**
   * 创建等待依赖执行包装函数的通用逻辑
   *
   * @private
   * @template T - 函数参数类型数组
   * @template R - 函数返回值类型
   * @param {string | string[]} requiredDeps - 需要等待的依赖名称或依赖名称数组
   * @param {AnyFunction} fn - 要包装的原始函数
   * @param {DependencyOptions} options - 配置选项
   * @returns {AsyncFunction<T, R>} 包装后的异步函数
   */
  private _createAwaitDepExecWrapper<T extends any[] = any[], R = any>(
    requiredDeps: string | string[],
    fn: AnyFunction,
    options: DependencyOptions,
  ): AsyncFunction<T, R> {
    const deps = toArray(requiredDeps);
    deps.forEach((dep) => this._register(dep));

    return async (...args: T): Promise<R> => {
      await this._waitForAll(deps, options.timeout);
      return await fn(...args);
    };
  }

  /**
   * 注册一个依赖项到管理器中
   *
   * @private
   * @param {string} depName - 要注册的依赖名称
   */
  private _register(depName: string): void {
    if (this.dependencies.has(depName)) return;

    this.dependencies.set(depName, false);
    const promise = new Promise<void>((resolve) => {
      this.resolvers.set(depName, resolve);
    });

    this.dependencies.set(`${depName}_promise`, promise as any);
  }

  /**
   * 标记指定依赖为已完成状态
   *
   * @private
   * @param {string} depName - 要标记完成的依赖名称
   */
  private _complete(depName: string): void {
    if (!this.dependencies.has(depName)) return;
    this.dependencies.set(depName, true);
    const resolver = this.resolvers.get(depName);
    if (resolver) {
      resolver();
      this.resolvers.delete(depName);
    }
  }

  /**
   * 等待所有指定的依赖完成
   *
   * @private
   * @param {string[]} deps - 要等待的依赖名称数组
   * @param {number} [timeout] - 可选的超时时间（毫秒）
   * @returns {Promise<void>} 当所有依赖完成时resolve的Promise
   * @throws {Error} 当超时时抛出错误
   */
  private async _waitForAll(deps: string[], timeout?: number): Promise<void> {
    const promises = deps.map((dep) => {
      if (this.isComplete(dep)) {
        return Promise.resolve();
      }
      return this.dependencies.get(`${dep}_promise`);
    });

    const waitPromise = Promise.all(promises);

    if (timeout) {
      const timeoutPromise = new Promise<never>((_, reject) => {
        setTimeout(() => {
          reject(new Error(`依赖等待超时 (${timeout}ms)`));
        }, timeout);
      });

      await Promise.race([waitPromise, timeoutPromise]);
    } else {
      await waitPromise;
    }
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341

如有错误，请提交issue :::

DependencyManager ​

函数签名 ​

DependencyManager

函数签名