xml-model 0.1.0

package/build/module/xml-from-object.js

@@ -0,0 +1,58 @@
+const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
+        let t = __RΦ.t[id];
+        if (t === void 0)
+            return void 0;
+        if (t.RΦ) {
+            let r = t.RΦ;
+            delete t.RΦ;
+            __RΦ.r(t, r(t));
+        }
+        else if (t.LΦ) {
+            let l = t.LΦ();
+            delete t.LΦ;
+            __RΦ.t[id] = t = l;
+        }
+        return t;
+    }, t: { [384]: { LΦ: t => LΦ_0.IΦElement }, [28]: { LΦ: t => Object }, [610]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(12), __RΦ.a(609)] }) }, [12]: { RΦ: t => ({ TΦ: "n" }) }, [609]: { TΦ: "5", name: "XMLFromObjectOptions" }, [612]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(611) }) }, [611]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [4]: { RΦ: t => ({ TΦ: "~" }) } } };
+import { MiddlewareChain, resolve } from "./middleware";
+import * as LΦ_0 from "./types";
+var IΦXMLFromObjectMiddlewareContext = { name: "XMLFromObjectMiddlewareContext", prototype: {}, identity: Symbol("XMLFromObjectMiddlewareContext (interface)") };
+export { IΦXMLFromObjectMiddlewareContext };
+(t => __RΦ.t[608] = t)(IΦXMLFromObjectMiddlewareContext);
+__RΦ.m("rt:P", ["xml", "object"])(IΦXMLFromObjectMiddlewareContext);
+__RΦ.m("rt:m", [])(IΦXMLFromObjectMiddlewareContext);
+__RΦ.m("rt:f", "Ie")(IΦXMLFromObjectMiddlewareContext);
+__RΦ.m("rt:t", () => __RΦ.a(384))(IΦXMLFromObjectMiddlewareContext.prototype, "xml");
+__RΦ.m("rt:f", "P")(IΦXMLFromObjectMiddlewareContext.prototype, "xml");
+__RΦ.m("rt:t", () => __RΦ.a(28))(IΦXMLFromObjectMiddlewareContext.prototype, "object");
+__RΦ.m("rt:f", "P")(IΦXMLFromObjectMiddlewareContext.prototype, "object");
+__RΦ.m("rt:t", () => __RΦ.a(384))(IΦXMLFromObjectMiddlewareContext.prototype, "xml");
+__RΦ.m("rt:f", "P")(IΦXMLFromObjectMiddlewareContext.prototype, "xml");
+__RΦ.m("rt:t", () => __RΦ.a(28))(IΦXMLFromObjectMiddlewareContext.prototype, "object");
+__RΦ.m("rt:f", "P")(IΦXMLFromObjectMiddlewareContext.prototype, "object");
+var IΦXMLFromObjectOptions = { name: "XMLFromObjectOptions", prototype: {}, identity: Symbol("XMLFromObjectOptions (interface)") };
+export { IΦXMLFromObjectOptions };
+(t => __RΦ.t[609] = t)(IΦXMLFromObjectOptions);
+__RΦ.m("rt:P", ["parent", "middlewares"])(IΦXMLFromObjectOptions);
+__RΦ.m("rt:m", [])(IΦXMLFromObjectOptions);
+__RΦ.m("rt:f", "Ie")(IΦXMLFromObjectOptions);
+__RΦ.m("rt:t", () => __RΦ.a(610))(IΦXMLFromObjectOptions.prototype, "parent");
+__RΦ.m("rt:f", "P")(IΦXMLFromObjectOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(612))(IΦXMLFromObjectOptions.prototype, "middlewares");
+__RΦ.m("rt:f", "P")(IΦXMLFromObjectOptions.prototype, "middlewares");
+__RΦ.m("rt:t", () => __RΦ.a(610))(IΦXMLFromObjectOptions.prototype, "parent");
+__RΦ.m("rt:f", "P")(IΦXMLFromObjectOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(612))(IΦXMLFromObjectOptions.prototype, "middlewares");
+__RΦ.m("rt:f", "P")(IΦXMLFromObjectOptions.prototype, "middlewares");
+export function xmlFromObject(object, options) {
+    const middlewares = MiddlewareChain(options);
+    const context = {
+        xml: { type: "element" },
+        object,
+    };
+    resolve(middlewares, context);
+    return context.xml;
+}
+__RΦ.m("rt:p", [{ n: "object", t: () => __RΦ.a(28), v: null }, { n: "options", t: () => __RΦ.a(609), v: null }])(xmlFromObject);
+__RΦ.m("rt:f", "F")(xmlFromObject);
+__RΦ.m("rt:t", () => __RΦ.a(384))(xmlFromObject);

