json-storage-formatter 1.0.1 → 1.0.3

package/README.md

@@ -13,67 +13,72 @@ The main methods of the library are **formatToStore** and **formatFromStore**
 Format an object to be stored as JSON
 
 ```TS
-    const objectWithMetadata = formatToStore(object);
-
-    // The result can be JSON.stringify
-    console.log(objectWithMetadata);
-    /*
-    {
-        _type_: 'map',
-        value: [
-            [
-            'key1',
-            {
-                _type_: 'date',
-                value: '2021-05-08T13:30:00.000Z',
-            },
-            ],
-            [
-            'key2',
+const objectWithMetadata = formatToStore(object);
+
+// The result can be JSON.stringify
+console.log(objectWithMetadata);
+/*
+{
+    $t: 'map',
+    $v: [
+        [
+        'key1',
+        {
+            $t: 'date',
+            $v: '2021-05-08T13:30:00.000Z',
+        },
+        ],
+        [
+        'key2',
+        {
+            $t: 'set',
+            $v: [
             {
-                _type_: 'set',
-                value: [
-                {
-                    _type_: 'map',
-                    value: [
-                    [
-                        'key1',
-                        {
-                        _type_: 'date',
-                        value: '2021-05-08T13:30:00.000Z',
-                        },
-                    ],
-                    ],
-                },
+                $t: 'map',
+                $v: [
+                [
+                    'key1',
+                    {
+                    $t: 'date',
+                    $v: '2021-05-08T13:30:00.000Z',
+                    },
+                ],
                 ],
             },
             ],
+        },
         ],
-    }
-     */
+    ],
+}
+*/
+
+// you can also stringify directly the result by specifying it on the configuration parameter
+const objectString = formatToStore(object, { stringify: true });
+
+console.log(objectString); // {"$t":"map","$v":[["key1",{"$t":"date","$v":"2021-05-08T13:30:00.000Z"}],["key2",{"$t":"set","$v":[{"$t":"map","$v":[["key1",{"$t":"date","$v":"2021-05-08T13:30:00.000Z"}]]}]}]]}
 
 ```
 
-## formatFromStore
+## formatFromStore<T>
 
 Format a value with possible metadata to his original form, it also supports Map, Set, Arrays
 
 ```TS
-    const object = formatFromStore(objectWithMetadata);
-
-    // Original types of the object with metadata
-    console.log(object);
-
-    /*
-    // the result will be the same than executing the following code
-    const formatFromStoreResultExample = new Map<string, unknown>([
-        ['key1', new Date('2021-05-08T13:30:00.000Z')],
-        [
-            'key2',
-            new Set([new Map([['key1', new Date('2021-05-08T13:30:00.000Z')]])]),
-        ],
-    ]);
-     */
+const object = formatFromStore<Map<string, unknown>>(objectWithMetadata);
+
+// Original types of the object with metadata
+console.log(object);
+
+/*
+// the result will be the same than executing the following code
+const formatFromStoreResultExample = new Map([
+    ['key1', new Date('2021-05-08T13:30:00.000Z')],
+    [
+        'key2',
+        new Set([new Map([['key1', new Date('2021-05-08T13:30:00.000Z')]])]),
+    ],
+]);
+    */
 ```
 
 ## clone

package/lib/json-storage-formatter.d.ts

@@ -1,3 +1,7 @@
+export type IValueWithMedaData = {
+    $t?: 'map' | 'set' | 'date';
+    $v?: unknown;
+};
 /**
  * Deep clone an object, it also suppors Map, Set, Arrays
  * @param obj
@@ -59,11 +63,16 @@ export declare const isPrimitive: (value: unknown) => boolean;
  * @returns
  * Orinal form of the value
  */
