@treeviz/gedcom-parser 1.0.1

package/dist/classes/indis.d.ts

@@ -0,0 +1,54 @@
+import { type IIndividuals } from "../interfaces/indis";
+import { type Settings } from "../types/settings";
+import { type IndiKey, type Filter, type OrderIterator, Range, type NestedGroup, type Order, type FilterIterator, type GroupIterator, type Group } from "../types/types";
+import { type IndiType } from "./indi";
+import { List } from "./list";
+export declare class Individuals extends List<IndiKey, IndiType> implements IIndividuals {
+    copy(): Individuals;
+    except(item: IndiType): Individuals;
+    filter(filters: Filter | FilterIterator<IndiType, IndiKey>): Individuals;
+    find(filters: Filter | FilterIterator<IndiType, IndiKey>): IndiType | undefined;
+    unattachedFilter(useUnattached: boolean): Individuals;
+    orderBy(orders: Order | OrderIterator<IndiType, IndiKey>): Individuals;
+    getFirstEvent(): IndiType;
+    getLastEvent(): IndiType;
+    getFirstBirth(): IndiType;
+    getLastBirth(): IndiType;
+    getFirstDeath(): IndiType;
+    getLastDeath(): IndiType;
+    groupBy(group: Group | GroupIterator<IndiType, IndiKey>, sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, lessOccuranceLabel?: string): Record<string, Individuals>;
+    groupByFirstLetters(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, settings?: Settings): Record<string, Individuals>;
+    groupBySurnames(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number): Record<string, Individuals>;
+    groupByTimeRanges(range: Range, sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number): Record<string, Individuals>;
+    nestedGroupByPlacesAndTimeRanges(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, uniqueCounting?: boolean): NestedGroup;
+    nestedGroupByTimeRangesAndPlaces(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, uniqueCounting?: boolean): NestedGroup;
+    nestedGroupByPlaces(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, partOrder?: "original" | "reverse", translate?: boolean, uniqueCounting?: boolean, groupKeyTranslator?: (parts: string[]) => string | undefined): NestedGroup;
+    groupByPlaces(sort?: "length" | "group" | OrderIterator<Individuals, string>, minOccurance?: number, partOrder?: "original" | "reverse", translate?: boolean, groupKeyTranslator?: (parts: string[]) => string | undefined): Record<string, Individuals>;
+    getFacts(): List<import("../types/types").IdType, import("./common").Common<string, import("../types/types").IdType>>;
+    private isRelativeOf;
+    isSiblingOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isSpouseOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isParentOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isChildOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isParentInLawOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    isChildInLawOf(indi?: IndiKey | IndiType, every?: boolean): boolean | `@I${number}@` | `@P${number}@` | `@XI${number}@` | `@XXI${number}@`;
+    splitByFamily(type: "Spouses" | "Parents" | "Children", relativeTo?: IndiType): {
+        items: Record<`@F${number}@` | `@XF${number}@` | `@XXF${number}@`, Individuals>;
+        lengthOfFamily: number;
+        lengthOfIndividuals: number;
+    };
+    getRelativesOnDegree(degree?: number): Individuals;
+    getRelativesOnLevel(level?: number, filter?: Filter): Individuals;
+    getAscendants(level?: number, filter?: Filter): Individuals;
+    getDescendants(level?: number, filter?: Filter): Individuals;
+    getAllAscendants(individuals?: Individuals): Individuals;
+    getAllDescendants(individuals?: Individuals, containDescendantsInLaw?: boolean): Individuals;
+    getSiblings(): Individuals;
+    getChildren(): Individuals;
+    getParents(): Individuals;
+    getCoParents(): Individuals;
+    getSpouses(): Individuals;
+    toName(): List<import("../types/types").IdType, import("./common").Common<string, import("../types/types").IdType>>;
+    toList(): Individuals;
+}
+//# sourceMappingURL=indis.d.ts.map

package/dist/classes/indis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indis.d.ts","sourceRoot":"","sources":["../../src/classes/indis.ts"],"names":[],"mappings":"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"}

package/dist/classes/indis.js

