@onerjs/serializers 8.41.6 → 8.41.8

package/3MF/core/xml/xml.interfaces.js

@@ -0,0 +1,110 @@
+/**
+ * @param x
+ * @returns
+ */
+export function IsQualifiedName(x) {
+    return typeof x?.name === "string";
+}
+const XML_CLASS_META = Symbol("__xml:meta$__");
+const XML_CLASS_NAME = Symbol("__xml:name$__");
+function AddXmlMeta(target, meta) {
+    const ctor = target.constructor;
+    (ctor[XML_CLASS_META] ?? (ctor[XML_CLASS_META] = [])).push(meta);
+}
+/**
+ * @param name
+ * @returns
+ */
+export function XmlName(name) {
+    return (ctor) => {
+        ctor[XML_CLASS_NAME] = name;
+    };
+}
+/**
+ * tell the serializer to ignore the property
+ * @returns
+ */
+export function XmlIgnore() {
+    return (target, prop) => AddXmlMeta(target, { kind: "none", prop, ignore: true });
+}
+/**
+ * tell the serializer to serialize the property as attribute
+ * @returns
+ */
+export function XmlAttr(opts) {
+    return (target, prop) => AddXmlMeta(target, { kind: "attr", prop, ...opts });
+}
+/**
+ * tell the serializer to serialize the property as element - this is the default behavior but shoud be
+ * specified when wanted to update the default name of the classe or if the class is not decorated (without \@XmlName)
+ * @returns
+ */
+export function XmlElem(opts) {
+    return (target, prop) => AddXmlMeta(target, { kind: "elem", prop, ...opts });
+}
+/**
+ *
+ * @param obj
+ * @returns
+ */
+export function GetXmlFieldMeta(obj) {
+    return (obj?.constructor?.[XML_CLASS_META] ?? []);
+}
+/**
+ *
+ * @param obj
+ * @returns
+ */
+export function GetXmlName(obj) {
+    const n = obj?.constructor?.[XML_CLASS_NAME];
+    return n ? n : undefined;
+}
+/**
+ *
+ * @param s
+ * @returns
+ */
+function LooksLikeXmlNcName(s) {
+    // Approximation ASCII de NCName: pas de ":" et demarre par lettre ou underscore
+    // Puis lettres/chiffres/underscore/point/tiret.
+    return /^[A-Za-z_][A-Za-z0-9._-]*$/.test(s);
+}
+/**
+ *
+ * @param qn
+ * @returns
+ */
+export function XmlNameToParts(qn) {
+    if (IsQualifiedName(qn)) {
+        return qn;
+    }
+    const s = (qn ?? "").trim();
+    if (!s) {
+        return { name: "" };
+    }
+    const i = s.indexOf(":");
+    if (i === -1) {
+        return { name: s };
+    }
+    // Un QName XML ne doit contenir qu un seul ":".
+    // Si il y en a plusieurs, on considere que ce n est pas un QName.
+    if (s.indexOf(":", i + 1) !== -1) {
+        return { name: s };
+    }
+    const prefix = s.slice(0, i);
+    const local = s.slice(i + 1);
+    if (LooksLikeXmlNcName(prefix) && LooksLikeXmlNcName(local)) {
+        return { ns: prefix, name: local };
+    }
+    return { name: s };
+}
+/**
+ *
+ * @param name
+ * @param prefix
+ * @returns
+ */
+export function ToQualifiedString(name, prefix) {
+    return prefix ? `${prefix}:${name}` : name;
+}
+//# sourceMappingURL=xml.interfaces.js.map

