xml-model 1.3.1 → 1.3.3

package/dist/vite/index.d.ts

@@ -0,0 +1,80 @@
+import { Plugin } from 'vite';
+import { RollupTypescriptOptions } from '@rollup/plugin-typescript';
+/**
+ * Vite plugin that preserves class names at build time.
+ *
+ * When Building, class names are changed but the library relies on them
+ * so they need to be preserved.
+ *
+ * @returns A Vite plugin that rewrites mangled class name expressions and enables `keepNames`.
+ */
+export declare function FixClassNames(): {
+    name: string;
+    enforce: "post";
+    transform(this: import('rollup').TransformPluginContext, code: string, id: string): {
+        code: string;
+        map: any;
+    };
+    config(this: import('vite').ConfigPluginContext): {
+        esbuild: {
+            keepNames: true;
+        };
+    };
+};
+/** Options for the `TypescriptRTTI` and `XMLModelVitePlugin` plugins. */
+export type RTTIPluginOptions = {
+    /**
+     * Options forwarded to `@rollup/plugin-typescript`.
+     *
+     * The plugin may not work correctly if you override the `transformers` property,
+     * as these options are shallow-merged (not deep-merged).
+     */
+    typescript?: RollupTypescriptOptions;
+    /**
+     * Restrict RTTI transformation to files matching this pattern.
+     *
+     * When omitted, all files are transformed.
+     */
+    include?: RegExp;
+    /** Exclude files matching this pattern from RTTI transformation. */
+    exclude?: RegExp;
+    /** Print debug logs from the RTTI transformer. */
+    debug?: boolean;
+};
+/**
+ * Vite plugin that applies the `typescript-rtti` TypeScript transformer.
+ *
+ * This transformer emits the runtime type metadata that xml-model uses to
+ * introspect property types without manual annotations.
+ *
+ * @param options - Plugin options controlling which files are transformed.
+ * @returns A configured `@rollup/plugin-typescript` instance with the RTTI transformer injected.
+ */
+export declare function TypescriptRTTI(options?: RTTIPluginOptions): import('rollup').Plugin<any>;
+/** Alias for `RTTIPluginOptions`. */
+export type XMLModelVitePluginOptions = RTTIPluginOptions;
+/**
+ * Main xml-model Vite plugin.
+ *
+ * Combines `FixClassNames`, `TypescriptRTTI`, and an internal resolver that
+ * rewrites the `xml-model/dist/*` import paths emitted by typescript-rtti back
+ * to the canonical `xml-model/*` paths exported by the package.
+ *
+ * @param options - Options forwarded to `TypescriptRTTI`.
+ * @returns An array of Vite plugins.
+ */
+export declare function XMLModelVitePlugin(options?: RTTIPluginOptions): (Plugin<any> | import('rollup').Plugin<any> | {
+    name: string;
+    enforce: "post";
+    transform(this: import('rollup').TransformPluginContext, code: string, id: string): {
+        code: string;
+        map: any;
+    };
+    config(this: import('vite').ConfigPluginContext): {
+        esbuild: {
+            keepNames: true;
+        };
+    };
+})[];
+export default XMLModelVitePlugin;
+//# sourceMappingURL=index.d.ts.map

package/{vite/dist → dist/vite}/index.js

