@treeviz/gedcom-parser 1.0.1

package/dist/classes/gedcom.js

@@ -0,0 +1,421 @@
+import { getVersion } from "../utils/get-product-details";
+import { Common, createCommon } from "./common";
+import { CustomTags } from "./indi";
+import { List } from "./list";
+export class GedCom extends Common {
+    constructor() {
+        super();
+        this.tagMembers = {};
+        this.reflist = {};
+        this.refcount = 0;
+        delete this._gedcom;
+        delete this.id;
+        this.removeValue();
+    }
+    getMain(type, index) {
+        const list = !type || type instanceof List ? type : this.getList(type);
+        if (!list) {
+            return undefined;
+        }
+        if (typeof index === "string") {
+            return list.item(index);
+        }
+        // const keyProbe: IdType[] = [
+        // 	`@I${index}@`,
+        // 	`@P${index}@`,
+        // 	`@XI${index}@`,
+        // 	`@XXI${index}@`,
+        // ];
+        // let itemProbe: T | undefined;
+        // keyProbe.find((key) => {
+        // 	const i = list.item(key);
+        // 	if (i) {
+        // 		itemProbe = i as T;
+        // 		return true;
+        // 	}
+        // 	return false;
+        // });
+        // if (itemProbe) {
+        // 	return itemProbe as T;
+        // }
+        const keys = list.keys();
+        return list.item(keys[index]);
+    }
+    getList(type) {
+        return this.get(type);
+    }
+    indis() {
+        return this.getList("@@INDI");
+    }
+    cloneIndis(target, source, avoidKeys = [], removeFromOriginalList = true) {
+        const hasFAMS = avoidKeys.includes("FAMS");
+        const targetIndi = typeof target === "string" ? this.indi(target) : target;
+        const sourceIndi = typeof source === "string" ? this.indi(source) : source;
+        if (!targetIndi || !sourceIndi) {
+            return this;
+        }
+        const spousesFamily = hasFAMS ? sourceIndi.FAMS?.toList() : undefined;
+        const childrenFamily = sourceIndi.FAMC?.toList();
+        const cloned = targetIndi.clone(false, avoidKeys);
+        const newCloned = sourceIndi.merge(cloned);
+        newCloned.cloneOf = targetIndi.id;
+        targetIndi.clonedBy = newCloned.id;
+        if (newCloned.id) {
+            this.getList("@@INDI")?.item(newCloned.id, newCloned);
+            if (childrenFamily?.length) {
+                childrenFamily.forEach((fam) => {
+                    if (!fam.ref) {
+                        return;
+                    }
+                    const newChild = createCommon(this, undefined, fam.ref);
+                    newChild.value = newCloned.id;
+                    fam.ref.assign("CHIL", newChild, true);
+                });
+            }
+            if (spousesFamily?.length) {
+                spousesFamily.forEach((fam) => {
+                    if (!fam.ref) {
+                        return;
+                    }
+                    const newSpouse = createCommon(this, undefined, fam.ref);
+                    newSpouse.value = newCloned.id;
+                    if (newCloned.isMale()) {
+                        fam.ref.assign("HUSB", newSpouse, true);
+                    }
+                    else if (newCloned.isFemale()) {
+                        fam.ref.assign("WIFE", newSpouse, true);
+                    }
+                });
+            }
+            if (removeFromOriginalList &&
+                newCloned.type &&
+                newCloned.type !== targetIndi.type) {
+                this.getList(`@@${newCloned.type}`)?.removeItem(newCloned.id);
+            }
+            newCloned.type = "INDI";
+        }
+    }
+    mergeIndis(target, source, removeFromOriginalList = true) {
+        const targetIndi = typeof target === "string" ? this.indi(target) : target;
+        const sourceIndi = typeof source === "string" ? this.indi(source) : source;
+        if (!targetIndi || !sourceIndi) {
+            return this;
+        }
+        const sourceIndiId = sourceIndi.id;
+        const spousesFamily = sourceIndi.FAMS?.toList();
+        const childrenFamily = sourceIndi.FAMC?.toList();
+        const newLinked = targetIndi.merge(sourceIndi);
+        const mergedId = newLinked.id;
+        if (sourceIndiId && (spousesFamily?.length || childrenFamily?.length)) {
+            if (childrenFamily?.length && mergedId) {
+                childrenFamily.forEach((fam) => {
+                    if (!fam.ref) {
+                        return;
+                    }
+                    const newChild = createCommon(this, undefined, fam.ref);
+                    newChild.value = mergedId;
+                    fam.ref.assign("CHIL", newChild, true);
+                });
+            }
+            if (spousesFamily?.length && mergedId) {
+                spousesFamily.forEach((fam) => {
+                    if (!fam.ref) {
+                        return;
+                    }
+                    const newSpouse = createCommon(this, undefined, fam.ref);
+                    newSpouse.value = mergedId;
+                    if (newLinked?.isMale()) {
+                        fam.ref.assign("HUSB", newSpouse, true);
+                    }
+                    else if (newLinked?.isFemale()) {
+                        fam.ref.assign("WIFE", newSpouse, true);
+                    }
+                });
+            }
+        }
+        if (removeFromOriginalList && sourceIndi?.type && sourceIndi.id) {
+            this.getList(`@@${sourceIndi.type}`)?.removeItem(sourceIndi.id);
+        }
+    }
+    fams() {
+        return this.getList("@@FAM");
+    }
+    objes() {
+        return this.getList("@@OBJE");
+    }
+    sours() {
+        return this.getList("@@SOUR");
+    }
+    repos() {
+        return this.getList("@@REPO");
+    }
+    subms() {
+        return this.getList("@@SUBM");
+    }
+    tags() {
+        return this.getList("@@_MTTAG");
+    }
+    customTags() {
+        return this.getList("@@_MTTAG")?.filter((tag) => {
+            return tag?.get("_MTCAT.NAME")?.toValue() === "Custom";
+        });
+    }
+    indi(index) {
+        return this.getMain(this.indis(), index);
+    }
+    fam(index) {
+        return this.getMain(this.fams(), index);
+    }
+    obje(index) {
+        return this.getMain(this.objes(), index);
+    }
+    sour(index) {
+        return this.getMain(this.sours(), index);
+    }
+    repo(index) {
+        return this.getMain(this.repos(), index);
+    }
+    subm(index) {
+        return this.getMain(this.subms(), index);
+    }
+    tag(index) {
+        return this.getMain(this.tags(), index);
+    }
+    fromList(id) {
+        return id ? this.reflist?.[id] : undefined;
+    }
+    tagByName(name) {
+        return this.tags()?.find((tag) => {
+            const tagName = tag?.get("NAME")?.toValue();
+            return tagName === name;
+        });
+    }
+    customTag(index) {
+        return this.getMain(this.customTags(), index);
+    }
+    getIndiRelatedLists(indis) {
+        const refs = {};
+        const individuals = this.indis()?.filter((indi, indiKey) => {
+            if (indis.includes(indiKey)) {
+                indi.getRefs()
+                    ?.values()
+                    ?.forEach((ref) => {
+                    const refKey = ref?.value;
+                    if (ref && refKey && !refs[refKey]) {
+                        refs[refKey] = ref;
+                    }
+                });
+                return true;
+            }
+            return false;
+        });
+        const usedLists = Object.entries(this).filter(([prop, list]) => {
+            return (prop !== "@@INDI" &&
+                prop.startsWith("@@") &&
+                list instanceof List);
+        });
+        const lists = {};
+        if (individuals) {
+            lists["@@INDI"] = individuals;
+        }
+        usedLists.forEach(([key, list]) => {
+            const validKey = key;
+            if (list) {
+                lists[validKey] = list.filter((item) => {
+                    return Boolean(item.id && refs[item.id]);
+                });
+            }
+        });
+        return lists;
+    }
+    getDownloadHeader() {
+        const newHead = createCommon();
+        Object.assign(newHead, this.get("HEAD") ?? {});
+        const newSour = createCommon();
+        newSour.set("CORP", createCommon());
+        newSour.set("CORP.WWW", createCommon());
+        newSour.set("NAME", createCommon());
+        newSour.set("VERS", createCommon());
+        newSour.CORP.value = "TreeViz - The Family Tree Visualiser";
+        newSour.CORP.WWW.value = "treeviz.com";
+        newSour.NAME.value = "TreeViz - The Family Tree Visualiser";
+        newSour.VERS.value = getVersion();
+        newHead.set("SOUR", newSour);
+        return newHead;
+    }
+    toFiltered(indis) {
+        if (!indis.length) {
+            return this;
+        }
+        const newGedcom = createGedCom();
+        const newContent = this.getIndiRelatedLists(indis);
+        Object.assign(newGedcom, this, newContent, {
+            HEAD: this.getDownloadHeader(),
+        });
+        return newGedcom;
+    }
+    toJson(tag, options) {
+        if (!options?.indis?.length) {
+            return super.toJson(tag, options);
+        }
+        const newGedcom = createGedCom();
+        const newContent = this.getIndiRelatedLists(options.indis);
+        Object.assign(newGedcom, this, newContent, {
+            HEAD: this.getDownloadHeader(),
+        });
+        delete options.indis;
+        return newGedcom.toJson(tag, options);
+    }
+    toGedcom(tag, level, options) {
+        if (options?.super) {
+            return super.toGedcom(tag, level, options);
+        }
+        const newGedcom = createGedCom();
+        if (!options?.original) {
+            Object.assign(newGedcom, {
+                HEAD: this.getDownloadHeader(),
+            });
+        }
+        Object.assign(newGedcom, this);
+        if (options?.indis?.length) {
+            const newContent = this.getIndiRelatedLists(options.indis);
+            Object.assign(newGedcom, newContent);
+        }
+        return newGedcom.toGedcom(tag, level, { ...options, super: true });
+    }
+    hasTag(tag) {
+        const tagName = typeof tag === "string"
+            ? tag
+            : tag?.get("NAME")?.toValue();
+        if (!tagName) {
+            return false;
+        }
+        return !!this.tagMembers?.[tagName]?.indis?.length;
+    }
+    hasUnknownAncestor() {
+        return !!this.tagMembers?.[CustomTags.UnknownAncestor]?.indis?.length;
+    }
+    hasIgnoredMember() {
+        return !!this.tagMembers?.[CustomTags.IgnoredMember]?.indis?.length;
+    }
+    hasUnattachedMember() {
+        return !!this.tagMembers?.[CustomTags.UnattachedMember]?.indis?.length;
+    }
+    hasUnknownGivenname() {
+        return !!this.tagMembers?.[CustomTags.UnknownGivenname]?.indis?.length;
+    }
+    hasUnknownSurname() {
+        return !!this.tagMembers?.[CustomTags.UnknownSurname]?.indis?.length;
+    }
+    hasNonRelevant() {
+        return this.hasUnknownAncestor() || this.hasUnattachedMember();
+    }
+    /**
+     * Get all places from the GEDCOM with occurrence counts
+     * @returns Record mapping place names to their occurrence count
+     */
+    getAllPlaces() {
+        const indis = this.indis();
+        const allPlaces = {};
+        indis?.forEach((indi) => {
+            if (!indi.id)
+                return;
+            const places = indi.getPlaces();
+            places.forEach((placeObj) => {
+                const placeName = placeObj?.place;
+                if (placeName && typeof placeName === "string") {
+                    allPlaces[placeName] = (allPlaces[placeName] || 0) + 1;
+                }
+            });
+        });
+        return allPlaces;
+    }
+    /**
+     * Get all places from the GEDCOM with associated individual IDs
+     * @param usedIndis Optional array of individual IDs to filter by
+     * @returns Record mapping place names to arrays of individual IDs
+     */
+    getAllPlacesWithIndis(usedIndis = []) {
+        const indis = this.indis();
+        const allPlaces = {};
+        indis?.forEach((indi) => {
+            if (!indi.id ||
+                (usedIndis.length && !usedIndis.includes(indi.id))) {
+                return;
+            }
+            const places = indi.getPlaces();
+            places.forEach((placeObj) => {
+                const placeName = placeObj?.place;
+                if (placeName && typeof placeName === "string" && indi.id) {
+                    if (!allPlaces[placeName]) {
+                        allPlaces[placeName] = [];
+                    }
+                    allPlaces[placeName].push(indi.id);
+                }
+            });
+        });
+        return allPlaces;
+    }
+}
+export const createGedCom = () => {
+    return new GedCom();
+};
+export const isGedcomString = (gedcomString) => {
+    return (typeof gedcomString === "string" &&
+        gedcomString[0] === "0" &&
+        gedcomString
+            .split("\n")
+            .slice(0, 1000)
+            .every((l) => !l || /^\d+\s+/.test(l)));
+};
+/**
+ * Validates if a string is a valid GEDCOM file content
+ * @param content - The file content to validate
+ * @returns An object with `valid` boolean and optional `error` message
+ */
+export const validateGedcomContent = (content) => {
+    if (!content) {
+        return { valid: false, error: "File is empty" };
+    }
+    const trimmedContent = content.trim();
+    if (!trimmedContent) {
+        return { valid: false, error: "File is empty" };
+    }
+    // Check for common binary file signatures
+    const firstBytes = trimmedContent.substring(0, 10);
+    const isBinary = firstBytes.startsWith("\x89PNG") || // PNG
+        firstBytes.startsWith("\xFF\xD8\xFF") || // JPEG
+        firstBytes.startsWith("GIF8") || // GIF
+        firstBytes.startsWith("BM") || // BMP
+        firstBytes.startsWith("PK") || // ZIP
+        firstBytes.startsWith("%PDF") || // PDF
+        // eslint-disable-next-line no-control-regex
+        /[\x00-\x08\x0E-\x1F]/.test(firstBytes); // Other binary content
+    if (isBinary) {
+        return {
+            valid: false,
+            error: "File appears to be a binary file (image, PDF, etc.), not a GEDCOM text file",
+        };
+    }
+    // Check if content starts with GEDCOM header
+    // GEDCOM files must start with "0 HEAD" or "0 head" (case-insensitive)
+    const startsWithHeader = /^0\s+(HEAD|head)/i.test(trimmedContent);
+    if (!startsWithHeader) {
+        return {
+            valid: false,
+            error: "Invalid GEDCOM file format. File must start with '0 HEAD' record",
+        };
+    }
+    /**
+     * Turning this off, because it's invalidating multiline gedcom property
+     * (I know these kind of GEDCOMs are not standard, but need to allow any user files)
+     **/
+    // Additional check using the existing isGedcomString logic
+    // if (!isGedcomString(trimmedContent)) {
+    // 	return {
+    // 		valid: false,
+    // 		error: "Invalid GEDCOM file format. File contains invalid line formats",
+    // 	};
+    // }
+    return { valid: true };
+};

package/dist/classes/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./common";
+export * from "./date";
+export * from "./fam";
+export * from "./fams";
+export * from "./gedcom";
+export * from "./indi";
+export * from "./indis";
+export * from "./list";
+export * from "./name";
+export * from "./note";
+export * from "./obje";
+export * from "./objes";
+export * from "./repo";
+export * from "./repos";
+export * from "./sour";
+export * from "./sours";
+export * from "./subm";
+export * from "./subms";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/classes/index.ts"],"names":[],"mappings":"AACA,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,OAAO,CAAC;AACtB,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}

package/dist/classes/index.js

@@ -0,0 +1,19 @@
+// Classes exports - barrel file for easier imports
+export * from "./common";
+export * from "./date";
+export * from "./fam";
+export * from "./fams";
+export * from "./gedcom";
+export * from "./indi";
+export * from "./indis";
+export * from "./list";
+export * from "./name";
+export * from "./note";
+export * from "./obje";
+export * from "./objes";
+export * from "./repo";
+export * from "./repos";
+export * from "./sour";
+export * from "./sours";
+export * from "./subm";
+export * from "./subms";