@treeviz/gedcom-parser 1.0.1 → 1.0.3

package/dist/cli/commands/relatives.js

@@ -0,0 +1,107 @@
+import { writeFileSync } from 'fs';
+import GedcomTree from '../../utils/parser.js';
+import { formatHeader, formatSuccess, formatListItem, formatJson, formatId, formatName, formatError, } from '../utils/formatters.js';
+import { readGedcomFile, handleError, cleanGedcomName, formatLifespan } from '../utils/helpers.js';
+export function registerRelativesCommand(program) {
+    program
+        .command('relatives <file> <id>')
+        .description('Get ancestors and/or descendants of an individual')
+        .option('-a, --ancestors', 'Include ancestors')
+        .option('-d, --descendants', 'Include descendants')
+        .option('-t, --tree', 'Include both ancestors and descendants')
+        .option('--depth <n>', 'Limit depth (generations)', '999')
+        .option('-o, --output <file>', 'Save to new GEDCOM file')
+        .option('-j, --json', 'Output in JSON format')
+        .action((file, id, options) => {
+        try {
+            const content = readGedcomFile(file);
+            const { gedcom: tree } = GedcomTree.parse(content);
+            const individual = tree.indi(id);
+            if (!individual) {
+                console.error(formatError(`Individual ${id} not found`));
+                process.exit(1);
+            }
+            const maxDepth = parseInt(options.depth || '999', 10);
+            const relatives = new Set();
+            relatives.add(id);
+            // Include both if --tree is specified
+            const includeAncestors = options.ancestors || options.tree;
+            const includeDescendants = options.descendants || options.tree;
+            // Get ancestors
+            if (includeAncestors) {
+                const getAncestors = (indi, depth) => {
+                    if (depth > maxDepth)
+                        return;
+                    const parents = indi.getParents();
+                    parents?.forEach(parent => {
+                        relatives.add(parent.id);
+                        getAncestors(parent, depth + 1);
+                    });
+                };
+                getAncestors(individual, 1);
+            }
+            // Get descendants
+            if (includeDescendants) {
+                const getDescendants = (indi, depth) => {
+                    if (depth > maxDepth)
+                        return;
+                    const children = indi.getChildren();
+                    children?.forEach(child => {
+                        relatives.add(child.id);
+                        getDescendants(child, depth + 1);
+                    });
+                };
+                getDescendants(individual, 1);
+            }
+            // Get all individuals
+            const allRelatives = Array.from(relatives)
+                .map(relId => tree.indi(relId))
+                .filter(indi => indi !== null);
+            if (options.output) {
+                // Create a new GEDCOM with only these individuals
+                const newContent = createSubsetGedcom(tree, allRelatives);
+                writeFileSync(options.output, newContent, 'utf-8');
+                console.log(formatSuccess(`Saved ${allRelatives.length} individuals to ${options.output}`));
+            }
+            else if (options.json) {
+                const jsonData = allRelatives.map(indi => ({
+                    id: indi.id,
+                    name: cleanGedcomName(indi.NAME?.toValue()),
+                    birthDate: indi.BIRT?.DATE?.toValue() || null,
+                    deathDate: indi.DEAT?.DATE?.toValue() || null,
+                }));
+                console.log(formatJson({ count: jsonData.length, individuals: jsonData }));
+            }
+            else {
+                console.log(formatHeader(`Found ${allRelatives.length} relative(s)\n`));
+                allRelatives.forEach(indi => {
+                    const name = cleanGedcomName(indi.NAME?.toValue());
+                    const lifespan = formatLifespan(indi.BIRT?.DATE?.toValue(), indi.DEAT?.DATE?.toValue());
+                    console.log(formatListItem(`${formatId(indi.id)} ${formatName(name)} ${lifespan}`));
+                });
+            }
+        }
+        catch (error) {
+            handleError(error, 'Failed to extract relatives');
+        }
+    });
+}
+function createSubsetGedcom(tree, individuals) {
+    const lines = [];
+    // Add header
+    lines.push('0 HEAD');
+    lines.push('1 SOUR gedcom-parser CLI');
+    lines.push('1 GEDC');
+    lines.push('2 VERS 5.5.1');
+    lines.push('1 CHAR UTF-8');
+    // Add individuals
+    individuals.forEach(indi => {
+        const raw = indi.raw();
+        if (raw) {
+            lines.push(...raw.split('\n').filter(line => line.trim()));
+        }
+    });
+    // Add trailer
+    lines.push('0 TRLR');
+    return lines.join('\n');
+}

