@domorium/validator 1.1.0 → 1.3.0

package/dist/parser/ast.d.ts

@@ -0,0 +1,63 @@
+import type { IToken } from "@chevrotain/types";
+import { TokenNames } from "./lexer";
+interface Position {
+    line: number;
+    character: number;
+}
+export interface Range {
+    start: Position;
+    end: Position;
+}
+export interface ASTToken {
+    name: TokenNames;
+    /** Character offset of the first character. */
+    startOffset: number;
+    /** Character offset just past the last character. */
+    endOffset: number;
+    /** Derived from the offsets; see the note on ASTNode. */
+    readonly range: Range;
+    value: string;
+}
+export interface ASTNode {
+    startOffset: number;
+    endOffset: number;
+    /**
+     * Line and character are computed on access rather than stored. A large
+     * document has millions of tokens, and a stored range costs three objects
+     * apiece — that alone was most of the syntax tree's memory. Reading `range`
+     * in a tight loop allocates; prefer the offsets there.
+     */
+    readonly range: Range;
+    tokens: Partial<Record<TokenNames, ASTToken>>;
+    parent?: ASTNode;
+    children: ASTNode[];
+    level: number;
+}
+export interface AstResult {
+    nodes: ASTNode[];
+    pointers: Map<string, ASTNode[]>;
+    xrefs: Map<string, ASTToken[]>;
+    /** Lines that carry no level, which GEDCOM requires on every line. */
+    malformed: ASTNode[];
+}
+/**
+ * Resolves a node's logical value by following CONT (new line) and CONC
+ * (concatenation) continuation children in document order, per the GEDCOM
+ * line-continuation rules.
+ */
+export declare function resolveValue(node: ASTNode): string;
+/**
+ * Builds the syntax tree straight from the token stream.
+ *
+ * There is no grammar to speak of: a GEDCOM line is
+ * `level [@xref@] TAG [value]`, and the lexer's modes already decide which is
+ * which. A parse tree in between was a second pass over 2.8 million tokens
+ * for a 15.6 MB document, and building the real tree from it a third — 543 ms
+ * and much of another 828 ms, to add nothing the tokens did not already say.
+ *
+ * Lines are found by offset against the line index rather than by looking for
+ * a level, so a line that has no level still becomes a node and is reported,
+ * instead of ending the parse and taking the rest of the document with it.
+ */
+export declare function buildAst(tokens: IToken[], text: string): AstResult;
+export {};

package/dist/parser/index.d.ts

@@ -1,2 +1,2 @@
-export type { ASTNode, ASTToken } from "./visitor";
-export { resolveValue } from "./visitor";
+export type { ASTNode, ASTToken } from "./ast";
+export { resolveValue } from "./ast";

package/dist/parser/lineIndex.d.ts

@@ -0,0 +1,9 @@
+import type { Position } from "../types/position";
+/**
+ * Offsets at which each line of a document starts. Storing one number per line
+ * lets the syntax tree keep character offsets instead of a line/character pair
+ * per token, which is where most of a large document's memory went.
+ */
+export type LineIndex = Int32Array;
+export declare function createLineIndex(text: string): LineIndex;
+export declare function offsetToPosition(index: LineIndex, offset: number): Position;

package/dist/validator/date-v7.d.ts

@@ -0,0 +1,8 @@
+import { GedcomScheme } from "../schemes/schema-types";
+export declare function isValidDateValue(value: string, scheme: GedcomScheme): boolean;
+export declare function isValidDatePeriod(value: string, scheme: GedcomScheme): boolean;
+/**
+ * `DateExact` names no calendar and takes no epoch: it is day, month and year in
+ * the Gregorian calendar, and all three are required.
+ */
+export declare function isValidDateExact(value: string, scheme: GedcomScheme): boolean;

package/dist/validator/rule-node.d.ts

@@ -5,12 +5,17 @@ type FieldType = "boolean" | "string" | "nonNegativeInteger" | "select" | "multi
 export declare class RuleNode {
     private readonly scheme;
     pointers: ASTNode[];
+    private readonly pointerMap;
     constructor(scheme: GedcomScheme, pointers: Map<string, ASTNode[]>);
+    /** Whether `xref` names a record of the kind this pointer type expects. */
+    private isPointerTarget;
     getFieldType(tagType: GedcomType): {
         type: FieldType;
         isList: boolean;
         to: GedcomType | undefined;
     };
+    private isGedcom7Payload;
+    private mayOmitPayload;
     getAvailableValues(tagType: GedcomType): string[] | null;
     /**
      * CONT/CONC are universal line-continuation tags: they are deliberately

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@domorium/validator",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "GEDCOM 5.5.1 and 7.0 parser and validator",
   "keywords": [
     "gedcom",

package/dist/parser/parser.d.ts

@@ -1,7 +0,0 @@
-import { CstNode, CstParser, ParserMethod } from "chevrotain";
-import { TokenVocabulary } from "@chevrotain/types";
-export declare class GedcomParser extends CstParser {
-    root: ParserMethod<[], CstNode>;
-    line: ParserMethod<[], CstNode>;
-    constructor(lexerDefinition: TokenVocabulary);
-}

package/dist/parser/visitor.d.ts

@@ -1,43 +0,0 @@
-import { CstNode } from "chevrotain";
-import { CstElement } from "@chevrotain/types";
-import { TokenNames } from "./lexer";
-declare const BaseGedcomVisitor: new (...args: any[]) => import("chevrotain").ICstVisitor<any, any>;
-interface Position {
-    line: number;
-    character: number;
-}
-export interface Range {
-    start: Position;
-    end: Position;
-}
-export interface ASTToken {
-    name: TokenNames;
-    range: Range;
-    value: string;
-}
-export interface ASTNode {
-    range: Range;
-    tokens: Partial<Record<TokenNames, ASTToken>>;
-    parent?: ASTNode;
-    children: ASTNode[];
-    level: number;
-}
-export interface VisitorResult {
-    nodes: ASTNode[];
-    pointers: Map<string, ASTNode[]>;
-    xrefs: Map<string, ASTToken[]>;
-}
-/**
- * Resolves a node's logical value by following CONT (new line) and CONC
- * (concatenation) continuation children in document order, per the GEDCOM
- * line-continuation rules.
- */
-export declare function resolveValue(node: ASTNode): string;
-export declare class GedcomVisitor extends BaseGedcomVisitor {
-    constructor();
-    root(ctx: CstNode | undefined): VisitorResult;
-    line({ children }: CstNode): ASTNode;
-    getTokens(elements?: CstElement[]): ASTToken[];
-    buildHierarchy(nodes: ASTNode[]): VisitorResult;
-}
-export {};