json-storage-formatter 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 johnny quesada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,126 @@
+# json-storage-formater
+
+Package for json stringify objects without losing data types. The transformation of the data includes extra metadata into the resulted string which later on is used to restored all the data structures to the their origninal forms.
+
+The library suppors Sets, Maps, Objects, Arrays, and Primitive data like Dates
+
+# API
+
+The main methods of the library are **formatToStore** and **formatFromStore**
+
+## formatToStore
+
+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',
+            {
+                _type_: 'set',
+                value: [
+                {
+                    _type_: 'map',
+                    value: [
+                    [
+                        'key1',
+                        {
+                        _type_: 'date',
+                        value: '2021-05-08T13:30:00.000Z',
+                        },
+                    ],
+                    ],
+                },
+                ],
+            },
+            ],
+        ],
+    }
+     */
+
+```
+
+## formatFromStore
+
+Format an 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')]])]),
+        ],
+    ]);
+     */
+```
+
+## clone
+
+Deep clone an object, it also suppors Map, Set, Arrays.
+The formatters clones the objects to avoid modify the parameter reference
+
+```ts
+const clone: <T>(obj: T) => T;
+```
+
+## isNil
+
+Check if a value is null or undefined
+
+```ts
+const isNil: (value: unknown) => boolean;
+```
+
+## isNumber
+
+Check if a value is a number
+
+```ts
+const isNumber: (value: unknown) => boolean;
+```
+
+## isBoolean
+
+Check if a value is a boolean
+
+```ts
+const isBoolean: (value: unknown) => boolean;
+```
+
+## isString
+
+Check if a value is a string
+
+```ts
+const isString: (value: unknown) => boolean;
+```
+
+## isDate
+
+Check if a value is a Date
+
+```ts
+const isDate: (value: unknown) => boolean;
+```

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

@@ -0,0 +1,69 @@
+/**
+ * Deep clone an object, it also suppors Map, Set, Arrays
+ * @param obj
+ * @returns
+ * A deep clone of the object
+ * */
+export declare const clone: <T>(obj: T) => T;
+/**
+ * Check if a value is null or undefined
+ * @param value
+ * @returns
+ * true if the value is null or undefined
+ * false otherwise
+ * */
+export declare const isNil: (value: unknown) => boolean;
+/**
+ * Check if a value is a number
+ * @param value
+ * @returns
+ *  true if the value is a number
+ * false otherwise
+ *  */
+export declare const isNumber: (value: unknown) => boolean;
+/**
+ * Check if a value is a boolean
+ * @param value
+ * @returns
+ * true if the value is a boolean
+ * false otherwise
+ * */
+export declare const isBoolean: (value: unknown) => boolean;
+/**
+ * Check if a value is a string
+ * @param value
+ * @returns
+ * true if the value is a string
+ * false otherwise
+ * */
+export declare const isString: (value: unknown) => boolean;
+/** Check if a value is a Date
+ * @param value
+ * @returns
+ * true if the value is a Date
+ * false otherwise
+ */
+export declare const isDate: (value: unknown) => boolean;
+/**
+ * Check if a value is a primitive
+ * @param value
+ * @returns
+ * true if the value is a primitive
+ * false otherwise
+ * null, number, boolean, string, symbol
+ */
+export declare const isPrimitive: (value: unknown) => boolean;
+/**
+ * Format an value with possible metadata to his original form, it also supports Map, Set, Arrays
+ * @param value
+ * @returns
+ * Orinal form of the value
+ */
+export declare const formatFromStore: <T>(value: T) => unknown;
+/**
+ * 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
+ */
+export declare const formatToStore: <T>(value: T) => unknown;
+//# sourceMappingURL=json-storage-formatter.d.ts.map

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

@@ -0,0 +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"}

package/lib/json-storage-formatter.js

