gedcom.json 1.0.8 → 1.0.10

package/src/ToJSON/processing/result.ts

@@ -4,11 +4,11 @@ import find from 'lodash/find';
 import findLast from 'lodash/findLast';
 import remove from 'lodash/remove';
 import isEqual from 'lodash/isEqual';
-import split from "lodash/split";
+import split from 'lodash/split';
 import forEach from 'lodash/forEach';
 import isObject from 'lodash/isObject';
 import isArray from 'lodash/isArray';
-import dropRight from "lodash/dropRight";
+import dropRight from 'lodash/dropRight';
 import indexOf from 'lodash/indexOf';
 import take from 'lodash/take';
 import slice from 'lodash/slice';
@@ -18,7 +18,7 @@ import last from 'lodash/last';
 import keys from 'lodash/keys';
 import first from 'lodash/first';
 
-import objectPath from "object-path";
+import objectPath from 'object-path';
 
 import ParsingObject from '../models/ParsingObject';
 import TagDefinition from '../models/TagDefinition';
@@ -30,67 +30,66 @@ import fclone from 'fclone';
 import { AddStartWith } from './manipulateValues';
 
 export function CreateResult(objects: ParsingObject[]) {
-    // collect all main objects
-    let mainObjectIndexes = GetMainObjectIndexes(objects);
-    let mainObjects: MainObject[] = [];
-
-    // create all main objects
-    forEach(mainObjectIndexes, mainObjectIndex => {
-        let mainObjectSubObjects = take(slice(objects, mainObjectIndex.StartIndex), mainObjectIndex.EndIndex - mainObjectIndex.StartIndex);
-        mainObjects.push(CreateMainObject(mainObjectSubObjects));
-    });
-
-    // merge all main objects together
-    let result = {};
-    forEach(mainObjects, mainObject => {        
-        SetObject(result, mainObject.Informations.PropertyPath, mainObject.Result, mainObject.Informations.Definition);
-    });
-
-    return result;
+  // collect all main objects
+  let mainObjectIndexes = GetMainObjectIndexes(objects);
+  let mainObjects: MainObject[] = [];
+
+  // create all main objects
+  forEach(mainObjectIndexes, (mainObjectIndex) => {
+    let mainObjectSubObjects = take(slice(objects, mainObjectIndex.StartIndex), mainObjectIndex.EndIndex - mainObjectIndex.StartIndex);
+    mainObjects.push(CreateMainObject(mainObjectSubObjects));
+  });
+
+  // merge all main objects together
+  let result = {};
+  forEach(mainObjects, (mainObject) => {
+    SetObject(result, mainObject.Informations.PropertyPath, mainObject.Result, mainObject.Informations.Definition);
+  });
+
+  return result;
 }
 
 export function CreateMainObject(objects: ParsingObject[]): MainObject {
-    let result = {};
-
-    // concat objects
-    let mergeWithLastValue = filter(objects, x => x.Definition.MergeWithLast === "true") as ParsingObject[];
-    let mergeValue = "";
-
-    forEachRight(mergeWithLastValue, obj => {
-        let index = indexOf(objects, obj);
-        let objectsToSearch = take(objects, index);
-        let mergeObject = last(objectsToSearch);    
-
-        let val = obj.Line.Value;
-        val = AddStartWith(obj.Definition.StartWith, val);
-        if (!mergeObject) {
-            mergeValue = val;
-            return;
-        }
-
-        if (!isEmpty(obj.Object) && (isArray(obj.Object) || isObject(obj.Object))) {
- 
-            SetOrCreateArray(mergeObject.Object, split(obj.Definition.Path, "."), obj.Definition, obj.Object);            
-            remove(objects, x => isEqual(x, obj));
-            return;
-        }
-
-        if (mergeObject.Definition.MergeWithLast === "true") {
-            mergeValue = `${val}${mergeValue}`;
-            remove(objects, x => isEqual(x, obj));
-            return;
-        }
-
-        mergeValue = `${val}${mergeValue}`;
-        
-        if (isString(mergeObject.Object)) {
-            mergeObject.Object += mergeValue;
-            mergeValue = "";
-            remove(objects, x => isEqual(x, obj));
-            return;
-        }
-
-        /*
+  let result = {};
+
+  // concat objects
+  let mergeWithLastValue = filter(objects, (x) => x.Definition.MergeWithLast === 'true') as ParsingObject[];
+  let mergeValue = '';
+
+  forEachRight(mergeWithLastValue, (obj) => {
+    let index = indexOf(objects, obj);
+    let objectsToSearch = take(objects, index);
+    let mergeObject = last(objectsToSearch);
+
+    let val = obj.Line.Value;
+    val = AddStartWith(obj.Definition.StartWith, val);
+    if (!mergeObject) {
+      mergeValue = val;
+      return;
+    }
+
+    if (!isEmpty(obj.Object) && (isArray(obj.Object) || isObject(obj.Object))) {
+      SetOrCreateArray(mergeObject.Object, split(obj.Definition.Path, '.'), obj.Definition, obj.Object);
+      remove(objects, (x) => isEqual(x, obj));
+      return;
+    }
+
+    if (mergeObject.Definition.MergeWithLast === 'true') {
+      mergeValue = `${val}${mergeValue}`;
+      remove(objects, (x) => isEqual(x, obj));
+      return;
+    }
+
+    mergeValue = `${val}${mergeValue}`;
+
+    if (isString(mergeObject.Object)) {
+      mergeObject.Object += mergeValue;
+      mergeValue = '';
+      remove(objects, (x) => isEqual(x, obj));
+      return;
+    }
+
+    /*
             startlevel to has greater than null, because
 
             1 EVEN RCKarnes-RootsWeb & John D Newport-Ancestry.com (johndnewport@valornet
@@ -107,227 +106,234 @@ export function CreateMainObject(objects: ParsingObject[]): MainObject {
             NOT!
 
          */
-        if (mergeObject.StartLevel > 0 && isObject(mergeObject.Object)) {
-            let key = last(keys(mergeObject.Object));
-            
-            if (!key) {
-                return;
-            }
-
-            let value = objectPath.get(mergeObject.Object, key);
-
-            if (!isString(value)) {
-                return;
-            }
-
-            objectPath.set(mergeObject.Object, key, `${value}${mergeValue}`);
-            mergeValue = "";
-            remove(objects, x => isEqual(x, obj));
-            return;
-        }
-    });
+    if (mergeObject.StartLevel > 0 && isObject(mergeObject.Object)) {
+      let key = last(keys(mergeObject.Object));
+
+      if (!key) {
+        return;
+      }
+
+      let value = objectPath.get(mergeObject.Object, key);
+
+      if (!isString(value)) {
+        return;
+      }
 
-    if (!isEmpty(mergeValue)) {
-        let index = indexOf(objects, first(mergeWithLastValue));
-        let objectsToSearch = take(objects, index);
-        let mergeObject = last(objectsToSearch); 
-        
-        if (mergeObject) {
-            objectPath.set(mergeObject.Object, "Text", mergeValue);
-            mergeValue = "";
-        }
+      objectPath.set(mergeObject.Object, key, `${value}${mergeValue}`);
+      mergeValue = '';
+      remove(objects, (x) => isEqual(x, obj));
+      return;
     }
+  });
 
