gedcom.json 1.0.8 → 1.0.10

package/src/ToJSON/parsing/processLine.ts

@@ -6,7 +6,7 @@ import drop from 'lodash/drop';
 
 import fclone from 'fclone';
 
-import ParsedLine from "../models/ParsedLine";
+import ParsedLine from '../models/ParsedLine';
 import Store from '../models/Store';
 import TagDefinition from '../models/TagDefinition';
 import LineParsingResult from '../models/LineParsingResult';
@@ -25,164 +25,167 @@ let store = new Store();
 
 /**
  * Resets all variables, which are used for parsing
-*/
+ */
 export function ResetProcessing() {
-    store.Reset();
-    parsingOptions = {};
+  store.Reset();
+  parsingOptions = {};
 }
 
 export function SetParsingOptions(options: any) {
-    parsingOptions = options;
+  parsingOptions = options;
 }
 
 export function GetResult() {
-    let result = store.CreateResultObject();
-    store.FullReset();
-    return result;
+  let result = store.CreateResultObject();
+  store.FullReset();
+  return result;
 }
 
 export function EndProcessing() {
-    store.Reset();    
-    ClearDateTimeMergingInfos();
+  store.Reset();
+  ClearDateTimeMergingInfos();
 }
 
-export function ProcessLine(line: ParsedLine, lastLevel: number) : LineParsingResult {
-    if (!line || !line.Tag) {
-        return new LineParsingResult(false, "No line or no line tag found");
-    }
+export function ProcessLine(line: ParsedLine, lastLevel: number): LineParsingResult {
+  if (!line || !line.Tag) {
+    return new LineParsingResult(false, 'No line or no line tag found');
+  }
 
-    if (line.Level === 0) {
-        let process = ProcessStartLevel(line);
-        return new LineParsingResult(process, process ? undefined : "No tag definition found");
-    }
+  if (line.Level === 0) {
+    let process = ProcessStartLevel(line);
+    return new LineParsingResult(process, process ? undefined : 'No tag definition found');
+  }
 
-    if (!store.IsParsing()) {
-        return new LineParsingResult(false, "Parent has no parsing definition");
-    }
+  if (!store.IsParsing()) {
+    return new LineParsingResult(false, 'Parent has no parsing definition');
+  }
 
-    if (!store.ShouldParseLine(line.Level)) {
-        return new LineParsingResult(false, "Parent has no parsing definition, so all children will be ignored");
-    }
+  if (!store.ShouldParseLine(line.Level)) {
+    return new LineParsingResult(false, 'Parent has no parsing definition, so all children will be ignored');
+  }
 
-    AdjustPath(line, lastLevel);
+  AdjustPath(line, lastLevel);
 
-    let definition = GetLocalDefinition(line.Tag)
+  let definition = GetLocalDefinition(line.Tag);
 
-    if (!definition) {
-        definition = GetTagDefinition(line.Tag);
-    }
+  if (!definition) {
+    definition = GetTagDefinition(line.Tag);
+  }
 
-    if (!definition) {
-        store.StopParsingUntilLevel(line.Level);
+  if (!definition) {
+    store.StopParsingUntilLevel(line.Level);
 
-        // add temporaray path, that will be removed later
-        store.AddTempPath();
-        return new LineParsingResult(false, "No tag definition found");
-    }
+    // add temporaray path, that will be removed later
+    store.AddTempPath();
+    return new LineParsingResult(false, 'No tag definition found');
+  }
+
+  store.StartParsing(definition, line);
 
-    store.StartParsing(definition, line);
-    
-    return new LineParsingResult(true);
+  return new LineParsingResult(true);
 }
 
 function GetLocalDefinition(tag: string): TagDefinition | undefined {
-    let path = fclone(store.GetPath());
+  let path = fclone(store.GetPath());
 
-    /* istanbul ignore next */ // should never happen
-    if (path.length === 0) {
-        return undefined;
-    }
+  /* istanbul ignore next */ // should never happen
+  if (path.length === 0) {
+    return undefined;
+  }
 
-    let definition = SearchDefinitionDeep(parsingOptions.Definition, path, tag);
-    
-    if (!definition) {
-        return undefined;
-    }
+  let definition = SearchDefinitionDeep(parsingOptions.Definition, path, tag);
+
+  if (!definition) {
+    return undefined;
+  }
 
-    return new TagDefinition(definition);
+  return new TagDefinition(definition);
 }
 
 export function SearchDefinitionDeep(properties: any[], searchpath: ParsingPath[], searchedTag: string): any {
-    // search path
-    let specificPath = map(searchpath, x => x.Tag);
-    specificPath.push(searchedTag);
+  // search path
+  let specificPath = map(searchpath, (x) => x.Tag);
+  specificPath.push(searchedTag);
 
-    let cachedValue = store.GetDefinitionFromCache(specificPath);
+  let cachedValue = store.GetDefinitionFromCache(specificPath);
 
-    if (cachedValue) {
-        return cachedValue.Definition;
-    }
+  if (cachedValue) {
+    return cachedValue.Definition;
+  }
 
-    // search all tag definitions
-    let tagDefinitions: any[] = [];
-    eachDeep(properties, (val:any, key:string, parent:any, context:any) => {
-        if (key === "Tag" && val === searchedTag) {
-             tagDefinitions.push({
-                Definition: parent,
-                Path: filter(map(context.parents, x => x.value.Tag), x => x !== undefined)
-            });
-        }
-    });
-
-    // explicit local path
-    let pathStartWithsTag;
-
-    // drop first tag until found -> last is global definition
-    while(!pathStartWithsTag && specificPath.length > 0) {
-        pathStartWithsTag = find(tagDefinitions, y => isEqual(y.Path, specificPath));
-
-        if (!pathStartWithsTag) {
-            specificPath = drop(specificPath);
-        }
+  // search all tag definitions
+  let tagDefinitions: any[] = [];
+  eachDeep(properties, (val: any, key: string, parent: any, context: any) => {
+    if (key === 'Tag' && val === searchedTag) {
+      tagDefinitions.push({
+        Definition: parent,
+        Path: filter(
+          map(context.parents, (x) => x.value.Tag),
+          (x) => x !== undefined
+        ),
+      });
     }
+  });
 
-    if (pathStartWithsTag?.Definition) {
-        let foundPath = map(searchpath, x => x.Tag);
-        foundPath.push(searchedTag);
-        store.AddDefinitionToCache(foundPath, pathStartWithsTag.Definition);
+  // explicit local path
+  let pathStartWithsTag;
+
+  // drop first tag until found -> last is global definition
+  while (!pathStartWithsTag && specificPath.length > 0) {
+    pathStartWithsTag = find(tagDefinitions, (y) => isEqual(y.Path, specificPath));
+
+    if (!pathStartWithsTag) {
+      specificPath = drop(specificPath);
     }
+  }
+
+  if (pathStartWithsTag?.Definition) {
+    let foundPath = map(searchpath, (x) => x.Tag);
+    foundPath.push(searchedTag);
+    store.AddDefinitionToCache(foundPath, pathStartWithsTag.Definition);
+  }
 
-    return pathStartWithsTag?.Definition;
+  return pathStartWithsTag?.Definition;
 }
 
 function AdjustPath(line: ParsedLine, lastLevel: number) {
-    if (line.Level > lastLevel) {
-        return;
-    }
+  if (line.Level > lastLevel) {
+    return;
+  }
 
-    if (line.Level === lastLevel) {
-        store.DropRightPath();
-        return;
-    }
+  if (line.Level === lastLevel) {
+    store.DropRightPath();
+    return;
+  }
 
-    store.DropRightPath(line.Level);
-    ClearDateTimeMergingInfos();
+  store.DropRightPath(line.Level);
+  ClearDateTimeMergingInfos();
 }
 
 function GetTagDefinition(tag: string): TagDefinition | undefined {
-    let definition = find(parsingOptions.Definition, x => x.Tag === tag);
+  let definition = find(parsingOptions.Definition, (x) => x.Tag === tag);
 
-    if (!definition) {
-        return undefined;
-    }
+  if (!definition) {
+    return undefined;
+  }
 
-    return new TagDefinition(definition);
+  return new TagDefinition(definition);
 }
 
-export function ProcessStartLevel(line: ParsedLine) : Boolean  {
-    if (line.Tag === "TRLR") {
-        return true;
-    }
+export function ProcessStartLevel(line: ParsedLine): Boolean {
+  if (line.Tag === 'TRLR') {
+    return true;
+  }
 
-    EndProcessing();
-    let definition = GetTagDefinition(line.Tag);
+  EndProcessing();
+  let definition = GetTagDefinition(line.Tag);
 
-    if (!definition) {
-        return false;
-    }
+  if (!definition) {
+    return false;
+  }
 
-    store.StartParsing(definition, line);
-    ClearDateTimeMergingInfos();
+  store.StartParsing(definition, line);
+  ClearDateTimeMergingInfos();
 
-    return true;
-}
+  return true;
+}

package/src/ToJSON/processing/manipulateValues.ts

@@ -1,83 +1,82 @@
-import isEmpty from "lodash/isEmpty";
+import isEmpty from 'lodash/isEmpty';
 import trim from 'lodash/trim';
 import replace from 'lodash/replace';
 import split from 'lodash/split';
 import map from 'lodash/map';
 
-import ParsedLine from "../models/ParsedLine";
-import TagDefinition from "../models/TagDefinition";
-import ConvertToDate from "../models/converter/ConvertToDate";
-import ConvertToArray from "../models/converter/ConvertToArray";
+import ParsedLine from '../models/ParsedLine';
+import TagDefinition from '../models/TagDefinition';
+import ConvertToDate from '../models/converter/ConvertToDate';
+import ConvertToArray from '../models/converter/ConvertToArray';
 
-import { ConvertDateStringToObject, ConvertTimeStringToObject } from "../parsing/parseDate";
-import ConvertToTime from "../models/converter/ConvertToTime";
+import { ConvertDateStringToObject, ConvertTimeStringToObject } from '../parsing/parseDate';
+import ConvertToTime from '../models/converter/ConvertToTime';
 
 export function ManipulateValue(definition: TagDefinition, line: ParsedLine) {
-    let value:string = trim(isEmpty(line.ReferenceId) ? line.Value : line.ReferenceId);
-    let convertTo = definition.PropertyType ?? definition.ConvertTo;
+  let value: string = trim(isEmpty(line.ReferenceId) ? line.Value : line.ReferenceId);
+  let convertTo = definition.PropertyType ?? definition.ConvertTo;
 
-    if (value.match(/^(@.*@)/)) {
+  if (value.match(/^(@.*@)/)) {
+    if (definition.ConvertTo instanceof ConvertToArray) {
+      return ConvertStringToArray(definition.ConvertTo, value);
+    }
 
-        if (definition.ConvertTo instanceof ConvertToArray) {
-            return ConvertStringToArray(definition.ConvertTo, value);
-        }
-        
-        return value;
-    };
+    return value;
+  }
 
-    value = AddStartWith(definition.StartWith, value);
+  value = AddStartWith(definition.StartWith, value);
 
-    if (definition.Replace) {
-        let pattern = definition.Replace.Value;
-        let replacement = definition.Replace.With;
+  if (definition.Replace) {
+    let pattern = definition.Replace.Value;
+    let replacement = definition.Replace.With;
 
-        if (pattern && replacement){
-            value = replace(value, pattern, replacement);
-        }
+    if (pattern && replacement) {
+      value = replace(value, pattern, replacement);
     }
+  }
 
-    if (definition.StripHtml){
-        value = value.replace(/(<([^>]+)>)/gi, "");
-    }
+  if (definition.StripHtml) {
+    value = value.replace(/(<([^>]+)>)/gi, '');
+  }
 
-    if (!convertTo) {
-        return value;
-    }
+  if (!convertTo) {
+    return value;
+  }
 
-    if (convertTo instanceof ConvertToDate) {
-        return ConvertDateStringToObject(convertTo, value);
-    }
+  if (convertTo instanceof ConvertToDate) {
+    return ConvertDateStringToObject(convertTo, value);
+  }
 
-    if (convertTo instanceof ConvertToTime) {
-        return ConvertTimeStringToObject(value, definition.Property);
-    }
+  if (convertTo instanceof ConvertToTime) {
+    return ConvertTimeStringToObject(value, definition.Property);
+  }
 
-    if (convertTo instanceof ConvertToArray) {
-        return ConvertStringToArray(convertTo, value);
-    }
+  if (convertTo instanceof ConvertToArray) {
+    return ConvertStringToArray(convertTo, value);
+  }
 
-    return value;
+  return value;
 }
 
 export function AddStartWith(startWith: string | undefined, value: string | undefined): string {
-    if (!startWith) {
-        return value ?? '';
-    }
+  if (!startWith) {
+    return value ?? '';
+  }
 
-    if (startWith === "\\n") {
-        startWith = "\n";
-    }
+  if (startWith === '\\n') {
+    startWith = '\n';
+  }
 
-    if (!value) {
-        return startWith;
-    }
+  if (!value) {
+    return startWith;
+  }
 
-    return `${startWith}${value}`;
+  return `${startWith}${value}`;
 }
 
 function ConvertStringToArray(convertOptions: ConvertToArray, value: string) {
-    let arr = split(value, convertOptions.Delimiter);
-    arr = map(arr, x => trim(x));
+  let arr = split(value, convertOptions.Delimiter);
+  arr = map(arr, (x) => trim(x));
 
-    return arr;
-}
+  return arr;
+}