xml-model 2.0.0-beta.1 → 2.0.0-beta.3

package/dist/xml/index.js

@@ -1,17 +1,4 @@
-import { XML, ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode } from "./xml-js.js";
-import { xml } from "./schema-meta.js";
-import { normalizeCodecOptions, registerDefault } from "./codec.js";
-import { xmlModel } from "./model.js";
-export {
-  XML,
-  ZXMLCommentNode,
-  ZXMLElementNode,
-  ZXMLNode,
-  ZXMLRoot,
-  ZXMLTextNode,
-  normalizeCodecOptions,
-  registerDefault,
-  xml,
-  xmlModel
-};
-//# sourceMappingURL=index.js.map
+import "./xml-js.js";
+import "./schema-meta.js";
+import "./codec.js";
+import "./model.js";

package/dist/xml/model.js

@@ -1,37 +1,33 @@
-import "zod";
-import { XML } from "./xml-js.js";
 import { model } from "../model.js";
-import { decode, XML_STATE, encode } from "./codec.js";
+import XML from "./xml-js.js";
 import { root } from "./schema-meta.js";
+import { XML_STATE, decode, encode } from "./codec.js";
+import "zod";
+//#region src/xml/model.ts
 function xmlModel(schema, options) {
-  const _schema = options ? root(schema, options) : schema;
-  return class extends model(_schema) {
-    static fromXML(input) {
-      if (typeof input === "string") {
-        input = XML.parse(input);
-      }
-      if (XML.isRoot(input)) {
-        input = XML.elementFromRoot(input);
-      }
-      const schema2 = this.dataSchema;
-      const inputData = decode(this.dataSchema, input);
-      const xmlState = inputData[XML_STATE];
-      const parsed = schema2.parse(inputData);
-      parsed[XML_STATE] = xmlState;
-      return this.fromData(parsed);
-    }
-    static toXML(instance) {
-      const data = this.toData(instance);
-      const element = encode(this.dataSchema, data);
-      return { elements: [element] };
-    }
-    static toXMLString(instance, options2 = {}) {
-      const xml = this.toXML(instance);
-      return XML.stringify(xml, options2);
-    }
-  };
+	const _schema = options ? root(schema, options) : schema;
+	return class extends model(_schema) {
+		static fromXML(input) {
+			if (typeof input === "string") input = XML.parse(input);
+			if (XML.isRoot(input)) input = XML.elementFromRoot(input);
+			const schema = this.dataSchema;
+			const inputData = decode(this.dataSchema, input);
+			const xmlState = inputData[XML_STATE];
+			const parsed = schema.parse(inputData);
+			parsed[XML_STATE] = xmlState;
+			return this.fromData(parsed);
+		}
+		static toXML(instance) {
+			const data = this.toData(instance);
+			return { elements: [encode(this.dataSchema, data)] };
+		}
+		static toXMLString(instance, options = {}) {
+			const xml = this.toXML(instance);
+			return XML.stringify(xml, options);
+		}
+	};
 }
-export {
-  xmlModel
-};
-//# sourceMappingURL=model.js.map
+//#endregion
+export { xmlModel };
+
+//# sourceMappingURL=model.js.map

package/dist/xml/schema-meta.js

@@ -1,96 +1,88 @@
+import { getParentSchema, isZodType } from "../util/zod.js";
 import "zod";
