json-storage-formatter 1.0.2 → 1.0.4

package/README.md

@@ -19,28 +19,28 @@ const objectWithMetadata = formatToStore(object);
 console.log(objectWithMetadata);
 /*
 {
-    _type_: 'map',
-    value: [
+    $t: 'map',
+    $v: [
         [
         'key1',
         {
-            _type_: 'date',
-            value: '2021-05-08T13:30:00.000Z',
+            $t: 'date',
+            $v: '2021-05-08T13:30:00.000Z',
         },
         ],
         [
         'key2',
         {
-            _type_: 'set',
-            value: [
+            $t: 'set',
+            $v: [
             {
-                _type_: 'map',
-                value: [
+                $t: 'map',
+                $v: [
                 [
                     'key1',
                     {
-                    _type_: 'date',
-                    value: '2021-05-08T13:30:00.000Z',
+                    $t: 'date',
+                    $v: '2021-05-08T13:30:00.000Z',
                     },
                 ],
                 ],
@@ -50,23 +50,28 @@ console.log(objectWithMetadata);
         ],
     ],
 }
-    */
+*/
+
+// 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);
+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<string, unknown>([
+const formatFromStoreResultExample = new Map([
     ['key1', new Date('2021-05-08T13:30:00.000Z')],
     [
         'key2',

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

@@ -1,3 +1,7 @@
+export type IValueWithMedaData = {
+    $t?: 'map' | 'set' | 'date' | 'regex' | 'error';
+    $v?: unknown;
+};
 /**
  * Deep clone an object, it also suppors Map, Set, Arrays
  * @param obj
@@ -44,6 +48,12 @@ export declare const isString: (value: unknown) => boolean;
  * false otherwise
  */
 export declare const isDate: (value: unknown) => boolean;
+/**
+ * Check if a value is a RegExp
+ * @param value The value to check
+ * @returns true if the value is a RegExp, false otherwise
+ * */
+export declare const isRegex: (value: unknown) => boolean;
 /**
  * Check if a value is a primitive
  * @param value
@@ -59,11 +69,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,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,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,GAAG,OAAO,GAAG,OAAO,CAAC;IAChD,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;;;;KAIK;AACL,eAAO,MAAM,OAAO,UAAW,OAAO,YAA4B,CAAC;AAEnE;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,UAAW,OAAO,YAKf,CAAC;AAE5B;;;;;GAKG;AACH,eAAO,MAAM,eAAe,uBAAwB,OAAO,MAgE1D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,aAAa;;gDA2FzB,CAAC"}

package/lib/json-storage-formatter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatToStore = exports.formatFromStore = exports.isPrimitive = exports.isDate = exports.isString = exports.isBoolean = exports.isNumber = exports.isNil = exports.clone = void 0;
+exports.formatToStore = exports.formatFromStore = exports.isPrimitive = exports.isRegex = exports.isDate = exports.isString = exports.isBoolean = exports.isNumber = exports.isNil = exports.clone = void 0;
 /**
  * Deep clone an object, it also suppors Map, Set, Arrays
  * @param obj
@@ -76,6 +76,13 @@ exports.isString = isString;
  */
 const isDate = (value) => value instanceof Date;
 exports.isDate = isDate;
+/**
+ * Check if a value is a RegExp
+ * @param value The value to check
+ * @returns true if the value is a RegExp, false otherwise
+ * */
+const isRegex = (value) => value instanceof RegExp;
+exports.isRegex = isRegex;
 /**
  * Check if a value is a primitive
  * @param value
@@ -102,20 +109,28 @@ 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 isMetaReg = (obj === null || obj === void 0 ? void 0 : obj.$t) === 'regex';
+        if (isMetaReg) {
+            return new RegExp(obj.$v);
+        }
+        const isMetaError = (obj === null || obj === void 0 ? void 0 : obj.$t) === 'error';
+        if (isMetaError) {
+            return new Error(obj.$v);
+        }
         const isArray = Array.isArray(obj);
         if (isArray) {
             return obj.map((item) => (0, exports.formatFromStore)(item));
@@ -130,11 +145,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;
@@ -146,24 +164,42 @@ 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;
+        }
+        if ((0, exports.isRegex)(obj)) {
+            const value = {
+                $t: 'regex',
+                $v: obj.toString(),
+            };
+            return value;
+        }
+        const isError = obj instanceof Error;
+        if (isError) {
+            const value = {
+                $t: 'error',
+                $v: obj.message,
+            };
+            return value;
         }
         const keys = Object.keys(obj);
         return keys.reduce((acumulator, key) => {
@@ -171,6 +207,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.2",
+  "version": "1.0.4",
   "description": "Package for json stringify objects without losing data types",
   "main": "lib/json-storage-formatter.js",
   "files": [