xml-toolkit 1.0.43 → 1.0.45

package/lib/XMLReader.js

@@ -91,9 +91,7 @@ const XMLReader = class extends Transform {
 			
 				this.off (THE_END, nope)
 				
-				if (e.type === SAXEvent.TYPES.END_DOCUMENT) return nope ()
-
-				const src = this [OPT_SRC]; if (src !== null) src.unpipe (this)
+				this [OPT_SRC].unpipe (this)
 				
 				ok (e)
 				
@@ -233,17 +231,7 @@ const XMLReader = class extends Transform {
 					this.publish (e, SAXEvent.TYPES.END_ELEMENT)
 
 				}
-				else {
-				
-					if (
-					
-						(this.element !== null && this.element.children !== null)
-					
-						||
-						
-						(this.collect !== null && this.collect (e))
-					
-					) e.children = []
+				else {			
 
 					this.element = e
 

package/lib/XMLSchema.js

@@ -3,27 +3,69 @@ const TYPES = Symbol ('_types')
 const FORM_U = 'unqualified'
 const FORM_Q =   'qualified'
 
+const adjustNode = node => {
+
+	node.children = node.children
+		.filter (i => i.localName !== 'annotation')
+		.map (node => adjustNode (node))
+
+	const {attributes, namespacesMap} = node, splitNs = name => {
+		
+		if (!attributes.has (name)) return
+		
+		const value = attributes.get (name), pos = value.indexOf (':')
+
+		attributes.set (name, [value.substring (pos + 1), namespacesMap.get (value.substring (0, pos))])
+
+	}
+
+	switch (node.localName) {
+
+		case 'attribute':
+		case 'element':
+		case 'group':
+			splitNs ('ref')
+			splitNs ('type')
+			break
+
+		case 'extension':
+		case 'restriction':
+			splitNs ('base')
+			break
+
+	}
+
+	return node
+
+}
+
 const XMLSchema = class extends Map {
 
-	constructor (parent, targetNamespace) {
+	static namespaceURI = 'http://www.w3.org/2001/XMLSchema'
+
+	constructor (parent, targetNamespace, node) {
 	
 		super ()
-	
-		this.parent = parent
-		
-		this.targetNamespace = targetNamespace
-		
+
 		this.formDefault = {}
-		
+
 		this [TYPES] = new Map ()
 
+		{(this.parent = parent).set (this.targetNamespace = targetNamespace, this)}
+
+		this.setSource (node)
+
 	}
 	
 	getType (localName) {
+
 		return this [TYPES].get (localName)
+
 	}
 
-	add (node, options = {}) {
+	setSource (node) {
+
+		node = adjustNode (node).detach ()
 			
 		const {attributes, children} = node
 		
@@ -50,18 +92,16 @@ const XMLSchema = class extends Map {
 		
 		}
 
+		this._src = node
+
 	}
 	
 	copyTargetNamespace (node, force = false) {
-
-		if (typeof node !== 'object') return		
 		
 		const {localName} = node
 		
 		for (const e of node.children) this.copyTargetNamespace (e, localName === 'schema')
 		
-		if ('targetNamespace' in node) return
-		
 		const {formDefault} = this; if (!(localName in formDefault)) return
 		
 		if (!force) {
@@ -76,50 +116,12 @@ const XMLSchema = class extends Map {
 	
 	}
 
-}
-
-XMLSchema.adjustNode = (node, recurse) => {
-
-	if (node.children) {
-	
-		node.children = node.children.filter (i => i.localName !== 'annotation')
-
-		if (recurse) node.children = node.children.map (node => XMLSchema.adjustNode (node, true))
-
-	}
-
-	const {attributes, namespacesMap} = node, splitNs = name => {
-		
-		if (!attributes.has (name)) return
-		
-		const v = attributes.get (name); if (Array.isArray (v)) return
-
-		const [local, prefix] = v.split (':').reverse ()
-		
-		attributes.set (name, [local, namespacesMap.get (prefix || '')])
-	
-	}
-
-	switch (node.localName) {
+	getSimpleTypeClass (node) {
 
-		case 'attribute':
-		case 'element':
-		case 'group':
-			splitNs ('ref')
-			splitNs ('type')
-			break
-
-		case 'extension':
-		case 'restriction':
-			splitNs ('base')
-			break
+		return this.parent.getSimpleTypeClass (node)
 
 	}
 
-	return node
-
 }
 
-XMLSchema.namespaceURI = 'http://www.w3.org/2001/XMLSchema'
-
 module.exports = XMLSchema

package/lib/XMLSchemaBuiltIn.js

@@ -0,0 +1,29 @@
+const fs = require ('fs')
+const path = require ('path')
+
+const XMLSchema = require ('./XMLSchema.js')
+const {XSSimpleType} = require ('./XSSimpleType.js')
+
+class XMLSchemaBuiltIn extends XMLSchema {
+
+	constructor (parent) {
+
+		const fn = path.join (__dirname, 'xsd.xsd')
+
+		const xml = fs.readFileSync (fn, 'utf-8')
+
+		const doc = parent.parser.process (xml)
+		
+		super (parent, XMLSchema.namespaceURI, doc) 
+
+	}
+
+	getSimpleTypeClass (node) {
+
+		return XSSimpleType.forName (node.attributes.name)
+
+	}
+
+}
+
+module.exports = XMLSchemaBuiltIn

package/lib/XMLSchemaXml.js

@@ -0,0 +1,24 @@
+const fs = require ('fs')
+const path = require ('path')
+
+const XMLSchema = require ('./XMLSchema.js')
+const NamespacesMap = require ('./NamespacesMap.js')
+const {XSSimpleType} = require ('./XSSimpleType.js')
+
+class XMLSchemaXml extends XMLSchema {
+
+	constructor (parent) {
+
+		const fn = path.join (__dirname, 'xml.xsd')
+
+		const xml = fs.readFileSync (fn, 'utf-8')
+
+		const doc = parent.parser.process (xml)
+		
+		super (parent, NamespacesMap.XMLNamespace, doc)
+
+	}
+
+}
+
+module.exports = XMLSchemaXml

package/lib/XMLSchemata.js

@@ -1,16 +1,15 @@
-const assert = require ('assert')
-
 const fs   = require ('fs')
 const path = require ('path')
 
+const NamespacesMap = require ('./NamespacesMap.js')
 const XMLParser = require ('./XMLParser.js')
-const XMLReader = require ('./XMLReader.js')
-const XMLNode   = require ('./XMLNode.js')
-const XMLSchema = require ('./XMLSchema.js'), {adjustNode} = XMLSchema
-const NamespacePrefixesMap = require ('./NamespacePrefixesMap.js')
-const {XMLNamespace, XMLSchemaNamespace} = require ('./NamespacesMap.js')
+const XMLSchema = require ('./XMLSchema.js')
+const XMLSchemaXml = require ('./XMLSchemaXml.js')
+const XMLSchemaBuiltIn = require ('./XMLSchemaBuiltIn.js')
 const XMLMarshaller = require ('./XMLMarshaller.js')
 
+const {XSSimpleType} = require ('./XSSimpleType.js')
+
 const IDX = Symbol ('_index')
 
 const XMLSchemata = class extends Map {
@@ -18,16 +17,17 @@ const XMLSchemata = class extends Map {
 	constructor (fn) {
 	
 		super ()
-		
-		this [IDX] = new Map ()
-		
+
 		this.documents = []
 		
-		if (fn) {
-			this.parser = new XMLParser ()
-			this.addFileSync (fn)
-			delete this.parser
-		}
+		this [IDX] = new Map ()
+
+		this.parser = new XMLParser ()
+
+		new XMLSchemaXml (this)
+		new XMLSchemaBuiltIn (this)
+
+		this.addFile (fn)
 
 	}
 	
@@ -40,23 +40,56 @@ const XMLSchemata = class extends Map {
 		idx.get (name).add (targetNamespace)
 	
 	}
+
+	getType ([localName, namespaceURI]) {
 	
-	getType (ref) {
+		const schema = this.get (namespaceURI); if (schema == null) throw new Error ('Unknown namespace: ' + namespaceURI)
 
-		const [localName, namespaceURI] = ref
+		const node = schema.getType (localName)
+
+		if (node.localName === 'simpleType' && !node._xsSimpleType) node._xsSimpleType = new (schema.getSimpleTypeClass (node)) (this)
+
+		return node
+
+	}
+
+	getSimpleType (node) {
+
+		if ('_xsSimpleType' in node) return node._xsSimpleType
+
+		return node._xsSimpleType = new (this.getSimpleTypeClass (node)) (this)
 
-		if (namespaceURI === XMLSchema.namespaceURI) return {
-			localName: 'simpleType',
-			namespaceURI,
-			attributes: {name: localName},
-			children: [],
-			namespacesMap: {},
-			targetNamespace: namespaceURI
-		}
+	}
+
+	getSimpleTypeClass (node) {
 		
-		const s = this.get (namespaceURI); if (s == null) throw new Error ('Unknown namespace: ' + namespaceURI)
+		for (const {localName, namespaceURI, attributes: {base}, children} of node.children)
 				
-		return s.getType (localName)
+			if (localName === 'restriction' && namespaceURI === XMLSchema.namespaceURI)
+
+				return this.getType (base)._xsSimpleType.restrict (children.map (
+
+					({localName, attributes: {value}}) => ({name: localName, value})
+
+				))
+
+		return XSSimpleType
+
+	}
+
+	getAttributeSimpleTypeClass ({children: [child]}) {
+
+		return this.getSimpleTypeClass (child) // annotations are filtered out
+
+	}
+
+	getAttributeSimpleType (node) {
+
+		if ('_xsSimpleType' in node) return node._xsSimpleType
+
+		const {attributes: {type}} = node; if (type) return node._xsSimpleType = this.getType (type)._xsSimpleType
+
+		return node._xsSimpleType = new (this.getAttributeSimpleTypeClass (node)) (this)
 
 	}
 
@@ -64,15 +97,6 @@ const XMLSchemata = class extends Map {
 
 		const [localName, namespaceURI] = ref
 		
-		if (namespaceURI === XMLNamespace) return {
-			localName: 'attribute',
-			namespaceURI,
-			attributes: {name: localName, type: ['string', XMLSchemaNamespace]},
-			children: [],
-			namespacesMap: {},
-			targetNamespace: namespaceURI
-		}
-
 		const s = this.get (namespaceURI); if (s == null) throw new Error ('Unknown namespace: ' + namespaceURI)
 				
 		return s.get (localName)
@@ -91,125 +115,65 @@ const XMLSchemata = class extends Map {
 	
 	}
 	
-	createMarshaller (localName, namespaceURI) {
+	createMarshaller (localName, namespaceURI, printerOptions) {
 	
 		if (arguments.length === 1) namespaceURI = this.getSchemaByLocalName (localName).targetNamespace
 		
-		return new XMLMarshaller (this, localName, namespaceURI)
+		return new XMLMarshaller (this, localName, namespaceURI, printerOptions)
 	
 	}
 	
 	stringify (data, o) {
-	
-		assert.strictEqual (typeof data, 'object')
-		
-		assert.strictEqual (Object.keys (data).length, 1)
-		
-		for (let [localName, content] of Object.entries (data)) 
-		
-			return this.createMarshaller (localName).stringify (content, o)
-	
-	}
-			
-	async addSchema (node, options = {}) {
 
-		let {targetNamespace} = node.attributes; if (!targetNamespace) targetNamespace = options.targetNamespace
+		if (data == null) throw Error ('Cannot stringify ' + data)
 
-		if (!this.has (targetNamespace)) this.set (targetNamespace, new XMLSchema (this, targetNamespace))
-		
-		const imp = node.children.filter (e => e.localName === 'import' && e.namespaceURI === XMLSchema.namespaceURI)
-		
-		if (imp.length !== 0) await Promise.all (imp.map (i => {
-		
-			const {schemaLocation, namespace} = i.attributes
-			
-			return options.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})
-			
-		}
+		if (typeof data !== 'object') throw Error ('Not an Object instance: ' + data)
 
-		const {targetNamespace} = options, mapper = n => n.detach ()
+		const entries = Object.entries (data), {length} = entries; if (length !== 1) throw Error ('The data object must have exactly 1 entry, found: ' + length)
 
-		for await (const node of 
-
-			new XMLReader ({
-				filterElements: e => e.namespaceURI === XMLSchema.namespaceURI,
-				map: adjustNode,
-			})
-			.process (fs.createReadStream (fn))
-
-		) 
-
-			if (node.localName === 'schema')
-			
-				await this.addSchema (mapper (node), {addLocation, targetNamespace})
+		const [[localName, content]] = entries; return this.createMarshaller (localName).stringify (content, o)
 	
 	}
 
-	addSchemaSync (node, options = {}) {
+	addFromNode (node, options) {
 	
-		if (node.localName !== 'schema' || node.namespaceURI !== XMLSchema.namespaceURI) {
-
-			const {children} = node; if (children) for (const i of children) this.addSchemaSync (i, options)
-				
-			return
+		if (node.localName === 'schema' && node.namespaceURI === XMLSchema.namespaceURI) return this.addSchema (node, options)
 			
-		}
-	
-		node = adjustNode (node, true).detach ()
+		for (const child of node.children) this.addFromNode (child, options)
 
-		let targetNamespace = node.attributes.targetNamespace || options.targetNamespace
-
-		if (targetNamespace && !this.has (targetNamespace)) this.set (targetNamespace, new XMLSchema (this, targetNamespace))
+	}
 
-		const {addLocation} = options; for (const {localName, namespaceURI, attributes} of node.children)
+	addSchema (node, options) {
 
-			if (localName === 'import' && namespaceURI === XMLSchema.namespaceURI)
+		const targetNamespace = node.attributes.get ('targetNamespace')
+		
+		const schema = new XMLSchema (this, targetNamespace, node)
+			
+		for (const {localName, namespaceURI, attributes: {schemaLocation, namespace}} of schema._src.children)
 
-				addLocation (attributes.schemaLocation, attributes.namespace)
+			if (localName === 'import' && namespaceURI === XMLSchema.namespaceURI && namespace !== NamespacesMap.XMLNamespace)
 
-		if (targetNamespace) this.get (targetNamespace).add (node)
+				this.addFile (path.join (options.dirname, schemaLocation), {targetNamespace: namespace})
 
 	}
 
-	addFileSync (fn, options = {}) {
-
-		const dirname = path.dirname (fn), that = this
-
-		options.addLocation = function (schemaLocation, namespace) {
-
-			that.addFileSync (path.join (dirname, schemaLocation), {targetNamespace: namespace})
+	addFile (fn, options = {}) {
 
-		}
+		options.dirname = path.dirname (fn)
 
 		const document = this.parser.process (fs.readFileSync (fn, 'utf-8'))
 
 		this.documents.push (document)
 
-		this.addSchemaSync (document, options)
+		this.addFromNode (document, options)
 
 	}
 
-}
+	static async fromFile (fn) {
 
-XMLSchemata.fromFile = async function (fn, options = {}) {
+		return new XMLSchemata (fn)
 
-	let xs = new XMLSchemata ()
-	
-	await xs.addFile (fn, options)
-	
-	return xs
+	}
 
 }