@prostojs/mate 0.4.0 → 0.5.1

package/dist/index.cjs

@@ -1,11 +1,44 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
+//#region src/module-identity.ts
+const MATE_MODULE_IDENTITY_KEY = Symbol.for("prostojs:mate:module-identity");
+function getModulePath() {
+	try {
+		return require("url").pathToFileURL(__filename).href;
+	} catch {
+		return;
+	}
+}
+function formatIdentity(identity) {
+	const version = identity.version ? `v${identity.version}` : "unknown version";
+	return identity.path ? `${version} at ${identity.path}` : version;
+}
+/**
+* Stamps `globalThis` with this copy's identity and warns if another
+* copy of @prostojs/mate was already loaded.
+*
+* Invoked once at module scope from index.ts, so importing the package
+* performs the check.
+*/
+function warnOnDuplicateMate() {
+	const g = globalThis;
+	const identity = {};
+	identity.version = "0.5.0";
+	const path = getModulePath();
+	if (path) identity.path = path;
+	const first = g[MATE_MODULE_IDENTITY_KEY];
+	if (first) console.warn(`[mate] A second copy of @prostojs/mate was loaded (${formatIdentity(first)}, now ${formatIdentity(identity)}). Decorator metadata is stored per-copy and will NOT be visible across copies. Check your bundler/dedupe settings.`);
+	else g[MATE_MODULE_IDENTITY_KEY] = identity;
+}
+
+//#endregion
 //#region src/utils/helpers.ts
+const hasOwn = Object.prototype.hasOwnProperty;
 function getConstructor(instance) {
 	return isConstructor(instance) ? instance : instance.constructor ? instance.constructor : Object.getPrototypeOf(instance).constructor;
 }
 function isConstructor(v) {
-	return typeof v === "function" && Object.getOwnPropertyDescriptor(v, "prototype") !== void 0 && Object.getOwnPropertyDescriptor(v, "caller") === void 0 && !!v.name;
+	return typeof v === "function" && hasOwn.call(v, "prototype") && !hasOwn.call(v, "caller") && !!v.name;
 }
 
 //#endregion
