@h3ravel/shared 0.27.6 → 0.28.0

package/dist/index.cjs

@@ -6,12 +6,16 @@ var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __copyProps = (to, from, except, desc) => {
-	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-		key = keys[i];
-		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
-			get: ((k) => from[k]).bind(null, key),
-			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-		});
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
 	}
 	return to;
 };
@@ -21,13 +25,14 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+let chalk = require("chalk");
+chalk = __toESM(chalk);
 let fs_promises = require("fs/promises");
 let escalade_sync = require("escalade/sync");
 escalade_sync = __toESM(escalade_sync);
+let fs = require("fs");
 let path = require("path");
 path = __toESM(path);
-let chalk = require("chalk");
-chalk = __toESM(chalk);
 let inquirer_autocomplete_standalone = require("inquirer-autocomplete-standalone");
 inquirer_autocomplete_standalone = __toESM(inquirer_autocomplete_standalone);
 let __inquirer_prompts = require("@inquirer/prompts");
@@ -36,88 +41,272 @@ crypto = __toESM(crypto);
 let preferred_pm = require("preferred-pm");
 preferred_pm = __toESM(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.default.join(cwd ?? process.cwd(), "node_modules", packageName);
-		const resolved = this.resolveFileUp("package", ["json"], packageJson);
-		if (!resolved) return;
-		return path.default.join(path.default.dirname(resolved), parts.join("/"));
-	}
-	/**
-	* Check if file exists
-	* 
-	* @param path 
-	* @returns 
-	*/
-	static async fileExists(path$2) {
-		try {
-			await (0, fs_promises.access)(path$2);
-			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 (0, escalade_sync.default)(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
@@ -195,6 +384,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.default.bgRed, preserveCol));
+			if (err.stack) output.push("    " + chalk.default.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(":");
@@ -291,9 +491,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.default.join(cwd ?? process.cwd(), "node_modules", packageName);
+		const resolved = this.resolveFileUp("package", ["json"], packageJson);
+		if (!resolved) return;
+		return path.default.join(path.default.dirname(resolved), parts.join("/"));
+	}
+	/**
+	* Check if file exists
+	* 
+	* @param path 
+	* @returns 
+	*/
+	static async fileExists(path$2) {
+		try {
+			await (0, fs_promises.access)(path$2);
+			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 (0, escalade_sync.default)(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$1 = this.findModulePkg(moduleId, cwd) ?? "";
+		for (const name of pathName) {
+			const file = path.default.join(module$1, name);
+			if ((0, fs.existsSync)(file)) return file;
+		}
+	}
 };
 
 //#endregion
@@ -307,7 +627,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.
@@ -336,6 +657,11 @@ var PathLoader = class {
 		if (base && name !== "base") this.paths[name] = path.default.join(base, path$2);
 		this.paths[name] = path$2;
 	}
+	distPath(path$2, skipExt = false) {
+		path$2 = path$2.replace("/src/", `/${process.env.DIST_DIR ?? "src"}/`.replace(/([^:]\/)\/+/g, "$1"));
+		if (!skipExt) path$2 = path$2.replace(/\.(ts|tsx|mts|cts)$/, ".js");
+		return path.default.normalize(path$2);
+	}
 };
 
 //#endregion
@@ -455,7 +781,7 @@ const mainTsconfig = {
 		},
 		target: "es2022",
 		module: "es2022",
-		moduleResolution: "Node",
+		moduleResolution: "bundler",
 		esModuleInterop: true,
 		strict: true,
 		allowJs: true,
@@ -525,14 +851,26 @@ var TaskManager = class {
 };
 
 //#endregion
+exports.Console = Console;
 exports.EnvParser = EnvParser;
 exports.FileSystem = FileSystem;
+exports.Finalizable = Finalizable;
+exports.INTERNAL_METHODS = INTERNAL_METHODS;
 exports.Logger = Logger;
+exports.Magic = Magic;
 exports.PathLoader = PathLoader;
 exports.Prompts = Prompts;
 exports.Resolver = Resolver;
 exports.TaskManager = TaskManager;
+exports.UseMagic = UseMagic;
 exports.baseTsconfig = baseTsconfig;
+exports.crc32 = crc32;
 exports.mainTsconfig = mainTsconfig;
+exports.makeMagic = makeMagic;
+exports.makeStaticMagic = makeStaticMagic;
+exports.mix = mix;
 exports.packageJsonScript = packageJsonScript;
+exports.trait = trait;
+exports.use = use;
+exports.uses = uses;
 //# sourceMappingURL=index.cjs.map