xml-toolkit 1.0.61 → 1.1.0

package/lib/simple/DT7.js

@@ -0,0 +1,248 @@
+const MIN_LENGTH = 10
+const CH_PERIOD = '.'.charCodeAt (0)
+const CH_COLON  = ':'.charCodeAt (0)
+const CH_MINUS  = '-'.charCodeAt (0)
+const CH_PLUS   = '+'.charCodeAt (0)
+const CH_T      = 'T'.charCodeAt (0)
+const CH_0      = '0'.charCodeAt (0)
+const CH_9      = '9'.charCodeAt (0)
+
+const tzCache = new Set (['Z', '+14:00', '-14:00'])
+
+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`)
+
+		this.src = src
+
+		this.parse ()
+		this.validate ()
+
+	}
+
+	parse () {
+
+		this.posMonth = this.src.indexOf ('-', 1)
+
+		if (this.posMonth === -1) throw Error (`The year separator is not found`)
+
+		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)}'`)
+		
+		const {length} = this.src
+
+		if (length < this.endOfDate) throw Error (`The day part must be 2 chars long, found '${this.day}'`)
+
+		if (length !== (this.endOfDateTime = this.endOfDate)) this.parseAfterDate ()
+
+	}
+
+	parseAfterDate () {
+		
+		if (this.src.charCodeAt (this.endOfDate) !== CH_T) return
+
+		for (const pos of [this.endOfHour, this.endOfMinute])
+
+			if (this.src.charCodeAt (pos) !== CH_COLON)
+				
+				throw Error (`Invalid time part: the character at position ${pos} must be ':', not '${this.src.charAt (pos)}'`)
+
+		this.hasTime = true
+
+		this.parseAfterMinute ()	
+
+	}
+
+	parseAfterMinute () {
+
+		this.endOfDateTime = this.endOfMinute + 3; if (this.src.charCodeAt (this.endOfDateTime) !== CH_PERIOD) return
+
+		const {length} = this.src; while (true) {
+
+			this.endOfDateTime ++; if (this.endOfDateTime === length) break
+
+			const c = this.src.charCodeAt (this.endOfDateTime); if (c >= CH_0 && c <= CH_9) continue
+
+			break
+
+		}
+
+	}
+
+	get posDay () {
+
+		return this.posMonth + 3
+
+	}
+
+	get endOfDate () {
+
+		return this.posMonth + 6
+
+	}
+	
+	get endOfHour () {
+
+		return this.posMonth + 9
+
+	}
+
+	get endOfMinute () {
+
+		return this.posMonth + 12
+
+	}
+
+	get year () {
+
+		return this.src.substring (0, this.posMonth)
+
+	}
+
+	get month () {
+
+		return this.src.substring (this.posMonth + 1, this.posDay)
+
+	}
+
+	get day () {
+
+		return this.src.substring (this.posDay + 1, this.posDay + 3)
+
+	}
+
+	get hour () {
+
+		if (this.hasTime) return this.src.substring (this.endOfDate + 1, this.endOfHour)
+
+	}
+
+	get minute () {
+
+		if (this.hasTime) return this.src.substring (this.endOfHour + 1, this.endOfMinute)
+
+	}
+
+	get second () {
+
+		if (this.hasTime) return this.src.substring (this.endOfMinute + 1, this.endOfDateTime)
+
+	}
+
+	get tz () {
+
+		const s = this.src.substring (this.endOfDateTime)
+
+		return s.length === 0 ? undefined : s
+
+	}
+
+	validate () {
+
+		this.validateDate ()
+
+		if (this.hasTime) this.validateTime ()
+
+		this.validateTZ ()
+
+	}
+	
+	validateDate () {
+
+		this.validateMonth ()
+		this.validateYear  ()
+		this.validateDay   ()
+
+	}
+
+	validateYear () {
+
+		const {year} = this, {length} = year, base = year.charCodeAt (0) === CH_MINUS ? 1 : 0
+
+		if (year.charCodeAt (base) === CH_0 && length - base !== 4) throw Error (`Starting with 0, the year must have exactly 4 digits`)
+		
+		for (let i = base; i < length; i ++) {
+
+			const c = year.charCodeAt (i)
+
+			if (c > CH_9 || c < CH_0) throw Error (`Invalid year: '${year.charAt (i)} at position ${i}'`)
+
+		}
+
+	}
+
+	validateMonth () {
+
+		const {month} = this
+
+		if (month < '01' || month > '12') throw Error (`Invalid month`)
+
+	}
+
+	validateDay () {
+
+		const {day} = this
+
+		if (day < '01' || day > '31') throw Error (`Invalid day`)
+
+		if (day === '31' || (this.month === '02' && day > '28')) {
+
+			if (new Date (this.src.substring (0, this.endOfDate)).getDate () != day) throw Error (`Non existing day`)
+
+		}
+
+	}
+
+	validateTime () {
+
+		const {hour, minute, second} = this
+
+		if (hour      < '00'    || hour      > '23') throw Error (`Invalid hour`)
+		if (minute    < '00'    || minute    > '59') throw Error (`Invalid minute`)
+
+		const intSecond = second.length === 2 ? second : second.substring (0, 2)
+
+		if (intSecond < '00'    || intSecond > '59') throw Error (`Invalid second`)
+
+	}
+
+	validateTZ () {
+
+		const {tz} = this; if (tz === undefined || tzCache.has (tz)) return
+
+		switch (tz.charCodeAt (0)) {
+			case CH_PLUS:
+			case CH_MINUS:
+				break
+			default:
+				throw Error (`Unless 'Z', the timezone must start with either '+' or '-', not ${tz.charAt (0)}`)
+		}
+
+		if (tz.length !== 6) throw Error (`Invalid timezone length: ${tz.length}`)
+
+		if (tz.charCodeAt (3) !== CH_COLON) throw Error (`Invalid timezone: ':' not found at position 3`)
+
+		{
+
+			const hh = tz.substring (1, 3); if (hh < '00' || hh > '13') throw Error (`Invalid TZ hour: ${hh}`)
+
+		}
+
+		{
+
+			const mm = tz.substring (4, 6); if (mm < '00' || mm > '59') throw Error (`Invalid TZ minute: ${mm}`)
+
+		}
+
+		tzCache.add (tz)
+
+	}
+
+}
+
+module.exports = DT7

