xml-model 2.0.0-beta.7 → 2.0.0

package/dist/index.js

@@ -1,7 +1,7 @@
 import { DATA, isModel, model } from "./model.js";
 import XML, { ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode } from "./xml/xml-js.js";
 import { xml } from "./xml/schema-meta.js";
-import { XMLCodecError, normalizeCodecOptions, registerDefault, xmlStateSchema } from "./xml/codec.js";
+import { XMLCodecError, normalizeCodecOptions, parseXML, registerDefault, stringifyXML, toXML, xmlCodec, xmlStateSchema } from "./xml/codec.js";
 import { xmlModel } from "./xml/model.js";
 import "./xml/index.js";
-export { DATA, XML, XMLCodecError, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode, isModel, model, normalizeCodecOptions, registerDefault, xml, xmlModel, xmlStateSchema };
+export { DATA, XML, XMLCodecError, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode, isModel, model, normalizeCodecOptions, parseXML, registerDefault, stringifyXML, toXML, xml, xmlCodec, xmlModel, xmlStateSchema };

package/dist/model.d.ts

@@ -1,4 +1,6 @@
 import { z, GlobalMeta } from 'zod';
+/** Stores the raw data object on model instances. */
+export declare const DATA: unique symbol;
 /**
  * Constructor type for model classes.
  *
@@ -36,8 +38,6 @@ export type ModelConstructor<S extends z.ZodObject<any> = z.ZodObject<any>, Inst
      */
     extend<Self extends ModelConstructor<S, Inst>, U extends z.core.$ZodLooseShape>(this: Self, extension: U, meta?: GlobalMeta): Omit<Self, keyof ModelConstructor<S, Inst>> & ModelConstructor<z.ZodObject<z.util.Extend<S["shape"], U>>, InstanceType<Self> & z.infer<z.ZodObject<z.util.Extend<S["shape"], U>>>>;
 };
-/** Stores the raw data object on model instances. */
-export declare const DATA: unique symbol;
 /** Returns true if `cls` is a class produced by `model()` (or a subclass of one). */
 export declare function isModel(cls: unknown): cls is ModelConstructor;
 /**

package/dist/model.js

@@ -1,6 +1,6 @@
 import { z } from "zod";
 //#region src/model.ts
-var schemaSymbol = Symbol("model:schema");
+var SCHEMA = Symbol("model:schema");
 /** Marker placed on every class returned by `model()`. Used by `isModel()`. */
 var MODEL_MARKER = Symbol("model:marker");
 /** Stores the raw data object on model instances. */