@@ -52,7 +52,15 @@ function TypescriptRTTI(options = {}) {
   });
 }
 function XMLModelVitePlugin(options = {}) {
-  return [FixClassNames(), TypescriptRTTI(options)];
+  const distResolver = {
+    name: "xml-model-resolve-dist",
+    enforce: "pre",
+    async resolveId(id) {
+      const match = id.match(/^xml-model\/dist\/(.*)/);
+      if (match) return this.resolve(`xml-model/${match[1]}`);
+    }
+  };
+  return [FixClassNames(), TypescriptRTTI(options), distResolver];
 }
 export {
   FixClassNames,

package/dist/xml/index.d.ts

@@ -1,7 +1,34 @@
 import { XMLElement, XMLRoot } from '../types';
+/**
+ * Parses an XML string into an `XMLRoot` document tree.
+ *
+ * @param string - A well-formed XML string.
+ * @returns The root of the parsed element tree.
+ */
 export declare function parse(string: string): XMLRoot;
+/**
+ * Serialises an `XMLRoot` or `XMLElement` back into an XML string.
+ * Delegates to xml-js's `js2xml` function.
+ */
 export declare const stringify: typeof import('xml-js').js2xml;
+/**
+ * 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.
+ */
 export declare function getContent(xml: XMLElement): string | number | boolean;
+/**
+ * Creates a minimal element structure wrapping the given text content.
+ * When no tag name is provided, returns a fragment with a text child.
+ * When a tag name is provided, returns a full element with the given name and optional attributes.
+ *
+ * @param content - The text content to wrap (defaults to empty string).
+ * @param tag - Optional element tag name.
+ * @param attributes - Optional attributes; only valid when `tag` is provided.
+ * @throws {TypeError} When `attributes` are provided without a `tag`.
+ */
 export declare function fromContent(content: string): {
     elements: [{
         type: "text";
@@ -17,9 +44,29 @@ export declare function fromContent(content: string, tag: string, attributes?: X
         text: string;
     }] | [];
 };
+/**
+ * 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.
+ */
 export declare function addElement(xml: XMLElement, element: XMLElement): void;
+/**
+ * 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.
+ */
 export declare function setAttribute(xml: XMLElement, attribute: string, value: string): void;
+/**
+ * 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.
+ */
 export declare function deleteAttribute(xml: XMLElement, attribute: string): void;
+/** Namespace object bundling all XML utility functions. */
 declare const XML: {
     parse: typeof parse;
     stringify: typeof import('xml-js').js2xml;

package/dist/xml/index.js

@@ -1,56 +1,40 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 import XMLJS from "./xml-js.js";
 function parse(string) {
   return XMLJS.parse(string);
 }
-__name(parse, "parse");
 const stringify = XMLJS.stringify;
 function getContent(xml) {
   if (xml.elements?.length === 1) {
     const content = xml.elements[0];
-    if (content.type === "text")
-      return content.text;
+    if (content.type === "text") return content.text;
   }
-  if (!xml.elements)
-    return "";
+  if (!xml.elements) return "";
   throw new TypeError(`can't get text from XMLElement: ${JSON.stringify(xml)}`);
 }
-__name(getContent, "getContent");
 function fromContent(content = "", tag, attributes) {
   const el = {
     elements: content ? [{ type: "text", text: String(content) }] : []
   };
-  if (tag)
-    el.name = tag;
+  if (tag) el.name = tag;
   if (attributes) {
-    if (!el.name)
-      throw new TypeError("please provide a name if you want to provide attributes");
+    if (!el.name) throw new TypeError("please provide a name if you want to provide attributes");
     el.attributes = attributes;
   }
-  if (el.name)
-    el.type = "element";
+  if (el.name) el.type = "element";
   return el;
 }
-__name(fromContent, "fromContent");
 function addElement(xml, element) {
-  if (!xml.elements)
-    xml.elements = [];
+  if (!xml.elements) xml.elements = [];
   xml.elements.push(element);
 }
-__name(addElement, "addElement");
 function setAttribute(xml, attribute, value) {
-  if (!xml.attributes)
-    xml.attributes = {};
+  if (!xml.attributes) xml.attributes = {};
   xml.attributes[attribute] = value;
 }
-__name(setAttribute, "setAttribute");
 function deleteAttribute(xml, attribute) {
-  if (!xml.attributes)
-    return;
+  if (!xml.attributes) return;
   delete xml.attributes[attribute];
 }
-__name(deleteAttribute, "deleteAttribute");
 const XML = {
   parse,
   stringify,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-model",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "allows transparent XML <-> Object conversion in typescript",
   "license": "MIT",
   "author": "MathisTLD",
@@ -11,17 +11,17 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
     },
+    "./vite": {
+      "types": "./dist/vite/index.d.ts",
+      "import": "./dist/vite/index.js"
+    },
     "./*": {
       "types": "./dist/*.d.ts",
       "import": "./dist/*.js"
-    },
-    "./vite": {
-      "types": "./vite/dist/index.d.ts",
-      "import": "./vite/dist/index.js"
     }
   },
   "scripts": {
-    "preversion": "npm test -- --run",
+    "preversion": "vitest run",
     "version": "npm run build",
     "postversion": "git push && git push --tags",
     "build": "vite build",
@@ -42,16 +42,18 @@
     "@types/node": "^24.10.11",
     "husky": "^9.1.7",
     "lint-staged": "^16.2.7",
-    "marmotte": "^0.1.4",
-    "oxfmt": "^0.28.0",
-    "oxlint": "^1.43.0",
+    "marmotte": "^0.4.2",
+    "oxfmt": "^0.36.0",
+    "oxlint": "^1.51.0",
     "reflect-metadata": "^0.1.14",
     "typescript": "*",
     "vite": "*",
+    "vitepress": "^2.0.0-alpha.16",
     "vitest": "^4.0.18"
   },
   "peerDependencies": {
     "@rollup/plugin-typescript": "^12.3.0",
+    "tslib": "^2.8.1",
     "typescript": "~5.1.6",
     "vite": "^7.3.1"
   },

package/dist/model/types.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=types.js.map

package/dist/types.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=types.js.map

package/vite/dist/src/class-names.test.d.ts

@@ -1,9 +0,0 @@
-export declare class Book {
-    name: string;
-    nbPages: number;
-    constructor(options: {
-        name: string;
-        nbPages: number;
-    });
-}
-//# sourceMappingURL=class-names.test.d.ts.map

package/vite/dist/src/defaults.d.ts

@@ -1,15 +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;
-}
-export declare const defaults: Defaults;
-export {};
-//# sourceMappingURL=defaults.d.ts.map

package/vite/dist/src/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/vite/dist/src/index.d.ts

@@ -1,8 +0,0 @@
-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 * from 'typescript-rtti';
-export { XML };
-//# sourceMappingURL=index.d.ts.map

package/vite/dist/src/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/vite/dist/src/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/vite/dist/src/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/vite/dist/src/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/vite/dist/src/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/vite/dist/src/model/types.d.ts

@@ -1,74 +0,0 @@
-import { ReflectedProperty } from 'typescript-rtti';
-import { XMLRoot, XMLElement } from '../types';
-import { Middleware } from '../middleware';
-import { XMLModel } from './index';
-export type XMLModelProperty<T> = Extract<keyof T, string>;
-export type PropertiesRecord<T> = {
-    [key in keyof T]?: T[key];
-};
-export type XMLPropertiesRecord<T> = {
-    [key in keyof T]?: XMLRoot;
-};
-export interface PropertyToXMLContext<T> extends Omit<toXMLContext<T>, "properties"> {
-    property: XMLModelPropertyOptions<T>;
-    value: T[keyof T];
-}
-export interface PropertyFromXMLContext<T> extends Omit<fromXMLContext<T>, "properties"> {
-    property: XMLModelPropertyOptions<T>;
-    elements: XMLElement[];
-}
-export interface XMLModelPropertyOptions<T> {
-    name: keyof T;
-    reflected: ReflectedProperty;
-    tagname: string;
-    ignored: boolean;
-    inline: boolean;
-    model?: XMLModel<any>;
-    isSourceElement: (element: XMLElement, context: Omit<PropertyFromXMLContext<T>, "elements">) => boolean;
-    resolveElements: (context: Omit<PropertyFromXMLContext<T>, "elements">) => XMLElement[];
-    fromXML: (context: PropertyFromXMLContext<T>) => T[keyof T];
-    toXML: (context: PropertyToXMLContext<T>) => XMLRoot;
-}
-export interface CreateXMLModelPropertyOptions<T> {
-    tagname?: string;
-    sourceElements?: string | RegExp | XMLModelPropertyOptions<T>["isSourceElement"];
-    resolveElements?: XMLModelPropertyOptions<T>["resolveElements"];
-    toXML?: XMLModelPropertyOptions<T>["toXML"];
-    fromXML?: XMLModelPropertyOptions<T>["fromXML"];
-    inline?: boolean;
-    ignore?: boolean;
-    model?: XMLModelPropertyOptions<T>["model"];
-}
-interface ConversionOptions<C, T> {
-    parent: ConversionOptions<C, T> | null;
-    middlewares: Middleware<C, T>[];
-}
-export interface fromXMLContext<T> {
-    xml: XMLRoot;
-    properties: PropertiesRecord<T>;
-    model: XMLModel<T>;
-}
-export interface toXMLContext<T> {
-    object: T;
-    properties: XMLPropertiesRecord<T>;
-    model: XMLModel<T>;
-}
-export interface XMLModelOptions<T> {
-    parent?: XMLModel<T>;
-    properties: {
-        fromXML: ConversionOptions<Omit<fromXMLContext<T>, "properties">, PropertiesRecord<T>>;
-        toXML: ConversionOptions<Omit<toXMLContext<T>, "properties">, XMLPropertiesRecord<T>>;
-        options: Map<XMLModelProperty<T>, XMLModelPropertyOptions<T>>;
-    };
-    fromXML: ConversionOptions<fromXMLContext<T>, T>;
-    toXML: ConversionOptions<toXMLContext<T>, XMLRoot>;
-    tagname: string;
-}
-export interface CreateXMLModelOptions<T> {
-    parent?: XMLModelOptions<T>["parent"];
-    fromXML?: XMLModelOptions<T>["fromXML"]["middlewares"][number];
-    toXML?: XMLModelOptions<T>["toXML"]["middlewares"][number];
-    tagname?: XMLModelOptions<T>["tagname"];
-}
-export { XMLModel };
-//# sourceMappingURL=types.d.ts.map

package/vite/dist/src/model.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=model.test.d.ts.map

package/vite/dist/src/types.d.ts

@@ -1,17 +0,0 @@
-export type { Constructor } from 'typescript-rtti';
-export type UnknownRecord = Record<string | number | symbol, unknown>;
-export type UnknownObject = object;
-export interface XMLAttributes {
-    [key: string]: string | number | undefined;
-}
-export interface XMLElement {
-    type?: string;
-    name?: string;
-    attributes?: XMLAttributes;
-    elements?: Array<XMLElement>;
-    text?: string | number | boolean;
-}
-export type XMLRoot = {
-    elements: XMLElement[];
-};
-//# sourceMappingURL=types.d.ts.map

package/vite/dist/src/util/is-regexp.d.ts

@@ -1,12 +0,0 @@
-/**
- * Stolen from https://github.com/sindresorhus/is-regexp/blob/main/index.js
- *
- * see https://github.com/sindresorhus/is#why-not-just-use-instanceof-instead-of-this-package
- *
- * could use `import { isRegExp } from "node:util/types"` but I want isomorphic lib
- * @param value
- * @returns
- */
-export declare function isRegExp(value: unknown): value is RegExp;
-export default isRegExp;
-//# sourceMappingURL=is-regexp.d.ts.map

package/vite/dist/src/util/kebab-case.d.ts

@@ -1,16 +0,0 @@
-/**
- * Transforms a string into kebab-case.
- *
- * stolen from https://github.com/joakimbeng/kebab-case/blob/master/index.js
- *
- * @example
- * kebabCase("helloWorld"); // "hello-world"
- * kebabCase("HelloWorld"); // "-hello-world"
- * kebabCase("HelloWorld", false); // "hello-world"
- *
- * @param str The string to transform
- * @param keepLeadingDash Whether to keep the leading dash in case the string starts with an uppercase letter (default: true)
- * @returns The kebab-cased string
- */
-export declare function kebabCase(str: string, keepLeadingDash?: boolean): string;
-//# sourceMappingURL=kebab-case.d.ts.map

package/vite/dist/src/util/merge-maps.d.ts

@@ -1,2 +0,0 @@
-export default function mergeMaps<K, V>(...sources: Map<K, V>[]): Map<K, V>;
-//# sourceMappingURL=merge-maps.d.ts.map

package/vite/dist/src/xml/index.d.ts

@@ -1,33 +0,0 @@
-import { XMLElement, XMLRoot } from '../types';
-export declare function parse(string: string): XMLRoot;
-export declare const stringify: typeof import('xml-js').js2xml;
-export declare function getContent(xml: XMLElement): string | number | boolean;
-export declare function fromContent(content: string): {
-    elements: [{
-        type: "text";
-        text: string;
-    }] | [];
-};
-export declare function fromContent(content: string, tag: string, attributes?: XMLElement["attributes"]): {
-    type: "element";
-    name: string;
-    attributes?: XMLElement["attributes"];
-    elements: [{
-        type: "text";
-        text: string;
-    }] | [];
-};
-export declare function addElement(xml: XMLElement, element: XMLElement): void;
-export declare function setAttribute(xml: XMLElement, attribute: string, value: string): void;
-export declare function deleteAttribute(xml: XMLElement, attribute: string): void;
-declare const XML: {
-    parse: typeof parse;
-    stringify: typeof import('xml-js').js2xml;
-    fromContent: typeof fromContent;
-    getContent: typeof getContent;
-    addElement: typeof addElement;
-    setAttribute: typeof setAttribute;
-    deleteAttribute: typeof deleteAttribute;
-};
-export default XML;
-//# sourceMappingURL=index.d.ts.map

package/vite/dist/src/xml/xml-js.d.ts

@@ -1,7 +0,0 @@
-import { xml2js as parse, js2xml as stringify } from 'xml-js';
-declare const _default: {
-    parse: typeof parse;
-    stringify: typeof stringify;
-};
-export default _default;
-//# sourceMappingURL=xml-js.d.ts.map