@h3ravel/shared 0.27.7 → 0.28.0

package/dist/index.js

@@ -1,94 +1,279 @@
+import chalk from "chalk";
 import { access } from "fs/promises";
 import escalade from "escalade/sync";
+import { existsSync } from "fs";
 import path from "path";
-import chalk from "chalk";
 import autocomplete from "inquirer-autocomplete-standalone";
 import { confirm, input, password, select } from "@inquirer/prompts";
 import crypto from "crypto";
 import preferredPM from "preferred-pm";
 
-//#region src/Utils/EnvParser.ts
-var EnvParser = class {
-	static parse(initial) {
-		const parsed = { ...initial };
-		for (const key in parsed) {
-			const value = parsed[key];
-			parsed[key] = this.parseValue(value);
+//#region src/Container.ts
+const INTERNAL_METHODS = Symbol("internal_methods");
+
+//#endregion
+//#region src/Mixins/MixinSystem.ts
+/**
+* Helper to mix multiple classes into one, this allows extending multiple classes by any single class
+* 
+* @param bases 
+* @returns 
+*/
+const mix = (...bases) => {
+	class Base {
+		constructor(...args) {
+			let instance = this;
+			for (const constructor of bases) {
+				const result = Reflect.construct(constructor, args, new.target);
+				if (result && (typeof result === "object" || typeof result === "function")) {
+					if (result !== instance) {
+						Object.assign(result, instance);
+						instance = result;
+					}
+				}
+			}
+			return instance;
 		}
-		return parsed;
 	}
-	static parseValue(value) {
-		/**
-		* Null/undefined stay untouched 
-		*/
-		if (value === null || value === void 0) return value;
-		/**
-		* Convert string "true"/"false" to boolean 
-		*/
-		if (value === "true") return true;
-		if (value === "false") return false;
-		/**
-		*  Convert string numbers to number 
-		*/
-		if (!isNaN(value) && value.trim() !== "") return Number(value);
-		/**
-		* Convert string "null" and "undefined"
-		*/
-		if (value === "null") return null;
-		if (value === "undefined") return void 0;
-		/**
-		* Otherwise return as-is (string)
-		*/
-		return value;
+	for (let i = 0; i < bases.length; i++) {
+		const currentBase = bases[i];
+		const nextBase = bases[i + 1];
+		Object.getOwnPropertyNames(currentBase.prototype).forEach((prop) => {
+			if (prop !== "constructor") Object.defineProperty(Base.prototype, prop, Object.getOwnPropertyDescriptor(currentBase.prototype, prop));
+		});
+		Object.getOwnPropertyNames(currentBase).forEach((prop) => {
+			if (![
+				"prototype",
+				"name",
+				"length"
+			].includes(prop)) Object.defineProperty(Base, prop, Object.getOwnPropertyDescriptor(currentBase, prop));
+		});
+		if (nextBase) {
+			Object.setPrototypeOf(currentBase.prototype, nextBase.prototype);
+			Object.setPrototypeOf(currentBase, nextBase);
+		}
 	}
+	Object.setPrototypeOf(Base.prototype, bases[0].prototype);
+	Object.setPrototypeOf(Base, bases[0]);
+	return Base;
 };
 
 //#endregion
-//#region src/Utils/FileSystem.ts
-var FileSystem = class {
-	static findModulePkg(moduleId, cwd) {
-		const parts = moduleId.replace(/\\/g, "/").split("/");
-		let packageName = "";
-		if (parts.length > 0 && parts[0][0] === "@") packageName += parts.shift() + "/";
-		packageName += parts.shift();
-		const packageJson = path.join(cwd ?? process.cwd(), "node_modules", packageName);
-		const resolved = this.resolveFileUp("package", ["json"], packageJson);
-		if (!resolved) return;
-		return path.join(path.dirname(resolved), parts.join("/"));
-	}
-	/**
-	* Check if file exists
-	* 
-	* @param path 
-	* @returns 
-	*/
-	static async fileExists(path$1) {
-		try {
-			await access(path$1);
-			return true;
-		} catch {
-			return false;
+//#region src/Mixins/TraitSystem.ts
+const crcTable = [];
+for (let n = 0; n < 256; n++) {
+	let c = n;
+	for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+	crcTable[n] = c;
+}
+const crc32 = (str) => {
+	let crc = -1;
+	for (let i = 0; i < str.length; i++) crc = crc >>> 8 ^ crcTable[(crc ^ str.charCodeAt(i)) & 255];
+	return (crc ^ -1) >>> 0;
+};
+const isCons = (fn) => typeof fn === "function" && !!fn.prototype && !!fn.prototype.constructor;
+const isTypeFactory = (fn) => typeof fn === "function" && !fn.prototype && fn.length === 0;
+function trait(...args) {
+	const factory = args.length === 2 ? args[1] : args[0];
+	const superTraits = args.length === 2 ? args[0] : void 0;
+	return {
+		id: crc32(factory.toString()),
+		symbol: Symbol("trait"),
+		factory,
+		superTraits
+	};
+}
+const extendProperties = (cons, field, value) => Object.defineProperty(cons, field, {
+	value,
+	enumerable: false,
+	writable: false
+});
+const rawTrait = (x) => isTypeFactory(x) ? x() : x;
+const deriveTrait = (trait$, baseClz, derived) => {
+	const trait$1 = rawTrait(trait$);
+	let clz = baseClz;
+	if (!derived.has(trait$1.id)) {
+		derived.set(trait$1.id, true);
+		if (trait$1.superTraits !== void 0) for (const superTrait of reverseTraitList(trait$1.superTraits)) clz = deriveTrait(superTrait, clz, derived);
+		clz = trait$1.factory(clz);
+		extendProperties(clz, "id", crc32(trait$1.factory.toString()));
+		extendProperties(clz, trait$1.symbol, true);
+	}
+	return clz;
+};
+const reverseTraitList = (traits) => traits.slice().reverse();
+function use(...traits) {
+	if (traits.length === 0) throw new Error("invalid number of parameters (expected one or more traits)");
+	let clz;
+	let lot;
+	const last = traits[traits.length - 1];
+	if (isCons(last) && !isTypeFactory(last)) {
+		clz = last;
+		lot = traits.slice(0, -1);
+	} else {
+		clz = class ROOT {};
+		lot = traits;
+	}
+	const derived = /* @__PURE__ */ new Map();
+	for (const trait$1 of reverseTraitList(lot)) clz = deriveTrait(trait$1, clz, derived);
+	return clz;
+}
+function uses(instance, trait$1) {
+	if (typeof instance !== "object" || instance === null) return false;
+	let obj = instance;
+	if (isCons(trait$1) && !isTypeFactory(trait$1)) return instance instanceof trait$1;
+	const idTrait = (isTypeFactory(trait$1) ? trait$1() : trait$1)["id"];
+	while (obj) {
+		if (Object.hasOwn(obj, "constructor")) {
+			if ((obj.constructor["id"] ?? 0) === idTrait) return true;
 		}
+		obj = Object.getPrototypeOf(obj);
 	}
-	/**
-	* Recursively find files starting from given cwd
-	* 
-	* @param name 
-	* @param extensions 
-	* @param cwd 
-	* 
-	* @returns 
-	*/
-	static resolveFileUp(name, extensions, cwd) {
-		cwd ??= process.cwd();
-		return escalade(cwd, (dir, filesNames) => {
-			if (typeof extensions === "function") return extensions(dir, filesNames);
-			const candidates = new Set(extensions.map((ext) => `${name}.${ext}`));
-			for (const filename of filesNames) if (candidates.has(filename)) return filename;
-			return false;
-		}) ?? void 0;
+	return false;
+}
+
+//#endregion
+//#region src/Mixins/UseFinalizable.ts
+/**
+* the central class instance registry
+*/
+const registry = new FinalizationRegistry((fn) => {
+	if (typeof fn === "function" && !fn.finalized) {
+		fn.finalized = true;
+		fn();
+	}
+});
+/**
+* the API trait "Finalizable<T>"
+*/
+const Finalizable = trait((base) => class Finalizable$1 extends base {
+	constructor(...args) {
+		super(...args);
+		const fn1 = this.$finalize;
+		if (typeof fn1 !== "function") throw new Error("trait Finalizable requires a $finalize method to be defined");
+		const fn2 = () => {
+			fn1(this);
+		};
+		fn2.finalized = false;
+		registry.register(this, fn2, this);
+	}
+});
+
+//#endregion
+//#region src/Mixins/UseMagic.ts
+/**
+* Wraps an object in a Proxy to emulate PHP magic methods.
+*
+* Supported:
+*  - __call(method, args)
+*  - __get(property)
+*  - __set(property, value)
+*  - __isset(property)
+*  - __unset(property)
+*
+* Called automatically by Magic's constructor.
+* 
+* Return in any class constructor to use
+* 
+* @param target 
+* @returns 
+*/
+function makeMagic(target) {
+	return new Proxy(target, {
+		get(obj, prop, receiver) {
+			if (typeof prop === "string") {
+				if (prop in obj) return Reflect.get(obj, prop, receiver);
+				if (obj.__call) return (...args) => obj.__call(prop, args);
+				if (obj.__get) return obj.__get(prop);
+			}
+		},
+		set(obj, prop, value) {
+			if (typeof prop === "string" && obj.__set) {
+				obj.__set(prop, value);
+				return true;
+			}
+			return Reflect.set(obj, prop, value);
+		},
+		has(obj, prop) {
+			if (typeof prop === "string" && obj.__isset) return obj.__isset(prop);
+			return Reflect.has(obj, prop);
+		},
+		deleteProperty(obj, prop) {
+			if (typeof prop === "string" && obj.__unset) {
+				obj.__unset(prop);
+				return true;
+			}
+			return Reflect.deleteProperty(obj, prop);
+		}
+	});
+}
+/**
+* Wraps a class constructor in a Proxy to emulate static PHP magic methods.
+*
+* Supported:
+*  - __callStatic(method, args)
+*  - static __get(property)
+*  - static __set(property, value)
+*  - static __isset(property)
+*  - static __unset(property)
+* 
+* @param cls 
+* @returns 
+*/
+function makeStaticMagic(cls) {
+	return new Proxy(cls, {
+		get(target, prop) {
+			if (typeof prop === "string") {
+				if (prop in target) return target[prop];
+				if (target.__callStatic) return (...args) => target.__callStatic(prop, args);
+				if (target.__get) return target.__get(prop);
+			}
+		},
+		set(target, prop, value) {
+			if (typeof prop === "string" && target.__set) {
+				target.__set(prop, value);
+				return true;
+			}
+			return Reflect.set(target, prop, value);
+		},
+		has(target, prop) {
+			if (typeof prop === "string" && target.__isset) return target.__isset(prop);
+			return Reflect.has(target, prop);
+		},
+		deleteProperty(target, prop) {
+			if (typeof prop === "string" && target.__unset) {
+				target.__unset(prop);
+				return true;
+			}
+			return Reflect.deleteProperty(target, prop);
+		}
+	});
+}
+/**
+* Base class that enables PHP-style magic methods automatically.
+*
+* Any subclass may implement:
+*  - __call
+*  - __get
+*  - __set
+*  - __isset
+*  - __unset
+*
+* The constructor returns a Proxy transparently.
+*/
+var Magic = class {
+	constructor() {
+		return makeMagic(this);
 	}
 };
+const UseMagic = trait((Base) => {
+	return class Magic$1 extends Base {
+		constructor(...args) {
+			super(...args);
+			return makeMagic(this);
+		}
+	};
+});
 
 //#endregion
 //#region src/Utils/Logger.ts
@@ -166,6 +351,17 @@ var Logger = class Logger {
 	* @returns 
 	*/
 	static textFormat(txt, color, preserveCol = false) {
+		if (txt instanceof Error) {
+			const err = txt;
+			const code = err.code ?? err.statusCode ? ` (${err.code ?? err.statusCode})` : "";
+			const output = [];
+			if (err.message) output.push(this.textFormat(`${err.constructor.name}${code}: ${err.message}`, chalk.bgRed, preserveCol));
+			if (err.stack) output.push("    " + chalk.white(err.stack.replace(`${err.name}: ${err.message}`, "").trim()));
+			return output.join("\n");
+		}
+		if (Array.isArray(txt)) return txt.map((e) => this.textFormat(e, color, preserveCol)).join("\n");
+		if (typeof txt === "object") return this.textFormat(Object.values(txt), color, preserveCol);
+		if (typeof txt !== "string") return color(txt);
 		const str = String(txt);
 		if (preserveCol) return str;
 		const [first, ...rest] = str.split(":");
@@ -262,9 +458,129 @@ var Logger = class Logger {
 		if (typeof config === "string") {
 			const conf = [[config, joiner]];
 			return this.parse(conf, "", log, sc);
-		} else if (config) return this.parse(config, String(joiner), log, sc);
+		} else if (Array.isArray(config)) return this.parse(config, String(joiner), log, sc);
+		else if (log && !this.shouldSuppressOutput("line")) return console.log(this.textFormat(config, Logger.chalker(["blue"])));
 		return this;
 	});
+	/**
+	* A simple console like output logger
+	* 
+	* @returns 
+	*/
+	static console() {
+		return Console;
+	}
+};
+
+//#endregion
+//#region src/Utils/Console.ts
+var Console = class {
+	static log = (...args) => Logger.log(args.map((e) => [e, "white"]));
+	static debug = (...args) => Logger.debug(args, false, true);
+	static warn = (...args) => args.map((e) => Logger.warn(e, false, true));
+	static info = (...args) => args.map((e) => Logger.info(e, false, true));
+	static error = (...args) => args.map((e) => Logger.error(e, false), true);
+};
+
+//#endregion
+//#region src/Utils/EnvParser.ts
+var EnvParser = class {
+	static parse(initial) {
+		const parsed = { ...initial };
+		for (const key in parsed) {
+			const value = parsed[key];
+			parsed[key] = this.parseValue(value);
+		}
+		return parsed;
+	}
+	static parseValue(value) {
+		/**
+		* Null/undefined stay untouched 
+		*/
+		if (value === null || value === void 0) return value;
+		/**
+		* Convert string "true"/"false" to boolean 
+		*/
+		if (value === "true") return true;
+		if (value === "false") return false;
+		/**
+		*  Convert string numbers to number 
+		*/
+		if (!isNaN(value) && value.trim() !== "") return Number(value);
+		/**
+		* Convert string "null" and "undefined"
+		*/
+		if (value === "null") return null;
+		if (value === "undefined") return void 0;
+		/**
+		* Otherwise return as-is (string)
+		*/
+		return value;
+	}
+};
+
+//#endregion
+//#region src/Utils/FileSystem.ts
+var FileSystem = class {
+	static findModulePkg(moduleId, cwd) {
+		const parts = moduleId.replace(/\\/g, "/").split("/");
+		let packageName = "";
+		if (parts.length > 0 && parts[0][0] === "@") packageName += parts.shift() + "/";
+		packageName += parts.shift();
+		const packageJson = path.join(cwd ?? process.cwd(), "node_modules", packageName);
+		const resolved = this.resolveFileUp("package", ["json"], packageJson);
+		if (!resolved) return;
+		return path.join(path.dirname(resolved), parts.join("/"));
+	}
+	/**
+	* Check if file exists
+	* 
+	* @param path 
+	* @returns 
+	*/
+	static async fileExists(path$1) {
+		try {
+			await access(path$1);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Recursively find files starting from given cwd
+	* 
+	* @param name 
+	* @param extensions 
+	* @param cwd 
+	* 
+	* @returns 
+	*/
+	static resolveFileUp(name, extensions, cwd) {
+		cwd ??= process.cwd();
+		return escalade(cwd, (dir, filesNames) => {
+			if (typeof extensions === "function") return extensions(dir, filesNames);
+			const candidates = new Set(extensions.map((ext) => `${name}.${ext}`));
+			for (const filename of filesNames) if (candidates.has(filename)) return filename;
+			return false;
+		}) ?? void 0;
+	}
+	/**
+	* Recursively find files starting from given cwd
+	* 
+	* @param name 
+	* @param extensions 
+	* @param cwd 
+	* 
+	* @returns 
+	*/
+	static resolveModulePath(moduleId, pathName, cwd) {
+		pathName = Array.isArray(pathName) ? pathName : [pathName];
+		const module = this.findModulePkg(moduleId, cwd) ?? "";
+		for (const name of pathName) {
+			const file = path.join(module, name);
+			if (existsSync(file)) return file;
+		}
+	}
 };
 
 //#endregion
@@ -278,7 +594,8 @@ var PathLoader = class {
 		config: "/src/config",
 		public: "/public",
 		storage: "/storage",
-		database: "/src/database"
+		database: "/src/database",
+		commands: "/src/App/Console/Commands/"
 	};
 	/**
 	* Dynamically retrieves a path property from the class.
@@ -307,6 +624,11 @@ var PathLoader = class {
 		if (base && name !== "base") this.paths[name] = path.join(base, path$1);
 		this.paths[name] = path$1;
 	}
+	distPath(path$1, skipExt = false) {
+		path$1 = path$1.replace("/src/", `/${process.env.DIST_DIR ?? "src"}/`.replace(/([^:]\/)\/+/g, "$1"));
+		if (!skipExt) path$1 = path$1.replace(/\.(ts|tsx|mts|cts)$/, ".js");
+		return path.normalize(path$1);
+	}
 };
 
 //#endregion
@@ -426,7 +748,7 @@ const mainTsconfig = {
 		},
 		target: "es2022",
 		module: "es2022",
-		moduleResolution: "Node",
+		moduleResolution: "bundler",
 		esModuleInterop: true,
 		strict: true,
 		allowJs: true,
@@ -496,5 +818,5 @@ var TaskManager = class {
 };
 
 //#endregion
-export { EnvParser, FileSystem, Logger, PathLoader, Prompts, Resolver, TaskManager, baseTsconfig, mainTsconfig, packageJsonScript };
+export { Console, EnvParser, FileSystem, Finalizable, INTERNAL_METHODS, Logger, Magic, PathLoader, Prompts, Resolver, TaskManager, UseMagic, baseTsconfig, crc32, mainTsconfig, makeMagic, makeStaticMagic, mix, packageJsonScript, trait, use, uses };
 //# sourceMappingURL=index.js.map