xml-toolkit 1.0.61 → 1.1.0

package/lib/simple/XSSimpleTypeDecimal.js

@@ -0,0 +1,130 @@
+const {XSSimpleType} = require ('./XSSimpleType.js')
+
+const CH_PLUS   = '+'.charCodeAt (0)
+const CH_MINUS  = '-'.charCodeAt (0)
+const CH_PERIOD = '.'.charCodeAt (0)
+const CH_0      = '0'.charCodeAt (0)
+const CH_9      = '9'.charCodeAt (0)
+
+class XSSimpleTypeDecimal extends XSSimpleType {
+
+	#fractionDigits = undefined
+	#totalDigits = undefined
+
+	get name () {
+		return 'decimal'
+	}
+
+	isValidNumber (num) {
+
+		return !Number.isNaN (num)
+
+	}
+
+	toOrdered (value) {
+
+		return parseFloat (value)
+
+	}
+
+	set totalDigits (v) {
+
+		this.#totalDigits = parseInt (v)
+
+	}
+
+	get totalDigits () {
+
+		return this.#totalDigits ?? super.totalDigits ?? Infinity
+
+	}	
+	
+	set fractionDigits (v) {
+
+		this.#fractionDigits = parseInt (v)
+
+	}
+
+	get fractionDigits () {
+
+		return this.#fractionDigits ?? super.fractionDigits ?? Infinity
+
+	}
+
+	testLength (value) {
+
+		return value.length === 0 ? 'No decimal value can be empty' : null
+
+	}
+
+	testFormat (value) {
+
+		let period = -1, total = 0, fraction = 0
+
+		for (let i = 0; i < value.length; i ++) {
+
+			const c = value.charCodeAt (i); switch (c) {
+
+				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`
+					continue
+
+				case CH_PERIOD:
+					if (period !== -1) return `'${value}' is not a valid decimal: 2nd period occured at position ${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}`
+					total ++
+					if (period !== -1) fraction ++
+
+			}
+
+		}
+		
+		if (total === 0) return `'${value}' is not a valid decimal: is has no digits at all`
+
+		const {totalDigits, fractionDigits} = this
+
+		if (total > totalDigits) return `'${value}' has ${total} digits, only ${totalDigits} allowed`
+
+		if (fraction > fractionDigits) return `'${value}' has ${fraction} digits after period, only ${fractionDigits} allowed`
+
+		return null
+
+	}
+
+	stringify (value) {
+
+		let num = value
+
+		const {fractionDigits} = this
+
+		const t = typeof value; switch (t) {
+
+			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, 'cannot be read as number')
+				return fractionDigits === Infinity ? 
+					num.toString () : 
+					num.toFixed (this.fractionDigits)
+
+			default: 
+				this.blame (value, `no idea how to treat ${t} as decimal`)
+
+		}
+
+	}
+
+}
+
+module.exports = XSSimpleTypeDecimal

package/lib/simple/XSSimpleTypeFloatingPoint.js

@@ -0,0 +1,80 @@
+const {XSSimpleType} = require ('./XSSimpleType.js')
+
+class XSSimpleTypeFloatingPoint extends XSSimpleType {
+
+	stringify (value) {
+
+		const verbatim = value
+
+		if (Number.isNaN (value)) return 'NaN'
+
+		if (typeof value !== 'number') value = this.toOrdered (value)
+
+		if (Number.isNaN (value)) this.blame (verbatim, 'Not a number, yet not NaN')
+
+		switch (value) {
+			case Number.POSITIVE_INFINITY: return 'INF'
+			case Number.NEGATIVE_INFINITY: return '-INF'
+			default: return String (value)
+		}
+
+	}
+
+	get name () {
+		return 'float'
+	}
+
+	toOrdered (value) {
+
+		return parseFloat (value)
+
+	}
+
+	testLength (value) {
+
+		return value.length === 0 ? 'No floating point number can be empty' : null
+
+	}
+
+	testFormat (value) {
+
+		if (Number.isNaN (this.toOrdered (value)) && value !== 'NaN') return `'${value}' is not a floating point number`
+
+		return null
+
+	}
+
+}
+
+class XSSimpleTypeFloat extends XSSimpleTypeFloatingPoint {
+
+	constructor (xs) {
+
+		super (xs)
+		this.maxInclusive = 3.4028235E+38
+		this.minInclusive = -this.maxInclusive
+
+	}
+
+}
+
+class XSSimpleTypeDouble extends XSSimpleTypeFloatingPoint {
+
+	constructor (xs) {
+
+		super (xs)
+		this.maxInclusive = 1.7976931348623157E+308
+		this.minInclusive = -this.maxInclusive
+
+	}
+
+}
+
+module.exports = {
+	XSSimpleTypeFloat,
+	XSSimpleTypeDouble,
+	byName: {
+		'float' : XSSimpleTypeFloat,
+		'double': XSSimpleTypeDouble,
+	}
+}

package/lib/simple/XSSimpleTypeInteger.js

@@ -0,0 +1,72 @@
+const XSSimpleTypeDecimal = require ('./XSSimpleTypeDecimal')
+
+const fromTo = (minInclusive, maxInclusive) => class extends XSSimpleTypeInteger {
+
+	constructor (xs) {
+
+		super (xs)
+		this.minInclusive = minInclusive
+		this.maxInclusive = maxInclusive
+
+	}
+
+}
+
+class XSSimpleTypeInteger extends XSSimpleTypeDecimal {
+
+	get name () {
+		return 'integer'
+	}
+
+	toOrdered (value) {
+
+		return BigInt (value)
+
+	}
+
+	set fractionDigits (v) {
+
+		if (v != '0') throw Error (`For an integer type, fractionDigits must be 0, not ${v}`)
+
+	}
+
+	get fractionDigits () {
+
+		return 0
+
+	}
+
+	isValidNumber (num) {
+
+		return Number.isInteger (num)
+
+	}
+
+}
+
+module.exports = {
+
+	XSSimpleTypeInteger,
+
+	byName: {
+
+		integer            : XSSimpleTypeInteger,
+
+		negativeInteger    : fromTo             (undefined, 1n),
+		nonPositiveInteger : fromTo             (undefined, 0n),
+		nonNegativeInteger : fromTo                    (0n, undefined),
+		positiveInteger    : fromTo                    (1n, undefined),
+
+		unsignedLong       : fromTo (                   0n, 18446744073709551615n),
+		unsignedInt        : fromTo (                   0n, 4294967295n),
+		unsignedShort      : fromTo (                   0n, 65535n),
+		unsignedByte       : fromTo (                   0n, 255n),
+
+		long               : fromTo (-9223372036854775808n, 9223372036854775807n),
+		int                : fromTo          (-2147483648n, 2147483647n),
+		short              : fromTo               (-32768n, 32767n),
+		byte               : fromTo                 (-128n, 127n),
+
+	}
+
+}

package/lib/simple/XSSimpleTypeQName.js

@@ -0,0 +1,24 @@
+const {XSSimpleType} = require ('./XSSimpleType.js')
+const NamespacePrefixesMap = require ('../NamespacePrefixesMap.js')
+
+class XSSimpleTypeQName extends XSSimpleType {
+
+	get name () {
+		return 'QName'
+	}
+
+	stringify (value) {
+
+		if (typeof value !== 'object' || !('localName' in value)) this.blame (value, 'not a {localName} object')
+
+		const {xs} = this
+
+		if (!xs.ns) xs.ns = new NamespacePrefixesMap (xs)
+
+		return xs.ns.QName (value.localName, value.namespaceURI)
+
+	}
+			
+}
+
+module.exports = XSSimpleTypeQName

package/lib/validation/Match.js

@@ -0,0 +1,54 @@
+class Match {
+
+    constructor (occurable) {
+
+        this.occurable = occurable
+        this.occured   = 0
+
+    }
+
+    get isSatisfied () {
+
+        return this.occured >= this.occurable.minOccurs
+
+    }
+ 
+    get isMaxedOut () {
+
+        return this.occured >= this.occurable.maxOccurs
+
+    }
+
+    allExpected (node) {
+
+        const all = new Set ([...this.expected (node ['_ns_map'])])
+
+        switch (all.size) {
+
+            case 0: return null
+
+            case 1: for (const first of all) return first
+
+            default: return `(${[...all].sort ().join (' | ')})`
+
+        }
+
+    }
+
+    // toString () {
+
+    //     const {occurable: {minOccurs, maxOccurs}, occured} = this
+
+    //     return `[${minOccurs} .. ${maxOccurs}]: ${occured}`
+
+    // }
+
+    getElementDefinition (node) {
+
+        return this.isMaxedOut ? null : this.getNextElementDefinition (node)
+
+    }
+
+}
+
+module.exports = Match

package/lib/validation/MatchAll.js

@@ -0,0 +1,33 @@
+const Match = require ('./Match')
+
+class All extends Match {
+
+    getNextElementDefinition (node) {
+
+        for (const child of this.children) if (child.occured === 0) {
+
+            const el = child.getElementDefinition (node); if (el === null) continue
+
+            this.occured = 1; for (const child of this.children) if (child.occured === 0) this.occured = 0
+                
+            return el
+
+        }
+
+        return null
+
+    }
+
+    * expected (nsMap) {
+
+        for (const child of this.children)
+            
+            if (!child.isSatisfied) 
+
+                for (const n of child.expected (nsMap)) yield n
+
+    }
+
+}
+
+module.exports = All

package/lib/validation/MatchAny.js

@@ -0,0 +1,15 @@
+const Match = require ('./Match')
+
+class Any extends Match {
+
+    getNextElementDefinition () {
+
+        this.occured ++
+
+        return this.occurable.node
+
+    }
+
+}
+
+module.exports = Any

package/lib/validation/MatchChoice.js

@@ -0,0 +1,74 @@
+const Match = require ('./Match')
+
+class MatchChoice extends Match {
+
+    #filteredChildren = null
+
+    constructor (occurable) {
+
+        super (occurable)
+
+    }
+
+    get filteredChildren () {
+
+        if (this.#filteredChildren === null) this.#filteredChildren = this.children
+
+        return this.#filteredChildren
+
+    }
+
+    getNextElementDefinition (node) {
+        
+        for (const child of this.filteredChildren) {
+
+            const el = child.getElementDefinition (node); if (el === null) continue
+
+            if (child.isSatisfied) {
+
+                this.occured ++
+
+                for (const child of (this.#filteredChildren = this.children)) child.occured = 0
+
+            }
+            else {
+
+                this.#filteredChildren = [child]
+
+            }
+
+            return el
+
+        }
+
+        return null
+
+    }
+
+    get isSatisfied () {
+
+        const {occured, occurable: {minOccurs}} = this
+
+        if (occured >= minOccurs) return true
+
+        if (occured < minOccurs - 1) return false
+
+        for (const child of (this.filteredChildren)) if (child.isSatisfied) return true
+
+        return false
+        
+    }
+
+    * expected (nsMap) {
+
+        for (const child of this.filteredChildren)
+            
+            // if (!child.isSatisfied)
+
+                for (const n of child.expected ()) yield n
+
+    }
+
+}
+
+module.exports = MatchChoice

package/lib/validation/MatchElement.js

@@ -0,0 +1,45 @@
+const Match = require ('./Match')
+
+class MatchElement extends Match {
+
+    getNextElementDefinition ({namespaceURI, localName}) {
+
+        const {node: {attributes: {name}, targetNamespace}} = this.occurable
+
+        if (localName !== name || namespaceURI != targetNamespace) return null
+
+        this.occured ++
+
+        return this.occurable.node
+
+    }
+
+    get clarkNotation () {
+
+        const {occurable: {node: {attributes: {name}, targetNamespace}}} = this
+
+        return `{${targetNamespace}}${name}`
+
+    }
+
+    * expected (nsMap) {
+
+        if (this.isMaxedOut) return
+
+        const {occurable: {node: {attributes: {name}, targetNamespace}}} = this
+
+        if (!nsMap) return yield this.clarkNotation
+
+        for (const qName of nsMap.getQNames (name, targetNamespace)) return yield `<${qName}>`
+
+    }
+
+    // toString () {
+
+    //     return this.clarkNotation + ' ' + super.toString ()
+
+    // }
+
+}
+
+module.exports = MatchElement

package/lib/validation/MatchSequence.js

@@ -0,0 +1,84 @@
+const Match = require ('./Match')
+
+class MatchSequence extends Match {
+
+    constructor (occurable) {
+
+        super (occurable)
+
+        this.index = 0
+
+    }
+
+    getElementDefinition (node) {
+
+        const {children} = this, {length} = children; if (length === 0) return null
+        
+        while (!this.isMaxedOut) {
+
+            const child = children [this.index], el = child.getElementDefinition (node)
+
+            if (el !== null) return el
+
+            if (!child.isSatisfied) return null
+
+            if ((++ this.index) < length) continue
+
+            this.index = 0
+
+            this.occured ++
+
+        }
+
+        return null
+
+    }
+
+    get isSatisfied () {
+
+        const {children} = this, {length} = children; if (length === 0) return true
+
+        for (let i = this.index + 1; i < length; i ++) {
+            
+            if (children [i].isSatisfied) continue
+
+// console.log (children [i])
+            
+            return false
+
+        }
+
+        return (this.occured + 1) >= this.occurable.minOccurs
+
+    }
+
+    * expected (nsMap) {
+
+        const {children} = this, {length} = children; if (length === 0) return
+
+        for (const n of children [this.index].expected (nsMap)) yield n
+
+        if (!children [this.index].isSatisfied) return
+
+        for (let i = this.index + 1; i < length; i ++) {
+
+            const child = children [i]
+
+            for (const n of child.expected (nsMap)) yield n
+
+            // if (child.minOccurs > 0) break
+
+        }
+
+    }
+
+    // toString () {
+
+    //     return `<${this.children.join ('; ')}>@${this.index} ${super.toString ()}`
+
+    // }
+
+
+}
+
+module.exports = MatchSequence

package/lib/validation/Occurable.js

@@ -0,0 +1,88 @@
+const CLASS_MAP = {
+	'all':      require ('./MatchAll'),
+	'any':      require ('./MatchAny'),
+	'choice':   require ('./MatchChoice'),
+	'element':  require ('./MatchElement'),
+	'sequence': require ('./MatchSequence'),
+}
+
+const parseOccurs = v => v == null ? 1 : v === 'unbounded' ? Infinity : parseInt (v)
+
+class Occurable {
+
+	node
+
+	constructor (arg, xs, minOccurs, maxOccurs) {
+
+		if (xs) this.xs = xs
+
+		this.children = []
+
+		if (Array.isArray (arg)) {
+
+			this.type = 'sequence'
+			this.minOccurs = 1
+			this.maxOccurs = 1
+
+			for (const o of arg) {
+
+				if (o.type === 'sequence' && o.minOccurs === 1 && o.maxOccurs === 1) {
+					
+					this.children = this.children.concat (o.children)
+					
+				}
+				else {
+					
+					this.children.push (o)
+
+				}
+
+			}
+
+		}
+		else {
+
+			const node = arg
+
+			this.node = node
+
+			this.type = node.localName		
+
+			this.minOccurs = parseOccurs (minOccurs ?? node.attributes ['minOccurs'])
+			this.maxOccurs = parseOccurs (maxOccurs ?? node.attributes ['maxOccurs'])
+
+			this.scan ()
+
+		}
+
+	}
+
+	scan () {
+
+		for (let node of this.node.children) switch (node.localName) {
+			case 'any':
+			case 'all':
+			case 'choice':
+			case 'sequence':
+			case 'element':
+				const {minOccurs, maxOccurs} = node.attributes
+				while ('ref' in node.attributes) node = this.xs.getByReference (node.attributes.ref)
+				this.children.push (new Occurable (node, this.xs, minOccurs, maxOccurs))
+				break
+		}
+			
+	}
+
+	createMatch () {
+
+		const {type} = this, m = new CLASS_MAP [type] (this)
+		
+		if (type !== 'element') m.children = this.children.map (o => o.createMatch ())
+
+		return m
+
+	}
+
+}
+
+module.exports = Occurable