package/build/module/xml-from-object.spec.d.ts

@@ -0,0 +1 @@
+import "mocha";

package/build/module/xml-from-object.spec.js

@@ -0,0 +1,104 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
+        let t = __RΦ.t[id];
+        if (t === void 0)
+            return void 0;
+        if (t.RΦ) {
+            let r = t.RΦ;
+            delete t.RΦ;
+            __RΦ.r(t, r(t));
+        }
+        else if (t.LΦ) {
+            let l = t.LΦ();
+            delete t.LΦ;
+            __RΦ.t[id] = t = l;
+        }
+        return t;
+    }, t: { [1657]: { RΦ: t => ({ TΦ: "O", m: [{ n: "name", f: "", t: __RΦ.a(13) }, { n: "nbPages", f: "", t: __RΦ.a(14) }] }) }, [13]: { LΦ: t => String }, [14]: { LΦ: t => Number }, [1664]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(1652) }) }, [1652]: { TΦ: "5", name: "Book" }, [4]: { RΦ: t => ({ TΦ: "~" }) }, [22]: { RΦ: t => ({ TΦ: "V" }) } } };
+import "mocha";
+import { expect } from "chai";
+import { Model, Prop, getModel } from "./model";
+import { js2xml } from "xml-js";
+let Book = class Book {
+    name;
+    nbPages;
+    constructor(options) {
+        this.name = options.name;
+        this.nbPages = options.nbPages;
+    }
+};
+__decorate([
+    Prop()
+], Book.prototype, "name", void 0);
+__decorate([
+    Prop()
+], Book.prototype, "nbPages", void 0);
+Book = __decorate([
+    Model()
+], Book);
+(t => __RΦ.t[1652] = t)(Book);
+__RΦ.m("rt:SP", [])(Book);
+__RΦ.m("rt:P", ["name", "nbPages"])(Book);
+__RΦ.m("rt:Sm", [])(Book);
+__RΦ.m("rt:m", [])(Book);
+__RΦ.m("rt:p", [{ n: "options", t: () => __RΦ.a(1657), v: null }])(Book);
+__RΦ.m("rt:f", "C")(Book);
+__RΦ.m("rt:t", () => __RΦ.a(13))(Book.prototype, "name");
+__RΦ.m("rt:f", "P")(Book.prototype, "name");
+__RΦ.m("rt:t", () => __RΦ.a(14))(Book.prototype, "nbPages");
+__RΦ.m("rt:f", "P")(Book.prototype, "nbPages");
+let Library = class Library {
+    name;
+    books = [];
+    constructor(name) {
+        this.name = name;
+    }
+};
+__decorate([
+    Prop()
+], Library.prototype, "name", void 0);
+__decorate([
+    Prop()
+], Library.prototype, "books", void 0);
+Library = __decorate([
+    Model()
+], Library);
+(t => __RΦ.t[1659] = t)(Library);
+__RΦ.m("rt:SP", [])(Library);
+__RΦ.m("rt:P", ["name", "books"])(Library);
+__RΦ.m("rt:Sm", [])(Library);
+__RΦ.m("rt:m", [])(Library);
+__RΦ.m("rt:p", [{ n: "name", t: () => __RΦ.a(13), v: null }])(Library);
+__RΦ.m("rt:f", "C")(Library);
+__RΦ.m("rt:t", () => __RΦ.a(13))(Library.prototype, "name");
+__RΦ.m("rt:f", "P")(Library.prototype, "name");
+__RΦ.m("rt:t", () => __RΦ.a(1664))(Library.prototype, "books");
+__RΦ.m("rt:f", "P")(Library.prototype, "books");
+describe("XML from Object", __RΦ.f(() => {
+    it("should convert to XML as expected", __RΦ.f(() => {
+        const library = new Library("test");
+        for (let i = 1; i <= 4; i++) {
+            const book = new Book({ name: `Book #${i}`, nbPages: Math.pow(10, i) });
+            library.books.push(book);
+        }
+        const xml = getModel(Library).toXMLElement(library);
+        const expectedXMLString = `<library>
+    <name>${library.name}</name>
+    <books>
+      ${library.books
+            .map(__RΦ.f((book) => `     <book>
+        <name>${book.name}</name>
+        <nb-pages>${book.nbPages}</nb-pages>
+      </book>`, [__RΦ.m("rt:p", [{ n: "book", t: () => __RΦ.a(4), v: null }]), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(13))], ""))
+            .join("")}
+    </books>
+</library>`.replace(/>(\ |\n)*</g, "><");
+        const xmlString = js2xml({ elements: [xml] });
+        expect(xmlString).to.equal(expectedXMLString);
+    }, [__RΦ.m("rt:p", []), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(22))], ""));
+}, [__RΦ.m("rt:p", []), __RΦ.m("rt:f", "F>"), __RΦ.m("rt:t", () => __RΦ.a(22))], ""));

