@treeviz/gedcom-parser 1.0.1

package/dist/utils/place-types.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Place-related types for GEDCOM parser
+ * These are simple types used by the Indi class for place filtering
+ */
+import type { Common } from "../classes/common";
+export interface Place {
+    type: PlaceType;
+    raw: string;
+    parts: string[];
+    level?: number;
+    source?: string;
+    key?: string;
+    index?: number;
+    obj?: Common;
+    ref?: Common;
+    place?: string;
+}
+export declare enum PlaceType {
+    All = "ALL",
+    Birth = "BIRT",
+    Marriage = "MARR",
+    Death = "DEAT",
+    Events = "EVEN",
+    Military = "_MILT",
+    MilitaryId = "_MILTID"
+}
+//# sourceMappingURL=place-types.d.ts.map

package/dist/utils/place-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-types.d.ts","sourceRoot":"","sources":["../../src/utils/place-types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,MAAM,WAAW,KAAK;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CACf;AAED,oBAAY,SAAS;IACpB,GAAG,QAAQ;IACX,KAAK,SAAS;IACd,QAAQ,SAAS;IACjB,KAAK,SAAS;IACd,MAAM,SAAS;IACf,QAAQ,UAAU;IAClB,UAAU,YAAY;CACtB"}

package/dist/utils/place-types.js

@@ -0,0 +1,14 @@
+/**
+ * Place-related types for GEDCOM parser
+ * These are simple types used by the Indi class for place filtering
+ */
+export var PlaceType;
+(function (PlaceType) {
+    PlaceType["All"] = "ALL";
+    PlaceType["Birth"] = "BIRT";
+    PlaceType["Marriage"] = "MARR";
+    PlaceType["Death"] = "DEAT";
+    PlaceType["Events"] = "EVEN";
+    PlaceType["Military"] = "_MILT";
+    PlaceType["MilitaryId"] = "_MILTID";
+})(PlaceType || (PlaceType = {}));

package/dist/utils/range.d.ts

@@ -0,0 +1,19 @@
+export type PrimitiveRange = "" | "-" | `-${number}` | `${number}-` | `${number}-${number}`;
+export type Range = PrimitiveRange | [(string | number)?, (string | number)?] | [string | number, (string | number)?];
+export interface SplitResult {
+    range: PrimitiveRange;
+    to?: boolean;
+    by?: boolean;
+}
+export declare const fromTuple: (s?: number, e?: number) => PrimitiveRange;
+export declare const inRange: (year: string | number | undefined, range: Range, trueIfNoYear?: boolean) => boolean;
+export declare const isIntersectedRange: (range1: Range, range2: Range) => boolean;
+export declare const splitRange: (to: Range, by: Range) => SplitResult[];
+export declare function parseRangeBounds(rangeKey: PrimitiveRange): [number | undefined, number | undefined];
+export declare function isRangeContained(containedRange: PrimitiveRange, containerRange: PrimitiveRange): boolean;
+export declare function extractSplitPoints(ranges: PrimitiveRange[]): number[];
+export declare function generateSplitRanges(splitPoints: number[]): PrimitiveRange[];
+export declare function splitOverlappingRanges<T>(rangesToValues: Array<[PrimitiveRange, T]>): Array<[PrimitiveRange, T[]]>;
+export declare function findMatchingRangeForSplitRange<T>(splitRange: PrimitiveRange, rangesToValues: Array<[PrimitiveRange, T]>): T[];
+export declare function extractSeparationYears(childName: string, ranges: Record<string, unknown[]>, parentName: string, ensureArray: (x: unknown) => unknown[]): number[];
+//# sourceMappingURL=range.d.ts.map