package/lib/simple/XSSimpleType.js

@@ -0,0 +1,259 @@
+class XSSimpleType {
+
+	constructor (xs) {
+
+		this.xs = xs
+		this.length = null
+		this.maxLength = Infinity
+		this.minLength = 0
+
+	}
+
+	get totalDigits ()     { return undefined }
+	set totalDigits (v)    { throw Error ('totalDigits are not supported for this type') }
+
+	get fractionDigits ()  { return undefined }
+	set fractionDigits (_) { throw Error ('fractionDigits are not supported for this type') }
+
+	toOrdered (_)          { throw Error ('the ordering is not supported for this type') }
+
+	get patterns ()        { return [] }
+	get values   ()        { return [] }
+
+	get name () {
+		return 'anyType'
+	}
+
+	blame (value, reasons) {
+
+		if (!Array.isArray (reasons)) reasons = [reasons]
+
+		let s; try {
+
+			s = JSON.stringify (value)
+
+		}
+		catch (x) {
+
+			s = String (value)
+
+		}
+
+		throw Error (`Cannot stringify ${typeof value} ${s} as ${this.name}: ${reasons.join ('; ')}`)
+
+	}
+
+	stringify (value) {
+
+		if (value == null) this.blame (value, 'nullish values are unacceptable')
+
+		const reasons = []; for (const s of this.strings (value)) {
+
+			const result = this.test (s); if (result === null) return s
+						
+			reasons.push (result)
+
+		}
+
+		this.blame (value, reasons)
+
+	}
+
+	* strings (value) {
+
+		yield String (value)
+
+	}
+
+	test (s) {
+
+		if (this.isEnumeration) return this.testEnumeration (s)
+		
+		return this.testLength (s) ?? this.testFormat (s) ?? this.testBounds (s) ?? this.testPatterns (s) ?? (/*super.test ? super.test (s) :*/ null)
+
+	}	
+
+	testFormat (s) {
+
+		return null
+
+	}
+
+	get units () {
+
+		return 'chars'
+
+	}
+
+	getLength (value) {
+
+		return value.length
+
+	}
+
+	testBounds (value) {
+
+		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}'`)
+			
+		if (this.minExclusive != null && (ordered ??= this.toOrdered (value)) <= this.minExclusive) throw Error (`The value '${value}' is less or equal than the threshold '${this.minExclusive}'`)
+
+		if (this.maxExclusive != null && (ordered ??= this.toOrdered (value)) >= this.maxExclusive) throw Error (`The value '${value}' is greater or equal than the threshold '${this.maxExclusive}'`)
+
+	}
+
+	testLength (value) {
+
+		const l = this.getLength (value), {length} = 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}`
+
+		}
+		else {
+
+			if (l !== length) return `The value '${value}' is ${l} ${this.units} long, must be exaclty ${length}`
+
+		}
+
+		return null
+
+	}
+
+	get isEnumeration () {
+
+		return this.values.length !== 0
+
+	}
+
+	testEnumeration (s) {
+
+		const {values} = this; if (values.includes (s)) return null
+
+		return `The value '${s}' is not in list: ${JSON.stringify (values)}`
+
+	}
+
+	testPatterns (s) {
+
+		const {patterns} = this, {length} = patterns; if (length === 0) return null
+
+		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)			
+
+	}
+
+	restrict (entries) {
+
+		return class extends this.constructor {
+
+			#patterns = []
+			#values = []
+
+			get patterns () {
+				return this.#patterns
+			}
+
+			get values () {
+				return this.#values
+			}
+
+			get name () {
+				return super.name
+			}
+
+			constructor (xs) {
+
+				super (xs)
+
+				for (const entry of entries) {
+
+					const {localName, attributes} = entry
+
+					try {
+
+						const {value} = attributes; switch (localName) {
+
+							case 'enumeration':
+								this.#values.push (value)
+								break
+
+							case 'pattern':
+								this.#patterns.push (new RegExp (value))
+								break
+
+							case 'totalDigits':
+								this.totalDigits = value
+								break
+
+							case 'fractionDigits':
+								this.fractionDigits = value
+								break
+
+							case 'length':
+								this.length = parseInt (value)
+								break
+
+							case 'maxLength':
+								this.maxLength = parseInt (value)
+								break
+
+							case 'minLength':
+								this.minLength = parseInt (value)
+								break
+
+							case 'maxInclusive':
+								this.maxInclusive = this.toOrdered (value)
+								break
+
+							case 'maxExclusive':
+								this.maxExclusive = this.toOrdered (value)
+								break
+
+							case 'minInclusive':
+								this.minInclusive = this.toOrdered (value)
+								break
+
+							case 'minExclusive':
+								this.minExclusive = this.toOrdered (value)
+								break
+
+						}				
+
+					}
+					catch (cause) {
+
+						throw cause
+
+					}
+					
+				}
+
+			}
+
+		}
+
+	}
+
+}
+
+module.exports = {
+	XSSimpleType,
+}

package/lib/simple/XSSimpleTypeBoolean.js

@@ -0,0 +1,91 @@
+const {XSSimpleType} = require ('./XSSimpleType.js')
+
+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
+
+				}
+				
+		}
+
+	}
+
+	get name () {
+		return 'boolean'
+	}
+
+	toOrdered (value) {
+
+		switch (value) {
+			case '0': 
+			case 'false': 
+				return 0
+			case '1': 
+			case 'true': 
+				return 1
+		}
+
+		return undefined
+
+	}
+
+	testLength (value) {
+
+		return value.length === 0 ? 'No boolean value can be empty' : null
+
+	}
+
+	testFormat (value) {
+
+		if (this.toOrdered (value) === undefined) return `'${value}' is not a boolean value`
+
+		return null
+
+	}
+
+	* strings (value) {
+
+		const c = XSSimpleTypeBoolean.toCanonical (value); if (c !== null) {
+
+			if (c) {
+				yield 'true'
+				yield '1'
+			}
+			else {
+				yield 'false'
+				yield '0'
+			}
+
+		}
+
+	}
+
+}
+
+module.exports = XSSimpleTypeBoolean

package/lib/simple/XSSimpleTypeDT.js

@@ -0,0 +1,96 @@
+const {XSSimpleType} = require ('./XSSimpleType.js')
+const DT7 = require ('./DT7.js')
+
+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
+
+	}
+
+	testFormat (s) {
+
+		const dt7 = new DT7 (s)
+
+		if (dt7.hour !== undefined) return `For a date value, the time part cannot be present`
+
+	}
+
+}
+
+class XSSimpleTypeDateTime extends XSSimpleTypeDT {
+
+	adjust (value) {
+
+		value = super.adjust (value)
+
+		return value.length === 10 ? value + 'T00:00:00' : value
+
+	}
+
+	testFormat (s) {
+
+		const dt7 = new DT7 (s)
+
+		if (dt7.hour === undefined) return `For a dateTime value, the time part is mandatory`
+
+	}
+
+	* strings (value) {
+
+		value = this.adjust (value)
+
+		yield value
+
+		if (value.length > 19) yield value.substring (0, 19)
+		
+	}
+
+}
+
+class XSSimpleTypeDateTimeStamp extends XSSimpleTypeDateTime {
+
+	testFormat (s) {
+
+		const dt7 = new DT7 (s)
+
+		if (dt7.hour === undefined || dt7.tz === undefined) return `For a dateTimeStamp value, both time and timezone parts are mandatory`
+
+	}
+
+}
+
+module.exports = {
+	XSSimpleTypeDate,
+	XSSimpleTypeDateTime,
+	XSSimpleTypeDateTimeStamp,
+	byName: {
+		date          : XSSimpleTypeDate,
+		dateTime      : XSSimpleTypeDateTime,
+		dateTimeStamp : XSSimpleTypeDateTimeStamp,
+	}
+
+}