-import { isZodType, getParentSchema } from "../util/zod.js";
-const metaKey = "@@xml-model";
+//#region src/xml/schema-meta.ts
+var metaKey = "@@xml-model";
+/** Merge `partial` into the schema's existing meta (shallow spread, no overwrite). */
 function setMeta(schema, partial) {
-  const existing = schema.meta()?.[metaKey] ?? {};
-  return schema.meta({ [metaKey]: { ...existing, ...partial } });
+	const existing = schema.meta()?.[metaKey] ?? {};
+	return schema.meta({ [metaKey]: {
+		...existing,
+		...partial
+	} });
 }
 function normalizePropOptions(options) {
-  if (!options) return {};
-  const partial = {};
-  if (options.tagname !== void 0)
-    partial.propertyTagname = options.tagname;
-  if (options.inline !== void 0) partial.inlineProperty = options.inline;
-  if (options.match !== void 0)
-    partial.propertyMatch = options.match;
-  if (options.decode !== void 0) {
-    const userDecode = options.decode;
-    partial.decodeAsProperty = function(ctx) {
-      const res = userDecode(ctx);
-      if (typeof res !== "undefined") {
-        Object.assign(ctx.result, res);
-      }
-    };
-  }
-  if (options.encode !== void 0) {
-    const userEncode = options.encode;
-    partial.encodeAsProperty = function(ctx) {
-      const { property } = ctx;
-      const res = userEncode(ctx);
-      if (typeof res === "undefined") return;
-      if (property.options.inlineProperty) {
-        ctx.result.elements.push(...res.elements);
-      } else {
-        res.name = property.tagname;
-        ctx.result.elements.push(res);
-      }
-    };
-  }
-  return partial;
+	if (!options) return {};
+	const partial = {};
+	if (options.tagname !== void 0) partial.propertyTagname = options.tagname;
+	if (options.inline !== void 0) partial.inlineProperty = options.inline;
+	if (options.match !== void 0) partial.propertyMatch = options.match;
+	if (options.decode !== void 0) {
+		const userDecode = options.decode;
+		partial.decodeAsProperty = function(ctx) {
+			const res = userDecode(ctx);
+			if (typeof res !== "undefined") Object.assign(ctx.result, res);
+		};
+	}
+	if (options.encode !== void 0) {
+		const userEncode = options.encode;
+		partial.encodeAsProperty = function(ctx) {
+			const { property } = ctx;
+			const res = userEncode(ctx);
+			if (typeof res === "undefined") return;
+			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements);
+			else {
+				res.name = property.tagname;
+				ctx.result.elements.push(res);
+			}
+		};
+	}
+	return partial;
 }
 function root(optionsOrSchema, options) {
-  if (isZodType(optionsOrSchema)) {
-    return setMeta(optionsOrSchema, options ?? {});
-  } else {
-    return { [metaKey]: optionsOrSchema };
-  }
+	if (isZodType(optionsOrSchema)) return setMeta(optionsOrSchema, options ?? {});
+	else return { [metaKey]: optionsOrSchema };
 }
 function prop(optionsOrSchema, options) {
-  if (isZodType(optionsOrSchema)) {
-    return setMeta(optionsOrSchema, normalizePropOptions(options));
-  } else {
-    return { [metaKey]: normalizePropOptions(optionsOrSchema) };
-  }
+	if (isZodType(optionsOrSchema)) return setMeta(optionsOrSchema, normalizePropOptions(options));
+	else return { [metaKey]: normalizePropOptions(optionsOrSchema) };
 }
 function attr(optionsOrSchema, options) {
-  const opts = isZodType(optionsOrSchema) ? options ?? {} : optionsOrSchema ?? {};
-  const partial = {
-    decodeAsProperty(ctx) {
-      const { name, options: propOptions } = ctx.property;
-      const attrName = opts.name ?? name;
-      const attrValue = ctx.xml?.attributes[attrName];
-      ctx.result[name] = propOptions.schema.parse(attrValue);
-    },
-    encodeAsProperty(ctx) {
-      const { value, name } = ctx.property;
-      const attrName = opts.name ?? name;
-      ctx.result.attributes[attrName] = value.toString();
-    }
-  };
-  if (isZodType(optionsOrSchema)) {
-    return setMeta(optionsOrSchema, partial);
-  } else {
-    return { [metaKey]: partial };
-  }
+	const opts = isZodType(optionsOrSchema) ? options ?? {} : optionsOrSchema ?? {};
+	const partial = {
+		decodeAsProperty(ctx) {
+			const { name, options: propOptions } = ctx.property;
+			const attrName = opts.name ?? name;
+			const attrValue = ctx.xml?.attributes[attrName];
+			ctx.result[name] = propOptions.schema.parse(attrValue);
+		},
+		encodeAsProperty(ctx) {
+			const { value, name } = ctx.property;
+			const attrName = opts.name ?? name;
+			ctx.result.attributes[attrName] = value.toString();
+		}
+	};
+	if (isZodType(optionsOrSchema)) return setMeta(optionsOrSchema, partial);
+	else return { [metaKey]: partial };
 }