-    // move objects to other objects
-    let mergeWithLast = filter(objects, x => x.Definition.MergeWithLast) as ParsingObject[];
+  if (!isEmpty(mergeValue)) {
+    let index = indexOf(objects, first(mergeWithLastValue));
+    let objectsToSearch = take(objects, index);
+    let mergeObject = last(objectsToSearch);
 
-    forEachRight(mergeWithLast, obj => {
-        let index = indexOf(objects, obj);
-        let objectsToSearch = take(objects, index);
+    if (mergeObject) {
+      objectPath.set(mergeObject.Object, 'Text', mergeValue);
+      mergeValue = '';
+    }
+  }
 
-        let mergeObject = findLast(objectsToSearch, x => x.Definition.Tag === obj.Definition.MergeWithLast);
+  // move objects to other objects
+  let mergeWithLast = filter(objects, (x) => x.Definition.MergeWithLast) as ParsingObject[];
 
-        if (mergeObject) {
-            SetOrCreateArray(mergeObject.Object, split(obj.Definition.Path, "."), obj.Definition, obj.Object);            
-            remove(objects, x => isEqual(x, obj));
-        }
-    });
+  forEachRight(mergeWithLast, (obj) => {
+    let index = indexOf(objects, obj);
+    let objectsToSearch = take(objects, index);
 
-    let mergeWithNext = filter(objects, x => x.Definition.MergeWithNext) as ParsingObject[];
+    let mergeObject = findLast(objectsToSearch, (x) => x.Definition.Tag === obj.Definition.MergeWithLast);
 
-    forEachRight(mergeWithNext, obj => {
-        let index = indexOf(objects, obj);
-        let objectsToSearch = slice(objects, index);
-        let mergeObject = find(objectsToSearch, x => x.Definition.Tag === obj.Definition.MergeWithNext);
+    if (mergeObject) {
+      SetOrCreateArray(mergeObject.Object, split(obj.Definition.Path, '.'), obj.Definition, obj.Object);
+      remove(objects, (x) => isEqual(x, obj));
+    }
+  });
 
-        if (mergeObject) {
-            SetOrCreateArray(mergeObject.Object, split(obj.Definition.Path, "."), obj.Definition, obj.Object);                
-            remove(objects, x => isEqual(x, obj));
-        }
-    });
+  let mergeWithNext = filter(objects, (x) => x.Definition.MergeWithNext) as ParsingObject[];
+
+  forEachRight(mergeWithNext, (obj) => {
+    let index = indexOf(objects, obj);
+    let objectsToSearch = slice(objects, index);
+    let mergeObject = find(objectsToSearch, (x) => x.Definition.Tag === obj.Definition.MergeWithNext);
+
+    if (mergeObject) {
+      SetOrCreateArray(mergeObject.Object, split(obj.Definition.Path, '.'), obj.Definition, obj.Object);
+      remove(objects, (x) => isEqual(x, obj));
+    }
+  });
+
+  // set all sub objects in object
+  forEach(objects, (o) => {
+    let obj = o as ParsingObject;
+    let partPath: string[] = [];
+
+    forEach(dropRight(obj.PropertyPath), (property: any) => {
+      if (IsEmpty(property)) {
+        return;
+      }
+
+      partPath.push(property);
 
-    // set all sub objects in object
-    forEach(objects, o => {
-        
-        let obj = o as ParsingObject;
-        let partPath:string[] = [];
-
-        forEach(dropRight(obj.PropertyPath), (property: any) => {
-            if (IsEmpty(property)) {
-                return;
-            }
-
-            partPath.push(property);
-            if (!objectPath.has(result, partPath)) {
-                objectPath.set(result, partPath, {});
-                return;
-            }
-
-            let value = objectPath.get(result, partPath);
-
-            // If path value is an array, add position in array to path
-            if (isArray(value)) {
-                obj.PropertyPath.splice(indexOf(obj.PropertyPath, property) + 1, 0, `${value.length - 1}`);
-            }
-            else if (!isObject(value) && !isArray(value)) {
-                let convertedValue = {};
-                objectPath.set(convertedValue, "Value", value);
-                objectPath.set(result, partPath, convertedValue);
-            }
-        });
-
-        remove(obj.PropertyPath, x => isEmpty(x));
-        SetOrCreateArray(result, obj.PropertyPath, obj.Definition, obj.Object);
+      const parentPath = dropRight(partPath);
+      const parentObj = objectPath.get(result, parentPath);
+
+      if (parentPath.length > 0 && objectPath.has(result, parentPath) && isArray(parentObj)) {
+        partPath = parentPath;
+        partPath.push(`${parentObj.length - 1}`);
+        partPath.push(property);
+      }
+
+      if (!objectPath.has(result, partPath)) {
+        objectPath.set(result, partPath, {});
+        return;
+      }
+
+      let value = objectPath.get(result, partPath);
+
+      // If path value is an array, add position in array to path
+      if (isArray(value)) {
+        obj.PropertyPath.splice(indexOf(obj.PropertyPath, property) + 1, 0, `${value.length - 1}`);
+      } else if (!isObject(value) && !isArray(value)) {
+        let convertedValue = {};
+        objectPath.set(convertedValue, 'Value', value);
+        objectPath.set(result, partPath, convertedValue);
+      }
     });
 
-    return new MainObject(objects[0], result);
+    remove(obj.PropertyPath, (x) => isEmpty(x));
+    SetOrCreateArray(result, obj.PropertyPath, obj.Definition, obj.Object);
+  });
+
+  return new MainObject(objects[0], result);
 }
 
 class MainObject {
-    constructor(informations: ParsingObject, obj: Object) {
-        this.Informations = informations;
-        this.Result = obj;
-    }
+  constructor(informations: ParsingObject, obj: Object) {
+    this.Informations = informations;
+    this.Result = obj;
+  }
 
-    Informations: ParsingObject;
-    Result: Object;
+  Informations: ParsingObject;
+  Result: Object;
 }
 
 export function GetMainObjectIndexes(objects: ParsingObject[]) {
-    // get all objects with level 0
-    let mainObjects = filter(objects, x => x.StartLevel === 0);
-    let mainObjectIndexes: number[] = [];
+  // get all objects with level 0
+  let mainObjects = filter(objects, (x) => x.StartLevel === 0);
+  let mainObjectIndexes: number[] = [];
 
-    forEach(mainObjects, mainObject => {
-        mainObjectIndexes.push(indexOf(objects, mainObject));
-    });
+  forEach(mainObjects, (mainObject) => {
+    mainObjectIndexes.push(indexOf(objects, mainObject));
+  });
 
-    let mainObjectIndexObject = [];
-
-    for(let i = 0; i < mainObjects.length; i++) {
-        let startIndex = mainObjectIndexes[i];
-        let endIndex = 0;
-        
-        if (i === mainObjects.length - 1) {
-            endIndex = objects.length;
-        }
-        else {
-            endIndex = mainObjectIndexes[i + 1];
-        }
-
-        mainObjectIndexObject.push({
-            StartIndex: startIndex,
-            EndIndex: endIndex
-        });
-    }
+  let mainObjectIndexObject = [];
 
-    return mainObjectIndexObject;
-}
+  for (let i = 0; i < mainObjects.length; i++) {
+    let startIndex = mainObjectIndexes[i];
+    let endIndex = 0;
 
-export function SetObject(mainObject: Object, path: string[], value: Object, definition: TagDefinition) {
-    if (path.length === 0) {
-        assignIn(mainObject, value);
-        return;
+    if (i === mainObjects.length - 1) {
+      endIndex = objects.length;
+    } else {
+      endIndex = mainObjectIndexes[i + 1];
     }
 
-    if (objectPath.has(value, path)) {
-        value = objectPath.get(value, path);
-    }
+    mainObjectIndexObject.push({
+      StartIndex: startIndex,
+      EndIndex: endIndex,
+    });
+  }
 
-    if (!objectPath.has(mainObject, path)) {
-        // should be array
-        if (definition.CollectAsArray) {
-            objectPath.set(mainObject, path, [ value ]);
-            return;
-        }
+  return mainObjectIndexObject;
+}
 
-        objectPath.set(mainObject, path, value);
-        return;
+export function SetObject(mainObject: Object, path: string[], value: Object, definition: TagDefinition) {
+  if (path.length === 0) {
+    assignIn(mainObject, value);
+    return;
+  }
+
+  if (objectPath.has(value, path)) {
+    value = objectPath.get(value, path);
+  }
+
+  if (!objectPath.has(mainObject, path)) {
+    // should be array
+    if (definition.CollectAsArray) {
+      objectPath.set(mainObject, path, [value]);
+      return;
     }
 
-    let oldValue = objectPath.get(mainObject, path);
+    objectPath.set(mainObject, path, value);
+    return;
+  }
 
-    if (isArray(oldValue)) {
-        objectPath.insert(mainObject, path, value, oldValue.length);
-        return;
-    }
+  let oldValue = objectPath.get(mainObject, path);
 
-    objectPath.set(mainObject, path, [ oldValue, value ]);
+  if (isArray(oldValue)) {
+    objectPath.insert(mainObject, path, value, oldValue.length);
+    return;
+  }
+
+  objectPath.set(mainObject, path, [oldValue, value]);
 }
 
 export function SetOrCreateArray(obj: any, path: string[], definition: TagDefinition, value: any) {
-    // should be a single value -> last wins
-    if (definition.IsSingleValue) {
-        if (objectPath.has(obj, path)) {
-            objectPath.del(obj, path);
-        }
+  // should be a single value -> last wins
+  if (definition.IsSingleValue) {
+    if (objectPath.has(obj, path)) {
+      objectPath.del(obj, path);
     }
-
-    // if empty AND NOT type of string, ignore value
-    if (IsEmpty(value) && !(definition.ConvertTo instanceof ConvertToString)) {
-        return;
+  }
+
+  // if empty AND NOT type of string, ignore value
+  if (IsEmpty(value) && !(definition.ConvertTo instanceof ConvertToString)) {
+    return;
+  }
+
+  if (!objectPath.has(obj, path)) {
+    // parent object could be a string or array, check this an create object if needed
+    let parentPath = dropRight(fclone(path));
+    if (objectPath.has(obj, parentPath)) {
+      let parentValue = objectPath.get(obj, parentPath);
+
+      if (!isObject(parentValue)) {
+        let convertedValue = {};
+        objectPath.set(convertedValue, 'Value', parentValue);
+        objectPath.set(obj, parentPath, convertedValue);
+      }
     }
 
-    if (!objectPath.has(obj, path)) {
-        // parent object could be a string or array, check this an create object if needed
-        let parentPath = dropRight(fclone(path));
-        if (objectPath.has(obj, parentPath)) {
-            let parentValue = objectPath.get(obj, parentPath);
+    objectPath.set(obj, path, value);
+    return;
+  }
 
-            if (!isObject(parentValue)) {
-                let convertedValue = {};
-                objectPath.set(convertedValue, "Value", parentValue);
-                objectPath.set(obj, parentPath, convertedValue);
-            }
-        }
+  let oldValue = objectPath.get(obj, path);
 
-        objectPath.set(obj, path, value);
-        return;
-    }
+  if (definition.ConvertTo instanceof ConvertToString) {
+    let newLineCharacter = definition.ConvertTo.NewLineCharacter;
 
-    let oldValue = objectPath.get(obj, path);
+    if (definition.ConvertTo.NewLineIfEmpty && IsEmpty(value)) {
+      value = newLineCharacter;
+    }
 
-    if (definition.ConvertTo instanceof ConvertToString) {
-        let newLineCharacter = definition.ConvertTo.NewLineCharacter;
+    // ignore empty value
+    if (IsEmpty(value)) {
+      return;
+    }
 
-        if (definition.ConvertTo.NewLineIfEmpty && IsEmpty(value)) {
-            value = newLineCharacter;
-        }
+    // concat
+    objectPath.set(obj, path, `${oldValue}${value}`);
+    return;
+  }
 
-        // ignore empty value
-        if (IsEmpty(value)) {
-            return;
-        }
-        
-        // concat
-        objectPath.set(obj, path, `${oldValue}${value}`);
-        return;
-    }
-    
-    if (isArray(oldValue)) {
-        objectPath.insert(obj, path, value, oldValue.length);
-        return;
-    }
+  if (isArray(oldValue)) {
+    objectPath.insert(obj, path, value, oldValue.length);
+    return;
+  }
 
-    objectPath.set(obj, path, [ oldValue, value ]);
-}
+  objectPath.set(obj, path, [oldValue, value]);
+}

package/src/common.ts

@@ -7,32 +7,32 @@ import isNaN from 'lodash/isNaN';
  * Test if an string can be parsed as an number
  * @param str the string
  */
-export function IsNumber(str: string) : Boolean {
-    if (IsEmpty(str) || str === ' '){
-        return false;
-    }
+export function IsNumber(str: string): Boolean {
+  if (IsEmpty(str) || str === ' ') {
+    return false;
+  }
 
-    let number = toNumber(str);
+  let number = toNumber(str);
 
-    if (isNaN(number)) {
-        return false;
-    }
+  if (isNaN(number)) {
+    return false;
+  }
 
-    return isNumber(number);
+  return isNumber(number);
 }
 
 /**
  * Converts a string to an number
  * @param str the string
  */
-export function ToNumber(str: string) : number {
-    return toNumber(str);
+export function ToNumber(str: string): number {
+  return toNumber(str);
 }
 
 /**
  * Tests if an string is empty
  * @param str the string
  */
-export function IsEmpty(str: string) : Boolean {
-    return isEmpty(str);
-}
+export function IsEmpty(str: string): Boolean {
+  return isEmpty(str);
+}

package/src/console.ts

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
 import yargs from 'yargs';
-import { Convert as ConvertToJSON } from "./ToJSON/console";
+import { Convert as ConvertToJSON } from './ToJSON/console';
 
-const { hideBin } = require('yargs/helpers')
-let argv = yargs(hideBin(process.argv)).argv
+const { hideBin } = require('yargs/helpers');
+let argv = yargs(hideBin(process.argv)).argv;
 
-if (!argv.mode || argv.mode === "JSON") {
-    ConvertToJSON(argv);
+if (!argv.mode || argv.mode === 'JSON') {
+  ConvertToJSON(argv);
+} else {
+  console.log('TODO: Conversion from JS\\JSON to GEDCOM');
 }
-else {
-    console.log("TODO: Conversion from JS\\JSON to GEDCOM");
-}

package/src/index.ts

@@ -1,7 +1,4 @@
-import JsonParsing from "./ToJSON/models/Parsing";
-import ParsingOptions from "./ToJSON/models/ParsingOptions";
+import JsonParsing from './ToJSON/models/Parsing';
+import ParsingOptions from './ToJSON/models/ParsingOptions';
 
-export {
-    JsonParsing,
-    ParsingOptions
-}
+export { JsonParsing, ParsingOptions };