package/build/module/xml-to-object.d.ts

@@ -0,0 +1,11 @@
+import type { XMLElement, UnknownRecord } from "./types";
+import { Middleware } from "./middleware";
+export interface XMLToObjectMiddlewareContext {
+    xml: XMLElement;
+    record: UnknownRecord;
+}
+export interface XMLToObjectOptions {
+    parent: XMLToObjectOptions | null;
+    middlewares: Middleware<XMLToObjectMiddlewareContext, void>[];
+}
+export declare function xmlToObject(xml: XMLElement, options: XMLToObjectOptions): UnknownRecord;

package/build/module/xml-to-object.js

@@ -0,0 +1,55 @@
+const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
+        let t = __RΦ.t[id];
+        if (t === void 0)
+            return void 0;
+        if (t.RΦ) {
+            let r = t.RΦ;
+            delete t.RΦ;
+            __RΦ.r(t, r(t));
+        }
+        else if (t.LΦ) {
+            let l = t.LΦ();
+            delete t.LΦ;
+            __RΦ.t[id] = t = l;
+        }
+        return t;
+    }, t: { [384]: { LΦ: t => LΦ_0.IΦElement }, [113]: { RΦ: t => ({ TΦ: "m", t: __RΦ.a(114), p: [] }) }, [114]: { LΦ: t => Object }, [386]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(12), __RΦ.a(385)] }) }, [12]: { RΦ: t => ({ TΦ: "n" }) }, [385]: { TΦ: "5", name: "XMLToObjectOptions" }, [388]: { RΦ: t => ({ TΦ: "[", e: __RΦ.a(387) }) }, [387]: { RΦ: t => ({ TΦ: "O", m: [{ n: "__call", f: "", t: __RΦ.a(4) }] }) }, [4]: { RΦ: t => ({ TΦ: "~" }) } } };
+import { MiddlewareChain, resolve } from "./middleware";
+import * as LΦ_0 from "./types";
+var IΦXMLToObjectMiddlewareContext = { name: "XMLToObjectMiddlewareContext", prototype: {}, identity: Symbol("XMLToObjectMiddlewareContext (interface)") };
+export { IΦXMLToObjectMiddlewareContext };
+(t => __RΦ.t[383] = t)(IΦXMLToObjectMiddlewareContext);
+__RΦ.m("rt:P", ["xml", "record"])(IΦXMLToObjectMiddlewareContext);
+__RΦ.m("rt:m", [])(IΦXMLToObjectMiddlewareContext);
+__RΦ.m("rt:f", "Ie")(IΦXMLToObjectMiddlewareContext);
+__RΦ.m("rt:t", () => __RΦ.a(384))(IΦXMLToObjectMiddlewareContext.prototype, "xml");
+__RΦ.m("rt:f", "P")(IΦXMLToObjectMiddlewareContext.prototype, "xml");
+__RΦ.m("rt:t", () => __RΦ.a(113))(IΦXMLToObjectMiddlewareContext.prototype, "record");
+__RΦ.m("rt:f", "P")(IΦXMLToObjectMiddlewareContext.prototype, "record");
+__RΦ.m("rt:t", () => __RΦ.a(384))(IΦXMLToObjectMiddlewareContext.prototype, "xml");
+__RΦ.m("rt:f", "P")(IΦXMLToObjectMiddlewareContext.prototype, "xml");
+__RΦ.m("rt:t", () => __RΦ.a(113))(IΦXMLToObjectMiddlewareContext.prototype, "record");
+__RΦ.m("rt:f", "P")(IΦXMLToObjectMiddlewareContext.prototype, "record");
+var IΦXMLToObjectOptions = { name: "XMLToObjectOptions", prototype: {}, identity: Symbol("XMLToObjectOptions (interface)") };
+export { IΦXMLToObjectOptions };
+(t => __RΦ.t[385] = t)(IΦXMLToObjectOptions);
+__RΦ.m("rt:P", ["parent", "middlewares"])(IΦXMLToObjectOptions);
+__RΦ.m("rt:m", [])(IΦXMLToObjectOptions);
+__RΦ.m("rt:f", "Ie")(IΦXMLToObjectOptions);
+__RΦ.m("rt:t", () => __RΦ.a(386))(IΦXMLToObjectOptions.prototype, "parent");
+__RΦ.m("rt:f", "P")(IΦXMLToObjectOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(388))(IΦXMLToObjectOptions.prototype, "middlewares");
+__RΦ.m("rt:f", "P")(IΦXMLToObjectOptions.prototype, "middlewares");
+__RΦ.m("rt:t", () => __RΦ.a(386))(IΦXMLToObjectOptions.prototype, "parent");
+__RΦ.m("rt:f", "P")(IΦXMLToObjectOptions.prototype, "parent");
+__RΦ.m("rt:t", () => __RΦ.a(388))(IΦXMLToObjectOptions.prototype, "middlewares");
+__RΦ.m("rt:f", "P")(IΦXMLToObjectOptions.prototype, "middlewares");
+export function xmlToObject(xml, options) {
+    const record = {};
+    const middlewares = MiddlewareChain(options);
+    resolve(middlewares, { xml, record });
+    return record;
+}
+__RΦ.m("rt:p", [{ n: "xml", t: () => __RΦ.a(384), v: null }, { n: "options", t: () => __RΦ.a(385), v: null }])(xmlToObject);
+__RΦ.m("rt:f", "F")(xmlToObject);
+__RΦ.m("rt:t", () => __RΦ.a(113))(xmlToObject);

