@chubbyts/chubbyts-decode-encode 1.2.0 → 1.3.0

package/README.md

@@ -24,17 +24,17 @@ A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.
 ## Requirements
 
  * node: 16
- * [@chubbyts/chubbyts-throwable-to-error][2]: ^1.1.0
- * [fast-xml-parser][3]: ^4.2.2
- * [qs][4]: ^6.11.1
- * [yaml][5]: ^2.2.2
+ * [@chubbyts/chubbyts-throwable-to-error][2]: ^1.2.1
+ * [fast-xml-parser][3]: ^4.2.6
+ * [qs][4]: ^6.11.2
+ * [yaml][5]: ^2.3.1
 
 ## Installation
 
 Through [NPM](https://www.npmjs.com) as [@chubbyts/chubbyts-decode-encode][1].
 
 ```ts
-npm i @chubbyts/chubbyts-decode-encode@^1.2.0
+npm i @chubbyts/chubbyts-decode-encode@^1.3.0
 ```
 
 ## Usage

package/dist/decoder/index.d.ts

@@ -1,4 +1,4 @@
-import type { Data } from '..';
+import type { Data } from '../index';
 export declare class DecodeError extends Error {
     constructor(message: string, stack?: string);
 }

package/dist/decoder/index.mjs

@@ -0,0 +1,19 @@
+export class DecodeError extends Error {
+    constructor(message, stack) {
+        super(message);
+        this.stack = stack;
+    }
+}
+export 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,
+    };
+};

package/dist/decoder/{json-type-decoder.js → json-type-decoder.cjs}

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJsonTypeDecoder = void 0;
 const throwable_to_error_1 = require("@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error");
-const _1 = require(".");
+const index_1 = require("./index.cjs");
 const createJsonTypeDecoder = () => {
     return {
         decode: (encodedData) => {
@@ -11,7 +11,7 @@ const createJsonTypeDecoder = () => {
             }
             catch (e) {
                 const error = (0, throwable_to_error_1.throwableToError)(e);
-                throw new _1.DecodeError(error.message, error.stack);
+                throw new index_1.DecodeError(error.message, error.stack);
             }
         },
         contentType: 'application/json',

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

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

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

@@ -0,0 +1,16 @@
+import { throwableToError } from '@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error';
+import { DecodeError } from './index.mjs';
+export const createJsonTypeDecoder = () => {
+    return {
+        decode: (encodedData) => {
+            try {
+                return JSON.parse(encodedData);
+            }
+            catch (e) {
+                const error = throwableToError(e);
+                throw new DecodeError(error.message, error.stack);
+            }
+        },
+        contentType: 'application/json',
+    };
+};

package/dist/decoder/{jsonx-type-decoder.js → jsonx-type-decoder.cjs}

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJsonxTypeDecoder = void 0;
 const fast_xml_parser_1 = require("fast-xml-parser");
 const throwable_to_error_1 = require("@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error");
-const jsonx_datatypes_1 = require("../jsonx-datatypes");
-const _1 = require(".");
+const jsonx_datatypes_1 = require("../jsonx-datatypes.cjs");
+const index_1 = require("./index.cjs");
 const decodeHtmlEntities = (string) => string.replace(/&#\d+;/gm, (code) => String.fromCharCode(code.match(/\d+/)[0]));
 const isWithName = (node) => typeof node === 'object' &&
     null !== node &&
@@ -86,7 +86,7 @@ const createJsonxTypeDecoder = () => {
             }
             catch (e) {
                 const error = (0, throwable_to_error_1.throwableToError)(e);
-                throw new _1.DecodeError(error.message, error.stack);
+                throw new index_1.DecodeError(error.message, error.stack);
             }
         },
         contentType: 'application/jsonx+xml',

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

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

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

@@ -0,0 +1,91 @@
+import { XMLParser } from 'fast-xml-parser';
+import { throwableToError } from '@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error';
+import { DATATYPE_ARRAY, DATATYPE_BOOLEAN, DATATYPE_NULL, DATATYPE_NUMBER, DATATYPE_OBJECT, DATATYPE_STRING, } from '../jsonx-datatypes.mjs';
+import { DecodeError } from './index.mjs';
+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] === DATATYPE_OBJECT && Array.isArray(node[DATATYPE_OBJECT]);
+const isArrayNode = (node) => Object.keys(node)[0] === DATATYPE_ARRAY && Array.isArray(node[DATATYPE_ARRAY]);
+const isStringNode = (node) => Object.keys(node)[0] === DATATYPE_STRING && Array.isArray(node[DATATYPE_STRING]);
+const isNumberNode = (node) => Object.keys(node)[0] === DATATYPE_NUMBER && Array.isArray(node[DATATYPE_NUMBER]);
+const isBooleanNode = (node) => Object.keys(node)[0] === DATATYPE_BOOLEAN && Array.isArray(node[DATATYPE_BOOLEAN]);
+const isNullNode = (node) => Object.keys(node)[0] === DATATYPE_NULL && Array.isArray(node[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));
+};
+export const createJsonxTypeDecoder = () => {
+    return {
+        decode: (encodedData) => {
+            try {
+                const parser = new XMLParser({ preserveOrder: true, ignoreAttributes: false, htmlEntities: false });
+                return convertNode(parser.parse(encodedData)[1]);
+            }
+            catch (e) {
+                const error = throwableToError(e);
+                throw new DecodeError(error.message, error.stack);
+            }
+        },
+        contentType: 'application/jsonx+xml',
+    };
+};

