@conformetry/languages 0.0.5 → 0.0.7

package/dist/src/index.d.ts

@@ -51,6 +51,8 @@ declare interface CompareChildrenArguments {
 
 /** The outcome of walking one level of two trees. */
 declare interface CompareChildrenResult {
+    /** What each placeholder value stood for — see `DocumentValidationResult`. */
+    readonly captures?: Readonly<Record<string, string>>;
     readonly differences: MarkdownComparisonError[];
     /** Template nodes the level weighed the instance against. */
     readonly totalWeight: number;
@@ -206,6 +208,8 @@ export declare class FilesService {
 
 /** What structurally comparing two JSON values produced. */
 export declare interface JsonComparison {
+    /** What each placeholder value stood for — see `DocumentValidationResult`. */
+    readonly captures?: Readonly<Record<string, string>>;
     readonly differences: ConformetryDifference[];
     /** Template nodes the walk weighed the instance against. */
     readonly totalWeight: number;
@@ -239,7 +243,12 @@ export declare class JsonComparisonService {
     constructor(scoringService: ScoringService);
     /** Builds one structural error at a JSON path. */
     private buildError;
-    /** Merges sibling comparisons into one. */
+    /**
+     * Captures what a template string's placeholder values stand for in an
+     * instance value, or `undefined` when the two do not match as a pattern.
+     */
+    private captureString;
+    /** Merges sibling comparisons into one, keeping the first captures. */
     private combine;
     /** Matches one required array entry against the instance array. */
     private compareArrayItem;
@@ -518,6 +527,18 @@ export declare class MarkdownNodesService {
     private readColumnCount;
     /** Compares two optional string fields, treating absent as empty. */
     private sameField;
+    /**
+     * Matches an instance node against a template node, returning what any
+     * placeholder value in the template node's text captured, or `undefined`
+     * when the instance node does not satisfy it.
+     *
+     * A node failing its ordinary rule is tried once more with its plain text
+     * as a pattern, provided the type and heading depth agree.
+     */
+    capture(args: {
+        instanceNode: MarkdownNode;
+        templateNode: MarkdownNode;
+    }): Record<string, string> | undefined;
     /**
      * Counts a node and every countable node beneath it.
      *
@@ -579,6 +600,8 @@ export declare class MarkdownTreeService {
     constructor(markdownNodesService: MarkdownNodesService, scoringService: ScoringService);
     /** Describes a template node the instance does not contain. */
     private buildError;
+    /** What the first matching candidate captured for the template node. */
+    private captureFirst;
     /**
      * Matches a container node, then descends into it.
      *
@@ -760,6 +783,11 @@ export declare class TextModule {
 export declare class TextService implements ConformetryLanguageValidator {
     constructor();
     readonly descriptor: LanguageValidatorDescriptor;
+    /**
+     * Captures what a template line's placeholder values stand for, taking the
+     * first unclaimed instance line that fits it as a pattern and claiming it.
+     */
+    private captureLine;
     /** Counts how many times each line occurs, for duplicate-aware matching. */
     private countLines;
     /** Finds template lines the instance does not supply often enough. */
@@ -776,6 +804,8 @@ export declare class TextService implements ConformetryLanguageValidator {
 
 /** What comparing two syntax trees produced. */
 declare interface TreeComparison {
+    /** What each placeholder value stood for — see `DocumentValidationResult`. */
+    readonly captures?: Readonly<Record<string, string>>;
     readonly differences: TypescriptComparisonError[];
     /** Number of template nodes the walk weighed the instance against. */
     readonly totalWeight: number;
@@ -958,6 +988,17 @@ export declare class TypescriptTreeService {
     private compareBestCandidate;
     /** Matches one template child against the instance's children. */
     private compareChild;
+    /**
+     * Matches a template node on its key, returning what any placeholder value
+     * in the key captured, or `undefined` when the instance node does not match.
+     *
+     * A key holding a placeholder value is a pattern, and is only tried against
+     * nodes of the same syntax kind: a bare value would otherwise match any key
+     * at all, the callee's own name included.
+     */
+    private matchKey;
+    /** Matches a keyless template node on syntax kind alone. */
+    private matchKind;
     /** Compares one level of two trees, descending into every match. */
     compareTree(args: CompareTreeArguments): TreeComparison;
 }