@arkstack/common 0.12.16 → 0.12.18

package/dist/index.js

@@ -1,4 +1,4 @@
-import { C as nodeEnv, S as interopDefault, _ as CONFIG_KEY, a as abort, b as env, c as getModel, d as perPage, f as RequestException, g as Encryption, h as Hash, l as initializeGlobalContext, m as Exception, o as abortIf, p as AppException, s as assertFound, u as isClass, v as appUrl, w as outputDir, x as importFile, y as config } from "./utils-CMuDt6cA.js";
+import { C as importFile, E as outputDir, S as env, T as nodeEnv, _ as Hash, b as appUrl, c as abortIf, d as initializeGlobalContext, f as isClass, g as Exception, h as AppException, l as assertFound, m as RequestException, p as perPage, s as abort, u as getModel, v as Encryption, w as interopDefault, x as config, y as CONFIG_KEY } from "./utils-Y1a3rhA3.js";
 import { Hook as Hook$1 } from "@arkstack/foundry";
 import { str } from "@h3ravel/support";
 import { Arkstack } from "@arkstack/contract";

package/dist/utils/index.d.ts

@@ -134,13 +134,40 @@ type DeriveTraitsStats<T extends ((Trait | TypeFactory<Trait>)[] | [...(Trait |
  * utility type: derive type from one or more traits or trait type factories
  */
 type DeriveTraits<T extends ((Trait | TypeFactory<Trait>)[] | [...(Trait | TypeFactory<Trait>)[], DirectBase])> = DeriveTraitsCons<T> & DeriveTraitsStats<T>;
+type TraitMethodHelpers = {
+  getTraitMethods: <T extends TraitMethod = TraitMethod>(name: PropertyKey) => T[];
+  callTraitMethods: <T = any>(name: PropertyKey, ...args: any[]) => T[];
+};
+type DeriveTraitsWithMethodHelpers<T extends ((Trait | TypeFactory<Trait>)[] | [...(Trait | TypeFactory<Trait>)[], DirectBase])> = DeriveTraits<T> extends (new (...args: infer Args) => infer Instance) ? (new (...args: Args) => Instance & TraitMethodHelpers) & Omit<DeriveTraits<T>, 'prototype'> & TraitMethodHelpers : never;
+type TraitMethod = (...args: any[]) => any;
+/**
+ * Return every trait implementation for a method, bound to the supplied
+ * instance or class. Methods are ordered from the base implementation to the
+ * currently active trait implementation.
+ *
+ * @param target
+ * @param name
+ * @returns
+ */
+declare const getTraitMethods: <T extends TraitMethod = TraitMethod>(target: object | Cons, name: PropertyKey) => T[];
+/**
+ * Invoke every trait implementation for a method in registration order.
+ *
+ * @param target
+ * @param name
+ * @param args
+ * @returns
+ */
+declare const callTraitMethods: <T = any>(target: object | Cons, name: PropertyKey, ...args: any[]) => T[];
+type UsableTraits = ([Trait | TypeFactory<Trait>, ...(Trait | TypeFactory<Trait>)[]] | [...(Trait | TypeFactory<Trait>)[], DirectBase]);
 /**
  * API: derive a class from one or more traits or trait type factories
  *
  * @param traits
  * @returns
  */
-declare function use<T extends ([Trait | TypeFactory<Trait>, ...(Trait | TypeFactory<Trait>)[]] | [...(Trait | TypeFactory<Trait>)[], DirectBase])>(...traits: T): DeriveTraits<T>;
+declare function use<T extends UsableTraits>(withMethodHelpers: true, ...traits: T): DeriveTraitsWithMethodHelpers<T>;
+declare function use<T extends UsableTraits>(...traits: T): DeriveTraits<T>;
 /**
  * internal type: implements trait type
  */
@@ -158,4 +185,4 @@ type Derived<T extends (Trait | TypeFactory<Trait> | Cons)> = T extends TypeFact
  */
 declare function uses<T extends (Trait | TypeFactory<Trait> | Cons)>(instance: unknown, trait: T): instance is Derived<T>;
 //#endregion
-export { AbstractModelConstructor, Derived, Encryption, Hash, ModelConstructor, ModelRegistry, Trait, abort, abortIf, assertFound, crc32, getModel, initializeGlobalContext, isClass, perPage, trait, use, uses };
+export { AbstractModelConstructor, Derived, Encryption, Hash, ModelConstructor, ModelRegistry, Trait, abort, abortIf, assertFound, callTraitMethods, crc32, getModel, getTraitMethods, initializeGlobalContext, isClass, perPage, trait, use, uses };

package/dist/utils/index.js

@@ -1,2 +1,2 @@
-import { a as abort, c as getModel, d as perPage, g as Encryption, h as Hash, i as uses, l as initializeGlobalContext, n as trait, o as abortIf, r as use, s as assertFound, t as crc32, u as isClass } from "../utils-CMuDt6cA.js";
-export { Encryption, Hash, abort, abortIf, assertFound, crc32, getModel, initializeGlobalContext, isClass, perPage, trait, use, uses };
+import { _ as Hash, a as use, c as abortIf, d as initializeGlobalContext, f as isClass, i as trait, l as assertFound, n as crc32, o as uses, p as perPage, r as getTraitMethods, s as abort, t as callTraitMethods, u as getModel, v as Encryption } from "../utils-Y1a3rhA3.js";
+export { Encryption, Hash, abort, abortIf, assertFound, callTraitMethods, crc32, getModel, getTraitMethods, initializeGlobalContext, isClass, perPage, trait, use, uses };

package/dist/{utils-CMuDt6cA.js → utils-Y1a3rhA3.js}

@@ -418,6 +418,75 @@ const extendProperties = (cons, field, value) => Object.defineProperty(cons, fie
 	enumerable: false,
 	writable: false
 });
+const traitMethodRegistry = Symbol("trait-method-registry");
+const cloneMethodRegistry = (target) => {
+	const registry = target[traitMethodRegistry];
+	return new Map([...registry?.entries() ?? []].map(([name, methods]) => [name, [...methods]]));
+};
+const registerMethodScope = (target, base, ignored) => {
+	const registry = cloneMethodRegistry(base);
+	for (const name of Reflect.ownKeys(target)) {
+		if (ignored.has(name)) continue;
+		const method = Object.getOwnPropertyDescriptor(target, name)?.value;
+		if (typeof method !== "function") continue;
+		const methods = registry.get(name);
+		const previous = base?.[name];
+		if (methods) {
+			if (methods.at(-1) !== method) methods.push(method);
+			registry.set(name, methods);
+		} else if (typeof previous === "function" && previous !== method) registry.set(name, [previous, method]);
+	}
+	Object.defineProperty(target, traitMethodRegistry, {
+		configurable: false,
+		enumerable: false,
+		value: registry,
+		writable: false
+	});
+};
+/**
+* Registers conflicting trait methods
+* 
+* @param classInstance 
+* @param baseClass 
+*/
+const registerTraitMethods = (classInstance, baseClass) => {
+	registerMethodScope(classInstance.prototype, baseClass.prototype, new Set(["constructor"]));
+	registerMethodScope(classInstance, baseClass, new Set([
+		"length",
+		"name",
+		"prototype",
+		"arguments",
+		"caller"
+	]));
+};
+/**
+* Return every trait implementation for a method, bound to the supplied
+* instance or class. Methods are ordered from the base implementation to the
+* currently active trait implementation.
+* 
+* @param target 
+* @param name 
+* @returns 
+*/
+const getTraitMethods = (target, name) => {
+	return (((typeof target === "function" ? target : Object.getPrototypeOf(target))?.[traitMethodRegistry])?.get(name) ?? []).map((method) => method.bind(target));
+};
+/**
+* Invoke every trait implementation for a method in registration order.
+* 
+* @param target 
+* @param name 
+* @param args 
+* @returns 
+*/
+const callTraitMethods = (target, name, ...args) => {
+	const methods = getTraitMethods(target, name);
+	if (methods.length === 0) {
+		console.warn(`No conflicting trait methods found for "${String(name)}".`);
+		return [];
+	}
+	return methods.map((method) => method(...args));
+};
 /**
 * utility function: get raw trait
 * 
@@ -429,21 +498,23 @@ const rawTrait = (x) => isTypeFactory(x) ? x() : x;
 * utility function: derive a trait
 * 
 * @param trait$ 
-* @param baseClz 
+* @param baseClass 
 * @param derived 
 * @returns 
 */
-const deriveTrait = (trait$, baseClz, derived) => {
+const deriveTrait = (trait$, baseClass, derived) => {
 	const trait = rawTrait(trait$);
-	let clz = baseClz;
+	let classInstance = baseClass;
 	if (!derived.has(trait.id)) {
 		derived.set(trait.id, true);
-		if (trait.superTraits !== void 0) for (const superTrait of reverseTraitList(trait.superTraits)) clz = deriveTrait(superTrait, clz, derived);
-		clz = trait.factory(clz);
-		extendProperties(clz, "id", crc32(trait.factory.toString()));
-		extendProperties(clz, trait.symbol, true);
+		if (trait.superTraits !== void 0) for (const superTrait of reverseTraitList(trait.superTraits)) classInstance = deriveTrait(superTrait, classInstance, derived);
+		const base = classInstance;
+		classInstance = trait.factory(classInstance);
+		registerTraitMethods(classInstance, base);
+		extendProperties(classInstance, "id", crc32(trait.factory.toString()));
+		extendProperties(classInstance, trait.symbol, true);
 	}
-	return clz;
+	return classInstance;
 };
 /**
 * utility function: get reversed trait list
@@ -452,30 +523,40 @@ const deriveTrait = (trait$, baseClz, derived) => {
 * @returns 
 */
 const reverseTraitList = (traits) => traits.slice().reverse();
-/**
-* API: derive a class from one or more traits or trait type factories
-* 
-* @param traits 
-* @returns 
-*/
-function use(...traits) {
+function use(...args) {
+	const withMethodHelpers = args[0] === true;
+	const traits = withMethodHelpers ? args.slice(1) : args;
 	if (traits.length === 0) throw new Error("invalid number of parameters (expected one or more traits)");
-	let clz;
+	let classInstance;
 	let lot;
 	const last = traits[traits.length - 1];
 	if (isCons(last) && !isTypeFactory(last)) {
-		clz = last;
+		classInstance = last;
 		lot = traits.slice(0, -1);
 	} else if (isArkormModelInstance(last)) {
-		clz = last.constructor;
+		classInstance = last.constructor;
 		lot = traits.slice(0, -1);
 	} else {
-		clz = class ROOT {};
+		classInstance = class ROOT {};
 		lot = traits;
 	}
 	const derived = /* @__PURE__ */ new Map();
-	for (const trait of reverseTraitList(lot)) clz = deriveTrait(trait, clz, derived);
-	return clz;
+	for (const trait of reverseTraitList(lot)) classInstance = deriveTrait(trait, classInstance, derived);
+	if (withMethodHelpers) classInstance = class TraitMethodEnabled extends classInstance {
+		getTraitMethods(name) {
+			return getTraitMethods(this, name);
+		}
+		callTraitMethods(name, ...args) {
+			return callTraitMethods(this, name, ...args);
+		}
+		static getTraitMethods(name) {
+			return getTraitMethods(this, name);
+		}
+		static callTraitMethods(name, ...args) {
+			return callTraitMethods(this, name, ...args);
+		}
+	};
+	return classInstance;
 }
 /**
 * API: type guard for checking whether class instance is derived from a trait
@@ -498,4 +579,4 @@ function uses(instance, trait) {
 	return false;
 }
 //#endregion
-export { nodeEnv as C, interopDefault as S, CONFIG_KEY as _, abort as a, env as b, getModel as c, perPage as d, RequestException as f, Encryption as g, Hash as h, uses as i, initializeGlobalContext as l, Exception as m, trait as n, abortIf as o, AppException as p, use as r, assertFound as s, crc32 as t, isClass as u, appUrl as v, outputDir as w, importFile as x, config as y };
+export { importFile as C, outputDir as E, env as S, nodeEnv as T, Hash as _, use as a, appUrl as b, abortIf as c, initializeGlobalContext as d, isClass as f, Exception as g, AppException as h, trait as i, assertFound as l, RequestException as m, crc32 as n, uses as o, perPage as p, getTraitMethods as r, abort as s, callTraitMethods as t, getModel as u, Encryption as v, interopDefault as w, config as x, CONFIG_KEY as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkstack/common",
-  "version": "0.12.16",
+  "version": "0.12.18",
   "type": "module",
   "description": "Core utilities, primitives, and shared infrastructure for the Arkstack ecosystem.",
   "homepage": "https://arkstack.toneflix.net",
@@ -41,9 +41,9 @@
   },
   "peerDependencies": {
     "@h3ravel/support": "^0.15.11",
-    "arkormx": "^ 2.5.0",
-    "@arkstack/foundry": "^0.12.16",
-    "@arkstack/contract": "^0.12.16"
+    "arkormx": "^2.5.2",
+    "@arkstack/foundry": "^0.12.18",
+    "@arkstack/contract": "^0.12.18"
   },
   "scripts": {
     "build": "tsdown --config-loader unrun",