xml-model 1.3.1 → 1.3.2

package/dist/_virtual/_commonjsHelpers.js

@@ -1,23 +1,18 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
 function getDefaultExportFromCjs(x) {
   return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
 }
-__name(getDefaultExportFromCjs, "getDefaultExportFromCjs");
 function getDefaultExportFromNamespaceIfPresent(n) {
   return n && Object.prototype.hasOwnProperty.call(n, "default") ? n["default"] : n;
 }
-__name(getDefaultExportFromNamespaceIfPresent, "getDefaultExportFromNamespaceIfPresent");
 function getDefaultExportFromNamespaceIfNotNamed(n) {
   return n && Object.prototype.hasOwnProperty.call(n, "default") && Object.keys(n).length === 1 ? n["default"] : n;
 }
-__name(getDefaultExportFromNamespaceIfNotNamed, "getDefaultExportFromNamespaceIfNotNamed");
 function getAugmentedNamespace(n) {
   if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
   var f = n.default;
   if (typeof f == "function") {
-    var a = /* @__PURE__ */ __name(function a2() {
+    var a = function a2() {
       var isInstance = false;
       try {
         isInstance = this instanceof a2;
@@ -27,7 +22,7 @@ function getAugmentedNamespace(n) {
         return Reflect.construct(f, arguments, this.constructor);
       }
       return f.apply(this, arguments);
-    }, "a");
+    };
     a.prototype = f.prototype;
   } else a = {};
   Object.defineProperty(a, "__esModule", { value: true });
@@ -35,14 +30,13 @@ function getAugmentedNamespace(n) {
     var d = Object.getOwnPropertyDescriptor(n, k);
     Object.defineProperty(a, k, d.get ? d : {
       enumerable: true,
-      get: /* @__PURE__ */ __name(function() {
+      get: function() {
         return n[k];
-      }, "get")
+      }
     });
   });
   return a;
 }
-__name(getAugmentedNamespace, "getAugmentedNamespace");
 export {
   commonjsGlobal,
   getAugmentedNamespace,

package/dist/defaults.js

@@ -1,10 +1,10 @@
-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");
+    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 || [];
@@ -92,7 +92,7 @@ const defaults = {
     if (property.model) {
       return property.model.toXML(value);
     }
-    const getXML = /* @__PURE__ */ __name(() => {
+    const getXML = () => {
       if (type.is("class")) {
         const model = getModel(type.class);
         return model.toXML(value);
@@ -108,19 +108,20 @@ const defaults = {
         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)) {
+          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;
+    else return xml;
   }
 };
 export {

package/dist/errors.js

@@ -1,6 +1,4 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-const _FromXMLConversionError = class _FromXMLConversionError extends Error {
+class FromXMLConversionError extends Error {
   constructor(context, error) {
     const message = `[Model: ${context.model.type.name}] failed to convert from XML`;
     super(message);
@@ -8,20 +6,18 @@ const _FromXMLConversionError = class _FromXMLConversionError extends Error {
     this.error = error;
     this.name = "FromXMLConversionError";
   }
-};
-__name(_FromXMLConversionError, "FromXMLConversionError");
-let FromXMLConversionError = _FromXMLConversionError;
-const _PropertyFromXMLConversionError = class _PropertyFromXMLConversionError extends 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`;
+    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 {
+}
+class ToXMLConversionError extends Error {
   constructor(context, cause) {
     const message = `[Model: ${context.model.type.name}] failed to convert to XML`;
     super(message);
@@ -29,19 +25,17 @@ const _ToXMLConversionError = class _ToXMLConversionError extends Error {
     this.cause = cause;
     this.name = "ToXMLConversionError";
   }
-};
-__name(_ToXMLConversionError, "ToXMLConversionError");
-let ToXMLConversionError = _ToXMLConversionError;
-const _PropertyToXMLConversionError = class _PropertyToXMLConversionError extends 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`;
+    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,

package/dist/middleware.js

@@ -1,29 +1,23 @@
-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;
+    if (options.parent) options = options.parent;
+    else return;
   } while (true);
 }
-__name(MiddlewareChain, "MiddlewareChain");
 function resolve(middlewares, context) {
-  const next = /* @__PURE__ */ __name(() => {
+  const next = () => {
     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

package/dist/model/built-ins.js

@@ -1,5 +1,3 @@
-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, {
@@ -39,7 +37,6 @@ function registerBuiltIns(create) {
     }
   });
 }
-__name(registerBuiltIns, "registerBuiltIns");
 export {
   registerBuiltIns as default
 };

package/dist/model/index.js

@@ -1,5 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import "../_virtual/Reflect.js";
 import { reflect } from "typescript-rtti";
 import { ToXMLConversionError, PropertyToXMLConversionError, FromXMLConversionError, PropertyFromXMLConversionError } from "../errors.js";
@@ -27,10 +25,8 @@ function* ParentChain(constructor) {
   }
   return;
 }
-__name(ParentChain, "ParentChain");
 function getParentModel(model) {
-  if (model.options.parent)
-    return model.options.parent;
+  if (model.options.parent) return model.options.parent;
   for (const constructor of ParentChain(model.type)) {
     const model2 = findModel(constructor);
     if (model2) {
@@ -39,17 +35,15 @@ function getParentModel(model) {
   }
   return null;
 }
-__name(getParentModel, "getParentModel");
-const _XMLModel = class _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);
+    const getParent = () => {
+      if (typeof parent === "undefined") parent = getParentModel(this);
       return parent;
-    }, "getParent");
+    };
     let propertiesLoaded = false;
     const properties = {
       options: /* @__PURE__ */ new Map(),
@@ -116,20 +110,24 @@ const _XMLModel = class _XMLModel {
         ]
       }
     };
-    const loadProperties = /* @__PURE__ */ __name(() => {
-      const props = this.reflectedClass.ownProperties.filter((prop) => typeof prop.host.constructor.prototype[prop.name] !== "function");
+    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);
+        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();
+        if (!propertiesLoaded) loadProperties();
         return properties;
       },
       fromXML: {
@@ -148,16 +146,13 @@ const _XMLModel = class _XMLModel {
         return options.tagname || defaults.tagnameFromModel(model);
       }
     };
-    if (options.parent)
-      this.options.parent = options.parent;
+    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);
+    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;
@@ -201,21 +196,21 @@ const _XMLModel = class _XMLModel {
     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")
-      }));
+      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;
   }
