mapper-factory 4.0.0 → 4.0.2

package/README.md

@@ -1,215 +1,215 @@
-# Mapper-Factory
-
-Mapper-Factory is a fully documented TypeScript library that provides a simple and easy-to-use way to map objects from one type to another. With just a few lines of code, you can convert complex, nested objects into the desired format.
-
-Work well on data structure and after enjoy the coding process :)
-
-## Installation
-
-To install the package, you can use npm by running the following command:
-
-```
-npm i mapper-factory
-```
-
-Or using yarn
-
-```
-yarn add mapper-factory
-```
-
-## Problem to solve
-
-We want to solve the problem to trasform a JSON object to a specific JS object adding custom properties, with integrated mapping. As example this JSON object:
-
-```
-{
-  firstName: 'Rick',
-  lastName: 'Sanchez',
-  employees: [
-    { firstName: 'Summer', lastName: 'Smith' },
-    { firstName: 'Morty', lastName: 'Smith' }
-  ],
-  rolesToMap: [ 'CEO', 'EMPLOYEE' ],
-  boss: { firstName: 'Jesus', lastName: 'Christ' }
-}
-```
-
-must became a JS object:
-
-```
-User {
-  name: 'Rick',
-  surname: 'Sanchez',
-  employees: [
-    User { name: 'Summer', surname: 'Smith' },
-    User { name: 'Morty', surname: 'Smith' }
-  ],
-  roles: [ 'CEO TEST TRASFORMER', 'EMPLOYEE TEST TRASFORMER' ],
-  boss: User { name: 'Jesus', surname: 'Christ' }
-  /** maybe some methods... */
-}
-```
-
-## Usage V2
-
-### Mapping simple objects
-
-Your class must use _MapClass_ decorator and set an interface that extends _MapInterface<T>_
-In this way your class could extend another, but continue using intellisense methods for YourClass
-
-```
-@MapClass()
-class YourClass extends YourCustomClassToExtend {
-    /** YOUR PROPERTIES  */
-}
-interface YourClass extends MapInterface<YourClass> { }
-```
-
-To get new _YourClass_ instance it's simple as always:
-
-```
-new YourClass();
-```
-
-but now you can easly mapping an object just using _MapInterface_ method _from_:
-
-```
-const yourInstance: YourClass = new YourClass().from(/** YOUR OBJECT TO MAP HERE*/);
-```
-
-and reverse your mapping using using _MapInterface_ method _toMap_:
-
-```
-const reversedMapping: Object = yourInstance.toMap();
-```
-
-With _MapInterface_ you can use on your class instance also other methods:
-
-- **_from_**: Create a new instance using model to map
-
-```
-const yourInstance: YourClass = new YourClass().from(/** YOUR OBJECT TO MAP HERE */);
-```
-
-- **_toMap_**: Create a JSON object using reverse mapping
-
-```
-const reverseMappedObject: Object = yourInstance.toMap();
-```
-
-- **_toModel_**: Create a new instance using same model of final JS object
-
-```
-const anotherInstance: YourClass = new YourClass.toModel(yourInstance);
-```
-
-- **_empty_**: Check if the object is empty
-
-```
-const isEmpty: boolean = yourInstance.empty();
-```
-
-- **_filled_**: Check if the object is filled
-
-```
-const isFilled: boolean = yourInstance.filled();
-```
-
-- **_get_**: Get specific property of the object
-
-```
-const specificProp: T = yourInstance.get('specificProp') as T;
-```
-
-- **_set_**: Set specific property of the object
-
-```
-yourInstance.set('specificProp', /** NEW VALUE FOR 'specificProp' */);
-```
-
-- **_copy_**: Deep copy of the object
-
-```
-const yourInstanceCopy: YourClass = yourInstance.copy();
-```
-
-After that, you can use _@MapField_ decorator over single property to specify the mapping. Let's dive into an example:
-
-```
-@MapClass()
-class User {
-
-    @MapField({
-        src: 'firstName'
-    })
-    name: string;
-
-    @MapField({
-        src: 'obj.obj[0][1]',
-        transformer: (arr) => arr.map(role => role + " TEST TRASFORMER"),
-        reverser: (arr) => arr.map(role => role.replace(" TEST TRASFORMER", "")),
-    })
-    roles?: string[];
-
-    @MapField({
-        transformer: (user) => new User(user)
-    })
-    boss: User;
-}
-interface User extends MapInterface<User> { }
-```
-
-Inside _@MapField_ you can use:
-
-- **_src_**: define a string of original field name (also using a path like _"obj.obj[0][1]"_)
-- **_transform_**: function to transform data input in _constructor_ of the class
-- **_reverse_**: function to transform data input in _toMap_ method of the class
-
-In this example:
-
-```
-@MapClass()
-class User {
-
-    id: string;
-    username: string;
-
-    @MapField({
-        src: 'firstName'
-    })
-    name: string;
-
-    @MapField({
-        src: 'lastName'
-    })
-    surname: string;
-
-    @MapField({
-        src: 'rolesToMap',
-        transformer: (arr) => arr.map(role => role + " TEST TRASFORMER"),
-        reverser: (arr) => arr.map(role => role.replace(" TEST TRASFORMER", "")),
-    })
-    roles?: string[];
-
-    @MapField({
-        transformer: (arr) => arr.map(user => new User(user))
-    })
-    employees?: User[];
-
-    @MapField({
-        transformer: (user) => new User(user)
-    })
-    boss?: User;
-}
-interface User extends MapInterface<User> { }
-```
-
-You can define a new User **_u_**, using two employees (using the same User model here but for a different object is the same):
-
-```
-let emp1: User = new User().from({ firstName: "Summer", lastName: "Smith" });
-let emp2: User = new User().from({ firstName: "Morty", lastName: "Smith" });
-
-let u = new User().from({ firstName: "Rick", lastName: "Sanchez", employees: [emp1.toMap(), emp2.toMap()], rolesToMap: ["CEO", "EMPLOYEE"] });
-```
+# Mapper-Factory
+
+Mapper-Factory is a fully documented TypeScript library that provides a simple and easy-to-use way to map objects from one type to another. With just a few lines of code, you can convert complex, nested objects into the desired format.
+
+Work well on data structure and after enjoy the coding process :)
+
+## Installation
+
+To install the package, you can use npm by running the following command:
+
+```
+npm i mapper-factory
+```
+
+Or using yarn
+
+```
+yarn add mapper-factory
+```
+
+## Problem to solve
+
+We want to solve the problem to trasform a JSON object to a specific JS object adding custom properties, with integrated mapping. As example this JSON object:
+
+```
+{
+  firstName: 'Rick',
+  lastName: 'Sanchez',
+  employees: [
+    { firstName: 'Summer', lastName: 'Smith' },
+    { firstName: 'Morty', lastName: 'Smith' }
+  ],
+  rolesToMap: [ 'CEO', 'EMPLOYEE' ],
+  boss: { firstName: 'Jesus', lastName: 'Christ' }
+}
+```
+
+must became a JS object:
+
+```
+User {
+  name: 'Rick',
+  surname: 'Sanchez',
+  employees: [
+    User { name: 'Summer', surname: 'Smith' },
+    User { name: 'Morty', surname: 'Smith' }
+  ],
+  roles: [ 'CEO TEST TRASFORMER', 'EMPLOYEE TEST TRASFORMER' ],
+  boss: User { name: 'Jesus', surname: 'Christ' }
+  /** maybe some methods... */
+}
+```
+
+## Usage V2
+
+### Mapping simple objects
+
+Your class must use _MapClass_ decorator and set an interface that extends _MapInterface<T>_
+In this way your class could extend another, but continue using intellisense methods for YourClass
+
+```
+@MapClass()
+class YourClass extends YourCustomClassToExtend {
+    /** YOUR PROPERTIES  */
+}
+interface YourClass extends MapInterface<YourClass> { }
+```
+
+To get new _YourClass_ instance it's simple as always:
+
+```
+new YourClass();
+```
+
+but now you can easly mapping an object just using _MapInterface_ method _from_:
+
+```
+const yourInstance: YourClass = new YourClass().from(/** YOUR OBJECT TO MAP HERE*/);
+```
+
+and reverse your mapping using using _MapInterface_ method _toMap_:
+
+```
+const reversedMapping: Object = yourInstance.toMap();
+```
+
+With _MapInterface_ you can use on your class instance also other methods:
+
+- **_from_**: Create a new instance using model to map
+
+```
+const yourInstance: YourClass = new YourClass().from(/** YOUR OBJECT TO MAP HERE */);
+```
+
+- **_toMap_**: Create a JSON object using reverse mapping
+
+```
+const reverseMappedObject: Object = yourInstance.toMap();
+```
+
+- **_toModel_**: Create a new instance using same model of final JS object
+
+```
+const anotherInstance: YourClass = new YourClass.toModel(yourInstance);
+```
+
+- **_empty_**: Check if the object is empty
+
+```
+const isEmpty: boolean = yourInstance.empty();
+```
+
+- **_filled_**: Check if the object is filled
+
+```
+const isFilled: boolean = yourInstance.filled();
+```
+
+- **_get_**: Get specific property of the object
+
+```
+const specificProp: T = yourInstance.get('specificProp') as T;
+```
+
+- **_set_**: Set specific property of the object
+
+```
+yourInstance.set('specificProp', /** NEW VALUE FOR 'specificProp' */);
+```
+
+- **_copy_**: Deep copy of the object
+
+```
+const yourInstanceCopy: YourClass = yourInstance.copy();
+```
+
+After that, you can use _@MapField_ decorator over single property to specify the mapping. Let's dive into an example:
+
+```
+@MapClass()
+class User {
+
+    @MapField({
+        src: 'firstName'
+    })
+    name: string;
+
+    @MapField({
+        src: 'obj.obj[0][1]',
+        transformer: (arr) => arr.map(role => role + " TEST TRASFORMER"),
+        reverser: (arr) => arr.map(role => role.replace(" TEST TRASFORMER", "")),
+    })
+    roles?: string[];
+
+    @MapField({
+        transformer: (user) => new User(user)
+    })
+    boss: User;
+}
+interface User extends MapInterface<User> { }
+```
+
+Inside _@MapField_ you can use:
+
+- **_src_**: define a string of original field name (also using a path like _"obj.obj[0][1]"_)
+- **_transform_**: function to transform data input in _constructor_ of the class
+- **_reverse_**: function to transform data input in _toMap_ method of the class
+
+In this example:
+
+```
+@MapClass()
+class User {
+
+    id: string;
+    username: string;
+
+    @MapField({
+        src: 'firstName'
+    })
+    name: string;
+
+    @MapField({
+        src: 'lastName'
+    })
+    surname: string;
+
+    @MapField({
+        src: 'rolesToMap',
+        transformer: (arr) => arr.map(role => role + " TEST TRASFORMER"),
+        reverser: (arr) => arr.map(role => role.replace(" TEST TRASFORMER", "")),
+    })
+    roles?: string[];
+
+    @MapField({
+        transformer: (arr) => arr.map(user => new User(user))
+    })
+    employees?: User[];
+
+    @MapField({
+        transformer: (user) => new User(user)
+    })
+    boss?: User;
+}
+interface User extends MapInterface<User> { }
+```
+
+You can define a new User **_u_**, using two employees (using the same User model here but for a different object is the same):
+
+```
+let emp1: User = new User().from({ firstName: "Summer", lastName: "Smith" });
+let emp2: User = new User().from({ firstName: "Morty", lastName: "Smith" });
+
+let u = new User().from({ firstName: "Rick", lastName: "Sanchez", employees: [emp1.toMap(), emp2.toMap()], rolesToMap: ["CEO", "EMPLOYEE"] });
+```

