@docx4j/jsonix 3.2.0

package/package.json

@@ -0,0 +1,82 @@
+{
+	"name": "@docx4j/jsonix",
+	"version": "3.2.0",
+	"description": "Jsonix (JSON interfaces for XML) is a JavaScript library which allows converting between XML and JSON structures.",
+	"keywords": [
+		"json",
+		"xml",
+		"unmarshal",
+		"unmarshalling",
+		"marshal",
+		"marshalling",
+		"parse",
+		"parsing",
+		"serialize",
+		"serializing",
+		"javascript objects",
+		"dom",
+		"util",
+		"utility",
+		"jaxb",
+		"jsonix"
+	],
+	"homepage": "https://github.com/plutext/jsonix",
+	"bugs": {
+		"url": "https://github.com/plutext/jsonix/issues"
+	},
+	"licenses": [
+		{
+			"type": "(Apache-2.0 AND BSD-2-Clause)",
+			"url": "https://github.com/plutext/jsonix/raw/master/LICENSE"
+		}
+	],
+	"author": {
+		"name": "Alexey Valikov",
+		"url": "http://github.com/highsource"
+	},
+	"contributors": [
+		{
+			"name": "Conrad Pankoff",
+			"url": "https://github.com/deoxxa"
+		},
+		{
+			"name": "MITRE SAF (C)",
+			"url": "https://saf.mitre.org"
+		},
+		{
+			"name": "Plutext Pty Ltd (Jason Harrop)",
+			"url": "https://www.plutext.com"
+		}
+	],
+	"main": "jsonix.js",
+	"module": "jsonix.mjs",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/plutext/jsonix.git"
+	},
+	"types": "./types/main.d.ts",
+	"exports": {
+		".": {
+			"types": "./types/main.d.ts",
+			"import": "./jsonix.mjs",
+			"require": "./jsonix.js"
+		},
+		"./jsonix.js": "./jsonix.js",
+		"./package.json": "./package.json"
+	},
+	"scripts": {
+		"test": "nodeunit tests/tests.js",
+		"typecheck": "tsc -p tests/typescript/tsconfig.json && tsc -p tests/typescript/tsconfig.node16.json",
+		"test:esm": "node tests/typescript/esm-smoke.mjs"
+	},
+	"dependencies": {
+		"@xmldom/xmldom": "^0.9.7",
+		"amdefine": "^1.0.1",
+		"xmlhttprequest": "^1.8.0"
+	},
+	"devDependencies": {
+		"node-static": "^0.7.11",
+		"nodeunit": "^0.11.3",
+		"typescript": "~5.6.3"
+	}
+}

package/pom.xml

@@ -0,0 +1,135 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<artifactId>jsonix-nodejs-scripts</artifactId>
+	<packaging>pom</packaging>
+	<name>Jsonix Node.js Scripts</name>
+	<parent>
+		<groupId>org.hisrc.jsonix</groupId>
+		<artifactId>jsonix-nodejs</artifactId>
+		<version>3.0.1-SNAPSHOT</version>
+	</parent>
+	<dependencies>
+		<dependency>
+			<groupId>${project.groupId}</groupId>
+			<artifactId>jsonix-schema-compiler-full</artifactId>
+		</dependency>
+	</dependencies>
+	<build>
+		<plugins>
+			<plugin>
+				<artifactId>maven-resources-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>copy-package.json</id>
+						<phase>initialize</phase>
+						<goals>
+							<goal>copy-resources</goal>
+						</goals>
+						<configuration>
+							<outputDirectory>${basedir}</outputDirectory>
+							<resources>					
+								<resource>
+									<directory>src/main/npm</directory>
+									<filtering>true</filtering>
+								</resource>
+							</resources>							
+						</configuration>						
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<artifactId>maven-dependency-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>unpack</id>
+						<phase>generate-sources</phase>
+						<goals>
+							<goal>copy</goal>
+						</goals>
+						<configuration>
+							<artifactItems>
+								<artifactItem>
+									<groupId>${project.groupId}</groupId>
+									<artifactId>jsonix-scripts</artifactId>
+									<version>${project.version}</version>
+									<type>js</type>
+									<classifier>all</classifier>
+									<overWrite>true</overWrite>
+									<outputDirectory>${basedir}</outputDirectory>
+									<destFileName>jsonix.js</destFileName>
+								</artifactItem>
+								<artifactItem>
+									<groupId>${project.groupId}</groupId>
+									<artifactId>jsonix-schema-compiler-full</artifactId>
+									<version>${jsonix-schema-compiler.version}</version>
+									<overWrite>true</overWrite>
+									<outputDirectory>${basedir}/lib</outputDirectory>
+									<destFileName>jsonix-schema-compiler-full.jar</destFileName>
+								</artifactItem>
+							</artifactItems>
+						</configuration>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.codehaus.mojo</groupId>
+				<artifactId>exec-maven-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>npm-install</id>
+						<phase>compile</phase>
+						<goals>
+							<goal>exec</goal>
+						</goals>
+						<configuration>
+							<executable>npm</executable>
+							<arguments>
+								<argument>install</argument>
+							</arguments>
+						</configuration>
+					</execution>
+					<execution>
+						<id>npm-test</id>
+						<phase>test</phase>
+						<goals>
+							<goal>exec</goal>
+						</goals>
+						<configuration>
+							<executable>npm</executable>
+							<arguments>
+								<argument>test</argument>
+							</arguments>
+						</configuration>
+					</execution>
+					<execution>
+						<id>npm-pack</id>
+						<phase>package</phase>
+						<goals>
+							<goal>exec</goal>
+						</goals>
+						<configuration>
+							<executable>npm</executable>
+							<arguments>
+								<argument>pack</argument>
+							</arguments>
+						</configuration>
+					</execution>
+					<!--execution>
+						<id>publish</id>
+						<phase>deploy</phase>
+						<goals>
+							<goal>exec</goal>
+						</goals>
+						<configuration>
+							<executable>npm</executable>
+							<arguments>
+								<argument>publish</argument>
+								<argument>.</argument>
+							</arguments>
+						</configuration>
+					</execution-->
+				</executions>
+			</plugin>
+		</plugins>
+	</build>
+</project>