package/dist/utils/range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/utils/range.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,cAAc,GACvB,EAAE,GACF,GAAG,GACH,IAAI,MAAM,EAAE,GACZ,GAAG,MAAM,GAAG,GACZ,GAAG,MAAM,IAAI,MAAM,EAAE,CAAC;AACzB,MAAM,MAAM,KAAK,GACd,cAAc,GACd,CAAC,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,GACxC,CAAC,MAAM,GAAG,MAAM,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;AACzC,MAAM,WAAW,WAAW;IAC3B,KAAK,EAAE,cAAc,CAAC;IACtB,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,EAAE,CAAC,EAAE,OAAO,CAAC;CACb;AAeD,eAAO,MAAM,SAAS,GAAI,IAAI,MAAM,EAAE,IAAI,MAAM,KAAG,cAKlD,CAAC;AAsBF,eAAO,MAAM,OAAO,GACnB,MAAM,MAAM,GAAG,MAAM,GAAG,SAAS,EACjC,OAAO,KAAK,EACZ,sBAAoB,YAyBpB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,QAAQ,KAAK,EAAE,QAAQ,KAAK,YAqD9D,CAAC;AAEF,eAAO,MAAM,UAAU,GAAI,IAAI,KAAK,EAAE,IAAI,KAAK,KAAG,WAAW,EA+C5D,CAAC;AAIF,wBAAgB,gBAAgB,CAC/B,QAAQ,EAAE,cAAc,GACtB,CAAC,MAAM,GAAG,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC,CAK1C;AAED,wBAAgB,gBAAgB,CAC/B,cAAc,EAAE,cAAc,EAC9B,cAAc,EAAE,cAAc,GAC5B,OAAO,CAaT;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE,CAUrE;AAED,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,GAAG,cAAc,EAAE,CAU3E;AAED,wBAAgB,sBAAsB,CAAC,CAAC,EACvC,cAAc,EAAE,KAAK,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,GACxC,KAAK,CAAC,CAAC,cAAc,EAAE,CAAC,EAAE,CAAC,CAAC,CAuD9B;AAED,wBAAgB,8BAA8B,CAAC,CAAC,EAC/C,UAAU,EAAE,cAAc,EAC1B,cAAc,EAAE,KAAK,CAAC,CAAC,cAAc,EAAE,CAAC,CAAC,CAAC,GACxC,CAAC,EAAE,CAUL;AAED,wBAAgB,sBAAsB,CACrC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC,EACjC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,OAAO,EAAE,GACpC,MAAM,EAAE,CA2CV"}

package/dist/utils/range.js