package/dist/cli/commands/show.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerShowCommand(program: Command): void;
+//# sourceMappingURL=show.d.ts.map

package/dist/cli/commands/show.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"show.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/show.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAuBpC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAiN1D"}

package/dist/cli/commands/show.js

@@ -0,0 +1,176 @@
+import GedcomTree from '../../utils/parser.js';
+import { formatHeader, formatLabel, formatValue, formatListItem, formatJson, formatId, formatName, formatDate, formatPlace, formatError, } from '../utils/formatters.js';
+import { readGedcomFile, handleError, cleanGedcomName, formatLifespan } from '../utils/helpers.js';
+export function registerShowCommand(program) {
+    program
+        .command('show <file> <id>')
+        .description('Display detailed information about an individual')
+        .option('-j, --json', 'Output in JSON format')
+        .option('-f, --format <format>', 'Output format: text, json, markdown', 'text')
+        .option('--include-events', 'Include all life events')
+        .option('--include-sources', 'Include sources')
+        .action((file, id, options) => {
+        try {
+            const content = readGedcomFile(file);
+            const { gedcom: tree } = GedcomTree.parse(content);
+            const individual = tree.indi(id);
+            if (!individual) {
+                console.error(formatError(`Individual ${id} not found`));
+                process.exit(1);
+            }
+            const name = cleanGedcomName(individual.NAME?.toValue());
+            const birthDate = individual.BIRT?.DATE?.toValue();
+            const birthPlace = individual.BIRT?.PLAC?.value;
+            const deathDate = individual.DEAT?.DATE?.toValue();
+            const deathPlace = individual.DEAT?.PLAC?.value;
+            const sex = individual.SEX?.value;
+            // Get parents
+            const parents = individual.getParents();
+            const father = parents?.find(p => p.SEX?.value === 'M');
+            const mother = parents?.find(p => p.SEX?.value === 'F');
+            // Get spouses
+            const spouses = individual.getSpouses();
+            // Get children
+            const children = individual.getChildren();
+            if (options.json || options.format === 'json') {
+                const jsonData = {
+                    id: individual.id,
+                    name,
+                    sex,
+                    birth: {
+                        date: birthDate || null,
+                        place: birthPlace || null,
+                    },
+                    death: {
+                        date: deathDate || null,
+                        place: deathPlace || null,
+                    },
+                    parents: {
+                        father: father ? {
+                            id: father.id,
+                            name: cleanGedcomName(father.NAME?.toValue()),
+                        } : null,
+                        mother: mother ? {
+                            id: mother.id,
+                            name: cleanGedcomName(mother.NAME?.toValue()),
+                        } : null,
+                    },
+                    spouses: spouses.map(spouse => ({
+                        id: spouse.id,
+                        name: cleanGedcomName(spouse.NAME?.toValue()),
+                        birthDate: spouse.BIRT?.DATE?.toValue() || null,
+                        deathDate: spouse.DEAT?.DATE?.toValue() || null,
+                    })),
+                    children: children.map(child => ({
+                        id: child.id,
+                        name: cleanGedcomName(child.NAME?.toValue()),
+                        birthDate: child.BIRT?.DATE?.toValue() || null,
+                        deathDate: child.DEAT?.DATE?.toValue() || null,
+                    })),
+                };
+                console.log(formatJson(jsonData));
+            }
+            else if (options.format === 'markdown') {
+                console.log(`# ${formatId(individual.id)} ${name}\n`);
+                if (birthDate || birthPlace) {
+                    console.log(`**Born:** ${birthDate || '?'}`);
+                    if (birthPlace)
+                        console.log(`  in ${birthPlace}`);
+                    console.log();
+                }
+                if (deathDate || deathPlace) {
+                    console.log(`**Died:** ${deathDate || '?'}`);
+                    if (deathPlace)
+                        console.log(`  in ${deathPlace}`);
+                    console.log();
+                }
+                if (father || mother) {
+                    console.log('## Parents\n');
+                    if (father) {
+                        const fatherName = cleanGedcomName(father.NAME?.toValue());
+                        const fatherLifespan = formatLifespan(father.BIRT?.DATE?.toValue(), father.DEAT?.DATE?.toValue());
+                        console.log(`- **Father:** ${father.id} ${fatherName} ${fatherLifespan}`);
+                    }
+                    if (mother) {
+                        const motherName = cleanGedcomName(mother.NAME?.toValue());
+                        const motherLifespan = formatLifespan(mother.BIRT?.DATE?.toValue(), mother.DEAT?.DATE?.toValue());
+                        console.log(`- **Mother:** ${mother.id} ${motherName} ${motherLifespan}`);
+                    }
+                    console.log();
+                }
+                if (spouses.length > 0) {
+                    console.log('## Spouses\n');
+                    spouses.forEach(spouse => {
+                        const spouseName = cleanGedcomName(spouse.NAME?.toValue());
+                        const spouseLifespan = formatLifespan(spouse.BIRT?.DATE?.toValue(), spouse.DEAT?.DATE?.toValue());
+                        console.log(`- ${spouse.id} ${spouseName} ${spouseLifespan}`);
+                    });
+                    console.log();
+                }
+                if (children.length > 0) {
+                    console.log('## Children\n');
+                    children.forEach(child => {
+                        const childName = cleanGedcomName(child.NAME?.toValue());
+                        const childLifespan = formatLifespan(child.BIRT?.DATE?.toValue(), child.DEAT?.DATE?.toValue());
+                        console.log(`- ${child.id} ${childName} ${childLifespan}`);
+                    });
+                    console.log();
+                }
+            }
+            else {
+                // Text format (default)
+                console.log(formatHeader(`${formatId(individual.id)} ${formatName(name)}\n`));
+                if (sex) {
+                    console.log(`${formatLabel('Sex')} ${formatValue(sex === 'M' ? 'Male' : sex === 'F' ? 'Female' : sex)}`);
+                }
+                if (birthDate || birthPlace) {
+                    console.log(`${formatLabel('Born')} ${formatDate(birthDate)}`);
+                    if (birthPlace) {
+                        console.log(`${formatLabel('Birth Place')} ${formatPlace(birthPlace)}`);
+                    }
+                }
+                if (deathDate || deathPlace) {
+                    console.log(`${formatLabel('Died')} ${formatDate(deathDate)}`);
+                    if (deathPlace) {
+                        console.log(`${formatLabel('Death Place')} ${formatPlace(deathPlace)}`);
+                    }
+                }
+                if (father || mother) {
+                    console.log();
+                    console.log(formatHeader('Parents'));
+                    if (father) {
+                        const fatherName = cleanGedcomName(father.NAME?.toValue());
+                        const fatherLifespan = formatLifespan(father.BIRT?.DATE?.toValue(), father.DEAT?.DATE?.toValue());
+                        console.log(formatListItem(`${formatLabel('Father')} ${formatId(father.id)} ${formatName(fatherName)} ${fatherLifespan}`));
+                    }
+                    if (mother) {
+                        const motherName = cleanGedcomName(mother.NAME?.toValue());
+                        const motherLifespan = formatLifespan(mother.BIRT?.DATE?.toValue(), mother.DEAT?.DATE?.toValue());
+                        console.log(formatListItem(`${formatLabel('Mother')} ${formatId(mother.id)} ${formatName(motherName)} ${motherLifespan}`));
+                    }
+                }
+                if (spouses.length > 0) {
+                    console.log();
+                    console.log(formatHeader('Spouses'));
+                    spouses.forEach(spouse => {
+                        const spouseName = cleanGedcomName(spouse.NAME?.toValue());
+                        const spouseLifespan = formatLifespan(spouse.BIRT?.DATE?.toValue(), spouse.DEAT?.DATE?.toValue());
+                        console.log(formatListItem(`${formatId(spouse.id)} ${formatName(spouseName)} ${spouseLifespan}`));
+                    });
+                }
+                if (children.length > 0) {
+                    console.log();
+                    console.log(formatHeader('Children'));
+                    children.forEach(child => {
+                        const childName = cleanGedcomName(child.NAME?.toValue());
+                        const childLifespan = formatLifespan(child.BIRT?.DATE?.toValue(), child.DEAT?.DATE?.toValue());
+                        console.log(formatListItem(`${formatId(child.id)} ${formatName(childName)} ${childLifespan}`));
+                    });
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, 'Failed to show individual details');
+        }
+    });
+}

package/dist/cli/commands/stats.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerStatsCommand(program: Command): void;
+//# sourceMappingURL=stats.d.ts.map

package/dist/cli/commands/stats.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/stats.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAcpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6D3D"}

package/dist/cli/commands/stats.js

@@ -0,0 +1,59 @@
+import { formatHeader, formatLabel, formatCount, formatJson, } from '../utils/formatters.js';
+import { readGedcomFile, handleError } from '../utils/helpers.js';
+import GedcomTree from '../../utils/parser.js';
+export function registerStatsCommand(program) {
+    program
+        .command('stats <file>')
+        .description('Generate statistics about a GEDCOM file')
+        .option('-j, --json', 'Output in JSON format')
+        .action((file, options) => {
+        try {
+            const content = readGedcomFile(file);
+            const { gedcom: tree } = GedcomTree.parse(content);
+            // Use the stats() method from the GedCom class
+            const stats = tree.stats();
+            if (options.json) {
+                console.log(formatJson(stats));
+            }
+            else {
+                console.log(formatHeader('GEDCOM File Statistics\n'));
+                console.log(formatLabel('Total Individuals'));
+                console.log(`  ${formatCount(stats.totalIndividuals)}`);
+                console.log(formatLabel('Total Families'));
+                console.log(`  ${formatCount(stats.totalFamilies)}`);
+                console.log();
+                console.log(formatLabel('By Gender'));
+                console.log(`  Males: ${formatCount(stats.byGender.males)}`);
+                console.log(`  Females: ${formatCount(stats.byGender.females)}`);
+                console.log(`  Unknown: ${formatCount(stats.byGender.unknown)}`);
+                console.log();
+                if (stats.dateRange.earliest && stats.dateRange.latest) {
+                    console.log(formatLabel('Date Range'));
+                    console.log(`  ${stats.dateRange.earliest} - ${stats.dateRange.latest}`);
+                    console.log();
+                }
+                if (stats.averageLifespan) {
+                    console.log(formatLabel('Average Lifespan'));
+                    console.log(`  ${stats.averageLifespan.toFixed(1)} years`);
+                    console.log();
+                }
+                if (stats.topSurnames.length > 0) {
+                    console.log(formatLabel('Most Common Surnames'));
+                    stats.topSurnames.forEach(({ surname, count }) => {
+                        console.log(`  ${surname}: ${formatCount(count)}`);
+                    });
+                    console.log();
+                }
+                if (stats.topBirthPlaces.length > 0) {
+                    console.log(formatLabel('Most Common Birth Places'));
+                    stats.topBirthPlaces.slice(0, 5).forEach(({ place, count }) => {
+                        console.log(`  ${place}: ${formatCount(count)}`);
+                    });
+                }
+            }
+        }
+        catch (error) {
+            handleError(error, 'Failed to generate statistics');
+        }
+    });
+}

package/dist/cli/commands/validate.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerValidateCommand(program: Command): void;
+//# sourceMappingURL=validate.d.ts.map

package/dist/cli/commands/validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/validate.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA0BpC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAqK9D"}

package/dist/cli/commands/validate.js

@@ -0,0 +1,148 @@
+import GedcomTree from '../../utils/parser.js';
+import { formatHeader, formatSuccess, formatWarning, formatError, formatListItem, formatJson, formatCount, } from '../utils/formatters.js';
+import { readGedcomFile, handleError } from '../utils/helpers.js';
+export function registerValidateCommand(program) {
+    program
+        .command('validate <file>')
+        .description('Validate a GEDCOM file')
+        .option('-j, --json', 'Output in JSON format')
+        .option('-s, --strict', 'Enable strict validation')
+        .option('--fix', 'Attempt to fix common issues (not implemented)')
+        .action((file, options) => {
+        try {
+            const content = readGedcomFile(file);
+            const { gedcom: tree } = GedcomTree.parse(content);
+            const errors = [];
+            const warnings = [];
+            // Get GEDCOM version
+            const header = tree.HEAD;
+            const version = header?.GEDC?.VERS?.value || 'Unknown';
+            // Basic validation checks
+            const individuals = tree.indis();
+            const families = tree.fams();
+            // Check for individuals without names
+            let missingNames = 0;
+            individuals.forEach(indi => {
+                if (!indi.NAME?.toValue()) {
+                    missingNames++;
+                    warnings.push(`Individual ${indi.id} is missing a name`);
+                }
+            });
+            // Check for individuals without birth dates
+            let missingBirthDates = 0;
+            individuals.forEach(indi => {
+                if (!indi.BIRT?.DATE?.toValue()) {
+                    missingBirthDates++;
+                }
+            });
+            // Check for individuals without death dates (but marked as deceased)
+            let missingDeathDates = 0;
+            individuals.forEach(indi => {
+                if (indi.DEAT && !indi.DEAT.DATE?.toValue()) {
+                    missingDeathDates++;
+                }
+            });
+            // Check for duplicate IDs
+            const seenIds = new Set();
+            const duplicateIds = [];
+            const checkDuplicates = (item) => {
+                if (seenIds.has(item.id)) {
+                    duplicateIds.push(item.id);
+                    errors.push(`Duplicate ID found: ${item.id}`);
+                }
+                seenIds.add(item.id);
+            };
+            individuals.forEach(checkDuplicates);
+            families.forEach(checkDuplicates);
+            // Check for missing family members
+            families.forEach(fam => {
+                const husb = fam.HUSB?.value;
+                const wife = fam.WIFE?.value;
+                if (!husb && !wife) {
+                    warnings.push(`Family ${fam.id} has no husband or wife`);
+                }
+                if (husb && !tree.indi(husb)) {
+                    errors.push(`Family ${fam.id} references non-existent husband ${husb}`);
+                }
+                if (wife && !tree.indi(wife)) {
+                    errors.push(`Family ${fam.id} references non-existent wife ${wife}`);
+                }
+            });
+            // Check for invalid date formats (basic check)
+            individuals.forEach(indi => {
+                const birthDate = indi.BIRT?.DATE?.toValue();
+                const deathDate = indi.DEAT?.DATE?.toValue();
+                if (birthDate && birthDate.includes('INVALID')) {
+                    errors.push(`Invalid birth date format for ${indi.id}`);
+                }
+                if (deathDate && deathDate.includes('INVALID')) {
+                    errors.push(`Invalid death date format for ${indi.id}`);
+                }
+            });
+            const result = {
+                valid: errors.length === 0,
+                version,
+                errors,
+                warnings,
+            };
+            if (options.json) {
+                console.log(formatJson(result));
+            }
+            else {
+                if (result.valid) {
+                    console.log(formatSuccess(`Valid GEDCOM ${version} file`));
+                }
+                else {
+                    console.log(formatError(`Invalid GEDCOM file - ${errors.length} error(s) found`));
+                }
+                console.log();
+                console.log(formatHeader('Validation Summary'));
+                console.log(`${formatError('Errors:')} ${formatCount(errors.length)}`);
+                console.log(`${formatWarning('Warnings:')} ${formatCount(warnings.length)}`);
+                if (errors.length > 0) {
+                    console.log();
+                    console.log(formatHeader('Errors'));
+                    errors.slice(0, 10).forEach(error => {
+                        console.log(formatListItem(formatError(error)));
+                    });
+                    if (errors.length > 10) {
+                        console.log(formatListItem(`... and ${errors.length - 10} more errors`));
+                    }
+                }
+                if (warnings.length > 0) {
+                    console.log();
+                    console.log(formatHeader('Warnings'));
+                    // Summarize warnings
+                    if (missingBirthDates > 0) {
+                        console.log(formatListItem(formatWarning(`Missing birth dates: ${missingBirthDates} individuals`)));
+                    }
+                    if (missingDeathDates > 0) {
+                        console.log(formatListItem(formatWarning(`Missing death dates: ${missingDeathDates} individuals`)));
+                    }
+                    if (duplicateIds.length > 0) {
+                        console.log(formatListItem(formatWarning(`Duplicate IDs: ${duplicateIds.length}`)));
+                    }
+                    // Show first few specific warnings
+                    const otherWarnings = warnings.filter(w => !w.includes('birth') && !w.includes('death'));
+                    otherWarnings.slice(0, 5).forEach(warning => {
+                        console.log(formatListItem(formatWarning(warning)));
+                    });
+                    if (otherWarnings.length > 5) {
+                        console.log(formatListItem(`... and ${otherWarnings.length - 5} more warnings`));
+                    }
+                }
+                if (options.fix) {
+                    console.log();
+                    console.log(formatWarning('Fix option is not yet implemented'));
+                }
+            }
+            // Exit with error code if validation failed
+            if (!result.valid) {
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            handleError(error, 'Failed to validate GEDCOM file');
+        }
+    });
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cli/index.ts"],"names":[],"mappings":""}

package/dist/cli/index.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { registerInfoCommand } from './commands/info.js';
+import { registerFindCommand } from './commands/find.js';
+import { registerShowCommand } from './commands/show.js';
+import { registerValidateCommand } from './commands/validate.js';
+import { registerRelativesCommand } from './commands/relatives.js';
+import { registerExtractCommand } from './commands/extract.js';
+import { registerStatsCommand } from './commands/stats.js';
+import { registerMergeCommand } from './commands/merge.js';
+import { registerConvertCommand } from './commands/convert.js';
+// Get package version
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const program = new Command();
+program
+    .name('gedcom-parser')
+    .description('CLI tool for parsing and manipulating GEDCOM files')
+    .version(packageJson.version);
+// Register all commands
+registerInfoCommand(program);
+registerFindCommand(program);
+registerShowCommand(program);
+registerValidateCommand(program);
+registerRelativesCommand(program);
+registerExtractCommand(program);
+registerStatsCommand(program);
+registerMergeCommand(program);
+registerConvertCommand(program);
+// Parse arguments
+program.parse(process.argv);
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/cli/utils/formatters.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Format a success message
+ */
+export declare function formatSuccess(message: string): string;
+/**
+ * Format a warning message
+ */
+export declare function formatWarning(message: string): string;
+/**
+ * Format an error message
+ */
+export declare function formatError(message: string): string;
+/**
+ * Format an info message
+ */
+export declare function formatInfo(message: string): string;
+/**
+ * Format a header
+ */
+export declare function formatHeader(text: string): string;
+/**
+ * Format a field label
+ */
+export declare function formatLabel(label: string): string;
+/**
+ * Format a value
+ */
+export declare function formatValue(value: string | number | null | undefined): string;
+/**
+ * Format an ID
+ */
+export declare function formatId(id: string): string;
+/**
+ * Format a count
+ */
+export declare function formatCount(count: number): string;
+/**
+ * Format a date
+ */
+export declare function formatDate(date: string | null | undefined): string;
+/**
+ * Format a place
+ */
+export declare function formatPlace(place: string | null | undefined): string;
+/**
+ * Format a name
+ */
+export declare function formatName(name: string | null | undefined): string;
+/**
+ * Format a list item
+ */
+export declare function formatListItem(text: string, indent?: number): string;
+/**
+ * Format a table row
+ */
+export declare function formatTableRow(columns: string[], widths: number[]): string;
+/**
+ * Format a table separator
+ */
+export declare function formatTableSeparator(widths: number[]): string;
+/**
+ * Pretty print JSON
+ */
+export declare function formatJson(data: unknown): string;
+/**
+ * Format a progress indicator
+ */
+export declare function formatProgress(current: number, total: number): string;
+//# sourceMappingURL=formatters.d.ts.map

package/dist/cli/utils/formatters.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../../src/cli/utils/formatters.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEnD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAElD;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAK7E;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE3C;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAKlE;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAKpE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAOlE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,GAAE,MAAU,GAAG,MAAM,CAGvE;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAI1E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,MAAM,CAI7D;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAEhD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAKrE"}