package/3MF/core/xml/xml.interfaces.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.interfaces.js","sourceRoot":"","sources":["../../../../../../dev/serializers/src/3MF/core/xml/xml.interfaces.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IXmlSerializerFormatOptions } from \"./xml.serializer.format\";\r\n\r\n/** */\r\nexport interface IQualifiedName {\r\n    /** */\r\n    ns?: string;\r\n    /** */\r\n    name: string;\r\n}\r\n\r\n/** */\r\nexport interface IXmlBuilder {\r\n    dec(version: string, encoding?: string, standalone?: boolean): IXmlBuilder;\r\n    att(ns: string | null, n: string, v: string): IXmlBuilder;\r\n    ele(ns: string | null, n: string): IXmlBuilder;\r\n    text(txt: string): IXmlBuilder;\r\n    end(): IXmlBuilder;\r\n}\r\n\r\n/**\r\n * @param x\r\n * @returns\r\n */\r\nexport function IsQualifiedName(x: unknown): x is { name: string } {\r\n    return typeof (x as any)?.name === \"string\";\r\n}\r\n\r\nexport type XmlName = string | IQualifiedName;\r\n\r\ntype FieldKind = \"attr\" | \"elem\" | \"none\";\r\n\r\n/**\r\n *\r\n */\r\nexport interface IFormatter<T = any> {\r\n    toString(value: T): string;\r\n}\r\n\r\nexport type FormatterCtor<T> = new (args: IXmlSerializerFormatOptions) => IFormatter<T>;\r\n\r\ntype FieldMeta = {\r\n    kind: FieldKind;\r\n    prop: string;\r\n    name?: XmlName;\r\n    ignore?: boolean;\r\n    formatter?: FormatterCtor<any>;\r\n};\r\n\r\nconst XML_CLASS_META = Symbol(\"__xml:meta$__\");\r\nconst XML_CLASS_NAME = Symbol(\"__xml:name$__\");\r\n\r\nfunction AddXmlMeta(target: any, meta: FieldMeta) {\r\n    const ctor = target.constructor;\r\n    (ctor[XML_CLASS_META] ??= []).push(meta);\r\n}\r\n\r\n/**\r\n * @param name\r\n * @returns\r\n */\r\nexport function XmlName(name: XmlName) {\r\n    return (ctor: Function) => {\r\n        (ctor as any)[XML_CLASS_NAME] = name;\r\n    };\r\n}\r\n\r\n/**\r\n * tell the serializer to ignore the property\r\n * @returns\r\n */\r\nexport function XmlIgnore() {\r\n    return (target: any, prop: string) => AddXmlMeta(target, { kind: \"none\", prop, ignore: true });\r\n}\r\n\r\n/**\r\n * tell the serializer to serialize the property as attribute\r\n * @returns\r\n */\r\nexport function XmlAttr(opts?: { name: XmlName; formatter?: FormatterCtor<any> }) {\r\n    return (target: any, prop: string) => AddXmlMeta(target, { kind: \"attr\", prop, ...opts });\r\n}\r\n\r\n/**\r\n * tell the serializer to serialize the property as element - this is the default behavior but shoud be\r\n * specified when wanted to update the default name of the classe or if the class is not decorated (without \\@XmlName)\r\n * @returns\r\n */\r\nexport function XmlElem(opts?: { name: XmlName }) {\r\n    return (target: any, prop: string) => AddXmlMeta(target, { kind: \"elem\", prop, ...opts });\r\n}\r\n\r\n/**\r\n *\r\n * @param obj\r\n * @returns\r\n */\r\nexport function GetXmlFieldMeta(obj: any): FieldMeta[] {\r\n    return (obj?.constructor?.[XML_CLASS_META] ?? []) as FieldMeta[];\r\n}\r\n\r\n/**\r\n *\r\n * @param obj\r\n * @returns\r\n */\r\nexport function GetXmlName(obj: any): XmlName | undefined {\r\n    const n = obj?.constructor?.[XML_CLASS_NAME];\r\n    return n ? (n as XmlName) : undefined;\r\n}\r\n\r\n/**\r\n *\r\n * @param s\r\n * @returns\r\n */\r\nfunction LooksLikeXmlNcName(s: string): boolean {\r\n    // Approximation ASCII de NCName: pas de \":\" et demarre par lettre ou underscore\r\n    // Puis lettres/chiffres/underscore/point/tiret.\r\n    return /^[A-Za-z_][A-Za-z0-9._-]*$/.test(s);\r\n}\r\n\r\n/**\r\n *\r\n * @param qn\r\n * @returns\r\n */\r\nexport function XmlNameToParts(qn: XmlName): IQualifiedName {\r\n    if (IsQualifiedName(qn)) {\r\n        return qn;\r\n    }\r\n    const s = (qn ?? \"\").trim();\r\n    if (!s) {\r\n        return { name: \"\" };\r\n    }\r\n    const i = s.indexOf(\":\");\r\n    if (i === -1) {\r\n        return { name: s };\r\n    }\r\n\r\n    // Un QName XML ne doit contenir qu un seul \":\".\r\n    // Si il y en a plusieurs, on considere que ce n est pas un QName.\r\n    if (s.indexOf(\":\", i + 1) !== -1) {\r\n        return { name: s };\r\n    }\r\n\r\n    const prefix = s.slice(0, i);\r\n    const local = s.slice(i + 1);\r\n\r\n    if (LooksLikeXmlNcName(prefix) && LooksLikeXmlNcName(local)) {\r\n        return { ns: prefix, name: local };\r\n    }\r\n    return { name: s };\r\n}\r\n\r\n/**\r\n *\r\n * @param name\r\n * @param prefix\r\n * @returns\r\n */\r\nexport function ToQualifiedString(name: string, prefix?: string): string {\r\n    return prefix ? `${prefix}:${name}` : name;\r\n}\r\n"]}