package/build/module/xml.d.ts

@@ -0,0 +1,15 @@
+import { js2xml } from "xml-js";
+import { XMLElement } from "./types";
+export declare function parse(string: string): XMLElement | import("xml-js").ElementCompact;
+export declare function stringify(xml: XMLElement, options: Parameters<typeof js2xml>[1]): string;
+export declare function getContent(xml: XMLElement): string | number | boolean | undefined;
+export declare function fromContent(content?: string, tag?: string, attributes?: XMLElement["attributes"]): XMLElement;
+export declare function addElement(xml: XMLElement, element: XMLElement): void;
+declare const XML: {
+    parse: typeof parse;
+    stringify: typeof stringify;
+    fromContent: typeof fromContent;
+    getContent: typeof getContent;
+    addElement: typeof addElement;
+};
+export default XML;

package/build/module/xml.js

@@ -0,0 +1,74 @@
+const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
+        let t = __RΦ.t[id];
+        if (t === void 0)
+            return void 0;
+        if (t.RΦ) {
+            let r = t.RΦ;
+            delete t.RΦ;
+            __RΦ.r(t, r(t));
+        }
+        else if (t.LΦ) {
+            let l = t.LΦ();
+            delete t.LΦ;
+            __RΦ.t[id] = t = l;
+        }
+        return t;
+    }, t: { [13]: { LΦ: t => String }, [639]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(384), __RΦ.a(638)] }) }, [384]: { LΦ: t => LΦ_0.IΦElement }, [638]: { LΦ: t => LΦ_0.IΦElementCompact }, [650]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(10), __RΦ.a(647)] }) }, [10]: { RΦ: t => ({ TΦ: "u" }) }, [647]: { LΦ: t => LΦ_0.IΦJS2XML }, [679]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(10), __RΦ.a(13), __RΦ.a(14), __RΦ.a(17), __RΦ.a(19)] }) }, [14]: { LΦ: t => Number }, [17]: { RΦ: t => ({ TΦ: "0" }) }, [19]: { RΦ: t => ({ TΦ: "1" }) }, [46]: { LΦ: t => "" }, [687]: { RΦ: t => ({ TΦ: "|", t: [__RΦ.a(10), __RΦ.a(686)] }) }, [686]: { LΦ: t => LΦ_0.IΦAttributes }, [22]: { RΦ: t => ({ TΦ: "V" }) } } };
+import { xml2js, js2xml } from "xml-js";
+import * as LΦ_0 from "xml-js/types";
+export function parse(string) {
+    return xml2js(string);
+}
+__RΦ.m("rt:p", [{ n: "string", t: () => __RΦ.a(13), v: null }])(parse);
+__RΦ.m("rt:f", "F")(parse);
+__RΦ.m("rt:t", () => __RΦ.a(639))(parse);
+export function stringify(xml, options) {
+    return js2xml(xml, options);
+}
+__RΦ.m("rt:p", [{ n: "xml", t: () => __RΦ.a(384), v: null }, { n: "options", t: () => __RΦ.a(650), v: null }])(stringify);
+__RΦ.m("rt:f", "F")(stringify);
+__RΦ.m("rt:t", () => __RΦ.a(13))(stringify);
+export function getContent(xml) {
+    if (!("elements" in xml)) {
+        return "";
+    }
+    else if (xml.elements?.length === 1) {
+        const content = xml.elements[0];
+        if (content.type === "text")
+            return content.text;
+    }
+    throw new Error("this element doesn't contain text");
+}
+__RΦ.m("rt:p", [{ n: "xml", t: () => __RΦ.a(384), v: null }])(getContent);
+__RΦ.m("rt:f", "F")(getContent);
+__RΦ.m("rt:t", () => __RΦ.a(679))(getContent);
+export function fromContent(content = "", tag, attributes) {
+    const el = {
+        type: "element",
+        elements: content ? [{ type: "text", text: String(content) }] : [],
+    };
+    if (tag)
+        el.name = tag;
+    if (attributes)
+        el.attributes = attributes;
+    return el;
+}
+__RΦ.m("rt:p", [{ n: "content", t: () => __RΦ.a(46), v: function () { return ""; } }, { n: "tag", t: () => __RΦ.a(13), v: null, f: "?" }, { n: "attributes", t: () => __RΦ.a(687), v: null, f: "?" }])(fromContent);
+__RΦ.m("rt:f", "F")(fromContent);
+__RΦ.m("rt:t", () => __RΦ.a(384))(fromContent);
+export function addElement(xml, element) {
+    if (!xml.elements)
+        xml.elements = [];
+    xml.elements.push(element);
+}
+__RΦ.m("rt:p", [{ n: "xml", t: () => __RΦ.a(384), v: null }, { n: "element", t: () => __RΦ.a(384), v: null }])(addElement);
+__RΦ.m("rt:f", "F")(addElement);
+__RΦ.m("rt:t", () => __RΦ.a(22))(addElement);
+const XML = {
+    parse,
+    stringify,
+    fromContent,
+    getContent,
+    addElement,
+};
+export default XML;

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "xml-model",
+  "version": "0.1.0",
+  "main": "build/main/index.js",
+  "typings": "build/main/index.d.ts",
+  "module": "build/module/index.js",
+  "author": "MathisTLD",
+  "license": "MIT",
+  "private": false,
+  "scripts": {
+    "test": "yarn lint && mocha -r ./register-ts-node --colors src/**/*.spec.ts",
+    "build": "run-p build:*",
+    "build:main": "rimraf build/main && ttsc -p tsconfig.json",
+    "build:module": "rimraf build/module && ttsc -p tsconfig.module.json",
+    "lint": "eslint src/**/*.ts"
+  },
+  "dependencies": {
+    "lodash": "^4.17.21",
+    "reflect-metadata": "^0.1.13",
+    "typescript-rtti": "^0.7.3",
+    "xml-js": "^1.6.11"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.3.1",
+    "@types/expect": "^24.3.0",
+    "@types/lodash": "^4.14.182",
+    "@types/mocha": "^9.1.1",
+    "@typescript-eslint/eslint-plugin": "^5.28.0",
+    "@typescript-eslint/parser": "^5.28.0",
+    "chai": "^4.3.6",
+    "eslint": "^8.18.0",
+    "mocha": "^10.0.0",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^3.0.2",
+    "ts-mocha": "^10.0.0",
+    "ts-node": "^10.8.1",
+    "ttypescript": "^1.5.13",
+    "typescript": "^4.7.4"
+  },
+  "files": [
+    "build/main",
+    "build/module",
+    "!**/*.spec.*",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md"
+  ],
+  "description": "allows transparent XML <-> Object conversion in typescript",
+  "repository": "git@github.com:MathisTLD/xml-model.git"
+}