@@ -0,0 +1,439 @@
+import difference from "lodash/difference";
+import { BIRTH_ASC, BIRTH_DESC, DEATH_ASC, DEATH_DESC, } from "../constants/orders";
+import { getPlaceParserProvider } from "../factories/place-parser-provider";
+import { getPlaceTranslatorProvider } from "../factories/place-translator-provider";
+import { Range, } from "../types/types";
+import { nameFormatter } from "../utils/name-formatter";
+import { setNestedGroup } from "../utils/nested-group";
+import { getPlaceParts } from "../utils/place-parser";
+import { placeTranslator } from "../utils/place-translator";
+import { List } from "./list";
+export class Individuals extends List {
+    copy() {
+        return super.copy(Individuals);
+    }
+    except(item) {
+        return super.except(item, Individuals);
+    }
+    filter(filters) {
+        return super.filter(filters, Individuals);
+    }
+    find(filters) {
+        return super.find(filters, Individuals);
+    }
+    unattachedFilter(useUnattached) {
+        if (useUnattached) {
+            return this;
+        }
+        return this.filter((item) => !item.isUnattachedMember());
+    }
+    orderBy(orders) {
+        return super.orderBy(orders, Individuals);
+    }
+    getFirstEvent() {
+        const firstDeath = this.getFirstBirth();
+        const firstBirth = this.getFirstDeath();
+        if (firstBirth?.DATE?.rawValue === undefined ||
+            (firstDeath?.DATE?.rawValue !== undefined &&
+                firstDeath.DATE.rawValue < firstBirth.DATE.rawValue)) {
+            return firstDeath;
+        }
+        return firstBirth;
+    }
+    getLastEvent() {
+        const lastDeath = this.getLastDeath();
+        const lastBirth = this.getLastBirth();
+        if (lastDeath?.DATE?.rawValue === undefined ||
+            (lastBirth?.DATE?.rawValue !== undefined &&
+                lastDeath.DATE.rawValue < lastBirth.DATE.rawValue)) {
+            return lastBirth;
+        }
+        return lastDeath;
+    }
+    getFirstBirth() {
+        return this.filter((item) => {
+            const birth = item.BIRT?.toList().index(0);
+            if (birth?.DATE?.rawValue?.getTime() === 0) {
+                return true;
+            }
+            return !!birth?.DATE?.rawValue?.getTime();
+        })
+            .orderBy(BIRTH_ASC)
+            .index(0);
+    }
+    getLastBirth() {
+        return this.filter((item) => {
+            const birth = item.BIRT?.toList().index(0);
+            if (birth?.DATE?.rawValue?.getTime() === 0) {
+                return true;
+            }
+            return !!birth?.DATE?.rawValue?.getTime();
+        })
+            .orderBy(BIRTH_DESC)
+            .index(0);
+    }
+    getFirstDeath() {
+        return this.filter((item) => {
+            const death = item.DEAT?.toList().index(0);
+            if (death?.DATE?.rawValue?.getTime() === 0) {
+                return true;
+            }
+            return !!death?.DATE?.rawValue?.getTime();
+        })
+            .orderBy(DEATH_ASC)
+            .index(0);
+    }
+    getLastDeath() {
+        return this.filter((item) => {
+            const death = item.DEAT?.toList().index(0);
+            if (death?.DATE?.rawValue?.getTime() === 0) {
+                return true;
+            }
+            return !!death?.DATE?.rawValue?.getTime();
+        })
+            .orderBy(DEATH_DESC)
+            .index(0);
+    }
+    groupBy(group, sort, minOccurance = -1, lessOccuranceLabel) {
+        return super.groupBy(group, sort, minOccurance, lessOccuranceLabel, Individuals);
+    }
+    groupByFirstLetters(sort = "group", minOccurance = -1, settings) {
+        return this.groupBy((item) => {
+            const { letter } = nameFormatter(item, settings);
+            return letter.trim() || "Unknown";
+        }, sort, minOccurance, "Letters appearing less than 5 times");
+    }
+    groupBySurnames(sort, minOccurance = -1) {
+        return this.groupBy("NAME.SURN", sort, minOccurance, "Surnames appearing less than 5 times");
+    }
+    groupByTimeRanges(range, sort = "group", minOccurance = -1) {
+        return this.groupBy({
+            ["BIRT.DATE.YEAR"]: {
+                getter: (year) => {
+                    if (!Number(year)) {
+                        return;
+                    }
+                    if (range === Range.Year) {
+                        return `${Math.floor(Number(year) / range) * range}`;
+                    }
+                    return `${Math.floor(Number(year) / range) * range + 1}-${Math.ceil((Number(year) + 1) / range) * range}`;
+                },
+            },
+        }, sort, minOccurance, "Time ranges appearing less than 5 times");
+    }
+    nestedGroupByPlacesAndTimeRanges(sort, minOccurance = -1, uniqueCounting = true) {
+        const placesWithYear = this.groupBy((item) => item
+            .getPlaces()
+            .map((place) => {
+            const date = place.obj?.get("DATE");
+            if (date?.YEAR) {
+                return `${place.place}, ${date.YEAR}`;
+            }
+            return `${place.place}, Unknown`;
+        })
+            .filter(Boolean), sort, minOccurance, "Places appearing less than 5 times");
+        return Object.entries(placesWithYear).reduce((acc, [place, indis]) => {
+            setNestedGroup(acc, place, indis, uniqueCounting);
+            return acc;
+        }, {});
+    }
+    nestedGroupByTimeRangesAndPlaces(sort, minOccurance = -1, uniqueCounting = true) {
+        const placesWithYear = this.groupBy((item) => item
+            .getPlaces()
+            .map((place) => {
+            const date = place.obj?.get("DATE");
+            if (date?.YEAR) {
+                return `${date.YEAR}, ${place.place}`;
+            }
+            return `Unknown, ${place.place}`;
+        })
+            .filter(Boolean), sort, minOccurance, "Places appearing less than 5 times");
+        return Object.entries(placesWithYear).reduce((acc, [place, indis]) => {
+            setNestedGroup(acc, place, indis, uniqueCounting);
+            return acc;
+        }, {});
+    }
+    nestedGroupByPlaces(sort, minOccurance = -1, partOrder = "reverse", translate = true, uniqueCounting = true, groupKeyTranslator) {
+        const places = this.groupByPlaces(sort, minOccurance, partOrder, translate, groupKeyTranslator);
+        return Object.entries(places).reduce((acc, [place, indis]) => {
+            setNestedGroup(acc, place, indis, uniqueCounting);
+            return acc;
+        }, {});
+    }
+    groupByPlaces(sort, minOccurance = -1, partOrder = "reverse", translate = true, groupKeyTranslator) {
+        return this.groupBy((item) => item
+            .getPlaces()
+            .map((place) => {
+            // Use custom place parser if provided, otherwise use built-in
+            const customPlaceParser = getPlaceParserProvider();
+            const placeParts = customPlaceParser
+                ? customPlaceParser(place.place || "")
+                : getPlaceParts(place.place || "");
+            const { leftParts = [], town, county, country, } = placeParts[0] || {};
+            // Build normalized parts array in city-to-country order
+            const normalizedParts = [
+                ...leftParts,
+                town,
+                county,
+                country,
+            ].filter(Boolean);
+            // Apply the requested order
+            const orderedParts = partOrder === "original"
+                ? normalizedParts
+                : normalizedParts.toReversed();
+            let newPlace = "";
+            if (groupKeyTranslator) {
+                // Use custom group key translator function
+                newPlace = groupKeyTranslator(orderedParts);
+            }
+            else if (translate) {
+                // Use custom place translator if provided, otherwise use built-in
+                const customPlaceTranslator = getPlaceTranslatorProvider();
+                if (customPlaceTranslator) {
+                    // Custom translator: pass as array
+                    newPlace = customPlaceTranslator(orderedParts);
+                }
+                else {
+                    // Built-in translator: expects string array
+                    newPlace = placeTranslator(orderedParts);
+                }
+            }
+            else {
+                // No translation, just join
+                newPlace = orderedParts.join(", ");
+            }
+            if (!newPlace) {
+                return undefined;
+            }
+            return {
+                marker: place.place,
+                group: newPlace,
+            };
+        })
+            .filter(Boolean), sort, minOccurance, "Places appearing less than 5 times");
+    }
+    getFacts() {
+        const facts = new List();
+        this.values().forEach((indi) => {
+            const indiFacts = indi?.getFacts();
+            if (indi?.id && indiFacts) {
+                facts.merge(indiFacts);
+            }
+        });
+        return facts;
+    }
+    isRelativeOf(type, indi, every = false) {
+        const usedIndi = typeof indi === "string"
+            ? this.index(0)?.getGedcom()?.indi(indi)
+            : indi;
+        let getter;
+        if (type === "sibling") {
+            getter = "getSiblings";
+        }
+        if (type === "parent") {
+            getter = "getParents";
+        }
+        if (type === "child") {
+            getter = "getChildren";
+        }
+        if (type === "spouse") {
+            getter = "getCoParents";
+        }
+        if (type === "parentInLaw") {
+            getter = "getParentsInLaw";
+        }
+        if (type === "childInLaw") {
+            getter = "getChildrenInLaw";
+        }
+        if (!usedIndi || !getter) {
+            return false;
+        }
+        const relatives = usedIndi[getter]();
+        const thisIds = this.keys();
+        if (relatives.length <= 0 || this.length <= 0) {
+            return false;
+        }
+        const filtered = relatives.filter({ id: thisIds });
+        if (every) {
+            return filtered.length === this.length
+                ? filtered.index(0)?.id || true
+                : false;
+        }
+        return filtered.length > 0 ? filtered.index(0)?.id || true : false;
+    }
+    isSiblingOf(indi, every = false) {
+        return this.isRelativeOf("sibling", indi, every);
+    }
+    isSpouseOf(indi, every = false) {
+        return this.isRelativeOf("spouse", indi, every);
+    }
+    isParentOf(indi, every = false) {
+        return this.isRelativeOf("parent", indi, every);
+    }
+    isChildOf(indi, every = false) {
+        return this.isRelativeOf("child", indi, every);
+    }
+    isParentInLawOf(indi, every = false) {
+        return this.isRelativeOf("parentInLaw", indi, every);
+    }
+    isChildInLawOf(indi, every = false) {
+        return this.isRelativeOf("childInLaw", indi, every);
+    }
+    splitByFamily(type, relativeTo) {
+        const splittedList = {};
+        const familiesRelativeTo = relativeTo
+            ?.get(type !== "Parents" ? "FAMS" : "FAMC")
+            ?.toValueList()
+            .keys() ?? [];
+        let lengthOfIndividuals = 0;
+        this.forEach((indi) => {
+            const families = indi
+                .get(type === "Spouses" ? "FAMS" : "FAMC")
+                ?.toValueList();
+            if (families) {
+                families.keys().forEach((fKey) => {
+                    const famKey = fKey;
+                    if (familiesRelativeTo &&
+                        !familiesRelativeTo.includes(famKey)) {
+                        return;
+                    }
+                    if (!splittedList[famKey]) {
+                        splittedList[famKey] = new Individuals();
+                    }
+                    splittedList[famKey]?.append(indi);
+                    lengthOfIndividuals++;
+                });
+            }
+        });
+        // Handle familiy with no co parent
+        if (type === "Spouses" && relativeTo) {
+            const missingFams = difference(familiesRelativeTo, Object.keys(splittedList));
+            if (missingFams.length) {
+                missingFams.forEach((fKey) => {
+                    const famKey = fKey;
+                    if (familiesRelativeTo &&
+                        !familiesRelativeTo.includes(famKey)) {
+                        return;
+                    }
+                    const missingChildren = relativeTo
+                        .getGedcom()
+                        ?.fam(famKey)
+                        ?.getChildren();
+                    if (!splittedList[famKey] && missingChildren?.length) {
+                        splittedList[famKey] = new Individuals();
+                    }
+                });
+            }
+        }
+        return {
+            items: splittedList,
+            lengthOfFamily: Object.keys(splittedList).length,
+            lengthOfIndividuals,
+        };
+    }
+    getRelativesOnDegree(degree = 0) {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getRelativesOnLevel(degree));
+            }
+        });
+        return persons;
+    }
+    getRelativesOnLevel(level = 0, filter) {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getRelativesOnLevel(level, filter));
+            }
+        });
+        return persons;
+    }
+    getAscendants(level = 0, filter) {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getAscendants(level, filter));
+            }
+        });
+        return persons;
+    }
+    getDescendants(level = 0, filter) {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getDescendants(level, filter));
+            }
+        });
+        return persons;
+    }
+    getAllAscendants(individuals) {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getAllAscendants(individuals));
+            }
+        });
+        return persons;
+    }
+    getAllDescendants(individuals, containDescendantsInLaw = false) {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getAllDescendants(individuals, containDescendantsInLaw));
+            }
+        });
+        return persons;
+    }
+    getSiblings() {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getSiblings());
+            }
+        });
+        return persons;
+    }
+    getChildren() {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getChildren());
+            }
+        });
+        return persons;
+    }
+    getParents() {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getParents());
+            }
+        });
+        return persons;
+    }
+    getCoParents() {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getCoParents());
+            }
+        });
+        return persons;
+    }
+    getSpouses() {
+        const persons = new Individuals();
+        this.values().forEach((indi) => {
+            if (indi) {
+                persons.merge(indi.getCoParents());
+            }
+        });
+        return persons;
+    }
+    toName() {
+        return super.toProp("NAME")?.toValue();
+    }
+    toList() {
+        return new Individuals().concat(this.getItems());
+    }
+}