-export declare const formatFromStore: <T>(value: T) => unknown;
+export declare const formatFromStore: <T = unknown>(value: unknown) => T;
 /**
- * Add metadata to a value to store it as json, it also supports Map, Set, Arrays
- * @returns
- * A value with metadata to store it as json
+ * Add metadata to a value to store it as json, it also supports Map, Set, Arrays,
+ * Returns a new object wich is a clone of the original object with metadata
+ * @template {TValue} The type of the value to format
+ * @template {TStringify} If the value should be stringified
+ * @param {TValue} value The value to format
+ * @param {{ stringify: TStringify }} { stringify: boolean } If the value should be stringified
  */
-export declare const formatToStore: <T>(value: T) => unknown;
+export declare const formatToStore: <TValue, TStringify extends boolean = false>(value: TValue, { stringify }?: {
+    stringify: TStringify;
+}) => TStringify extends true ? string : unknown;
 //# sourceMappingURL=json-storage-formatter.d.ts.map

package/lib/json-storage-formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-storage-formatter.d.ts","sourceRoot":"","sources":["../src/json-storage-formatter.ts"],"names":[],"mappings":"AAKA;;;;;KAKK;AACL,eAAO,MAAM,KAAK,kBAsCjB,CAAC;AAEF;;;;;;KAMK;AACL,eAAO,MAAM,KAAK,UAAW,OAAO,YAA0C,CAAC;AAE/E;;;;;;MAMM;AACN,eAAO,MAAM,QAAQ,UAAW,OAAO,YAA8B,CAAC;AAEtE;;;;;;KAMK;AACL,eAAO,MAAM,SAAS,UAAW,OAAO,YAA+B,CAAC;AAExE;;;;;;KAMK;AACL,eAAO,MAAM,QAAQ,UAAW,OAAO,YAA8B,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,MAAM,UAAW,OAAO,YAA0B,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,UAAW,OAAO,YAKf,CAAC;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,eAAe,mBAAkB,OAoD7C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,mBAAkB,OAwD3C,CAAC"}
+{"version":3,"file":"json-storage-formatter.d.ts","sourceRoot":"","sources":["../src/json-storage-formatter.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,CAAC,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAC5B,EAAE,CAAC,EAAE,OAAO,CAAC;CACd,CAAC;AAEF;;;;;KAKK;AACL,eAAO,MAAM,KAAK,kBAqCjB,CAAC;AAEF;;;;;;KAMK;AACL,eAAO,MAAM,KAAK,UAAW,OAAO,YAA0C,CAAC;AAE/E;;;;;;MAMM;AACN,eAAO,MAAM,QAAQ,UAAW,OAAO,YAA8B,CAAC;AAEtE;;;;;;KAMK;AACL,eAAO,MAAM,SAAS,UAAW,OAAO,YAA+B,CAAC;AAExE;;;;;;KAMK;AACL,eAAO,MAAM,QAAQ,UAAW,OAAO,YAA8B,CAAC;AAEtE;;;;;GAKG;AACH,eAAO,MAAM,MAAM,UAAW,OAAO,YAA0B,CAAC;AAEhE;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,UAAW,OAAO,YAKf,CAAC;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,eAAe,uBAAwB,OAAO,MAoD1D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;gDAuEzB,CAAC"}

package/lib/json-storage-formatter.js

@@ -8,7 +8,6 @@ exports.formatToStore = exports.formatFromStore = exports.isPrimitive = exports.
  * A deep clone of the object
  * */
 const clone = (obj) => {
-    debugger;
     if ((0, exports.isPrimitive)(obj) || (0, exports.isDate)(obj)) {
         return obj;
     }
@@ -103,18 +102,18 @@ const formatFromStore = (value) => {
         if ((0, exports.isPrimitive)(obj)) {
             return obj;
         }
-        const isMetaDate = (obj === null || obj === void 0 ? void 0 : obj._type_) === 'date';
+        const isMetaDate = (obj === null || obj === void 0 ? void 0 : obj.$t) === 'date';
         if (isMetaDate) {
-            return new Date(obj.value);
+            return new Date(obj.$v);
         }
-        const isMetaMap = (obj === null || obj === void 0 ? void 0 : obj._type_) === 'map';
+        const isMetaMap = (obj === null || obj === void 0 ? void 0 : obj.$t) === 'map';
         if (isMetaMap) {
-            const mapData = ((_a = obj.value) !== null && _a !== void 0 ? _a : []).map(([key, item]) => [key, (0, exports.formatFromStore)(item)]);
+            const mapData = ((_a = obj.$v) !== null && _a !== void 0 ? _a : []).map(([key, item]) => [key, (0, exports.formatFromStore)(item)]);
             return new Map(mapData);
         }
-        const isMetaSet = (obj === null || obj === void 0 ? void 0 : obj._type_) === 'set';
+        const isMetaSet = (obj === null || obj === void 0 ? void 0 : obj.$t) === 'set';
         if (isMetaSet) {
-            const setData = (_b = obj.value) !== null && _b !== void 0 ? _b : [].map((item) => (0, exports.formatFromStore)(item));
+            const setData = (_b = obj.$v) !== null && _b !== void 0 ? _b : [].map((item) => (0, exports.formatFromStore)(item));
             return new Set(setData);
         }
         const isArray = Array.isArray(obj);
@@ -131,11 +130,14 @@ const formatFromStore = (value) => {
 };
 exports.formatFromStore = formatFromStore;
 /**
- * Add metadata to a value to store it as json, it also supports Map, Set, Arrays
- * @returns
- * A value with metadata to store it as json
+ * Add metadata to a value to store it as json, it also supports Map, Set, Arrays,
+ * Returns a new object wich is a clone of the original object with metadata
+ * @template {TValue} The type of the value to format
+ * @template {TStringify} If the value should be stringified
+ * @param {TValue} value The value to format
+ * @param {{ stringify: TStringify }} { stringify: boolean } If the value should be stringified
  */
-const formatToStore = (value) => {
+const formatToStore = (value, { stringify } = { stringify: false }) => {
     const format = (obj) => {
         if ((0, exports.isPrimitive)(obj)) {
             return obj;
@@ -147,24 +149,27 @@ const formatToStore = (value) => {
         const isMap = obj instanceof Map;
         if (isMap) {
             const pairs = Array.from(obj.entries());
-            return {
-                _type_: 'map',
-                value: pairs.map((pair) => (0, exports.formatToStore)(pair)),
+            const value = {
+                $t: 'map',
+                $v: pairs.map((pair) => (0, exports.formatToStore)(pair)),
             };
+            return value;
         }
         const isSet = obj instanceof Set;
         if (isSet) {
             const values = Array.from(obj.values());
-            return {
-                _type_: 'set',
-                value: values.map((item) => (0, exports.formatToStore)(item)),
+            const value = {
+                $t: 'set',
+                $v: values.map((item) => (0, exports.formatToStore)(item)),
             };
+            return value;
         }
         if ((0, exports.isDate)(obj)) {
-            return {
-                _type_: 'date',
-                value: obj.toISOString(),
+            const value = {
+                $t: 'date',
+                $v: obj.toISOString(),
             };
+            return value;
         }
         const keys = Object.keys(obj);
         return keys.reduce((acumulator, key) => {
@@ -172,6 +177,10 @@ const formatToStore = (value) => {
             return Object.assign(Object.assign({}, acumulator), { [key]: (0, exports.formatToStore)(prop) });
         }, {});
     };
-    return format((0, exports.clone)(value));
+    const objectWithMetadata = format((0, exports.clone)(value));
+    const result = stringify
+        ? JSON.stringify(objectWithMetadata)
+        : objectWithMetadata;
+    return result;
 };
 exports.formatToStore = formatToStore;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "json-storage-formatter",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Package for json stringify objects without losing data types",
   "main": "lib/json-storage-formatter.js",
   "files": [