Bugfix: clone internal object references

Author: dpimonov

CHANGELOG.md

@@ -5,6 +5,12 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [8.1.1] - 2025-06-02
+
+### Fixed
+
+- Clone of internal object references.
+
 ## [8.1.0] - 2025-06-01
 
 ### Added

spec/type-manager.spec.ts

@@ -55,11 +55,7 @@ describe('Type manager', () =>
 
     it('should deserialize type when object is provided and vice versa', () =>
     {
-        const messageManager = new TypeManager();
-
-        messageManager.applyTypeOptionsBase(TypeManager.typeOptionsBase);
-        messageManager.applyTypeOptionsMap(new Map(Array.from(TypeManager.typeOptionsMap)));
-
+        const messageManager = TypeManager.clone();
         const baseObject = { body: 'a', label: 'b', user: { username: 'a', email: 'b', description: null, about: 'g', device: 'h' }, groups: [{ title: 'a' }, { title: 'a' }] };
         const baseObjects = [baseObject, baseObject];
         const entity = messageManager.deserialize(Message, baseObject);
@@ -157,11 +153,7 @@ describe('Type manager', () =>
 
     it('should use base type default value when it is enabled', () =>
     {
-        const groupManager = new TypeManager();
-
-        groupManager.applyTypeOptionsBase(TypeManager.typeOptionsBase);
-        groupManager.applyTypeOptionsMap(new Map(Array.from(TypeManager.typeOptionsMap)));
-
+        const groupManager = TypeManager.clone();
         const baseObject = { title: 'a' };
         const entity = groupManager.deserialize(Group, baseObject);
 
@@ -180,11 +172,7 @@ describe('Type manager', () =>
 
     it('should produce the same result for serialization functions', () =>
     {
-        const groupManager = new TypeManager();
-
-        groupManager.applyTypeOptionsBase(TypeManager.typeOptionsBase);
-        groupManager.applyTypeOptionsMap(new Map(Array.from(TypeManager.typeOptionsMap)));
-
+        const groupManager = TypeManager.clone();
         const baseObject = { title: 'a' };
         const entityA = groupManager.deserialize(Group, baseObject);
         const entityB = groupManager.parse(Group, groupManager.stringify(Group, baseObject)) as Group;
@@ -229,10 +217,7 @@ describe('Type manager', () =>
 
     it('should preserve provided configuration', () =>
     {
-        const groupManager = new TypeManager();
-
-        groupManager.applyTypeOptionsBase(TypeManager.typeOptionsBase);
-        groupManager.applyTypeOptionsMap(new Map(Array.from(TypeManager.typeOptionsMap)));
+        const groupManager = TypeManager.clone();
 
         groupManager.applyTypeOptionsBase({
             preserveDiscriminator: true,
@@ -309,6 +294,7 @@ describe('Type manager', () =>
         expect(groupMetadata.typeFn.prototype[TypeManager.symbol]).toBeDefined();
         expect(groupMetadata.typeFn.prototype[groupManager.symbol]).toBeUndefined();
         expect(TypeManager.typeOptionsMap.size).toBeGreaterThan(0);
-        expect(groupManager.typeOptionsMap.size).toBe(0);
+        expect(groupManager.typeOptionsMap.size).toBeGreaterThan(0);
+        expect(groupManager.typeOptionsMap.size).toBe(TypeManager.typeOptionsMap.size);
     });
 });

src/type-manager.ts

@@ -7,9 +7,13 @@ import { TypeFactory } from './factories/type-factory';
 import { jsonParse } from './functions/json-parse';
 import { jsonStringify } from './functions/json-stringify';
 import { GenericArgument } from './generic-argument';
+import { InjectIndex } from './inject-index';
+import { InjectOptions } from './inject-options';
 import { SingletonInjector } from './injectors/singleton-injector';
 import { Logger } from './logger';
 import { LoggerLevel } from './logger-level';
+import { PropertyName } from './property-name';
+import { PropertyOptions } from './property-options';
 import { ReferenceCallback } from './reference-callback';
 import { CircularReferenceHandler } from './reference-handlers/circular-reference-handler';
 import { ReferenceKey } from './reference-key';
@@ -754,14 +758,112 @@ export class TypeManager
      */
     public clone(): TypeManager
     {
-        const typeOptionsBase = Object.assign({}, this.typeOptionsBase);
-        const typeOptionsMap = new Map(Array.from(this.typeOptionsMap));
+        const typeOptionsBase = this.cloneTypeOptionsBase();
+        const typeOptionsMap = this.cloneTypeOptionsMap();
         const typeManagerOptions = { typeOptionsBase: typeOptionsBase, typeOptionsMap: typeOptionsMap };
         const typeManager = new TypeManager(typeManagerOptions);
 
         return typeManager;
     }
 
+    /**
+     * Creates a clone of type options base.
+     * 
+     * @returns {TypeOptionsBase<any>} Type options base clone.
+     */
+    private cloneTypeOptionsBase(): TypeOptionsBase<any>
+    {
+        const typeOptionsBase = this.typeOptionsBase;
+        const customValueMap = typeOptionsBase.customValueMap;
+        const customValueMapClone = new Map<CustomKey<any>, CustomValue>();
+        const typeOptionsBaseClone = Object.assign({}, typeOptionsBase, { customValueMap: customValueMapClone });
+
+        for (const [customKey, customValue] of customValueMap)
+        {
+            customValueMapClone.set(customKey, customValue);
+        }
+
+        return typeOptionsBaseClone;
+    }
+
+    /**
+     * Creates a clone of type options map.
+     * 
+     * @returns {Map<TypeFn<any>, TypeOptions<any>>} Type options map clone.
+     */
+    private cloneTypeOptionsMap(): Map<TypeFn<any>, TypeOptions<any>>
+    {
+        const typeOptionsMap = this.typeOptionsMap;
+        const typeOptionsMapClone = new Map<TypeFn<any>, TypeOptions<any>>();
+
+        for (const [typeFn, typeOptions] of typeOptionsMap)
+        {
+            const typeOptionsClone = Object.assign({}, typeOptions);
+            const typeCustomValueMap = typeOptions.customValueMap;
+
+            if (typeCustomValueMap !== undefined)
+            {
+                const typeCustomValueMapClone = new Map<CustomKey<any>, CustomValue>();
+
+                for (const [customKey, customValue] of typeCustomValueMap)
+                {
+                    typeCustomValueMapClone.set(customKey, customValue);
+                }
+
+                typeOptionsClone.customValueMap = typeCustomValueMapClone;
+            }
+
+            const propertyOptionsMap = typeOptions.propertyOptionsMap;
+
+            if (propertyOptionsMap !== undefined)
+            {
+                const propertyOptionsMapClone = new Map<PropertyName, PropertyOptions<any>>();
+
+                for (const [propertyName, propertyOptions] of propertyOptionsMap)
+                {
+                    const propertyOptionsClone = Object.assign({}, propertyOptions);
+                    const propertyCustomValueMap = propertyOptions.customValueMap;
+
+                    if (propertyCustomValueMap !== undefined)
+                    {
+                        const propertyCustomValueMapClone = new Map<CustomKey<any>, CustomValue>();
+
+                        for (const [customKey, customValue] of propertyCustomValueMap)
+                        {
+                            propertyCustomValueMapClone.set(customKey, customValue);
+                        }
+
+                        propertyOptionsClone.customValueMap = propertyCustomValueMapClone;
+                    }
+
+                    propertyOptionsMapClone.set(propertyName, propertyOptionsClone);
+                }
+
+                typeOptionsClone.propertyOptionsMap = propertyOptionsMapClone;
+            }
+
+            const injectOptionsMap = typeOptions.injectOptionsMap;
+
+            if (injectOptionsMap !== undefined)
+            {
+                const injectOptionsMapClone = new Map<InjectIndex, InjectOptions<any>>();
+
+                for (const [injectIndex, injectOptions] of injectOptionsMap)
+                {
+                    const injectOptionsClone = Object.assign({}, injectOptions);
+
+                    injectOptionsMapClone.set(injectIndex, injectOptionsClone);
+                }
+
+                typeOptionsClone.injectOptionsMap = injectOptionsMapClone;
+            }
+
+            typeOptionsMapClone.set(typeFn, typeOptionsClone);
+        }
+
+        return typeOptionsMapClone;
+    }
+
     /**
      * Clears all type registrations from the static type manager. After calling this 
      * method, the static type manager will no longer hold any registered type metadata.
@@ -795,21 +897,6 @@ export class TypeManager
         typeMetadataSet.clear();
         typeFnMap.clear();
 
-        const typeManagerOptions = this.typeManagerOptions;
-        const typeOptionsMap = typeManagerOptions.typeOptionsMap;
-
-        if (typeOptionsMap !== undefined)
-        {
-            typeOptionsMap.clear();
-        }
-
-        const typeConfigurationMap = typeManagerOptions.typeConfigurationMap;
-
-        if (typeConfigurationMap !== undefined)
-        {
-            typeConfigurationMap.clear();
-        }
-        
         return this;
     }