@@ -0,0 +1,265 @@
+const toTuple = (r) => {
+    if (Array.isArray(r)) {
+        const [s, e] = r;
+        return [
+            s === undefined ? undefined : Number(s),
+            e === undefined ? undefined : Number(e),
+        ];
+    }
+    if (r === "-" || r === "")
+        return [undefined, undefined];
+    const [s, e] = r.split("-");
+    return [s ? Number(s) : undefined, e ? Number(e) : undefined];
+};
+export const fromTuple = (s, e) => {
+    if (s === undefined && e === undefined)
+        return "-";
+    if (s === undefined)
+        return `-${e}`;
+    if (e === undefined)
+        return `${s}-`;
+    return `${s}-${e}`;
+};
+const isValidRange = (range) => {
+    if (!Array.isArray(range) &&
+        range !== "" &&
+        range !== "-" &&
+        !/^\d*-\d*$/.test(range)) {
+        return false;
+    }
+    if (Array.isArray(range) &&
+        range.some((r) => typeof r === "string" && isNaN(Number(r)))) {
+        return false;
+    }
+    return true;
+};
+export const inRange = (year, range, trueIfNoYear = false) => {
+    if (!isValidRange(range)) {
+        return false;
+    }
+    if (!year) {
+        return trueIfNoYear;
+    }
+    const [start = -Infinity, end = Infinity] = toTuple(range);
+    if (!start && !end) {
+        return true;
+    }
+    if (start && !end) {
+        return Number(year) >= Number(start);
+    }
+    if (!start && end) {
+        return Number(year) <= Number(end);
+    }
+    return Number(start) <= Number(year) && Number(year) <= Number(end);
+};
+export const isIntersectedRange = (range1, range2) => {
+    if (!isValidRange(range1) || !isValidRange(range2)) {
+        return false;
+    }
+    const [start1 = -Infinity, end1 = Infinity] = toTuple(range1);
+    const [start2 = -Infinity, end2 = Infinity] = toTuple(range2);
+    if (!start1 && !end1) {
+        return true;
+    }
+    if (!start2 && !end2) {
+        return true;
+    }
+    if (start1 && !end1) {
+        if (start2 && !end2) {
+            return true;
+        }
+        if (!start2 && end2) {
+            return Number(start1) <= Number(end2);
+        }
+        return Number(start1) <= Number(end2);
+    }
+    if (!start1 && end1) {
+        if (start2 && !end2) {
+            return Number(start2) <= Number(end1);
+        }
+        if (!start2 && end2) {
+            return true;
+        }
+        return Number(start2) <= Number(end1);
+    }
+    if (start1 && end1) {
+        if (start2 && !end2) {
+            return Number(start2) <= Number(end1);
+        }
+        if (!start2 && end2) {
+            return Number(start1) <= Number(end2);
+        }
+        return Number(start1) <= Number(end2) && Number(start2) <= Number(end1);
+    }
+    return false;
+};
+export const splitRange = (to, by) => {
+    const [toStart, toEnd] = toTuple(to);
+    const [byStart, byEnd] = toTuple(by);
+    // Helper to build the PrimitiveRange string from optional numeric bounds
+    const make = (s, e) => fromTuple(s, e);
+    // If there is no intersection at all, return the full "to" range
+    if (!isIntersectedRange(to, by)) {
+        return [{ range: fromTuple(toStart, toEnd), to: true }];
+    }
+    // Calculate overlap boundaries between the two ranges
+    const overlapStart = Math.max(toStart ?? -Infinity, byStart ?? -Infinity);
+    const overlapEnd = Math.min(toEnd ?? Infinity, byEnd ?? Infinity);
+    const results = [];
+    // Lower segment of "to" that lies completely before the overlap
+    if ((toStart ?? -Infinity) < overlapStart) {
+        const loEnd = overlapStart - 1;
+        results.push({
+            range: make(toStart, loEnd),
+            to: true,
+        });
+    }
+    // The overlapping segment between "to" and "by"
+    results.push({
+        range: make(Number.isFinite(overlapStart) ? overlapStart : undefined, Number.isFinite(overlapEnd) ? overlapEnd : undefined),
+        to: true,
+        by: true,
+    });
+    // Upper segment of "to" that lies completely after the overlap
+    if ((toEnd ?? Infinity) > overlapEnd) {
+        const hiStart = overlapEnd + 1;
+        results.push({
+            range: make(hiStart, toEnd),
+            to: true,
+        });
+    }
+    return results;
+};
+// Additional range splitting utilities for complex operations
+export function parseRangeBounds(rangeKey) {
+    const split = rangeKey.split("-");
+    const start = split[0] ? Number(split[0]) : undefined;
+    const end = split[1] ? Number(split[1]) : undefined;
+    return [start, end];
+}
+export function isRangeContained(containedRange, containerRange) {
+    const [containedStart, containedEnd] = parseRangeBounds(containedRange);
+    const [containerStart, containerEnd] = parseRangeBounds(containerRange);
+    const containedStartNum = containedStart ?? -Infinity;
+    const containedEndNum = containedEnd ?? Infinity;
+    const containerStartNum = containerStart ?? -Infinity;
+    const containerEndNum = containerEnd ?? Infinity;
+    return (containedStartNum >= containerStartNum &&
+        containedEndNum <= containerEndNum);
+}
+export function extractSplitPoints(ranges) {
+    const points = new Set();
+    ranges.forEach((range) => {
+        const [start, end] = parseRangeBounds(range);
+        if (start !== undefined)
+            points.add(start);
+        if (end !== undefined)
+            points.add(end + 1);
+    });
+    return Array.from(points).sort((a, b) => a - b);
+}
+export function generateSplitRanges(splitPoints) {
+    const ranges = [];
+    for (let i = 0; i < splitPoints.length - 1; i++) {
+        const start = splitPoints[i];
+        const end = splitPoints[i + 1] - 1;
+        ranges.push(fromTuple(start, end));
+    }
+    return ranges;
+}
+export function splitOverlappingRanges(rangesToValues) {
+    if (rangesToValues.length === 0)
+        return [];
+    const ranges = rangesToValues.map(([range]) => range);
+    const splitPoints = extractSplitPoints(ranges);
+    // Generate split ranges including open-ended ranges
+    const splitRanges = [];
+    // Handle ranges before the first split point
+    if (splitPoints.length > 0) {
+        const firstPoint = splitPoints[0];
+        // Check if any range covers before firstPoint
+        const hasRangeBeforeFirst = ranges.some((range) => {
+            const [start] = parseRangeBounds(range);
+            return start === undefined || start < firstPoint;
+        });
+        if (hasRangeBeforeFirst) {
+            splitRanges.push(fromTuple(undefined, firstPoint - 1));
+        }
+    }
+    // Generate ranges between split points
+    for (let i = 0; i < splitPoints.length - 1; i++) {
+        const start = splitPoints[i];
+        const end = splitPoints[i + 1] - 1;
+        splitRanges.push(fromTuple(start, end));
+    }
+    // Handle ranges after the last split point
+    if (splitPoints.length > 0) {
+        const lastPoint = splitPoints[splitPoints.length - 1];
+        // Check if any range covers after lastPoint
+        const hasRangeAfterLast = ranges.some((range) => {
+            const [, end] = parseRangeBounds(range);
+            return end === undefined || end >= lastPoint;
+        });
+        if (hasRangeAfterLast) {
+            splitRanges.push(fromTuple(lastPoint, undefined));
+        }
+    }
+    return splitRanges
+        .map((splitRange) => {
+        const matchingValues = [];
+        rangesToValues.forEach(([originalRange, value]) => {
+            if (isRangeContained(splitRange, originalRange)) {
+                matchingValues.push(value);
+            }
+        });
+        return [splitRange, matchingValues];
+    })
+        .filter(([, values]) => values.length > 0); // Only return ranges that have matching values
+}
+export function findMatchingRangeForSplitRange(splitRange, rangesToValues) {
+    const matchingValues = [];
+    rangesToValues.forEach(([originalRange, value]) => {
+        if (isRangeContained(splitRange, originalRange)) {
+            matchingValues.push(value);
+        }
+    });
+    return matchingValues;
+}
+export function extractSeparationYears(childName, ranges, parentName, ensureArray) {
+    const separationYears = [];
+    Object.entries(ranges).forEach(([rangeKey, entries]) => {
+        if (rangeKey === "names" || !entries) {
+            return;
+        }
+        const pts = entries;
+        pts.forEach((pt) => {
+            const towns = ensureArray(pt.town);
+            const keyDiffersFromTown = !towns.includes(childName);
+            const pointsToParent = towns.includes(parentName);
+            // Only consider it a parent-child relationship if town array has EXACTLY ONE entry
+            const isSingleParent = towns.length === 1;
+            // Check if this is a range where the child points to the parent (before separation)
+            if (keyDiffersFromTown && pointsToParent && isSingleParent) {
+                // The end of this range is when the child separates
+                const split = rangeKey.split("-");
+                const end = split[1] ? Number(split[1]) : undefined;
+                if (typeof end === "number") {
+                    const separationYear = end + 1;
+                    if (!separationYears.includes(separationYear)) {
+                        separationYears.push(separationYear);
+                    }
+                }
+            }
+            // Check if this is a range where the child becomes independent (after separation)
+            else if (!keyDiffersFromTown && !pointsToParent) {
+                const split = rangeKey.split("-");
+                const start = split[0] ? Number(split[0]) : undefined;
+                if (typeof start === "number" &&
+                    !separationYears.includes(start)) {
+                    separationYears.push(start);
+                }
+            }
+        });
+    });
+    return separationYears.sort((a, b) => a - b);
+}