package/dist/class.decorator.js

@@ -1,4 +1,4 @@
-import { copy, empty, filled, from, get, objToModel, set, toMap } from "./functions";
+import { copy, empty, filled, from, get, objToModel, set, toMap, } from "./functions";
 export function MapClass() {
     return function (constructor) {
         constructor.prototype.from = from;

package/dist/field-decorators/array.decorator.d.ts

@@ -1,4 +1,4 @@
 import { MapInterface } from "../class.decorator";
 export declare function ArrayField<T extends MapInterface<T>>(clsFactory: new () => T, opt?: {
     src?: string;
-}): PropertyDecorator;
+}): (target: unknown, propertyKey: string | symbol) => void;

package/dist/field-decorators/array.decorator.js

@@ -3,9 +3,7 @@ export function ArrayField(clsFactory, opt) {
     const Ctor = clsFactory;
     return MapField({
         src: opt?.src,
-        transformer: (arr) => Array.isArray(arr)
-            ? arr.map((item) => new Ctor().from(item))
-            : [],
+        transformer: (arr) => Array.isArray(arr) ? arr.map((item) => new Ctor().from(item)) : [],
         reverser: (arr) => Array.isArray(arr) ? arr.map((item) => item.toMap()) : [],
     });
 }

package/dist/field-decorators/date.decorator.d.ts