-const xml = { root, prop, attr };
+/** Namespace object for XML metadata helpers. */
+var xml = {
+	root,
+	prop,
+	attr
+};
 function getOwnUserOptions(schema) {
-  const meta = schema.meta();
-  return meta?.[metaKey] ?? {};
+	return schema.meta()?.[metaKey] ?? {};
 }
 function getUserOptions(schema) {
-  const own = getOwnUserOptions(schema);
-  const parentSchema = getParentSchema(schema);
-  if (!parentSchema) return own;
-  const parentOptions = getUserOptions(parentSchema);
-  return { ...parentOptions, ...own };
+	const own = getOwnUserOptions(schema);
+	const parentSchema = getParentSchema(schema);
+	if (!parentSchema) return own;
+	return {
+		...getUserOptions(parentSchema),
+		...own
+	};
 }
-export {
-  attr,
-  getOwnUserOptions,
-  getUserOptions,
-  prop,
-  root,
-  xml
-};
-//# sourceMappingURL=schema-meta.js.map
+//#endregion
+export { getUserOptions, root, xml };
+
+//# sourceMappingURL=schema-meta.js.map

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

@@ -1,4 +1,3 @@
-import { Options, Element } from 'xml-js';
 import { z } from 'zod';
 export declare const ZXMLElementNode: z.ZodObject<{
     type: z.ZodLiteral<"element">;
@@ -63,13 +62,156 @@ export type XMLRoot = {
 };
 type EmptyObj = Record<PropertyKey, never>;
 export type XMLVoid = EmptyObj;
-export type ParseOptions = Omit<Options.XML2JS, "compact">;
+type IgnoreOptions = {
+    /** Whether to ignore the XML declaration (`<?xml?>`). @default false */
+    ignoreDeclaration?: boolean;
+    /** Whether to ignore processing instructions (`<?go there?>`). @default false */
+    ignoreInstruction?: boolean;
+    /** Whether to ignore element attributes. @default false */
+    ignoreAttributes?: boolean;
+    /** Whether to ignore comments (`<!-- -->`). @default false */
+    ignoreComment?: boolean;
+    /** Whether to ignore CData sections (`<![CDATA[ ]]>`). @default false */
+    ignoreCdata?: boolean;
+    /** Whether to ignore DOCTYPE declarations. @default false */
+    ignoreDoctype?: boolean;
+    /** Whether to ignore text content inside elements. @default false */
+    ignoreText?: boolean;
+};
+type ChangingKeyNames = {
+    /** Override the key name used for the declaration property. @default "declaration" */
+    declarationKey?: string;
+    /** Override the key name used for processing instructions. @default "instruction" */
+    instructionKey?: string;
+    /** Override the key name used for element attributes. @default "attributes" */
+    attributesKey?: string;
+    /** Override the key name used for text content. @default "text" */
+    textKey?: string;
+    /** Override the key name used for CData sections. @default "cdata" */
+    cdataKey?: string;
+    /** Override the key name used for DOCTYPE. @default "doctype" */
+    doctypeKey?: string;
+    /** Override the key name used for comments. @default "comment" */
+    commentKey?: string;
+    /** Override the key name used for the parent back-reference (when `addParent` is enabled). @default "parent" */
+    parentKey?: string;
+    /** Override the key name used for node type. @default "type" */
+    typeKey?: string;
+    /** Override the key name used for element name. @default "name" */
+    nameKey?: string;
+    /** Override the key name used for child elements array. @default "elements" */
+    elementsKey?: string;
+};
+/** Options for parsing XML into a JS object tree. */
+export type ParseOptions = IgnoreOptions & ChangingKeyNames & {
+    /** Whether to trim whitespace surrounding text content. @default false */
+    trim?: boolean;
+    /**
+     * Whether to replace `&`, `<`, `>` with their XML entities in text nodes.
+     * @deprecated See https://github.com/nashwaan/xml-js/issues/26
+     * @default false
+     */
+    sanitize?: boolean;
+    /** Whether to coerce numeric and boolean text values to their native JS types. @default false */
+    nativeType?: boolean;
+    /**
+     * Whether to add a `parent` property on each element pointing back to its parent.
+     * Useful for upward traversal but creates circular references.
+     * @default false
+     */
+    addParent?: boolean;
+    /**
+     * Whether to always wrap sub-elements in an array, even when there is only one.
+     * Pass an array of element names to restrict this behaviour to those names only.
+     * Only applicable in compact mode.
+     * @default false
+     */
+    alwaysArray?: boolean | Array<string>;
+    /**
+     * Whether to always emit an `elements` array even on empty elements.
+     * `<a></a>` becomes `{ elements: [{ type: "element", name: "a", elements: [] }] }`
+     * instead of `{ elements: [{ type: "element", name: "a" }] }`.
+     * Only applicable in non-compact mode.
+     * @default false
+     */
+    alwaysChildren?: boolean;
+    /**
+     * Whether to parse the contents of processing instructions as attributes.
+     * `<?go to="there"?>` becomes `{ go: { attributes: { to: "there" } } }`
+     * instead of `{ go: 'to="there"' }`.
+     * @default false
+     */
+    instructionHasAttributes?: boolean;
+    /** Whether to preserve whitespace-only text nodes that appear between elements. @default false */
+    captureSpacesBetweenElements?: boolean;
+    /** Custom processing hook called for each DOCTYPE value. */
+    doctypeFn?: (value: string, parentElement: object) => void;
+    /** Custom processing hook called for each processing instruction value. */
+    instructionFn?: (instructionValue: string, instructionName: string, parentElement: string) => void;
+    /** Custom processing hook called for each CData section. */
+    cdataFn?: (value: string, parentElement: object) => void;
+    /** Custom processing hook called for each comment. */
+    commentFn?: (value: string, parentElement: object) => void;
+    /** Custom processing hook called for each text node. */
+    textFn?: (value: string, parentElement: object) => void;
+    /** Custom processing hook called for each processing instruction name. */
+    instructionNameFn?: (instructionName: string, instructionValue: string, parentElement: string) => void;
+    /** Custom processing hook called for each element name. */
+    elementNameFn?: (value: string, parentElement: object) => void;
+    /** Custom processing hook called for each attribute name. */
+    attributeNameFn?: (attributeName: string, attributeValue: string, parentElement: string) => void;
+    /** Custom processing hook called for each attribute value. */
+    attributeValueFn?: (attributeValue: string, attributeName: string, parentElement: string) => void;
+    /** Custom processing hook called for the whole attributes object of an element. */
+    attributesFn?: (value: string, parentElement: string) => void;
+};
 declare function parse(xml: string, options?: ParseOptions): XMLRoot;
-export type StringifyOptions = Options.JS2XML;
+/** Options for serializing a JS object tree back to XML. */
+export type StringifyOptions = IgnoreOptions & ChangingKeyNames & {
+    /** Number of spaces (or a string like `'\t'`) to use for indenting XML output. @default 0 */
+    spaces?: number | string;
+    /** Whether to indent text nodes onto their own line when `spaces` is set. @default false */
+    indentText?: boolean;
+    /** Whether to write CData sections on a new indented line. @default false */
+    indentCdata?: boolean;
+    /** Whether to print each attribute on its own indented line (when `spaces` is set). @default false */
+    indentAttributes?: boolean;
+    /** Whether to indent processing instructions onto their own line. @default false */
+    indentInstruction?: boolean;
+    /** Whether to emit empty elements as full tag pairs (`<a></a>`) instead of self-closing (`<a/>`). @default false */
+    fullTagEmptyElement?: boolean;
+    /** Whether to omit quotes around attribute values that are native JS types (numbers, booleans). @default false */
+    noQuotesForNativeAttributes?: boolean;
+    /** Custom processing hook called for each DOCTYPE value. */
+    doctypeFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for each processing instruction value. */
+    instructionFn?: (instructionValue: string, instructionName: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for each CData section. */
+    cdataFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for each comment. */
+    commentFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for each text node. */
+    textFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for each processing instruction name. */
+    instructionNameFn?: (instructionName: string, instructionValue: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for each element name. */
+    elementNameFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for each attribute name. */
+    attributeNameFn?: (attributeName: string, attributeValue: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for each attribute value. */
+    attributeValueFn?: (attributeValue: string, attributeName: string, currentElementName: string, currentElementObj: object) => void;
+    /** Custom processing hook called for the whole attributes object of an element. */
+    attributesFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    /**
+     * Per-element override for `fullTagEmptyElement`.
+     * Return `true` to emit a full tag pair for the given element, `false` for self-closing.
+     */
+    fullTagEmptyElementFn?: (currentElementName: string, currentElementObj: object) => void;
+};
 declare function stringify(xml: XMLRoot, options?: StringifyOptions): string;
-declare function isRoot(xml: Element): xml is XMLRoot;
+declare function isRoot(xml: object): xml is XMLRoot;
 declare function elementFromRoot(root: XMLRoot): XMLElementNode | undefined;
-declare function isEmpty(xml: Element): xml is XMLVoid;
+declare function isEmpty(xml: object): xml is XMLVoid;
 /**
  * Extracts the text content from an element that has a single text child node.
  *

package/dist/xml/xml-js.js

@@ -1,93 +1,122 @@
-import { xml2js, js2xml } from "xml-js";
+import { require_lib } from "../node_modules/xml-js/lib/index.js";
 import { z } from "zod";
-const ZXMLElementNode = z.object({
-  type: z.literal("element"),
-  // TODO: test if required
-  name: z.string(),
-  attributes: z.record(z.string(), z.string()).optional(),
-  get elements() {
-    return z.array(ZXMLNode).optional();
-  }
-  // TODO: other fields
+//#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();
+	}
 });
-const ZXMLCommentNode = z.object({ type: z.literal("comment"), comment: z.string() });
-const ZXMLTextNode = z.object({ type: z.literal("text"), text: z.string() });
-const ZXMLNode = z.discriminatedUnion("type", [ZXMLElementNode, ZXMLCommentNode, ZXMLTextNode]);
-const ZXMLRoot = z.object({ elements: z.array(ZXMLNode) });
+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 = xml2js(xml, strippedOptions);
-  if ("elements" in res) return res;
-  throw new Error("Got empty XML");
+	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 js2xml(xml, options);
+	return (0, import_lib.js2xml)(xml, options);
 }
 function isRoot(xml) {
-  const keys = Object.keys(xml);
-  return keys.length === 1 && Array.isArray(xml.elements);
+	return Object.keys(xml).length === 1 && "elements" in xml && Array.isArray(xml.elements);
 }
 function elementFromRoot(root) {
-  return root.elements.find((el) => el.type === "element");
+	return root.elements.find((el) => el.type === "element");
 }
 function isEmpty(xml) {
-  return Object.keys(xml).length === 0;
+	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)}`);
+	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;
+	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);
+	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;
+	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];
+	if (!xml.attributes) return;
+	delete xml.attributes[attribute];
 }
-const XML = {
-  parse,
-  stringify,
-  isRoot,
-  elementFromRoot,
-  isEmpty,
-  fromContent,
-  getContent,
-  addElement,
-  setAttribute,
-  deleteAttribute
-};
-export {
-  XML,
-  ZXMLCommentNode,
-  ZXMLElementNode,
-  ZXMLNode,
-  ZXMLRoot,
-  ZXMLTextNode,
-  XML as default
+/** Namespace object bundling all XML utility functions. */
+var XML = {
+	parse,
+	stringify,
+	isRoot,
+	elementFromRoot,
+	isEmpty,
+	fromContent,
+	getContent,
+	addElement,
+	setAttribute,
+	deleteAttribute
 };
-//# sourceMappingURL=xml-js.js.map
+//#endregion
+export { ZXMLCommentNode, ZXMLElementNode, ZXMLNode, ZXMLRoot, ZXMLTextNode, XML as default };
+
+//# sourceMappingURL=xml-js.js.map