package/3MF/core/xml/xml.serializer.d.ts

@@ -0,0 +1,39 @@
+import { type IXmlBuilder, type XmlName } from "./xml.interfaces.js";
+import { type IXmlSerializerFormatOptions } from "./xml.serializer.format.js";
+/**
+ */
+export declare class XmlSerializer {
+    /** */
+    private _format;
+    /** */
+    private _builder;
+    /** */
+    private _ns;
+    /** */
+    private _prefixCount;
+    private _nFmt?;
+    /**
+     *
+     * @param builder
+     * @param format
+     */
+    constructor(builder: IXmlBuilder, format?: IXmlSerializerFormatOptions);
+    /**
+     *
+     * @param ns
+     * @returns
+     */
+    withNamespace(...ns: XmlName[]): XmlSerializer;
+    /**
+     *
+     * @param root
+     * @param name
+     */
+    serialize(root: object, name?: XmlName): void;
+    private _writeObject;
+    private _getPrefix;
+    private _writeObjectContent;
+    private _gatherNamespaces;
+    private _assignNamespace;
+    private _buildNsPrefix;
+}

package/3MF/core/xml/xml.serializer.format.d.ts

@@ -0,0 +1,92 @@
+import type { IFormatter } from "./xml.interfaces.js";
+/**
+ *
+ */
+export interface IXmlSerializerNumberOptions {
+    /**
+     *
+     */
+    eps: number;
+    /**
+     *
+     */
+    maxDecimalsCap?: number;
+    /**
+     *
+     */
+    trimTrailingZeros?: boolean;
+    /**
+     *
+     */
+    fixedDecimals?: number;
+    /**
+     *
+     */
+    allowScientific?: boolean;
+    /**
+     *
+     */
+    snapNearZero?: boolean;
+    /**
+     *
+     */
+    zeroThreshold?: number;
+    /**
+     *
+     */
+    perAttributeEps?: Record<string, number>;
+}
+/**
+ *
+ */
+export interface IXmlSerializerFormatOptions {
+    /**
+     *
+     */
+    number?: IXmlSerializerNumberOptions;
+}
+export declare const DefaultXmlSerializerNumberOptions: Readonly<IXmlSerializerNumberOptions>;
+export declare const DefaultXmlSerializerFormatOptions: Readonly<IXmlSerializerFormatOptions>;
+/**
+ *@param opts
+ *@returns
+ */
+export declare function ResolveNumberOptions(opts?: IXmlSerializerNumberOptions): Required<Omit<IXmlSerializerNumberOptions, "perAttributeEps" | "fixedDecimals" | "maxDecimalsCap" | "trimTrailingZeros" | "allowScientific" | "snapNearZero" | "zeroThreshold">> & Pick<IXmlSerializerNumberOptions, "perAttributeEps" | "fixedDecimals"> & {
+    maxDecimalsCap: number;
+    trimTrailingZeros: boolean;
+    allowScientific: boolean;
+    snapNearZero: boolean;
+    zeroThreshold: number;
+};
+/**
+ *@param opts
+ *@returns
+ */
+export declare function ResolveFormatOptions(opts?: IXmlSerializerFormatOptions): {
+    number: Required<Omit<IXmlSerializerNumberOptions, "maxDecimalsCap" | "trimTrailingZeros" | "fixedDecimals" | "allowScientific" | "snapNearZero" | "zeroThreshold" | "perAttributeEps">> & Pick<IXmlSerializerNumberOptions, "fixedDecimals" | "perAttributeEps"> & {
+        maxDecimalsCap: number;
+        trimTrailingZeros: boolean;
+        allowScientific: boolean;
+        snapNearZero: boolean;
+        zeroThreshold: number;
+    };
+};
+/**
+ *
+ */
+export declare class NumberFormatter implements IFormatter<number> {
+    o: IXmlSerializerFormatOptions;
+    private _o;
+    /**
+     *
+     * @param o
+     */
+    constructor(o: IXmlSerializerFormatOptions);
+    /**
+     *
+     * @param x
+     * @returns
+     */
+    toString(x: number): string;
+    private _clampInt;
+}