package/src/main/npm/package.json

@@ -0,0 +1,64 @@
+{
+	"name": "@docx4j/jsonix",
+	"version": "${project.version}",
+	"description": "Jsonix (JSON interfaces for XML) is a JavaScript library which allows converting between XML and JSON structures.",
+	"keywords": [
+		"json",
+		"xml",
+		"unmarshal",
+		"unmarshalling",
+		"marshal",
+		"marshalling",
+		"parse",
+		"parsing",
+		"serialize",
+		"serializing",
+		"javascript objects",
+		"dom",
+		"util",
+		"utility",
+		"jaxb",
+		"jsonix"
+	],
+	"homepage": "https://github.com/plutext/jsonix",
+	"bugs": {
+		"url": "https://github.com/plutext/jsonix/issues"
+	},
+	"licenses": [
+		{
+			"type": "BSD-3-Clause",
+			"url": "https://github.com/plutext/jsonix/raw/master/LICENSE"
+		}
+	],
+	"author": {
+		"name": "Alexey Valikov",
+		"url": "http://github.com/highsource"
+	},
+	"contributors": [
+		{
+			"name": "Conrad Pankoff",
+			"url": "https://github.com/deoxxa"
+		},
+		{
+			"name": "Plutext Pty Ltd (Jason Harrop)",
+			"url": "https://www.plutext.com"
+		}
+	],
+	"main": "jsonix.js",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/plutext/jsonix.git"
+	},
+	"scripts": {
+		"test": "nodeunit tests/tests.js"
+	},
+	"dependencies": {
+		"amdefine": "0.x.x",
+		"xmldom": ">=0.1.21",
+		"xmlhttprequest": "1.x.x"
+	},
+	"devDependencies": {
+		"nodeunit": "0.x.x",
+		"node-static": "0.x.x"
+	}
+}

package/types/main.d.ts