-};
-__name(_XMLModel, "XMLModel");
-let XMLModel = _XMLModel;
+}
 function createModel(type, options) {
   if (findModel(type)) {
     throw new TypeError(`a model for type ${type.name} already exists`);
@@ -224,14 +219,11 @@ function createModel(type, options) {
   registrerModel(model);
   return model;
 }
-__name(createModel, "createModel");
 function ModelDecoratorFactory(options) {
   return function(constructor) {
-    if (!findModel(constructor))
-      createModel(constructor, options || {});
+    if (!findModel(constructor)) createModel(constructor, options || {});
   };
 }
-__name(ModelDecoratorFactory, "ModelDecoratorFactory");
 registerBuiltIns(createModel);
 export {
   ModelDecoratorFactory as Model,

package/dist/model/property.js

@@ -1,5 +1,3 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import { reflect } from "typescript-rtti";
 import { defaults } from "../defaults.js";
 import isRegExp from "../util/is-regexp.js";
@@ -15,13 +13,12 @@ function resolvePropertyConversionOptions(options, constructor, property) {
     },
     inline: !!options.inline,
     ignored: !!options.ignore,
-    isSourceElement: /* @__PURE__ */ __name((...args) => defaults.propertySourceElementsFilter(...args), "isSourceElement"),
+    isSourceElement: (...args) => defaults.propertySourceElementsFilter(...args),
     resolveElements: options.resolveElements ? options.resolveElements : (...args) => defaults.propertyResolveSourceElements(...args),
-    fromXML: /* @__PURE__ */ __name((context) => (options.fromXML ?? defaults.propertyFromXML)(context), "fromXML"),
-    toXML: /* @__PURE__ */ __name((context) => (options.toXML ?? defaults.propertyToXML)(context), "toXML")
+    fromXML: (context) => (options.fromXML ?? defaults.propertyFromXML)(context),
+    toXML: (context) => (options.toXML ?? defaults.propertyToXML)(context)
   };
-  if (options?.model)
-    _options.model = options.model;
+  if (options?.model) _options.model = options.model;
   if (options?.sourceElements) {
     const _sourceElements = options.sourceElements;
     if (typeof _sourceElements === "string") {
@@ -34,7 +31,6 @@ function resolvePropertyConversionOptions(options, constructor, property) {
   }
   return _options;
 }
-__name(resolvePropertyConversionOptions, "resolvePropertyConversionOptions");
 const PropertyOptions = /* @__PURE__ */ new Map();
 function storePropertyConversionOptions(constructor, property, options) {
   let map = PropertyOptions.get(constructor);
@@ -44,26 +40,26 @@ function storePropertyConversionOptions(constructor, property, options) {
   }
   map.set(property, options);
 }
-__name(storePropertyConversionOptions, "storePropertyConversionOptions");
 function findPropertyConversionOptions(constructor, property) {
   const options = PropertyOptions.get(constructor);
   if (options) {
     return options.get(property);
   }
 }
-__name(findPropertyConversionOptions, "findPropertyConversionOptions");
 function getPropertyConversionOptions(constructor, property) {
   const options = findPropertyConversionOptions(constructor, property);
   return options ?? resolvePropertyConversionOptions({}, constructor, property);
 }
-__name(getPropertyConversionOptions, "getPropertyConversionOptions");
 function PropDecoratorFactory(options) {
   return function(prototype, property) {
-    const _options = resolvePropertyConversionOptions(options ?? {}, prototype.constructor, property);
+    const _options = resolvePropertyConversionOptions(
+      options ?? {},
+      prototype.constructor,
+      property
+    );
     storePropertyConversionOptions(prototype.constructor, property, _options);
   };
 }
-__name(PropDecoratorFactory, "PropDecoratorFactory");
 export {
   PropDecoratorFactory as Prop,
   getPropertyConversionOptions

package/dist/model/registry.js

@@ -1,22 +1,15 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const Models = /* @__PURE__ */ new Map();
 function registrerModel(model) {
   return Models.set(model.type, model);
 }
-__name(registrerModel, "registrerModel");
 function findModel(id) {
   return Models.get(id);
 }
-__name(findModel, "findModel");
 function getModel(id) {
   const model = findModel(id);
-  if (model)
-    return model;
-  else
-    throw new TypeError(`couldn't find model for type ${id.name}`);
+  if (model) return model;
+  else throw new TypeError(`couldn't find model for type ${id.name}`);
 }
-__name(getModel, "getModel");
 export {
   Models,
   findModel,