@metadev/daga 1.4.1 → 1.4.2

package/index.d.ts

@@ -2,6 +2,8 @@ export { CollapseButtonComponent } from './lib/collapse-button/collapse-button.c
 export { DagaModule } from './lib/daga.module';
 export { DiagramButtonsComponent } from './lib/diagram-buttons/diagram-buttons.component';
 export { DiagramEditorComponent } from './lib/diagram-editor/diagram-editor.component';
+export { CollabClient } from './lib/diagram-editor/diagram/collab/collab-client';
+export { CollabTimestamp as LogicalTimestamp } from './lib/diagram-editor/diagram/collab/primitives';
 export { DagaExporter } from './lib/diagram-editor/diagram/converters/daga-exporter';
 export { DagaImporter } from './lib/diagram-editor/diagram/converters/daga-importer';
 export { DagaModel } from './lib/diagram-editor/diagram/converters/daga-model';
@@ -35,13 +37,13 @@ export { DiagramButtons } from './lib/interfaces/diagram-buttons';
 export { DiagramEditor } from './lib/interfaces/diagram-editor';
 export { Palette } from './lib/interfaces/palette';
 export { PropertyEditor } from './lib/interfaces/property-editor';
-export { ObjectEditorComponent } from './lib/object-editor/object-editor.component';
 export { PaletteComponent } from './lib/palette/palette.component';
+export { ObjectEditorComponent } from './lib/property-editor/object-editor/object-editor.component';
 export { PropertyEditorComponent } from './lib/property-editor/property-editor.component';
+export { TextListEditorComponent } from './lib/property-editor/text-list-editor/text-list-editor.component';
+export { TextMapEditorComponent } from './lib/property-editor/text-map-editor/text-map-editor.component';
 export { CanvasProviderService } from './lib/services/canvas-provider.service';
 export { DagaConfigurationService } from './lib/services/daga-configuration.service';
-export { TextListEditorComponent } from './lib/text-list-editor/text-list-editor.component';
-export { TextMapEditorComponent } from './lib/text-map-editor/text-map-editor.component';
 export { Line, Point, Rectangle } from './lib/util/canvas-util';
 export { LineShape, LineStyle } from './lib/util/line';
 export { ClosedShape } from './lib/util/shape';

package/lib/daga.module.d.ts

@@ -4,16 +4,15 @@ import * as i2 from "./diagram-buttons/diagram-buttons.component";
 import * as i3 from "./diagram/diagram.component";
 import * as i4 from "./diagram-editor/diagram-editor.component";
 import * as i5 from "./errors/errors.component";
-import * as i6 from "./object-editor/object-editor.component";
+import * as i6 from "./property-editor/object-editor/object-editor.component";
 import * as i7 from "./palette/palette.component";
-import * as i8 from "./text-list-editor/text-list-editor.component";
-import * as i9 from "./text-map-editor/text-map-editor.component";
+import * as i8 from "./property-editor/text-list-editor/text-list-editor.component";
+import * as i9 from "./property-editor/text-map-editor/text-map-editor.component";
 import * as i10 from "./property-editor/property-editor.component";
 import * as i11 from "@angular/common";
 import * as i12 from "@angular/forms";
