xml-model 1.3.3 → 2.0.0-beta.2

package/dist/xml/xml-js.js

@@ -1,9 +1,122 @@
-import { js2xml, xml2js } from "xml-js";
-const XMLJS = {
-  parse: xml2js,
-  stringify: js2xml
+import { require_lib } from "../node_modules/xml-js/lib/index.js";
+import { z } from "zod";
+//#region src/xml/xml-js.ts
+var import_lib = require_lib();
+var ZXMLElementNode = z.object({
+	type: z.literal("element"),
+	name: z.string(),
+	attributes: z.record(z.string(), z.string()).optional(),
+	get elements() {
+		return z.array(ZXMLNode).optional();
+	}
+});
+var ZXMLCommentNode = z.object({
+	type: z.literal("comment"),
+	comment: z.string()
+});
+var ZXMLTextNode = z.object({
+	type: z.literal("text"),
+	text: z.string()
+});
+var ZXMLNode = z.discriminatedUnion("type", [
+	ZXMLElementNode,
+	ZXMLCommentNode,
+	ZXMLTextNode
+]);
+var ZXMLRoot = z.object({ elements: z.array(ZXMLNode) });
+function parse(xml, options = {}) {
+	const strippedOptions = { ...options };
+	delete strippedOptions["compact"];
+	const res = (0, import_lib.xml2js)(xml, strippedOptions);
+	if ("elements" in res) return res;
+	throw new Error("Got empty XML");
+}
+function stringify(xml, options = {}) {
+	return (0, import_lib.js2xml)(xml, options);
+}
+function isRoot(xml) {
+	return Object.keys(xml).length === 1 && "elements" in xml && Array.isArray(xml.elements);
+}
+function elementFromRoot(root) {
+	return root.elements.find((el) => el.type === "element");
+}
+function isEmpty(xml) {
+	return Object.keys(xml).length === 0;
+}
+/**
+* Extracts the text content from an element that has a single text child node.
+*
+* @param xml - An `XMLElement` expected to contain a single text node.
+* @returns The text value, or an empty string when there are no child elements.
+* @throws {TypeError} When the element has multiple or non-text children.
+*/
+function getContent(xml) {
+	if (xml.elements?.length === 1) {
+		const content = xml.elements[0];
+		if (content.type === "text") return content.text;
+	}
+	if (!xml.elements) return "";
+	throw new TypeError(`can't get text from XMLElement: ${JSON.stringify(xml)}`);
+}
+function fromContent(content = "", tag, attributes) {
+	const elements = content ? [{
+		type: "text",
+		text: String(content)
+	}] : [];
+	if (!tag) return { elements };
+	const el = {
+		type: "element",
+		name: tag,
+		elements
+	};
+	if (attributes) el.attributes = attributes;
+	return el;
+}
+/**
+* Appends a child element to `xml`, initialising the `elements` array if needed.
+*
+* @param xml - The parent element to modify.
+* @param element - The child element to append.
+*/
+function addElement(xml, element) {
+	if (!xml.elements) xml.elements = [];
+	xml.elements.push(element);
+}
+/**
+* Sets an attribute on an element, initialising the `attributes` map if needed.
+*
+* @param xml - The element to modify.
+* @param attribute - The attribute name.
+* @param value - The attribute value.
+*/
+function setAttribute(xml, attribute, value) {
+	if (!xml.attributes) xml.attributes = {};
+	xml.attributes[attribute] = value;
+}
+/**
+* Removes an attribute from an element. Does nothing if the element has no attributes.
+*
+* @param xml - The element to modify.
+* @param attribute - The attribute name to remove.
+*/
+function deleteAttribute(xml, attribute) {
+	if (!xml.attributes) return;
+	delete xml.attributes[attribute];
+}
+/** Namespace object bundling all XML utility functions. */
+var XML = {
+	parse,
+	stringify,
+	isRoot,
+	elementFromRoot,
+	isEmpty,
+	fromContent,
+	getContent,
+	addElement,
+	setAttribute,
+	deleteAttribute
 };
-export {
-  XMLJS as default
-};
-//# sourceMappingURL=xml-js.js.map
+//#endregion
+export { ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode, XML as default };
+
+//# sourceMappingURL=xml-js.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-model",
-  "version": "1.3.3",
+  "version": "2.0.0-beta.2",
   "description": "allows transparent XML <-> Object conversion in typescript",
   "license": "MIT",
   "author": "MathisTLD",
@@ -11,9 +11,9 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
-    "./vite": {
-      "types": "./dist/vite/index.d.ts",
-      "import": "./dist/vite/index.js"
+    "./xml": {
+      "types": "./dist/xml/index.d.ts",
+      "import": "./dist/xml/index.js"
     },
     "./*": {
       "types": "./dist/*.d.ts",
@@ -21,51 +21,36 @@
     }
   },
   "scripts": {
-    "preversion": "vitest run",
+    "preversion": "vp test run",
     "version": "npm run build",
     "postversion": "git push && git push --tags",
-    "build": "vite build",
-    "dev": "vite build --watch",
-    "test": "vitest",
-    "lint": "oxlint",
-    "lint:fix": "oxlint --fix",
-    "fmt": "oxfmt",
-    "fmt:check": "oxfmt --check",
-    "prepare": "husky"
-  },
-  "dependencies": {
-    "typescript-rtti": "0.9.6",
-    "xml-js": "^1.6.11"
+    "build": "vp build",
+    "dev": "vp build --watch",
+    "docs": "vp dev",
+    "test": "vp test",
+    "lint": "vp lint",
+    "lint:fix": "vp lint --fix",
+    "fmt": "vp fmt",
+    "fmt:check": "vp fmt --check",
+    "prepare": "vp config"
   },
+  "dependencies": {},
   "devDependencies": {
-    "@rollup/plugin-typescript": "*",
     "@types/node": "^24.10.11",
-    "husky": "^9.1.7",
-    "lint-staged": "^16.2.7",
-    "marmotte": "^0.4.2",
-    "oxfmt": "^0.36.0",
-    "oxlint": "^1.51.0",
-    "reflect-metadata": "^0.1.14",
-    "typescript": "*",
-    "vite": "*",
+    "marmotte": "^0.4.4",
+    "typescript": "^5.9.3",
+    "vite-plus": "latest",
     "vitepress": "^2.0.0-alpha.16",
-    "vitest": "^4.0.18"
+    "vitepress-plugin-llms": "^1.11.0",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest",
+    "xml-js": "^1.6.11"
   },
   "peerDependencies": {
-    "@rollup/plugin-typescript": "^12.3.0",
-    "tslib": "^2.8.1",
-    "typescript": "~5.1.6",
-    "vite": "^7.3.1"
+    "zod": "^4.1.0"
   },
-  "peerDependenciesMeta": {
-    "@rollup/plugin-typescript": {
-      "optional": true
-    },
-    "vite": {
-      "optional": true
-    }
+  "overrides": {
+    "vite": "npm:@voidzero-dev/vite-plus-core@latest",
+    "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
   },
-  "lint-staged": {
-    "*": "oxfmt --no-error-on-unmatched-pattern"
-  }
-}
+  "packageManager": "npm@11.12.0"
+}

