read-gedcom

import { AnyConstructor } from '../meta'; import { TreeNode, TreeNodeRoot } from '../tree'; import { SelectionGedcom } from './internal'; /** * A selection of Gedcom nodes, represented in an array-like datastructure. */ export declare class SelectionAny implements ArrayLike<TreeNode> { #private; /** * The number of nodes in the selection. * @category Base */ length: number; /** * The nodes in the selection. * @category Base */ [n: number]: TreeNode; /** * The common root node of the elements in this selection. * @category Base */ rootNode: TreeNodeRoot; /** * @param rootNode * @param nodes * @category Base */ constructor(rootNode: TreeNodeRoot, nodes: TreeNode[]); /** * Returns an array of {@link TreeNode.tag}. * @category Base */ tag(): (string | null)[]; /** * Returns an array of {@link TreeNode.pointer}. * @category Base */ pointer(): (string | null)[]; /** * Returns an array of {@link TreeNode.value}. * @category Base */ value(): (string | null)[]; /** * Calls {@link value} and filters out <code>null</code> values. * @category Base */ valueNonNull(): string[]; /** * Wraps the value of {@link rootNode} in {@link SelectionGedcom}. * The selection will contain exactly one node. * @category Base */ root(): SelectionGedcom; /** * Query the direct children of this node. * It is possible to efficiently filter the results by tag and pointer. * Leaving either or both of these parameter empty will result in a wildcard behavior (not filtering). * In most cases this method is not useful as the functionality is already implemented in the subclasses through various more precise methods. * Returns an array of children. * @param tag Optionally filter the results by their Gedcom tag * @param pointer Optionally filter the result by their pointer value * @category Base */ get(tag?: string | string[] | null, pointer?: string | string[] | null): SelectionAny; /** * Query the direct children of this node. * It is possible to efficiently filter the results by tag and pointer. * Leaving either or both of these parameter empty will result in a wildcard behavior (not filtering). * In most cases this method is not useful as the functionality is already implemented in the subclasses through various more precise methods. * Returns an array of children. * Additionally, allows the specification of an adapter class. * @param tag Optionally filter the results by their Gedcom tag * @param pointer Optionally filter the result by their pointer value * @param adapter The adapter class, see {@link as} * @category Base */ get<N extends SelectionAny>(tag: string | string[] | null, pointer: string | string[] | null, adapter: AnyConstructor<N>): N; /** * Filter nodes from the selection based on a predicate. * @param f The filtering predicate * @category Base */ filter(f: (node: TreeNode) => boolean): this; /** * Filter lifted nodes from the selection based on a predicate. * The argument is a selection of one node. * @param f The filtering predicate * @category Base */ filterSelect(f: (node: this) => boolean): this; /** * View this selection as a different type. This method can be used to extend functionality for non-standard Gedcom files. * @param Adapter The class adapter * @category Base */ as<N extends SelectionAny>(Adapter: AnyConstructor<N>): N; /** * Export the selection as an array of nodes. * The inverse operation is {@link of}. * @category Base */ array(): TreeNode[]; /** * Exports the selection as an array of selections of one element. * @category Base */ arraySelect(): this[]; /** * Returns a concatenation of two selections. * The right hand side selection should be a subtype of the left hand side's. * The resulting selection will be the same type as the left hand side's. * @param other The right hand side selection * @category Base */ concatenate<N extends this>(other: N): this; /** * Returns a concatenation of two selections. * The right hand side selection should be a subtype of the left hand side's. * The resulting selection will be the same type as the left hand side's, with the elements of the right hand side's first. * @param other The right hand side selection * @category Base */ concatenateLeft<N extends this>(other: N): this; /** * Returns a sorted selection, with respect to the comparator. * The default comparator relies on the {@link TreeNode.indexSource} attribute. * @param comparator The comparator * @category Base */ sorted(comparator?: (a: TreeNode, b: TreeNode) => number): this; /** * Checks whether two selections are equal. * Note that the strategy used here is reference equality, hence for this method to return <code>true</code>, the nodes must be the same references (and in the same order). * @param other The selection to compare it against * @category Base */ equals(other: SelectionAny): boolean; /** * Returns a string representation for this selection. * @category Base */ toString(): string; /** * Create a selection from an array of nodes. * It is highly recommended (but not required) for the nodes to be at the same logical level in the hierarchy. * The inverse operation is {@link array}. * @param previous The previous selection, required to inherit the reference to the root * @param nodes The nodes to be included in the selection * @category Base */ static of(previous: SelectionAny, nodes: TreeNode[] | TreeNode): SelectionAny; /** * Create a selection from an array of nodes. * It is highly recommended (but not required) for the nodes to be at the same logical level in the hierarchy. * The inverse operation is {@link array}. * @param previous The previous selection, required to inherit the reference to the root * @param nodes The nodes to be included in the selection * @param Adapter The adapter class, see {@link as} * @category Base */ static of<N extends SelectionAny>(previous: SelectionAny, nodes: TreeNode[] | TreeNode, Adapter: AnyConstructor<N>): N; }