package/3MF/core/xml/xml.serializer.format.js

@@ -0,0 +1,122 @@
+export const DefaultXmlSerializerNumberOptions = Object.freeze({
+    eps: 1e-6,
+    maxDecimalsCap: 15,
+    trimTrailingZeros: true,
+    // fixedDecimals: undefined,
+    allowScientific: false,
+    snapNearZero: true,
+    // zeroThreshold defaults to eps if not provided
+    // perAttributeEps: undefined,
+});
+export const DefaultXmlSerializerFormatOptions = Object.freeze({
+    number: DefaultXmlSerializerNumberOptions,
+});
+/**
+ *@param opts
+ *@returns
+ */
+export function ResolveNumberOptions(opts) {
+    const eps = opts?.eps ?? DefaultXmlSerializerNumberOptions.eps;
+    return {
+        eps,
+        maxDecimalsCap: opts?.maxDecimalsCap ?? DefaultXmlSerializerNumberOptions.maxDecimalsCap,
+        trimTrailingZeros: opts?.trimTrailingZeros ?? DefaultXmlSerializerNumberOptions.trimTrailingZeros,
+        fixedDecimals: opts?.fixedDecimals,
+        allowScientific: opts?.allowScientific ?? DefaultXmlSerializerNumberOptions.allowScientific,
+        snapNearZero: opts?.snapNearZero ?? DefaultXmlSerializerNumberOptions.snapNearZero,
+        zeroThreshold: opts?.zeroThreshold ?? eps,
+        perAttributeEps: opts?.perAttributeEps,
+    };
+}
+/**
+ *@param opts
+ *@returns
+ */
+export function ResolveFormatOptions(opts) {
+    return {
+        number: ResolveNumberOptions(opts?.number),
+    };
+}
+/**
+ *
+ */
+export class NumberFormatter {
+    /**
+     *
+     * @param o
+     */
+    constructor(o) {
+        this.o = o;
+        this._o = o.number;
+        if (!Number.isFinite(this._o.eps) || this._o.eps <= 0) {
+            throw new Error("opts.eps must be a finite, positive number");
+        }
+    }
+    /**
+     *
+     * @param x
+     * @returns
+     */
+    toString(x) {
+        if (!Number.isFinite(x)) {
+            throw new Error(`Cannot format non-finite number: ${x}`);
+        }
+        const opts = this._o;
+        const maxDecimalsCap = this._clampInt(opts.maxDecimalsCap ?? 15, 0, 20);
+        const trimTrailingZeros = opts.trimTrailingZeros ?? true;
+        const snapNearZero = opts.snapNearZero ?? true;
+        const zeroThreshold = opts.zeroThreshold ?? opts.eps;
+        // Quantize to eps grid
+        const inv = 1 / opts.eps;
+        let q = Math.round(x * inv) / inv;
+        // Normalize -0 to 0
+        if (Object.is(q, -0)) {
+            q = 0;
+        }
+        // Snap tiny values to 0 (helps size + stability)
+        if (snapNearZero && Math.abs(q) <= zeroThreshold) {
+            q = 0;
+        }
+        // Choose decimals policy
+        let decimals;
+        if (opts.fixedDecimals !== undefined) {
+            decimals = this._clampInt(opts.fixedDecimals, 0, maxDecimalsCap);
+        }
+        else {
+            // decimals needed for eps steps
+            decimals = this._clampInt(Math.ceil(-Math.log10(opts.eps)), 0, maxDecimalsCap);
+        }
+        // Note: this implementation intentionally avoids scientific notation.
+        // If allowScientific=true, you may want a different path (toPrecision).
+        if (opts.allowScientific) {
+            // Still avoid scientific here; keep deterministic fixed output.
+            // If you really want scientific, implement a separate branch.
+        }
+        // Fast path when decimals = 0
+        if (decimals === 0) {
+            return String(Math.trunc(q));
+        }
+        // Start fixed, then optionally trim
+        let s = q.toFixed(decimals);
+        if (trimTrailingZeros && opts.fixedDecimals === undefined) {
+            // Trim trailing zeros and optional trailing dot
+            s = s
+                .replace(/(\.\d*?[1-9])0+$/, "$1")
+                .replace(/\.0+$/, "")
+                .replace(/\.$/, "");
+        }
+        // Safety: ensure no scientific notation (should not happen with toFixed)
+        if (/[eE]/.test(s)) {
+            throw new Error(`Scientific notation not allowed in XML output: ${s}`);
+        }
+        return s;
+    }
+    _clampInt(n, min, max) {
+        if (!Number.isFinite(n)) {
+            return min;
+        }
+        n = Math.trunc(n);
+        return Math.max(min, Math.min(max, n));
+    }
+}
+//# sourceMappingURL=xml.serializer.format.js.map