package/register-ts-node.js

@@ -0,0 +1,9 @@
+try {
+  require("ts-node").register({
+    project: "./tsconfig.json",
+    compiler: "ttypescript",
+  });
+} catch (error) {
+  console.log("[ERROR] " + error.message);
+  process.exit(1);
+}

package/src/defaults/index.ts

@@ -0,0 +1,181 @@
+import type { XMLModelPropertyOptions } from "../model/types";
+
+import type { XMLModelOptions, XMLModel } from "../model/types";
+import { getModel } from "../model";
+
+import kebabCase from "lodash/kebabCase";
+import type { XMLElement, XMLRoot } from "../types";
+
+type defaults<T = any> = {
+  // XML -> Object
+  fromXML: Required<XMLModelOptions<T>>["fromXML"]["middlewares"][number];
+  propertySourceElementsFilter: XMLModelPropertyOptions<T>["isSourceElement"];
+  propertyResolveSourceElements: XMLModelPropertyOptions<T>["resolveElements"];
+  propertyFromXML: Required<XMLModelPropertyOptions<T>>["fromXML"];
+  // Object -> XML
+  toXML: Required<XMLModelOptions<T>>["toXML"]["middlewares"][number];
+  tagnameFromModel: (model: XMLModel) => string;
+  tagnameFromProperty: (property: XMLModelPropertyOptions<T>) => string;
+  propertyToXML: Required<XMLModelPropertyOptions<T>>["toXML"];
+};
+
+export const defaults: defaults = {
+  fromXML() {
+    throw new TypeError(
+      "you should define 'defaults.fromXML' yourself or provide a 'fromXML' function to @Model() decorator's options"
+    );
+  },
+  propertyResolveSourceElements(context) {
+    // We assume context.xml.elements is a single tag containing all the props
+    // FIXME: is it safe ?
+    const innerElements: XMLElement[] = context.xml.elements[0]?.elements || [];
+    return innerElements.filter((el) =>
+      context.property.isSourceElement(el, context)
+    );
+  },
+  propertySourceElementsFilter(element, context) {
+    return context.property.tagname == element.name;
+  },
+  propertyFromXML(context) {
+    // TODO: handle inline
+    const prop = context.property;
+    const elements = context.elements;
+    const type = context.property.reflected.type;
+    if (prop.reflected.isOptional && elements.length === 0) {
+      return undefined;
+    }
+    if (type.is("class")) {
+      const model = getModel(type.class);
+      return model.fromXML({ elements: context.elements });
+    } else if (type.is("array")) {
+      let arrayEl: XMLElement = {};
+      if (
+        !prop.inline &&
+        elements.length === 1 &&
+        elements[0].name === prop.tagname
+      ) {
+        // we assume our array is contained in a root tag
+        arrayEl = elements[0];
+      } else if (
+        prop.inline &&
+        elements.every((el) => el.name === prop.tagname)
+      ) {
+        // we assume our array is contained in xml.elements
+        arrayEl = { elements };
+      }
+      if (arrayEl.elements) {
+        const elType = type.elementType;
+        if (elType.is("class")) {
+          const model = getModel(elType.class);
+          const xmlInstances = arrayEl.elements.map((el) => ({
+            elements: [el],
+          }));
+          return xmlInstances.map((xml) => model.fromXML(xml));
+        }
+      }
+    } else if (
+      type.is("union") &&
+      type.types.length &&
+      type.types[0].is("literal")
+    ) {
+      const firstType = type.types[0];
+      if (firstType.is("literal")) {
+        const firstTypeCtor = firstType.value.constructor;
+        if (
+          type.types.every(
+            (type) =>
+              type.is("literal") && type.value.constructor === firstTypeCtor
+          )
+        ) {
+          // all elements of unions are litteral with same type
+          const model = getModel(firstTypeCtor);
+          return model.fromXML({ elements });
+        }
+      }
+    }
+
+    // TODO: should warn ???
+    return undefined;
+  },
+  /* Object -> XML */
+  toXML({ properties, model }) {
+    const elements: XMLElement[] = [];
+
+    model.options.properties.options.forEach((prop) => {
+      if (prop.name in properties && typeof prop.name !== "symbol") {
+        // FIXME: prop.name should never be a symbol anyway
+        const _xml = properties[prop.name] as XMLRoot;
+        // overwrite tagnames
+        _xml.elements.forEach((el) => {
+          (el.name = prop.tagname), // TODO: configurable ?
+            elements.push(el);
+        });
+      }
+    });
+    return {
+      elements: [
+        {
+          type: "element",
+          name: model.options.tagname,
+          elements,
+        },
+      ],
+    };
+  },
+  tagnameFromModel(model) {
+    return kebabCase(model.type.name);
+  },
+  tagnameFromProperty(property) {
+    return kebabCase(String(property.name));
+  },
+  propertyToXML(context) {
+    const property = context.property;
+    const type = property.reflected.type;
+    const value = context.value;
+    if (property.reflected.isOptional && typeof value === "undefined") {
+      return { elements: [] }; // FIXME should return unefined ???
+    }
+    const getXML = () => {
+      if (type.is("class")) {
+        const model = getModel(type.class);
+        return model.toXML(value);
+      } else if (type.is("array") && type.elementType.is("class")) {
+        const elementType = type.elementType;
+        if (elementType.is("class")) {
+          const model = getModel(elementType.class);
+          const elements: XMLElement[] = [];
+          (value as object[]).forEach((el) =>
+            elements.push(...model.toXML(el).elements)
+          );
+          return { elements: [{ type: "element", name: "array", elements }] };
+        }
+        // TODO: handle other types of array
+      } else if (
+        type.is("union") &&
+        type.types.length &&
+        type.types[0].is("literal")
+      ) {
+        const firstType = type.types[0];
+        if (firstType.is("literal")) {
+          const firstTypeCtor = firstType.value.constructor;
+          if (
+            type.types.every(
+              (type) =>
+                type.is("literal") && type.value.constructor === firstTypeCtor
+            )
+          ) {
+            // all elements of unions are litteral with same type
+            const model = getModel(firstTypeCtor);
+            return model.toXML(context.value);
+          }
+        }
+      }
+      // TODO: should warn ???
+      return { elements: [] };
+    };
+    const xml = getXML();
+    if (context.property.inline)
+      return { elements: xml.elements.map((el) => el.elements || []).flat() };
+    else return xml;
+  },
+};

