@stxt-lang/core 0.6.0 → 0.6.2

package/out/all.d.ts

@@ -17,6 +17,8 @@ export { transformNodeToSchema } from "./schema/SchemaParser";
 export { UnifiedSchemaProvider } from "./runtime/UnifiedSchemaProvider";
 export { ConditionalValidator } from "./runtime/ConditionalValidator";
 export { NodeWriter, IndentStyle } from "./runtime/NodeWriter";
+export { toCanonicalTree, toCanonicalJson } from "./runtime/TreeJson";
+export type { CanonicalDocument, CanonicalNode, CanonicalInlineNode, CanonicalBlockNode } from "./runtime/TreeJson";
 export { transformTemplateNodeToSchema } from "./template/TemplateParser";
 export { DiscoveryResolver, DiscoveryOptions } from "./discovery/DiscoveryResolver";
 export { DiscoveryResult, DiscoveryDefinition, DiscoveryLevel } from "./discovery/DiscoveryResult";

package/out/all.js

@@ -3,7 +3,7 @@
 // Anything that should be consumable by third parties (e.g. the VSCode extension)
 // has to be re-exported from here.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscoveryError = exports.DiscoveryResult = exports.DiscoveryResolver = exports.transformTemplateNodeToSchema = exports.IndentStyle = exports.NodeWriter = exports.ConditionalValidator = exports.UnifiedSchemaProvider = exports.transformNodeToSchema = exports.ChildDefinition = exports.NodeDefinition = exports.SchemaValidator = exports.Schema = exports.ValidationException = exports.ParseException = exports.StringUtils = exports.parseLine = exports.Constants = exports.Line = exports.ParseResult = exports.Parser = exports.Node = void 0;
+exports.DiscoveryError = exports.DiscoveryResult = exports.DiscoveryResolver = exports.transformTemplateNodeToSchema = exports.toCanonicalJson = exports.toCanonicalTree = exports.IndentStyle = exports.NodeWriter = exports.ConditionalValidator = exports.UnifiedSchemaProvider = exports.transformNodeToSchema = exports.ChildDefinition = exports.NodeDefinition = exports.SchemaValidator = exports.Schema = exports.ValidationException = exports.ParseException = exports.StringUtils = exports.parseLine = exports.Constants = exports.Line = exports.ParseResult = exports.Parser = exports.Node = void 0;
 var Node_1 = require("./core/Node");
 Object.defineProperty(exports, "Node", { enumerable: true, get: function () { return Node_1.Node; } });
 var Parser_1 = require("./core/Parser");
