gedcom.json 1.0.8 → 1.0.10

package/src/ToJSON/models/Statistics.ts

@@ -5,75 +5,75 @@ import join from 'lodash/join';
  * Class with parsing statistics
  */
 export default class Statistics {
-    constructor(){
-        this.ParsedLines = [];
-        this.IncorrectLines = [];
-        this.NotParsedLines = [];
-        this.NotParsedLinesWithoutGEDCOMTag = [];
-    }
+  constructor() {
+    this.ParsedLines = [];
+    this.IncorrectLines = [];
+    this.NotParsedLines = [];
+    this.NotParsedLinesWithoutGEDCOMTag = [];
+  }
 
-    /**
-     * @returns list of all correct parsed lines
-     */
-    ParsedLines: StatisticLine[];
-    /**
-     * @returns list of all incorrect parsed lines
-     */
-    IncorrectLines: StatisticLine[];
-    /**
-     * @returns list of all not parsed lines
-     */
-    NotParsedLines: StatisticLine[];
+  /**
+   * @returns list of all correct parsed lines
+   */
+  ParsedLines: StatisticLine[];
+  /**
+   * @returns list of all incorrect parsed lines
+   */
+  IncorrectLines: StatisticLine[];
+  /**
+   * @returns list of all not parsed lines
+   */
+  NotParsedLines: StatisticLine[];
 
-    /**
-     * @returns list of all not parsed lines
-     */
-    NotParsedLinesWithoutGEDCOMTag: StatisticLine[];
+  /**
+   * @returns list of all not parsed lines
+   */
+  NotParsedLinesWithoutGEDCOMTag: StatisticLine[];
 
-    /**
-     * @returns a count of all correctly parsed lines
-     */
-    get ParsedLinesCount(): number {
-        return this.ParsedLines.length;
-    }
+  /**
+   * @returns a count of all correctly parsed lines
+   */
+  get ParsedLinesCount(): number {
+    return this.ParsedLines.length;
+  }
 
-    /**
-     * @returns a count of all incorrect parsed lines
-     */
-    get IncorrectLinesCount(): number {
-        return this.IncorrectLines.length;
-    }
+  /**
+   * @returns a count of all incorrect parsed lines
+   */
+  get IncorrectLinesCount(): number {
+    return this.IncorrectLines.length;
+  }
 
-    /**
-     * @returns a count of all not parsed lines
-     */
-    get NotParsedLinesCount(): number {
-        return this.NotParsedLines.length;
-    }
+  /**
+   * @returns a count of all not parsed lines
+   */
+  get NotParsedLinesCount(): number {
+    return this.NotParsedLines.length;
+  }
 
-    /**
-     * @returns a count of all not parsed lines
-     */
-    get NotParsedLinesWithoutGEDCOMTagCount(): number {
-        return this.NotParsedLinesWithoutGEDCOMTag.length;
-    }
+  /**
+   * @returns a count of all not parsed lines
+   */
+  get NotParsedLinesWithoutGEDCOMTagCount(): number {
+    return this.NotParsedLinesWithoutGEDCOMTag.length;
+  }
 
-    /**
-     * @returns a count of all processed lines
-     */
-    get LinesCount(): number {
-        return this.ParsedLines.length + this.IncorrectLines.length + this.NotParsedLines.length + this.NotParsedLinesWithoutGEDCOMTag.length;
-    }
+  /**
+   * @returns a count of all processed lines
+   */
+  get LinesCount(): number {
+    return this.ParsedLines.length + this.IncorrectLines.length + this.NotParsedLines.length + this.NotParsedLinesWithoutGEDCOMTag.length;
+  }
 
-    /**
-     * @returns a comma separated list of all not parsed line numbers
-     */
-    get NotParsedLinesList(): string {
-        let lineNumbers: number[] = [];
-        this.NotParsedLines.forEach(line => {
-            lineNumbers.push(line.LineNumber);
-        });
+  /**
+   * @returns a comma separated list of all not parsed line numbers
+   */
+  get NotParsedLinesList(): string {
+    let lineNumbers: number[] = [];
+    this.NotParsedLines.forEach((line) => {
+      lineNumbers.push(line.LineNumber);
+    });
 
-        return join(lineNumbers, ", ");
-    }
-}
+    return join(lineNumbers, ', ');
+  }
+}

