@eggjs/core 6.5.0 → 6.6.0-beta.10

package/dist/loader/file_loader.d.ts

@@ -0,0 +1,105 @@
+import { Fun } from "../utils/index.js";
+
+//#region src/loader/file_loader.d.ts
+declare const FULLPATH: unique symbol;
+declare const EXPORTS: unique symbol;
+declare const CaseStyle: {
+  readonly camel: "camel";
+  readonly lower: "lower";
+  readonly upper: "upper";
+};
+type CaseStyle = (typeof CaseStyle)[keyof typeof CaseStyle];
+type CaseStyleFunction = (filepath: string) => string[];
+type FileLoaderInitializer = (exports: unknown, options: {
+  path: string;
+  pathName: string;
+}) => unknown;
+type FileLoaderFilter = (exports: unknown) => boolean;
+interface FileLoaderOptions {
+  /** directories to be loaded */
+  directory: string | string[];
+  /** attach the target object from loaded files */
+  target: Record<string, any>;
+  /** match the files when load, support glob, default to all js files */
+  match?: string | string[];
+  /** ignore the files when load, support glob */
+  ignore?: string | string[];
+  /** custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path` */
+  initializer?: FileLoaderInitializer;
+  /** determine whether invoke when exports is function */
+  call?: boolean;
+  /** determine whether override the property when get the same name */
+  override?: boolean;
+  /** an object that be the argument when invoke the function */
+  inject?: Record<string, any>;
+  /** a function that filter the exports which can be loaded */
+  filter?: FileLoaderFilter;
+  /** set property's case when converting a filepath to property list. */
+  caseStyle?: CaseStyle | CaseStyleFunction;
+  lowercaseFirst?: boolean;
+}
+interface FileLoaderParseItem {
+  fullpath: string;
+  properties: string[];
+  exports: object | Fun;
+}
+/**
+ * Load files from directory to target object.
+ * @since 1.0.0
+ */
+declare class FileLoader {
+  static get FULLPATH(): symbol;
+  static get EXPORTS(): symbol;
+  readonly options: FileLoaderOptions & Required<Pick<FileLoaderOptions, 'caseStyle'>>;
+  /**
+   * @class
+   * @param {Object} options - options
+   * @param {String|Array} options.directory - directories to be loaded
+   * @param {Object} options.target - attach the target object from loaded files
+   * @param {String} options.match - match the files when load, support glob, default to all js files
+   * @param {String} options.ignore - ignore the files when load, support glob
+   * @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
+   * @param {Boolean} options.call - determine whether invoke when exports is function
+   * @param {Boolean} options.override - determine whether override the property when get the same name
+   * @param {Object} options.inject - an object that be the argument when invoke the function
+   * @param {Function} options.filter - a function that filter the exports which can be loaded
+   * @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
+   */
+  constructor(options: FileLoaderOptions);
+  /**
+   * attach items to target object. Mapping the directory to properties.
+   * `app/controller/group/repository.js` => `target.group.repository`
+   * @returns {Object} target
+   * @since 1.0.0
+   */
+  load(): Promise<object>;
+  /**
+   * Parse files from given directories, then return an items list, each item contains properties and exports.
+   *
+   * For example, parse `app/controller/group/repository.js`
+   *
+   * ```
+   * module.exports = app => {
+   *   return class RepositoryController extends app.Controller {};
+   * }
+   * ```
+   *
+   * It returns a item
+   *
+   * ```
+   * {
+   *   properties: [ 'group', 'repository' ],
+   *   exports: app => { ... },
+   * }
+   * ```
+   *
+   * `Properties` is an array that contains the directory of a filepath.
+   *
+   * `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
+   * @returns {Array} items
+   * @since 1.0.0
+   */
+  protected parse(): Promise<FileLoaderParseItem[]>;
+}
+//#endregion
+export { CaseStyle, CaseStyleFunction, EXPORTS, FULLPATH, FileLoader, FileLoaderFilter, FileLoaderInitializer, FileLoaderOptions, FileLoaderParseItem };

package/dist/loader/file_loader.js