package/dist/_virtual/Reflect.js

@@ -1,8 +0,0 @@
-import { getDefaultExportFromCjs } from "./_commonjsHelpers.js";
-import { __require as require_Reflect } from "../node_modules/reflect-metadata/Reflect.js";
-var _ReflectExports = require_Reflect();
-const Reflect = /* @__PURE__ */ getDefaultExportFromCjs(_ReflectExports);
-export {
-  Reflect as default
-};
-//# sourceMappingURL=Reflect.js.map

package/dist/_virtual/Reflect2.js

@@ -1,5 +0,0 @@
-var _Reflect = {};
-export {
-  _Reflect as __exports
-};
-//# sourceMappingURL=Reflect2.js.map

package/dist/_virtual/_commonjsHelpers.js

@@ -1,47 +0,0 @@
-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;
-}
-function getDefaultExportFromNamespaceIfPresent(n) {
-  return n && Object.prototype.hasOwnProperty.call(n, "default") ? n["default"] : n;
-}
-function getDefaultExportFromNamespaceIfNotNamed(n) {
-  return n && Object.prototype.hasOwnProperty.call(n, "default") && Object.keys(n).length === 1 ? n["default"] : n;
-}
-function getAugmentedNamespace(n) {
-  if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
-  var f = n.default;
-  if (typeof f == "function") {
-    var a = function a2() {
-      var isInstance = false;
-      try {
-        isInstance = this instanceof a2;
-      } catch {
-      }
-      if (isInstance) {
-        return Reflect.construct(f, arguments, this.constructor);
-      }
-      return f.apply(this, arguments);
-    };
-    a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, "__esModule", { value: true });
-  Object.keys(n).forEach(function(k) {
-    var d = Object.getOwnPropertyDescriptor(n, k);
-    Object.defineProperty(a, k, d.get ? d : {
-      enumerable: true,
-      get: function() {
-        return n[k];
-      }
-    });
-  });
-  return a;
-}
-export {
-  commonjsGlobal,
-  getAugmentedNamespace,
-  getDefaultExportFromCjs,
-  getDefaultExportFromNamespaceIfNotNamed,
-  getDefaultExportFromNamespaceIfPresent
-};
-//# sourceMappingURL=_commonjsHelpers.js.map

