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

package/dist/xml/codec.js

@@ -1,385 +1,339 @@
-import { z } from "zod";
-import { XML } from "./xml-js.js";
+import XML from "./xml-js.js";
+import { isZodType } from "../util/zod.js";
 import { getUserOptions } from "./schema-meta.js";
 import { kebabCase } from "../util/kebab-case.js";
-import { isZodType } from "../util/zod.js";
+import { z } from "zod";
+//#region src/xml/codec.ts
 function assertSingleElement(xml) {
-  if (xml.length !== 1) throw new Error(`Expected single XML element, got ${xml.length}`);
-}
-function assertSingleRoot(xml) {
-  assertSingleElement(xml);
-  if (!Array.isArray(xml[0].elements)) throw new Error(`Expected element with children list`);
+	if (xml.length !== 1) throw new Error(`Expected single XML element, got ${xml.length}`);
 }
 function normalizeCodecOptions(schema, options = {}) {
-  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}`
-        );
-      }
-    }
-    return _defaultOptions;
-  };
-  const userTagname = options.tagname;
-  const tagname = typeof userTagname === "string" ? () => userTagname : typeof userTagname === "function" ? userTagname : () => {
-    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 userMatch = options.propertyMatch;
-  const propertyMatch = userMatch instanceof RegExp ? (el) => userMatch.test(el.name) : typeof userMatch === "function" ? userMatch : (el, ctx) => el.name === ctx.tagname;
-  const decode2 = options.decode ?? defaultOptions().decode;
-  const encode2 = options.encode ?? defaultOptions().encode;
-  const result = {
-    schema,
-    tagname,
-    decode: decode2,
-    encode: encode2,
-    propertyTagname,
-    inlineProperty,
-    propertyMatch,
-    decodeAsProperty: options.decodeAsProperty ?? function(ctx) {
-      const res = result.decode({ options: result, xml: ctx.property.xml });
-      ctx.result[ctx.property.name] = res;
-    },
-    encodeAsProperty: options.encodeAsProperty ?? function(ctx) {
-      const { property } = ctx;
-      const optsWithTagname = { ...result, tagname: () => property.tagname };
-      const res = result.encode({
-        options: optsWithTagname,
-        // FIXME: we should not rely on type casting
-        data: property.value
-      });
-      if (XML.isEmpty(res)) {
-        return;
-      }
-      if (property.options.inlineProperty) {
-        ctx.result.elements.push(...res.elements);
-      } else {
-        ctx.result.elements.push(res);
-      }
-    }
-  };
-  return result;
+	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}`);
+		}
+		return _defaultOptions;
+	};
+	const userTagname = options.tagname;
+	const tagname = typeof userTagname === "string" ? () => userTagname : typeof userTagname === "function" ? userTagname : () => {
+		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 userMatch = options.propertyMatch;
+	const propertyMatch = userMatch instanceof RegExp ? (el) => userMatch.test(el.name) : typeof userMatch === "function" ? userMatch : (el, ctx) => el.name === ctx.tagname;
+	const result = {
+		schema,
+		tagname,
+		decode: options.decode ?? defaultOptions().decode,
+		encode: options.encode ?? defaultOptions().encode,
+		propertyTagname,
+		inlineProperty,
+		propertyMatch,
+		decodeAsProperty: options.decodeAsProperty ?? function(ctx) {
+			const res = result.decode({
+				options: result,
+				xml: ctx.property.xml
+			});
+			ctx.result[ctx.property.name] = res;
+		},
+		encodeAsProperty: options.encodeAsProperty ?? function(ctx) {
+			const { property } = ctx;
+			const optsWithTagname = {
+				...result,
+				tagname: () => property.tagname
+			};
+			const res = result.encode({
+				options: optsWithTagname,
+				data: property.value
+			});
+			if (XML.isEmpty(res)) return;
+			if (property.options.inlineProperty) ctx.result.elements.push(...res.elements);
+			else ctx.result.elements.push(res);
+		}
+	};
+	return result;
 }