@@ -39,6 +39,9 @@ Object.defineProperty(exports, "ConditionalValidator", { enumerable: true, get:
 var NodeWriter_1 = require("./runtime/NodeWriter");
 Object.defineProperty(exports, "NodeWriter", { enumerable: true, get: function () { return NodeWriter_1.NodeWriter; } });
 Object.defineProperty(exports, "IndentStyle", { enumerable: true, get: function () { return NodeWriter_1.IndentStyle; } });
+var TreeJson_1 = require("./runtime/TreeJson");
+Object.defineProperty(exports, "toCanonicalTree", { enumerable: true, get: function () { return TreeJson_1.toCanonicalTree; } });
+Object.defineProperty(exports, "toCanonicalJson", { enumerable: true, get: function () { return TreeJson_1.toCanonicalJson; } });
 var TemplateParser_1 = require("./template/TemplateParser");
 Object.defineProperty(exports, "transformTemplateNodeToSchema", { enumerable: true, get: function () { return TemplateParser_1.transformTemplateNodeToSchema; } });
 var DiscoveryResolver_1 = require("./discovery/DiscoveryResolver");

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/runtime/TreeJson.d.ts

@@ -0,0 +1,40 @@
+import { Node } from "../core/Node";
+/** Canonical JSON representation of a parsed STXT document (STXT-TREE-SPEC). */
+export type CanonicalDocument = CanonicalNode[];
+/** A node in the canonical JSON representation of an STXT document. */
+export type CanonicalNode = CanonicalInlineNode | CanonicalBlockNode;
+/** Canonical representation of an INLINE (`:`) node. */
+export interface CanonicalInlineNode {
+    name: string;
+    canonicalName: string;
+    namespace: string;
+    form: "inline";
+    value: string;
+    children: CanonicalNode[];
+}
+/** Canonical representation of a BLOCK (`>>`) node. */
+export interface CanonicalBlockNode {
+    name: string;
+    canonicalName: string;
+    namespace: string;
+    form: "block";
+    lines: string[];
+}
+/**
+ * Converts every root node of a parsed document to the logical tree defined by
+ * STXT-TREE-SPEC. The result deliberately excludes source positions, indentation
+ * style, comments and derived values such as a qualified name.
+ *
+ * @param nodes root nodes of an already parsed STXT document.
+ * @returns the canonical document tree, ready to be serialized as JSON.
+ */
+export declare function toCanonicalTree(nodes: ReadonlyArray<Node>): CanonicalDocument;
+/**
+ * Serializes the canonical tree of a parsed document as human-readable JSON.
+ * JSON whitespace is not part of STXT-TREE-SPEC; two-space indentation is this
+ * implementation's deterministic presentation for command-line use.
+ *
+ * @param nodes root nodes of an already parsed STXT document.
+ * @returns the canonical document tree encoded as JSON, without a final line break.
+ */
+export declare function toCanonicalJson(nodes: ReadonlyArray<Node>): string;

package/out/runtime/TreeJson.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCanonicalTree = toCanonicalTree;
+exports.toCanonicalJson = toCanonicalJson;
+/**
+ * Converts every root node of a parsed document to the logical tree defined by
+ * STXT-TREE-SPEC. The result deliberately excludes source positions, indentation
+ * style, comments and derived values such as a qualified name.
+ *
+ * @param nodes root nodes of an already parsed STXT document.
+ * @returns the canonical document tree, ready to be serialized as JSON.
+ */
+function toCanonicalTree(nodes) {
+    return nodes.map(node => toCanonicalNode(node));
+}
+/**
+ * Serializes the canonical tree of a parsed document as human-readable JSON.
+ * JSON whitespace is not part of STXT-TREE-SPEC; two-space indentation is this
+ * implementation's deterministic presentation for command-line use.
+ *
+ * @param nodes root nodes of an already parsed STXT document.
+ * @returns the canonical document tree encoded as JSON, without a final line break.
+ */
+function toCanonicalJson(nodes) {
+    return JSON.stringify(toCanonicalTree(nodes), null, 2);
+}
+function toCanonicalNode(node) {
+    if (node.isTextNode()) {
+        return {
+            name: node.getName(),
+            canonicalName: node.getNormalizedName(),
+            namespace: node.getNamespace(),
+            form: "block",
+            lines: [...node.getTextLines()],
+        };
+    }
+    return {
+        name: node.getName(),
+        canonicalName: node.getNormalizedName(),
+        namespace: node.getNamespace(),
+        form: "inline",
+        value: node.getValue(),
+        children: node.getChildren().map(child => toCanonicalNode(child)),
+    };
+}
+//# sourceMappingURL=TreeJson.js.map

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/SchemaProviderMemory.js

@@ -52,9 +52,14 @@ class SchemaProviderMemory {
     addSchema(txt) {
         const parser = new Parser_1.Parser();
         const node = parser.parse(txt)[0];
-        const schema = (0, SchemaParser_1.transformNodeToSchema)(node);
+        // A schema that does not validate against its meta-schema must not be
+        // registered (same policy as UnifiedSchemaProvider/DiscoveryResolver)
         const schemaValidator = new SchemaValidator_1.SchemaValidator(new SchemaProviderMeta_1.SchemaProviderMeta(), true);
-        schemaValidator.validate(node);
+        const errors = schemaValidator.validate(node);
+        if (errors.length > 0) {
+            throw errors[0];
+        }
+        const schema = (0, SchemaParser_1.transformNodeToSchema)(node);
         const key = schema.getNamespace();
         this.schemas.set(key, schema);
     }

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/out/template/TemplateSchemaProviderMemory.d.ts

@@ -18,7 +18,8 @@ export declare class TemplateSchemaProviderMemory extends SchemaProviderMemory {
      *
      * @param template text of the `@stxt.template` document.
      * @throws ValidationException with code `INVALID_SCHEMA` if the document does not hold exactly
-     *         one template, or if the resulting schema has no namespace.
+     *         one template or the resulting schema has no namespace, or the first validation error
+     *         if the template does not validate against the template meta-schema.
      */
     addTemplate(template: string): void;
 }

package/out/template/TemplateSchemaProviderMemory.js

@@ -31,7 +31,8 @@ class TemplateSchemaProviderMemory extends SchemaProviderMemory_1.SchemaProvider
      *
      * @param template text of the `@stxt.template` document.
      * @throws ValidationException with code `INVALID_SCHEMA` if the document does not hold exactly
-     *         one template, or if the resulting schema has no namespace.
+     *         one template or the resulting schema has no namespace, or the first validation error
+     *         if the template does not validate against the template meta-schema.
      */
     addTemplate(template) {
         const parser = new Parser_1.Parser();
@@ -39,9 +40,13 @@ class TemplateSchemaProviderMemory extends SchemaProviderMemory_1.SchemaProvider
         if (nodes.length !== 1) {
             throw new ValidationException_1.ValidationException(0, "INVALID_SCHEMA", `There are ${nodes.length}, and expected is 1`);
         }
-        // Validate the template against the template meta-schema
+        // A template that does not validate against the template meta-schema must not
+        // be registered (same policy as UnifiedSchemaProvider/DiscoveryResolver)
         const schemaValidator = new SchemaValidator_1.SchemaValidator(new MetaTemplateSchemaProvider_1.MetaTemplateSchemaProvider(), true);
-        schemaValidator.validate(nodes[0]);
+        const errors = schemaValidator.validate(nodes[0]);
+        if (errors.length > 0) {
+            throw errors[0];
+        }
         // Build the schema out of the template
         const sch = (0, TemplateParser_1.transformTemplateNodeToSchema)(nodes[0]);
         // Minimum safety check (Java checked the expected namespace here too)

package/package.json

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