@eggjs/core 7.0.0-beta.18 → 7.0.0-beta.20

package/dist/loader/file_loader.d.ts

@@ -1,105 +0,0 @@
-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

@@ -1,198 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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/dist/types.d.ts

@@ -1,56 +0,0 @@
-//#region src/types.d.ts
-interface EggAppInfo {
-  /** package.json */
-  pkg: Record<string, any>;
-  /** the application name from package.json */
-  name: string;
-  /** current directory of application */
-  baseDir: string;
-  /** equals to serverEnv */
-  env: string;
-  /** equals to serverScope */
-  scope: string;
-  /** home directory of the OS */
-  HOME: string;
-  /** baseDir when local and unittest, HOME when other environment */
-  root: string;
-}
-interface EggPluginInfo {
-  /** the plugin name, it can be used in `dep` */
-  name: string;
-  /** the package name of plugin */
-  package?: string;
-  version?: string;
-  /** whether enabled */
-  enable: boolean;
-  implicitEnable?: boolean;
-  /** the directory of the plugin package */
-  path?: string;
-  /** the dependent plugins, you can use the plugin name */
-  dependencies: string[];
-  /** the optional dependent plugins. */
-  optionalDependencies: string[];
-  dependents?: string[];
-  /** specify the serverEnv that only enable the plugin in it */
-  env: string[];
-  /** the file plugin config in. */
-  from: string;
-}
-interface CustomLoaderConfigItem {
-  /** the directory of the custom loader */
-  directory: string;
-  /** the inject object, it can be app or ctx */
-  inject: string;
-  /** whether load unit files */
-  loadunit?: boolean;
-}
-interface EggAppConfig extends Record<string, any> {
-  coreMiddleware: string[];
-  middleware: string[];
-  customLoader?: Record<string, CustomLoaderConfigItem>;
-  controller?: {
-    supportParams?: boolean;
-  };
-}
-//#endregion
-export { CustomLoaderConfigItem, EggAppConfig, EggAppInfo, EggPluginInfo };

package/dist/utils/index.d.ts

@@ -1,19 +0,0 @@
-//#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

@@ -1,103 +0,0 @@
-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

@@ -1,16 +0,0 @@
-//#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

@@ -1,46 +0,0 @@
-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 };