@reactodia/workspace/dist/typings/editor/dataElements.d.ts

Reactodia Workspace -- library for visual interaction with graphs in a form of a diagram.

import { type ReadonlyHashSet } from '@reactodia/hashmap';
import { Events, EventSource, PropertyChange } from '../coreUtils/events';
import { ElementIri, ElementModel, ElementTypeIri, ElementTypeModel, LinkKey, LinkModel, LinkTypeIri, LinkTypeModel, PropertyTypeIri, PropertyTypeModel } from '../data/model';
import { Element, ElementEvents, ElementProps, ElementTemplateState, Link, LinkEvents, LinkProps, LinkTemplateState } from '../diagram/elements';
import { Command } from '../diagram/history';
import { DiagramModel } from '../diagram/model';
export interface EntityElementEvents extends ElementEvents {
    changeData: PropertyChange<EntityElement, ElementModel>;
}
export interface EntityElementProps extends ElementProps {
    data: ElementModel;
}
export declare class EntityElement extends Element {
    readonly events: Events<EntityElementEvents>;
    private _data;
    constructor(props: EntityElementProps);
    static placeholderData(iri: ElementIri): ElementModel;
    protected get entitySource(): EventSource<EntityElementEvents>;
    get iri(): ElementIri;
    get data(): ElementModel;
    setData(value: ElementModel): void;
}
export declare function setEntityElementData(entity: EntityElement, data: ElementModel): Command;
export interface EntityGroupEvents extends ElementEvents {
    changeItems: PropertyChange<EntityGroup, ReadonlyArray<EntityGroupItem>>;
}
export interface EntityGroupProps extends ElementProps {
    items?: ReadonlyArray<EntityGroupItem>;
}
export declare class EntityGroup extends Element {
    readonly events: Events<EntityGroupEvents>;
    private _items;
    private _itemIris;
    constructor(props: EntityGroupProps);
    protected get entitySource(): EventSource<EntityGroupEvents>;
    get items(): ReadonlyArray<EntityGroupItem>;
    setItems(value: ReadonlyArray<EntityGroupItem>): void;
    get itemIris(): ReadonlySet<ElementIri>;
    private updateItemIris;
}
export interface EntityGroupItem {
    readonly data: ElementModel;
    readonly elementState?: ElementTemplateState | undefined;
}
export declare function setEntityGroupItems(group: EntityGroup, items: ReadonlyArray<EntityGroupItem>): Command;
export declare function iterateEntitiesOf(element: Element): Iterable<ElementModel>;
export interface RelationLinkEvents extends LinkEvents {
    changeData: PropertyChange<RelationLink, LinkModel>;
}
export interface RelationLinkProps extends LinkProps {
    data: LinkModel;
}
export declare class RelationLink extends Link {
    readonly events: Events<RelationLinkEvents>;
    private _data;
    constructor(props: RelationLinkProps);
    protected get relationSource(): EventSource<RelationLinkEvents>;
    protected getTypeId(): LinkTypeIri;
    get data(): LinkModel;
    setData(value: LinkModel): void;
    withDirection(data: LinkModel): RelationLink;
}
export declare function setRelationLinkData(relation: RelationLink, data: LinkModel): Command;
export interface RelationGroupEvents extends LinkEvents {
    changeItems: PropertyChange<RelationGroup, ReadonlyArray<RelationGroupItem>>;
}
export interface RelationGroupProps extends LinkProps {
    typeId: LinkTypeIri;
    items: ReadonlyArray<RelationGroupItem>;
}
export declare class RelationGroup extends Link {
    readonly events: Events<RelationGroupEvents>;
    private readonly _typeId;
    private _items;
    private readonly _itemKeys;
    private readonly _sources;
    private readonly _targets;
    constructor(props: RelationGroupProps);
    protected get relationSource(): EventSource<RelationGroupEvents>;
    protected getTypeId(): LinkTypeIri;
    get items(): ReadonlyArray<RelationGroupItem>;
    setItems(value: ReadonlyArray<RelationGroupItem>): void;
    get itemKeys(): ReadonlyHashSet<LinkKey>;
    get itemSources(): ReadonlySet<ElementIri>;
    get itemTargets(): ReadonlySet<ElementIri>;
    private updateItemKeys;
}
export interface RelationGroupItem {
    readonly data: LinkModel;
    readonly linkState?: LinkTemplateState | undefined;
}
export declare function setRelationGroupItems(group: RelationGroup, items: ReadonlyArray<RelationGroupItem>): Command;
export declare function iterateRelationsOf(link: Link): Iterable<LinkModel>;
export interface ElementTypeEvents {
    changeData: PropertyChange<ElementType, ElementTypeModel | undefined>;
}
export declare class ElementType {
    private readonly source;
    readonly events: Events<ElementTypeEvents>;
    readonly id: ElementTypeIri;
    private _data;
    constructor(props: {
        id: ElementTypeIri;
        data?: ElementTypeModel;
    });
    get data(): ElementTypeModel | undefined;
    setData(value: ElementTypeModel | undefined): void;
}
export interface PropertyTypeEvents {
    changeData: PropertyChange<PropertyType, PropertyTypeModel | undefined>;
}
export declare class PropertyType {
    private readonly source;
    readonly events: Events<PropertyTypeEvents>;
    readonly id: PropertyTypeIri;
    private _data;
    constructor(props: {
        id: PropertyTypeIri;
        data?: PropertyTypeModel;
    });
    get data(): PropertyTypeModel | undefined;
    setData(value: PropertyTypeModel | undefined): void;
}
export interface LinkTypeEvents {
    changeData: PropertyChange<LinkType, LinkTypeModel | undefined>;
}
export declare class LinkType {
    private readonly source;
    readonly events: Events<LinkTypeEvents>;
    readonly id: LinkTypeIri;
    private _data;
    constructor(props: {
        id: LinkTypeIri;
        data?: LinkTypeModel | undefined;
    });
    get data(): LinkTypeModel | undefined;
    setData(value: LinkTypeModel | undefined): void;
}
export declare function changeEntityData(model: DiagramModel, target: ElementIri, data: ElementModel): Command;
export declare function changeRelationData(model: DiagramModel, oldData: LinkModel, newData: LinkModel): Command;
//# sourceMappingURL=dataElements.d.ts.map