Interface GraphEdgeCollection<NodeData, EdgeData>

Store-backed edge membership with atomic batch helpers.

interface GraphEdgeCollection<NodeData = unknown, EdgeData = unknown> {
    size: number;
    filter(
        predicate: (edge: GraphEdge<EdgeData>, index: number) => boolean,
    ): GraphEdgeCollection<NodeData, EdgeData>;
    forEach(visitor: (item: GraphEdge, index: number) => void): void;
    has(id: GraphId): boolean;
    ids(): readonly GraphId[];
    keys(): readonly string[];
    map<T>(mapper: (item: GraphEdge, index: number) => T): readonly T[];
    toArray(): readonly GraphEdge<EdgeData>[];
    updateAttributes(
        attributes: GraphAttributes,
        mode?: AttributeUpdateMode,
    ): GraphBatchMutationResult;
    updateData(
        updater: (edge: GraphEdge<EdgeData>, index: number) => EdgeData,
    ): GraphBatchMutationResult;
}

Type Parameters

NodeData = unknown
EdgeData = unknown

Hierarchy

CollectionReads<GraphEdge<EdgeData>>
- GraphEdgeCollection

Index

Properties

Methods

filter forEach has ids keys map toArray updateAttributes updateData

Properties

`Readonly`size

size: number

Number of members that currently exist in the source store.

Methods

filter

filter(
predicate: (edge: GraphEdge<EdgeData>, index: number) => boolean,
): GraphEdgeCollection<NodeData, EdgeData>
Parameters
- predicate: (edge: GraphEdge<EdgeData>, index: number) => boolean
Returns GraphEdgeCollection<NodeData, EdgeData>

forEach

forEach(visitor: (item: GraphEdge, index: number) => void): void
Parameters
- visitor: (item: GraphEdge, index: number) => void
Returns void

Inherited from CollectionReads.forEach

has

has(id: GraphId): boolean
Parameters
- id: GraphId
Returns boolean

Inherited from CollectionReads.has

ids

ids(): readonly GraphId[]

Current stored ID representations, in current store order.

Returns readonly GraphId[]

Inherited from CollectionReads.ids

keys

keys(): readonly string[]

Returns readonly string[]

Inherited from CollectionReads.keys

map

map<T>(mapper: (item: GraphEdge, index: number) => T): readonly T[]
Type Parameters
- T
Parameters
- mapper: (item: GraphEdge, index: number) => T
Returns readonly T[]

Inherited from CollectionReads.map

toArray

toArray(): readonly GraphEdge<EdgeData>[]

Frozen record array; application data retains its original reference semantics.

Returns readonly GraphEdge<EdgeData>[]

Inherited from CollectionReads.toArray

updateAttributes

updateAttributes(
attributes: GraphAttributes,
mode?: AttributeUpdateMode,
): GraphBatchMutationResult
Parameters
- attributes: GraphAttributes
- Optionalmode: AttributeUpdateMode
Returns GraphBatchMutationResult

updateData

updateData(
updater: (edge: GraphEdge<EdgeData>, index: number) => EdgeData,
): GraphBatchMutationResult
Synchronously compute data, then commit one batch. Updaters must not mutate the store.
Parameters
- updater: (edge: GraphEdge<EdgeData>, index: number) => EdgeData
Returns GraphBatchMutationResult