package/src/defaults/models.ts

@@ -0,0 +1,45 @@
+import { createModel } from "../model";
+import { Constructor } from "../types";
+import { getContent, fromContent } from "../xml";
+
+// string is <string>value</string>
+createModel<string>(String as unknown as Constructor<string>, {
+  toXML: (ctx) => {
+    return {
+      elements: [fromContent(ctx.object, "string")],
+    };
+  },
+  fromXML: (ctx) => {
+    return String(getContent(ctx.xml.elements[0]));
+  },
+});
+
+// number is <number>value</number>
+createModel<number>(Number as unknown as Constructor<number>, {
+  toXML: (ctx) => {
+    return {
+      elements: [fromContent(String(ctx.object), "number")],
+    };
+  },
+  fromXML: (ctx) => {
+    return Number(getContent(ctx.xml.elements[0]));
+  },
+});
+
+// number is <boolean>value</boolean>
+createModel<boolean>(Boolean as unknown as Constructor<boolean>, {
+  toXML: (ctx) => {
+    return {
+      elements: [
+        {
+          type: "element",
+          name: "boolean",
+          ...fromContent(String(ctx.object)),
+        },
+      ],
+    };
+  },
+  fromXML: (ctx) => {
+    return Boolean(getContent(ctx.xml.elements[0]));
+  },
+});

