@chubbyts/chubbyts-decode-encode 1.0.0

package/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2022 Dominik Zogg
+
+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,182 @@
+# chubbyts-decode-encode
+
+[![CI](https://github.com/chubbyts/chubbyts-decode-encode/workflows/CI/badge.svg?branch=master)](https://github.com/chubbyts/chubbyts-decode-encode/actions?query=workflow%3ACI)
+[![Coverage Status](https://coveralls.io/repos/github/chubbyts/chubbyts-decode-encode/badge.svg?branch=master)](https://coveralls.io/github/chubbyts/chubbyts-decode-encode?branch=master)
+[![Infection MSI](https://badge.stryker-mutator.io/github.com/chubbyts/chubbyts-decode-encode/master)](https://dashboard.stryker-mutator.io/reports/github.com/chubbyts/chubbyts-decode-encode/master)
+[![npm-version](https://img.shields.io/npm/v/@chubbyts/chubbyts-decode-encode.svg)](https://www.npmjs.com/package/@chubbyts/chubbyts-decode-encode)
+
+[![bugs](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=bugs)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![code_smells](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=code_smells)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![coverage](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=coverage)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![duplicated_lines_density](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=duplicated_lines_density)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![ncloc](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=ncloc)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![sqale_rating](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=sqale_rating)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![alert_status](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=alert_status)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![reliability_rating](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=reliability_rating)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![security_rating](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=security_rating)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![sqale_index](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=sqale_index)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+[![vulnerabilities](https://sonarcloud.io/api/project_badges/measure?project=chubbyts_chubbyts-decode-encode&metric=vulnerabilities)](https://sonarcloud.io/dashboard?id=chubbyts_chubbyts-decode-encode)
+
+## Description
+
+A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.
+
+## Requirements
+
+ * node: 14
+ * [fast-xml-parser][2]: ^4.0.8
+ * [object-path][3]: ^0.11.8
+ * [yaml][4]: ^2.1.1
+
+## Installation
+
+Through [NPM](https://www.npmjs.com) as [@chubbyts/chubbyts-decode-encode][1].
+
+```ts
+npm i @chubbyts/chubbyts-decode-encode@^1.0.0
+```
+
+## Usage
+
+### Decoder
+
+#### createDecoder
+
+```ts
+import { createDecoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder';
+import { createJsonTypeDecoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder/json-type-decoder';
+
+const decoder = createDecoder([createJsonTypeDecoder()]);
+const data = decoder.decode('{"key":"value"}', 'application/json');
+// data: {key: "value"}
+const contentTypes = decoder.contentTypes;
+// contentTypes: ['application/json']
+```
+
+#### createJsonTypeDecoder
+
+```ts
+import { createJsonTypeDecoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder/json-type-decoder';
+
+const jsonTypeDecoder = createJsonTypeDecoder();
+const data = jsonTypeDecoder.decode('{"key":"value"}');
+// data: {key: "value"}
+const contentType = jsonTypeDecoder.contentType;
+// contentType: 'application/json'
+```
+
+#### createJsonxTypeDecoder
+
+```ts
+import { createJsonxTypeDecoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder/jsonx-type-decoder';
+
+const jsonxTypeDecoder = createJsonxTypeDecoder();
+const data = jsonxTypeDecoder.decode(`
+<?xml version="1.0" encoding="UTF-8"?>
+<json:object>
+  <json:string name="key">value</json:string>
+</json:object>
+`);
+// data: {key: "value"}
+const contentType = jsonxTypeDecoder.contentType;
+// contentType: 'application/jsonx+xml'
+```
+
+#### createUrlEncodedTypeDecoder
+
+```ts
+import { createUrlEncodedTypeDecoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder/url-encoded-type-decoder';
+
+const urlEncodedTypeDecoder = createUrlEncodedTypeDecoder();\"
+const data = urlEncodedTypeDecoder.decode('key=value');
+// data: {key: "value"}
+const contentType = urlEncodedTypeDecoder.contentType;
+// contentType: 'application/x-www-form-urlencoded'
+```
+
+#### createYamlTypeDecoder
+
+```ts
+import { createYamlTypeDecoder } from '@chubbyts/chubbyts-decode-encode/dist/decoder/yaml-type-decoder';
+
+const yamlTypeDecoder = createYamlTypeDecoder();
+const data = yamlTypeDecoder.decode('key: value');
+// data: {key: "value"}
+const contentType = yamlTypeDecoder.contentType;
+// contentType: 'application/x-yaml'
+```
+
+### Encoder
+
+#### createEncoder
+
+```ts
+import { createEncoder } from '@chubbyts/chubbyts-encode-encode/dist/encoder';
+import { createJsonTypeEncoder } from '@chubbyts/chubbyts-encode-encode/dist/encoder/json-type-encoder';
+
+const encoder = createEncoder([createJsonTypeEncoder()]);
+const encodedData = encoder.encode({key: "value"}, 'application/json');dec
+// encodedData: {"key":"value"}
+const contentTypes = encoder.contentTypes;
+// contentTypes: ['application/json']
+```
+
+#### createJsonTypeEncoder
+
+```ts
+import { createJsonTypeEncoder } from '@chubbyts/chubbyts-encode-encode/dist/encoder/json-type-encoder';
+
+const jsonTypeEncoder = createJsonTypeEncoder();
+const encodedData = jsonTypeEncoder.encode({key: "value"});
+// encodedData: {"key":"value"}
+const contentType = jsonTypeEncoder.contentType;
+// contentTypes: 'application/json'
+```
+
+#### createJsonxTypeEncoder
+
+```ts
+import { createJsonxTypeEncoder } from '@chubbyts/chubbyts-encode-encode/dist/encoder/jsonx-type-encoder';
+
+const jsonxTypeEncoder = createJsonxTypeEncoder();
+const encodedData = jsonxTypeEncoder.encode({key: "value"});
+// encodedData: <?xml version="1.0" encoding="UTF-8"?>
+// <json:object>
+//   <json:string name="key">value</json:string>
+// </json:object>
+const contentType = jsonxTypeEncoder.contentType;
+// contentTypes: 'application/jsonx+xml'
+```
+
+#### createUrlEncodedTypeEncoder
+
+```ts
+import { createUrlEncodedTypeEncoder } from '@chubbyts/chubbyts-encode-encode/dist/encoder/url-encoded-type-encoder';
+
+const urlEncodedTypeEncoder = createUrlEncodedTypeEncoder();
+const encodedData = urlEncodedTypeEncoder.encode({key: "value"});
+// encodedData: key=value
+const contentType = urlEncodedTypeEncoder.contentType;
+// contentTypes: 'application/x-www-form-urlencoded'
+```
+
+#### createYamlTypeEncoder
+
+```ts
+import { createYamlTypeEncoder } from '@chubbyts/chubbyts-encode-encode/dist/encoder/yaml-type-encoder';
+
+const yamlTypeEncoder = createYamlTypeEncoder();
+const encodedData = yamlTypeEncoder.encode({key: "value"});
+// encodedData: key: value
+const contentType = yamlTypeEncoder.contentType;
+// contentTypes: 'application/x-yaml'
+```
+
+## Copyright
+
+Dominik Zogg 2022
+
+[1]: https://www.npmjs.com/package/@chubbyts/chubbyts-decode-encode
+[2]: https://www.npmjs.com/package/fast-xml-parser
+[3]: https://www.npmjs.com/package/object-path
+[4]: https://www.npmjs.com/package/yaml

package/dist/decoder/index.d.ts

@@ -0,0 +1,10 @@
+import { Data } from '..';
+export declare type TypeDecoder = {
+    decode: (encodedData: string) => Data;
+    contentType: string;
+};
+export declare type Decoder = {
+    decode: (encodedData: string, contentType: string) => Data;
+    contentTypes: Array<string>;
+};
+export declare const createDecoder: (decoderTypes: Array<TypeDecoder>) => Decoder;

package/dist/decoder/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecoder = void 0;
+const createDecoder = (decoderTypes) => {
+    const decoderTypeMap = new Map(decoderTypes.map((DecoderType) => [DecoderType.contentType, DecoderType]));
+    const contentTypes = Array.from(decoderTypeMap.keys());
+    return {
+        decode: (encodedData, contentType) => {
+            if (decoderTypeMap.has(contentType)) {
+                return decoderTypeMap.get(contentType).decode(encodedData);
+            }
+            throw new Error(`Unsupported contentType "${contentType}", supported contentTypes are "${contentTypes.join('", "')}".`);
+        },
+        contentTypes,
+    };
+};
+exports.createDecoder = createDecoder;

package/dist/decoder/json-type-decoder.d.ts

@@ -0,0 +1,2 @@
+import { TypeDecoder } from '.';
+export declare const createJsonTypeDecoder: () => TypeDecoder;

package/dist/decoder/json-type-decoder.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonTypeDecoder = void 0;
+const createJsonTypeDecoder = () => {
+    const decode = (encodedData) => {
+        return JSON.parse(encodedData);
+    };
+    const contentType = 'application/json';
+    return {
+        decode,
+        contentType,
+    };
+};
+exports.createJsonTypeDecoder = createJsonTypeDecoder;

package/dist/decoder/jsonx-type-decoder.d.ts

@@ -0,0 +1,2 @@
+import { TypeDecoder } from '.';
+export declare const createJsonxTypeDecoder: () => TypeDecoder;

package/dist/decoder/jsonx-type-decoder.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonxTypeDecoder = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const jsonx_datatypes_1 = require("../jsonx-datatypes");
+const decodeHtmlEntities = (string) => string.replace(/&#\d+;/gm, (code) => String.fromCharCode(code.match(/\d+/)[0]));
+const isWithName = (node) => typeof node === 'object' &&
+    null !== node &&
+    typeof node[':@'] === 'object' &&
+    node[':@'] !== null &&
+    typeof node[':@']['@_name'] === 'string';
+const isObjectNode = (node) => Object.keys(node)[0] === jsonx_datatypes_1.DATATYPE_OBJECT && Array.isArray(node[jsonx_datatypes_1.DATATYPE_OBJECT]);
+const isArrayNode = (node) => Object.keys(node)[0] === jsonx_datatypes_1.DATATYPE_ARRAY && Array.isArray(node[jsonx_datatypes_1.DATATYPE_ARRAY]);
+const isStringNode = (node) => Object.keys(node)[0] === jsonx_datatypes_1.DATATYPE_STRING && Array.isArray(node[jsonx_datatypes_1.DATATYPE_STRING]);
+const isNumberNode = (node) => Object.keys(node)[0] === jsonx_datatypes_1.DATATYPE_NUMBER && Array.isArray(node[jsonx_datatypes_1.DATATYPE_NUMBER]);
+const isBooleanNode = (node) => Object.keys(node)[0] === jsonx_datatypes_1.DATATYPE_BOOLEAN && Array.isArray(node[jsonx_datatypes_1.DATATYPE_BOOLEAN]);
+const isNullNode = (node) => Object.keys(node)[0] === jsonx_datatypes_1.DATATYPE_NULL && Array.isArray(node[jsonx_datatypes_1.DATATYPE_NULL]);
+const convertNullNode = () => {
+    return null;
+};
+const convertBooleanNode = (node) => {
+    return node['json:boolean'][0]['#text'];
+};
+const convertNumberNode = (node) => {
+    return node['json:number'][0]['#text'];
+};
+const convertStringNode = (node) => {
+    return decodeHtmlEntities(node['json:string'][0]['#text']);
+};
+const convertNode = (node) => {
+    if (isObjectNode(node)) {
+        return convertObjectNode(node);
+    }
+    else if (isArrayNode(node)) {
+        return convertArrayNode(node);
+    }
+    else if (isStringNode(node)) {
+        return convertStringNode(node);
+    }
+    else if (isNumberNode(node)) {
+        return convertNumberNode(node);
+    }
+    else if (isBooleanNode(node)) {
+        return convertBooleanNode(node);
+    }
+    else if (isNullNode(node)) {
+        return convertNullNode();
+    }
+    throw new Error(`Unsupported node: ${JSON.stringify(node)}`);
+};
+const convertArrayNode = (node) => {
+    return node['json:array'].map(convertNode);
+};
+const convertNodeWithName = (node) => {
+    if (isObjectNode(node) && isWithName(node)) {
+        return [node[':@']['@_name'], convertObjectNode(node)];
+    }
+    else if (isArrayNode(node) && isWithName(node)) {
+        return [node[':@']['@_name'], convertArrayNode(node)];
+    }
+    else if (isStringNode(node) && isWithName(node)) {
+        return [node[':@']['@_name'], convertStringNode(node)];
+    }
+    else if (isNumberNode(node) && isWithName(node)) {
+        return [node[':@']['@_name'], convertNumberNode(node)];
+    }
+    else if (isBooleanNode(node) && isWithName(node)) {
+        return [node[':@']['@_name'], convertBooleanNode(node)];
+    }
+    else if (isNullNode(node) && isWithName(node)) {
+        return [node[':@']['@_name'], convertNullNode()];
+    }
+    throw new Error(`Unsupported node: ${JSON.stringify(node)}`);
+};
+const convertObjectNode = (node) => {
+    return Object.fromEntries(node['json:object'].map(convertNodeWithName));
+};
+const createJsonxTypeDecoder = () => {
+    const decode = (encodedData) => {
+        const parser = new fast_xml_parser_1.XMLParser({ preserveOrder: true, ignoreAttributes: false, htmlEntities: false });
+        const parsedData = parser.parse(encodedData);
+        return convertNode(parsedData[1]);
+    };
+    const contentType = 'application/jsonx+xml';
+    return {
+        decode,
+        contentType,
+    };
+};
+exports.createJsonxTypeDecoder = createJsonxTypeDecoder;

package/dist/decoder/url-encoded-type-decoder.d.ts

@@ -0,0 +1,2 @@
+import { TypeDecoder } from '.';
+export declare const createUrlEncodedTypeDecoder: () => TypeDecoder;

package/dist/decoder/url-encoded-type-decoder.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUrlEncodedTypeDecoder = void 0;
+const object_path_1 = require("object-path");
+const optimizeValue = (value) => {
+    if (value === 'null') {
+        return null;
+    }
+    if (value === 'true') {
+        return true;
+    }
+    if (value === 'false') {
+        return false;
+    }
+    const integer = parseInt(value, 10);
+    if (!isNaN(integer) && integer.toString() === value) {
+        return integer;
+    }
+    const float = parseFloat(value);
+    if (!isNaN(float) && float.toString() === value) {
+        return float;
+    }
+    return value;
+};
+const createUrlEncodedTypeDecoder = () => {
+    const decode = (encodedData) => {
+        let data = {};
+        encodedData.split('&').forEach((keyValue) => {
+            const [rawKey, rawValue] = keyValue.split('=');
+            const key = rawKey.replace(/\[[^\]]+\]/gm, (match) => `.${match.match(/[^\[\]]+/)[0]}`);
+            const value = optimizeValue(decodeURIComponent(rawValue));
+            (0, object_path_1.set)(data, key, value);
+        });
+        return data;
+    };
+    const contentType = 'application/x-www-form-urlencoded';
+    return {
+        decode,
+        contentType,
+    };
+};
+exports.createUrlEncodedTypeDecoder = createUrlEncodedTypeDecoder;

package/dist/decoder/yaml-type-decoder.d.ts

@@ -0,0 +1,2 @@
+import { TypeDecoder } from '.';
+export declare const createYamlTypeDecoder: () => TypeDecoder;

package/dist/decoder/yaml-type-decoder.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createYamlTypeDecoder = void 0;
+const yaml_1 = require("yaml");
+const createYamlTypeDecoder = () => {
+    const decode = (encodedData) => {
+        return (0, yaml_1.parse)(encodedData);
+    };
+    const contentType = 'application/x-yaml';
+    return {
+        decode,
+        contentType,
+    };
+};
+exports.createYamlTypeDecoder = createYamlTypeDecoder;

package/dist/encoder/index.d.ts

@@ -0,0 +1,10 @@
+import { Data } from '..';
+export declare type TypeEncoder = {
+    encode: (data: Data) => string;
+    contentType: string;
+};
+export declare type Encoder = {
+    encode: (data: Data, contentType: string) => string;
+    contentTypes: Array<string>;
+};
+export declare const createEncoder: (encoderTypes: Array<TypeEncoder>) => Encoder;

package/dist/encoder/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEncoder = void 0;
+const createEncoder = (encoderTypes) => {
+    const encoderTypeMap = new Map(encoderTypes.map((encoderType) => [encoderType.contentType, encoderType]));
+    const contentTypes = Array.from(encoderTypeMap.keys());
+    return {
+        encode: (data, contentType) => {
+            if (encoderTypeMap.has(contentType)) {
+                return encoderTypeMap.get(contentType).encode(data);
+            }
+            throw new Error(`Unsupported contentType "${contentType}", supported contentTypes are "${contentTypes.join('", "')}".`);
+        },
+        contentTypes,
+    };
+};
+exports.createEncoder = createEncoder;

package/dist/encoder/json-type-encoder.d.ts

@@ -0,0 +1,2 @@
+import { TypeEncoder } from '.';
+export declare const createJsonTypeEncoder: (prettyPrint?: boolean) => TypeEncoder;

package/dist/encoder/json-type-encoder.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonTypeEncoder = void 0;
+const createJsonTypeEncoder = (prettyPrint = false) => {
+    const encode = (data) => JSON.stringify(data, undefined, prettyPrint ? 4 : undefined);
+    const contentType = 'application/json';
+    return {
+        encode,
+        contentType,
+    };
+};
+exports.createJsonTypeEncoder = createJsonTypeEncoder;

package/dist/encoder/jsonx-type-encoder.d.ts

@@ -0,0 +1,2 @@
+import { TypeEncoder } from '.';
+export declare const createJsonxTypeEncoder: (prettyPrint?: boolean) => TypeEncoder;

package/dist/encoder/jsonx-type-encoder.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJsonxTypeEncoder = void 0;
+const __1 = require("..");
+const jsonx_datatypes_1 = require("../jsonx-datatypes");
+const fast_xml_parser_1 = require("fast-xml-parser");
+const encodeHtmlEntities = (string) => string.replace(/[\u00A0-\u9999<>\&]/g, (i) => '&#' + i.charCodeAt(0) + ';');
+const createXmlNode = () => {
+    return {
+        '?xml': [
+            {
+                '#text': '',
+            },
+        ],
+        ':@': {
+            '@_version': '1.0',
+            '@_encoding': 'UTF-8',
+        },
+    };
+};
+const createJsonxAttributes = () => {
+    return {
+        ':@': {
+            '@_xsi:schemaLocation': 'http://www.datapower.com/schemas/json jsonx.xsd',
+            '@_xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+            '@_xmlns:json': 'http://www.ibm.com/xmlns/prod/2009/jsonx',
+        },
+    };
+};
+const createNullNode = (key = undefined) => {
+    const node = {
+        [jsonx_datatypes_1.DATATYPE_NULL]: [],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createBooleanNode = (value, key = undefined) => {
+    const node = {
+        [jsonx_datatypes_1.DATATYPE_BOOLEAN]: [
+            {
+                '#text': value,
+            },
+        ],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createNumberNode = (value, key = undefined) => {
+    const node = {
+        [jsonx_datatypes_1.DATATYPE_NUMBER]: [
+            {
+                '#text': value,
+            },
+        ],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createStringNode = (value, key = undefined) => {
+    const node = {
+        [jsonx_datatypes_1.DATATYPE_STRING]: [
+            {
+                '#text': value === value.trim() ? encodeHtmlEntities(value) : `<![CDATA[${encodeHtmlEntities(value)}]]>`,
+            },
+        ],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createNode = (value, key = undefined) => {
+    if ((0, __1.isObject)(value)) {
+        return createObjectNode(value, key);
+    }
+    else if ((0, __1.isArray)(value)) {
+        return createArrayNode(value, key);
+    }
+    else if ((0, __1.isString)(value)) {
+        return createStringNode(value, key);
+    }
+    else if ((0, __1.isNumber)(value)) {
+        return createNumberNode(value, key);
+    }
+    else if ((0, __1.isBoolean)(value)) {
+        return createBooleanNode(value, key);
+    }
+    else if ((0, __1.isNull)(value)) {
+        return createNullNode(key);
+    }
+    throw new Error(`Unsupported value: ${JSON.stringify(value)}`);
+};
+const createArrayNode = (value, key = undefined) => {
+    const elements = value.map((subValue) => createNode(subValue));
+    const node = {
+        [jsonx_datatypes_1.DATATYPE_ARRAY]: elements,
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createObjectNode = (value, key = undefined) => {
+    const elements = Object.entries(value).map(([subKey, subValue]) => createNode(subValue, subKey));
+    const node = {
+        [jsonx_datatypes_1.DATATYPE_OBJECT]: elements,
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createJsonxTypeEncoder = (prettyPrint = false) => {
+    const encode = (data) => {
+        const builder = new fast_xml_parser_1.XMLBuilder({
+            preserveOrder: true,
+            ignoreAttributes: false,
+            processEntities: false,
+            format: prettyPrint,
+        });
+        return builder.build([
+            createXmlNode(),
+            {
+                ...createNode(data),
+                ...createJsonxAttributes(),
+            },
+        ]);
+    };
+    const contentType = 'application/jsonx+xml';
+    return {
+        encode,
+        contentType,
+    };
+};
+exports.createJsonxTypeEncoder = createJsonxTypeEncoder;

package/dist/encoder/url-encoded-type-encoder.d.ts

@@ -0,0 +1,2 @@
+import { TypeEncoder } from '.';
+export declare const createUrlEncodedTypeEncoder: () => TypeEncoder;

package/dist/encoder/url-encoded-type-encoder.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUrlEncodedTypeEncoder = void 0;
+const __1 = require("..");
+const getValueAsString = (value) => {
+    if (null === value) {
+        return 'null';
+    }
+    if (typeof value === 'boolean') {
+        return value ? 'true' : 'false';
+    }
+    if (typeof value === 'number') {
+        return value.toString();
+    }
+    return value;
+};
+const getKeyValue = (path, key, value) => {
+    const subPath = '' !== path ? path + '[' + key + ']' : key;
+    if ((0, __1.isObject)(value) || (0, __1.isArray)(value)) {
+        const queryPart = buildQuery(value, subPath);
+        return queryPart !== '' ? queryPart + '&' : '';
+    }
+    return subPath + '=' + encodeURIComponent(getValueAsString(value)) + '&';
+};
+const buildQuery = (data, path = '') => {
+    let query = '';
+    if ((0, __1.isObject)(data)) {
+        Object.keys(data).forEach((key) => {
+            query += getKeyValue(path, key, data[key]);
+        });
+    }
+    else if ((0, __1.isArray)(data)) {
+        data.forEach((value, i) => {
+            query += getKeyValue(path, i.toString(), value);
+        });
+    }
+    return query.substring(0, query.length - 1);
+};
+const createUrlEncodedTypeEncoder = () => {
+    const encode = (data) => {
+        return buildQuery(JSON.parse(JSON.stringify(data)));
+    };
+    const contentType = 'application/x-www-form-urlencoded';
+    return {
+        encode,
+        contentType,
+    };
+};
+exports.createUrlEncodedTypeEncoder = createUrlEncodedTypeEncoder;

package/dist/encoder/yaml-type-encoder.d.ts

@@ -0,0 +1,2 @@
+import { TypeEncoder } from '.';
+export declare const createYamlTypeEncoder: () => TypeEncoder;

package/dist/encoder/yaml-type-encoder.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createYamlTypeEncoder = void 0;
+const yaml_1 = require("yaml");
+const createYamlTypeEncoder = () => {
+    const encode = (data) => (0, yaml_1.stringify)(JSON.parse(JSON.stringify(data)), { indent: 4 });
+    const contentType = 'application/x-yaml';
+    return {
+        encode,
+        contentType,
+    };
+};
+exports.createYamlTypeEncoder = createYamlTypeEncoder;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export declare type Data = {
+    [key: string]: Data;
+} | Array<Data> | string | number | boolean | null;
+export declare const isNull: (value: unknown) => value is null;
+export declare const isBoolean: (value: unknown) => value is boolean;
+export declare const isNumber: (value: unknown) => value is number;
+export declare const isString: (value: unknown) => value is string;
+export declare const isArray: (value: unknown) => value is Data[];
+export declare const isObject: (value: unknown) => value is {
+    [key: string]: Data;
+};

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = exports.isArray = exports.isString = exports.isNumber = exports.isBoolean = exports.isNull = void 0;
+const isNull = (value) => value === null;
+exports.isNull = isNull;
+const isBoolean = (value) => typeof value === 'boolean';
+exports.isBoolean = isBoolean;
+const isNumber = (value) => typeof value === 'number';
+exports.isNumber = isNumber;
+const isString = (value) => typeof value === 'string';
+exports.isString = isString;
+const isArray = (value) => Array.isArray(value);
+exports.isArray = isArray;
+const isObject = (value) => value !== null && typeof value === 'object' && value.constructor.name == 'Object';
+exports.isObject = isObject;

package/dist/jsonx-datatypes.d.ts

@@ -0,0 +1,36 @@
+export declare const DATATYPE_OBJECT = "json:object";
+export declare const DATATYPE_ARRAY = "json:array";
+export declare const DATATYPE_BOOLEAN = "json:boolean";
+export declare const DATATYPE_STRING = "json:string";
+export declare const DATATYPE_NUMBER = "json:number";
+export declare const DATATYPE_NULL = "json:null";
+export declare type WithName = {
+    ':@': {
+        '@_name': string;
+    };
+};
+export declare type JsonxNullNode = {
+    [DATATYPE_NULL]: Array<never>;
+};
+export declare type JsonxBooleanNode = {
+    [DATATYPE_BOOLEAN]: Array<{
+        '#text': boolean;
+    }>;
+};
+export declare type JsonxNumberNode = {
+    [DATATYPE_NUMBER]: Array<{
+        '#text': number;
+    }>;
+};
+export declare type JsonxStringNode = {
+    [DATATYPE_STRING]: Array<{
+        '#text': string;
+    }>;
+};
+export declare type JsonxArrayNode = {
+    [DATATYPE_ARRAY]: Array<JsonxNullNode | JsonxBooleanNode | JsonxNumberNode | JsonxStringNode | JsonxArrayNode | JsonxObjectNode>;
+};
+export declare type JsonxObjectNode = {
+    [DATATYPE_OBJECT]: Array<JsonxNullNode | JsonxBooleanNode | JsonxNumberNode | JsonxStringNode | JsonxArrayNode | JsonxObjectNode>;
+};
+export declare type JsonxNode = JsonxNullNode | JsonxBooleanNode | JsonxNumberNode | JsonxStringNode | JsonxArrayNode | JsonxObjectNode;

package/dist/jsonx-datatypes.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATATYPE_NULL = exports.DATATYPE_NUMBER = exports.DATATYPE_STRING = exports.DATATYPE_BOOLEAN = exports.DATATYPE_ARRAY = exports.DATATYPE_OBJECT = void 0;
+exports.DATATYPE_OBJECT = 'json:object';
+exports.DATATYPE_ARRAY = 'json:array';
+exports.DATATYPE_BOOLEAN = 'json:boolean';
+exports.DATATYPE_STRING = 'json:string';
+exports.DATATYPE_NUMBER = 'json:number';
+exports.DATATYPE_NULL = 'json:null';

package/package.json

@@ -0,0 +1,69 @@
+{
+  "name": "@chubbyts/chubbyts-decode-encode",
+  "version": "1.0.0",
+  "description": "A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.",
+  "keywords": [
+    "chubbyts",
+    "decode",
+    "encode",
+    "json",
+    "jsonx",
+    "url-encoded",
+    "xml",
+    "yaml"
+  ],
+  "author": "Dominik Zogg",
+  "license": "MIT",
+  "repository": "chubbyts/chubbyts-decode-encode",
+  "scripts": {
+    "cs-fix": "prettier --write src tests",
+    "cs": "prettier --check src tests",
+    "test": "jest",
+    "infection": "stryker run",
+    "build": "tsc",
+    "prepare": "rm -Rf dist && npm run build && npm run cs && npm run test"
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node",
+    "collectCoverageFrom": [
+      "src/**/*.ts"
+    ],
+    "coverageThreshold": {
+      "global": {
+        "lines": 100
+      }
+    }
+  },
+  "prettier": {
+    "printWidth": 120,
+    "tabWidth": 2,
+    "singleQuote": true,
+    "trailingComma": "all"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=14"
+  },
+  "dependencies": {
+    "fast-xml-parser": "^4.0.8",
+    "object-path": "^0.11.8",
+    "yaml": "^2.1.1"
+  },
+  "devDependencies": {
+    "@stryker-mutator/core": "^6.0.2",
+    "@stryker-mutator/jest-runner": "^6.0.2",
+    "@types/jest": "^27.5.1",
+    "@types/node": "^14",
+    "@types/object-path": "^0.11.1",
+    "jest": "^28.1.0",
+    "prettier": "^2.6.2",
+    "ts-jest": "^28.0.3",
+    "typescript": "^4.7.2"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}