xml-toolkit 1.1.3 → 1.1.5

package/index.js

@@ -31,6 +31,7 @@ module.exports = {
 	XMLSchema:           require ('./lib/XMLSchema'),
 	XMLSchemaBuiltIn:    require ('./lib/XMLSchemaBuiltIn'),
 	XMLSchemata:         require ('./lib/XMLSchemata'),
+	XMLMessages:         require ('./lib/XMLMessages'),
 	XSSimpleType,
 	XSSimpleTypeFloat,
 	XSSimpleTypeDouble,

package/lib/XMLIterator.js

@@ -1,18 +1,19 @@
 const XMLNode  = require ('./XMLNode.js')
 const SAXEvent = require ('./SAXEvent.js')
 const EntityResolver = require ('./EntityResolver.js')
-
-const CH_LF = '\n'.charCodeAt (0)
+const XMLPosition = require ('./XMLPosition.js')
 
 const XMLIterator = class {
 
+	#position = new XMLPosition ()
+
 	constructor (src, options = {}) {
 	
-		this.src          = src
-		this.options      = options
-		this.pos          = 0
-		this.selfEnclosed = null
-		this.entityResolver = options.entityResolver ?? new EntityResolver ()
+		this.src              = src
+		this.options          = options
+		this.absolutePosition = 0
+		this.selfEnclosed     = null
+		this.entityResolver   = options.entityResolver ?? new EntityResolver ()
 
 	}
 	
@@ -32,23 +33,9 @@ const XMLIterator = class {
 
 	}
 
-	get linePos () {
-
-		const {pos} = this
-
-		let l = 1, c = -1
+	get position () {
 
-		for (let i = pos; i >= 0; i --) {
-
-			if (this.src.charCodeAt (i) !== CH_LF) continue
-
-			l ++; if (c !== -1) continue
-
-			c = pos - i
-
-		}
-
-		return [l, c]
+		return this.#position
 
 	}
 
@@ -56,18 +43,24 @@ const XMLIterator = class {
 	
 		if (this.selfEnclosed !== null) return this.autoClose ()
 	
-		const {src, pos, entityResolver} = this
+		const {src, absolutePosition, entityResolver} = this
 
-		if (src.length - pos < 1) return {done: true}
+		if (src.length - absolutePosition < 1) return {done: true}
 		
-		const value = new XMLNode (src.slice (pos), entityResolver)
+		const value = new XMLNode (src.slice (absolutePosition), entityResolver)
 
 		value.trim ()
-		
-		const {length} = value.src; if (length === 0) return {done: true}
 
-		this.pos += length
+		{
+
+			const {src} = value, {length} = src; if (length === 0) return {done: true}
 
+			this.absolutePosition += length
+
+			this.#position.scan (src)
+
+		}
+		
 		if (value.isStartElement && value.isSelfEnclosed) this.selfEnclosed = value
 
 		return {value}

package/lib/XMLLexer.js

@@ -1,6 +1,7 @@
 const assert      = require ('assert')
 const {Transform} = require ('stream')
 const {StringDecoder} = require('string_decoder')
+const XMLPosition   = require ('./XMLPosition.js')
 
 const ST_TEXT  = 0
 const ST_LT	   = 1
@@ -23,6 +24,8 @@ const S_ENCODING = Symbol ('encoding')
 
 const XMLLexer = class extends Transform {
 
+	#position = new XMLPosition ()
+
 	constructor (options = {}) {
 
 		options.readableObjectMode = true
@@ -51,6 +54,12 @@ const XMLLexer = class extends Transform {
 
 	}
 
+	get position () {
+
+		return this.#position
+
+	}
+
 	isClosing (pos) {
 
 		const {awaited, body} = this, {length} = awaited; if (length === 0) return true
@@ -74,7 +83,7 @@ const XMLLexer = class extends Transform {
 
 			default:
 				assert (awaited === null, 'not ST_TAG[_X]: awaited must be null')
-				this.position = 0
+				this.xPosition = 0
 				break
 
 		}
@@ -155,7 +164,7 @@ const XMLLexer = class extends Transform {
 								
 							default:
 								this.setState (ST_TAG_X, CL_DEAFULT)
-								this.position = pos
+								this.xPosition = pos
 								break
 						
 						}
@@ -182,7 +191,7 @@ const XMLLexer = class extends Transform {
 				
 				case ST_TAG_X:
 				
-					for (let pos = this.position + 1; pos < body.length; pos ++) {
+					for (let pos = this.xPosition + 1; pos < body.length; pos ++) {
 
 						switch (body.charCodeAt (pos)) {
 						
@@ -196,7 +205,7 @@ const XMLLexer = class extends Transform {
 										
 								}
 								
-								this.position = pos
+								this.xPosition = pos
 								break
 
 							case CH_GT:
@@ -210,9 +219,6 @@ const XMLLexer = class extends Transform {
 					}
 					
 					return
-
-				default:
-					throw new Error ('Invalid state: ' + this.state)
 					
 			}
 
@@ -226,7 +232,11 @@ const XMLLexer = class extends Transform {
 
 		this.start = pos
 		
-		if (lexeme.length !== 0) this.push (lexeme)
+		if (lexeme.length === 0) return
+			
+		this.#position.scan (lexeme)
+
+		this.push (lexeme)
 
 	}
 
@@ -237,24 +247,16 @@ const XMLLexer = class extends Transform {
 		callback ()
 
 	}
-	
-	getPosition () {
-	
-		let {beforeBody, start} = this
 		
-		return beforeBody + BigInt (start)
-	
-	}
-	
 	checkMaxLength () {
 	
 		const {body, maxLength} = this, size = body.length - this.start; 
 		
 		if (size <= maxLength) return
 
-		const s = body.slice (0, size - 1), dump = JSON.stringify ([s])
+		this.#position.scan (body.slice (0, size - 1))
 
-		this.destroy (new Error (`The fragment ${dump} at position ${this.getPosition ()} exceeds maxLength=${maxLength}`))
+		this.destroy (new Error (this.position.format (['XML-00001', maxLength])))
 	
 	}
 	

package/lib/XMLMessages.js

@@ -0,0 +1,57 @@
+const util = require ('node:util')
+
+const VOCABULARY = new Map ([
+
+	['XML-00001', 'maxLength=%i exceeded'],
+	['XML-00002', 'Unbalanced end element'],
+	['XML-00003', 'Unmatched end element, </${%s}> expected'],
+
+	['XVC-00001', 'No nested elements allowed inside %s'],
+	['XVC-00002', 'is unexpected here; should be %s'],
+	['XVC-00003', 'Unknown attribute: %s'],
+	['XVC-00004', 'The attribute "%s" must have the value "%s", not "%s"'],
+	['XVC-00005', 'Missing required attribute: "%s"'],
+
+	['XVS-00001', `The value "%s" doesn't match the pattern %s`],
+	['XVS-00002', `The value "%s" doesn't match any of the patterns: %s`],
+	['XVS-00003', `The value '%s' is not in list: %s`],
+	['XVS-00004', `The value '%s' has the length %i, which exceeds the allowed maximum of %i`],
+	['XVS-00005', `The value '%s' has the length %i, which is less than the allowed minimum of %i`],
+	['XVS-00006', `The value '%s' has the length %i, must be exaclty %i`],
+	['XVS-00007', `The value '%s' is less than the least allowed '%s'`],
+	['XVS-00008', `The value '%s' is greater than the greatest allowed '%s'`],
+	['XVS-00009', `The value '%s' is less or equal than the threshold '%s'`],
+	['XVS-00010', `The value '%s' is greater or equal than the threshold '%s'`],
+	['XVS-00011', `No boolean value can be empty`],
+	['XVS-00012', `'%s' is not a boolean value`],
+	['XVS-00013', `No decimal value can be empty`],
+	['XVS-00014', `'%s' is not a valid decimal: '%s' can occur only at the beginning`],
+	['XVS-00015', `'%s' is not a valid decimal: 2nd period occured at position %i`],
+	['XVS-00016', `'%s' is not a valid decimal: '%s' occured at position %i`],
+	['XVS-00017', `'%s' is not a valid decimal: is has no digits at all`],
+	['XVS-00018', `'%s' has %i digits, only %i allowed`],
+	['XVS-00019', `'%s' has  %i digits after period, only %i allowed`],
+	['XVS-00020', `No floating point number can be empty`],
+	['XVS-00021', `'%s' is not a floating point number`],
+	['XVS-00022', `For a date value, the time part cannot be present, but '%s' contains it`],
+	['XVS-00023', `For a dateTime value, the time part is mandatory, missing from '%s'`],
+	['XVS-00024', `For a dateTimeStamp value, both time and timezone parts are mandatory, missing from '%s'`],
+	['XVS-00025', `The year separator is not found in '%s'`],
+
+])
+
+class XMLMessages {
+
+	static VOCABULARY = VOCABULARY
+
+	static format (args) {
+
+		args [0] = VOCABULARY.get (args [0])
+
+		return util.format.apply (util, args)
+
+	}
+	
+}
+
+module.exports = XMLMessages

package/lib/XMLParser.js

@@ -84,7 +84,7 @@ const XMLParser = class {
 					this.element = node
 					if (this.document === null) {
 						this.document = node
-						if (this.xs !== null) this.validator = new XMLValidatior (this.xs, node, () => nodes.linePos)
+						if (this.xs !== null) this.validator = new XMLValidatior (this.xs, node, nodes.position)
 					}
 					else {
 						if (this.xs !== null) this.validator.startElement (node)
@@ -93,7 +93,8 @@ const XMLParser = class {
 
 				case SAXEvent.TYPES.END_ELEMENT:
 
-					if (this.element === null) throw new Error (`Unbalanced end element tag "${node.src}" occured at position ${nodes.pos}`)
+					if (this.element === null)          throw new Error (nodes.position.format (['XML-00002']))
+					if (this.element.name != node.name) throw new Error (nodes.position.format (['XML-00003', this.element.name]))
 					node ['_ns_map'] = this.element ['_ns_map']
 					this.element.type = type
 					this.element = this.element.parent

package/lib/XMLPosition.js

@@ -0,0 +1,83 @@
+const CH_LF = '\n'.charCodeAt (0)
+const CH_SPACE = ' '.charCodeAt (0)
+const MAX_LEN_TOTAL = 50
+const STR_ELLIPSIS  = '...'
+const MAX_LEN = MAX_LEN_TOTAL - STR_ELLIPSIS.length
+
+const XMLMessages = require ('./XMLMessages')
+
+class XMLPosition {
+
+	#line = 0
+	#localPosition = 0
+	#lastLine = 0
+	#lastLocalPosition = 0
+	#chunk
+
+	scan (chunk) {
+
+		this.#lastLine = this.#line
+		this.#lastLocalPosition = this.#localPosition
+		this.#chunk = chunk
+
+		for (let i = 0; i < chunk.length; i ++) switch (chunk.charCodeAt (i)) {
+
+			case CH_LF:
+				this.#line ++
+				this.#localPosition = 0
+				break
+
+			default:
+				this.#localPosition ++
+
+		}
+
+	}
+
+	get line () {
+
+		return this.#lastLine + 1
+
+	}
+
+	get position () {
+
+		return this.#lastLocalPosition + 1
+
+	}
+
+	get chunk () {
+
+		const {length} = this.#chunk; if (length <= MAX_LEN) return this.#chunk
+
+		return this.#chunk.substr (0, MAX_LEN) + STR_ELLIPSIS
+
+	}
+
+	get src () {
+
+		const b = Buffer.from (this.chunk)
+
+		for (let i = 0; i < b.length; i ++) if (b [i] < CH_SPACE) b [i] = CH_SPACE
+
+		return ' `' + b + '`'
+
+	}
+
+	toString () {
+
+		const {line, position, src} = this		
+
+		return `[${line}:${position}]${src} `
+
+	}
+
+	format (args) {
+
+		return this.toString () + XMLMessages.format (args)
+
+	}
+	
+}
+
+module.exports = XMLPosition

package/lib/XMLReader.js

@@ -1,8 +1,8 @@
-const assert      = require ('assert')
-const {Transform} = require ('stream')
-const SAXEvent    = require ('./SAXEvent.js')
-const XMLNode     = require ('./XMLNode.js')
-const XMLLexer    = require ('./XMLLexer.js')
+const assert        = require ('assert')
+const {Transform}   = require ('stream')
+const SAXEvent      = require ('./SAXEvent.js')
+const XMLNode       = require ('./XMLNode.js')
+const XMLLexer      = require ('./XMLLexer.js')
 const XMLValidatior = require ('./validation/XMLValidatior.js')
 
 const OPT_SRC  = Symbol ('_src')
@@ -10,8 +10,6 @@ const OPT_SAX  = Symbol ('_sax')
 
 const NO_CHILDREN = []; NO_CHILDREN.push = () => {}
 
-const CH_LF = '\n'.charCodeAt (0)
-
 const XMLReader = class extends Transform {
 
 	constructor (options = {}) {
@@ -70,16 +68,11 @@ const XMLReader = class extends Transform {
 		this.useNamespaces = options.useNamespaces
 		this.filter        = filter || null
 		this.map           = map || null
-		
-		this.lineNo = 1
-		this.lineStart = 0
-
+	
 		if (this.useEntities) this.entityResolver = new (require ('./EntityResolver.js')) ()
 		
 		this.text = ''
 		this.element = null
-		this.position = 0
-		this.pos = 0 // TODO: cleanup
 		
 		this [OPT_SRC] = null; this.on ('pipe', src => this [OPT_SRC] = src)
 		
@@ -154,7 +147,7 @@ const XMLReader = class extends Transform {
 		if (!this.validator) switch (xmlNode.type) {
 
 			case SAXEvent.TYPES.START_ELEMENT:									
-				this.validator = new XMLValidatior (this.xs, xmlNode, () => this.linePos)
+				this.validator = new XMLValidatior (this.xs, xmlNode, this.lex.position)
 
 			default:
 				return
@@ -250,28 +243,10 @@ const XMLReader = class extends Transform {
 
 	}
 
-	get linePos () {
-
-		return [this.lineNo, this.pos - this.lineStart]
-
-	}
-
 	_transform (chunk, encoding, callback) {
 
 		const {length} = chunk; if (length !== 0) {
 
-			for (let i = 0; i < length; i ++) {
-
-				this.pos ++
-
-				if (chunk.charCodeAt (i) !== CH_LF) continue
-
-				this.lineNo ++
-
-				this.lineStart = this.pos
-
-			}
-
 			let e = new XMLNode (chunk, this.entityResolver), {type} = e, {element} = this
 
 			switch (type) {
@@ -294,10 +269,12 @@ const XMLReader = class extends Transform {
 			}
 
 			switch (type) {
-							
+
 				case SAXEvent.TYPES.END_ELEMENT:
 
-					if (element === null) return callback (new Error (`Unbalanced end element tag "${chunk}" occured at position ${this.position}`))
+					if (element === null)       return callback (new Error (this.lex.position.format (['XML-00002'])))
+
+					if (e.name != element.name) return callback (new Error (this.lex.position.format (['XML-00003', this.element.name])))
 
 					e = element
 
@@ -334,8 +311,6 @@ const XMLReader = class extends Transform {
 
 			}
 
-			this.position += length
-
 		}		
 
 		callback ()

package/lib/XMLSchemata.js

@@ -7,6 +7,7 @@ const XMLSchema = require ('./XMLSchema.js')
 const XMLSchemaXml = require ('./XMLSchemaXml.js')
 const XMLSchemaBuiltIn = require ('./XMLSchemaBuiltIn.js')
 const XMLMarshaller = require ('./XMLMarshaller.js')
+const XMLMessages = require ('./XMLMessages.js')
 
 const XSAnyType = require ('./XSAnyType.js')
 const {XSSimpleType} = require ('./simple/XSSimpleType.js')
@@ -117,24 +118,19 @@ const XMLSchemata = class extends Map {
 
 				}
 
-				validateScalar (v) {
+				test (v) {
 
-					const messages = []; for (const node of this.nodes) {
+					let message = ''; for (const node of this.nodes) {
 
-						try {
+						const result = this.xs.getSimpleType (node).test (v); if (!result) return null
 
-							return this.xs.getSimpleType (node).validateScalar (v)
+						if (message.length !== 0) message += '; '
 
-						}
-						catch (err) {
-
-							messages.push (err.message)
-
-						}
+						message += XMLMessages.format (result)
 
 					}
 
-					throw Error (messages.join ('; '))
+					return message					
 
 				}
 

package/lib/simple/DT7.js

@@ -9,13 +9,23 @@ const CH_9      = '9'.charCodeAt (0)
 
 const tzCache = new Set (['Z', '+14:00', '-14:00'])
 
+const die = payload => {
+
+	const err = Error ('DT7 error')
+
+	err.payload = payload
+
+	throw err
+
+}
+
 class DT7 {
 	
 	constructor (src) {
 
 		const t = typeof src; if (t !== 'string') throw Error (`The Seven-property Date Time Model can only be constructed from a string, not a(n) ${t}`)
 
-		const {length} = src; if (length < MIN_LENGTH) throw Error (`${length} chars found, at least ${MIN_LENGTH} required`)
+		const {length} = src; if (length < MIN_LENGTH) die (['XVS-00005', src, length, MIN_LENGTH])
 
 		this.src = src
 
@@ -28,8 +38,8 @@ class DT7 {
 
 		this.posMonth = this.src.indexOf ('-', 1)
 
-		if (this.posMonth === -1) throw Error (`The year separator is not found`)
-
+		if (this.posMonth === -1) die (['XVS-00025', this.src])
+		
 		if (this.posMonth < 3) throw Error (`'${this.year}' is not a valid year: cannot be shorter than 4 characters`)
 
 		if (this.src.charCodeAt (this.posDay) !== CH_MINUS) throw Error (`The character at ${this.posDay} must be '-', not '${this.src.charAt (this.posDay)}'`)

package/lib/simple/XSSimpleType.js

@@ -1,3 +1,5 @@
+const XMLMessages = require ('../XMLMessages')
+
 class XSSimpleType {
 
 	constructor (xs) {
@@ -51,7 +53,7 @@ class XSSimpleType {
 
 			const result = this.test (s); if (result === null) return s
 						
-			reasons.push (result)
+			reasons.push (XMLMessages.format (result))
 
 		}
 
@@ -95,30 +97,54 @@ class XSSimpleType {
 
 		let ordered = undefined
 
-		if (this.minInclusive != null && (ordered   = this.toOrdered (value)) <  this.minInclusive) throw Error (`The value '${value}' is less than allowed '${this.minInclusive}'`)
+		{
 
-		if (this.maxInclusive != null && (ordered ??= this.toOrdered (value)) >  this.maxInclusive) throw Error (`The value '${value}' is greater than allowed '${this.maxInclusive}'`)
+			const {minInclusive} = this; if (minInclusive != null && (ordered   = this.toOrdered (value)) <  minInclusive) return ['XVS-00007', value, minInclusive]
 			
-		if (this.minExclusive != null && (ordered ??= this.toOrdered (value)) <= this.minExclusive) throw Error (`The value '${value}' is less or equal than the threshold '${this.minExclusive}'`)
+		}
+
+		{
+
+			const {maxInclusive} = this; if (maxInclusive != null && (ordered ??= this.toOrdered (value)) > maxInclusive) return ['XVS-00008', value, maxInclusive]
+			
+		}
+
+		{
 
-		if (this.maxExclusive != null && (ordered ??= this.toOrdered (value)) >= this.maxExclusive) throw Error (`The value '${value}' is greater or equal than the threshold '${this.maxExclusive}'`)
+			const {minExclusive} = this; if (minExclusive != null && (ordered ??= this.toOrdered (value)) <= minExclusive) return ['XVS-00009', value, minExclusive]
+			
+		}
+
+		{
+
+			const {maxExclusive} = this; if (maxExclusive != null && (ordered ??= this.toOrdered (value)) >= maxExclusive) return ['XVS-00010', value, maxExclusive]
+			
+		}
 
 	}
 
 	testLength (value) {
 
-		const l = this.getLength (value), {length} = this
+		const l = this.getLength (value), {length, units} = this
 
 		if (length === null) {
 
-			if (l > this.maxLength) return `The value '${value}' is ${l} ${this.units} long, which exceeds the allowed maximum of ${this.maxLength}`
+			{
 
-			if (l < this.minLength) return `The value '${value}' is ${l} ${this.units} long, which is less than the allowed minimum of ${this.minLength}`
+				const {maxLength} = this; if (l > maxLength) return ['XVS-00004', value, l, maxLength]
+
+			}
+
+			{
+
+				const {minLength} = this; if (l < minLength) return ['XVS-00005', value, l, minLength]
+
+			}
 
 		}
 		else {
 
-			if (l !== length) return `The value '${value}' is ${l} ${this.units} long, must be exaclty ${length}`
+			if (l !== length) return ['XVS-00006', value, l, length]
 
 		}
 
@@ -136,7 +162,7 @@ class XSSimpleType {
 
 		const {values} = this; if (values.includes (s)) return null
 
-		return `The value '${s}' is not in list: ${JSON.stringify (values)}`
+		return ['XVS-00003', JSON.stringify (values)]
 
 	}
 
@@ -146,17 +172,7 @@ class XSSimpleType {
 
 		for (const pattern of patterns) if (pattern.test (s)) return null
 
-		if (length === 1) return `The value '${s}' doesn't match the pattern '${patterns [0]}'`
-
-		return `The value '${s}' doesn't match any of the patterns: ${patterns.map (_ => '' + _).join (', ')}`
-
-	}
-
-	validateScalar (s) {
-
-		const result = this.test (s ?? '')
-
-		if (result) throw Error (result)			
+		return [length === 1 ? 'XVS-00001' : 'XVS-00002', s, patterns.join (', ')]
 
 	}
 

package/lib/simple/XSSimpleTypeBoolean.js

@@ -57,13 +57,13 @@ class XSSimpleTypeBoolean extends XSSimpleType {
 
 	testLength (value) {
 
-		return value.length === 0 ? 'No boolean value can be empty' : null
+		return value.length === 0 ? ['XVS-00011'] : null		
 
 	}
 
 	testFormat (value) {
 
-		if (this.toOrdered (value) === undefined) return `'${value}' is not a boolean value`
+		if (this.toOrdered (value) === undefined) return ['XVS-00012', value]
 
 		return null
 

package/lib/simple/XSSimpleTypeDT.js

@@ -33,9 +33,20 @@ class XSSimpleTypeDate extends XSSimpleTypeDT {
 
 	testFormat (s) {
 
-		const dt7 = new DT7 (s)
+		try {
+
+			const dt7 = new DT7 (s)
+
+			if (dt7.hour !== undefined) return ['XVS-00022', s]
+			
+		}
+		catch (err) {
 
-		if (dt7.hour !== undefined) return `For a date value, the time part cannot be present`
+			if ('payload' in err) return err.payload
+
+			throw err
+
+		}
 
 	}
 
@@ -55,7 +66,7 @@ class XSSimpleTypeDateTime extends XSSimpleTypeDT {
 
 		const dt7 = new DT7 (s)
 
-		if (dt7.hour === undefined) return `For a dateTime value, the time part is mandatory`
+		if (dt7.hour === undefined) return ['XVS-00023', s]
 
 	}
 
@@ -77,7 +88,7 @@ class XSSimpleTypeDateTimeStamp extends XSSimpleTypeDateTime {
 
 		const dt7 = new DT7 (s)
 
-		if (dt7.hour === undefined || dt7.tz === undefined) return `For a dateTimeStamp value, both time and timezone parts are mandatory`
+		if (dt7.hour === undefined || dt7.tz === undefined) return ['XVS-00024', s]
 
 	}
 

package/lib/simple/XSSimpleTypeDecimal.js

@@ -53,7 +53,7 @@ class XSSimpleTypeDecimal extends XSSimpleType {
 
 	testLength (value) {
 
-		return value.length === 0 ? 'No decimal value can be empty' : null
+		return value.length === 0 ? ['XVS-00013'] : null
 
 	}
 
@@ -67,16 +67,16 @@ class XSSimpleTypeDecimal extends XSSimpleType {
 
 				case CH_PLUS:
 				case CH_MINUS:
-					if (i !== 0) return `'${value}' is not a valid decimal: '${value.charAt (i)}' can occur only at the beginning`
+					if (i !== 0) return ['XVS-00014', value, value.charAt (i)]
 					continue
 
 				case CH_PERIOD:
-					if (period !== -1) return `'${value}' is not a valid decimal: 2nd period occured at position ${i}`
+					if (period !== -1) return ['XVS-00015', value, i]
 					period = i
 					continue
 
 				default:
-					if (c < CH_0 || c > CH_9) return `'${value}' is not a valid decimal: '${value.charAt (i)}' occured at position ${i}`
+					if (c < CH_0 || c > CH_9) return ['XVS-00016', value, value.charAt (i), i]
 					total ++
 					if (period !== -1) fraction ++
 
@@ -84,13 +84,19 @@ class XSSimpleTypeDecimal extends XSSimpleType {
 
 		}
 		
-		if (total === 0) return `'${value}' is not a valid decimal: is has no digits at all`
+		if (total === 0) return ['XVS-00017', value]
 
-		const {totalDigits, fractionDigits} = this
+		{
 
-		if (total > totalDigits) return `'${value}' has ${total} digits, only ${totalDigits} allowed`
+			const {totalDigits} = this; if (total > totalDigits) return ['XVS-00018', value, total, totalDigits]
 
-		if (fraction > fractionDigits) return `'${value}' has ${fraction} digits after period, only ${fractionDigits} allowed`
+		}
+
+		{
+
+			const {fractionDigits} = this; if (fraction > fractionDigits) return ['XVS-00019', value, fraction, fractionDigits]
+
+		}
 
 		return null
 

package/lib/simple/XSSimpleTypeFloatingPoint.js

@@ -32,13 +32,13 @@ class XSSimpleTypeFloatingPoint extends XSSimpleType {
 
 	testLength (value) {
 
-		return value.length === 0 ? 'No floating point number can be empty' : null
+		return value.length === 0 ? ['XVS-00020'] : null
 
 	}
 
 	testFormat (value) {
 
-		if (Number.isNaN (this.toOrdered (value)) && value !== 'NaN') return `'${value}' is not a floating point number`
+		if (Number.isNaN (this.toOrdered (value)) && value !== 'NaN') return ['XVS-00021', value]
 
 		return null
 

package/lib/validation/XMLValidationState.js

@@ -1,4 +1,5 @@
 const {XSINamespace} = require ('../NamespacesMap')
+const XMLMessages = require ('../XMLMessages')
 
 class XMLValidationState {
 
@@ -17,16 +18,16 @@ class XMLValidationState {
 		}
 		catch (cause) {
 
-			throw Error (`Validation problem with ${this.formatPosition (parsedNode)}: ${cause.message}`, {cause})
+			this.warn (cause.message)
 
 		}
 
 	}
 
-	get getPosition () {
-		
-		return this.parent.getPosition 
-	
+	warn (message, cause) {
+
+		this.parent.warn (message, cause)
+
 	}
 
 	setTypeFrom (element) {
@@ -45,15 +46,7 @@ class XMLValidationState {
 
 	blameNothingExpected () {
 
-		throw Error (`No nested elements allowed inside ${this.parsedNode.src}`)
-
-	}
-
-	formatPosition ({src}) {
-
-		const [line, char] = this.getPosition ()
-
-		return `${src} at line ${line}, position ${char}`
+		this.warn (['XVC-00001', this.parsedNode.src])
 
 	}
 
@@ -61,7 +54,7 @@ class XMLValidationState {
 
 		const expected = match.allExpected (parsedNode); if (expected == null) this.blameNothingExpected ()
 
-		throw Error (`Unexpected ${this.formatPosition (parsedNode)}, expected: ${expected}`)
+		this.warn (['XVC-00002', expected])
 
 	}
 
@@ -69,7 +62,7 @@ class XMLValidationState {
 
 		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 {match} = this; if (!match) this.warn (['XVC-00001', this.anyType.debugQName])
 
 		const element = match.getElementDefinition (parsedNode); if (!element) this.blameUnexpectedTag (parsedNode, match)
 
@@ -103,16 +96,15 @@ class XMLValidationState {
 
 		this.#hadText = true
 
-		try {
+		this.validateScalar (text, this.anyType.asSimpleType ())
 
-			this.anyType.asSimpleType ().validateScalar (text)
+	}
 
-		}
-		catch (cause) {
+	validateScalar (value, type) {
 
-			throw Error (`Validation problem with the contents of ${this.formatPosition (this.parsedNode)}: ${cause.message}`, {cause})
+		const result = type.test (value ?? '')
 
-		}
+		if (result) this.warn (result)
 
 	}
 
@@ -154,7 +146,7 @@ class XMLValidationState {
 
 				if (attributesMap.getNamespaceURI (name) === XSINamespace) continue
 
-				throw Error (`Unknown attribute: "${name}"`)
+				this.warn (['XVC-00003', name])
 
 			}
 
@@ -162,31 +154,18 @@ class XMLValidationState {
 
 			const {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 (typeof fixed === 'string' && value !== fixed) this.warn (['XVC-00004', name, fixed, value])
 
 			if (type) {
 
-				validateBy (this.xs.getType (type))
+				this.validateScalar (value, this.xs.getSimpleType (this.xs.getType (type)))
 
 			}
 			else {
 
-				for (const node of def.children) validateBy (node)
+				for (const node of def.children)
+
+					this.validateScalar (value, this.xs.getSimpleType (node))
 
 			}
 
@@ -194,7 +173,7 @@ class XMLValidationState {
 
 		for (const [name, def] of attributes) if (!matched.has (def)) {
 
-			if (def.attributes.use === 'required') throw Error (`Missing required attribute: "${name}"`)
+			if (def.attributes.use === 'required') this.warn (['XVC-00005', name])
 
 			if ('default' in def.attributes) attributesMap.set (name, def.attributes.default)
 

package/lib/validation/XMLValidatior.js

@@ -4,15 +4,23 @@ class XMLValidatior {
 
 	#state = null
 
-	constructor (xs, rootNode, getPosition) {
+	constructor (xs, rootNode, position) {
 
 		this.xs = xs
-		this.getPosition = getPosition
+		this.position = position
 
 		this.startElement (rootNode)
 
 	}
 
+	warn (message) {
+
+		const {position} = this
+
+		throw Error (Array.isArray (message) ? position.format (message) : this.position + message)
+
+	}
+
 	startElement (parsedNode) {
 
 		if (this.#state === null) return this.#state = new XMLValidationState (this, parsedNode, this.xs.getSchema (parsedNode.namespaceURI).getElement (parsedNode.localName))

package/package.json

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