@@ -76,9 +109,11 @@ var Mate = class {
 	_cleanup() {
 		Reflect._cleanup?.call(Reflect);
 		this._readCache = void 0;
+		this._readCacheNonCtor = void 0;
 	}
 	set(args, key, value, isArray) {
 		this._readCache = void 0;
+		this._readCacheNonCtor = void 0;
 		let level = "CLASS";
 		const newArgs = args.level === "CLASS" ? { target: getConstructor(args.target) } : args.level === "PROP" ? {
 			target: args.target,
@@ -124,11 +159,19 @@ var Mate = class {
 		Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
 	}
 	read(target, propKey) {
-		const constructor = isConstructor(target) ? target : getConstructor(target);
-		const proto = constructor.prototype;
 		const propKeyStr = propKey;
-		const ctorCache = this._readCache?.get(constructor);
-		if (ctorCache?.has(propKeyStr)) return ctorCache.get(propKeyStr);
+		const ctorCacheRoot = this._readCache;
+		if (ctorCacheRoot !== void 0 && typeof target === "function") {
+			const hit = readCached(ctorCacheRoot.get(target), propKeyStr);
+			if (hit !== MISS) return hit;
+		}
+		const isConstr = isConstructor(target);
+		const constructor = isConstr ? target : getConstructor(target);
+		if (!isConstr) {
+			const hit = readCached(ctorCacheRoot?.get(constructor) ?? this._readCacheNonCtor?.get(constructor), propKeyStr);
+			if (hit !== MISS) return hit;
+		}
+		const proto = constructor.prototype;
 		let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === "string" ? proto : constructor, propKey);
 		if (ownMeta && propKey === void 0 && ownMeta.params === void 0) {
 			const parent = Object.getPrototypeOf(constructor);
@@ -160,7 +203,7 @@ var Mate = class {
 				}
 			}
 		}
-		const cache = this._readCache ??= /* @__PURE__ */ new WeakMap();
+		const cache = isConstr || typeof constructor !== "function" || isConstructor(constructor) ? this._readCache ??= /* @__PURE__ */ new WeakMap() : this._readCacheNonCtor ??= /* @__PURE__ */ new WeakMap();
 		let tc = cache.get(constructor);
 		if (!tc) {
 			tc = /* @__PURE__ */ new Map();
@@ -197,8 +240,20 @@ var Mate = class {
 	}
 };
 const fnProto = Object.getPrototypeOf(Function);
+const MISS = Symbol("mate.read.miss");
+function readCached(tc, propKey) {
+	if (tc === void 0) return MISS;
+	const v = tc.get(propKey);
+	return v !== void 0 || tc.has(propKey) ? v : MISS;
+}
+
+//#endregion
+//#region src/index.ts
+warnOnDuplicateMate();
 
 //#endregion
+exports.MATE_MODULE_IDENTITY_KEY = MATE_MODULE_IDENTITY_KEY;
 exports.Mate = Mate;
 exports.getConstructor = getConstructor;
-exports.isConstructor = isConstructor;
+exports.isConstructor = isConstructor;
+exports.warnOnDuplicateMate = warnOnDuplicateMate;

package/dist/index.d.ts

@@ -46,7 +46,19 @@ declare class Mate<TClass extends TObject = TMateClassMeta<TMateParamMeta>, TPro
   protected workspace: string;
   protected options: TMateOptions<TClass, TProp>;
   protected logger: TConsoleBase;
+  /**
+   * Read cache keyed by the resolved constructor. Invariant: every function
+   * key here passed `isConstructor` when stored, so a hit on a function
+   * `target` itself proves `target` is that constructor — `read` probes
+   * it before running `isConstructor`.
+   */
   protected _readCache?: WeakMap<object, Map<string | undefined, unknown>>;
+  /**
+   * Read cache for resolved "constructors" that are functions failing
+   * `isConstructor` (e.g. an anonymous class reached through an instance's
+   * `.constructor`). Kept apart so they cannot satisfy the fast probe.
+   */
+  protected _readCacheNonCtor?: WeakMap<object, Map<string | undefined, unknown>>;
   constructor(workspace: string, options?: TMateOptions<TClass, TProp>);
   /**
    * Cleanup function to reset metadata
@@ -70,8 +82,33 @@ declare class Mate<TClass extends TObject = TMateClassMeta<TMateParamMeta>, TPro
 }
 type ArrayElementType<T> = T extends (infer E)[] ? E : never;
 //#endregion
+//#region dts-build/module-identity.d.ts
+/**
+ * Duplicate-copy detection for @prostojs/mate
+ *
+ * Mate stores class metadata in WeakMaps keyed by constructor reference.
+ * If a bundler loads two copies of mate (or of a decorated class),
+ * decorators run against one copy while lookups hit the other, and
+ * metadata silently "disappears". The first loaded copy stamps
+ * `globalThis` under a global symbol; any subsequent copy finds the
+ * stamp and warns.
+ */
+interface TMateModuleIdentity {
+  version?: string;
+  path?: string;
+}
+declare const MATE_MODULE_IDENTITY_KEY: unique symbol;
+/**
+ * Stamps `globalThis` with this copy's identity and warns if another
+ * copy of @prostojs/mate was already loaded.
+ *
+ * Invoked once at module scope from index.ts, so importing the package
+ * performs the check.
+ */
+declare function warnOnDuplicateMate(): void;
+//#endregion
 //#region dts-build/utils/helpers.d.ts
 declare function getConstructor<T = TAny>(instance: T): TFunction;
 declare function isConstructor<T = TAny>(v: T): v is T & TClassConstructor;
 //#endregion
-export { Mate, TMateClassMeta, TMateOptions, TMateParamMeta, TMatePropMeta, TMergedDecoratorArgs, getConstructor, isConstructor };
+export { MATE_MODULE_IDENTITY_KEY, Mate, TMateClassMeta, TMateModuleIdentity, TMateOptions, TMateParamMeta, TMatePropMeta, TMergedDecoratorArgs, getConstructor, isConstructor, warnOnDuplicateMate };

package/dist/index.mjs

@@ -1,9 +1,42 @@
+//#region src/module-identity.ts
+const MATE_MODULE_IDENTITY_KEY = Symbol.for("prostojs:mate:module-identity");
+function getModulePath() {
+	try {
+		return import.meta.url;
+	} catch {
+		return;
+	}
+}
+function formatIdentity(identity) {
+	const version = identity.version ? `v${identity.version}` : "unknown version";
+	return identity.path ? `${version} at ${identity.path}` : version;
+}
+/**
+* Stamps `globalThis` with this copy's identity and warns if another
+* copy of @prostojs/mate was already loaded.
+*
+* Invoked once at module scope from index.ts, so importing the package
+* performs the check.
+*/
+function warnOnDuplicateMate() {
+	const g = globalThis;
+	const identity = {};
+	identity.version = "0.5.0";
+	const path = getModulePath();
+	if (path) identity.path = path;
+	const first = g[MATE_MODULE_IDENTITY_KEY];
+	if (first) console.warn(`[mate] A second copy of @prostojs/mate was loaded (${formatIdentity(first)}, now ${formatIdentity(identity)}). Decorator metadata is stored per-copy and will NOT be visible across copies. Check your bundler/dedupe settings.`);
+	else g[MATE_MODULE_IDENTITY_KEY] = identity;
+}
+
+//#endregion
 //#region src/utils/helpers.ts
+const hasOwn = Object.prototype.hasOwnProperty;
 function getConstructor(instance) {
 	return isConstructor(instance) ? instance : instance.constructor ? instance.constructor : Object.getPrototypeOf(instance).constructor;
 }
 function isConstructor(v) {
-	return typeof v === "function" && Object.getOwnPropertyDescriptor(v, "prototype") !== void 0 && Object.getOwnPropertyDescriptor(v, "caller") === void 0 && !!v.name;
+	return typeof v === "function" && hasOwn.call(v, "prototype") && !hasOwn.call(v, "caller") && !!v.name;
 }
 
 //#endregion
@@ -74,9 +107,11 @@ var Mate = class {
 	_cleanup() {
 		Reflect._cleanup?.call(Reflect);
 		this._readCache = void 0;
+		this._readCacheNonCtor = void 0;
 	}
 	set(args, key, value, isArray) {
 		this._readCache = void 0;
+		this._readCacheNonCtor = void 0;
 		let level = "CLASS";
 		const newArgs = args.level === "CLASS" ? { target: getConstructor(args.target) } : args.level === "PROP" ? {
 			target: args.target,
@@ -122,11 +157,19 @@ var Mate = class {
 		Reflect.defineMetadata(this.workspace, meta, newArgs.target, newArgs.propKey);
 	}
 	read(target, propKey) {
-		const constructor = isConstructor(target) ? target : getConstructor(target);
-		const proto = constructor.prototype;
 		const propKeyStr = propKey;
-		const ctorCache = this._readCache?.get(constructor);
-		if (ctorCache?.has(propKeyStr)) return ctorCache.get(propKeyStr);
+		const ctorCacheRoot = this._readCache;
+		if (ctorCacheRoot !== void 0 && typeof target === "function") {
+			const hit = readCached(ctorCacheRoot.get(target), propKeyStr);
+			if (hit !== MISS) return hit;
+		}
+		const isConstr = isConstructor(target);
+		const constructor = isConstr ? target : getConstructor(target);
+		if (!isConstr) {
+			const hit = readCached(ctorCacheRoot?.get(constructor) ?? this._readCacheNonCtor?.get(constructor), propKeyStr);
+			if (hit !== MISS) return hit;
+		}
+		const proto = constructor.prototype;
 		let ownMeta = Reflect.getOwnMetadata(this.workspace, typeof propKey === "string" ? proto : constructor, propKey);
 		if (ownMeta && propKey === void 0 && ownMeta.params === void 0) {
 			const parent = Object.getPrototypeOf(constructor);
@@ -158,7 +201,7 @@ var Mate = class {
 				}
 			}
 		}
-		const cache = this._readCache ??= /* @__PURE__ */ new WeakMap();
+		const cache = isConstr || typeof constructor !== "function" || isConstructor(constructor) ? this._readCache ??= /* @__PURE__ */ new WeakMap() : this._readCacheNonCtor ??= /* @__PURE__ */ new WeakMap();
 		let tc = cache.get(constructor);
 		if (!tc) {
 			tc = /* @__PURE__ */ new Map();
@@ -195,6 +238,16 @@ var Mate = class {
 	}
 };
 const fnProto = Object.getPrototypeOf(Function);
+const MISS = Symbol("mate.read.miss");
+function readCached(tc, propKey) {
+	if (tc === void 0) return MISS;
+	const v = tc.get(propKey);
+	return v !== void 0 || tc.has(propKey) ? v : MISS;
+}
+
+//#endregion
+//#region src/index.ts
+warnOnDuplicateMate();
 
 //#endregion
-export { Mate, getConstructor, isConstructor };
+export { MATE_MODULE_IDENTITY_KEY, Mate, getConstructor, isConstructor, warnOnDuplicateMate };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@prostojs/mate",
-    "version": "0.4.0",
+    "version": "0.5.1",
     "description": "MATE is TS Metadata Organizer",
     "keywords": [
         "decorators",