@@ -0,0 +1,356 @@
+/**
+ * Type declarations for the @docx4j/jsonix runtime.
+ *
+ * The data shapes below (TypedNamedValue, XML.QName, XML.Calendar, XML.Duration and the
+ * TYPE_NAME discriminant) are a contract with the declaration files that
+ * jsonix-schema-compiler emits with -generateTypeScript: generated files carry their own
+ * structurally identical copies, so anything the runtime returns can be typed with a
+ * generated element type, and anything typed with a generated type can be marshalled.
+ * tests/typescript guards that contract. Change them together or not at all.
+ */
+
+export namespace Jsonix {
+  export namespace XML {
+    /**
+     * A qualified name (Jsonix.XML.QName). Runtime instances always carry every field;
+     * marshal input may give only namespaceURI and localPart.
+     */
+    export interface QName {
+      namespaceURI: string;
+      localPart: string;
+      prefix?: string;
+      /** "{namespaceURI}localPart" */
+      key?: string;
+      /** "prefix:localPart" */
+      string?: string;
+    }
+
+    /**
+     * The representation of xs:date, xs:time, xs:dateTime and the xs:g* types
+     * (Jsonix.XML.Calendar). Unset fields are NaN. Jsonix never returns a JavaScript Date.
+     */
+    export interface Calendar {
+      year?: number;
+      month?: number;
+      day?: number;
+      hour?: number;
+      minute?: number;
+      second?: number;
+      fractionalSecond?: number;
+      timezone?: number;
+    }
+
+    /** The representation of xs:duration values. sign is 1 or -1. */
+    export interface Duration {
+      sign?: number;
+      years?: number;
+      months?: number;
+      days?: number;
+      hours?: number;
+      minutes?: number;
+      seconds?: number;
+    }
+  }
+
+  /**
+   * An element: what an unmarshaller returns, what a marshaller accepts, and the value of an
+   * elementRef property. Generated declarations alias this per global element, for example
+   * `type PurchaseOrderElement = TypedNamedValue<PurchaseOrderType>`.
+   */
+  export interface TypedNamedValue<T = unknown> {
+    name: XML.QName;
+    value: T;
+  }
+
+  /**
+   * A mapping module as consumed by `new Jsonix.Context([...])`: a plain object generated by
+   * jsonix-schema-compiler or written by hand. Generated declarations type theirs as
+   * `JsonixMapping<RootElement>`, whose phantom `__rootElement` carries the union of the module's
+   * global element types; `Context` reads it to infer what its unmarshallers return.
+   */
+  export interface Mapping<R = unknown> {
+    readonly __rootElement?: R;
+    readonly [key: string]: unknown;
+  }
+
+  /**
+   * The union of the root element types of the given mapping(s), or the untyped element when a
+   * mapping does not declare one (hand-written mappings, generated ones compiled without
+   * -generateTypeScript).
+   */
+  export type RootElementOf<M> = M extends { readonly __rootElement?: infer R }
+    ? NonNullable<R> extends TypedNamedValue
+      ? NonNullable<R>
+      : TypedNamedValue
+    : TypedNamedValue;
+
+  export interface ContextOptions {
+    /** Maps namespace URIs to the prefixes used when marshalling. */
+    namespacePrefixes?: { [namespaceURI: string]: string };
+    /** Whether xsi:type attributes are honoured when unmarshalling and written when marshalling. Defaults to true. */
+    supportXsiType?: boolean;
+    /** The mapping style, by name or as a custom style object. Defaults to 'standard'. */
+    mappingStyle?: 'standard' | 'simplified' | object;
+    /**
+     * When true, every typed object the unmarshaller creates (objects with TYPE_NAME, or
+     * instanceFactory instances) gets a non-enumerable PARENT property pointing at the nearest
+     * enclosing typed object; root objects have none. Element wrappers, maps, calendars, QNames
+     * and DOM nodes never get one. Defaults to false. Generated declarations type PARENT as the
+     * union of the types that can contain each type.
+     */
+    parentPointers?: boolean;
+  }
+
+  /** Convenience for hand-written types: an object that may carry a parent pointer. Generated declarations inline the union. */
+  export interface Parented<P = unknown> {
+    readonly PARENT?: P;
+  }
+
+  export namespace Util {
+    /**
+     * Copies a value structurally: primitives are shared; QNames, calendars and DOM nodes are
+     * cloned; arrays and plain objects (including element wrappers, durations, maps and typed
+     * objects, keeping TYPE_NAME) are copied recursively, own enumerable properties only. An
+     * object referenced twice is copied once. PARENT pointers inside the copy are re-linked to
+     * the copied parents; the copy's own PARENT is `parent` if given, otherwise unset.
+     */
+    function deepCopy<T>(value: T, parent?: unknown): T;
+    /** Defines a non-enumerable, writable PARENT on `value` (no-op for non-objects). */
+    function setParent(value: object, parent: unknown): void;
+  }
+
+  /**
+   * Options for unmarshalURL (passed to the XMLHttpRequest transport) and unmarshalFile
+   * (passed to fs.readFile).
+   */
+  export type UnmarshalOptions = object;
+
+  /**
+   * R is the union of root element types inferred from the context's mappings; each method can
+   * narrow it with an explicit type argument, e.g. `unmarshalString<PurchaseOrderElement>(xml)`.
+   */
+  export interface Unmarshaller<R extends TypedNamedValue = TypedNamedValue> {
+    /** Parses an XML string. */
+    unmarshalString<E extends TypedNamedValue = R>(text: string): E;
+    /** Unmarshals a DOM document (or element). */
+    unmarshalDocument<E extends TypedNamedValue = R>(doc: Node, scope?: unknown): E;
+    /** Loads the URL with XMLHttpRequest and unmarshals the response. */
+    unmarshalURL<E extends TypedNamedValue = R>(
+      url: string,
+      callback: (unmarshalled: E) => void,
+      options?: UnmarshalOptions
+    ): void;
+    /** Node.js only: reads the file and unmarshals it. Throws in environments without a file system. */
+    unmarshalFile<E extends TypedNamedValue = R>(
+      fileName: string,
+      callback: (unmarshalled: E) => void,
+      options?: UnmarshalOptions
+    ): void;
+  }
+
+  export interface Marshaller {
+    /** Serialises an element to an XML string. */
+    marshalString<E extends TypedNamedValue>(element: E): string;
+    /** Serialises an element to a DOM document. */
+    marshalDocument<E extends TypedNamedValue>(element: E): Document;
+  }
+
+  /**
+   * M is inferred from the mappings passed to the constructor; `createUnmarshaller()` then returns
+   * elements typed as the union of those mappings' root elements. The constraint is `object`, not
+   * `Mapping`, so hand-written mappings typed with an interface (no index signature) are accepted.
+   */
+  export class Context<M extends object = Mapping> {
+    /**
+     * @param mappings Mapping modules (generated or hand-written). Cross-module references are
+     *   resolved by name, in any order.
+     * @param options Optional configuration.
+     */
+    constructor(mappings: M[], options?: ContextOptions);
+
+    createUnmarshaller(): Unmarshaller<RootElementOf<M>>;
+    createMarshaller(): Marshaller;
+
+    getTypeInfoByName(name: string): TypeInfo;
+    getTypeInfoByTypeName(typeName: string): TypeInfo;
+    getTypeInfoByTypeNameKey(typeNameKey: string): TypeInfo;
+    getElementInfo(name: string, scope: string): any;
+    getSubstitutionMembers(name: string): any;
+    getNamespaceURI(prefix: string): any;
+    getPrefix(namespaceURI: string, defaultPrefix: string): any;
+
+    builtinTypeInfos: {
+      Jsonix: {
+        Schema: {
+          XSD: {
+            AnyType: { INSTANCE: {} };
+            AnySimpleType: { INSTANCE: {} };
+            AnyURI: { INSTANCE: {} };
+            Base64Binary: { INSTANCE: {} };
+            Boolean: { INSTANCE: {} };
+            Byte: { INSTANCE: {} };
+            Calendar: { INSTANCE: {} };
+            DateAsDate: { INSTANCE: {} };
+            Date: { INSTANCE: {} };
+            DateTimeAsDate: { INSTANCE: {} };
+            DateTime: { INSTANCE: {} };
+            Decimal: { INSTANCE: {} };
+            Double: { INSTANCE: {} };
+            Duration: { INSTANCE: {} };
+            Float: { INSTANCE: {} };
+            GDay: { INSTANCE: {} };
+            GMonth: { INSTANCE: {} };
+            GMonthDay: { INSTANCE: {} };
+            GYear: { INSTANCE: {} };
+            GYearMonth: { INSTANCE: {} };
+            HexBinary: { INSTANCE: {} };
+            ID: { INSTANCE: {} };
+            IDREF: { INSTANCE: {} };
+            IDREFS: { INSTANCE: {} };
+            Int: { INSTANCE: {} };
+            Integer: { INSTANCE: {} };
+            Language: { INSTANCE: {} };
+            Long: { INSTANCE: {} };
+            Name: { INSTANCE: {} };
+            NCName: { INSTANCE: {} };
+            NegativeInteger: { INSTANCE: {} };
+            NMToken: { INSTANCE: {} };
+            NMTokens: { INSTANCE: {} };
+            NonNegativeInteger: { INSTANCE: {} };
+            NonPositiveInteger: { INSTANCE: {} };
+            NormalizedString: { INSTANCE: {} };
+            Number: { INSTANCE: {} };
+            PositiveInteger: { INSTANCE: {} };
+            QName: { INSTANCE: {} };
+            Short: { INSTANCE: {} };
+            String: { INSTANCE: {} };
+            Strings: { INSTANCE: {} };
+            TimeAsDate: { INSTANCE: {} };
+            Time: { INSTANCE: {} };
+            Token: { INSTANCE: {} };
+            UnsignedByte: { INSTANCE: {} };
+            UnsignedInt: { INSTANCE: {} };
+            UnsignedLong: { INSTANCE: {} };
+            UnsignedShort: { INSTANCE: {} };
+          };
+        };
+      };
+    }[];
+
+    // private
+    elementInfos: ClassInfo[];
+  }
+
+  // Mapping internals (as built by Context). These describe the mapping model, not the data.
+
+  export interface Styled {
+    CLASS_NAME: string;
+    mappingStyle: Object;
+  }
+
+  export interface TypeInfo {
+    name: string;
+    baseTypeInfo: TypeInfo;
+  }
+
+  export interface EnumLeafInfo extends TypeInfo {
+    name: string;
+    baseTypeInfo: TypeInfo;
+    entries: { [name: string]: string };
+    keys: { [index: number]: string };
+    values: { [index: number]: string };
+    built: boolean;
+  }
+
+  export interface PropertyInfo {
+    CLASS_NAME: string;
+    name: string;
+    collection: boolean;
+    targetNamespace: string;
+    defaultElementNamespaceURI: string;
+    defaultAttributeNamespaceURI: string;
+    built: boolean;
+  }
+
+  export interface AbstractElementPropertyInfo extends PropertyInfo {
+    wrapperElement: XML.QName;
+    allowDom: boolean;
+    allowTypedObject: boolean;
+    mixed: boolean;
+  }
+
+  export interface ElementPropertyInfo extends AbstractElementPropertyInfo {
+    typeInfo: TypeInfo | string;
+    elementName: XML.QName;
+  }
+
+  export interface ClassInfo extends TypeInfo, Styled {
+    CLASS_NAME: string;
+    localName: string;
+    typeName: XML.QName;
+    instanceFactory: {};
+    properties: { [index: number]: PropertyInfo };
+    propertiesMap: { [name: string]: PropertyInfo };
+    structure: {
+      elements: { [fqn: string]: PropertyInfo };
+      attributes: {};
+      anyAttribute: {};
+      value: {};
+      any: {};
+    };
+    targetNamespace: string;
+    defaultElementNamespaceURI: string;
+    defaultAttributeNamespaceURI: string;
+    built: boolean;
+    propertyInfoCreators: {
+      aa: { aa: any };
+      anyAttribute: { aa: any };
+      ae: { ae: any };
+      anyElement: { ae: any };
+      a: { a: any };
+      attribute: { a: any };
+      em: { em: any };
+      elementMap: { em: any };
+      e: { e: any };
+      element: { e: any };
+      es: { es: any };
+      elements: { es: any };
+      er: { er: any };
+      elementRef: { er: any };
+      ers: { ers: any };
+      elementRefs: { ers: any };
+      v: { v: any };
+      value: { v: any };
+    };
+  }
+}
+
+/**
+ * Backwards compatibility: versions up to 3.0.11 declared these as global (ambient) interfaces.
+ * Prefer the Jsonix.* names.
+ * @deprecated
+ */
+declare global {
+  /** @deprecated use Jsonix.Unmarshaller */
+  interface Unmarshaller extends Jsonix.Unmarshaller {}
+  /** @deprecated use Jsonix.Marshaller */
+  interface Marshaller extends Jsonix.Marshaller {}
+  /** @deprecated use Jsonix.XML.QName */
+  interface QName extends Jsonix.XML.QName {
+    CLASS_NAME: string;
+  }
+  /** @deprecated use Jsonix.Styled */
+  interface Styled extends Jsonix.Styled {}
+  /** @deprecated use Jsonix.TypeInfo */
+  interface TypeInfo extends Jsonix.TypeInfo {}
+  /** @deprecated use Jsonix.EnumLeafInfo */
+  interface EnumLeafInfo extends Jsonix.EnumLeafInfo {}
+  /** @deprecated use Jsonix.PropertyInfo */
+  interface PropertyInfo extends Jsonix.PropertyInfo {}
+  /** @deprecated use Jsonix.AbstractElementPropertyInfo */
+  interface AbstractElementPropertyInfo extends Jsonix.AbstractElementPropertyInfo {}
+  /** @deprecated use Jsonix.ElementPropertyInfo */
+  interface ElementPropertyInfo extends Jsonix.ElementPropertyInfo {}
+  /** @deprecated use Jsonix.ClassInfo */
+  interface ClassInfo extends Jsonix.ClassInfo {}
+}