mapper-factory 4.0.0 → 4.0.1

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

@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 import { ClassType } from '../types';
 export declare const MAP_FIELD: unique symbol;
 export interface MapperMetadata<T = any> {

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

@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 export const MAP_FIELD = Symbol('MAP_FIELD');
 export function isClass(func) {
     return (typeof func === 'function' &&
@@ -11,7 +10,7 @@ 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 +21,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 +38,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/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,35 @@ 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];
+                finalValue = value;
+            }
+            if (finalValue !== undefined) {
+                setValueByPath(obj, src, finalValue);
             }
         });
+    }
     return obj;
 }
 /**
@@ -111,8 +79,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,14 +88,7 @@ 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
@@ -143,77 +103,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";

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,6 +1,6 @@
 {
   "name": "mapper-factory",
-  "version": "4.0.0",
+  "version": "4.0.1",
   "description": "mapper for typescript object",
   "type": "module",
   "main": "dist/index.js",
@@ -41,9 +41,6 @@
     "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"
   }