xml-toolkit 1.0.60 → 1.1.0

package/lib/validation/XMLValidationState.js

@@ -0,0 +1,169 @@
+class XMLValidationState {
+
+	#child = null
+	#hadText = false
+
+	constructor (parent, parsedNode, elementDefinition) {
+
+		this.xs = (this.parent = parent).xs
+		this.parsedNode = parsedNode
+		
+		try {
+
+			this.setTypeFrom (elementDefinition)
+
+		}
+		catch (cause) {
+
+			throw Error (`Validation problem with ${parsedNode.src} at position ${this.getPosition ()}: ${cause.message}`, {cause})
+
+		}
+
+	}
+
+	get getPosition () {
+		
+		return this.parent.getPosition 
+	
+	}
+
+	setTypeFrom (element) {
+
+		const {xs} = this
+
+		const typeDefinition = xs.getTypeDefinition (element)
+
+		this.anyType = xs.getAnyType (typeDefinition)
+
+		this.validateAttributes (this.parsedNode.attributes)
+
+		const {content} = this.anyType; if (content) this.match = content.createMatch ()
+
+	}
+
+	blameNothingExpected () {
+
+		throw Error (`No nested elements allowed inside ${this.parsedNode.src}`)
+
+	}
+
+	blameUnexpectedTag (parsedNode, match) {
+
+		const expected = match.allExpected (parsedNode); if (expected == null) this.blameNothingExpected ()
+
+		const {src} = parsedNode, {length} = src
+
+		throw Error (`Unexpected ${src} at position ${BigInt (this.getPosition ()) - BigInt (length)}, expected: ${expected}`)
+
+	}
+
+	startElement (parsedNode) {
+
+		if (this.#child !== null) return this.#child.startElement (parsedNode)
+
+		const {match} = this; if (!match) throw Error (`No nested elements allowed inside ${this.anyType.debugQName}`)
+
+		const element = match.getElementDefinition (parsedNode); if (!element) this.blameUnexpectedTag (parsedNode, match)
+
+		if (element.localName === 'any') return
+
+		this.#child = new XMLValidationState (this, parsedNode, element)
+
+	}
+
+	endElement (parsedNode) {
+
+		if (this.#child === null) {
+
+			if (!this.#hadText) this.characters ('')
+
+			const {match} = this; if (match && !match.isSatisfied) this.blameUnexpectedTag (parsedNode, match)
+			
+			return null
+
+		}
+
+		this.#child = this.#child.endElement (parsedNode)
+
+		return this
+
+	}
+
+	characters (text) {
+
+		if (this.#child !== null) return this.#child.characters (text)
+
+		this.#hadText = true
+
+		try {
+
+			this.anyType.asSimpleType ().validateScalar (text)
+
+		}
+		catch (cause) {
+			
+			throw Error (`Validation problem with the contents of <${this.parsedNode.name}...> at position ${this.getPosition ()}: ${cause.message}`, {cause})
+
+		}
+
+	}
+
+	validateAttributes (attributesMap) {
+
+		const {attributes, isAnyAttributeAllowed} = this.anyType
+
+		for (const [name, value] of attributesMap) {
+
+			if (!attributes.has (name)) {
+
+				if (isAnyAttributeAllowed) continue
+
+				throw Error (`Unknown attribute: "${name}"`)
+
+			}
+			
+			const def = attributes.get (name), {attributes: {fixed, type}} = def
+
+			if (typeof fixed === 'string' && value !== fixed) throw Error (`The attribute "${name}" must have the value "${fixed}", not "${value}"`)
+
+			const validateBy = typeNode => {
+
+				try {
+
+					this.xs.getSimpleType (typeNode).validateScalar (value)
+
+				}
+				catch (cause) {
+
+					throw Error (`attribute '${name}": ${cause.message}`, {cause})
+
+				}
+
+			}
+
+			if (type) {
+
+				validateBy (this.xs.getType (type))
+
+			}
+			else {
+
+				for (const node of def.children) validateBy (node)
+
+			}
+
+		}
+
+		for (const [name, def] of attributes) if (!attributesMap.has (name)) {
+
+			if (def.attributes.use === 'required') throw Error (`Missing required attribute: "${name}"`)
+
+			if ('default' in def.attributes) attributesMap.set (name, def.attributes.default)
+
+		}
+
+	}
+
+}
+
+module.exports = XMLValidationState

package/lib/validation/XMLValidatior.js

@@ -0,0 +1,38 @@
+const XMLValidationState = require ('./XMLValidationState')
+
+class XMLValidatior {
+
+	#state = null
+
+	constructor (xs, rootNode, getPosition) {
+
+		this.xs = xs
+		this.getPosition = getPosition
+
+		this.startElement (rootNode)
+
+	}
+
+	startElement (parsedNode) {
+
+		if (this.#state === null) return this.#state = new XMLValidationState (this, parsedNode, this.xs.getSchema (parsedNode.namespaceURI).getElement (parsedNode.localName))
+
+		this.#state.startElement (parsedNode)
+
+	}
+
+	characters (text) {
+
+		this.#state.characters (text)
+
+	}
+
+	endElement (parsedNode) {
+
+		this.#state.endElement (parsedNode)
+
+	}
+
+}
+
+module.exports = XMLValidatior

package/lib/xml.xsd

@@ -6,7 +6,7 @@
    <xs:union memberTypes="xs:language">
     <xs:simpleType>    
      <xs:restriction base="xs:string">
-      <xs:enumeration value=""/>
+      <xs:enumeration value="en"/>
      </xs:restriction>
     </xs:simpleType>
    </xs:union>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xml-toolkit",
-  "version": "1.0.60",
+  "version": "1.1.0",
   "description": "XML parser, marshaller, SOAP adapter",
   "main": "index.js",
   "files": [

package/lib/XSSimpleType.js

@@ -1,329 +0,0 @@
-const NamespacePrefixesMap = require ('./NamespacePrefixesMap.js')
-
-class XSSimpleType {
-
-	constructor (xs) {
-
-		this.xs = xs
-		this.patterns = []
-		this.fractionDigits = Infinity
-
-	}
-
-	blame (value) {
-
-		let s; try {
-
-			s = JSON.stringify (value)
-
-		}
-		catch (x) {
-
-			s = String (value)
-
-		}
-
-		throw Error (`Cannot stringify ${typeof value} ${s}`)
-
-	}
-
-	stringify (value) {
-
-		if (value == null) this.blame (value)
-
-		for (const s of this.strings (value)) if (this.test (s)) return s
-
-		this.blame (value)
-
-	}
-
-	* strings (value) {
-
-		yield String (value)
-
-	}
-
-	test (s) {
-
-		const {patterns} = this; if (patterns.length === 0) return true
-
-		for (const pattern of patterns) if (pattern.test (s)) return true
-
-		return false
-
-	}
-
-	restrict (entries) {
-
-		return class extends this.constructor {
-
-			constructor (xs) {
-
-				super (xs)
-
-				for (const {name, value} of entries) switch (name) {
-
-					case 'pattern':
-						this.patterns.push (new RegExp (value))
-						break
-
-					case 'fractionDigits':
-						this.fractionDigits = parseInt (value)
-						break
-
-				}
-
-			}
-
-		}
-
-	}
-
-}
-
-class XSSimpleTypeQName extends XSSimpleType {
-
-	stringify (value) {
-
-		if (typeof value !== 'object' || !('localName' in value)) this.blame (value)
-
-		const {xs} = this
-
-		if (!xs.ns) xs.ns = new NamespacePrefixesMap (xs)
-
-		return xs.ns.QName (value.localName, value.namespaceURI)
-
-	}
-			
-}
-
-class XSSimpleTypeFloat extends XSSimpleType {
-
-	stringify (value) {
-
-		if (isNaN (value)) this.blame (value)
-
-		return (
-			value ===  Infinity ?  'INF' : 
-			value === -Infinity ? '-INF' : 
-			super.stringify (value)
-		)
-
-	}
-
-}
-
-class XSSimpleTypeDecimal extends XSSimpleType {
-
-	isValidNumber (num) {
-
-		return !Number.isNaN (num)
-
-	}
-
-	stringify (value) {
-
-		let num = value
-
-		const {fractionDigits} = this
-
-		switch (typeof value) {
-
-			case 'bigint':
-				return fractionDigits === 0 || fractionDigits === Infinity ? 
-					String (value) : 
-					`${value}.${'0'.repeat (fractionDigits)}`
-
-			case 'string':
-				num = parseFloat (value)	
-
-			case 'number':
-				if (!this.isValidNumber (num)) this.blame (value)
-				return fractionDigits === Infinity ? 
-					num.toString () : 
-					num.toFixed (this.fractionDigits)
-
-			default: 
-				this.blame (value)
-
-		}
-
-	}
-
-}
-
-class XSSimpleTypeInteger extends XSSimpleTypeDecimal {
-
-	constructor (xs) {
-
-		super (xs)
-
-		this.fractionDigits = 0
-
-	}
-
-	isValidNumber (num) {
-
-		return Number.isInteger (num)
-
-	}
-
-}
-
-class XSSimpleTypeBoolean extends XSSimpleType {
-
-	static toCanonical (value) {
-
-		switch (typeof value) {
-
-			case 'boolean': return value
-
-			case 'number':
-				switch (value) {
-					case 0: return false
-					case 1: return true
-					default: return null
-				}
-
-			case 'string':
-
-				switch (value) {
-
-					case '0':
-					case 'false':
-						return false
-
-					case '1':
-					case 'true':
-						return true
-
-					default: 
-						return null
-
-				}
-				
-		}
-
-	}
-
-	* strings (value) {
-
-		const c = XSSimpleTypeBoolean.toCanonical (value); if (c !== null) {
-
-			if (c) {
-				yield 'true'
-				yield '1'
-			}
-			else {
-				yield 'false'
-				yield '0'
-			}
-
-		}
-
-	}
-
-}
-
-class XSSimpleTypeDT extends XSSimpleType {
-
-	adjust (value) {
-
-		return typeof value === 'string' ? value : new Date (value).toJSON ()
-
-	}
-
-}
-
-class XSSimpleTypeDate extends XSSimpleTypeDT {
-
-	* strings (value) {
-
-		value = this.adjust (value)
-
-		const ymd = value.substring (0, 10)
-
-		const {length} = value; if (length > 10) {
-
-			const pos = value.indexOf ('Z')
-
-			if (pos !== -1 && pos !== length - 1) yield ymd + value.substring (pos)
-
-		}
-
-		yield ymd
-
-	}
-
-}
-
-class XSSimpleTypeDateTime extends XSSimpleTypeDT {
-
-	adjust (value) {
-
-		value = super.adjust (value)
-
-		return value.length === 10 ? value + 'T00:00:00' : value
-
-	}
-
-	* strings (value) {
-
-		value = this.adjust (value)
-
-		yield value
-
-		if (value.length > 19) yield value.substring (0, 19)
-		
-	}
-
-}
-
-XSSimpleType.forName = name => {
-
-	switch (name) {
-
-		case 'QName'   : return XSSimpleTypeQName
-
-		case 'boolean' : return XSSimpleTypeBoolean
-
-		case 'date'    : return XSSimpleTypeDate
-
-		case 'dateTime': return XSSimpleTypeDateTime
-
-		case 'decimal' : return XSSimpleTypeDecimal
-
-		case 'float'   :
-		case 'double'  :
-						 return XSSimpleTypeFloat
-
-		case 'byte':
-		case 'int':
-		case 'integer':
-		case 'long':
-		case 'negativeInteger':
-		case 'nonNegativeInteger':
-		case 'nonPositiveInteger':
-		case 'positiveInteger':
-		case 'short':
-		case 'unsignedByte':
-		case 'unsignedInt':
-		case 'unsignedLong':
-		case 'unsignedShort':
-						return XSSimpleTypeInteger
-
-		default        : return XSSimpleType
-	}
-
-}
-
-module.exports = {
-	XSSimpleType,
-	XSSimpleTypeFloat,
-	XSSimpleTypeBoolean,
-	XSSimpleTypeDate,
-	XSSimpleTypeDateTime,
-	XSSimpleTypeDecimal,
-	XSSimpleTypeQName,
-	XSSimpleTypeInteger,
-}