package/src/ToJSON/models/Store.ts

@@ -1,142 +1,140 @@
-import dropRight from "lodash/dropRight";
-import split from "lodash/split";
-import map from "lodash/map";
-import flattenDeep from "lodash/flattenDeep";
+import dropRight from 'lodash/dropRight';
+import split from 'lodash/split';
+import map from 'lodash/map';
+import flattenDeep from 'lodash/flattenDeep';
 import remove from 'lodash/remove';
 import find from 'lodash/find';
 import isEqual from 'lodash/isEqual';
 
-import objectPath from "object-path";
-import fclone from "fclone";
+import objectPath from 'object-path';
+import fclone from 'fclone';
 
-import TagDefinition from "./TagDefinition";
-import ParsedLine from "./ParsedLine";
-import ConvertToTime from "./converter/ConvertToTime";
-import ParsingObject from "./ParsingObject";
-import ParsingPath from "./ParsingPath";
+import TagDefinition from './TagDefinition';
+import ParsedLine from './ParsedLine';
+import ConvertToTime from './converter/ConvertToTime';
+import ParsingObject from './ParsingObject';
+import ParsingPath from './ParsingPath';
 
-import { CreateResult } from "../processing/result";
-import { IsEmpty } from "../../common";
-import { AddStartWith, ManipulateValue } from "../processing/manipulateValues";
-import DefinitionCache from "./DefinitionCache";
+import { CreateResult } from '../processing/result';
+import { IsEmpty } from '../../common';
+import { AddStartWith, ManipulateValue } from '../processing/manipulateValues';
+import DefinitionCache from './DefinitionCache';
 
 export default class Store {
-    constructor() {
-        this.objects = [];
-        this.path = [];
-        this.isParsing = false;
-        this.stopParsingTillLevel = undefined;
-    }
-
-    private objects: ParsingObject[];
-    /*
+  constructor() {
+    this.objects = [];
+    this.path = [];
+    this.isParsing = false;
+    this.stopParsingTillLevel = undefined;
+  }
+
+  private objects: ParsingObject[];
+  /*
         the actual parsed path
     */
-    private path: ParsingPath[];
+  private path: ParsingPath[];
 
-    /*
+  /*
         if true the line will be parsed, when false all lines will be ignored until a new defined tag with level 0 is found
     */
-    private isParsing: Boolean;
+  private isParsing: Boolean;
 
-    private stopParsingTillLevel?: Number;
+  private stopParsingTillLevel?: Number;
 
-    private definitionCache: DefinitionCache[] = [];
+  private definitionCache: DefinitionCache[] = [];
 
-    AddDefinitionToCache(path: string[], definition: any) {
-        this.definitionCache.push(new DefinitionCache(path, definition));
-    }
+  AddDefinitionToCache(path: string[], definition: any) {
+    this.definitionCache.push(new DefinitionCache(path, definition));
+  }
 
-    GetDefinitionFromCache(path: string[]) {
-        return find(this.definitionCache, x => isEqual(path, x.Path))
-    }
+  GetDefinitionFromCache(path: string[]) {
+    return find(this.definitionCache, (x) => isEqual(path, x.Path));
+  }
 
-    AddTempPath() {
-        this.path.push(new ParsingPath("TEMP", ""));
-    }
+  AddTempPath() {
+    this.path.push(new ParsingPath('TEMP', ''));
+  }
 
-    StartParsing(definition: TagDefinition, line: ParsedLine) {
-        this.isParsing = true;
-        this.path.push(new ParsingPath(definition.Tag, definition.Path));
-
-        // concat path and remove empty values
-        let path = flattenDeep(map(fclone(this.path), x => split(x.Path, ".")));
-        remove(path, x => IsEmpty(x));
-
-        let obj = new ParsingObject(definition, line, path);
-
-        // if no value is set, but the value should start with a specific value -> set the value and remove the property
-        if (!(line.ReferenceId || line.Value)) {
-            line.Value = AddStartWith(definition.StartWith, line.Value);
-            definition.StartWith = undefined;
-        }
-
-        if (definition.Property && (line.ReferenceId || line.Value)) {
-            if (definition.CollectAs) {
-                objectPath.set(obj.Object, definition.Property, ManipulateValue(definition, line));
-            }
-            else {
-                obj.Object = ManipulateValue(definition, line);
-            }
-        }
-        else {
-            // time has no own property, but must be merged with the last date
-            if (definition.ConvertTo instanceof ConvertToTime) {
-                ManipulateValue(definition, line);
-            }
-        }
-
-        this.objects.push(obj);
-    }
+  StartParsing(definition: TagDefinition, line: ParsedLine) {
+    this.isParsing = true;
+    this.path.push(new ParsingPath(definition.Tag, definition.Path));
 
-    IsParsing(): Boolean {
-        return this.isParsing;
-    }
+    // concat path and remove empty values
+    let path = flattenDeep(map(fclone(this.path), (x) => split(x.Path, '.')));
+    remove(path, (x) => IsEmpty(x));
 
-    DropRightPath(number?: number) {
-        if (!number) {
-            this.path = dropRight(this.path, number);
-            return;
-        }
-        
-        this.path = dropRight(this.path, this.path.length - number);
-    }
+    let obj = new ParsingObject(definition, line, path);
 
-    GetPath() {
-        return this.path;
+    // if no value is set, but the value should start with a specific value -> set the value and remove the property
+    if (!(line.ReferenceId || line.Value)) {
+      line.Value = AddStartWith(definition.StartWith, line.Value);
+      definition.StartWith = undefined;
     }
 
-    CreateResultObject() {
-        return CreateResult(this.objects);
+    if (definition.Property && (line.ReferenceId || line.Value)) {
+      if (definition.CollectAs) {
+        objectPath.set(obj.Object, definition.Property, ManipulateValue(definition, line));
+      } else {
+        obj.Object = ManipulateValue(definition, line);
+      }
+    } else {
+      // time has no own property, but must be merged with the last date
+      if (definition.ConvertTo instanceof ConvertToTime) {
+        ManipulateValue(definition, line);
+      }
     }
 
-    StopParsingUntilLevel(level: Number) {
-        this.stopParsingTillLevel = level;
+    this.objects.push(obj);
+  }
+
+  IsParsing(): Boolean {
+    return this.isParsing;
+  }
+
+  DropRightPath(number?: number) {
+    if (!number) {
+      this.path = dropRight(this.path, number);
+      return;
     }
 
-    ShouldParseLine(level: Number): Boolean {
-        if (!this.stopParsingTillLevel) {
-            return true;
-        }
+    this.path = dropRight(this.path, this.path.length - number);
+  }
 
-        if (level <= this.stopParsingTillLevel) {
-            this.stopParsingTillLevel = 0;
-            return true;
-        }
+  GetPath() {
+    return this.path;
+  }
 
-        return false;
-    }
+  CreateResultObject() {
+    return CreateResult(this.objects);
+  }
+
+  StopParsingUntilLevel(level: Number) {
+    this.stopParsingTillLevel = level;
+  }
 
-    Reset() {
-        this.isParsing = false;
-        this.path = [];
-        this.stopParsingTillLevel = undefined;
-        this.definitionCache = [];
+  ShouldParseLine(level: Number): Boolean {
+    if (!this.stopParsingTillLevel) {
+      return true;
     }
 
-    FullReset() {
-        this.Reset();
-        this.objects = [];
-        this.definitionCache = [];
+    if (level <= this.stopParsingTillLevel) {
+      this.stopParsingTillLevel = 0;
+      return true;
     }
-}
+
+    return false;
+  }
+
+  Reset() {
+    this.isParsing = false;
+    this.path = [];
+    this.stopParsingTillLevel = undefined;
+    this.definitionCache = [];
+  }
+
+  FullReset() {
+    this.Reset();
+    this.objects = [];
+    this.definitionCache = [];
+  }
+}

package/src/ToJSON/models/TagDefinition.ts

@@ -1,144 +1,145 @@
-import isObject from "lodash/isObject";
+import isObject from 'lodash/isObject';
 
-import ConvertTo from "./converter/ConvertTo";
-import ConvertToArray from "./converter/ConvertToArray";
-import ConvertToDate from "./converter/ConvertToDate";
-import ConvertToString from "./converter/ConvertToString";
-import ConvertToTime from "./converter/ConvertToTime";
+import ConvertTo from './converter/ConvertTo';
+import ConvertToArray from './converter/ConvertToArray';
+import ConvertToDate from './converter/ConvertToDate';
+import ConvertToString from './converter/ConvertToString';
+import ConvertToTime from './converter/ConvertToTime';
 
 export default class TagDefinition {
-    constructor(plainJsObject: any) {
-        this.CollectAs = plainJsObject.CollectAs;
-        this.Tag = plainJsObject.Tag;
-        this.MergeWithLast = plainJsObject.MergeWithLast?.toString();
-        this.MergeWithNext = plainJsObject.MergeWithNext;      
-        this.Type = plainJsObject.Type;
-        this.IsSingleValue = plainJsObject.IsSingleValue;
-        this.CollectAsArray = plainJsObject.CollectAsArray === true;
-        this.StartWith = plainJsObject.StartWith;        
-        
-        if (isObject(plainJsObject.Property)) {
-            let propertyWithOption = new PropertyWithOption(plainJsObject.Property);
-            this.Property = propertyWithOption.Name;
-            this.PropertyType = propertyWithOption.Type;
-        }
-        else {
-            this.Property = plainJsObject.Property;
-        }
-        
-        if (plainJsObject.Replace) {
-            this.Replace = new ReplaceValue(plainJsObject.Replace.Value, plainJsObject.Replace.With);
-        }
-
-        if (plainJsObject.StripHtml) {
-            this.StripHtml = plainJsObject.StripHtml;
-        }
-
-        this.ConvertTo = CreateConvertTo(plainJsObject.Type, plainJsObject.ConvertTo);
+  constructor(plainJsObject: any) {
+    this.CollectAs = plainJsObject.CollectAs;
+    this.Tag = plainJsObject.Tag;
+    this.MergeWithLast = plainJsObject.MergeWithLast?.toString();
+    this.MergeWithNext = plainJsObject.MergeWithNext;
+    this.Type = plainJsObject.Type;
+    this.IsSingleValue = plainJsObject.IsSingleValue;
+    this.CollectAsArray = plainJsObject.CollectAsArray === true;
+    this.StartWith = plainJsObject.StartWith;
+
+    if (isObject(plainJsObject.Property)) {
+      let propertyWithOption = new PropertyWithOption(plainJsObject.Property);
+      this.Property = propertyWithOption.Name;
+      this.PropertyType = propertyWithOption.Type;
+    } else {
+      this.Property = plainJsObject.Property;
     }
 
-    CollectAs?: string;
-    StartWith?: string;
-    CollectAsArray?: Boolean;
-    Property?: string;
-    Tag: string = "";
-    MergeWithLast?: string;
-    Replace?: ReplaceValue;
-    StripHtml?: Boolean;
-    ConvertTo?: ConvertTo;
-    Type?: string;
-    MergeWithNext?: string;
-    IsSingleValue?: Boolean;
-    PropertyType?: ConvertTo;
-
-    get Path(): string {
-        return this.CollectAs ?? this.Property ?? "";
+    if (plainJsObject.Replace) {
+      this.Replace = new ReplaceValue(plainJsObject.Replace.Value, plainJsObject.Replace.With);
     }
-}
 
-class ReplaceValue {
-    constructor(value: string, withProperty: string) {
-        this.Value = value;
-        this.With = withProperty;
+    if (plainJsObject.StripHtml) {
+      this.StripHtml = plainJsObject.StripHtml;
     }
 
-    Value: string;
-    With: string;
+    this.ConvertTo = CreateConvertTo(plainJsObject.Type, plainJsObject.ConvertTo);
+  }
+
+  CollectAs?: string;
+  StartWith?: string;
+  CollectAsArray?: Boolean;
+  Property?: string;
+  Tag: string = '';
+  MergeWithLast?: string;
+  Replace?: ReplaceValue;
+  StripHtml?: Boolean;
+  ConvertTo?: ConvertTo;
+  Type?: string;
+  MergeWithNext?: string;
+  IsSingleValue?: Boolean;
+  PropertyType?: ConvertTo;
+
+  get Path(): string {
+    return this.CollectAs ?? this.Property ?? '';
+  }
 }
 
-class PropertyWithOption {
-    constructor(property: any) {
-        this.Name = property.Name;
-
-        if (property.Type) {
-            this.Type = CreateConvertTo(property.Type);   
-            return;
-        }
-
-        this.Type = CreateConvertTo(undefined, property.ConvertTo);
-    }
+class ReplaceValue {
+  constructor(value: string, withProperty: string) {
+    this.Value = value;
+    this.With = withProperty;
+  }
 
-    Name?: string;
-    Type?: ConvertTo;
+  Value: string;
+  With: string;
 }
 
-function CreateConvertTo(type?: string, convertTo?: any) : ConvertTo | undefined {
-    let setConvertToDate = () : ConvertToDate => {
-        return new ConvertToDate(convertTo?.About,
-            convertTo?.Calculated,
-            convertTo?.Estimated,
-            convertTo?.Before,
-            convertTo?.After,
-            convertTo?.Between,
-            convertTo?.And,
-            convertTo?.Interpreted,
-            convertTo?.From,
-            convertTo?.To,
-            convertTo?.Value,
-            convertTo?.HasMonth,
-            convertTo?.HasYear,
-            convertTo?.HasDay,
-            convertTo?.Original,
-            convertTo?.Calendar);
-    }
+class PropertyWithOption {
+  constructor(property: any) {
+    this.Name = property.Name;
 
-    let setConvertToString = () : ConvertToString => {
-        return new ConvertToString(convertTo?.NewLineCharacter, convertTo?.NewLineIfEmpty);
+    if (property.Type) {
+      this.Type = CreateConvertTo(property.Type);
+      return;
     }
 
-    let setConvertToArray = () : ConvertToArray => {
-        return new ConvertToArray(convertTo?.Delimiter);
-    }
+    this.Type = CreateConvertTo(undefined, property.ConvertTo);
+  }
 
-    let setConvertToTime = () : ConvertToTime => {
-        return new ConvertToTime();
-    }
+  Name?: string;
+  Type?: ConvertTo;
+}
 
-    if (type) {
-        switch(type) {
-            case "Date":
-                return setConvertToDate();
-            case "String":
-                return setConvertToString();
-            case "Array":
-                return setConvertToArray();
-            case "Time":
-                return setConvertToTime();
-        }
+function CreateConvertTo(type?: string, convertTo?: any): ConvertTo | undefined {
+  let setConvertToDate = (): ConvertToDate => {
+    return new ConvertToDate(
+      convertTo?.About,
+      convertTo?.Calculated,
+      convertTo?.Estimated,
+      convertTo?.Before,
+      convertTo?.After,
+      convertTo?.Between,
+      convertTo?.And,
+      convertTo?.Interpreted,
+      convertTo?.From,
+      convertTo?.To,
+      convertTo?.Value,
+      convertTo?.HasMonth,
+      convertTo?.HasYear,
+      convertTo?.HasDay,
+      convertTo?.Original,
+      convertTo?.Calendar
+    );
+  };
+
+  let setConvertToString = (): ConvertToString => {
+    return new ConvertToString(convertTo?.NewLineCharacter, convertTo?.NewLineIfEmpty);
+  };
+
+  let setConvertToArray = (): ConvertToArray => {
+    return new ConvertToArray(convertTo?.Delimiter);
+  };
+
+  let setConvertToTime = (): ConvertToTime => {
+    return new ConvertToTime();
+  };
+
+  if (type) {
+    switch (type) {
+      case 'Date':
+        return setConvertToDate();
+      case 'String':
+        return setConvertToString();
+      case 'Array':
+        return setConvertToArray();
+      case 'Time':
+        return setConvertToTime();
     }
-
-    if (convertTo) {
-        switch(convertTo.Type) {
-            case "String":
-                return setConvertToString();
-            case "Date":
-                return setConvertToDate();
-            case "Array":
-                return setConvertToArray();
-            case "Time":
-                return setConvertToTime();
-        }
+  }
+
+  if (convertTo) {
+    switch (convertTo.Type) {
+      case 'String':
+        return setConvertToString();
+      case 'Date':
+        return setConvertToDate();
+      case 'Array':
+        return setConvertToArray();
+      case 'Time':
+        return setConvertToTime();
     }
+  }
 
-    return;
-}
+  return;
+}