@@ -0,0 +1,198 @@
+import utils_default from "../utils/index.js";
+import { debuglog } from "node:util";
+import path from "node:path";
+import fs from "node:fs";
+import { isSupportTypeScript } from "@eggjs/utils";
+import assert from "node:assert";
+import { isAsyncFunction, isClass, isGeneratorFunction, isPrimitive } from "is-type-of";
+import globby from "globby";
+
+//#region src/loader/file_loader.ts
+const debug = debuglog("egg/core/file_loader");
+const FULLPATH = Symbol("EGG_LOADER_ITEM_FULLPATH");
+const EXPORTS = Symbol("EGG_LOADER_ITEM_EXPORTS");
+const CaseStyle = {
+	camel: "camel",
+	lower: "lower",
+	upper: "upper"
+};
+/**
+* Load files from directory to target object.
+* @since 1.0.0
+*/
+var FileLoader = class {
+	static get FULLPATH() {
+		return FULLPATH;
+	}
+	static get EXPORTS() {
+		return EXPORTS;
+	}
+	options;
+	/**
+	* @class
+	* @param {Object} options - options
+	* @param {String|Array} options.directory - directories to be loaded
+	* @param {Object} options.target - attach the target object from loaded files
+	* @param {String} options.match - match the files when load, support glob, default to all js files
+	* @param {String} options.ignore - ignore the files when load, support glob
+	* @param {Function} options.initializer - custom file exports, receive two parameters, first is the inject object(if not js file, will be content buffer), second is an `options` object that contain `path`
+	* @param {Boolean} options.call - determine whether invoke when exports is function
+	* @param {Boolean} options.override - determine whether override the property when get the same name
+	* @param {Object} options.inject - an object that be the argument when invoke the function
+	* @param {Function} options.filter - a function that filter the exports which can be loaded
+	* @param {String|Function} options.caseStyle - set property's case when converting a filepath to property list.
+	*/
+	constructor(options) {
+		assert(options.directory, "options.directory is required");
+		assert(options.target, "options.target is required");
+		this.options = {
+			caseStyle: CaseStyle.camel,
+			call: true,
+			override: false,
+			...options
+		};
+		if (this.options.lowercaseFirst === true) {
+			utils_default.deprecated("lowercaseFirst is deprecated, use caseStyle instead");
+			this.options.caseStyle = CaseStyle.lower;
+		}
+	}
+	/**
+	* attach items to target object. Mapping the directory to properties.
+	* `app/controller/group/repository.js` => `target.group.repository`
+	* @returns {Object} target
+	* @since 1.0.0
+	*/
+	async load() {
+		const items = await this.parse();
+		const target = this.options.target;
+		for (const item of items) {
+			debug("[load] loading item: fullpath: %s, properties: %o", item.fullpath, item.properties);
+			item.properties.reduce((target$1, property, index) => {
+				let obj;
+				const properties = item.properties.slice(0, index + 1).join(".");
+				if (index === item.properties.length - 1) {
+					if (property in target$1 && !this.options.override) throw new Error(`can't overwrite property '${properties}' from ${target$1[property][FULLPATH]} by ${item.fullpath}`);
+					obj = item.exports;
+					if (obj && !isPrimitive(obj)) {
+						Reflect.set(obj, FULLPATH, item.fullpath);
+						Reflect.set(obj, EXPORTS, true);
+					}
+				} else obj = target$1[property] || {};
+				target$1[property] = obj;
+				if (debug.enabled) debug("[load] loaded item properties: %o => keys: %j, index: %d", properties, Object.keys(obj), index);
+				return obj;
+			}, target);
+		}
+		return target;
+	}
+	/**
+	* Parse files from given directories, then return an items list, each item contains properties and exports.
+	*
+	* For example, parse `app/controller/group/repository.js`
+	*
+	* ```
+	* module.exports = app => {
+	*   return class RepositoryController extends app.Controller {};
+	* }
+	* ```
+	*
+	* It returns a item
+	*
+	* ```
+	* {
+	*   properties: [ 'group', 'repository' ],
+	*   exports: app => { ... },
+	* }
+	* ```
+	*
+	* `Properties` is an array that contains the directory of a filepath.
+	*
+	* `Exports` depends on type, if exports is a function, it will be called. if initializer is specified, it will be called with exports for customizing.
+	* @returns {Array} items
+	* @since 1.0.0
+	*/
+	async parse() {
+		let files = this.options.match;
+		if (files) files = Array.isArray(files) ? files : [files];
+		else files = isSupportTypeScript() ? ["**/*.(js|ts)", "!**/*.d.ts"] : ["**/*.js"];
+		let ignore = this.options.ignore;
+		if (ignore) {
+			ignore = Array.isArray(ignore) ? ignore : [ignore];
+			ignore = ignore.filter((f) => !!f).map((f) => "!" + f);
+			files = files.concat(ignore);
+		}
+		let directories = this.options.directory;
+		if (!Array.isArray(directories)) directories = [directories];
+		const filter = typeof this.options.filter === "function" ? this.options.filter : null;
+		const items = [];
+		debug("[parse] parsing directories: %j", directories);
+		for (const directory of directories) {
+			const filepaths = globby.sync(files, { cwd: directory });
+			debug("[parse] globby files: %o, cwd: %o => %o", files, directory, filepaths);
+			for (const filepath of filepaths) {
+				const fullpath = path.join(directory, filepath);
+				if (!fs.statSync(fullpath).isFile()) continue;
+				if (filepath.endsWith(".js")) {
+					const filepathTs = filepath.replace(/\.js$/, ".ts");
+					if (filepaths.includes(filepathTs)) {
+						debug("[parse] ignore %s, because %s exists", fullpath, filepathTs);
+						continue;
+					}
+				}
+				const properties = getProperties(filepath, this.options.caseStyle);
+				const pathName = directory.split(/[/\\]/).slice(-1) + "." + properties.join(".");
+				const exports = await getExports(fullpath, this.options, pathName);
+				if (exports === null || exports === void 0 || filter && filter(exports) === false) continue;
+				if (isClass(exports)) {
+					exports.prototype.pathName = pathName;
+					exports.prototype.fullPath = fullpath;
+				}
+				items.push({
+					fullpath,
+					properties,
+					exports
+				});
+				debug("[parse] parse %s, properties %j, exports %o", fullpath, properties, exports);
+			}
+		}
+		return items;
+	}
+};
+function getProperties(filepath, caseStyle) {
+	if (typeof caseStyle === "function") {
+		const result = caseStyle(filepath);
+		assert(Array.isArray(result), `caseStyle expect an array, but got ${JSON.stringify(result)}`);
+		return result;
+	}
+	return defaultCamelize(filepath, caseStyle);
+}
+async function getExports(fullpath, options, pathName) {
+	let exports = await utils_default.loadFile(fullpath);
+	if (options.initializer) {
+		exports = options.initializer(exports, {
+			path: fullpath,
+			pathName
+		});
+		debug("[getExports] after initializer => %o", exports);
+	}
+	if (isGeneratorFunction(exports)) throw new TypeError(`Support for generators was removed, fullpath: ${fullpath}`);
+	if (isClass(exports) || isAsyncFunction(exports)) return exports;
+	if (options.call && typeof exports === "function") {
+		exports = exports(options.inject);
+		if (exports !== null && exports !== void 0) return exports;
+	}
+	return exports;
+}
+function defaultCamelize(filepath, caseStyle) {
+	return filepath.slice(0, filepath.lastIndexOf(".")).split("/").map((property) => {
+		if (!/^[a-z][a-z0-9_-]*$/i.test(property)) throw new Error(`${property} is not match 'a-z0-9_-' in ${filepath}`);
+		property = property.replaceAll(/[_-][a-z]/gi, (s) => s.slice(1).toUpperCase());
+		let first = property[0];
+		if (caseStyle === CaseStyle.lower) first = first.toLowerCase();
+		else if (caseStyle === CaseStyle.upper) first = first.toUpperCase();
+		return first + property.slice(1);
+	});
+}
+
+//#endregion
+export { CaseStyle, EXPORTS, FULLPATH, FileLoader };