package/src/index.ts

@@ -0,0 +1,6 @@
+export type { XMLElement, XMLRoot, Constructor } from "./types";
+export { defaults } from "./defaults";
+export { getModel, createModel, Model, Prop } from "./model";
+
+import XML from "./xml";
+export { XML };

package/src/middleware.ts

@@ -0,0 +1,34 @@
+export type Middleware<C, T> = (context: C, next: () => T) => T;
+
+interface ChainableOptions<C, T> {
+  parent: ChainableOptions<C, T> | null;
+  middlewares: Middleware<C, T>[];
+}
+
+export function* MiddlewareChain<C, T>(options: ChainableOptions<C, T>) {
+  do {
+    for (let index = options.middlewares.length - 1; index >= 0; index--) {
+      yield options.middlewares[index];
+    }
+    if (options.parent) options = options.parent;
+    else return;
+  } while (true);
+}
+type MiddlewareChain<C, T> = Iterator<Middleware<C, T>>;
+
+export function resolve<C, T>(
+  middlewares: MiddlewareChain<C, T>,
+  context: C
+): T {
+  const next = (): T => {
+    const { value: nextMiddleware, done } = middlewares.next();
+    if (done || !nextMiddleware) {
+      // previous middlewares should have returned a value before
+      // TODO: dedicated error class
+      throw new Error("no more next middleware");
+    } else {
+      return nextMiddleware(context, next);
+    }
+  };
+  return next();
+}