xml-model 1.3.2 → 2.0.0-beta.1

package/dist/defaults.js

@@ -1,130 +0,0 @@
-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 = () => {
-      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: [] };
-    };
-    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/dist/errors.d.ts

@@ -1,24 +0,0 @@
-import { fromXMLContext, PropertyFromXMLContext, PropertyToXMLContext, toXMLContext } from './model/types';
-export declare class FromXMLConversionError<T> extends Error {
-    context: Omit<fromXMLContext<T>, "properties">;
-    error: unknown;
-    name: string;
-    constructor(context: Omit<fromXMLContext<T>, "properties">, error: unknown);
-}
-export declare class PropertyFromXMLConversionError<T> extends FromXMLConversionError<T> {
-    propertyContext: PropertyFromXMLContext<T>;
-    name: string;
-    constructor(context: Omit<fromXMLContext<T>, "properties">, propertyContext: PropertyFromXMLContext<T>, error: unknown);
-}
-export declare class ToXMLConversionError<T> extends Error {
-    context: Omit<toXMLContext<T>, "properties">;
-    cause: unknown;
-    name: string;
-    constructor(context: Omit<toXMLContext<T>, "properties">, cause: unknown);
-}
-export declare class PropertyToXMLConversionError<T> extends ToXMLConversionError<T> {
-    propertyContext: PropertyToXMLContext<T>;
-    name: string;
-    constructor(context: Omit<toXMLContext<T>, "properties">, propertyContext: PropertyToXMLContext<T>, cause: unknown);
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -1,45 +0,0 @@
-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";
-  }
-}
-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`;
-  }
-}
-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";
-  }
-}
-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`;
-  }
-}
-export {
-  FromXMLConversionError,
-  PropertyFromXMLConversionError,
-  PropertyToXMLConversionError,
-  ToXMLConversionError
-};
-//# sourceMappingURL=errors.js.map

package/dist/middleware.d.ts

@@ -1,10 +0,0 @@
-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>;
-type MiddlewareChain<C, T> = Iterator<Middleware<C, T>>;
-export declare function resolve<C, T>(middlewares: MiddlewareChain<C, T>, context: C): T;
-export {};
-//# sourceMappingURL=middleware.d.ts.map

package/dist/middleware.js

@@ -1,25 +0,0 @@
-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);
-}
-function resolve(middlewares, context) {
-  const next = () => {
-    const { value: nextMiddleware, done } = middlewares.next();
-    if (done || !nextMiddleware) {
-      throw new Error("no more next middleware");
-    } else {
-      return nextMiddleware(context, next);
-    }
-  };
-  return next();
-}
-export {
-  MiddlewareChain,
-  resolve
-};
-//# sourceMappingURL=middleware.js.map

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

@@ -1,3 +0,0 @@
-import { createModel } from '.';
-export default function registerBuiltIns(create: typeof createModel): void;
-//# sourceMappingURL=built-ins.d.ts.map

package/dist/model/built-ins.js

@@ -1,43 +0,0 @@
-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]));
-    }
-  });
-}
-export {
-  registerBuiltIns as default
-};
-//# sourceMappingURL=built-ins.js.map

package/dist/model/index.d.ts

@@ -1,21 +0,0 @@
-import { Constructor } from 'typescript-rtti';
-import { XMLModelOptions, XMLModelPropertyOptions, CreateXMLModelOptions } from './types';
-import { XMLRoot } from '../types';
-export declare function getParentModel(model: XMLModel<any>): XMLModel<any>;
-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: 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 function ModelDecoratorFactory<T>(options?: CreateXMLModelOptions<T>): (constructor: Constructor<T>) => void;
-export { getModel } from './registry';
-export { ModelDecoratorFactory as Model };
-export { Prop } from './property';
-//# sourceMappingURL=index.d.ts.map

package/dist/model/index.js

@@ -1,236 +0,0 @@
-import "../_virtual/Reflect.js";
-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;
-}
-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;
-}
-class XMLModel {
-  constructor(type, options) {
-    this.type = type;
-    const model = this;
-    let parent = void 0;
-    const getParent = () => {
-      if (typeof parent === "undefined") parent = getParentModel(this);
-      return parent;
-    };
-    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 = () => {
-      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;
-    };
-    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: (target, p, reciever) => {
-            if (p === "model") return this;
-            else return Reflect.get(target, p, reciever);
-          }
-        })
-        // FIXME: is typing ok ?
-      );
-    });
-    const res = parent ? mergeMaps(parent.resolveAllProperties(), ownProperties) : ownProperties;
-    return res;
-  }
-}
-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;
-}
-function ModelDecoratorFactory(options) {
-  return function(constructor) {
-    if (!findModel(constructor)) createModel(constructor, options || {});
-  };
-}
-registerBuiltIns(createModel);
-export {
-  ModelDecoratorFactory as Model,
-  Prop,
-  XMLModel,
-  createModel,
-  getModel,
-  getParentModel
-};
-//# sourceMappingURL=index.js.map