package/dist/singleton.d.ts

@@ -0,0 +1,33 @@
+import { EggCore } from "./egg.js";
+
+//#region src/singleton.d.ts
+type SingletonCreateMethod = (config: Record<string, any>, app: EggCore, clientName: string) => unknown | Promise<unknown>;
+interface SingletonOptions {
+  name: string;
+  app: EggCore;
+  create: SingletonCreateMethod;
+}
+declare class Singleton<T = any> {
+  #private;
+  readonly clients: Map<string, T>;
+  readonly app: EggCore;
+  readonly create: SingletonCreateMethod;
+  readonly name: string;
+  readonly options: Record<string, any>;
+  constructor(options: SingletonOptions);
+  init(): void | Promise<void>;
+  initSync(): void;
+  initAsync(): Promise<void>;
+  /**
+   * @deprecated please use `getSingletonInstance(id)` instead
+   */
+  get(id: string): T;
+  /**
+   * Get singleton instance by id
+   */
+  getSingletonInstance(id: string): T;
+  createInstance(config: Record<string, any>, clientName: string): T;
+  createInstanceAsync(config: Record<string, any>, clientName: string): Promise<T>;
+}
+//#endregion
+export { Singleton, SingletonCreateMethod, SingletonOptions };

package/dist/singleton.js

