gedcom-ts 2.0.1 → 2.1.0

package/dist/edit/DateActEdit.d.ts

@@ -0,0 +1,37 @@
+import { DateAct, type Day, type Month, type TypeDateActSimpleQualifier } from "../commons/DateAct";
+/**
+ * API d’édition cohérente autour d’un {@link DateAct} existant (mutation in-place).
+ */
+export declare class DateActEdit {
+    private readonly target;
+    constructor(target: DateAct);
+    get value(): DateAct;
+    clear(): this;
+    /** Parse GEDCOM `DATE` / `SDATE` (même règles que `new DateAct(line)`). */
+    applyGedcomPayload(line: string): this;
+    setExactDate(year?: number, month?: Month, day?: Day): this;
+    setQualified(typeDateAct: TypeDateActSimpleQualifier, year?: number, month?: Month, day?: Day): this;
+    setBetween(start: {
+        year: number;
+        month?: Month;
+        day?: Day;
+    }, end: {
+        year: number;
+        month?: Month;
+        day?: Day;
+    }): this;
+    setFromTo(start: {
+        year: number;
+        month?: Month;
+        day?: Day;
+    }, end: {
+        year: number;
+        month?: Month;
+        day?: Day;
+    }): this;
+    setTime(value: string | null): this;
+    setDatePhrase(value: string | null): this;
+    appendDatePhrase(fragment: string): this;
+    setVerbatimPayload(value: string | null): this;
+}
+export declare function editDateAct(date: DateAct): DateActEdit;

package/dist/edit/NotesEdit.d.ts

@@ -0,0 +1,14 @@
+import { Note, Notes } from "../commons/Note";
+/**
+ * API d’édition cohérente autour d'un {@link Notes}.
+ */
+export declare class NotesEdit {
+    private readonly target;
+    constructor(target: Notes);
+    get value(): Notes;
+    add(note: Note): this;
+    replaceAt(index: number, note: Note): this;
+    removeAt(index: number): this;
+    clear(): this;
+}
+export declare function editNotes(notes: Notes): NotesEdit;

package/dist/edit/PersonEdit.d.ts

@@ -0,0 +1,27 @@
+import type { IndiAttribute } from "../commons/IndiAttribute";
+import { Person, Sex } from "../commons/Person";
+import type { PersonNameVariant } from "../commons/PersonNameVariant";
+import { ActsEdit } from "./ActsEdit";
+import { NotesEdit } from "./NotesEdit";
+/**
+ * API d’édition cohérente autour d'un {@link Person} existant (identité, unions, actes, notes).
+ */
+export declare class PersonEdit {
+    private readonly target;
+    constructor(target: Person);
+    get value(): Person;
+    setSex(sex: Sex | undefined): this;
+    setLastname(lastname: string): this;
+    setFirstnames(firstnames: readonly string[]): this;
+    setSosa(sosa: number | undefined): this;
+    setFamc(famc: number | undefined): this;
+    /** Remplace la liste des unions (`FAMS`). */
+    setFams(fams: readonly number[]): this;
+    clearFams(): this;
+    appendFams(famId: number): this;
+    setNameVariants(variants: readonly PersonNameVariant[]): this;
+    setAttributes(attrs: readonly IndiAttribute[]): this;
+    acts(): ActsEdit;
+    notes(): NotesEdit;
+}
+export declare function editPerson(person: Person): PersonEdit;

package/dist/edit/PlaceEdit.d.ts

@@ -0,0 +1,23 @@
+import { CoordinateGPS, Place } from "../commons/Place";
+/**
+ * API d’édition cohérente autour d’un {@link Place} existant.
+ */
+export declare class PlaceEdit {
+    private readonly target;
+    constructor(target: Place);
+    get value(): Place;
+    setFromGedcom7Payload(payload: string): this;
+    setCity(city: string | null): this;
+    setCounty(county: string | null): this;
+    setState(state: string | null): this;
+    setCountry(country: string | null): this;
+    setPlacPhrase(phrase: string | null): this;
+    appendPlacPhrase(fragment: string): this;
+    clearPlacPhrase(): this;
+    setCoordinates(latitude: number, longitude: number): this;
+    clearCoordinates(): this;
+    /** Remplace le bloc coordonnées (ex. nouveau `CoordinateGPS`). */
+    replaceCoordinateModel(coordinate: CoordinateGPS): this;
+    clearStructured(): this;
+}
+export declare function editPlace(place: Place): PlaceEdit;

