Improved XML Schema support

Author: rmraya

ts/SAXParser.ts

@@ -80,6 +80,22 @@ export class SAXParser {
         this.resetNamespaceContext();
     }
 
+    private resetParserState(): void {
+        this.pointer = 0;
+        this.elementStack = 0;
+        this.elementNameStack = [];
+        this.xmlSpaceStack = [];
+        this.characterRun = '';
+        this.rootParsed = false;
+        this.inCDATA = false;
+        this.inComment = false;
+        this.inDoctype = false;
+        this.inProcessingInstruction = false;
+        this.childrenNames = [];
+        this.lastParsedAttributeLexical.clear();
+        this.characterRunPreservedCR.clear();
+    }
+
     setContentHandler(contentHandler: ContentHandler): void {
         this.contentHandler = contentHandler;
         this.contentHandler.setValidating(this.validating);
@@ -150,6 +166,15 @@ export class SAXParser {
         this.reader = new FileReader(resolvedPath, encoding);
         try {
             this.buffer = this.reader.read();
+
+            this.resetParserState();
+
+            // Reset grammar state so each document starts with a clean composite
+            if (typeof this.grammarHandler.initialize === 'function') {
+                this.grammarHandler.initialize();
+                this.grammarHandler.setIncludeDefaultAttributes(this.includeDefaultAttributes);
+            }
+
             this.contentHandler.initialize();
             this.readDocument();
         } catch (error) {
@@ -314,6 +339,7 @@ export class SAXParser {
             !this.inComment && !this.inDoctype && !this.inProcessingInstruction) {
             throw new Error('Entity reference not allowed in this context');
         }
+        const textForValidation: string = this.characterRun ? this.normalizeCharacterRun(this.characterRun) : '';
         this.cleanCharacterRun();
         this.pointer++; // skip '&'
         let name: string = '';
@@ -588,6 +614,7 @@ export class SAXParser {
     }
 
     endElement() {
+        const textForValidation: string = this.characterRun ? this.normalizeCharacterRun(this.characterRun) : '';
         this.cleanCharacterRun();
         this.pointer += 2; // skip '</'
         let name: string = '';
@@ -624,7 +651,7 @@ export class SAXParser {
             const elementValidationResult = this.grammarHandler.getGrammar().validateElement(name, {
                 attributes: new Map(),
                 childrenNames: actualChildrenNames,  // Pass the real child element names
-                textContent: this.characterRun,
+                textContent: textForValidation,
                 attributeOnly: false
             });
 

ts/grammar/CompositeGrammar.ts

@@ -11,9 +11,9 @@
  *******************************************************************************/
 
 import { } from "../grammar/Grammar";
+import { XMLUtils } from "../XMLUtils";
 import { SchemaType } from "./SchemaType";
 import { XMLSchemaGrammar } from "./XMLSchemaGrammar";
-import { XMLUtils } from "../XMLUtils";
 
 export class SchemaElementDecl {
     private name: string;
@@ -27,6 +27,7 @@ export class SchemaElementDecl {
     private defaultValue?: string;
     private fixedValue?: string;
     private form: 'qualified' | 'unqualified' = 'unqualified';
+    private namespaceURI?: string;
 
     constructor(name: string) {
         this.validateName(name);
@@ -133,32 +134,40 @@ export class SchemaElementDecl {
         return this.fixedValue || this.defaultValue;
     }
 
+    getNamespaceURI(): string | undefined {
+        return this.namespaceURI;
+    }
+
+    setNamespaceURI(namespaceURI: string | undefined): void {
+        this.namespaceURI = namespaceURI;
+    }
+
     // Resolve type from grammar if type name is set but type object is not
     resolveType(grammar: XMLSchemaGrammar): SchemaType | undefined {
         if (this.type) {
             return this.type;
         }
-        
+
         if (this.typeName) {
             return grammar.getTypeDefinition(this.typeName);
         }
-        
+
         return undefined;
     }
 
     // Schema validation methods
-    
+
     private validateName(name: string): void {
         if (!name) {
             throw new Error('Element name cannot be empty');
         }
-        
+
         // XML Schema spec: Element names must be valid NCNames (no spaces, no colons except for qualified names)
         // Check for invalid characters first (like spaces)
         if (name.includes(' ') || name.includes('\t') || name.includes('\n') || name.includes('\r')) {
             throw new Error(`Element name '${name}' contains invalid whitespace characters - XML Schema element names must be valid NCNames`);
         }
-        
+
         // Skip validation for Clark notation (expanded QNames like {namespace}localName)
         if (name.startsWith('{')) {
             const closeBrace = name.indexOf('}');
@@ -171,14 +180,14 @@ export class SchemaElementDecl {
                 return;
             }
         }
-        
+
         // Handle qualified names (prefix:localName) vs NCNames
         const colonIndex = name.indexOf(':');
         if (colonIndex !== -1) {
             // Qualified name - validate both prefix and local name as NCNames
             const prefix = name.substring(0, colonIndex);
             const localName = name.substring(colonIndex + 1);
-            
+
             if (!XMLUtils.isValidNCName(prefix)) {
                 throw new Error(`Element name prefix '${prefix}' is not a valid NCName`);
             }
@@ -214,12 +223,12 @@ export class SchemaElementDecl {
         this.validateName(this.name);
         this.validateOccurrence(this.minOccurs, this.maxOccurs);
         this.validateValueConstraints(this.defaultValue, this.fixedValue);
-        
+
         // Schema spec: abstract elements cannot have default/fixed values
         if (this.abstract && (this.defaultValue !== undefined || this.fixedValue !== undefined)) {
             throw new Error('Abstract elements cannot have default or fixed values');
         }
-        
+
         // Schema spec: elements with type and inline type are mutually exclusive
         if (this.type !== undefined && this.typeName !== undefined) {
             throw new Error('Element cannot have both inline type and type reference');