@@ -0,0 +1,177 @@
+"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;
+/**
+ * Deep clone an object, it also suppors Map, Set, Arrays
+ * @param obj
+ * @returns
+ * A deep clone of the object
+ * */
+const clone = (obj) => {
+    debugger;
+    if ((0, exports.isPrimitive)(obj) || (0, exports.isDate)(obj)) {
+        return obj;
+    }
+    const isArray = Array.isArray(obj);
+    if (isArray) {
+        return obj.map((item) => (0, exports.clone)(item));
+    }
+    const isMap = obj instanceof Map;
+    if (isMap) {
+        const pairs = Array.from(obj.entries());
+        return new Map(pairs.map((pair) => (0, exports.clone)(pair)));
+    }
+    const isSet = obj instanceof Set;
+    if (isSet) {
+        const values = Array.from(obj.values());
+        return new Set(values.map((value) => (0, exports.clone)(value)));
+    }
+    const keys = Object.keys(obj);
+    return keys.reduce((acumulator, key) => {
+        const value = obj[key];
+        return Object.assign(Object.assign({}, acumulator), { [key]: (0, exports.clone)(value) });
+    }, {});
+};
+exports.clone = clone;
+/**
+ * Check if a value is null or undefined
+ * @param value
+ * @returns
+ * true if the value is null or undefined
+ * false otherwise
+ * */
+const isNil = (value) => value === null || value === undefined;
+exports.isNil = isNil;
+/**
+ * Check if a value is a number
+ * @param value
+ * @returns
+ *  true if the value is a number
+ * false otherwise
+ *  */
+const isNumber = (value) => typeof value === 'number';
+exports.isNumber = isNumber;
+/**
+ * Check if a value is a boolean
+ * @param value
+ * @returns
+ * true if the value is a boolean
+ * false otherwise
+ * */
+const isBoolean = (value) => typeof value === 'boolean';
+exports.isBoolean = isBoolean;
+/**
+ * Check if a value is a string
+ * @param value
+ * @returns
+ * true if the value is a string
+ * false otherwise
+ * */
+const isString = (value) => typeof value === 'string';
+exports.isString = isString;
+/** Check if a value is a Date
+ * @param value
+ * @returns
+ * true if the value is a Date
+ * false otherwise
+ */
+const isDate = (value) => value instanceof Date;
+exports.isDate = isDate;
+/**
+ * Check if a value is a primitive
+ * @param value
+ * @returns
+ * true if the value is a primitive
+ * false otherwise
+ * null, number, boolean, string, symbol
+ */
+const isPrimitive = (value) => (0, exports.isNil)(value) ||
+    (0, exports.isNumber)(value) ||
+    (0, exports.isBoolean)(value) ||
+    (0, exports.isString)(value) ||
+    typeof value === 'symbol';
+exports.isPrimitive = isPrimitive;
+/**
+ * Format an value with possible metadata to his original form, it also supports Map, Set, Arrays
+ * @param value
+ * @returns
+ * Orinal form of the value
+ */
+const formatFromStore = (value) => {
+    const format = (obj) => {
+        var _a, _b;
+        if ((0, exports.isPrimitive)(obj)) {
+            return obj;
+        }
+        const isMetaDate = (obj === null || obj === void 0 ? void 0 : obj._type_) === 'date';
+        if (isMetaDate) {
+            return new Date(obj.value);
+        }
+        const isMetaMap = (obj === null || obj === void 0 ? void 0 : obj._type_) === 'map';
+        if (isMetaMap) {
+            const mapData = ((_a = obj.value) !== 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';
+        if (isMetaSet) {
+            const setData = (_b = obj.value) !== null && _b !== void 0 ? _b : [].map((item) => (0, exports.formatFromStore)(item));
+            return new Set(setData);
+        }
+        const isArray = Array.isArray(obj);
+        if (isArray) {
+            return obj.map((item) => (0, exports.formatFromStore)(item));
+        }
+        const keys = Object.keys(obj);
+        return keys.reduce((acumulator, key) => {
+            const unformatedValue = obj[key];
+            return Object.assign(Object.assign({}, acumulator), { [key]: (0, exports.formatFromStore)(unformatedValue) });
+        }, {});
+    };
+    return format((0, exports.clone)(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
+ */
+const formatToStore = (value) => {
+    const format = (obj) => {
+        if ((0, exports.isPrimitive)(obj)) {
+            return obj;
+        }
+        const isArray = Array.isArray(obj);
+        if (isArray) {
+            return obj.map((item) => (0, exports.formatToStore)(item));
+        }
+        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 isSet = obj instanceof Set;
+        if (isSet) {
+            const values = Array.from(obj.values());
+            return {
+                _type_: 'set',
+                value: values.map((item) => (0, exports.formatToStore)(item)),
+            };
+        }
+        if ((0, exports.isDate)(obj)) {
+            return {
+                _type_: 'date',
+                value: obj.toISOString(),
+            };
+        }
+        const keys = Object.keys(obj);
+        return keys.reduce((acumulator, key) => {
+            const prop = obj[key];
+            return Object.assign(Object.assign({}, acumulator), { [key]: (0, exports.formatToStore)(prop) });
+        }, {});
+    };
+    return format((0, exports.clone)(value));
+};
+exports.formatToStore = formatToStore;

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "json-storage-formatter",
+  "version": "1.0.0",
+  "description": "Package for json stringify objects without losing data types",
+  "main": "lib/json-storage-formatter.js",
+  "files": [
+    "lib"
+  ],
+  "scripts": {
+    "test:debug": "node --inspect-brk node_modules/.bin/jest --watch --runInBand",
+    "test:quick": "jest --maxWorkers=4 -c --no-watchman -u",
+    "test:coverage": "jest --maxWorkers=4 -c --colors --no-watchman --verbose --coverage",
+    "build": "tsc",
+    "prepare": "npm run build",
+    "version": "npm run format && git add -A src",
+    "postversion": "git push && git push --tags"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/johnny-quesada-developer/json-storage-formatter.git"
+  },
+  "keywords": [
+    "json",
+    "state",
+    "typescript",
+    "storage",
+    "asynstorage",
+    "localstorage"
+  ],
+  "author": "johnny quesada",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/johnny-quesada-developer/json-storage-formatter/issues"
+  },
+  "homepage": "https://github.com/johnny-quesada-developer/json-storage-formatter#readme",
+  "devDependencies": {
+    "@types/jest": "^26.0.17",
+    "@types/lodash": "^4.14.165",
+    "@typescript-eslint/eslint-plugin": "^4.9.0",
+    "@typescript-eslint/parser": "^4.9.0",
+    "eslint": "^7.15.0",
+    "eslint-config-airbnb": "^18.2.1",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-jsx-a11y": "^6.4.1",
+    "eslint-plugin-react": "^7.21.5",
+    "eslint-plugin-react-hooks": "^4.2.0",
+    "jest": "^29.3.1",
+    "ts-jest": "^29.0.3",
+    "typescript": "^4.1.2"
+  }
+}