package/package.json

@@ -0,0 +1,153 @@
+{
+	"name": "@treeviz/gedcom-parser",
+	"version": "1.0.1",
+	"description": "Lightweight, pluggable GEDCOM parser for JavaScript/TypeScript with optional caching and place matching. Zero browser dependencies.",
+	"type": "module",
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.js"
+		},
+		"./utils": {
+			"types": "./dist/utils/index.d.ts",
+			"import": "./dist/utils/index.js"
+		},
+		"./utils/cache": {
+			"types": "./dist/utils/cache.d.ts",
+			"import": "./dist/utils/cache.js"
+		},
+		"./utils/get-raw-size": {
+			"types": "./dist/utils/get-raw-size.d.ts",
+			"import": "./dist/utils/get-raw-size.js"
+		},
+		"./utils/parser": {
+			"types": "./dist/utils/parser.d.ts",
+			"import": "./dist/utils/parser.js"
+		},
+		"./classes": {
+			"types": "./dist/classes/index.d.ts",
+			"import": "./dist/classes/index.js"
+		},
+		"./classes/*": {
+			"types": "./dist/classes/*.d.ts",
+			"import": "./dist/classes/*.js"
+		},
+		"./factories": {
+			"types": "./dist/factories/index.d.ts",
+			"import": "./dist/factories/index.js"
+		},
+		"./factories/*": {
+			"types": "./dist/factories/*.d.ts",
+			"import": "./dist/factories/*.js"
+		},
+		"./constants": {
+			"types": "./dist/constants/index.d.ts",
+			"import": "./dist/constants/index.js"
+		},
+		"./constants/*": {
+			"types": "./dist/constants/*.d.ts",
+			"import": "./dist/constants/*.js"
+		},
+		"./structures": {
+			"types": "./dist/structures/index.d.ts",
+			"import": "./dist/structures/index.js"
+		},
+		"./structures/*": {
+			"types": "./dist/structures/*.d.ts",
+			"import": "./dist/structures/*.js"
+		},
+		"./kinship-translator": {
+			"types": "./dist/kinship-translator/index.d.ts",
+			"import": "./dist/kinship-translator/index.js"
+		},
+		"./kinship-translator/*": {
+			"types": "./dist/kinship-translator/*.d.ts",
+			"import": "./dist/kinship-translator/*.js"
+		},
+		"./interfaces": {
+			"types": "./dist/interfaces/index.d.ts",
+			"import": "./dist/interfaces/index.js"
+		},
+		"./interfaces/*": {
+			"types": "./dist/interfaces/*.d.ts",
+			"import": "./dist/interfaces/*.js"
+		},
+		"./types": {
+			"types": "./dist/types/index.d.ts",
+			"import": "./dist/types/index.js"
+		},
+		"./types/*": {
+			"types": "./dist/types/*.d.ts",
+			"import": "./dist/types/*.js"
+		},
+		"./utils/*": {
+			"types": "./dist/utils/*.d.ts",
+			"import": "./dist/utils/*.js"
+		},
+		"./__tests__/test-utils": {
+			"types": "./src/__tests__/test-utils/index.ts",
+			"import": "./src/__tests__/test-utils/index.ts"
+		}
+	},
+	"files": [
+		"dist",
+		"README.md",
+		"LICENSE"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.json",
+		"dev": "tsc -p tsconfig.json --watch",
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"prepublishOnly": "npm run build"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/idavidka/gedcom-parser.git"
+	},
+	"bugs": {
+		"url": "https://github.com/idavidka/gedcom-parser/issues"
+	},
+	"homepage": "https://github.com/idavidka/gedcom-parser#readme",
+	"keywords": [
+		"gedcom",
+		"genealogy",
+		"parser",
+		"family-tree",
+		"typescript",
+		"pluggable",
+		"gedcom-parser",
+		"gedcom55",
+		"gedcom-5.5.1",
+		"family-history",
+		"ancestry",
+		"lineage",
+		"pedigree",
+		"treeviz",
+		"cache",
+		"place-matching",
+		"ssr",
+		"browser",
+		"nodejs"
+	],
+	"author": {
+		"name": "idavidka & @treeviz contributors",
+		"url": "https://github.com/idavidka"
+	},
+	"license": "MIT",
+	"dependencies": {
+		"date-fns": "^2.30.0",
+		"lodash": "^4.17.21"
+	},
+	"devDependencies": {
+		"@types/lodash": "^4.17.13",
+		"@types/node": "^20.17.23",
+		"typescript": "^5.6.3",
+		"vitest": "^3.0.7"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}