mapper-factory 4.0.1 → 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,4 +1,4 @@
-import { ClassType } from '../types';
+import { ClassType } from "../types";
 export declare const MAP_FIELD: unique symbol;
 export interface MapperMetadata<T = any> {
     src?: keyof T;
@@ -12,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,10 +1,14 @@
-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) => {

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

@@ -16,7 +16,7 @@ export function toMap() {
             let finalValue;
             if (metadata) {
                 if (Array.isArray(value) && !metadata.reverser) {
-                    finalValue = value.map((item) => item?.toMap ? item.toMap() : item);
+                    finalValue = value.map((item) => (item?.toMap ? item.toMap() : item));
                 }
                 else if (metadata.reverser) {
                     finalValue = metadata.reverser(value, this);
@@ -29,7 +29,15 @@ export function toMap() {
                 }
             }
             else {
-                finalValue = value;
+                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);
@@ -94,7 +102,10 @@ export function set(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.
@@ -131,7 +142,7 @@ export function from(object) {
     // 2. Process Remaining Properties (Direct Copy)
     // Only if they are not part of a mapped source root
     if (object) {
-        Object.keys(object).forEach(prop => {
+        Object.keys(object).forEach((prop) => {
             if (!mappedSrcRoots.has(prop)) {
                 this[prop] = object[prop];
             }

package/dist/test.js

@@ -17,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({
@@ -58,14 +53,6 @@ History = __decorate([
     MapClass()
 ], History);
 let User = class User {
-    id;
-    username;
-    name;
-    surname;
-    roles;
-    employees;
-    boss;
-    histories;
 };
 __decorate([
     MapField({
@@ -112,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",
@@ -121,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);
@@ -168,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({
@@ -191,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({
@@ -217,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" ? "✅" : "❌");
@@ -228,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()
@@ -241,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),
@@ -252,9 +243,6 @@ ObjDecorator = __decorate([
     MapClass()
 ], ObjDecorator);
 let TestDecorators = class TestDecorators {
-    date;
-    objList;
-    obj;
 };
 __decorate([
     DateField({ src: "dateSrc" }),
@@ -280,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/package.json

@@ -1,47 +1,47 @@
-{
-  "name": "mapper-factory",
-  "version": "4.0.1",
-  "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"
-  }
-}
+{
+  "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"
+  }
+}