package/dist/classes/list.d.ts

@@ -0,0 +1,55 @@
+import { type IdType, type Filter, type FilterIterator, type MultiTag, type Order, type OrderIterator, type Group, type GroupIterator } from "../types/types";
+import { type ConvertOptions } from "../interfaces/common";
+import { type IList } from "../interfaces/list";
+import { type Common } from "./common";
+export declare class List<K extends IdType = IdType, T extends Common = Common> implements IList<K, T> {
+    private items;
+    isListable: boolean;
+    marker: string | undefined;
+    constructor(items?: Partial<Record<K, T>> | T[]);
+    get length(): number;
+    has(indi?: K | T): boolean;
+    get(name: MultiTag): List<IdType, Common<string, IdType>>;
+    getIf(name: MultiTag, condition: string, name2: MultiTag): List<IdType, Common<string, IdType>>;
+    keys(): K[];
+    values(): (T | undefined)[];
+    entries(): [K, T | undefined][];
+    setLength(_type?: "increase" | "decrease"): void;
+    first(): Partial<Record<K, T>>[K];
+    last(): Partial<Record<K, T>>[K];
+    index(index: number): Partial<Record<K, T>>[K];
+    item(name: K, value?: T): T | undefined;
+    removeItem(name: K): void;
+    exclude(excludedList: List<K, T>): this;
+    concat(items?: Partial<Record<K, T>> | T[]): this;
+    merge(mergedList?: List<K, T>): this;
+    intersection(mergedList?: List<K, T>): List<K, T>;
+    difference(mergedList?: List<K, T>): List<K, T>;
+    prepend(item: T): this;
+    append(item: T): this;
+    delete(item: T): this;
+    copy(ClassName?: typeof List<K, T>): List<K, T>;
+    except(item: T, ClassName?: typeof List<K, T>): List<K, T>;
+    forEach(iterate: (item: T, key: K, index: number) => void): void;
+    map<R>(iterate: (item: T, key: K, index: number) => R): R[];
+    reduce<R>(iterate: (acc: R, item: T, key: K, index: number) => R, initialValue: R): R;
+    filter(filters: Filter | FilterIterator<T, K>, ClassName?: typeof List<K, T>): List<K, T>;
+    find(filters: Filter | FilterIterator<T, K>, _ClassName?: typeof List<K, T>): T;
+    orderBy(orders: Order | OrderIterator<T, K>, ClassName?: typeof List<K, T>): List<K, T>;
+    groupBy(groups: Group | GroupIterator<T, K>, sort?: "length" | "group" | OrderIterator<List<K, T>, string>, minOccurance?: number, lessOccuranceLabel?: string, ClassName?: typeof List<K, T>): Record<string, List<K, T>>;
+    findIndex(item: T): number;
+    getItems(): Partial<Record<K, T>>;
+    toJson(tag: MultiTag, options?: ConvertOptions): string;
+    toObject(tag: MultiTag, options?: ConvertOptions): Record<string, string | ({
+        value?: string;
+    } & Record<string, unknown>) | (string | ({
+        value?: string;
+    } & Record<string, unknown>))[]>;
+    toGedcom(tag: MultiTag, level?: number, options?: ConvertOptions): string;
+    toGedcomLines(tag: MultiTag, level?: number, options?: ConvertOptions): string[];
+    toValue(): List<IdType, Common<string, IdType>>;
+    toProp(tag: MultiTag): List<IdType, Common<string, IdType>>;
+    toList(): List<IdType, Common<string, IdType>>;
+    toValueList(): List<IdType, Common<string, IdType>>;
+}
+//# sourceMappingURL=list.d.ts.map

package/dist/classes/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../../src/classes/list.ts"],"names":[],"mappings":"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"}