-import * as i13 from "@metadev/lux";
 export declare class DagaModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<DagaModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<DagaModule, never, [typeof i1.CollapseButtonComponent, typeof i2.DiagramButtonsComponent, typeof i3.DiagramComponent, typeof i4.DiagramEditorComponent, typeof i5.ErrorsComponent, typeof i6.ObjectEditorComponent, typeof i7.PaletteComponent, typeof i8.TextListEditorComponent, typeof i9.TextMapEditorComponent, typeof i10.PropertyEditorComponent, typeof i11.CommonModule, typeof i12.FormsModule, typeof i13.LuxModule], [typeof i3.DiagramComponent, typeof i4.DiagramEditorComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DagaModule, never, [typeof i1.CollapseButtonComponent, typeof i2.DiagramButtonsComponent, typeof i3.DiagramComponent, typeof i4.DiagramEditorComponent, typeof i5.ErrorsComponent, typeof i6.ObjectEditorComponent, typeof i7.PaletteComponent, typeof i8.TextListEditorComponent, typeof i9.TextMapEditorComponent, typeof i10.PropertyEditorComponent, typeof i11.CommonModule, typeof i12.FormsModule], [typeof i3.DiagramComponent, typeof i4.DiagramEditorComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<DagaModule>;
 }

package/lib/diagram-editor/diagram/collab/collab-action.d.ts

@@ -0,0 +1,90 @@
+import { Canvas } from '../../../interfaces/canvas';
+import { Point } from '../../../util/canvas-util';
+import { CollabTimestamp } from './primitives';
+/**
+ * An action taken by a local or remote user.
+ *
+ * The action can performed on its creator's device, serialized
+ * and deserialized to reach remote users' devices, and performed
+ * on remote users' devices.
+ * @private
+ */
+export interface CollabAction {
+    /**
+     * Performs this action on the diagram.
+     *
+     * Note: Local Actions should call `canvas.collabEngine.doCollaboratively(collabAction)`, **not** this method directly.
+     *
+     * CollabAction `do()` methods must follow the rules of operation-based CRDT messages:
+     * If two users concurrently create CollabActions (possibly of different types) on the same diagram, then performing the actions on a future diagram state _in either order_ must result in the same diagram state.
+     */
+    do(): void;
+    /**
+     * Serializes this action, converting it to a JSON form.
+     *
+     * To deserialize, use the *static* deserialize method on the same class.
+     */
+    serialize(): CollabActionSerialized;
+}
+/**
+ * @private
+ */
+export type CollabActionSerialized = AddNodeSerialized | MoveNodeSerialized;
+/**
+ * @private
+ */
+export type AddNodeSerialized = {
+    type: 'add';
+    id: string;
+    nodeTypeId: string;
+    coords: Point;
+    label?: string;
+    values?: {
+        [key: string]: unknown;
+    };
+};
+/**
+ * Collaborative action which consists of adding a node.
+ * @see AddNodeAction
+ * @private
+ */
+export declare class AddNodeCollabAction implements CollabAction {
+    canvas: Canvas;
+    id: string;
+    nodeTypeId: string;
+    coords: Point;
+    label?: string;
+    values?: {
+        [key: string]: unknown;
+    };
+    constructor(canvas: Canvas, id: string, nodeTypeId: string, coords: Point, label?: string, values?: {
+        [key: string]: unknown;
+    });
+    do(): void;
+    serialize(): AddNodeSerialized;
+    static deserialize(canvas: Canvas, serialized: AddNodeSerialized): AddNodeCollabAction;
+}
+/**
+ * @private
+ */
+export type MoveNodeSerialized = {
+    type: 'move';
+    nodeId: string;
+    to: Point;
+    timestamp: CollabTimestamp;
+};
+/**
+ * Collaborative action which consists of moving a node.
+ * @see MoveNodeAction
+ * @private
+ */
+export declare class MoveNodeCollabAction implements CollabAction {
+    readonly canvas: Canvas;
+    readonly nodeId: string;
+    readonly to: Point;
+    readonly timestamp: CollabTimestamp;
+    constructor(canvas: Canvas, nodeId: string, to: Point, timestamp: CollabTimestamp);
+    do(): void;
+    serialize(): MoveNodeSerialized;
+    static deserialize(canvas: Canvas, serialized: MoveNodeSerialized): MoveNodeCollabAction;
+}

package/lib/diagram-editor/diagram/collab/collab-client.d.ts

@@ -0,0 +1,57 @@
+import { Canvas } from '../../../interfaces/canvas';
+/**
+ * The client that communicates with the daga-server over WebSockets.
+ *
+ * Use this to create and join rooms.
+ * @public
+ */
+export declare class CollabClient {
+    /**
+     * The WebSocket URL of the daga-server.
+     */
+    readonly dagaServer: string;
+    readonly userId: string;
+    readonly clientId: string;
+    private readonly ws;
+    private sendQueue;
+    /**
+     * Joined sessions by locator.
+     */
+    private sessions;
+    /**
+     * Created but unacked sessions by refId.
+     */
+    private pendingSessions;
+    constructor(dagaServer: string, userId: string);
+    private onOpen;
+    private onMessage;
+    private onClose;
+    private onError;
+    /**
+     * Internal send method. Use instead of calling ws.send directly.
+     */
+    private send;
+    /**
+     * Internal receive method. Use instead of handling ws receive events directly.
+     */
+    private receive;
+    /**
+     * Creates and joins a room. The given canvas becomes collaborative, starting
+     * with its current model.
+     *
+     * Returns a Promise that resolves with the new room's locator once joined.
+     * @public
+     */
+    createAndJoinRoom(canvas: Canvas): Promise<string>;
+    /**
+     * Joins the room with the given locator. The given canvas becomes collaborative,
+     * **replacing** its current model with the room's model.
+     *
+     * Returns a Promise that resolves once the room has been joined and loaded into
+     * the canvas. You should hide or lock the canvas until it resolves, since any
+     * user inputs before then will be overwritten.
+     * @public
+     */
+    joinRoom(canvas: Canvas, locator: string): Promise<void>;
+    private startSyncing;
+}

package/lib/diagram-editor/diagram/collab/collab-engine.d.ts

@@ -0,0 +1,46 @@
+import type { Canvas } from '../../../interfaces/canvas';
+import { CollabAction, CollabActionSerialized } from './collab-action';
+import { CollabTimestamp } from './primitives';
+/**
+ * A collaboration engine, which manages collaboration for a diagram.
+ * @private
+ */
+export declare class CollabEngine {
+    /**
+     * Canvas that this collaboration engine belongs to.
+     * @private
+     */
+    readonly canvas: Canvas;
+    /**
+     * The local replica ID.
+     */
+    readonly replicaId: string;
+    /**
+     * Event handler for when we request to send a message to the server.
+     */
+    onSend?: (message: CollabActionSerialized) => void;
+    /**
+     * Whether we have joined (or are joining) a room on the server.
+     */
+    isInRoom: boolean;
+    constructor(canvas: Canvas);
+    /**
+     * Returns a fresh timestamp, suitable for use by new CollabActions.
+     */
+    freshTimestamp(): CollabTimestamp;
+    /**
+     * Returns a fresh unique ID, suitable for use by new CollabActions.
+     */
+    freshId(): string;
+    /**
+     * Performs the action - immediately locally, and eventually for remote collaborators.
+     */
+    doCollaboratively(action: CollabAction): void;
+    /**
+     * Processes a message received from the server.
+     *
+     * The message is assumed to be non-redundant (in particular, not one of
+     * our own messages) and delivered after all prior messages on the server.
+     */
+    receive(message: CollabActionSerialized): void;
+}

package/lib/diagram-editor/diagram/collab/message-types.d.ts

@@ -0,0 +1,97 @@
+/**
+ * Message types for communicating with the daga server.
+ *
+ * Duplicated between https://github.com/metadevpro/daga-server/blob/dev/types.ts and
+ * https://github.com/metadevpro/daga/blob/dev/libs/daga/src/lib/diagram-editor/diagram/collab/message-types.ts
+ */
+/**
+ * Stand-in for the DagaModel type on the server.
+ */
+export interface DagaModelStub {
+}
+export interface RoomInfo {
+    locator: string;
+    ownerId: string;
+    initialModel: DagaModelStub;
+    messages: AddMessage[];
+}
+export interface UserInfo {
+    id: string;
+    username: string;
+}
+export interface ClientInfo {
+    key: string;
+    connection: unknown;
+    user: UserInfo;
+    ts: string;
+}
+export interface IMessage {
+    ts: string;
+}
+export type Message = HeloMessage | ByeMessage | CreateMessage | CreateAckMessage | EnrollMessage | EnrollAckMessage | DeleteMessage | AddMessage | ErrorMessage | OkMessage;
+export interface HeloMessage extends IMessage {
+    type: 'HELO';
+    clientId: string;
+    userId: string;
+    token?: string;
+    /** version of the protocol */
+    version: string;
+}
+export interface ByeMessage extends IMessage {
+    type: 'BYE';
+    clientId: string;
+    userId: string;
+}
+export interface CreateMessage extends IMessage {
+    type: 'CREA';
+    clientId: string;
+    userId: string;
+    /** Correlation id for the client */
+    refId: string;
+    initialModel: DagaModelStub;
+}
+export interface CreateAckMessage extends IMessage {
+    type: 'CACK';
+    clientId: string;
+    userId: string;
+    /** Correlation id for the client */
+    refId: string;
+    locator: string;
+}
+export interface EnrollMessage extends IMessage {
+    type: 'ENRO';
+    clientId: string;
+    userId: string;
+    locator: string;
+}
+export interface EnrollAckMessage extends IMessage {
+    type: 'EACK';
+    locator: string;
+    initialModel: DagaModelStub;
+}
+export interface DeleteMessage extends IMessage {
+    type: 'DLTE';
+    clientId: string;
+    userId: string;
+    locator: string;
+}
+export interface AddMessage extends IMessage {
+    type: 'ADD';
+    clientId: string;
+    userId: string;
+    locator: string;
+    payload: unknown;
+}
+export interface ErrorMessage extends IMessage {
+    type: 'ERR';
+    clientId: string;
+    userId: string;
+    locator: string;
+    status: number;
+    description: string;
+}
+export interface OkMessage extends IMessage {
+    type: 'OK';
+    clientId: string;
+    userId: string;
+}

package/lib/diagram-editor/diagram/collab/primitives.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A timestamp used to break ties during collaborative editing.
+ * If multiple users edit a property at the same time, the edit with the last timestamp "wins".
+ *
+ * Specifically, `CollabTimestamp` is a [Lamport timestamp](https://en.wikipedia.org/wiki/Lamport_timestamp),
+ * consisting of a logical clock and a tiebreaker (`replicaId`, a UUID that is created fresh for each diagram).
+ */
+export type CollabTimestamp = [clock: number, replicaId: string];
+/**
+ * Returns whether the incoming timestamp wins over the existing timestamp.
+ *
+ * In the DiagramModel, timestamps that have never been set are left undefined;
+ * `timestampWins` treats that as an "initial timestamp" that loses to all LogicalTimestamps.
+ */
+export declare function timestampWins(incoming: CollabTimestamp, existing: CollabTimestamp | undefined): boolean;

package/lib/diagram-editor/diagram/converters/daga-model.d.ts

@@ -1,5 +1,6 @@
 import { Point } from '../../../util/canvas-util';
 import { Side } from '../../../util/svg-util';
+import { CollabTimestamp } from '../collab/primitives';
 export declare const DAGA_FILE_VERSION = 1;
 /**
  * Representation of a diagram model in a serialized format.
@@ -18,6 +19,7 @@ export interface DagaModel {
     createdAt: Date;
     updatedAt: Date;
     updatedDaysAgo?: string;
+    logicalClock?: number;
     nodes: {
         id: string;
         type: string;
@@ -44,6 +46,7 @@ export interface DagaModel {
         }[];
         label: string;
         coords: Point;
+        coordsTimestamp?: CollabTimestamp;
         width: number;
         height: number;
         data: {

package/lib/diagram-editor/diagram/diagram-action.d.ts

@@ -1,13 +1,10 @@
 import { Canvas } from '../../interfaces/canvas';
 import { Point } from '../../util/canvas-util';
 import { Side } from '../../util/svg-util';
-import { DiagramConnection, DiagramConnectionType } from './diagram-connection';
-import { DiagramField } from './diagram-field';
+import { DiagramConnectionType } from './diagram-connection';
 import { DiagramModel } from './diagram-model';
-import { DiagramNode, DiagramNodeType } from './diagram-node';
-import { DiagramPort } from './diagram-port';
+import { DiagramNodeType } from './diagram-node';
 import { ValueSet } from './diagram-property';
-import { DiagramSection } from './diagram-section';
 /**
  * A queue of recent actions taken by the user that can be undone and redone.
  * @private
@@ -56,7 +53,21 @@ export declare class ActionQueue {
  * @private
  */
 export interface DiagramAction {
+    /**
+     * Perform this action on the diagram for the first time.
+     * Performing the same action with the same parameters on a diagram with the same state should always result in the same changes to the state of the diagram.
+     */
+    do(): void;
+    /**
+     * Undo the changes in the diagram caused by this action.
+     * After having called `do()` followed by `undo()`, calling `redo()` followed by `undo()` any number of times should always result in no net changes to the state of the diagram.
+     */
     undo(): void;
+    /**
+     * Redo the changes in the diagram caused by this action.
+     * After having called `do()`, calling `undo()` followed by `redo()` any number of times should always result in no net changes to the state of the diagram.
+     * `redo()` is usually equivalent to `do()`, but not always.
+     */
     redo(): void;
 }
 /**
@@ -132,16 +143,11 @@ export declare class AddNodeAction implements DiagramAction {
     values?: {
         [key: string]: unknown;
     };
-    id?: string | undefined;
-    sectionIds?: (string | undefined)[];
-    sectionPortIds?: (string | undefined)[][];
-    sectionPortLabelIds?: (string | undefined)[][];
-    portIds?: (string | undefined)[];
-    portLabelIds?: (string | undefined)[];
-    labelId?: string | undefined;
+    id: string;
     constructor(canvas: Canvas, type: DiagramNodeType, coords: Point, label?: string, values?: {
         [key: string]: unknown;
-    }, id?: string);
+    });
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -156,6 +162,7 @@ export declare class MoveNodeAction implements DiagramAction {
     from: Point;
     to: Point;
     constructor(canvas: Canvas, nodeId: string, from: Point, to: Point);
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -171,6 +178,7 @@ export declare class StretchNodeAction implements DiagramAction {
     from: number;
     to: number;
     constructor(canvas: Canvas, nodeId: string, direction: Side, from: number, to: number);
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -186,6 +194,7 @@ export declare class StretchSectionAction implements DiagramAction {
     from: number;
     to: number;
     constructor(canvas: Canvas, sectionId: string, direction: Side, from: number, to: number);
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -201,6 +210,7 @@ export declare class AddConnectionAction implements DiagramAction {
     endId: string;
     id?: string;
     constructor(canvas: Canvas, type: DiagramConnectionType, startId: string, endId: string, id?: string);
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -215,6 +225,7 @@ export declare class EditFieldAction implements DiagramAction {
     from: string;
     to: string;
     constructor(canvas: Canvas, fieldId: string, from: string, to: string);
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -238,6 +249,7 @@ export declare class UpdateValuesAction implements DiagramAction {
         [key: string]: unknown;
     });
     getValueSet(): ValueSet | undefined;
+    do(): void;
     undo(): void;
     redo(): void;
 }
@@ -247,17 +259,13 @@ export declare class UpdateValuesAction implements DiagramAction {
  */
 export declare class RemoveAction implements DiagramAction {
     model: DiagramModel;
-    nodes: DiagramNode[];
     nodeIds: string[];
-    sections: DiagramSection[];
     sectionIds: string[];
-    ports: DiagramPort[];
     portIds: string[];
-    connections: DiagramConnection[];
     connectionIds: string[];
-    fields: DiagramField[];
     fieldIds: string[];
-    constructor(model: DiagramModel, nodes: DiagramNode[], sections: DiagramSection[], ports: DiagramPort[], connections: DiagramConnection[], fields: DiagramField[]);
+    constructor(model: DiagramModel, nodeIds: string[], sectionIds: string[], portIds: string[], connectionIds: string[], fieldIds: string[]);
+    do(): void;
     undo(): void;
     redo(): void;
 }

package/lib/diagram-editor/diagram/diagram-canvas.d.ts

@@ -4,6 +4,7 @@ import { DiagramValidator } from '../../errors/diagram-validator';
 import { Canvas } from '../../interfaces/canvas';
 import { DiagramEditor } from '../../interfaces/diagram-editor';
 import { Point } from '../../util/canvas-util';
+import { CursorStyle } from '../../util/style';
 import { ActionQueue, DiagramActions } from './diagram-action';
 import { DiagramConfig } from './diagram-config';
 import { DiagramConnection, DiagramConnectionType } from './diagram-connection';
@@ -11,7 +12,7 @@ import { DiagramElement } from './diagram-element';
 import { DiagramModel } from './diagram-model';
 import { DiagramPort } from './diagram-port';
 import { ValueSet } from './diagram-property';
-import { CursorStyle } from '../../util/style';
+import { CollabEngine } from './collab/collab-engine';
 /**
  * Thickness of the invisible path around a connection used to make it easier to click on, in pixels.
  * @private
@@ -49,6 +50,7 @@ export declare class DiagramCanvas implements Canvas {
         [key in DiagramActions]?: boolean;
     };
     actionQueue: ActionQueue;
+    collabEngine: CollabEngine;
     private static canvasCount;
     private backgroundPatternId;
     private zoomBehavior;

package/lib/diagram-editor/diagram/diagram-connection.d.ts

@@ -133,17 +133,49 @@ export declare class DiagramConnection extends DiagramElement {
     set name(name: string);
     constructor(model: DiagramModel, type: DiagramConnectionType, start?: DiagramPort, end?: DiagramPort, id?: string);
     updateInView(): void;
+    /**
+     * Set the start of this connection to the given port or reset this connection's starting port if `undefined`.
+     * Add or remove this connection from the list of outgoing connections of ports correspondingly.
+     * @public
+     * @param start A port.
+     */
     setStart(start?: DiagramPort): void;
+    /**
+     * Set the end of this connection to the given port or reset this connection's ending port if `undefined`.
+     * Add or remove this connection from the list of incoming connections of ports correspondingly.
+     * @public
+     * @param end A port.
+     */
     setEnd(end?: DiagramPort): void;
+    /**
+     * Reassign the start and end ports of this connection to ports with less distance between them that have the same root element.
+     * If no ports with less distance between them are found, do nothing.
+     * @public
+     */
     tighten(): void;
     getPriority(): number;
 }
 export declare class DiagramConnectionSet extends DiagramEntitySet<DiagramConnection> {
     private model;
+    /**
+     * Set of the possible types of connection that the connections of this set can have.
+     * @public
+     */
     types: DiagramEntitySet<DiagramConnectionType>;
+    /**
+     * Instance a set of connections for the given model. This method is used internally.
+     * @private
+     */
     constructor(model: DiagramModel);
-    new(type: DiagramConnectionType, start?: DiagramPort, end?: DiagramPort, id?: string | undefined): DiagramConnection;
+    /**
+     * Instance a new connection and add it to this set.
+     * @public
+     * @param type The type of the connection given as either the type itself or the id of the type.
+     * @param start The start port of the connection.
+     * @param end The end port of the connection.
+     * @param id The id of the connection. Should be left undefined unless a specific id is required.
+     * @returns The instanced connection.
+     */
+    new(type: DiagramConnectionType | string, start?: DiagramPort, end?: DiagramPort, id?: string | undefined): DiagramConnection;
     remove(id: string): void;
-    filter(type?: string, threshold?: number): DiagramConnection[];
-    find(type?: string, threshold?: number): DiagramConnection | undefined;
 }

package/lib/diagram-editor/diagram/diagram-element.d.ts

@@ -41,6 +41,11 @@ export declare abstract class DiagramElement implements DiagramEntity {
      * @private
      */
     selected: boolean;
+    /**
+     * Whether this diagram element has been removed.
+     * @private
+     */
+    removed: boolean;
     constructor(model: DiagramModel, id: string);
     /**
      * Get the priority of this element to calculate whether it should be filtered out in the view or not.
@@ -112,13 +117,13 @@ export declare class DiagramEntitySet<E extends DiagramEntity> implements Iterab
      * @public
      * @returns An array containing the entities of this set that meet the given criteria.
      */
-    filter(): E[];
+    filter(predicate: (value: E, index: number, array: E[]) => unknown): E[];
     /**
      * Gets an entity of this set matching specific criteria.
      * @public
      * @returns An entity of this set.
      */
-    find(): E | undefined;
+    find(predicate: (value: E, index: number, array: E[]) => unknown): E | undefined;
     /**
      * Gets an entity from this set.
      * @public

package/lib/diagram-editor/diagram/diagram-field.d.ts

@@ -105,14 +105,25 @@ export declare class DiagramField extends DiagramElement {
     constructor(model: DiagramModel, rootElement: DiagramNode | DiagramSection | DiagramPort | undefined, coords: Point, width: number, height: number, fontSize: number, fontFamily: string | null, color: string, selectedColor: string, horizontalAlign: HorizontalAlign, verticalAlign: VerticalAlign, text: string, editable: boolean, fit: boolean, id?: string);
     select(): d3.Selection<SVGGElement, unknown, null, unknown> | undefined;
     updateInView(): void;
+    /**
+     * Change the coordinates of this field to the given coordinates.
+     * @public
+     * @param coords A point in the diagram.
+     */
     move(coords: Point): void;
     getPriority(): number;
 }
 export declare class DiagramFieldSet extends DiagramEntitySet<DiagramField> {
     private model;
+    /**
+     * Instance a set of fields for the given model. This method is used internally.
+     * @private
+     */
     constructor(model: DiagramModel);
+    /**
+     * Instance a new field and add it to this set. This method is normally called when instancing an element with a field and it is rarely called by itself.
+     * @private
+     */
     new(rootElement: DiagramNode | DiagramSection | DiagramPort | undefined, coords: Point, fontSize: number, fontFamily: string | null, color: string, selectedColor: string, width: number, height: number, horizontalAlign: HorizontalAlign, verticalAlign: VerticalAlign, text: string, editable: boolean, fit: boolean, id?: string | undefined): DiagramField;
     remove(id: string): void;
-    filter(threshold?: number): DiagramField[];
-    find(threshold?: number): DiagramField | undefined;
 }

package/lib/diagram-editor/diagram/diagram-model.d.ts

@@ -7,6 +7,7 @@ import { Property, ValueSet } from './diagram-property';
 import { DiagramSectionSet } from './diagram-section';
 /**
  * Stores the data of a diagram.
+ * Represents the state of the diagram.
  * @public
  */
 export declare class DiagramModel {
@@ -80,6 +81,11 @@ export declare class DiagramModel {
      * @public
      */
     valueSet: ValueSet;
+    /**
+     * The last-seen logical clock value, used to generate CollabTimestamps.
+     * @public
+     */
+    logicalClock: number;
     constructor(canvas: Canvas | undefined, id: string | undefined, name: string, description: string | undefined, type: string, properties?: Property[]);
     /**
      * Deletes everything in this diagram.