-const cache = /* @__PURE__ */ new Map();
+var cache = /* @__PURE__ */ new Map();
 function resolveCodecOptions(schema) {
-  const cached = cache.get(schema);
-  if (cached) return cached;
-  const userOpts = getUserOptions(schema);
-  const options = normalizeCodecOptions(schema, userOpts);
-  cache.set(schema, options);
-  return options;
+	const cached = cache.get(schema);
+	if (cached) return cached;
+	const options = normalizeCodecOptions(schema, getUserOptions(schema));
+	cache.set(schema, options);
+	return options;
 }
-const XML_STATE = /* @__PURE__ */ Symbol("xml-model.state");
+/**
+* Non-enumerable Symbol attached to decoded data objects (and forwarded to model instances).
+* Groups all XML codec round-trip state under a single key.
+*/
+var XML_STATE = Symbol("xml-model.state");
 function resolvePropertiesCodecOptions(schema) {
-  const shape = schema.def.shape;
-  const options = {};
-  for (const [prop, fieldSchema] of Object.entries(shape)) {
-    options[prop] = resolveCodecOptions(fieldSchema);
-  }
-  return options;
+	const shape = schema.def.shape;
+	const options = {};
+	for (const [prop, fieldSchema] of Object.entries(shape)) options[prop] = resolveCodecOptions(fieldSchema);
+	return options;
 }
 function decode(schema, xml) {
-  const options = resolveCodecOptions(schema);
-  return options.decode({ options, xml });
+	const options = resolveCodecOptions(schema);
+	return options.decode({
+		options,
+		xml
+	});
 }
 function encode(schema, data) {
-  const options = resolveCodecOptions(schema);
-  return options.encode({ options, data });
+	const options = resolveCodecOptions(schema);
+	return options.encode({
+		options,
+		data
+	});
 }
 function registerDefault(resolve) {
-  defaults.push(resolve);
+	defaults.push(resolve);
 }