@@ -0,0 +1,107 @@
+import assert from "node:assert";
+import { isAsyncFunction } from "is-type-of";
+
+//#region src/singleton.ts
+var Singleton = class {
+	clients = /* @__PURE__ */ new Map();
+	app;
+	create;
+	name;
+	options;
+	constructor(options) {
+		assert(options.name, "[egg/core/singleton] Singleton#constructor options.name is required");
+		assert(options.app, "[egg/core/singleton] Singleton#constructor options.app is required");
+		assert(options.create, "[egg/core/singleton] Singleton#constructor options.create is required");
+		assert(!(options.name in options.app), `[egg/core/singleton] ${options.name} is already exists in app`);
+		this.app = options.app;
+		this.name = options.name;
+		this.create = options.create;
+		this.options = options.app.config[this.name] ?? {};
+	}
+	init() {
+		return isAsyncFunction(this.create) ? this.initAsync() : this.initSync();
+	}
+	initSync() {
+		const options = this.options;
+		assert(!(options.client && options.clients), `[egg/core/singleton] ${this.name} can not set options.client and options.clients both`);
+		if (options.client) {
+			const client = this.createInstance(options.client, options.name);
+			this.#setClientToApp(client);
+			this.#extendDynamicMethods(client);
+			return;
+		}
+		if (options.clients) {
+			for (const id of Object.keys(options.clients)) {
+				const client = this.createInstance(options.clients[id], id);
+				this.clients.set(id, client);
+			}
+			this.#setClientToApp(this);
+			return;
+		}
+		this.#setClientToApp(this);
+	}
+	async initAsync() {
+		const options = this.options;
+		assert(!(options.client && options.clients), `[egg/core/singleton] ${this.name} can not set options.client and options.clients both`);
+		if (options.client) {
+			const client = await this.createInstanceAsync(options.client, options.name);
+			this.#setClientToApp(client);
+			this.#extendDynamicMethods(client);
+			return;
+		}
+		if (options.clients) {
+			await Promise.all(Object.keys(options.clients).map((id) => {
+				return this.createInstanceAsync(options.clients[id], id).then((client) => this.clients.set(id, client));
+			}));
+			this.#setClientToApp(this);
+			return;
+		}
+		this.#setClientToApp(this);
+	}
+	#setClientToApp(client) {
+		Reflect.set(this.app, this.name, client);
+	}
+	/**
+	* @deprecated please use `getSingletonInstance(id)` instead
+	*/
+	get(id) {
+		return this.clients.get(id);
+	}
+	/**
+	* Get singleton instance by id
+	*/
+	getSingletonInstance(id) {
+		return this.clients.get(id);
+	}
+	createInstance(config, clientName) {
+		assert(!isAsyncFunction(this.create), `[egg/core/singleton] ${this.name} only support asynchronous creation, please use createInstanceAsync`);
+		config = {
+			...this.options.default,
+			...config
+		};
+		return this.create(config, this.app, clientName);
+	}
+	async createInstanceAsync(config, clientName) {
+		config = {
+			...this.options.default,
+			...config
+		};
+		return await this.create(config, this.app, clientName);
+	}
+	#extendDynamicMethods(client) {
+		assert(!client.createInstance, "[egg/core/singleton] singleton instance should not have createInstance method");
+		assert(!client.createInstanceAsync, "[egg/core/singleton] singleton instance should not have createInstanceAsync method");
+		try {
+			let extendable = client;
+			if (!Object.isExtensible(client) || Object.isFrozen(client)) extendable = client.__proto__ || client;
+			extendable.createInstance = this.createInstance.bind(this);
+			extendable.createInstanceAsync = this.createInstanceAsync.bind(this);
+		} catch (err) {
+			this.app.coreLogger.warn("[egg/core/singleton] %s dynamic create is disabled because of client is un-extendable", this.name);
+			this.app.coreLogger.warn(err);
+		}
+	}
+};
+
+//#endregion
+export { Singleton };

