xml-model 0.3.0 → 1.0.0

package/README.md

@@ -1,7 +1,52 @@
 # XML Model
 
 ## Usage
+
 needs [typescript-rtti](https://github.com/typescript-rtti/typescript-rtti) and [ttypescript](https://github.com/cevek/ttypescript) to work
 
+To build something that relies in `xml-model` with vite
+
+```typescript
+import { defineConfig } from "vite";
+import XMLModelVitePlugin from "xml-model/vite";
+
+export default defineConfig({
+  plugins: [
+    // see options in JSDoc
+    XMLModelVitePlugin(),
+  ],
+  // ... rest of the config
+});
+```
+
 ## Documentation
-check source
+
+### Example
+
+```typescript
+import "reflect-metadata";
+import { Model, getModel, XML } from "xml-model";
+
+@Model({
+  fromXML(ctx) {
+    const instance = new MyClass();
+    if (ctx.properties.foo) instance.foo = ctx.properties.foo;
+    return instance;
+  },
+})
+class MyClass {
+  foo = "bar";
+}
+
+const model = getModel(MyClass);
+
+const a: MyClass = model.fromXML("<my-class><foo>test</foo></my-class>");
+console.log(JSON.stringify(a)); // {"foo":"test"}
+
+const b = new MyClass();
+console.log(XML.stringify(model.toXML(b))); // <my-class><foo>bar</foo></my-class>
+b.foo = "other";
+console.log(XML.stringify(model.toXML(b))); // <my-class><foo>other</foo></my-class>
+```
+
+See [source code](https://github.com/MathisTLD/xml-model) for more

package/dist/defaults.d.ts

@@ -0,0 +1,14 @@
+import { fromXMLContext, PropertyFromXMLContext, PropertyToXMLContext, toXMLContext, XMLModelPropertyOptions, XMLModel } from './model/types';
+import { XMLElement, XMLRoot } from './types';
+interface Defaults {
+    fromXML<T>(context: fromXMLContext<T>): T;
+    propertySourceElementsFilter<T>(...args: Parameters<XMLModelPropertyOptions<T>["isSourceElement"]>): boolean;
+    propertyResolveSourceElements<T>(context: Omit<PropertyFromXMLContext<T>, "elements">): XMLElement[];
+    propertyFromXML<T>(context: PropertyFromXMLContext<T>): T[keyof T];
+    toXML<T>(context: toXMLContext<T>): XMLRoot;
+    tagnameFromModel: (model: XMLModel) => string;
+    tagnameFromProperty<T>(property: XMLModelPropertyOptions<T>): string;
+    propertyToXML<T>(context: PropertyToXMLContext<T>): XMLRoot;
+}
+export declare const defaults: Defaults;
+export {};

package/dist/defaults.js

@@ -0,0 +1,129 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { getModel } from "./model/registry.js";
+import { kebabCase } from "./util/kebab-case.js";
+const defaults = {
+  fromXML() {
+    throw new TypeError("you should define 'defaults.fromXML' yourself or provide a 'fromXML' function to @Model() decorator's options");
+  },
+  propertyResolveSourceElements(context) {
+    const innerElements = 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) {
+    const prop = context.property;
+    const elements = context.elements;
+    if (prop.reflected.isOptional && elements.length === 0) {
+      return void 0;
+    }
+    if (prop.model) {
+      return prop.model.fromXML({ elements });
+    }
+    const type = context.property.reflected.type;
+    if (type.is("class")) {
+      const model = getModel(type.class);
+      return model.fromXML({ elements: context.elements });
+    } else if (type.is("array")) {
+      let arrayEl = {};
+      if (!prop.inline && elements.length === 1 && elements[0].name === prop.tagname) {
+        arrayEl = elements[0];
+      } else if (prop.inline) {
+        arrayEl = { elements };
+      }
+      const els = arrayEl.elements || [];
+      const elType = type.elementType;
+      if (elType.is("class")) {
+        const model = getModel(elType.class);
+        const xmlInstances = els.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((type2) => type2.is("literal") && type2.value.constructor === firstTypeCtor)) {
+          const model = getModel(firstTypeCtor);
+          return model.fromXML({ elements });
+        }
+      }
+    }
+    return void 0;
+  },
+  /* Object -> XML */
+  toXML({ properties, model }) {
+    const elements = [];
+    model.resolveAllProperties().forEach((prop) => {
+      if (prop.name in properties && typeof prop.name !== "symbol") {
+        const _xml = properties[prop.name];
+        _xml.elements.forEach((el) => {
+          el.name = prop.tagname;
+          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: [] };
+    }
+    if (property.model) {
+      return property.model.toXML(value);
+    }
+    const getXML = /* @__PURE__ */ __name(() => {
+      if (type.is("class")) {
+        const model = getModel(type.class);
+        return model.toXML(value);
+      } else if (type.is("array")) {
+        const elementType = type.elementType;
+        if (elementType.is("class")) {
+          const model = getModel(elementType.class);
+          const elements = [];
+          value.forEach((el) => elements.push(...model.toXML(el).elements));
+          return { elements: [{ type: "element", name: "array", elements }] };
+        }
+      } 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((type2) => type2.is("literal") && type2.value.constructor === firstTypeCtor)) {
+            const model = getModel(firstTypeCtor);
+            return model.toXML(context.value);
+          }
+        }
+      }
+      return { elements: [] };
+    }, "getXML");
+    const xml = getXML();
+    if (context.property.inline)
+      return { elements: xml.elements.map((el) => el.elements || []).flat() };
+    else
+      return xml;
+  }
+};
+export {
+  defaults
+};
+//# sourceMappingURL=defaults.js.map

package/{build/main → dist}/errors.d.ts

@@ -1,4 +1,4 @@
-import { fromXMLContext, PropertyFromXMLContext, PropertyToXMLContext, toXMLContext } from "./model/types";
+import { fromXMLContext, PropertyFromXMLContext, PropertyToXMLContext, toXMLContext } from './model/types';
 export declare class FromXMLConversionError<T> extends Error {
     context: Omit<fromXMLContext<T>, "properties">;
     error: unknown;

package/dist/errors.js

@@ -0,0 +1,51 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const _FromXMLConversionError = class _FromXMLConversionError extends Error {
+  constructor(context, error) {
+    const message = `[Model: ${context.model.type.name}] failed to convert from XML`;
+    super(message);
+    this.context = context;
+    this.error = error;
+    this.name = "FromXMLConversionError";
+  }
+};
+__name(_FromXMLConversionError, "FromXMLConversionError");
+let FromXMLConversionError = _FromXMLConversionError;
+const _PropertyFromXMLConversionError = class _PropertyFromXMLConversionError extends FromXMLConversionError {
+  constructor(context, propertyContext, error) {
+    super(context, error);
+    this.propertyContext = propertyContext;
+    this.name = "PropertyFromXMLConversionError";
+    this.message = `[Model: ${context.model.type.name}] failed to convert prop <${String(propertyContext.property.name)}> from XML`;
+  }
+};
+__name(_PropertyFromXMLConversionError, "PropertyFromXMLConversionError");
+let PropertyFromXMLConversionError = _PropertyFromXMLConversionError;
+const _ToXMLConversionError = class _ToXMLConversionError extends Error {
+  constructor(context, cause) {
+    const message = `[Model: ${context.model.type.name}] failed to convert to XML`;
+    super(message);
+    this.context = context;
+    this.cause = cause;
+    this.name = "ToXMLConversionError";
+  }
+};
+__name(_ToXMLConversionError, "ToXMLConversionError");
+let ToXMLConversionError = _ToXMLConversionError;
+const _PropertyToXMLConversionError = class _PropertyToXMLConversionError extends ToXMLConversionError {
+  constructor(context, propertyContext, cause) {
+    super(context, cause);
+    this.propertyContext = propertyContext;
+    this.name = "PropertyToXMLConversionError";
+    this.message = `[Model: ${context.model.type.name}] failed to convert prop <${String(propertyContext.property.name)}> to XML`;
+  }
+};
+__name(_PropertyToXMLConversionError, "PropertyToXMLConversionError");
+let PropertyToXMLConversionError = _PropertyToXMLConversionError;
+export {
+  FromXMLConversionError,
+  PropertyFromXMLConversionError,
+  PropertyToXMLConversionError,
+  ToXMLConversionError
+};
+//# sourceMappingURL=errors.js.map

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,19 @@
+import { defaults } from "./defaults.js";
+import { Model, createModel } from "./model/index.js";
+import { FromXMLConversionError, PropertyFromXMLConversionError, PropertyToXMLConversionError, ToXMLConversionError } from "./errors.js";
+import { default as default2 } from "./xml/index.js";
+import { Prop } from "./model/property.js";
+import { getModel } from "./model/registry.js";
+export {
+  FromXMLConversionError,
+  Model,
+  Prop,
+  PropertyFromXMLConversionError,
+  PropertyToXMLConversionError,
+  ToXMLConversionError,
+  default2 as XML,
+  createModel,
+  defaults,
+  getModel
+};
+//# sourceMappingURL=index.js.map

package/{build/main → dist}/middleware.d.ts

@@ -1,9 +1,9 @@
-export declare type Middleware<C, T> = (context: C, next: () => T) => T;
+export type Middleware<C, T> = (context: C, next: () => T) => T;
 interface ChainableOptions<C, T> {
     parent: ChainableOptions<C, T> | null;
     middlewares: Middleware<C, T>[];
 }
 export declare function MiddlewareChain<C, T>(options: ChainableOptions<C, T>): Generator<Middleware<C, T>, void, unknown>;
-declare type MiddlewareChain<C, T> = Iterator<Middleware<C, T>>;
+type MiddlewareChain<C, T> = Iterator<Middleware<C, T>>;
 export declare function resolve<C, T>(middlewares: MiddlewareChain<C, T>, context: C): T;
 export {};

package/dist/middleware.js

@@ -0,0 +1,31 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+function* MiddlewareChain(options) {
+  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);
+}
+__name(MiddlewareChain, "MiddlewareChain");
+function resolve(middlewares, context) {
+  const next = /* @__PURE__ */ __name(() => {
+    const { value: nextMiddleware, done } = middlewares.next();
+    if (done || !nextMiddleware) {
+      throw new Error("no more next middleware");
+    } else {
+      return nextMiddleware(context, next);
+    }
+  }, "next");
+  return next();
+}
+__name(resolve, "resolve");
+export {
+  MiddlewareChain,
+  resolve
+};
+//# sourceMappingURL=middleware.js.map

package/dist/model/built-ins.d.ts

@@ -0,0 +1,2 @@
+import { createModel } from '.';
+export default function registerBuiltIns(create: typeof createModel): void;

package/dist/model/built-ins.js

@@ -0,0 +1,46 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { getContent, fromContent } from "../xml/index.js";
+function registerBuiltIns(create) {
+  create(String, {
+    toXML(ctx) {
+      return {
+        elements: [fromContent(ctx.object, "string")]
+      };
+    },
+    fromXML(ctx) {
+      return String(getContent(ctx.xml.elements[0]));
+    }
+  });
+  create(Number, {
+    toXML(ctx) {
+      return {
+        elements: [fromContent(String(ctx.object), "number")]
+      };
+    },
+    fromXML(ctx) {
+      return Number(getContent(ctx.xml.elements[0]));
+    }
+  });
+  create(Boolean, {
+    toXML(ctx) {
+      return {
+        elements: [
+          {
+            type: "element",
+            name: "boolean",
+            ...fromContent(String(ctx.object))
+          }
+        ]
+      };
+    },
+    fromXML(ctx) {
+      return Boolean(getContent(ctx.xml.elements[0]));
+    }
+  });
+}
+__name(registerBuiltIns, "registerBuiltIns");
+export {
+  registerBuiltIns as default
+};
+//# sourceMappingURL=built-ins.js.map

package/{build/module → dist}/model/index.d.ts

@@ -1,23 +1,19 @@
-import type { Constructor } from "typescript-rtti";
-import { XMLModelOptions, XMLModelPropertyOptions, CreateXMLModelOptions } from "./types";
-import { XMLRoot } from "../types";
+import { Constructor } from 'typescript-rtti';
+import { XMLModelOptions, XMLModelPropertyOptions, CreateXMLModelOptions } from './types';
+import { XMLRoot } from '../types';
 export declare class XMLModel<T = any> {
     readonly type: Constructor<T>;
     options: XMLModelOptions<T>;
     constructor(type: Constructor<T>, options: CreateXMLModelOptions<T>);
     fromXML(xml: XMLRoot | string): T;
-    toXML(instance: object): XMLRoot;
-    get reflectedClass(): import("typescript-rtti").ReflectedClass<Constructor<T>>;
+    toXML(instance: unknown): XMLRoot;
+    get reflectedClass(): import('typescript-rtti').ReflectedClass<Constructor<T>>;
     resolveAllProperties(): Map<string, XMLModelPropertyOptions<any> & {
         model: any;
     }>;
 }
 export declare function createModel<T>(type: Constructor<T>, options: CreateXMLModelOptions<T>): XMLModel<T>;
-declare type ModelID<T> = Constructor<T>;
-export declare const Models: Map<ModelID<unknown>, XMLModel<unknown>>;
-export declare function findModel<T>(id: ModelID<T>): XMLModel<T> | undefined;
-export declare function getModel<T>(id: ModelID<T>): XMLModel<T>;
 declare function ModelDecoratorFactory<T>(options?: CreateXMLModelOptions<T>): (constructor: Constructor<T>) => void;
+export { getModel } from './registry';
 export { ModelDecoratorFactory as Model };
-export { Prop } from "./property";
-import "../defaults/models";
+export { Prop } from './property';

package/dist/model/index.js

@@ -0,0 +1,242 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+import { reflect } from "typescript-rtti";
+import { ToXMLConversionError, PropertyToXMLConversionError, FromXMLConversionError, PropertyFromXMLConversionError } from "../errors.js";
+import mergeMaps from "../util/merge-maps.js";
+import { resolve, MiddlewareChain } from "../middleware.js";
+import { getPropertyConversionOptions } from "./property.js";
+import { Prop } from "./property.js";
+import XML from "../xml/index.js";
+import { defaults } from "../defaults.js";
+import { findModel, registrerModel } from "./registry.js";
+import { getModel } from "./registry.js";
+import registerBuiltIns from "./built-ins.js";
+function* ParentChain(constructor) {
+  let parent = Object.getPrototypeOf(constructor);
+  if (parent === constructor) {
+    return;
+  }
+  while (parent) {
+    yield parent;
+    const _parent = Object.getPrototypeOf(constructor);
+    if (parent === _parent) {
+      return;
+    }
+    parent = _parent;
+  }
+  return;
+}
+__name(ParentChain, "ParentChain");
+function getParentModel(model) {
+  if (model.options.parent)
+    return model.options.parent;
+  for (const constructor of ParentChain(model.type)) {
+    const model2 = findModel(constructor);
+    if (model2) {
+      return model2;
+    }
+  }
+  return null;
+}
+__name(getParentModel, "getParentModel");
+const _XMLModel = class _XMLModel {
+  constructor(type, options) {
+    this.type = type;
+    const model = this;
+    let parent = void 0;
+    const getParent = /* @__PURE__ */ __name(() => {
+      if (typeof parent === "undefined")
+        parent = getParentModel(this);
+      return parent;
+    }, "getParent");
+    let propertiesLoaded = false;
+    const properties = {
+      options: /* @__PURE__ */ new Map(),
+      fromXML: {
+        get parent() {
+          return getParent()?.options.properties.fromXML || null;
+        },
+        middlewares: [
+          (context, next) => {
+            const record = getParent() ? next() : {};
+            properties.options.forEach((property) => {
+              const xml = context.xml;
+              const elements = property.resolveElements({
+                model,
+                xml,
+                property
+              });
+              const propertyFromXMLContext = {
+                model,
+                xml: context.xml,
+                property,
+                elements
+              };
+              try {
+                record[property.name] = property.fromXML(propertyFromXMLContext);
+              } catch (error) {
+                if (error instanceof FromXMLConversionError) {
+                  throw error;
+                } else {
+                  throw new PropertyFromXMLConversionError(context, propertyFromXMLContext, error);
+                }
+              }
+            });
+            return record;
+          }
+        ]
+      },
+      toXML: {
+        get parent() {
+          return getParent()?.options.properties.toXML || null;
+        },
+        middlewares: [
+          (context, next) => {
+            const record = getParent() ? next() : {};
+            properties.options.forEach((options2) => {
+              const propertyToXMLContext = {
+                model,
+                object: context.object,
+                property: options2,
+                value: context.object[options2.name]
+              };
+              try {
+                record[options2.name] = options2.toXML(propertyToXMLContext);
+              } catch (error) {
+                if (error instanceof ToXMLConversionError) {
+                  throw error;
+                } else {
+                  throw new PropertyToXMLConversionError(context, propertyToXMLContext, error);
+                }
+              }
+            });
+            return record;
+          }
+        ]
+      }
+    };
+    const loadProperties = /* @__PURE__ */ __name(() => {
+      const props = this.reflectedClass.ownProperties.filter((prop) => typeof prop.host.constructor.prototype[prop.name] !== "function");
+      props.forEach((property) => {
+        const options2 = getPropertyConversionOptions(this.type, property.name);
+        if (!options2.ignored) {
+          properties.options.set(property.name, options2);
+        }
+      });
+      propertiesLoaded = true;
+    }, "loadProperties");
+    this.options = {
+      get properties() {
+        if (!propertiesLoaded)
+          loadProperties();
+        return properties;
+      },
+      fromXML: {
+        middlewares: [],
+        get parent() {
+          return getParent()?.options.fromXML || null;
+        }
+      },
+      toXML: {
+        middlewares: [],
+        get parent() {
+          return getParent()?.options.toXML || null;
+        }
+      },
+      get tagname() {
+        return options.tagname || defaults.tagnameFromModel(model);
+      }
+    };
+    if (options.parent)
+      this.options.parent = options.parent;
+    if (!getParent()) {
+      this.options.fromXML.middlewares.push((ctx) => defaults.fromXML(ctx));
+      this.options.toXML.middlewares.push((ctx) => defaults.toXML(ctx));
+    }
+    if (options.fromXML)
+      this.options.fromXML.middlewares.push(options.fromXML);
+    if (options.toXML)
+      this.options.toXML.middlewares.push(options.toXML);
+  }
+  fromXML(xml) {
+    const _xml = typeof xml === "string" ? XML.parse(xml) : xml;
+    const model = this;
+    const context = {
+      xml: _xml,
+      get properties() {
+        const propContext = {
+          xml: _xml,
+          model
+        };
+        return resolve(MiddlewareChain(model.options.properties.fromXML), propContext);
+      },
+      model
+    };
+    return resolve(MiddlewareChain(this.options.fromXML), context);
+  }
+  toXML(instance) {
+    const model = this;
+    if (instance instanceof this.type || typeof instance !== "undefined" && instance.constructor === this.type) {
+      const context = {
+        object: instance,
+        get properties() {
+          const propContext = {
+            object: instance,
+            model
+          };
+          return resolve(MiddlewareChain(model.options.properties.toXML), propContext);
+        },
+        model: this
+      };
+      return resolve(MiddlewareChain(this.options.toXML), context);
+    } else {
+      throw new TypeError(`provided object is not an instance of ${this.type.name}`);
+    }
+  }
+  get reflectedClass() {
+    return reflect(this.type);
+  }
+  resolveAllProperties() {
+    const ownProperties = /* @__PURE__ */ new Map();
+    const parent = getParentModel(this);
+    this.options.properties.options.forEach((options, key) => {
+      ownProperties.set(key, new Proxy(options, {
+        get: /* @__PURE__ */ __name((target, p, reciever) => {
+          if (p === "model")
+            return this;
+          else
+            return Reflect.get(target, p, reciever);
+        }, "get")
+      }));
+    });
+    const res = parent ? mergeMaps(parent.resolveAllProperties(), ownProperties) : ownProperties;
+    return res;
+  }
+};
+__name(_XMLModel, "XMLModel");
+let XMLModel = _XMLModel;
+function createModel(type, options) {
+  if (findModel(type)) {
+    throw new TypeError(`a model for type ${type.name} already exists`);
+  }
+  const model = new XMLModel(type, options);
+  registrerModel(model);
+  return model;
+}
+__name(createModel, "createModel");
+function ModelDecoratorFactory(options) {
+  return function(constructor) {
+    if (!findModel(constructor))
+      createModel(constructor, options || {});
+  };
+}
+__name(ModelDecoratorFactory, "ModelDecoratorFactory");
+registerBuiltIns(createModel);
+export {
+  ModelDecoratorFactory as Model,
+  Prop,
+  XMLModel,
+  createModel,
+  getModel
+};
+//# sourceMappingURL=index.js.map

package/{build/main → dist}/model/property.d.ts

@@ -1,5 +1,5 @@
-import type { Constructor } from "typescript-rtti";
-import type { XMLModelProperty, XMLModelPropertyOptions, CreateXMLModelPropertyOptions } from "./types";
+import { Constructor } from 'typescript-rtti';
+import { XMLModelProperty, XMLModelPropertyOptions, CreateXMLModelPropertyOptions } from './types';
 export declare function getPropertyConversionOptions<T>(constructor: Constructor<T>, property: XMLModelProperty<T>): XMLModelPropertyOptions<T>;
 declare function PropDecoratorFactory<T = any>(options?: CreateXMLModelPropertyOptions<T>): (prototype: any, property: XMLModelProperty<T>) => void;
 export { PropDecoratorFactory as Prop };