-const defaults = [];
+var defaults = [];
 function resolveDefault(schema) {
-  for (let index = defaults.length - 1; index >= 0; index--) {
-    const resolver = defaults[index];
-    const res = resolver(schema);
-    if (res) return res;
-  }
+	for (let index = defaults.length - 1; index >= 0; index--) {
+		const resolver = defaults[index];
+		const res = resolver(schema);
+		if (res) return res;
+	}
 }
 registerDefault((schema) => {
-  if (schema instanceof z.ZodArray) {
-    const elOptions = resolveCodecOptions(
-      // FIXME: why is this cast needed ?
-      schema.def.element
-    );
-    return normalizeCodecOptions(schema, {
-      decode(ctx) {
-        const { xml } = ctx;
-        if (!xml) return [];
-        return xml.elements.filter((el) => el.type === "element").map((el) => elOptions.decode({ options: elOptions, xml: el }));
-      },
-      // FIXME: when encode method was missing typescript didn't complain
-      encode(ctx) {
-        const values = ctx.data;
-        if (!Array.isArray(values)) throw new Error("expected array");
-        return {
-          type: "element",
-          name: ctx.options.tagname(ctx),
-          attributes: {},
-          elements: values.map((v) => elOptions.encode({ options: elOptions, data: v }))
-        };
-      }
-    });
-  }
-  if (schema instanceof z.ZodOptional) {
-    const inner = schema.def.innerType;
-    if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
-    const innerOptions = resolveCodecOptions(inner);
-    return normalizeCodecOptions(schema, {
-      decode(ctx) {
-        if (!ctx.xml) return void 0;
-        else return innerOptions.decode(ctx);
-      },
-      encode(ctx) {
-        if (typeof ctx.data === "undefined")
-          return {};
-        else return innerOptions.encode(ctx);
-      }
-    });
-  }
-  if (schema instanceof z.ZodDefault) {
-    const { innerType: inner, defaultValue } = schema.def;
-    if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
-    const innerOptions = resolveCodecOptions(inner);
-    const getDefault = typeof schema.def.defaultValue === "function" ? schema.def.defaultValue : () => defaultValue;
-    return normalizeCodecOptions(schema, {
-      decode(ctx) {
-        if (!ctx.xml) return getDefault();
-        else return innerOptions.decode(ctx);
-      },
-      encode(ctx) {
-        return innerOptions.encode(ctx);
-      }
-    });
-  }
-  if (schema instanceof z.ZodLazy) {
-    const inner = schema.def.getter();
-    if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
-    return resolveDefault(inner);
-  }
-  if (schema instanceof z.ZodCodec) {
-    const inSchema = schema.def.in;
-    const outSchema = schema.def.out;
-    if (!isZodType(inSchema))
-      throw new Error(`Expected schema.def.in to be a ZodType, got ${inSchema}`);
-    if (!isZodType(outSchema))
-      throw new Error(`Expected schema.def.out to be a ZodType, got ${outSchema}`);
-    const inputCodecOptions = resolveCodecOptions(inSchema);
-    return normalizeCodecOptions(schema, {
-      decode({ xml }) {
-        const input = inputCodecOptions.decode({ options: inputCodecOptions, xml });
-        return schema.def.transform(input, { value: input, issues: [] });
-      },
-      encode(ctx) {
-        const data = outSchema.encode(ctx.data);
-        const innerOpts = ctx.options.tagname !== inputCodecOptions.tagname ? { ...inputCodecOptions, tagname: ctx.options.tagname } : inputCodecOptions;
-        return innerOpts.encode({ options: innerOpts, data });
-      }
-    });
-  }
-  if (schema instanceof z.ZodLiteral) {
-    const values = schema.def.values;
-    const valuesFromString = Object.fromEntries(values.map((v) => [v.toString(), v]));
-    return normalizeCodecOptions(schema, {
-      decode(ctx) {
-        const raw = XML.getContent(ctx.xml);
-        if (!(raw in valuesFromString))
-          throw new Error(`Could not retrieve literal value from string "${raw}"`);
-        return valuesFromString[raw];
-      },
-      encode(ctx) {
-        return XML.fromContent(String(ctx.data), ctx.options.tagname(ctx));
-      }
-    });
-  }
-  if (schema instanceof z.ZodString) {
-    return normalizeCodecOptions(schema, {
-      decode(ctx) {
-        return XML.getContent(ctx.xml);
-      },
-      encode(ctx) {
-        return XML.fromContent(ctx.data, ctx.options.tagname(ctx));
-      }
-    });
-  }
-  if (schema instanceof z.ZodNumber) {
-    return normalizeCodecOptions(schema, {
-      decode(ctx) {
-        return Number(XML.getContent(ctx.xml));
-      },
-      encode(ctx) {
-        return XML.fromContent(ctx.data.toString(), ctx.options.tagname(ctx));
-      }
-    });
-  }
-  if (schema instanceof z.ZodBoolean) {
-    return normalizeCodecOptions(schema, {
-      decode(ctx) {
-        return XML.getContent(ctx.xml) === "true";
-      },
-      encode(ctx) {
-        return XML.fromContent(ctx.data.toString(), ctx.options.tagname(ctx));
-      }
-    });
-  }
+	if (schema instanceof z.ZodArray) {
+		const elOptions = resolveCodecOptions(schema.def.element);
+		return normalizeCodecOptions(schema, {
+			decode(ctx) {
+				const { xml } = ctx;
+				if (!xml) return [];
+				return xml.elements.filter((el) => el.type === "element").map((el) => elOptions.decode({
+					options: elOptions,
+					xml: el
+				}));
+			},
+			encode(ctx) {
+				const values = ctx.data;
+				if (!Array.isArray(values)) throw new Error("expected array");
+				return {
+					type: "element",
+					name: ctx.options.tagname(ctx),
+					attributes: {},
+					elements: values.map((v) => elOptions.encode({
+						options: elOptions,
+						data: v
+					}))
+				};
+			}
+		});
+	}
+	if (schema instanceof z.ZodOptional) {
+		const inner = schema.def.innerType;
+		if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
+		const innerOptions = resolveCodecOptions(inner);
+		return normalizeCodecOptions(schema, {
+			decode(ctx) {
+				if (!ctx.xml) return void 0;
+				else return innerOptions.decode(ctx);
+			},
+			encode(ctx) {
+				if (typeof ctx.data === "undefined") return {};
+				else return innerOptions.encode(ctx);
+			}
+		});
+	}
+	if (schema instanceof z.ZodDefault) {
+		const { innerType: inner, defaultValue } = schema.def;
+		if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
+		const innerOptions = resolveCodecOptions(inner);
+		const getDefault = typeof schema.def.defaultValue === "function" ? schema.def.defaultValue : () => defaultValue;
+		return normalizeCodecOptions(schema, {
+			decode(ctx) {
+				if (!ctx.xml) return getDefault();
+				else return innerOptions.decode(ctx);
+			},
+			encode(ctx) {
+				return innerOptions.encode(ctx);
+			}
+		});
+	}
+	if (schema instanceof z.ZodLazy) {
+		const inner = schema.def.getter();
+		if (!isZodType(inner)) throw new Error(`Expected a ZodType, got ${inner}`);
+		return resolveDefault(inner);
+	}
+	if (schema instanceof z.ZodCodec) {
+		const inSchema = schema.def.in;
+		const outSchema = schema.def.out;
+		if (!isZodType(inSchema)) throw new Error(`Expected schema.def.in to be a ZodType, got ${inSchema}`);
+		if (!isZodType(outSchema)) throw new Error(`Expected schema.def.out to be a ZodType, got ${outSchema}`);
+		const inputCodecOptions = resolveCodecOptions(inSchema);
+		return normalizeCodecOptions(schema, {
+			decode({ xml }) {
+				const input = inputCodecOptions.decode({
+					options: inputCodecOptions,
+					xml
+				});
+				return schema.def.transform(input, {
+					value: input,
+					issues: []
+				});
+			},
+			encode(ctx) {
+				const data = outSchema.encode(ctx.data);
+				const innerOpts = ctx.options.tagname !== inputCodecOptions.tagname ? {
+					...inputCodecOptions,
+					tagname: ctx.options.tagname
+				} : inputCodecOptions;
+				return innerOpts.encode({
+					options: innerOpts,
+					data
+				});
+			}
+		});
+	}
+	if (schema instanceof z.ZodLiteral) {
+		const values = schema.def.values;
+		const valuesFromString = Object.fromEntries(values.map((v) => [v.toString(), v]));
+		return normalizeCodecOptions(schema, {
+			decode(ctx) {
+				const raw = XML.getContent(ctx.xml);
+				if (!(raw in valuesFromString)) throw new Error(`Could not retrieve literal value from string "${raw}"`);
+				return valuesFromString[raw];
+			},
+			encode(ctx) {
+				return XML.fromContent(String(ctx.data), ctx.options.tagname(ctx));
+			}
+		});
+	}
+	if (schema instanceof z.ZodString) return normalizeCodecOptions(schema, {
+		decode(ctx) {
+			return XML.getContent(ctx.xml);
+		},
+		encode(ctx) {
+			return XML.fromContent(ctx.data, ctx.options.tagname(ctx));
+		}
+	});
+	if (schema instanceof z.ZodNumber) return normalizeCodecOptions(schema, {
+		decode(ctx) {
+			return Number(XML.getContent(ctx.xml));
+		},
+		encode(ctx) {
+			return XML.fromContent(ctx.data.toString(), ctx.options.tagname(ctx));
+		}
+	});
+	if (schema instanceof z.ZodBoolean) return normalizeCodecOptions(schema, {
+		decode(ctx) {
+			return XML.getContent(ctx.xml) === "true";
+		},
+		encode(ctx) {
+			return XML.fromContent(ctx.data.toString(), ctx.options.tagname(ctx));
+		}
+	});
 });
 registerDefault((schema) => {
-  if (schema instanceof z.ZodObject) {
-    const options = resolvePropertiesCodecOptions(schema);
-    return normalizeCodecOptions(schema, {
-      decode(ctx) {
-        const sequence = [];
-        const propContexts = Object.fromEntries(
-          Object.entries(options).map(([name, propOpts]) => {
-            const tagname = propOpts.propertyTagname({ name, options: propOpts });
-            return [
-              name,
-              {
-                name,
-                options: propOpts,
-                tagname,
-                // starts as a collection container; replaced with actual element or null after matching
-                xml: { elements: [] }
-              }
-            ];
-          })
-        );
-        const seenProperties = /* @__PURE__ */ new Set();
-        for (const el of ctx.xml.elements) {
-          if (el.type !== "element") continue;
-          const matches = [];
-          for (const prop in options) {
-            const propCtx = propContexts[prop];
-            if (options[prop].propertyMatch(el, propCtx)) {
-              matches.push(prop);
-              propCtx.xml.elements.push(el);
-            }
-          }
-          if (!matches.length) {
-            sequence.push(el);
-            continue;
-          } else if (matches.length === 1) {
-            const propName = matches[0];
-            if (seenProperties.has(propName)) {
-              const prop = options[propName];
-              if (!prop.inlineProperty)
-                throw new Error(
-                  "Matching multiple elements for a single property is only supported when `inlineProperty` is true"
-                );
-            } else {
-              sequence.push(propName);
-              seenProperties.add(propName);
-            }
-          } else {
-            throw new Error(
-              `Same element was matched by multiple properties: ${matches.join(", ")}`
-            );
-          }
-        }
-        for (const propName in options) {
-          if (!seenProperties.has(propName)) sequence.push(propName);
-        }
-        const result = {};
-        for (const prop in options) {
-          const o = options[prop];
-          const propCtx = propContexts[prop];
-          if (!o.inlineProperty) {
-            const matches = propCtx.xml.elements;
-            if (matches.length === 0) propCtx.xml = null;
-            else {
-              assertSingleElement(matches);
-              propCtx.xml = matches[0];
-            }
-          }
-          o.decodeAsProperty({
-            // @ts-ignore
-            options: ctx.options,
-            xml: ctx.xml,
-            // @ts-ignore
-            property: propCtx,
-            result
-          });
-        }
-        Object.defineProperty(result, XML_STATE, {
-          value: { fieldOrder: sequence },
-          enumerable: false,
-          writable: true,
-          configurable: true
-        });
-        return result;
-      },
-      encode(ctx) {
-        const { data } = ctx;
-        const result = {
-          type: "element",
-          name: ctx.options.tagname(ctx),
-          // already create the attributes record so `attr(...)` encoding handlers don't have to
-          attributes: {},
-          elements: []
-        };
-        const sequence = data[XML_STATE]?.fieldOrder ?? Object.keys(options);
-        for (const item of sequence) {
-          if (typeof item === "string") {
-            const o = options[item];
-            if (!o) {
-              throw new Error(`Failed to resolve property options for sequence item ${item}`);
-            }
-            o.encodeAsProperty({
-              // FIXME should not need type casts
-              options: ctx.options,
-              data,
-              property: {
-                name: item,
-                options: o,
-                tagname: o.propertyTagname({ name: item, options: o }),
-                value: data[item]
-              },
-              result
-            });
-          } else {
-            result.elements.push(item);
-          }
-        }
-        return result;
-      }
-    });
-  }
+	if (schema instanceof z.ZodObject) {
+		const options = resolvePropertiesCodecOptions(schema);
+		return normalizeCodecOptions(schema, {
+			decode(ctx) {
+				const sequence = [];
+				const propContexts = Object.fromEntries(Object.entries(options).map(([name, propOpts]) => {
+					return [name, {
+						name,
+						options: propOpts,
+						tagname: propOpts.propertyTagname({
+							name,
+							options: propOpts
+						}),
+						xml: { elements: [] }
+					}];
+				}));
+				const seenProperties = /* @__PURE__ */ new Set();
+				for (const el of ctx.xml.elements) {
+					if (el.type !== "element") continue;
+					const matches = [];
+					for (const prop in options) {
+						const propCtx = propContexts[prop];
+						if (options[prop].propertyMatch(el, propCtx)) {
+							matches.push(prop);
+							propCtx.xml.elements.push(el);
+						}
+					}
+					if (!matches.length) {
+						sequence.push(el);
+						continue;
+					} else if (matches.length === 1) {
+						const propName = matches[0];
+						if (seenProperties.has(propName)) {
+							if (!options[propName].inlineProperty) throw new Error("Matching multiple elements for a single property is only supported when `inlineProperty` is true");
+						} else {
+							sequence.push(propName);
+							seenProperties.add(propName);
+						}
+					} else throw new Error(`Same element was matched by multiple properties: ${matches.join(", ")}`);
+				}
+				for (const propName in options) if (!seenProperties.has(propName)) sequence.push(propName);
+				const result = {};
+				for (const prop in options) {
+					const o = options[prop];
+					const propCtx = propContexts[prop];
+					if (!o.inlineProperty) {
+						const matches = propCtx.xml.elements;
+						if (matches.length === 0) propCtx.xml = null;
+						else {
+							assertSingleElement(matches);
+							propCtx.xml = matches[0];
+						}
+					}
+					o.decodeAsProperty({
+						options: ctx.options,
+						xml: ctx.xml,
+						property: propCtx,
+						result
+					});
+				}
+				Object.defineProperty(result, XML_STATE, {
+					value: { fieldOrder: sequence },
+					enumerable: false,
+					writable: true,
+					configurable: true
+				});
+				return result;
+			},
+			encode(ctx) {
+				const { data } = ctx;
+				const result = {
+					type: "element",
+					name: ctx.options.tagname(ctx),
+					attributes: {},
+					elements: []
+				};
+				const sequence = data[XML_STATE]?.fieldOrder ?? Object.keys(options);
+				for (const item of sequence) if (typeof item === "string") {
+					const o = options[item];
+					if (!o) throw new Error(`Failed to resolve property options for sequence item ${item}`);
+					o.encodeAsProperty({
+						options: ctx.options,
+						data,
+						property: {
+							name: item,
+							options: o,
+							tagname: o.propertyTagname({
+								name: item,
+								options: o
+							}),
+							value: data[item]
+						},
+						result
+					});
+				} else result.elements.push(item);
+				return result;
+			}
+		});
+	}
 });
-function xmlCodec(schema) {
-  const codec = z.codec(z.string(), schema, {
-    decode(xml) {
-      const xmlRoot = XML.parse(xml);
-      const xmlEl = XML.elementFromRoot(xmlRoot);
-      const input = decode(schema, xmlEl);
-      return input;
-    },
-    encode(value) {
-      const xmlEl = encode(
-        schema,
-        // FIXME: value is expected to be of type input<S>
-        // so `schema` should be able or re-encoding its output
-        value
-      );
-      return XML.stringify({ elements: [xmlEl] });
-    }
-  });
-  return codec;
-}
-export {
-  XML_STATE,
-  assertSingleElement,
-  assertSingleRoot,
-  decode,
-  encode,
-  normalizeCodecOptions,
-  registerDefault,
-  xmlCodec
-};
-//# sourceMappingURL=codec.js.map
+//#endregion
+export { XML_STATE, decode, encode, normalizeCodecOptions, registerDefault };
+
+//# sourceMappingURL=codec.js.map