package/dist/model/property.d.ts

@@ -1,6 +0,0 @@
-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 };
-//# sourceMappingURL=property.d.ts.map

package/dist/model/property.js

@@ -1,67 +0,0 @@
-import { reflect } from "typescript-rtti";
-import { defaults } from "../defaults.js";
-import isRegExp from "../util/is-regexp.js";
-function resolvePropertyConversionOptions(options, constructor, property) {
-  const _options = {
-    name: property,
-    get reflected() {
-      const reflectedClass = reflect(constructor);
-      return reflectedClass.getOwnProperty(property) || reflectedClass.getProperty(property);
-    },
-    get tagname() {
-      return options.tagname || defaults.tagnameFromProperty(this);
-    },
-    inline: !!options.inline,
-    ignored: !!options.ignore,
-    isSourceElement: (...args) => defaults.propertySourceElementsFilter(...args),
-    resolveElements: options.resolveElements ? options.resolveElements : (...args) => defaults.propertyResolveSourceElements(...args),
-    fromXML: (context) => (options.fromXML ?? defaults.propertyFromXML)(context),
-    toXML: (context) => (options.toXML ?? defaults.propertyToXML)(context)
-  };
-  if (options?.model) _options.model = options.model;
-  if (options?.sourceElements) {
-    const _sourceElements = options.sourceElements;
-    if (typeof _sourceElements === "string") {
-      _options.isSourceElement = (element) => element.name === _sourceElements;
-    } else if (isRegExp(_sourceElements)) {
-      _options.isSourceElement = (element) => _sourceElements.test(element.name || "");
-    } else if (_sourceElements) {
-      _options.isSourceElement = _sourceElements;
-    }
-  }
-  return _options;
-}
-const PropertyOptions = /* @__PURE__ */ new Map();
-function storePropertyConversionOptions(constructor, property, options) {
-  let map = PropertyOptions.get(constructor);
-  if (!map) {
-    map = /* @__PURE__ */ new Map();
-    PropertyOptions.set(constructor, map);
-  }
-  map.set(property, options);
-}
-function findPropertyConversionOptions(constructor, property) {
-  const options = PropertyOptions.get(constructor);
-  if (options) {
-    return options.get(property);
-  }
-}
-function getPropertyConversionOptions(constructor, property) {
-  const options = findPropertyConversionOptions(constructor, property);
-  return options ?? resolvePropertyConversionOptions({}, constructor, property);
-}
-function PropDecoratorFactory(options) {
-  return function(prototype, property) {
-    const _options = resolvePropertyConversionOptions(
-      options ?? {},
-      prototype.constructor,
-      property
-    );
-    storePropertyConversionOptions(prototype.constructor, property, _options);
-  };
-}
-export {
-  PropDecoratorFactory as Prop,
-  getPropertyConversionOptions
-};
-//# sourceMappingURL=property.js.map

package/dist/model/registry.d.ts

@@ -1,9 +0,0 @@
-import { Constructor } from 'typescript-rtti';
-import { XMLModel } from '.';
-type ModelID<T> = Constructor<T>;
-export declare const Models: Map<ModelID<unknown>, XMLModel<unknown>>;
-export declare function registrerModel(model: XMLModel<unknown>): 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>;
-export {};
-//# sourceMappingURL=registry.d.ts.map

package/dist/model/registry.js

@@ -1,19 +0,0 @@
-const Models = /* @__PURE__ */ new Map();
-function registrerModel(model) {
-  return Models.set(model.type, model);
-}
-function findModel(id) {
-  return Models.get(id);
-}
-function getModel(id) {
-  const model = findModel(id);
-  if (model) return model;
-  else throw new TypeError(`couldn't find model for type ${id.name}`);
-}
-export {
-  Models,
-  findModel,
-  getModel,
-  registrerModel
-};
-//# sourceMappingURL=registry.js.map