package/dist/edit/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Couche d’édition cohérente (chaînage `this`, noms `set*` / `clear*` / `append*`) sur le modèle existant.
+ *
+ * @example
+ * ```ts
+ * import { editPerson, editDateAct } from "gedcom-ts";
+ * editPerson(person)
+ *   .setLastname("Dupont")
+ *   .acts()
+ *   .at(0)
+ *   .setDateAct(new DateAct("1 JAN 1900"));
+ * ```
+ */
+export { ActEdit, editAct } from "./ActEdit";
+export { ActsEdit, editActs } from "./ActsEdit";
+export { DateActEdit, editDateAct } from "./DateActEdit";
+export { NotesEdit, editNotes } from "./NotesEdit";
+export { PersonEdit, editPerson } from "./PersonEdit";
+export { PlaceEdit, editPlace } from "./PlaceEdit";

package/dist/export/GEDCOM.d.ts

@@ -1,26 +1,50 @@
 import { Person } from '../commons/Person';
+/** Options d’export `.ged` / `.zip` (round-trip partiel avec {@link ReadGed.preservedTopLevelRecords}). */
+export type GedcomExportOptions = {
+    /** Blocs `0 …` à recoller avant `SUBM` / `TRLR` (ex. `readGed.preservedTopLevelRecords`). */
+    extraTopLevelRecords?: readonly string[] | null;
+    /** Balise BCP 47 pour `1 LANG` sous `HEAD` (défaut `en-US`). */
+    headLanguageTag?: string | null;
+    /** Texte `1 COPR` sous `HEAD` (copyright / mention légale), une ligne logique. */
+    headCopyright?: string | null;
+    /**
+     * Définitions d’extensions `HEAD`.`SCHMA` (`2 TAG …`), ex. `{ tag: "_FOO", uri: "https://…" }`.
+     * Les tags sont émis tels quels (GEDCOM 7 : souvent préfixe `_`).
+     */
+    headSchemaTagDefs?: readonly {
+        readonly tag: string;
+        readonly uri: string;
+    }[] | null;
+    /**
+     * Valeur `1 DEST` sous `HEAD` (URI ou identifiant d’application cible, ex. `https://gedcom.io/`).
+     */
+    headDestination?: string | null;
+};
 declare class GEDCOM {
     protected title: string;
     protected persons: Array<Person>;
     protected onCreate: number;
     private haveFiles;
-    constructor(title: string | undefined, persons: Array<Person>, haveFiles: boolean);
+    private readonly exportOptions;
+    constructor(title: string | undefined, persons: Array<Person>, haveFiles: boolean, exportOptions?: GedcomExportOptions | null);
     private get beginGedcom();
+    private get defaultSubmitterRecord();
+    /** Enregistrements `OBJE` pour les médias avec {@link MultimediaFile.objeXrefId} et {@link MultimediaFile.sourceUri}. */
+    private collectObjeRecords;
+    private joinExtraTopLevelRecords;
     private get contentGedcom();
     gedcomBlob(): Blob;
 }
 export declare class ExportGedzipFile extends GEDCOM {
-    private zip;
-    constructor(...args: [persons: Array<Person>] | [title: string, persons: Array<Person>]);
+    constructor(...args: [Person[]] | [string, Person[]] | [Person[], GedcomExportOptions] | [string, Person[], GedcomExportOptions]);
     download(): Promise<void>;
-    private collectMediaFiles;
     private resolvePersonIndi;
     private resolveActIndis;
     private resolveZipPath;
     private zipFile;
 }
 export declare class ExportGedcomFile extends GEDCOM {
-    constructor(...args: [persons: Array<Person>] | [title: string, persons: Array<Person>]);
+    constructor(...args: [Person[]] | [string, Person[]] | [Person[], GedcomExportOptions] | [string, Person[], GedcomExportOptions]);
     download(): void;
 }
 export declare class FamilyLine {
@@ -33,18 +57,20 @@ export declare class PersonLine {
     private readonly INDI;
     private readonly NAME;
     private readonly SEX;
+    private readonly ATTRS;
     private readonly FAMS;
     private readonly FAMC;
     private readonly FILES;
     private readonly ACTS;
     private readonly NOTES;
+    private readonly haveFiles;
     constructor(person: Person, haveFiles: boolean);
     line(): string;
-    private getFileLines;
     private getIndi;
     private getName;
+    private getIndiAttributes;
     private getSex;
-    private getFiles;
+    private buildPersonMultimediaLines;
     private getFams;
     private getFamc;
 }

package/dist/import/LoadFile.d.ts

@@ -1,2 +1,16 @@
 import { ReadGed } from './ReadGed';
+import type { Place } from '../commons/Place';
+/**
+ * Erreur levée quand une entrée `.ged` dans un ZIP ne se décode pas comme du GEDCOM valide
+ * (en-tête `0 HEAD` absent au début). Cause la plus fréquente : **ZIP chiffré** (mot de passe),
+ * non pris en charge par le décompresseur utilisé ici.
+ *
+ * Les applications peuvent comparer `error.message === IMPORT_ERR_ZIP_GED_UNREADABLE`.
+ */
+export declare const IMPORT_ERR_ZIP_GED_UNREADABLE = "ZIP chiffr\u00E9 (mot de passe) ou .ged illisible dans l\u2019archive : extrayez le fichier .ged avec votre explorateur ou utilitaire ZIP, puis importez uniquement ce .ged. L\u2019import direct des archives prot\u00E9g\u00E9es par mot de passe n\u2019est pas pris en charge.";
+/** Same as {@link ReadGed.empty}; use when starting a tree without a `.ged` / `.zip` import. */
+export declare const createEmptyReadGed: (options?: {
+    mapFiles?: Map<string, File>;
+    placesMap?: Map<string, Place>;
+}) => ReadGed;
 export declare const importGedFile: (file: File) => Promise<ReadGed>;

package/dist/import/ReadGed.d.ts

@@ -1,19 +1,67 @@
 import { Person } from '../commons/Person';
 import { SplitGedcom } from "./SplitedInformations";
 import { Place } from "../commons/Place";
+import { type GedcomDatasetVersion } from "../utils/gedcom/datasetVersion";
+/**
+ * Graphe importé depuis un fichier GEDCOM. Les enregistrements de niveau `0` non intégrés au modèle
+ * typé (OBJE, REPO, SOUR, etc.) restent accessibles via {@link preservedTopLevelRecords}.
+ */
 export declare class ReadGed extends SplitGedcom {
+    private resolvedInformationFamilies;
+    private resolvedInformationNotes;
+    private famPointerToId;
+    private notePointerToId;
+    private objePayloadById;
+    /** Déduit du bloc `HEAD` (`GEDC`.`VERS`). */
+    datasetVersion: GedcomDatasetVersion;
     persons: Person[];
     mapPersons: Map<number, Person>;
     partnersMap: Map<number, Person[]>;
     childsMap: Map<number, Person[]>;
     mapFiles: Map<string, File>;
     placesMap: Map<string, Place>;
+    /**
+     * Index des pointeurs d’individu GEDCOM vers {@link Person.INDI} interne.
+     * Clés typiques : `Homer_Simpson` (xref textuelle), `I12` (xref `@I12@`).
+     */
+    private individualPointerToIndiNumber;
     constructor(gedcomContent?: string, mapFiles?: Map<string, File>, placesMap?: Map<string, Place>, mapPersons?: Map<number, Person>);
+    /**
+     * Empty genealogy (no INDI/FAM), same runtime shape as after {@link importGedFile}:
+     * `persons`, `partnersMap`, `childsMap`, `mapPersons`, `placesMap`, `mapFiles` are initialized.
+     */
+    static empty(options?: {
+        mapFiles?: Map<string, File>;
+        placesMap?: Map<string, Place>;
+    }): ReadGed;
     static fromGedcomFile(gedcomFile: File, mapFiles?: Map<string, File>, placesMap?: Map<string, Place>, mapPersons?: Map<number, Person>): Promise<ReadGed>;
     private finalizeAfterParse;
+    /**
+     * Reconstruit {@link partnersMap} et {@link childsMap} à partir des pointeurs `FAMS` / `FAMC`
+     * de chaque personne. Peut être rappelé après édition des liens ; chaque appel remplace les
+     * cartes (pas d’accumulation).
+     */
     groupPartners(): void;
     createDirectAncestries(person: Person): Person[];
     generateUniqueIndi(): number;
+    /**
+     * Résout un pointeur GEDCOM d’individu (`@Homer_Simpson@`, `Homer_Simpson`, `@I5@`, `I5`) vers la personne importée.
+     * Utile pour interpréter `1 CHIL @…@` ou `1 HUSB @…@` dans des fichiers à xref textuelle.
+     */
+    resolveIndividualPointer(raw: string): Person | undefined;
+    /** Enfants rattachés aux unions listées dans `parent.FAMS` (même logique que {@link childsMap}). */
+    getChildrenForParent(parent: Person): Person[];
+    /** Enfants d’une famille donnée (identifiant interne `F`, ex. `0` pour `@F0000@`). */
+    getChildrenOfFamily(familyId: number): Person[];
     private haveParentsOfPerson;
     private createPersons;
+    /**
+     * Xrefs textuelles `0 @Homer_Simpson@ INDI` → entiers uniques (après le max des `@I{n}@` du fichier).
+     */
+    private buildTextualIndiXrefToSyntheticIdMap;
+    private buildPerson;
+    private hydratePlacesFromActs;
+    private upsertPlace;
+    private linkPersonAsPartner;
+    private linkPersonAsChild;
 }

package/dist/import/SplitedInformations.d.ts

@@ -1,13 +1,39 @@
 export declare class SplitGedcom {
+    /** Lignes du premier enregistrement `0 HEAD` (y compris la ligne `0 HEAD`), si présent. */
+    protected informationHeaderLines: string[] | null;
     protected informationPersons: string[][];
-    protected informationFamilies: Map<number, string[]>;
-    protected informationNotes: Map<number, string[]>;
+    /** Lignes sous `0 @F…@ FAM` indexées par libellé xref canonique (`1`, `famA`, …). */
+    protected informationFamiliesByLabel: Map<string, string[]>;
+    /** Lignes sous `0 @N…@ NOTE|SNOTE` indexées par libellé xref canonique. */
+    protected informationNotesByLabel: Map<string, string[]>;
+    /**
+     * Enregistrements `0 …` non intégrés au modèle typé (OBJE, REPO, SOUR, SUBM, FAM/NOTE à xref non
+     * numérique, etc.). Conservés dans l’ordre du fichier pour diagnostic ou futur re‑export.
+     * `0 TRLR` n’est pas conservé (terminaison standard).
+     */
+    private readonly _preservedTopLevelRecords;
+    get preservedTopLevelRecords(): readonly string[];
     constructor(gedcomContent?: string);
     protected ingestGedcomText(gedcomContent: string): void;
     protected ingestGedcomFileStream(file: File): Promise<void>;
     private ingestRecordBlock;
+    /** N’ajoute pas `0 TRLR` (terminaison du fichier). */
+    private preserveTopLevelRecord;
+    /** Tout enregistrement `0 @xref@ INDI` (xref numérique `@I1@` ou textuelle `@Homer_Simpson@`). */
+    private isIndiRecordFirstLine;
+    /**
+     * Retire de {@link preservedTopLevelRecords} les blocs `0 @O…@ OBJE` décodables et renvoie leurs
+     * charges utiles pour l’hydratation des pointeurs `OBJE` sous `INDI` / actes.
+     */
+    protected absorbStandaloneObjeBlocksInto(): Map<number, {
+        sourceUri: string;
+    }>;
+    private splitInformationHeader;
     private splitInformationPersons;
+    /** @returns `true` si le bloc a été stocké dans {@link informationFamiliesByLabel}. */
     private splitInformationFamilies;
+    /** @returns `true` si le bloc a été stocké dans {@link informationNotesByLabel}. */
     private splitInformationNotes;
-    private extractXrefId;
+    private extractFamRecordLabel;
+    private extractNoteRecordLabel;
 }