xml-toolkit 1.0.7 → 1.0.10

package/lib/NamespacePrefixesMap.js

@@ -2,53 +2,33 @@ const assert = require ('assert')
 
 const NamespacePrefixesMap = class extends Map {
 
-	constructor (schemata, o) {
+	constructor (schemata) {
 	
-		assert.strictEqual (typeof o, 'object')
-
 		super ()
 		
-		this.schemata = schemata
+		for (const uri of schemata.keys ()) 
 		
-		this.add (o)
+			this.set (uri, 'ns' + this.size)
 		
 	}
-	
-	add (o) {
 
-		if (this.isAddedAsNamespaceReference (o)) return
-		
-		for (let v of Object.values (o)) if (typeof v === 'object') this.add (v)
-	
-	}
-	
-	isAddedAsNamespaceReference (a) {
+	QName (localName, namespaceURI) {
 
-		if (!Array.isArray (a)) return false
-		
-		if (a.length !== 2) return false
-		
-		const uri = a [1]
-		
-		if (!this.schemata.has (uri)) return false
+		if (namespaceURI == null) return localName
+
+		assert (this.has (namespaceURI), 'Unknown target namespace: ' + namespaceURI)
 
-		if (this.has (uri)) return true
-		
-		this.set (uri, 'ns' + this.size)
-		
-	}
-	
-	QName (localName, namespaceURI) {
-	
-		if (namespaceURI == null || !this.has (namespaceURI)) return localName
-		
 		return this.get (namespaceURI) + ':' + localName
 	
 	}
 
-	appendTo (buf) {
+	toString () {
+	
+		let s = ''
 
-		for (let [k, v] of this.entries ()) buf [0] += ' xmlns:' + v + '="' + k + '"'
+		for (let [k, v] of this.entries ()) s += ' xmlns:' + v + '="' + k + '"'
+		
+		return s
 
 	}
 

package/lib/XMLMarshaller.js

@@ -1,5 +1,6 @@
 const assert       = require ('assert')
 const stringEscape = require ('string-escape-map')
+const NamespacePrefixesMap = require ('./NamespacePrefixesMap.js')
 
 let esc = [
   ['<', '&lt;'],
@@ -33,152 +34,184 @@ const XMLMarshaller = class {
 
 		this.schemaElement = this.schema.get (localName); assert (this.schemaElement, 'No schema element found for namespaceURI = ' + namespaceURI + ', localName = ' + localName)
 
-		this.ns = this.xs.getNamespacePrefixesMap (this.schemaElement)
+		this.ns = new NamespacePrefixesMap (xs)
+		
+		this.isNsDumped = false
+		
+		this.qNames = []
 
 	}
 	
-	stringify (content, name) {
-								
-		const qName = this.ns.QName (name || this.schemaElement.name, this.schema.targetNamespace)
+	stringify (data, name) {
 
-		let {complexType, sequence, choice, all, type} = this.schemaElement, group = sequence || choice || all
+		const {schemaElement} = this, {targetNamespace, attributes, children} = schemaElement
 
-		if (type) {
+		this.buf = ''
 
-			type = this.xs.getByReference (type)
+		this.appendElement (schemaElement, data, this.ns.QName (name || attributes.name, targetNamespace))
 
-			switch (type._type) {
+		let xml = this.buf
 
-				case 'complexType':
-					complexType = type
-					break
+		delete this.buf
 
-				case 'simpleType':
-					simpleType = type
-					break
+		return xml
 
-			}
+	}	
+	
+	appendElement (node, data, qName) {
 
-		}
+		this.appendStartTag (node, data, qName)
+		
+		this.appendElementBody (node, data)
+		
+		this.appendEndTag ()
 
-		let buf = ['<' + qName]
+	}
+	
+	appendStartTag (node, data, qName) {
+	
+		this.qNames.push (qName)
+	
+		this.buf += '<' + qName
 		
-		this.ns.appendTo (buf)
+		if (!this.isNsDumped) {
 		
-		if (complexType) this._aComplexType (buf, complexType, content)
+			this.buf += this.ns
+		
+			this.isNsDumped = true
 
-		buf [0] += '>'
+		}
 
-		if (complexType) this._bComplexType (buf, complexType, content)
-		if (group)       this._bSequence    (buf, group, content)
+		this.appendAttributes (node, data)
 
-		return buf [0] + '</' + qName + '>'
+		this.buf += '>'
 
-	}	
+	}
+
+	appendEndTag () {
+
+		this.buf += '</' + this.qNames.pop () + '>'
+
+	}
+
+	appendNullElement (node) {
 	
-	/// _a: attributes
+		const {attributes: {name, nillable}, targetNamespace} = node
 	
-	_aComplexType (buf, complexType, content) {
+		if (BOOL.get (nillable) !== 'true') return
 		
-		const {complexContent, attribute} = complexType
+		const qName = this.ns.QName (name, targetNamespace)
 
-		if (attribute) 		
-			for (const e of Array.isArray (attribute) ? attribute : [attribute])		
-				this._aAttribute (buf, e, content [e.name])
-		
-		if (complexContent) this._aComplexContent (buf, complexContent, content)
-	
-	}	
-	
-	_aComplexContent (buf, complexContent, content) {
-			
-		const {extension} = complexContent
+		this.buf += `<${qName} xsi:nil="true" />`
 
-		if (extension) this._aExtension (buf, extension, content)
-		
 	}
 	
-	_aExtension (buf, extension, content) {
+	appendScalar (node, data, restriction = {}) {
 		
-		const {base, attribute} = extension
+		for (const {localName, attributes, children} of node.children) {
 
-		if (base) {
-		
-			const [localName, namespaceURI] = base
-		
-			const schema = this.xs.get (namespaceURI)
-		
-			const type = schema.get (localName)
+			if (localName === 'restriction') {
+			
+				for (const {localName, attributes: {value}} of children) restriction [localName] = value
+			
+				return this.appendScalar (this.xs.getByReference (attributes.base), data, restriction)
+				
+			}
 			
-			if (type._type === 'complexType') this._aComplexType (buf, type, content)
-					
 		}
 
-		if (attribute) 		
-			for (const a of Array.isArray (attribute) ? attribute : [attribute])		
-				this._aAttribute (buf, a, content [a.name])
+		this.buf += this.to_string (data, node.attributes.name, restriction)
 
-	}	
+	}
 	
-	_aAttribute (buf, attribute, content) {
+	appendElementBody (node, data) {
 
-		if (content == null) return
+		const {attributes: {type}, children} = node
 
-		let {name, targetNamespace, simpleType, type} = attribute
-		
-		if (type) {
+		if (type) return this.appendContent (this.xs.getByReference (type), data)
 
-			type = this.xs.getByReference (type)
+		for (const i of children) this.appendContent (i, data)
 
-			switch (type._type) {
+	}
 
-				case 'simpleType':
-					simpleType = type
-					break
+	appendAttributes (node, data) {
 
-			}
+		const {localName, namespaceURI, attributes, children, targetNamespace} = node, {name, type, ref} = attributes
 
-		}
+		if (ref) return this.appendAttributes (this.xs.getByReference (ref), data)
+	
+		switch (localName) {
 
-		const qName = this.ns.QName (name, targetNamespace)
-		
-		buf [0] += ' ' + qName + '="'
-			
-		if (simpleType)  this._bSimpleType  (buf, simpleType, content)
+			case 'attribute':
+
+				if (!(name in data)) return
+
+				let v = data [name]; if (v == null) return 
+				
+				this.buf += ' ' + this.ns.QName (name, targetNamespace) + '="'
+								
+				this.appendScalar (this.xs.getByReference (type), v)
+
+				this.buf += '"'
+				
+				break
+				
+			case 'extension':
 			
-		buf [0] += '"'
+				this.appendAttributes (this.xs.getByReference (attributes.base), data)
+
+			case 'any':
+			case 'sequence':
+			case 'choice':
+			case 'group':
+			case 'simpleType':
 			
-	}	
-	
-	/// _b: body	
-	
-	_bComplexType (buf, complexType, content) {
+				return
 
-		const {complexContent, sequence, choice, all} = complexType, group = sequence || choice || all
+			default:
 
-		if (group)          this._bSequence       (buf, group, content)
-		if (complexContent) this._bComplexContent (buf, complexContent, content)
+				for (const i of children) this.appendAttributes (i, data)
+				
+		}
 	
 	}
+	
+	appendContent (node, data) {
 
-	_bSimpleType (buf, simpleType, content, _restriction = {}) {
+		const {localName, namespaceURI, attributes, children, targetNamespace} = node, {name, type, ref} = attributes
 	
-		let {restriction} = simpleType; if (restriction) {
+		if (ref) return this.appendContent (this.xs.getByReference (ref), data)
 
-			for (const [k, v] of Object.entries (_restriction)) switch (k) {				
-				case 'base': case 'targetNamespace': break
-				default: restriction [k] = v
-			}
+		switch (localName) {
+
+			case 'simpleType':
+
+				return this.appendScalar (node, data)
 			
-			this._bSimpleType (buf, this.xs.getByReference (restriction.base), content, restriction)
+			case 'element':
 
-		}
-		else {
+				if (!(name in data)) return
+			
+				let v = data [name]; if (v == null) return this.appendNullElement (node)
+
+				const qName = this.ns.QName (name, targetNamespace)
+				
+				if (!Array.isArray (v)) return this.appendElement (node, v, qName)
+				
+				for (const d of v) this.appendElement (node, d, qName)
 
-			buf [0] += this.to_string (content, simpleType.name, _restriction)
+				break
+				
+			case 'extension':
+			
+				this.appendContent (this.xs.getByReference (attributes.base), data)
+				
+			default:
 
+				for (const i of children) this.appendContent (i, data)
+				
 		}
-	
+
 	}
 	
 	to_string (v, type, restriction = {}) {
@@ -277,125 +310,6 @@ const XMLMarshaller = class {
 	
 	}
 	
-	_bComplexContent (buf, complexContent, content) {
-			
-		const {extension} = complexContent
-
-		if (extension) this._bExtension (buf, extension, content)
-		
-	}
-	
-	_bExtension (buf, _extension, content) {
-		
-		const {base, sequence, choice, all} = _extension, group = sequence || choice || all
-
-		if (base) {
-		
-			const [localName, namespaceURI] = base
-		
-			const schema = this.xs.get (namespaceURI)
-		
-			const type = schema.get (localName)
-			
-			if (type._type === 'complexType') this._bComplexType (buf, type, content)
-					
-		}
-
-		if (group) this._bSequence (buf, group, content)
-
-	}
-
-	_bSequence (buf, _sequence, content) {
-
-		const {element, sequence, choice, all, group} = _sequence, g = sequence || choice || all
-
-		if (g) this._bSequence (buf, g, content)
-
-		if (element) {
-
-			for (let e of Array.isArray (element) ? element : [element]) {
-
-				const {ref} = e; if (ref) e = this.xs.getByReference (ref)
-
-				const c = content [e.name]
-
-				this._bElement (buf, e, c)
-				
-			}
-				
-		}
-		
-		if (group) {
-
-			for (let e of Array.isArray (group) ? group : [group]) {
-
-				const {ref} = e; if (ref) e = this.xs.getByReference (ref)
-
-				this._bSequence (buf, e, content)
-				
-			}
-				
-		}
-
-	}
-	
-	_bElement_null (buf, element) {
-	
-		if (BOOL.get (element.nillable) !== 'true') return
-		
-		const {name, targetNamespace} = element, qName = this.ns.QName (name, targetNamespace)
-
-		buf [0] += `<${qName} xsi:nil="true" />`
-
-	}
-	
-	_bElement (buf, element, content) {
-
-		if (content == null) return this._bElement_null (buf, element)
-		
-		if (!Array.isArray (content)) content = [content]
-		
-		if (content.length === 0) return
-
-		let {name, targetNamespace, complexType, simpleType, type} = element
-		
-		if (type) {
-
-			type = this.xs.getByReference (type)
-
-			switch (type._type) {
-
-				case 'complexType':
-					complexType = type
-					break
-
-				case 'simpleType':
-					simpleType = type
-					break
-
-			}
-
-		}
-
-		const qName = this.ns.QName (name, targetNamespace)
-		
-		for (const i of content) {
-		
-			buf [0] += '<' + qName
-
-			if (complexType) this._aComplexType (buf, complexType, content)
-			
-			buf [0] += '>'
-			
-			if (complexType) this._bComplexType (buf, complexType, i)
-			if (simpleType)  this._bSimpleType  (buf, simpleType, i)
-			
-			buf [0] += '</' + qName + '>'
-
-		}
-			
-	}
-
 }
 
 module.exports = XMLMarshaller

package/lib/XMLNode.js

@@ -10,6 +10,10 @@ const PARENT     = Symbol ('_parent')
 const LEVEL      = Symbol ('_level')
 const NS_MAP     = Symbol ('_ns_map')
 
+const m2o = 
+	Object.fromEntries ? m => Object.fromEntries (m.entries ()) :
+	m => {let o = {}; for (const [k, v] of m.entries ()) o [k] = v; return o}
+
 const XMLNode = class extends SAXEvent {
 
 	constructor (src, xmlReader, _type) {
@@ -132,6 +136,33 @@ const XMLNode = class extends SAXEvent {
 
 	}
 
+	detach (o = {}) {
+	
+		switch (this.type) {
+
+			case SAXEvent.TYPES.CHARACTERS:
+			case SAXEvent.TYPES.CDATA:
+				return this.text
+				
+			default:
+
+				const {localName, namespaceURI, attributes, children, namespacesMap} = this
+				
+				let r = {
+					localName,
+					namespaceURI,
+					attributes    : m2o (attributes),
+					children      : (children || []).map (n => n.detach (o)),
+				}
+
+				if (o.nsMap) r.namespacesMap = m2o (namespacesMap || [])
+
+				return r
+
+		}
+
+	}
+
 }
 
 XMLNode.getLocalName = name => {

package/lib/XMLSchema.js

@@ -13,57 +13,33 @@ const XMLSchema = class extends Map {
 	}
 
 	add (node, options = {}) {
+		
+		this.copyTargetNamespace (node)
+	
+		const {attributes, children} = node
 
-		if (node.elementFormDefault === 'unqualified') this.isDefaultElementFormQualified = false
-		if (node.attributeFormDefault === 'qualified') this.isAttributeElementFormQualified = true
-
-		for (const type of [
-
-			'element',
-			'complexType',
-			'simpleType',
-			'group',
-
-		]) if (type in node) {
-
-			let list = node [type]
-
-			if (!Array.isArray (list)) list = [list]
+		if (attributes.elementFormDefault === 'unqualified') this.isDefaultElementFormQualified = false
+		if (attributes.attributeFormDefault === 'qualified') this.isAttributeElementFormQualified = true
+		
+		for (const e of children) {
+		
+			const {name} = e.attributes
 
-			for (const item of list) {
+			this.set (name, e)
 			
-				delete item.annotation
-				
-				item._type = type
-				
-				this.copyTargetNamespace (item)				
-
-				this.set (item.name, item)
-				
-				this.parent.register (item.name, this.targetNamespace)
-				
-			}
-
+			this.parent.register (name, this.targetNamespace)
+		
 		}
 
 	}
 	
-	copyTargetNamespace (o) {
-
-		if (typeof o !== 'object') return		
+	copyTargetNamespace (node) {
 
-		if (Array.isArray (o)) {
+		if (typeof node !== 'object') return		
 
-			for (const v of o) this.copyTargetNamespace (v)
-
-		}
-		else {
-
-			o.targetNamespace = this.targetNamespace
+		node.targetNamespace = this.targetNamespace
 			
-			for (const v of Object.values (o)) this.copyTargetNamespace (v)
-
-		}
+		for (const e of node.children) this.copyTargetNamespace (e)
 	
 	}
 
@@ -103,4 +79,6 @@ XMLSchema.adjustNode = node => {
 
 }
 
+XMLSchema.namespaceURI = 'http://www.w3.org/2001/XMLSchema'
+
 module.exports = XMLSchema

package/lib/XMLSchemata.js

@@ -35,9 +35,13 @@ const XMLSchemata = class extends Map {
 
 		const [localName, namespaceURI] = ref
 		
-		if (namespaceURI === 'http://www.w3.org/2001/XMLSchema') return {
-			_type: 'simpleType',
-			name: localName
+		if (namespaceURI === XMLSchema.namespaceURI) return {
+			localName: 'simpleType',
+			namespaceURI,
+			attributes: {name: localName},
+			children: [],
+			namespacesMap: {},
+			targetNamespace: namespaceURI
 		}
 		
 		return this.get (namespaceURI).get (localName)
@@ -55,12 +59,6 @@ const XMLSchemata = class extends Map {
 		for (const uri of ns) return this.get (uri)
 	
 	}
-
-	getNamespacePrefixesMap (o) {
-	
-		return new NamespacePrefixesMap (this, o)
-	
-	}
 	
 	createMarshaller (localName, namespaceURI) {
 	
@@ -83,21 +81,21 @@ const XMLSchemata = class extends Map {
 	}
 			
 	async addSchema (node, options = {}) {
-	
-		let {targetNamespace} = node; if (!targetNamespace) targetNamespace = options.targetNamespace
+
+		let {targetNamespace} = node.attributes; if (!targetNamespace) targetNamespace = options.targetNamespace
 
 		if (!this.has (targetNamespace)) this.set (targetNamespace, new XMLSchema (this, targetNamespace))
 		
-		let imp = node.import; if (imp) {
+		const imp = node.children.filter (e => e.localName === 'import' && e.namespaceURI === XMLSchema.namespaceURI)
 		
-			const {addLocation} = options
+		if (imp.length !== 0) await Promise.all (imp.map (i => {
 		
-			if (!Array.isArray (imp)) imp = [imp]
+			const {schemaLocation, namespace} = i.attributes
 			
-			for (const {schemaLocation, namespace} of imp) await addLocation (schemaLocation, namespace)
+			return options.addLocation (schemaLocation, namespace)
+		
+		}))		
 		
-		}
-
 		this.get (targetNamespace).add (node)
 
 	}
@@ -110,12 +108,12 @@ const XMLSchemata = class extends Map {
 			
 		}
 
-		const {targetNamespace} = options, mapper = XMLNode.toObject ({})
+		const {targetNamespace} = options, mapper = n => n.detach ()
 
 		for await (const node of 
 
 			new XMLReader ({
-				filterElements: e => e.namespaceURI === 'http://www.w3.org/2001/XMLSchema',
+				filterElements: e => e.namespaceURI === XMLSchema.namespaceURI,
 				map: adjustNode,
 			})
 			.process (fs.createReadStream (fn))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-toolkit",
-  "version": "1.0.7",
+  "version": "1.0.10",
   "description": "Collection of classes for dealing with XML",
   "main": "index.js",
   "scripts": {

package/test/test.js

@@ -59,12 +59,15 @@ console.log (xml)
 
 	const sax = new XMLReader ({
 //		stripSpace: true,
+//		filterElements: 'root',		
+//		filterElements: 'PARAMTYPES'
 		filterElements: 'SendRequestRequest',
-		map: XMLNode.toObject ({
+		map: n => n.detach ({nsMap: true}),
+//		map: XMLNode.toObject ({
 //			wrap: 1,
-			getName: (localName, namespaceURI) => (!namespaceURI ? '' : '{' + namespaceURI + '}') + localName,
-			map: o => Object.fromEntries (Object.entries (o).map (([k, v]) => [k + '111', v]))
-		})
+//			getName: (localName, namespaceURI) => (!namespaceURI ? '' : '{' + namespaceURI + '}') + localName,
+//			map: o => Object.fromEntries (Object.entries (o).map (([k, v]) => [k + '111', v]))
+//		})
 	})
 
 /*
@@ -111,7 +114,12 @@ async function test_004_schemata (fn) {
 	const o = s.get (localName)
 	
 	const nspm = xs.getNamespacePrefixesMap (o)
-*/	
+
+	console.log (xs.stringify ({
+  		"ExportDebtRequestsRequest": {Id: 1}	
+	}))
+*/
+	
 	console.log (xs.stringify ({
   "ExportDebtRequestsResponse": {	
     "request-data": {
@@ -208,6 +216,12 @@ async function test_004_schemata (fn) {
 	console.log (xs.get ('urn:dom.gosuslugi.ru/debt-requests/1.0.0').get ('ActionType').restriction)
 */
  
+	console.log (xs.stringify ({
+  		"ExportDebtRequestsRequest": {Id: 1}	
+	})) 
+
+//	console.log (xs.get ('urn:dom.gosuslugi.ru/debt-responses/1.0.0').get ('AttachmentType')) 
+ 
 }
 
 async function test_005_schemata (fn) {
@@ -315,7 +329,7 @@ async function main () {
 //	await test_003_emitter_sync ('E05a.xml')
 //	await test_003_emitter_sync ('param_types.xml')
 //	await test_003_emitter_sync ('not-sa01.xml')
-//	await test_003_emitter_sync ('ent.xml')
+// 	await test_003_emitter_sync ('ent.xml')
 //	await test_003_emitter_sync ('soap.xml')
 	await test_004_schemata ()
 	await test_005_schemata ()