@@ -34,8 +34,10 @@ function model(schema) {
 	class Base {
 		static dataSchema = schema;
 		static [MODEL_MARKER] = true;
+		static [SCHEMA];
+		[DATA];
 		static schema() {
-			if (!Object.prototype.hasOwnProperty.call(this, schemaSymbol)) this[schemaSymbol] = z.codec(this.dataSchema, z.instanceof(this), {
+			if (!Object.prototype.hasOwnProperty.call(this, SCHEMA)) this[SCHEMA] = z.codec(this.dataSchema, z.instanceof(this), {
 				decode: (data) => {
 					return this.fromData(data);
 				},
@@ -43,7 +45,7 @@ function model(schema) {
 					return instance[DATA];
 				}
 			});
-			return this[schemaSymbol];
+			return this[SCHEMA];
 		}
 		static extend(extension, meta) {
 			let extended = this.dataSchema.extend(extension);

package/dist/xml/codec.d.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { XMLElement } from './xml-js';
+import { XMLElement, XMLRoot, StringifyOptions } from './xml-js';
 export declare class XMLCodecError extends Error {
     readonly path: readonly (string | number)[];
     readonly rawMessage: string;
@@ -12,22 +12,24 @@ export declare function assertSingleRoot(xml: XMLElement[]): asserts xml is [XML
 type PropKey<S extends z.ZodObject> = keyof z.input<S> & string;
 export interface CodecOptions<S extends z.ZodType> {
     schema: S;
-    tagname(ctx: RootEncodingContext<S>): string;
-    decode(ctx: RootDecodingContext<S>): z.input<S>;
-    encode(ctx: RootEncodingContext<S>): XMLElement;
-    propertyTagname: (ctx: {
+    /** Resolved options of the wrapped inner schema, if any (e.g. the inner type of ZodOptional). */
+    parent: CodecOptions<z.ZodType> | undefined;
+    tagname(this: void, ctx: RootEncodingContext<S>): string;
+    decode(this: void, ctx: RootDecodingContext<S>): z.input<S>;
+    encode(this: void, ctx: RootEncodingContext<S>): XMLElement;
+    propertyTagname: (this: void, ctx: {
         name: string;
         options: CodecOptions<z.ZodType>;
     }) => string;
     /** if true, XML representation is not contained in a single XML tag */
     inlineProperty: boolean;
-    propertyMatch: (el: XMLElement, ctx: {
+    propertyMatch: (this: void, el: XMLElement, ctx: {
         name: string;
         tagname: string;
         options: CodecOptions<z.ZodType>;
     }) => boolean;
-    decodeAsProperty(ctx: PropertyDecodingContext): void;
-    encodeAsProperty(ctx: PropertyEncodingContext): void;
+    decodeAsProperty(this: void, ctx: PropertyDecodingContext): void;
+    encodeAsProperty(this: void, ctx: PropertyEncodingContext): void;
 }
 /**
  * Stored in schema meta under the single `@@xml-model` key.
@@ -72,7 +74,7 @@ export interface PropertyEncodingContext<S extends z.ZodObject = z.ZodObject, K
     };
     result: XMLElement;
 }
-export declare function normalizeCodecOptions<S extends z.ZodType>(schema: S, options?: UserCodecOptions<S>): CodecOptions<S>;
+export declare function normalizeCodecOptions<S extends z.ZodType>(schema: S, options?: UserCodecOptions<S>, parent?: CodecOptions<z.ZodType> | undefined): CodecOptions<S>;
 type OrderEntry = string | XMLElement;
 export interface XMLState {
     /** Preserves element ordering and unknown elements across a decode → encode round-trip. */
@@ -108,10 +110,63 @@ export declare function xmlStateSchema(options: {
 }): z.ZodOptional<z.ZodCustom<XMLState & {
     source: XMLElement;
 }>>;
-export declare function decode<S extends z.ZodType>(schema: S, xml: XMLElement): z.input<S>;
+/**
+ * Converts an `XMLElement` into the **input type** of `schema` (`z.input<S>`).
+ *
+ * This is a pure XML-to-data adapter: it does not run Zod's parse pipeline, so
+ * `z.codec` transforms and default values are **not** applied. The result is the
+ * raw decoded value suitable for passing to `schema.parse()`.
+ */
+export declare function decode<S extends z.ZodType>(schema: S, xml: XMLElement | null): z.input<S>;
+/**
+ * Converts the **input type** of `schema` (`z.input<S>`) into an `XMLElement`.
+ *
+ * This is a pure data-to-XML adapter: it expects values at `z.input<S>` level,
+ * meaning `z.codec` transforms must already have been reversed (via `schema.encode()`)
+ * before calling this function.
+ */
 export declare function encode<S extends z.ZodType>(schema: S, data: z.input<S>): XMLElement;
+/**
+ * Parses an XML string, `XMLRoot`, or `XMLElement` into the **output type** of
+ * `schema` (`z.output<S>`), running the full pipeline:
+ * XML → `decode` → `schema.parse()`.
+ *
+ * `z.codec` transforms (e.g. string → Date) and default values are applied.
+ * Use the lower-level {@link decode} if you need the raw input-type value without
+ * running the Zod parse pipeline.
+ */
+export declare function parseXML<S extends z.ZodType>(schema: S, input: string | XMLRoot | XMLElement): z.output<S>;
+/**
+ * Converts a value at the **output type** of `schema` (`z.output<S>`) into an
+ * `XMLElement`, running the full pipeline: `schema.encode()` → `encode`.
+ *
+ * `z.codec` transforms are reversed before the XML adapter runs.
+ * Use the lower-level {@link encode} if you already have an input-type value and
+ * do not need to run the Zod encode pipeline.
+ *
+ * Does not accept nullable values — check for `null`/`undefined` before calling.
+ */
+export declare function toXML<S extends z.ZodType>(schema: S, data: z.output<S>): XMLElement;
+/**
+ * Converts a value at the **output type** of `schema` (`z.output<S>`) into an
+ * XML string, running the full pipeline: `schema.encode()` → `encode` → `XML.stringify`.
+ *
+ * Equivalent to `XML.stringify({ elements: [toXML(schema, data)] }, options)`.
+ */
+export declare function stringifyXML<S extends z.ZodType>(schema: S, data: z.output<S>, options?: StringifyOptions): string;
 type DefaultResolver<S extends z.ZodType = z.ZodType> = (schema: S) => CodecOptions<S> | void;
 export declare function registerDefault(resolve: DefaultResolver): void;
+/**
+ * Creates a `z.codec` that converts between an XML string and the **input type**
+ * of `schema` (`z.input<S>`).
+ *
+ * The codec sits at the XML ↔ `z.input<S>` boundary only — it does not run Zod's
+ * parse pipeline. `z.codec` transforms (e.g. string → Date) and class instantiation
+ * are left to `schema.parse()` / `schema.encode()`, which you call separately if needed.
+ *
+ * Typical use: `xmlCodec(MyClass.dataSchema)` for standalone encode/decode without
+ * going through the full `fromXML` / `toXMLString` class API.
+ */
 export declare function xmlCodec<S extends z.ZodType>(schema: S): z.ZodCodec<z.ZodString, S>;
 export {};
 //# sourceMappingURL=codec.d.ts.map

package/dist/xml/codec.js

@@ -1,7 +1,7 @@
 import XML from "./xml-js.js";
-import { isZodType } from "../util/zod.js";
+import { getParentSchema, isZodType } from "../util/zod.js";
 import { kebabCase } from "../util/kebab-case.js";
-import { getUserOptions, prop } from "./schema-meta.js";
+import { getOwnUserOptions, prop, root } from "./schema-meta.js";
 import { z } from "zod";
 //#region src/xml/codec.ts
 var XMLCodecError = class extends Error {
@@ -22,35 +22,37 @@ function rethrow(e, segment) {
 function assertSingleElement(xml) {
 	if (xml.length !== 1) throw new Error(`Expected single XML element, got ${xml.length}`);
 }
-function normalizeCodecOptions(schema, options = {}) {
+function normalizeCodecOptions(schema, options = {}, parent = void 0) {
 	let _defaultOptions;
 	const defaultOptions = () => {
 		if (!_defaultOptions) {
-			_defaultOptions = resolveDefault(schema);
-			if (!_defaultOptions) throw new Error(`Failed to resolve default codec options for schema of type ${schema.type}`);
+			const resolved = resolveDefault(schema);
+			if (!resolved) throw new Error(`Failed to resolve default codec options for schema of type ${schema.type}`);
+			_defaultOptions = resolved;
 		}
 		return _defaultOptions;
 	};
 	const userTagname = options.tagname;
-	const tagname = typeof userTagname === "string" ? () => userTagname : typeof userTagname === "function" ? userTagname : () => {
+	const tagname = typeof userTagname === "string" ? () => userTagname : typeof userTagname === "function" ? userTagname : parent ? (ctx) => parent.tagname(ctx) : () => {
 		throw new Error("tagname is not defined");
 	};
 	const userPropTagname = options.propertyTagname;
-	const propertyTagname = typeof userPropTagname === "string" ? () => userPropTagname : typeof userPropTagname === "function" ? userPropTagname : (ctx) => kebabCase(ctx.name);
-	const inlineProperty = options.inlineProperty ?? false;
+	const propertyTagname = typeof userPropTagname === "string" ? () => userPropTagname : typeof userPropTagname === "function" ? userPropTagname : parent ? (ctx) => parent.propertyTagname(ctx) : (ctx) => kebabCase(ctx.name);
+	const inlineProperty = options.inlineProperty ?? parent?.inlineProperty ?? false;
 	const userMatch = options.propertyMatch;
-	const propertyMatch = userMatch instanceof RegExp ? (el) => userMatch.test(el.name) : typeof userMatch === "function" ? userMatch : (el, ctx) => el.name === ctx.tagname;
+	const propertyMatch = userMatch instanceof RegExp ? (el) => userMatch.test(el.name) : typeof userMatch === "function" ? userMatch : parent ? (el, ctx) => parent.propertyMatch(el, ctx) : (el, ctx) => el.name === ctx.tagname;
 	const result = {
 		schema,
+		parent,
 		tagname,
-		decode: options.decode ? (ctx) => options.decode(ctx, () => defaultOptions().decode(ctx)) : (ctx) => defaultOptions().decode(ctx),
-		encode: options.encode ? (ctx) => options.encode(ctx, () => defaultOptions().encode(ctx)) : (ctx) => defaultOptions().encode(ctx),
+		decode: options.decode ? (ctx) => options.decode(ctx, () => defaultOptions().decode(ctx)) : defaultOptions().decode,
+		encode: options.encode ? (ctx) => options.encode(ctx, () => defaultOptions().encode(ctx)) : defaultOptions().encode,
 		propertyTagname,
 		inlineProperty,
 		propertyMatch,
-		decodeAsProperty: options.decodeAsProperty ?? function(ctx) {
-			const res = result.decode({
-				options: result,
+		decodeAsProperty: options.decodeAsProperty ?? parent?.decodeAsProperty ?? function(ctx) {
+			const res = ctx.property.options.decode({
+				options: ctx.property.options,
 				xml: ctx.property.xml
 			});
 			ctx.result[ctx.property.name] = res;
@@ -66,11 +68,13 @@ function normalizeCodecOptions(schema, options = {}) {
 				data: property.value
 			});
 			if (XML.isEmpty(res)) return;
-			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements.map((el) => el.type === "element" ? {
-				...el,
-				name: property.tagname
-			} : el));
-			else ctx.result.elements.push(res);
+			if (property.options.inlineProperty) {
+				const elements = res.elements?.map((el) => el.type === "element" ? {
+					...el,
+					name: property.tagname
+				} : el);
+				if (elements) (ctx.result.elements ??= []).push(...elements);
+			} else (ctx.result.elements ??= []).push(res);
 		}
 	};
 	return result;
@@ -79,14 +83,21 @@ var cache = /* @__PURE__ */ new Map();
 function resolveCodecOptions(schema) {
 	const cached = cache.get(schema);
 	if (cached) return cached;
-	const options = normalizeCodecOptions(schema, getUserOptions(schema));
-	cache.set(schema, options);
-	return options;
+	const placeholder = {};
+	cache.set(schema, placeholder);
+	const parentSchema = getParentSchema(schema);
+	const parent = parentSchema ? resolveCodecOptions(parentSchema) : void 0;
+	const options = normalizeCodecOptions(schema, getOwnUserOptions(schema), parent);
+	Object.assign(placeholder, options);
+	return placeholder;
 }
 /** Tracks all schemas created by `xmlStateSchema()` for fast detection at setup time. */
 var xmlStateSchemas = /* @__PURE__ */ new WeakSet();
 function xmlStateSchema(options) {
-	const result = prop(z.custom().optional(), {
+	const result = prop(root(z.custom(), {
+		decode: () => ({}),
+		encode: () => ({})
+	}).optional(), {
 		decode: options?.source ? (ctx, _next) => {
 			(ctx.result[ctx.property.name] ??= {}).source = ctx.xml;
 		} : () => {},
@@ -95,6 +106,15 @@ function xmlStateSchema(options) {
 	xmlStateSchemas.add(result);
 	return result;
 }
+/** Returns true if any schema in the wrapper chain has a user-defined tagname. */
+function hasUserTagname(schema) {
+	let s = schema;
+	while (s) {
+		if (getOwnUserOptions(s).tagname) return true;
+		s = getParentSchema(s);
+	}
+	return false;
+}
 function resolvePropertiesCodecOptions(schema) {
 	const shape = schema.def.shape;
 	const options = {};
@@ -111,6 +131,13 @@ function findXmlStateKey(shape) {
 	if (keys.length > 1) throw new Error(`Only one xmlStateSchema field is allowed per object schema, found: ${keys.join(", ")}`);
 	return keys[0];
 }
+/**
+* Converts an `XMLElement` into the **input type** of `schema` (`z.input<S>`).
+*
+* This is a pure XML-to-data adapter: it does not run Zod's parse pipeline, so
+* `z.codec` transforms and default values are **not** applied. The result is the
+* raw decoded value suitable for passing to `schema.parse()`.
+*/
 function decode(schema, xml) {
 	const options = resolveCodecOptions(schema);
 	return options.decode({
@@ -118,6 +145,13 @@ function decode(schema, xml) {
 		xml
 	});
 }
+/**
+* Converts the **input type** of `schema` (`z.input<S>`) into an `XMLElement`.
+*
+* This is a pure data-to-XML adapter: it expects values at `z.input<S>` level,
+* meaning `z.codec` transforms must already have been reversed (via `schema.encode()`)
+* before calling this function.
+*/
 function encode(schema, data) {
 	const options = resolveCodecOptions(schema);
 	return options.encode({
@@ -125,6 +159,46 @@ function encode(schema, data) {
 		data
 	});
 }
+/**
+* Parses an XML string, `XMLRoot`, or `XMLElement` into the **output type** of
+* `schema` (`z.output<S>`), running the full pipeline:
+* XML → `decode` → `schema.parse()`.
+*
+* `z.codec` transforms (e.g. string → Date) and default values are applied.
+* Use the lower-level {@link decode} if you need the raw input-type value without
+* running the Zod parse pipeline.
+*/
+function parseXML(schema, input) {
+	if (typeof input === "string") input = XML.parse(input);
+	if (XML.isRoot(input)) {
+		const el = XML.elementFromRoot(input);
+		if (!el) throw new Error("Failed to resolve XML element from root");
+		input = el;
+	}
+	return schema.parse(decode(schema, input));
+}
+/**
+* Converts a value at the **output type** of `schema` (`z.output<S>`) into an
+* `XMLElement`, running the full pipeline: `schema.encode()` → `encode`.
+*
+* `z.codec` transforms are reversed before the XML adapter runs.
+* Use the lower-level {@link encode} if you already have an input-type value and
+* do not need to run the Zod encode pipeline.
+*
+* Does not accept nullable values — check for `null`/`undefined` before calling.
+*/
+function toXML(schema, data) {
+	return encode(schema, schema.encode(data));
+}
+/**
+* Converts a value at the **output type** of `schema` (`z.output<S>`) into an
+* XML string, running the full pipeline: `schema.encode()` → `encode` → `XML.stringify`.
+*
+* Equivalent to `XML.stringify({ elements: [toXML(schema, data)] }, options)`.
+*/
+function stringifyXML(schema, data, options) {
+	return XML.stringify({ elements: [toXML(schema, data)] }, options);
+}
 function registerDefault(resolve) {
 	defaults.push(resolve);
 }
@@ -141,12 +215,12 @@ registerDefault((schema) => {
 		const elSchema = schema.def.element;
 		if (!isZodType(elSchema)) throw new Error(`Expected a ZodType, got ${elSchema}`);
 		const elOptions = resolveCodecOptions(elSchema);
-		const elHasOwnTagname = Boolean(getUserOptions(elSchema).tagname);
+		const elHasOwnTagname = hasUserTagname(elSchema);
 		return normalizeCodecOptions(schema, {
 			decode(ctx) {
 				const { xml } = ctx;
 				if (!xml) return [];
-				return xml.elements.filter((el) => el.type === "element").map((el) => elOptions.decode({
+				return (xml.elements ?? []).filter((el) => el.type === "element").map((el) => elOptions.decode({
 					options: elOptions,
 					xml: el
 				}));
@@ -189,7 +263,7 @@ registerDefault((schema) => {
 			encodeAsProperty(ctx) {
 				if (typeof ctx.property.value !== "undefined") innerOptions.encodeAsProperty(ctx);
 			}
-		});
+		}, innerOptions);
 	}
 	if (schema instanceof z.ZodDefault) {
 		const { innerType: inner, defaultValue } = schema.def;
@@ -204,7 +278,7 @@ registerDefault((schema) => {
 			encode(ctx) {
 				return innerOptions.encode(ctx);
 			}
-		});
+		}, innerOptions);
 	}
 	if (schema instanceof z.ZodLazy) {
 		const inner = schema.def.getter();
@@ -232,11 +306,11 @@ registerDefault((schema) => {
 					data: ctx.data
 				});
 			}
-		});
+		}, inputCodecOptions);
 	}
 	if (schema instanceof z.ZodLiteral) {
 		const values = schema.def.values;
-		const valuesFromString = Object.fromEntries(values.map((v) => [v.toString(), v]));
+		const valuesFromString = Object.fromEntries(values.map((v) => [v?.toString(), v]));
 		return normalizeCodecOptions(schema, {
 			decode(ctx) {
 				const raw = XML.getContent(ctx.xml);
@@ -398,16 +472,21 @@ function formatReason(errors) {
 function peekDiscriminatorValue(discriminator, propertyOptions, ctx) {
 	const errors = [];
 	for (const options of propertyOptions) try {
+		const tagname = options.propertyTagname({
+			name: discriminator,
+			options
+		});
 		const propCtx = {
 			name: discriminator,
 			options,
-			tagname: options.propertyTagname({
-				name: discriminator,
-				options
-			}),
-			xml: { elements: [] }
+			tagname,
+			xml: {
+				type: "element",
+				name: tagname,
+				elements: []
+			}
 		};
-		ctx.xml.elements.forEach((el) => {
+		ctx.xml?.elements?.forEach((el) => {
 			if (el.type !== "element") return;
 			if (options.propertyMatch(el, propCtx)) propCtx.xml.elements.push(el);
 		});
@@ -499,7 +578,30 @@ registerDefault((schema) => {
 		});
 	}
 });
+/**
+* Creates a `z.codec` that converts between an XML string and the **input type**
+* of `schema` (`z.input<S>`).
+*
+* The codec sits at the XML ↔ `z.input<S>` boundary only — it does not run Zod's
+* parse pipeline. `z.codec` transforms (e.g. string → Date) and class instantiation
+* are left to `schema.parse()` / `schema.encode()`, which you call separately if needed.
+*
+* Typical use: `xmlCodec(MyClass.dataSchema)` for standalone encode/decode without
+* going through the full `fromXML` / `toXMLString` class API.
+*/
+function xmlCodec(schema) {
+	return z.codec(z.string(), schema, {
+		decode(xml) {
+			const xmlRoot = XML.parse(xml);
+			return decode(schema, XML.elementFromRoot(xmlRoot) ?? null);
+		},
+		encode(value) {
+			const xmlEl = encode(schema, value);
+			return XML.stringify({ elements: [xmlEl] });
+		}
+	});
+}
 //#endregion
-export { XMLCodecError, decode, encode, normalizeCodecOptions, registerDefault, xmlStateSchema };
+export { XMLCodecError, decode, encode, normalizeCodecOptions, parseXML, registerDefault, stringifyXML, toXML, xmlCodec, xmlStateSchema };
 
 //# sourceMappingURL=codec.js.map

package/dist/xml/index.d.ts

@@ -1,6 +1,7 @@
 export * from './xml-js';
 export { xml } from './schema-meta';
 export type { UserCodecOptions, XMLState } from './codec';
-export { registerDefault, normalizeCodecOptions, XMLCodecError, xmlStateSchema } from './codec';
+export { xmlCodec, // if not re-exported here, xmlCodec is not exported from "./codex.js" but only from "./codec.d.ts"
+registerDefault, normalizeCodecOptions, XMLCodecError, xmlStateSchema, parseXML, toXML, stringifyXML, } from './codec';
 export { xmlModel, type XmlModelConstructor } from './model';
 //# sourceMappingURL=index.d.ts.map

package/dist/xml/model.js

@@ -9,7 +9,11 @@ function xmlModel(schema, options) {
 	return class extends model(_schema) {
 		static fromXML(input) {
 			if (typeof input === "string") input = XML.parse(input);
-			if (XML.isRoot(input)) input = XML.elementFromRoot(input);
+			if (XML.isRoot(input)) {
+				const el = XML.elementFromRoot(input);
+				if (!el) throw new TypeError("No root element");
+				input = el;
+			}
 			const rawData = decode(this.dataSchema, input);
 			return this.fromData(this.dataSchema.parse(rawData));
 		}

package/dist/xml/schema-meta.d.ts

@@ -67,6 +67,5 @@ export declare const xml: {
     attr: typeof attr;
 };
 export declare function getOwnUserOptions<S extends z.ZodType>(schema: S): UserCodecOptions<S>;
-export declare function getUserOptions<S extends z.ZodType>(schema: S): UserCodecOptions<S>;
 export {};
 //# sourceMappingURL=schema-meta.d.ts.map

package/dist/xml/schema-meta.js

@@ -1,5 +1,5 @@
 import XML from "./xml-js.js";
-import { getParentSchema, isZodType } from "../util/zod.js";
+import { isZodType } from "../util/zod.js";
 import { kebabCase } from "../util/kebab-case.js";
 import "zod";
 //#region src/xml/schema-meta.ts
@@ -45,11 +45,13 @@ function normalizePropOptions(options) {
 					data: property.value
 				});
 				if (XML.isEmpty(res)) return;
-				if (property.options.inlineProperty) ctx.result.elements.push(...res.elements.map((el) => el.type === "element" ? {
-					...el,
-					name: property.tagname
-				} : el));
-				else ctx.result.elements.push({
+				if (property.options.inlineProperty) {
+					const elements = res.elements?.map((el) => el.type === "element" ? {
+						...el,
+						name: property.tagname
+					} : el);
+					if (elements) (ctx.result.elements ??= []).push(...elements);
+				} else (ctx.result.elements ??= []).push({
 					...res,
 					name: property.tagname
 				});
@@ -79,7 +81,7 @@ function attr(optionsOrSchema, options) {
 		encodeAsProperty(ctx) {
 			const { value } = ctx.property;
 			const attrName = opts.name ?? kebabCase(ctx.property.name);
-			ctx.result.attributes[attrName] = value.toString();
+			(ctx.result.attributes ??= {})[attrName] = String(value);
 		}
 	};
 	if (isZodType(optionsOrSchema)) return setMeta(optionsOrSchema, partial);
@@ -94,27 +96,7 @@ var xml = {
 function getOwnUserOptions(schema) {
 	return schema.meta()?.[metaKey] ?? {};
 }
-var INHERITABLE_KEYS = [
-	"tagname",
-	"propertyTagname",
-	"inlineProperty",
-	"propertyMatch",
-	"decodeAsProperty",
-	"encodeAsProperty"
-];
-function getUserOptions(schema) {
-	const own = getOwnUserOptions(schema);
-	const parentSchema = getParentSchema(schema);
-	if (!parentSchema) return own;
-	const parentOptions = getUserOptions(parentSchema);
-	const inherited = {};
-	for (const key of INHERITABLE_KEYS) if (parentOptions[key] !== void 0 && own[key] === void 0) inherited[key] = parentOptions[key];
-	return {
-		...inherited,
-		...own
-	};
-}
 //#endregion
-export { getUserOptions, prop, root, xml };
+export { getOwnUserOptions, prop, root, xml };
 
 //# sourceMappingURL=schema-meta.js.map

package/dist/xml/xml-js.js

@@ -59,7 +59,7 @@ function isEmpty(xml) {
 * @throws {TypeError} When the element has multiple or non-text children.
 */
 function getContent(xml) {
-	if (!xml.elements.length) return "";
+	if (!xml.elements?.length) return "";
 	if (xml.elements.length === 1) {
 		const content = xml.elements[0];
 		if (content.type === "text") return content.text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-model",
-  "version": "2.0.0-beta.7",
+  "version": "2.0.0",
   "description": "allows transparent XML <-> Object conversion in typescript",
   "license": "MIT",
   "author": "MathisTLD",
@@ -53,4 +53,4 @@
     "vitest": "npm:@voidzero-dev/vite-plus-test@latest"
   },
   "packageManager": "npm@11.12.0"
-}
+}