xml-toolkit 0.0.8 → 1.0.2

package/lib/XMLSchema.js

@@ -0,0 +1,103 @@
+const XMLSchema = class extends Map {
+
+	constructor (parent, targetNamespace) {
+	
+		super ()
+	
+		this.parent = parent
+		this.targetNamespace = targetNamespace
+		
+		this.isDefaultElementFormQualified   = true
+		this.isAttributeElementFormQualified = false
+
+	}
+
+	add (node, options = {}) {
+
+		if (node.elementFormDefault === 'unqualified') this.isDefaultElementFormQualified = false
+		if (node.attributeFormDefault === 'qualified') this.isAttributeElementFormQualified = true
+
+		for (const type of [
+
+			'element',
+			'complexType',
+			'simpleType',
+
+		]) if (type in node) {
+
+			let list = node [type]
+
+			if (!Array.isArray (list)) list = [list]
+
+			for (const item of list) {
+			
+				delete item.annotation
+				
+				item._type = type
+				
+				this.copyTargetNamespace (item)				
+
+				this.set (item.name, item)
+				
+				this.parent.register (item.name, this.targetNamespace)
+				
+			}
+
+		}
+
+	}
+	
+	copyTargetNamespace (o) {
+
+		if (typeof o !== 'object') return		
+
+		if (Array.isArray (o)) {
+
+			for (const v of o) this.copyTargetNamespace (v)
+
+		}
+		else {
+
+			o.targetNamespace = this.targetNamespace
+			
+			for (const v of Object.values (o)) this.copyTargetNamespace (v)
+
+		}
+	
+	}
+
+}
+
+XMLSchema.adjustNode = node => {
+
+	if (node.children) node.children = node.children.filter (i => i.localName !== 'annotation')
+	
+	const {attributes, namespacesMap} = node, splitNs = name => {
+		
+		if (!attributes.has (name)) return
+	
+		const [local, prefix] = attributes.get (name).split (':').reverse ()
+		
+		attributes.set (name, [local, namespacesMap.get (prefix)])
+	
+	}
+
+	switch (node.localName) {
+
+		case 'attribute':
+		case 'element':
+			splitNs ('type')
+			break
+
+		case 'extension':
+		case 'restriction':
+			splitNs ('base')
+			break
+
+	}
+
+	return node
+
+}
+
+module.exports = XMLSchema

package/lib/XMLSchemata.js

@@ -0,0 +1,143 @@
+const assert = require ('assert')
+
+const fs   = require ('fs')
+const path = require ('path')
+
+const XMLReader = require ('./XMLReader.js')
+const XMLNode   = require ('./XMLNode.js')
+const XMLSchema = require ('./XMLSchema.js'), {adjustNode} = XMLSchema
+const NamespacePrefixesMap = require ('./NamespacePrefixesMap.js')
+const XMLMarshaller = require ('./XMLMarshaller.js')
+
+const IDX = Symbol ('_index')
+
+const XMLSchemata = class extends Map {
+
+	constructor () {
+	
+		super ()
+		
+		this [IDX] = new Map ()
+	
+	}
+	
+	register (name, targetNamespace) {
+	
+		const idx = this [IDX]
+		
+		if (!idx.has (name)) idx.set (name, new Set ())
+		
+		idx.get (name).add (targetNamespace)
+	
+	}
+	
+	getByReference (ref) {
+
+		const [localName, namespaceURI] = ref
+		
+		if (namespaceURI === 'http://www.w3.org/2001/XMLSchema') return {
+			_type: 'simpleType',
+			name: localName
+		}
+		
+		return this.get (namespaceURI).get (localName)
+
+	}
+	
+	getSchemaByLocalName (localName) {
+	
+		const ns = this [IDX].get (localName)
+		
+		if (!ns) throw new Error ('Unknown name: ' + localName)
+
+		if (ns.size !== 1) throw new Error ('Ambiguous name ' + localName + ' belongs to: ' + Array.from (ns.values ()).map (s => `"${s}"`).join (', '))
+
+		for (const uri of ns) return this.get (uri)
+	
+	}
+
+	getNamespacePrefixesMap (o) {
+	
+		return new NamespacePrefixesMap (this, o)
+	
+	}
+	
+	createMarshaller (localName, namespaceURI) {
+	
+		if (arguments.length === 1) namespaceURI = this.getSchemaByLocalName (localName).targetNamespace
+		
+		return new XMLMarshaller (this, localName, namespaceURI)
+	
+	}
+	
+	stringify (o) {
+	
+		assert.strictEqual (typeof o, 'object')
+		
+		assert.strictEqual (Object.keys (o).length, 1)
+		
+		for (let [localName, content] of Object.entries (o)) 
+		
+			return this.createMarshaller (localName).stringify (content)
+	
+	}
+			
+	async addSchema (node, options = {}) {
+	
+		let {targetNamespace} = node; if (!targetNamespace) targetNamespace = options.targetNamespace
+
+		if (!this.has (targetNamespace)) this.set (targetNamespace, new XMLSchema (this, targetNamespace))
+		
+		let imp = node.import; if (imp) {
+		
+			const {addLocation} = options
+		
+			if (!Array.isArray (imp)) imp = [imp]
+			
+			for (const {schemaLocation, namespace} of imp) await addLocation (schemaLocation, namespace)
+		
+		}
+
+		this.get (targetNamespace).add (node)
+
+	}
+	
+	async addFile (fn, options = {}) {
+			
+		const dirname = path.dirname (fn), that = this, addLocation = async function (schemaLocation, namespace) {
+			
+			await that.addFile (path.join (dirname, schemaLocation), options = {targetNamespace: namespace})
+			
+		}
+
+		const {targetNamespace} = options, mapper = XMLNode.toObject ({})
+
+		for await (const node of 
+
+			new XMLReader ({
+				filterElements: e => e.namespaceURI === 'http://www.w3.org/2001/XMLSchema',
+				map: adjustNode,
+			})
+			.process (fs.createReadStream (fn))
+
+		) 
+
+			if (node.localName === 'schema')
+			
+				await this.addSchema (mapper (node), {addLocation, targetNamespace})
+	
+	}
+
+}
+
+XMLSchemata.fromFile = async function (fn, options = {}) {
+
+	let xs = new XMLSchemata ()
+	
+	await xs.addFile (fn, options)
+	
+	return xs
+
+}
+
+module.exports = XMLSchemata

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "xml-toolkit",
-  "version": "0.0.8",
+  "version": "1.0.2",
   "description": "Collection of classes for dealing with XML",
   "main": "index.js",
   "scripts": {
-    "test": "node test/test.js" 
+    "test": "node test/test.js"
   },
   "repository": {
     "type": "git",
@@ -20,5 +20,8 @@
   "bugs": {
     "url": "https://github.com/do-/node-xml-toolkit/issues"
   },
-  "homepage": "https://github.com/do-/node-xml-toolkit#readme"
+  "homepage": "https://github.com/do-/node-xml-toolkit#readme",
+  "dependencies": {
+    "string-escape-map": "^1.0.0"
+  }
 }