package/3MF/core/xml/xml.serializer.format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml.serializer.format.js","sourceRoot":"","sources":["../../../../../../dev/serializers/src/3MF/core/xml/xml.serializer.format.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IFormatter } from \"./xml.interfaces\";\r\n\r\n/**\r\n *\r\n */\r\nexport interface IXmlSerializerNumberOptions {\r\n    /**\r\n     *\r\n     */\r\n    eps: number;\r\n    /**\r\n     *\r\n     */\r\n    maxDecimalsCap?: number; // default 15\r\n    /**\r\n     *\r\n     */\r\n    trimTrailingZeros?: boolean; // default true\r\n    /**\r\n     *\r\n     */\r\n    fixedDecimals?: number; // optional, overrides trim\r\n    /**\r\n     *\r\n     */\r\n    allowScientific?: boolean; // default false\r\n    /**\r\n     *\r\n     */\r\n    snapNearZero?: boolean; // default true\r\n    /**\r\n     *\r\n     */\r\n    zeroThreshold?: number; // default eps\r\n    /**\r\n     *\r\n     */\r\n    perAttributeEps?: Record<string, number>;\r\n}\r\n\r\n/**\r\n *\r\n */\r\nexport interface IXmlSerializerFormatOptions {\r\n    /**\r\n     *\r\n     */\r\n    number?: IXmlSerializerNumberOptions;\r\n}\r\n\r\nexport const DefaultXmlSerializerNumberOptions: Readonly<IXmlSerializerNumberOptions> = Object.freeze({\r\n    eps: 1e-6,\r\n    maxDecimalsCap: 15,\r\n    trimTrailingZeros: true,\r\n    // fixedDecimals: undefined,\r\n    allowScientific: false,\r\n    snapNearZero: true,\r\n    // zeroThreshold defaults to eps if not provided\r\n    // perAttributeEps: undefined,\r\n});\r\n\r\nexport const DefaultXmlSerializerFormatOptions: Readonly<IXmlSerializerFormatOptions> = Object.freeze({\r\n    number: DefaultXmlSerializerNumberOptions,\r\n});\r\n\r\n/**\r\n *@param opts\r\n *@returns\r\n */\r\nexport function ResolveNumberOptions(opts?: IXmlSerializerNumberOptions): Required<\r\n    Omit<IXmlSerializerNumberOptions, \"perAttributeEps\" | \"fixedDecimals\" | \"maxDecimalsCap\" | \"trimTrailingZeros\" | \"allowScientific\" | \"snapNearZero\" | \"zeroThreshold\">\r\n> &\r\n    Pick<IXmlSerializerNumberOptions, \"perAttributeEps\" | \"fixedDecimals\"> & {\r\n        maxDecimalsCap: number;\r\n        trimTrailingZeros: boolean;\r\n        allowScientific: boolean;\r\n        snapNearZero: boolean;\r\n        zeroThreshold: number;\r\n    } {\r\n    const eps = opts?.eps ?? DefaultXmlSerializerNumberOptions.eps;\r\n\r\n    return {\r\n        eps,\r\n        maxDecimalsCap: opts?.maxDecimalsCap ?? DefaultXmlSerializerNumberOptions.maxDecimalsCap!,\r\n        trimTrailingZeros: opts?.trimTrailingZeros ?? DefaultXmlSerializerNumberOptions.trimTrailingZeros!,\r\n        fixedDecimals: opts?.fixedDecimals,\r\n        allowScientific: opts?.allowScientific ?? DefaultXmlSerializerNumberOptions.allowScientific!,\r\n        snapNearZero: opts?.snapNearZero ?? DefaultXmlSerializerNumberOptions.snapNearZero!,\r\n        zeroThreshold: opts?.zeroThreshold ?? eps,\r\n        perAttributeEps: opts?.perAttributeEps,\r\n    };\r\n}\r\n\r\n/**\r\n *@param opts\r\n *@returns\r\n */\r\nexport function ResolveFormatOptions(opts?: IXmlSerializerFormatOptions) {\r\n    return {\r\n        number: ResolveNumberOptions(opts?.number),\r\n    };\r\n}\r\n\r\n/**\r\n *\r\n */\r\nexport class NumberFormatter implements IFormatter<number> {\r\n    private _o: IXmlSerializerNumberOptions;\r\n\r\n    /**\r\n     *\r\n     * @param o\r\n     */\r\n    public constructor(public o: IXmlSerializerFormatOptions) {\r\n        this._o = o.number!;\r\n\r\n        if (!Number.isFinite(this._o.eps) || this._o.eps <= 0) {\r\n            throw new Error(\"opts.eps must be a finite, positive number\");\r\n        }\r\n    }\r\n\r\n    /**\r\n     *\r\n     * @param x\r\n     * @returns\r\n     */\r\n\r\n    public toString(x: number): string {\r\n        if (!Number.isFinite(x)) {\r\n            throw new Error(`Cannot format non-finite number: ${x}`);\r\n        }\r\n\r\n        const opts = this._o;\r\n        const maxDecimalsCap = this._clampInt(opts.maxDecimalsCap ?? 15, 0, 20);\r\n        const trimTrailingZeros = opts.trimTrailingZeros ?? true;\r\n        const snapNearZero = opts.snapNearZero ?? true;\r\n        const zeroThreshold = opts.zeroThreshold ?? opts.eps;\r\n\r\n        // Quantize to eps grid\r\n        const inv = 1 / opts.eps;\r\n        let q = Math.round(x * inv) / inv;\r\n\r\n        // Normalize -0 to 0\r\n        if (Object.is(q, -0)) {\r\n            q = 0;\r\n        }\r\n\r\n        // Snap tiny values to 0 (helps size + stability)\r\n        if (snapNearZero && Math.abs(q) <= zeroThreshold) {\r\n            q = 0;\r\n        }\r\n\r\n        // Choose decimals policy\r\n        let decimals: number;\r\n        if (opts.fixedDecimals !== undefined) {\r\n            decimals = this._clampInt(opts.fixedDecimals, 0, maxDecimalsCap);\r\n        } else {\r\n            // decimals needed for eps steps\r\n            decimals = this._clampInt(Math.ceil(-Math.log10(opts.eps)), 0, maxDecimalsCap);\r\n        }\r\n\r\n        // Note: this implementation intentionally avoids scientific notation.\r\n        // If allowScientific=true, you may want a different path (toPrecision).\r\n        if (opts.allowScientific) {\r\n            // Still avoid scientific here; keep deterministic fixed output.\r\n            // If you really want scientific, implement a separate branch.\r\n        }\r\n\r\n        // Fast path when decimals = 0\r\n        if (decimals === 0) {\r\n            return String(Math.trunc(q));\r\n        }\r\n\r\n        // Start fixed, then optionally trim\r\n        let s = q.toFixed(decimals);\r\n\r\n        if (trimTrailingZeros && opts.fixedDecimals === undefined) {\r\n            // Trim trailing zeros and optional trailing dot\r\n            s = s\r\n                .replace(/(\\.\\d*?[1-9])0+$/, \"$1\")\r\n                .replace(/\\.0+$/, \"\")\r\n                .replace(/\\.$/, \"\");\r\n        }\r\n\r\n        // Safety: ensure no scientific notation (should not happen with toFixed)\r\n        if (/[eE]/.test(s)) {\r\n            throw new Error(`Scientific notation not allowed in XML output: ${s}`);\r\n        }\r\n\r\n        return s;\r\n    }\r\n\r\n    private _clampInt(n: number, min: number, max: number): number {\r\n        if (!Number.isFinite(n)) {\r\n            return min;\r\n        }\r\n        n = Math.trunc(n);\r\n        return Math.max(min, Math.min(max, n));\r\n    }\r\n}\r\n"]}