package/{src/types.ts → dist/types.d.ts}

@@ -1,4 +1,5 @@
-export interface EggAppInfo {
+//#region src/types.d.ts
+interface EggAppInfo {
   /** package.json */
   pkg: Record<string, any>;
   /** the application name from package.json */
@@ -14,8 +15,7 @@ export interface EggAppInfo {
   /** baseDir when local and unittest, HOME when other environment */
   root: string;
 }
-
-export interface EggPluginInfo {
+interface EggPluginInfo {
   /** the plugin name, it can be used in `dep` */
   name: string;
   /** the package name of plugin */
@@ -36,8 +36,7 @@ export interface EggPluginInfo {
   /** the file plugin config in. */
   from: string;
 }
-
-export interface CustomLoaderConfigItem {
+interface CustomLoaderConfigItem {
   /** the directory of the custom loader */
   directory: string;
   /** the inject object, it can be app or ctx */
@@ -45,8 +44,7 @@ export interface CustomLoaderConfigItem {
   /** whether load unit files */
   loadunit?: boolean;
 }
-
-export interface EggAppConfig extends Record<string, any> {
+interface EggAppConfig extends Record<string, any> {
   coreMiddleware: string[];
   middleware: string[];
   customLoader?: Record<string, CustomLoaderConfigItem>;
@@ -54,3 +52,5 @@ export interface EggAppConfig extends Record<string, any> {
     supportParams?: boolean;
   };
 }
+//#endregion
+export { CustomLoaderConfigItem, EggAppConfig, EggAppInfo, EggPluginInfo };

package/dist/utils/index.d.ts

@@ -0,0 +1,19 @@
+//#region src/utils/index.d.ts
+type Fun = (...args: unknown[]) => unknown;
+declare function getCalleeFromStack(withLine?: boolean, stackIndex?: number): string;
+declare const _default: {
+  deprecated(message: string): void;
+  extensions: any;
+  extensionNames: string[];
+  existsPath(filepath: string): Promise<boolean>;
+  loadFile(filepath: string): Promise<any>;
+  resolvePath(filepath: string, options?: {
+    paths?: string[];
+  }): string;
+  methods: string[];
+  callFn(fn: Fun, args?: unknown[], ctx?: unknown): Promise<unknown>;
+  getCalleeFromStack: typeof getCalleeFromStack;
+  getResolvedFilename(filepath: string, baseDir: string): string;
+};
+//#endregion
+export { Fun, _default };

package/dist/utils/index.js

@@ -0,0 +1,103 @@
+import BuiltinModule from "node:module";
+import { debuglog } from "node:util";
+import path from "node:path";
+import fs from "node:fs";
+import { stat } from "node:fs/promises";
+import { importModule, importResolve } from "@eggjs/utils";
+
+//#region src/utils/index.ts
+const debug = debuglog("egg/core/utils");
+const extensions = (typeof module !== "undefined" && module.constructor.length > 1 ? module.constructor : BuiltinModule)._extensions;
+const extensionNames = Object.keys(extensions).concat([".cjs", ".mjs"]);
+debug("Module extensions: %j", extensionNames);
+function getCalleeFromStack(withLine, stackIndex) {
+	stackIndex = stackIndex === void 0 ? 2 : stackIndex;
+	const limit = Error.stackTraceLimit;
+	const prep = Error.prepareStackTrace;
+	Error.prepareStackTrace = prepareObjectStackTrace;
+	Error.stackTraceLimit = 5;
+	const obj = {};
+	Error.captureStackTrace(obj);
+	let callSite = obj.stack[stackIndex];
+	let fileName = "";
+	if (callSite) {
+		fileName = callSite.getFileName();
+		/* istanbul ignore if */
+		if (fileName && fileName.endsWith("egg-mock/lib/app.js")) {
+			callSite = obj.stack[stackIndex + 1];
+			fileName = callSite.getFileName();
+		}
+	}
+	Error.prepareStackTrace = prep;
+	Error.stackTraceLimit = limit;
+	if (!callSite || !fileName) return "<anonymous>";
+	if (!withLine) return fileName;
+	return `${fileName}:${callSite.getLineNumber()}:${callSite.getColumnNumber()}`;
+}
+var utils_default = {
+	deprecated(message) {
+		if (debug.enabled) console.trace("[@eggjs/core/deprecated] %s", message);
+		else {
+			console.log("[@eggjs/core/deprecated] %s", message);
+			console.log("[@eggjs/core/deprecated] set NODE_DEBUG=@eggjs/core/utils can show call stack");
+		}
+	},
+	extensions,
+	extensionNames,
+	async existsPath(filepath) {
+		try {
+			await stat(filepath);
+			return true;
+		} catch {
+			return false;
+		}
+	},
+	async loadFile(filepath) {
+		debug("[loadFile:start] filepath: %s", filepath);
+		try {
+			const extname = path.extname(filepath);
+			if (extname && !extensionNames.includes(extname) && extname !== ".ts") return fs.readFileSync(filepath);
+			return await importModule(filepath, { importDefaultOnly: true });
+		} catch (e) {
+			if (!(e instanceof Error)) {
+				console.trace(e);
+				throw e;
+			}
+			const err = /* @__PURE__ */ new Error(`[egg/core] load file: ${filepath}, error: ${e.message}`);
+			err.cause = e;
+			debug("[loadFile] handle %s error: %s", filepath, e);
+			throw err;
+		}
+	},
+	resolvePath(filepath, options) {
+		return importResolve(filepath, options);
+	},
+	methods: [
+		"head",
+		"options",
+		"get",
+		"put",
+		"patch",
+		"post",
+		"delete"
+	],
+	async callFn(fn, args, ctx) {
+		args = args || [];
+		if (typeof fn !== "function") return;
+		return ctx ? fn.call(ctx, ...args) : fn(...args);
+	},
+	getCalleeFromStack,
+	getResolvedFilename(filepath, baseDir) {
+		return filepath.replace(baseDir + path.sep, "").replace(/[/\\]/g, "/");
+	}
+};
+/**
+* Capture call site stack from v8.
+* https://github.com/v8/v8/wiki/Stack-Trace-API
+*/
+function prepareObjectStackTrace(_obj, stack) {
+	return stack;
+}
+
+//#endregion
+export { utils_default as default };

package/dist/utils/sequencify.d.ts

@@ -0,0 +1,16 @@
+//#region src/utils/sequencify.d.ts
+interface SequencifyResult {
+  sequence: string[];
+  requires: Record<string, true>;
+}
+interface SequencifyTask {
+  dependencies: string[];
+  optionalDependencies: string[];
+}
+declare function sequencify(tasks: Record<string, SequencifyTask>, names: string[]): {
+  sequence: string[];
+  missingTasks: string[];
+  recursiveDependencies: string[];
+};
+//#endregion
+export { SequencifyResult, SequencifyTask, sequencify };

package/dist/utils/sequencify.js

@@ -0,0 +1,46 @@
+import { debuglog } from "node:util";
+
+//#region src/utils/sequencify.ts
+const debug = debuglog("egg/core/utils/sequencify");
+function sequence(tasks, names, result, missing, recursive, nest, optional, parent) {
+	for (const name of names) {
+		if (result.requires[name]) continue;
+		const node = tasks[name];
+		if (!node) {
+			if (optional === true) continue;
+			missing.push(name);
+		} else if (nest.includes(name)) {
+			nest.push(name);
+			recursive.push(...nest.slice(0));
+			nest.pop();
+		} else if (node.dependencies.length > 0 || node.optionalDependencies.length > 0) {
+			nest.push(name);
+			if (node.dependencies.length > 0) sequence(tasks, node.dependencies, result, missing, recursive, nest, optional, name);
+			if (node.optionalDependencies.length > 0) sequence(tasks, node.optionalDependencies, result, missing, recursive, nest, true, name);
+			nest.pop();
+		}
+		if (!optional) {
+			result.requires[name] = true;
+			debug("task: %s is enabled by %s", name, parent);
+		}
+		if (!result.sequence.includes(name)) result.sequence.push(name);
+	}
+}
+function sequencify(tasks, names) {
+	const result = {
+		sequence: [],
+		requires: {}
+	};
+	const missing = [];
+	const recursive = [];
+	sequence(tasks, names, result, missing, recursive, [], false, "app");
+	if (missing.length > 0 || recursive.length > 0) result.sequence = [];
+	return {
+		sequence: result.sequence.filter((item) => result.requires[item]),
+		missingTasks: missing,
+		recursiveDependencies: recursive
+	};
+}
+
+//#endregion
+export { sequencify };