package/dist/decoder/{url-encoded-type-decoder.js → url-encoded-type-decoder.cjs}

@@ -2,12 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUrlEncodedTypeDecoder = void 0;
 const qs_1 = require("qs");
-const __1 = require("..");
+const index_1 = require("../index.cjs");
 const decodeValue = (value) => {
-    if ((0, __1.isObject)(value)) {
+    if ((0, index_1.isObject)(value)) {
         return Object.fromEntries(Object.entries(value).map(([subKey, subValue]) => [subKey, decodeValue(subValue)]));
     }
-    if ((0, __1.isArray)(value)) {
+    if ((0, index_1.isArray)(value)) {
         return value.map(decodeValue);
     }
     if (value === 'null') {

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

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

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

@@ -0,0 +1,34 @@
+import { parse } from 'qs';
+import { isArray, isObject } from '../index.mjs';
+const decodeValue = (value) => {
+    if (isObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([subKey, subValue]) => [subKey, decodeValue(subValue)]));
+    }
+    if (isArray(value)) {
+        return value.map(decodeValue);
+    }
+    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;
+};
+export const createUrlEncodedTypeDecoder = () => {
+    return {
+        decode: (encodedData) => decodeValue(parse(encodedData, { depth: 100 })),
+        contentType: 'application/x-www-form-urlencoded',
+    };
+};

package/dist/decoder/{yaml-type-decoder.js → yaml-type-decoder.cjs}

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createYamlTypeDecoder = void 0;
 const yaml_1 = require("yaml");
 const throwable_to_error_1 = require("@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error");
-const _1 = require(".");
+const index_1 = require("./index.cjs");
 const createYamlTypeDecoder = () => {
     return {
         decode: (encodedData) => {
@@ -12,7 +12,7 @@ const createYamlTypeDecoder = () => {
             }
             catch (e) {
                 const error = (0, throwable_to_error_1.throwableToError)(e);
-                throw new _1.DecodeError(error.message, error.stack);
+                throw new index_1.DecodeError(error.message, error.stack);
             }
         },
         contentType: 'application/x-yaml',

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

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

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

@@ -0,0 +1,17 @@
+import { parse } from 'yaml';
+import { throwableToError } from '@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error';
+import { DecodeError } from './index.mjs';
+export const createYamlTypeDecoder = () => {
+    return {
+        decode: (encodedData) => {
+            try {
+                return parse(encodedData);
+            }
+            catch (e) {
+                const error = throwableToError(e);
+                throw new DecodeError(error.message, error.stack);
+            }
+        },
+        contentType: 'application/x-yaml',
+    };
+};

package/dist/encoder/index.d.ts

@@ -1,4 +1,4 @@
-import type { Data } from '..';
+import type { Data } from '../index';
 export declare class EncodeError extends Error {
     constructor(message: string, stack?: string);
 }

package/dist/encoder/index.mjs

@@ -0,0 +1,19 @@
+export class EncodeError extends Error {
+    constructor(message, stack) {
+        super(message);
+        this.stack = stack;
+    }
+}
+export 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,
+    };
+};

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

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

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

@@ -0,0 +1,6 @@
+export const createJsonTypeEncoder = (prettyPrint = false) => {
+    return {
+        encode: (data) => JSON.stringify(data, undefined, prettyPrint ? 4 : undefined),
+        contentType: 'application/json',
+    };
+};

package/dist/encoder/{jsonx-type-encoder.js → jsonx-type-encoder.cjs}

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJsonxTypeEncoder = void 0;
 const fast_xml_parser_1 = require("fast-xml-parser");
 const throwable_to_error_1 = require("@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error");
-const __1 = require("..");
-const jsonx_datatypes_1 = require("../jsonx-datatypes");
-const _1 = require(".");
+const index_1 = require("../index.cjs");
+const jsonx_datatypes_1 = require("../jsonx-datatypes.cjs");
+const index_2 = require("./index.cjs");
 const encodeHtmlEntities = (string) => string.replace(/[\u00A0-\u9999<>&]/g, (i) => '&#' + i.charCodeAt(0) + ';');
 const createXmlNode = () => {
     return {
@@ -98,22 +98,22 @@ const createStringNode = (value, key = undefined) => {
     };
 };
 const createNode = (value, key = undefined) => {
-    if ((0, __1.isObject)(value)) {
+    if ((0, index_1.isObject)(value)) {
         return createObjectNode(value, key);
     }
-    else if ((0, __1.isArray)(value)) {
+    else if ((0, index_1.isArray)(value)) {
         return createArrayNode(value, key);
     }
-    else if ((0, __1.isString)(value)) {
+    else if ((0, index_1.isString)(value)) {
         return createStringNode(value, key);
     }
-    else if ((0, __1.isNumber)(value)) {
+    else if ((0, index_1.isNumber)(value)) {
         return createNumberNode(value, key);
     }
-    else if ((0, __1.isBoolean)(value)) {
+    else if ((0, index_1.isBoolean)(value)) {
         return createBooleanNode(value, key);
     }
-    else if ((0, __1.isNull)(value)) {
+    else if ((0, index_1.isNull)(value)) {
         return createNullNode(key);
     }
     throw new Error(`Unsupported value: ${JSON.stringify(value)}`);
@@ -168,7 +168,7 @@ const createJsonxTypeEncoder = (prettyPrint = false) => {
             }
             catch (e) {
                 const error = (0, throwable_to_error_1.throwableToError)(e);
-                throw new _1.EncodeError(error.message, error.stack);
+                throw new index_2.EncodeError(error.message, error.stack);
             }
         },
         contentType: 'application/jsonx+xml',

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

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

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

@@ -0,0 +1,173 @@
+import { XMLBuilder } from 'fast-xml-parser';
+import { throwableToError } from '@chubbyts/chubbyts-throwable-to-error/dist/throwable-to-error';
+import { isArray, isBoolean, isNumber, isObject, isString, isNull } from '../index.mjs';
+import { DATATYPE_ARRAY, DATATYPE_BOOLEAN, DATATYPE_NULL, DATATYPE_NUMBER, DATATYPE_OBJECT, DATATYPE_STRING, } from '../jsonx-datatypes.mjs';
+import { EncodeError } from './index.mjs';
+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 = {
+        [DATATYPE_NULL]: [],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createBooleanNode = (value, key = undefined) => {
+    const node = {
+        [DATATYPE_BOOLEAN]: [
+            {
+                '#text': value,
+            },
+        ],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createNumberNode = (value, key = undefined) => {
+    const node = {
+        [DATATYPE_NUMBER]: [
+            {
+                '#text': value,
+            },
+        ],
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+const createStringNode = (value, key = undefined) => {
+    const node = {
+        [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 (isObject(value)) {
+        return createObjectNode(value, key);
+    }
+    else if (isArray(value)) {
+        return createArrayNode(value, key);
+    }
+    else if (isString(value)) {
+        return createStringNode(value, key);
+    }
+    else if (isNumber(value)) {
+        return createNumberNode(value, key);
+    }
+    else if (isBoolean(value)) {
+        return createBooleanNode(value, key);
+    }
+    else if (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 = {
+        [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 = {
+        [DATATYPE_OBJECT]: elements,
+    };
+    if (key === undefined) {
+        return node;
+    }
+    return {
+        ...node,
+        ':@': {
+            '@_name': key,
+        },
+    };
+};
+export const createJsonxTypeEncoder = (prettyPrint = false) => {
+    const builder = new XMLBuilder({
+        preserveOrder: true,
+        ignoreAttributes: false,
+        processEntities: false,
+        format: prettyPrint,
+    });
+    return {
+        encode: (data) => {
+            try {
+                return builder.build([
+                    createXmlNode(),
+                    {
+                        ...createNode(data),
+                        ...createJsonxAttributes(),
+                    },
+                ]);
+            }
+            catch (e) {
+                const error = throwableToError(e);
+                throw new EncodeError(error.message, error.stack);
+            }
+        },
+        contentType: 'application/jsonx+xml',
+    };
+};

package/dist/encoder/{url-encoded-type-encoder.js → url-encoded-type-encoder.cjs}

@@ -2,21 +2,21 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createUrlEncodedTypeEncoder = void 0;
 const qs_1 = require("qs");
-const __1 = require("..");
+const index_1 = require("../index.cjs");
 const encodeValue = (value) => {
-    if ((0, __1.isObject)(value)) {
+    if ((0, index_1.isObject)(value)) {
         return Object.fromEntries(Object.entries(value).map(([subKey, subValue]) => [subKey, encodeValue(subValue)]));
     }
-    if ((0, __1.isArray)(value)) {
+    if ((0, index_1.isArray)(value)) {
         return value.map(encodeValue);
     }
-    if ((0, __1.isNumber)(value)) {
+    if ((0, index_1.isNumber)(value)) {
         return value.toString();
     }
-    if ((0, __1.isBoolean)(value)) {
+    if ((0, index_1.isBoolean)(value)) {
         return value ? 'true' : 'false';
     }
-    if ((0, __1.isNull)(value)) {
+    if ((0, index_1.isNull)(value)) {
         return 'null';
     }
     return value;

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

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

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

@@ -0,0 +1,26 @@
+import { stringify } from 'qs';
+import { isArray, isBoolean, isNull, isNumber, isObject } from '../index.mjs';
+const encodeValue = (value) => {
+    if (isObject(value)) {
+        return Object.fromEntries(Object.entries(value).map(([subKey, subValue]) => [subKey, encodeValue(subValue)]));
+    }
+    if (isArray(value)) {
+        return value.map(encodeValue);
+    }
+    if (isNumber(value)) {
+        return value.toString();
+    }
+    if (isBoolean(value)) {
+        return value ? 'true' : 'false';
+    }
+    if (isNull(value)) {
+        return 'null';
+    }
+    return value;
+};
+export const createUrlEncodedTypeEncoder = () => {
+    return {
+        encode: (data) => stringify(encodeValue(data), { encodeValuesOnly: true }),
+        contentType: 'application/x-www-form-urlencoded',
+    };
+};

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

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

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

@@ -0,0 +1,7 @@
+import { stringify } from 'yaml';
+export const createYamlTypeEncoder = () => {
+    return {
+        encode: (data) => stringify(data, { indent: 4 }),
+        contentType: 'application/x-yaml',
+    };
+};

package/dist/index.mjs

@@ -0,0 +1,6 @@
+export const isNull = (value) => value === null;
+export const isBoolean = (value) => typeof value === 'boolean';
+export const isNumber = (value) => typeof value === 'number';
+export const isString = (value) => typeof value === 'string';
+export const isArray = (value) => Array.isArray(value);
+export const isObject = (value) => value !== null && typeof value === 'object' && value.constructor.name == 'Object';

package/dist/jsonx-datatypes.mjs

@@ -0,0 +1,6 @@
+export const DATATYPE_OBJECT = 'json:object';
+export const DATATYPE_ARRAY = 'json:array';
+export const DATATYPE_BOOLEAN = 'json:boolean';
+export const DATATYPE_STRING = 'json:string';
+export const DATATYPE_NUMBER = 'json:number';
+export const DATATYPE_NULL = 'json:null';

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "@chubbyts/chubbyts-decode-encode",
-  "version": "1.2.0",
+  "type": "module",
+  "version": "1.3.0",
   "description": "A simple decode/encode solution for json / jsonx / url-encoded / xml / yaml.",
   "keywords": [
     "chubbyts",
@@ -16,14 +17,14 @@
   "license": "MIT",
   "repository": "chubbyts/chubbyts-decode-encode",
   "scripts": {
+    "build": "node ./build.js",
     "cs-fix": "prettier --write src tests",
     "cs": "prettier --check src tests",
+    "infection": "stryker run",
     "lint-fix": "eslint src tests --fix",
     "lint": "eslint src tests",
-    "test": "jest",
-    "infection": "stryker run",
-    "build": "rm -Rf dist && tsc",
-    "prepare": "npm run build"
+    "prepare": "npm run build",
+    "test": "jest"
   },
   "jest": {
     "preset": "ts-jest",
@@ -46,27 +47,36 @@
   "files": [
     "dist"
   ],
+  "exports": {
+    "./*": {
+      "types": "./*.d.ts",
+      "require": "./*.cjs",
+      "import": "./*.mjs",
+      "default": "./*.mjs"
+    }
+  },
   "engines": {
     "node": ">=16"
   },
   "dependencies": {
-    "@chubbyts/chubbyts-throwable-to-error": "^1.1.0",
-    "fast-xml-parser": "^4.2.2",
-    "qs": "^6.11.1",
-    "yaml": "^2.2.2"
+    "@chubbyts/chubbyts-throwable-to-error": "^1.2.1",
+    "fast-xml-parser": "^4.2.6",
+    "qs": "^6.11.2",
+    "yaml": "^2.3.1"
   },
   "devDependencies": {
-    "@chubbyts/chubbyts-eslint": "^1.1.1",
-    "@chubbyts/chubbyts-function-mock": "^1.3.2",
-    "@stryker-mutator/core": "^6.4.2",
-    "@stryker-mutator/jest-runner": "^6.4.2",
-    "@types/jest": "^29.5.1",
-    "@types/node": "^20.1.1",
+    "@chubbyts/chubbyts-eslint": "^2.0.3",
+    "@chubbyts/chubbyts-function-mock": "^1.4.1",
+    "@chubbyts/chubbyts-packaging": "^2.0.4",
+    "@stryker-mutator/core": "^7.1.0",
+    "@stryker-mutator/jest-runner": "^7.1.0",
+    "@types/jest": "^29.5.3",
+    "@types/node": "^20.4.1",
     "@types/qs": "^6.9.7",
-    "jest": "^29.5.0",
-    "prettier": "^2.8.8",
-    "ts-jest": "^29.1.0",
-    "typescript": "^5.0.4"
+    "jest": "^29.6.1",
+    "prettier": "^3.0.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.1.6"
   },
   "publishConfig": {
     "access": "public"