@stxt-lang/core 0.6.1 → 0.6.3

package/out/core/Node.d.ts

@@ -5,7 +5,6 @@
  * as told apart by {@link Node.isTextNode}.
  */
 export declare class Node {
-    private static readonly VALID_NAME;
     private readonly name;
     private readonly normalizedName;
     private readonly namespace;

package/out/core/Node.js

@@ -38,10 +38,7 @@ class Node {
         if (this.value.length > 0 && this.isTextNode()) {
             throw new RuntimeException_1.RuntimeException("INLINE_VALUE_NOT_VALID", "Not empty value with textNode");
         }
-        if (!Node.VALID_NAME.test(name)) {
-            throw new ParseException_1.ParseException(line, "INVALID_NODE_NAME", `Node name contains invalid characters: ${name}`);
-        }
-        if (this.normalizedName.length === 0) {
+        if (!StringUtils_1.StringUtils.isValidNodeName(this.name)) {
             throw new ParseException_1.ParseException(line, "INVALID_NODE_NAME", `Node name not valid: ${name}`);
         }
     }
@@ -166,6 +163,4 @@ class Node {
     }
 }
 exports.Node = Node;
-// STXT-SPEC 4.2: Unicode letters and digits (categories L and Nd) plus '-', '_' and space
-Node.VALID_NAME = /^[\p{L}\p{Nd}\-_ ]+$/u;
 //# sourceMappingURL=Node.js.map

package/out/core/StringUtils.d.ts

@@ -1,5 +1,6 @@
 /** String normalization helpers used for names, namespaces and values. */
 export declare class StringUtils {
+    private static readonly NODE_NAME;
     private constructor();
     /**
      * Removes the trailing whitespace of a string.
@@ -29,6 +30,16 @@ export declare class StringUtils {
      * @returns the string with the outer spaces trimmed and the inner ones collapsed into a single one; null/undefined is treated as the empty string.
      */
     static compactSpaces(s: string | null | undefined): string;
+    /**
+     * Tells whether a value is a valid STXT node name.
+     *
+     * The test happens after NFC normalization: the source may use either the
+     * precomposed or decomposed Unicode spelling of a letter with a diacritic.
+     *
+     * @param input name to validate.
+     * @returns true if the name contains only permitted characters and has a non-empty canonical name.
+     */
+    static isValidNodeName(input: string | null | undefined): boolean;
     /**
      * Builds the canonical name of a node, as defined by STXT-SPEC 4.3.
      *

package/out/core/StringUtils.js

@@ -51,6 +51,19 @@ class StringUtils {
     static compactSpaces(s) {
         return (s ?? "").trim().replace(/\s+/g, " ");
     }
+    /**
+     * Tells whether a value is a valid STXT node name.
+     *
+     * The test happens after NFC normalization: the source may use either the
+     * precomposed or decomposed Unicode spelling of a letter with a diacritic.
+     *
+     * @param input name to validate.
+     * @returns true if the name contains only permitted characters and has a non-empty canonical name.
+     */
+    static isValidNodeName(input) {
+        const nfc = this.compactSpaces(input).normalize("NFC");
+        return this.NODE_NAME.test(nfc) && this.normalize(nfc).length > 0;
+    }
     // Used for the normalized name of the nodes (STXT-SPEC 4.3): NFC + lower case,
     // keeping diacritics and non-Latin alphabets (IDN model)
     /**
@@ -74,4 +87,7 @@ class StringUtils {
     }
 }
 exports.StringUtils = StringUtils;
+// STXT-SPEC 4.2 / 4.3: validate the logical name after NFC so that a
+// decomposed spelling such as "e" + combining acute is accepted as "é".
+StringUtils.NODE_NAME = /^[\p{L}\p{Nd}\-_ ]+$/u;
 //# sourceMappingURL=StringUtils.js.map

package/out/discovery/DiscoveryResolver.js

@@ -127,10 +127,9 @@ class DiscoveryResolver {
         if (cached) {
             return cached;
         }
-        const level = { dir, definitions: new Map(), errors: [] };
-        const conflicted = new Set();
+        const level = { dir, definitions: new Map(), conflictedNamespaces: new Set(), errors: [] };
         for (const file of await this.collectFiles(dir)) {
-            await this.loadFile(file, level, conflicted);
+            await this.loadFile(file, level);
         }
         this.levelCache.set(dir, level);
         return level;
@@ -152,7 +151,7 @@ class DiscoveryResolver {
     }
     // Loads one file of a level: parses it and registers every root as a definition,
     // reporting the errors of spec section 8.
-    async loadFile(file, level, conflicted) {
+    async loadFile(file, level) {
         // Spec section 3: every file under a resolution directory must be a definition.
         if (!file.endsWith(STXT_EXTENSION)) {
             level.errors.push(new DiscoveryError_1.DiscoveryError(DiscoveryError_1.DiscoveryError.NOT_A_DEFINITION, file, `Not an STXT definition file: ${file}`));
@@ -171,12 +170,12 @@ class DiscoveryResolver {
             return;
         }
         for (const node of nodes) {
-            this.loadRootNode(node, file, level, conflicted);
+            this.loadRootNode(node, file, level);
         }
     }
     // Validates one root node against its meta-schema, compiles it to a schema and
     // registers it in the level, detecting same-level duplicates.
-    loadRootNode(node, file, level, conflicted) {
+    loadRootNode(node, file, level) {
         const namespace = node.getNamespace();
         let schema;
         try {
@@ -200,10 +199,10 @@ class DiscoveryResolver {
         const existing = level.definitions.get(key);
         // Spec section 8: on a same-level duplicate, never silently pick one of the
         // definitions — the namespace has no active definition while the conflict exists.
-        if (conflicted.has(key) || existing) {
+        if (level.conflictedNamespaces.has(key) || existing) {
             if (existing) {
                 level.definitions.delete(key);
-                conflicted.add(key);
+                level.conflictedNamespaces.add(key);
             }
             const firstFile = existing ? existing.file : "another file of this level";
             level.errors.push(new DiscoveryError_1.DiscoveryError(DiscoveryError_1.DiscoveryError.DUPLICATE_NAMESPACE, file, `Duplicate definition for namespace '${schema.getNamespace()}' at level ${level.dir}: ` +

package/out/discovery/DiscoveryResult.d.ts

@@ -24,6 +24,8 @@ export interface DiscoveryLevel {
     dir: string;
     /** Definitions of the level by lowercased target namespace, conflicts excluded. */
     definitions: Map<string, DiscoveryDefinition>;
+    /** Namespaces with a same-level conflict; they block fallback to farther levels. */
+    conflictedNamespaces: Set<string>;
     /** Resolution errors found while loading this level. */
     errors: DiscoveryError[];
 }

package/out/discovery/DiscoveryResult.js

@@ -52,6 +52,11 @@ class DiscoveryResult {
     getDefinition(namespace) {
         const key = StringUtils_1.StringUtils.lowerCase(namespace);
         for (const level of this.levels) {
+            // STXT-DISCOVERY-SPEC section 8: a closer conflict leaves the namespace
+            // without an active definition instead of falling back to a farther level.
+            if (level.conflictedNamespaces.has(key)) {
+                return undefined;
+            }
             const definition = level.definitions.get(key);
             if (definition) {
                 return definition;
@@ -69,6 +74,11 @@ class DiscoveryResult {
         const seen = new Set();
         const result = [];
         for (const level of this.levels) {
+            // Mark conflicts as seen so getActiveDefinitions() has the same semantics
+            // as getDefinition(): they block definitions in farther levels.
+            for (const key of level.conflictedNamespaces) {
+                seen.add(key);
+            }
             for (const [key, definition] of level.definitions) {
                 if (!seen.has(key)) {
                     seen.add(key);

package/out/schema/ChildDefinition.js

@@ -23,7 +23,7 @@ class ChildDefinition {
         this.min = min;
         this.max = max;
         NamespaceValidator_1.NamespaceValidator.validateNamespaceFormat(this.namespace, numLine);
-        if (this.normalizedName.length === 0) {
+        if (!StringUtils_1.StringUtils.isValidNodeName(this.name)) {
             throw new ValidationException_1.ValidationException(numLine, "INVALID_NODE_NAME", `Node name not valid: ${name}`);
         }
     }

package/out/schema/NodeDefinition.js

@@ -24,7 +24,7 @@ class NodeDefinition {
         this.normalizedName = StringUtils_1.StringUtils.normalize(name);
         this.type = type;
         this.description = description;
-        if (this.normalizedName.length === 0) {
+        if (!StringUtils_1.StringUtils.isValidNodeName(this.name)) {
             throw new ValidationException_1.ValidationException(line, "INVALID_NODE_NAME", `Node name not valid: ${name}`);
         }
     }

package/out/schema/SchemaProviderMeta.d.ts

@@ -16,9 +16,13 @@ export declare class SchemaProviderMeta implements SchemaProvider {
     /**
      * Serves the meta-schema of the schema language.
      *
+     * Follows the {@link SchemaProvider} contract: providers never throw "not found". Any
+     * namespace other than `@stxt.schema` yields `null`, so that this provider can sit at
+     * the end of a fallback chain (it is the default parent of {@link SchemaProviderMemory})
+     * and the {@link SchemaValidator} is the only one reporting `SCHEMA_NOT_FOUND`.
+     *
      * @param namespace namespace whose schema is wanted; only `@stxt.schema` is served.
-     * @returns the meta-schema of the schema language.
-     * @throws RuntimeException with code `RESOURCE_NOT_FOUND` if any other namespace is asked for.
+     * @returns the meta-schema of the schema language, or `null` for any other namespace.
      */
-    getSchema(namespace: string): Schema;
+    getSchema(namespace: string): Schema | null;
 }

package/out/schema/SchemaProviderMeta.js

@@ -4,7 +4,6 @@ exports.SchemaProviderMeta = void 0;
 const Schema_1 = require("./Schema");
 const Parser_1 = require("../core/Parser");
 const ValidationException_1 = require("../exceptions/ValidationException");
-const RuntimeException_1 = require("../exceptions/RuntimeException");
 const SchemaParser_1 = require("./SchemaParser");
 /**
  * {@link SchemaProvider} that defines in code the meta-schema of the schema language itself
@@ -27,13 +26,17 @@ class SchemaProviderMeta {
     /**
      * Serves the meta-schema of the schema language.
      *
+     * Follows the {@link SchemaProvider} contract: providers never throw "not found". Any
+     * namespace other than `@stxt.schema` yields `null`, so that this provider can sit at
+     * the end of a fallback chain (it is the default parent of {@link SchemaProviderMemory})
+     * and the {@link SchemaValidator} is the only one reporting `SCHEMA_NOT_FOUND`.
+     *
      * @param namespace namespace whose schema is wanted; only `@stxt.schema` is served.
-     * @returns the meta-schema of the schema language.
-     * @throws RuntimeException with code `RESOURCE_NOT_FOUND` if any other namespace is asked for.
+     * @returns the meta-schema of the schema language, or `null` for any other namespace.
      */
     getSchema(namespace) {
         if (namespace !== Schema_1.Schema.SCHEMA_NAMESPACE) {
-            throw new RuntimeException_1.RuntimeException("RESOURCE_NOT_FOUND", `Not found '${namespace}' in namespace: ${Schema_1.Schema.SCHEMA_NAMESPACE}`);
+            return null;
         }
         if (!this.meta) {
             throw new ValidationException_1.ValidationException(0, "META_SCHEMA_NOT_AVAILABLE", "Meta schema not available");

package/out/template/MetaTemplateSchemaProvider.d.ts

@@ -16,9 +16,12 @@ export declare class MetaTemplateSchemaProvider implements SchemaProvider {
     /**
      * Serves the meta-schema of the template language.
      *
+     * Follows the {@link SchemaProvider} contract: providers never throw "not found". Any
+     * namespace other than `@stxt.template` yields `null`; only the `SchemaValidator`
+     * reports `SCHEMA_NOT_FOUND`.
+     *
      * @param namespace namespace whose schema is wanted; only `@stxt.template` is served.
-     * @returns the meta-schema of the template language.
-     * @throws RuntimeException with code `RESOURCE_NOT_FOUND` if any other namespace is asked for.
+     * @returns the meta-schema of the template language, or `null` for any other namespace.
      */
-    getSchema(namespace: string): Schema;
+    getSchema(namespace: string): Schema | null;
 }

package/out/template/MetaTemplateSchemaProvider.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MetaTemplateSchemaProvider = void 0;
 const Parser_1 = require("../core/Parser");
 const ValidationException_1 = require("../exceptions/ValidationException");
-const RuntimeException_1 = require("../exceptions/RuntimeException");
 const TemplateParser_1 = require("./TemplateParser");
 /**
  * {@link SchemaProvider} that defines in code the meta-schema of the template language itself
@@ -26,13 +25,16 @@ class MetaTemplateSchemaProvider {
     /**
      * Serves the meta-schema of the template language.
      *
+     * Follows the {@link SchemaProvider} contract: providers never throw "not found". Any
+     * namespace other than `@stxt.template` yields `null`; only the `SchemaValidator`
+     * reports `SCHEMA_NOT_FOUND`.
+     *
      * @param namespace namespace whose schema is wanted; only `@stxt.template` is served.
-     * @returns the meta-schema of the template language.
-     * @throws RuntimeException with code `RESOURCE_NOT_FOUND` if any other namespace is asked for.
+     * @returns the meta-schema of the template language, or `null` for any other namespace.
      */
     getSchema(namespace) {
         if (namespace !== "@stxt.template") {
-            throw new RuntimeException_1.RuntimeException("RESOURCE_NOT_FOUND", `Not found '${namespace}' in namespace: @stxt.template`);
+            return null;
         }
         // meta always exists once the constructor finished, but this mirrors the Java version
         if (!this.meta) {

package/out/template/TemplateParser.js

@@ -72,6 +72,11 @@ function transformTemplateNodeToSchema(node) {
 }
 /** Adds to the schema the definition a node of the structure declares, along with its children. */
 function addToSchema(schema, node) {
+    // A Structure line must use the template grammar's ':' form. The core parser
+    // also accepts BLOCK nodes here, so reject them explicitly (STXT-TEMPLATE-SPEC 6.3).
+    if (node.isTextNode()) {
+        throw new ValidationException_1.ValidationException(node.getLine(), "INVALID_CHILD_LINE", "Template Structure lines must use ':'");
+    }
     // Get the qualified name
     let namespace = node.getNamespace();
     const name = node.getName();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stxt-lang/core",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "Parser and schema validator for STXT, an indentation-based structured-text format.",
   "main": "out/all.js",
   "types": "out/all.d.ts",