@@ -1,3 +1,3 @@
 export declare function DateField(opt?: {
     src?: string;
-}): PropertyDecorator;
+}): (target: unknown, propertyKey: string | symbol) => void;

package/dist/field-decorators/field.decorator.d.ts

@@ -1,5 +1,4 @@
-import 'reflect-metadata';
-import { ClassType } from '../types';
+import { ClassType } from "../types";
 export declare const MAP_FIELD: unique symbol;
 export interface MapperMetadata<T = any> {
     src?: keyof T;
@@ -13,7 +12,7 @@ export interface MapperMetadata<T = any> {
 }
 export declare function isClass(func: any): func is ClassType;
 export declare function getPrototype(target: Record<string, unknown> | ClassType): any;
-export declare const MapField: <T = any>({ transformer, reverser, src, initialize, }?: MapperMetadata<T>) => PropertyDecorator;
+export declare const MapField: <T = any>({ transformer, reverser, src, initialize, }?: MapperMetadata<T>) => ((target: unknown, propertyKey: string | symbol) => void);
 export declare const getMapFieldMetadataList: (target: Record<string, unknown> | ClassType | any) => {
     [key: string]: MapperMetadata;
 } | undefined;

package/dist/field-decorators/field.decorator.js

@@ -1,17 +1,20 @@
-import 'reflect-metadata';
-export const MAP_FIELD = Symbol('MAP_FIELD');
+export const MAP_FIELD = Symbol("MAP_FIELD");
 export function isClass(func) {
-    return (typeof func === 'function' &&
+    return (typeof func === "function" &&
         /^class\s/.test(Function.prototype.toString.call(func)));
 }
 export function getPrototype(target) {
-    return isClass(target) || !target?.prototype ? !target?.constructor ? target : target?.constructor : target?.prototype;
+    return isClass(target) || !target?.prototype
+        ? !target?.constructor
+            ? target
+            : target?.constructor
+        : target?.prototype;
 }
 export const MapField = ({ transformer, reverser, src, initialize = false, } = {}) => {
     return (target, property) => {
         const classConstructor = target.constructor;
         const propertyName = property.toString();
-        const metadata = Reflect.getMetadata(MAP_FIELD, classConstructor) || {};
+        const metadata = classConstructor[MAP_FIELD] || {};
         // create new object reference to avoid this issue: https://github.com/rbuckton/reflect-metadata/issues/62
         const newMetadata = { ...metadata };
         const previousValues = metadata[propertyName];
@@ -22,14 +25,14 @@ export const MapField = ({ transformer, reverser, src, initialize = false, } = {
             transformer,
             reverser,
         };
-        Reflect.defineMetadata(MAP_FIELD, newMetadata, classConstructor);
+        classConstructor[MAP_FIELD] = newMetadata;
     };
 };
 export const getMapFieldMetadataList = (target) => {
-    return Reflect.getMetadata(MAP_FIELD, getPrototype(target));
+    return getPrototype(target)[MAP_FIELD];
 };
 export const hasMapFieldMetadataList = (target) => {
-    return Reflect.hasMetadata(MAP_FIELD, getPrototype(target));
+    return !!getPrototype(target)[MAP_FIELD];
 };
 export const getMapFieldMetadata = (target, propertyName) => {
     const metadata = getMapFieldMetadataList(target);
@@ -39,6 +42,6 @@ export const getMapFieldMetadata = (target, propertyName) => {
     return metadata[name];
 };
 export const hasMapFieldMetadata = (target, propertyName) => {
-    const metadata = Reflect.getMetadata(MAP_FIELD, getPrototype(target));
+    const metadata = getPrototype(target)[MAP_FIELD];
     return metadata && !!metadata[propertyName];
 };

package/dist/field-decorators/object.decorator.d.ts

@@ -1,4 +1,4 @@
 import { MapInterface } from "../class.decorator";
 export declare function ObjectField<T extends MapInterface<T>>(clsFactory: new () => T, opt?: {
     src?: string;
-}): PropertyDecorator;
+}): (target: unknown, propertyKey: string | symbol) => void;

package/dist/functions.d.ts

@@ -1,49 +1,54 @@
+export interface MapperTarget {
+    [key: string]: any;
+    from?(obj: unknown): MapperTarget;
+    toMap?(): Record<string, unknown>;
+}
 /**
  * Convert the instance of this class to JSON Object.
  *
  * @returns JSON object mapped considering metadata "src" and "reverser"
  */
-export declare function toMap(): any;
+export declare function toMap(this: MapperTarget): Record<string, unknown>;
 /**
  * Convert a JSON Object to an instance of this class.
  *
  * @param obj JSON Object
  * @returns Instance of this class
  */
-export declare function objToModel(obj: Object): any;
+export declare function objToModel(this: MapperTarget, obj: Record<string, any>): MapperTarget;
 /**
  * Check if this instance is empty.
  *
  * @returns true or false
  */
-export declare function empty(): boolean;
+export declare function empty(this: MapperTarget): boolean;
 /**
  * Check if this instance is filled.
  *
  * @returns true or false
  */
-export declare function filled(): boolean;
+export declare function filled(this: MapperTarget): boolean;
 /**
  * GET property value from a string path.
  *
  * @param path String path
  * @returns Value of the property
  */
-export declare function get<T>(path: string): T;
+export declare function get<T>(this: MapperTarget, path: string): T;
 /**
  * SET property value from a string path.
  *
  * @param path String path
  * @param value Value of the property
  */
-export declare function set(path: string, value: any): void;
+export declare function set(this: MapperTarget, path: string, value: unknown): void;
 /**
  * Deep copy of the object caller
  */
-export declare function copy<T>(): T;
+export declare function copy<T extends MapperTarget>(this: T): T;
 /**
  * Constructor of the mapper.
  *
  * @param object object to be mapped considering metadata "src", "transformer" and "reverser"
  */
-export declare function from(object: any): any;
+export declare function from(this: MapperTarget, object: Record<string, any>): MapperTarget;

package/dist/functions.js

@@ -1,4 +1,5 @@
 import { getMapFieldMetadataList } from "./field-decorators/field.decorator";
+import { getValueByPath, setValueByPath } from "./utils";
 /**
  * Convert the instance of this class to JSON Object.
  *
@@ -6,68 +7,43 @@ import { getMapFieldMetadataList } from "./field-decorators/field.decorator";
  */
 export function toMap() {
     const metadataList = getMapFieldMetadataList(this);
-    let obj = {};
-    const processProperty = (objCopy, propsStereoid, value, reverser) => {
-        let lastIndex;
-        for (let i = 0; i < propsStereoid.length; i++) {
-            const prop = propsStereoid[i];
-            if (prop.isArray) {
-                let arrIndex = prop.arrIndex
-                    .split(/\[(\w+)\]/g)
-                    .filter((index) => index !== "");
-                objCopy[prop.prop] = objCopy[prop.prop] || [];
-                objCopy = objCopy[prop.prop];
-                arrIndex.forEach((index, i) => {
-                    objCopy[index] =
-                        objCopy[index] || (i == arrIndex.length - 1 ? {} : []);
-                    if (i != arrIndex.length - 1)
-                        objCopy = objCopy[index];
-                    else
-                        lastIndex = index;
-                });
-            }
-            else {
-                objCopy[prop.prop] = objCopy[prop.prop] || {};
-                if (i != propsStereoid.length - 1)
-                    objCopy = objCopy[prop.prop];
-                else
-                    lastIndex = prop.prop;
-            }
-        }
-        objCopy[lastIndex] = reverser ? reverser(value, this) : value;
-    };
-    this &&
+    const obj = {};
+    if (this) {
         Object.keys(this).forEach((propertyName) => {
             const metadata = metadataList && metadataList[propertyName];
             const src = metadata?.src || propertyName;
+            const value = this[propertyName];
+            let finalValue;
             if (metadata) {
-                if (src.includes(".")) {
-                    let props = src.split(".");
-                    let propsStereoid = props.map((prop) => ({
-                        prop: prop.includes("[")
-                            ? prop.substring(0, prop.indexOf("["))
-                            : prop,
-                        isArray: prop.includes("[") && prop.includes("]"),
-                        arrIndex: prop.substring(prop.indexOf("[")),
-                    }));
-                    processProperty(obj, propsStereoid, this[propertyName], metadata.reverser);
+                if (Array.isArray(value) && !metadata.reverser) {
+                    finalValue = value.map((item) => (item?.toMap ? item.toMap() : item));
+                }
+                else if (metadata.reverser) {
+                    finalValue = metadata.reverser(value, this);
+                }
+                else if (value?.toMap) {
+                    finalValue = value.toMap();
                 }
                 else {
-                    obj[src] =
-                        Array.isArray(this[propertyName]) && !metadata.reverser
-                            ? this[propertyName].map((item) => item?.toMap ? item.toMap() : item)
-                            : metadata.reverser
-                                ? metadata.reverser(this[propertyName], this)
-                                : this[propertyName]?.toMap
-                                    ? this[propertyName].toMap()
-                                    : this[propertyName];
+                    finalValue = value;
                 }
             }
             else {
-                if (this[propertyName] != undefined)
-                    obj[propertyName] = this[propertyName];
+                if (Array.isArray(value)) {
+                    finalValue = value.map((item) => (item?.toMap ? item.toMap() : item));
+                }
+                else if (value?.toMap) {
+                    finalValue = value.toMap();
+                }
+                else {
+                    finalValue = value;
+                }
+            }
+            if (finalValue !== undefined) {
+                setValueByPath(obj, src, finalValue);
             }
         });
+    }
     return obj;
 }
 /**
@@ -111,8 +87,7 @@ export function filled() {
  * @returns Value of the property
  */
 export function get(path) {
-    const props = path.replace(/\[(\w+)\]/g, ".$1").split(".");
-    return props.reduce((acc, prop) => acc && acc[prop], this);
+    return getValueByPath(this, path);
 }
 /**
  * SET property value from a string path.
@@ -121,20 +96,16 @@ export function get(path) {
  * @param value Value of the property
  */
 export function set(path, value) {
-    const props = path.replace(/\[(\w+)\]/g, ".$1").split(".");
-    let obj = this;
-    props.slice(0, -1).forEach((prop) => {
-        if (!obj[prop])
-            obj[prop] = {};
-        obj = obj[prop];
-    });
-    obj[props[props.length - 1]] = value;
+    setValueByPath(this, path, value);
 }
 /**
  * Deep copy of the object caller
  */
 export function copy() {
-    return this.from(this.toMap());
+    if (this.from && this.toMap) {
+        return this.from(this.toMap());
+    }
+    return this;
 }
 /**
  * Constructor of the mapper.
@@ -143,77 +114,50 @@ export function copy() {
  */
 export function from(object) {
     const metadataList = getMapFieldMetadataList(this);
-    const processProperty = (objCopy, propsStereoid) => {
-        for (let i = 0; i < propsStereoid.length; i++) {
-            const prop = propsStereoid[i];
-            if (prop.isArray) {
-                let arrIndex = prop.arrIndex
-                    .split(/\[(\w+)\]/g)
-                    .filter((index) => index !== "");
-                objCopy = objCopy[prop.prop];
-                arrIndex.forEach((index) => {
-                    objCopy = objCopy[index];
-                });
-            }
-            else {
-                objCopy = objCopy[prop.prop];
-            }
-        }
-        return objCopy;
-    };
-    const setProperty = (metaKey, value, object) => {
-        const metaProp = metadataList?.[metaKey];
-        if (metaProp?.transformer) {
-            const valueTransformed = metaProp.transformer(value, object);
-            if (valueTransformed != undefined)
-                this[metaKey] = valueTransformed;
-        }
-        else {
-            if (value != undefined)
-                this[metaKey] = value;
-        }
-    };
-    object &&
-        Object.keys(object).forEach((propertyName) => {
-            let metaKeys = metadataList &&
-                Object.keys(metadataList).filter((metadata) => metadataList[metadata]?.src?.split(".")?.includes(propertyName));
-            if (metaKeys?.length) {
-                metaKeys.forEach((metaKey) => {
-                    const metaProp = metadataList?.[metaKey];
-                    if (metaProp) {
-                        const props = metaProp.src.split(".");
-                        const propsStereoid = props.map((prop) => ({
-                            prop: prop.includes("[")
-                                ? prop.substring(0, prop.indexOf("["))
-                                : prop,
-                            isArray: prop.includes("[") && prop.includes("]"),
-                            arrIndex: prop.substring(prop.indexOf("[")),
-                        }));
-                        const value = processProperty({ ...object }, propsStereoid);
-                        setProperty(metaKey, value, object);
+    const mappedSrcRoots = new Set();
+    // 1. Process Metadata
+    if (metadataList && object) {
+        Object.keys(metadataList).forEach((key) => {
+            const meta = metadataList[key];
+            const src = meta.src || key;
+            // Identify root property for this mapping to exclude it from direct copy later
+            const normalizedPath = src.replace(/\[(\w+)\]/g, ".$1");
+            const root = normalizedPath.split(".")[0];
+            mappedSrcRoots.add(root);
+            const value = getValueByPath(object, src);
+            // Only process if value exists in source (matches old behavior and avoids infinite recursion on undefined)
+            if (value !== undefined) {
+                if (meta.transformer) {
+                    const transformed = meta.transformer(value, object);
+                    if (transformed !== undefined) {
+                        this[key] = transformed;
                     }
-                });
-            }
-            else {
-                let metaKey = metadataList &&
-                    Object.keys(metadataList).find((metadata) => metadataList[metadata]?.src == propertyName);
-                if (metaKey) {
-                    const src = metadataList?.[metaKey].src || propertyName;
-                    setProperty(metaKey, object[src], object);
                 }
                 else {
-                    setProperty(propertyName, object[propertyName], object);
+                    this[key] = value;
                 }
             }
         });
-    // Initialize properties with "initialize" metadata
-    metadataList &&
+    }
+    // 2. Process Remaining Properties (Direct Copy)
+    // Only if they are not part of a mapped source root
+    if (object) {
+        Object.keys(object).forEach((prop) => {
+            if (!mappedSrcRoots.has(prop)) {
+                this[prop] = object[prop];
+            }
+        });
+    }
+    // 3. Initialize properties with "initialize" metadata
+    if (metadataList) {
         Object.keys(metadataList).forEach((metaName) => {
-            if (metadataList[metaName]?.initialize &&
-                metadataList[metaName]?.transformer &&
+            const meta = metadataList[metaName];
+            if (meta?.initialize &&
+                meta?.transformer &&
                 this[metaName] === undefined) {
-                this[metaName] = metadataList[metaName].transformer(null, object);
+                this[metaName] = meta.transformer(null, object);
             }
         });
+    }
     return this;
 }

package/dist/index.d.ts

@@ -7,7 +7,7 @@ import { ClassType } from "./types";
 export { ClassType, MapInterface, MapClass, MapField, DateField, ArrayField, ObjectField, };
 /**
  * npx tsc
- * npx ts-node src/test.ts
+ * npx tsx src/test.ts
  * npm version ( patch | minor | major )
  * npm publish
  */

package/dist/index.js

@@ -6,7 +6,7 @@ import { ObjectField } from "./field-decorators/object.decorator";
 export { MapClass, MapField, DateField, ArrayField, ObjectField, };
 /**
  * npx tsc
- * npx ts-node src/test.ts
+ * npx tsx src/test.ts
  * npm version ( patch | minor | major )
  * npm publish
  */

package/dist/test.js

@@ -7,6 +7,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+//// import "reflect-metadata";
 import { MapClass } from "./class.decorator";
 import { ArrayField } from "./field-decorators/array.decorator";
 import { DateField } from "./field-decorators/date.decorator";
@@ -16,11 +17,6 @@ import { ObjectField } from "./field-decorators/object.decorator";
 console.log("\nMAPPER FACTORY - TEST");
 console.log("\n");
 let History = class History {
-    id;
-    name;
-    testControl;
-    daysActive;
-    testConcatenation;
 };
 __decorate([
     MapField({
@@ -57,14 +53,6 @@ History = __decorate([
     MapClass()
 ], History);
 let User = class User {
-    id;
-    username;
-    name;
-    surname;
-    roles;
-    employees;
-    boss;
-    histories;
 };
 __decorate([
     MapField({
@@ -111,6 +99,7 @@ User = __decorate([
 const emp1 = new User().from({ firstName: "Summer", lastName: "Smith" });
 const emp2 = new User().from({ firstName: "Morty", lastName: "Smith" });
 const JSONObject = {
+    id: "0",
     username: "god",
     firstName: "Rick",
     lastName: "Sanchez",
@@ -120,13 +109,19 @@ const JSONObject = {
 };
 //TEST constructor
 const u = new User().from(JSONObject);
-const constructorTest = u.username == JSONObject.username &&
+console.log("\n\n\n");
+console.log(u);
+console.log("\n\n\n");
+console.log(JSONObject);
+console.log("\n\n\n");
+const constructorTest = !!(u.id == JSONObject.id &&
+    u.username == JSONObject.username &&
     u.name == JSONObject.firstName &&
     u.surname == JSONObject.lastName &&
     u.employees?.map((emp) => emp.name == emp1.name) &&
     u.roles?.map((role) => role == "CEO") &&
     u.boss.name == "Nello" &&
-    u.boss.surname == "Stanco";
+    u.boss.surname == "Stanco");
 console.log("TEST CONSTRUCTOR", constructorTest ? "✅" : "❌");
 //TEST toModel method with JS Object
 const u1 = new User().toModel(u);
@@ -167,7 +162,6 @@ const hTest2 = new History().from({
 const toModelTest4 = hTest2.toMap().test.concatenation == "resolve ";
 console.log("TEST CONCAT WITH POINT", toModelTest4 ? "✅" : "❌");
 let Test = class Test {
-    a;
 };
 __decorate([
     MapField({
@@ -190,10 +184,10 @@ console.log("TEST TO MODEL WITH INITIALIZE", model3.a == "test to model" ? "✅"
 const model4 = model3.toMap();
 console.log("TEST TO MAP WITH INITIALIZE", model4.b.a == "test reverser" ? "✅" : "❌");
 const model5 = model3.copy();
-console.log("TEST COPY WITH INITIALIZE", Object.keys(model5).every((k) => model5[k] == model3[k]) ? "✅" : "❌");
+console.log("TEST COPY WITH INITIALIZE", Object.keys(model5).every((k) => model5.get(k) == model3.get(k))
+    ? "✅"
+    : "❌");
 let TestFlag = class TestFlag {
-    flTest;
-    a;
 };
 __decorate([
     MapField({
@@ -216,7 +210,9 @@ TestFlag = __decorate([
     MapClass()
 ], TestFlag);
 const testFlagInitialize = new TestFlag().from();
-console.log("TEST INITIALIZE", testFlagInitialize && testFlagInitialize.a == "test transformer" ? "✅" : "❌");
+console.log("TEST INITIALIZE", testFlagInitialize && testFlagInitialize.a == "test transformer"
+    ? "✅"
+    : "❌");
 const testFlag0 = new TestFlag().from();
 const testFlag0Map = testFlag0.toMap();
 console.log("TEST FLAG0", testFlag0.flTest === false && testFlag0Map.flTest == "0" ? "✅" : "❌");
@@ -227,8 +223,6 @@ const testFlag2 = new TestFlag().from({ flTest: "0" });
 const testFlag2Map = testFlag2.toMap();
 console.log("TEST FLAG2", !testFlag2.flTest && testFlag2Map.flTest == "0" ? "✅" : "❌");
 let TestWithoutMapField = class TestWithoutMapField {
-    id;
-    name;
 };
 TestWithoutMapField = __decorate([
     MapClass()
@@ -240,8 +234,6 @@ const JSONObject2 = {
 const testWOMF = new TestWithoutMapField().from(JSONObject2);
 console.log("TEST WITHOUT MAP FIELD", testWOMF ? "✅" : "❌");
 let ObjDecorator = class ObjDecorator {
-    id;
-    testObject;
 };
 __decorate([
     ObjectField(ObjDecorator),
@@ -251,9 +243,6 @@ ObjDecorator = __decorate([
     MapClass()
 ], ObjDecorator);
 let TestDecorators = class TestDecorators {
-    date;
-    objList;
-    obj;
 };
 __decorate([
     DateField({ src: "dateSrc" }),
@@ -279,7 +268,7 @@ const JSONTestDecorators = {
     obj: { id: "5", testObject: { id: "6" } },
 };
 const testDecorators = new TestDecorators().from(JSONTestDecorators);
-console.log("TEST WITH DECORATORS", testDecorators.date.toISOString() &&
+console.log("TEST WITH DECORATORS", testDecorators.date?.toISOString() &&
     testDecorators.objList?.length === 2 &&
     testDecorators.obj instanceof ObjDecorator &&
     testDecorators.objList[0] instanceof ObjDecorator &&

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Retrieve a value from an object using a string path (dot notation).
+ * Supports array indexing e.g. "users[0].name" or "users.0.name".
+ */
+export declare function getValueByPath(obj: any, path: string): any;
+/**
+ * Set a value on an object using a string path (dot notation).
+ * Creates nested objects/arrays if they don't exist.
+ */
+export declare function setValueByPath(obj: any, path: string, value: any): void;

package/dist/utils.js

@@ -0,0 +1,43 @@
+/**
+ * Retrieve a value from an object using a string path (dot notation).
+ * Supports array indexing e.g. "users[0].name" or "users.0.name".
+ */
+export function getValueByPath(obj, path) {
+    if (obj == null || !path)
+        return undefined;
+    // Normalize path: "a[0].b" -> "a.0.b"
+    const normalizedPath = path.replace(/\[(\w+)\]/g, ".$1");
+    const parts = normalizedPath.split(".");
+    let current = obj;
+    for (const part of parts) {
+        if (current == null)
+            return undefined;
+        current = current[part];
+    }
+    return current;
+}
+/**
+ * Set a value on an object using a string path (dot notation).
+ * Creates nested objects/arrays if they don't exist.
+ */
+export function setValueByPath(obj, path, value) {
+    if (obj == null || !path)
+        return;
+    const normalizedPath = path.replace(/\[(\w+)\]/g, ".$1");
+    const parts = normalizedPath.split(".");
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        // If the property doesn't exist, create it.
+        // Look ahead to decide if we need an array or an object.
+        if (current[part] == null) {
+            const nextPart = parts[i + 1];
+            // If next part is an integer, assume array.
+            const isNextIndex = !isNaN(parseInt(nextPart)) && isFinite(parseInt(nextPart));
+            current[part] = isNextIndex ? [] : {};
+        }
+        current = current[part];
+    }
+    const lastPart = parts[parts.length - 1];
+    current[lastPart] = value;
+}

package/package.json

@@ -1,50 +1,47 @@
-{
-  "name": "mapper-factory",
-  "version": "4.0.0",
-  "description": "mapper for typescript object",
-  "type": "module",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
-    }
-  },
-  "files": [
-    "/dist",
-    "/images"
-  ],
-  "scripts": {
-    "build": "npx tsc",
-    "dev": "npx tsc --watch",
-    "test": "npx tsx src/test.ts",
-    "patch": "npm version patch",
-    "minor": "npm version minor",
-    "major": "npm version major",
-    "deploy": "npm publish"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/lucaAngrisani/mapper-factory.git"
-  },
-  "keywords": [
-    "mapper-ts",
-    "mapper-factory",
-    "mapper",
-    "factory",
-    "mapper factory"
-  ],
-  "author": "lucaAngrisani Angrigo",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/lucaAngrisani/mapper-factory/issues"
-  },
-  "homepage": "https://github.com/lucaAngrisani/mapper-factory#readme",
-  "dependencies": {
-    "reflect-metadata": "^0.2.2"
-  },
-  "devDependencies": {
-    "typescript": "^5.7.3"
-  }
-}
+{
+  "name": "mapper-factory",
+  "version": "4.0.2",
+  "description": "mapper for typescript object",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "/dist",
+    "/images"
+  ],
+  "scripts": {
+    "build": "npx tsc",
+    "dev": "npx tsc --watch",
+    "test": "npx tsx src/test.ts",
+    "patch": "npm version patch",
+    "minor": "npm version minor",
+    "major": "npm version major",
+    "deploy": "npm publish"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lucaAngrisani/mapper-factory.git"
+  },
+  "keywords": [
+    "mapper-ts",
+    "mapper-factory",
+    "mapper",
+    "factory",
+    "mapper factory"
+  ],
+  "author": "lucaAngrisani Angrigo",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/lucaAngrisani/mapper-factory/issues"
+  },
+  "homepage": "https://github.com/lucaAngrisani/mapper-factory#readme",
+  "devDependencies": {
+    "typescript": "^5.7.3"
+  }
+}