package/dist/defaults.d.ts

@@ -1,28 +0,0 @@
-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;
-}
-/**
- * Global defaults used by all models and properties when no override is provided.
- *
- * You can mutate individual entries to change library-wide behaviour — for example,
- * replace `defaults.fromXML` to provide a base deserialization strategy instead of
- * having to specify `fromXML` on every `@Model()`.
- *
- * Key behaviours:
- * - `fromXML` — throws by default; every root model **must** provide its own implementation.
- * - `tagnameFromModel` / `tagnameFromProperty` — convert class/property names to kebab-case.
- * - `propertyFromXML` — handles class, array, and union-of-literal property types via runtime reflection.
- * - `propertyToXML` — serialises class, array, and union-of-literal values; respects `inline`.
- */
-export declare const defaults: Defaults;
-export {};
-//# sourceMappingURL=defaults.d.ts.map

package/dist/defaults.js

@@ -1,165 +0,0 @@
-import { getModel } from "./model/registry.js";
-import { kebabCase } from "./util/kebab-case.js";
-const defaults = {
-  /**
-   * Default model-level `fromXML` handler.
-   * Always throws — models must supply their own `fromXML` or inherit one from a parent.
-   * @throws {TypeError}
-   */
-  fromXML() {
-    throw new TypeError(
-      "you should define 'defaults.fromXML' yourself or provide a 'fromXML' function to @Model() decorator's options"
-    );
-  },
-  /**
-   * Collects the XML elements that are the source data for a property.
-   * Assumes `xml.elements[0]` is the wrapper element that contains all property tags.
-   */
-  propertyResolveSourceElements(context) {
-    const innerElements = context.xml.elements[0]?.elements || [];
-    return innerElements.filter((el) => context.property.isSourceElement(el, context));
-  },
-  /**
-   * Returns `true` when the element's tag name matches the property's tagname.
-   */
-  propertySourceElementsFilter(element, context) {
-    return context.property.tagname === element.name;
-  },
-  /**
-   * Converts resolved XML elements into a typed property value.
-   * Handles class types, arrays of class types, and union-of-literal types.
-   * Returns `undefined` for optional properties with no matching elements,
-   * and also for unrecognised types.
-   */
-  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;
-  },
-  /**
-   * Default model-level `toXML` handler.
-   * Collects serialised property fragments and wraps them in a root element
-   * named after the model's tagname.
-   */
-  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
-        }
-      ]
-    };
-  },
-  /**
-   * Derives the XML tag name for a model from its class name, converted to kebab-case.
-   * e.g. `MyClass` → `my-class`.
-   */
-  tagnameFromModel(model) {
-    return kebabCase(model.type.name);
-  },
-  /**
-   * Derives the XML tag name for a property from its name, converted to kebab-case.
-   * e.g. `myProp` → `my-prop`.
-   */
-  tagnameFromProperty(property) {
-    return kebabCase(String(property.name));
-  },
-  /**
-   * Converts a typed property value to an `XMLRoot` fragment.
-   * Handles class types, arrays of class types, and union-of-literal types.
-   * When the property has `inline: true`, array items are flattened into the parent element.
-   */
-  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,40 +0,0 @@
-import { fromXMLContext, PropertyFromXMLContext, PropertyToXMLContext, toXMLContext } from './model/types';
-/**
- * Thrown when model-level XML → object conversion fails.
- * Wraps the original error along with the conversion context.
- */
-export declare class FromXMLConversionError<T> extends Error {
-    context: Omit<fromXMLContext<T>, "properties">;
-    error: unknown;
-    name: string;
-    constructor(context: Omit<fromXMLContext<T>, "properties">, error: unknown);
-}
-/**
- * Thrown when a single property's XML → value conversion fails.
- * Extends `FromXMLConversionError` with additional property context.
- */
-export declare class PropertyFromXMLConversionError<T> extends FromXMLConversionError<T> {
-    propertyContext: PropertyFromXMLContext<T>;
-    name: string;
-    constructor(context: Omit<fromXMLContext<T>, "properties">, propertyContext: PropertyFromXMLContext<T>, error: unknown);
-}
-/**
- * Thrown when model-level object → XML conversion fails.
- * Wraps the original cause along with the conversion context.
- */
-export declare class ToXMLConversionError<T> extends Error {
-    context: Omit<toXMLContext<T>, "properties">;
-    cause: unknown;
-    name: string;
-    constructor(context: Omit<toXMLContext<T>, "properties">, cause: unknown);
-}
-/**
- * Thrown when a single property's value → XML conversion fails.
- * Extends `ToXMLConversionError` with additional property context.
- */
-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