package/3MF/core/xml/xml.serializer.js

@@ -0,0 +1,261 @@
+import { XmlNameToParts, GetXmlName, ToQualifiedString, GetXmlFieldMeta } from "./xml.interfaces.js";
+import { NumberFormatter, ResolveFormatOptions } from "./xml.serializer.format.js";
+function IsDate(x) {
+    return x instanceof Date;
+}
+function IsString(x) {
+    return typeof x === "string";
+}
+function IsNumber(x) {
+    return typeof x === "number";
+}
+function IsPrimitive(x) {
+    return typeof x === "string" || typeof x === "number" || typeof x === "boolean" || typeof x === "bigint" || IsDate(x);
+}
+function IsPrimitiveButString(x) {
+    return typeof x === "number" || typeof x === "boolean" || typeof x === "bigint" || IsDate(x);
+}
+/**
+ */
+export class XmlSerializer {
+    /**
+     *
+     * @param builder
+     * @param format
+     */
+    constructor(builder, format) {
+        /** */
+        this._ns = new Map();
+        /** */
+        this._prefixCount = 0;
+        this._builder = builder;
+        this._format = ResolveFormatOptions(format);
+        this._nFmt = new NumberFormatter(this._format);
+    }
+    /**
+     *
+     * @param ns
+     * @returns
+     */
+    withNamespace(...ns) {
+        for (const s of ns) {
+            this._assignNamespace(s);
+        }
+        return this;
+    }
+    /**
+     *
+     * @param root
+     * @param name
+     */
+    serialize(root, name) {
+        name = name ?? GetXmlName(root);
+        if (!name) {
+            throw new Error("can not find name for given object");
+        }
+        const currentName = XmlNameToParts(name);
+        if (currentName.ns) {
+            // ensure we register the root namespace as default if not already set...
+            this._assignNamespace(currentName.ns, "xmlns");
+        }
+        this._gatherNamespaces(root, new WeakSet());
+        const doc = this._builder.ele(null, currentName.name);
+        for (const [v, n] of Array.from(this._ns.entries())) {
+            doc.att("xmlns", n, v);
+        }
+        this._writeObjectContent(doc, root, new WeakSet().add(root));
+        this._builder.end();
+    }
+    _writeObject(builder, source, visited) {
+        if (visited.has(source)) {
+            return;
+        }
+        visited.add(source);
+        if (Array.isArray(source)) {
+            for (const item of source) {
+                if (IsPrimitiveButString(item)) {
+                    continue;
+                }
+                if (IsString(item)) {
+                    this._builder.text(item);
+                    continue;
+                }
+                this._writeObject(builder, item, visited);
+            }
+            return;
+        }
+        const qname = GetXmlName(source);
+        if (!qname) {
+            return;
+        }
+        const currentName = XmlNameToParts(qname);
+        const prefix = this._getPrefix(currentName);
+        const tmp = ToQualifiedString(currentName.name, prefix);
+        builder.ele(null, tmp);
+        this._writeObjectContent(builder, source, visited);
+        this._builder.end();
+    }
+    _getPrefix(qn) {
+        if (qn.ns) {
+            const p = this._ns.get(qn.ns.toLowerCase());
+            if (p !== "xmlns") {
+                return p;
+            }
+        }
+        return undefined;
+    }
+    _writeObjectContent(builder, source, visited) {
+        // gather meta and build index
+        const metas = GetXmlFieldMeta(source) ?? [];
+        const metaByProp = new Map();
+        for (const m of metas) {
+            const arr = metaByProp.get(m.prop) ?? [];
+            arr.push(m);
+            metaByProp.set(m.prop, arr);
+        }
+        // ensure the att are processed first, otherwize, the tag might be closed...
+        const keys = Object.keys(source).sort((a, b) => {
+            const aHasAttr = (metaByProp.get(a) ?? []).some((m) => m.kind === "attr");
+            const bHasAttr = (metaByProp.get(b) ?? []).some((m) => m.kind === "attr");
+            if (aHasAttr === bHasAttr) {
+                return 0;
+            }
+            return aHasAttr ? -1 : 1; // attr d abord
+        });
+        // We decide per property, using metadata if present
+        for (const prop of keys) {
+            const value = source[prop];
+            if (value === null || value === undefined) {
+                continue;
+            }
+            const propMetas = metaByProp.get(prop);
+            if (propMetas) {
+                const ignored = propMetas.some((m) => m.ignore === true || m.kind === "none");
+                if (ignored) {
+                    continue;
+                }
+                for (const m of propMetas) {
+                    const name = m.name ?? m.prop.toLowerCase(); // if the name is not defined, we assume it's the lower case version of name of the property.
+                    if (name) {
+                        switch (m.kind) {
+                            case "attr": {
+                                let vStr = null;
+                                if (IsNumber(value) && this._nFmt) {
+                                    vStr = this._nFmt.toString(value);
+                                }
+                                if (m.formatter) {
+                                    // TODO : cache the created formatter to avoid to many allocation.
+                                    const f = new m.formatter(this._format);
+                                    vStr = f.toString(value);
+                                }
+                                vStr = vStr ?? value.toString();
+                                if (vStr) {
+                                    const currentName = XmlNameToParts(name);
+                                    const prefix = this._getPrefix(currentName);
+                                    const tmp = ToQualifiedString(currentName.name, prefix);
+                                    builder.att(null, tmp, vStr);
+                                }
+                                break;
+                            }
+                        }
+                    }
+                }
+                continue;
+            }
+            if (IsPrimitiveButString(value)) {
+                continue;
+            }
+            if (IsString(value)) {
+                this._builder.text(value);
+                continue;
+            }
+            this._writeObject(builder, value, visited);
+        }
+    }
+    // this is the first browse of the hierarchy to collect the namespaces and assign placeholder.( ns0, ns1,...)
+    _gatherNamespaces(tag, visited) {
+        if (visited.has(tag)) {
+            return;
+        }
+        visited.add(tag);
+        if (Array.isArray(tag)) {
+            for (const item of tag) {
+                if (IsPrimitive(item)) {
+                    continue;
+                }
+                this._gatherNamespaces(item, visited);
+            }
+            return;
+        }
+        const qname = GetXmlName(tag);
+        if (qname) {
+            this._assignNamespace(qname);
+        }
+        // gather meta and build index
+        const metas = GetXmlFieldMeta(tag) ?? [];
+        const metaByProp = new Map();
+        for (const m of metas) {
+            const arr = metaByProp.get(m.prop) ?? [];
+            arr.push(m);
+            metaByProp.set(m.prop, arr);
+        }
+        // We decide per property, using metadata if present
+        const toVisit = [];
+        for (const prop of Object.keys(tag)) {
+            const value = tag[prop];
+            if (value === null || value === undefined) {
+                continue;
+            }
+            const propMetas = metaByProp.get(prop);
+            if (propMetas) {
+                const ignored = propMetas.some((m) => m.ignore === true || m.kind === "none");
+                if (ignored) {
+                    continue;
+                }
+                for (const m of propMetas) {
+                    if (m.name) {
+                        this._assignNamespace(m.name);
+                    }
+                }
+            }
+            toVisit.push(value);
+        }
+        for (const v of toVisit) {
+            if (IsPrimitive(v)) {
+                continue;
+            }
+            this._gatherNamespaces(v, visited);
+        }
+    }
+    _assignNamespace(qn, prefix) {
+        const nqn = XmlNameToParts(qn);
+        if (nqn?.ns) {
+            const ns = nqn.ns.toLowerCase();
+            if (!this._ns.get(ns)) {
+                this._ns.set(ns, prefix ?? this._buildNsPrefix(ns));
+            }
+            return;
+        }
+        if (prefix === "xmlns") {
+            const ns = nqn.name.toLowerCase();
+            if (!this._ns.get(ns)) {
+                this._ns.set(ns, prefix ?? this._buildNsPrefix(ns));
+            }
+        }
+    }
+    _buildNsPrefix(_ns) {
+        let alreadyReferenced = false;
+        let value;
+        do {
+            value = `ns${this._prefixCount++}`;
+            for (const v of Array.from(this._ns.values())) {
+                if (v === value) {
+                    alreadyReferenced = true;
+                    break;
+                }
+            }
+        } while (alreadyReferenced);
+        return value;
+    }
+}
+//# sourceMappingURL=xml.serializer.js.map