@arkstack/common 0.12.16 → 0.12.17

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-DVFdK8BR.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,6 +134,26 @@ 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 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[];
 /**
  * API: derive a class from one or more traits or trait type factories
  *
@@ -158,4 +178,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-DVFdK8BR.js";
+export { Encryption, Hash, abort, abortIf, assertFound, callTraitMethods, crc32, getModel, getTraitMethods, initializeGlobalContext, isClass, perPage, trait, use, uses };

package/dist/{utils-CMuDt6cA.js → utils-DVFdK8BR.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
@@ -460,22 +531,22 @@ 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 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);
+	return classInstance;
 }
 /**
 * API: type guard for checking whether class instance is derived from a trait
@@ -498,4 +569,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.17",
   "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.17",
+    "@arkstack/contract": "^0.12.17"
   },
   "scripts": {
     "build": "tsdown --config-loader unrun",