microboard-temp 0.1.1 → 0.1.2

package/dist/types/Board.d.ts

@@ -0,0 +1,126 @@
+import { BoardOps, ItemsIndexRecord } from 'BoardOperations';
+import { Camera } from 'Camera';
+import { Events, Operation } from 'Events';
+import { SyncBoardEvent } from 'Events/Events';
+import { Item, ItemData, FrameData, Matrix, Mbr } from 'Items';
+import { AINode } from 'Items/AINode';
+import { DrawingContext } from 'Items/DrawingContext';
+import { Group } from 'Items/Group';
+import { ImageItem } from 'Items/Image';
+import { Keyboard } from 'Keyboard';
+import { Pointer } from 'Pointer';
+import { Presence } from 'Presence/Presence';
+import { SpatialIndex } from 'SpatialIndex';
+import { Subject } from 'Subject';
+import { Tools } from 'Tools';
+import { ItemsMap } from 'Validators';
+export type InterfaceType = 'edit' | 'view' | 'loading';
+export declare class Board {
+    private boardId;
+    private accessKey?;
+    saveEditingFile?: (() => Promise<void>) | undefined;
+    events: Events;
+    private isBoardMenuOpen;
+    readonly selection: Selection;
+    readonly tools: Tools;
+    readonly pointer: Pointer;
+    aiGeneratingOnItem: string | undefined;
+    aiImagePlaceholder: ImageItem | undefined;
+    aiImageConnectorID: string | undefined;
+    readonly camera: Camera;
+    readonly presence: Presence;
+    index: SpatialIndex;
+    items: import("SpatialIndex").Items;
+    readonly keyboard: Keyboard;
+    private drawingContext;
+    private interfaceType;
+    readonly subject: Subject<void>;
+    private name;
+    private isOpen;
+    resolveConnecting: () => void;
+    connecting: Promise<void>;
+    constructor(boardId?: string, accessKey?: string | undefined, saveEditingFile?: (() => Promise<void>) | undefined);
+    /**
+     * Disconnects from the connection and sets the board mode to "loading"
+     */
+    disconnect(): void;
+    getNewItemId(): string;
+    emit(operation: BoardOps): void;
+    getBoardId(): string;
+    getAccessKey(): string | undefined;
+    setBoardId(boardId: string): void;
+    getDrawingContext(): DrawingContext | null;
+    setDrawingContext(context: DrawingContext): void;
+    apply(op: Operation): void;
+    private applyBoardOperation;
+    private applyAddItems;
+    private applyAddLockedGroupOperation;
+    private applyRemoveOperation;
+    private applyRemoveLockedGroupOperation;
+    private applyItemOperation;
+    private findItemAndApply;
+    /** Nest item to the frame which is seen on the screen and covers the most volume of the item
+     */
+    handleNesting(items: Item | Item[]): void;
+    createItem(id: string, data: ItemData): Item;
+    parseHTML(el: HTMLElement): ItemData | {
+        data: FrameData;
+        childrenMap: {
+            [id: string]: ItemData;
+        };
+    };
+    add<T extends Item>(item: T, timeStamp?: number): T;
+    addLockedGroup(item: Group): Item;
+    remove(item: Item, withConnectors?: boolean): void;
+    removeLockedGroup(item: Group): void;
+    getByZIndex(index: number): Item;
+    getZIndex(item: Item): number;
+    getLastZIndex(): number;
+    moveManyToZIndex(items: ItemsIndexRecord): void;
+    moveToZIndex(item: Item, zIndex: number): void;
+    moveSecondBeforeFirst(first: Item, second: Item): void;
+    moveSecondAfterFirst(first: Item, second: Item): void;
+    bringToFront(items: Item | Item[]): void;
+    sendToBack(items: Item | Item[]): void;
+    copy(): ItemData[];
+    serialize(): ItemData[];
+    serializeHTML(): string;
+    /** @returns ids of added items */
+    deserializeHTMLAndEmit(stringedHTML: string): string[];
+    deserializeHTML(stringedHTML: string): void;
+    deserialize(snapshot: BoardSnapshot): void;
+    getCameraSnapshot(): Matrix | undefined;
+    getItemsMbr(): Mbr;
+    getSnapshotFromCache(): Promise<BoardSnapshot | undefined>;
+    private saveSnapshotToIndexedDB;
+    private removeSnapshotFromIndexedDB;
+    saveSnapshot(snapshot?: BoardSnapshot): void;
+    getSnapshot(): BoardSnapshot;
+    paste(itemsMap: ItemsMap, select?: boolean, shouldUpdateMediaUsage?: boolean): Promise<void>;
+    removeVoidComments(): void;
+    getParentAINodes(node: AINode): AINode[];
+    setIsBoardMenuOpen(isOpen: boolean): void;
+    getIsBoardMenuOpen(): boolean;
+    duplicate(itemsMap: {
+        [key: string]: ItemData;
+    }): void;
+    applyPasteOperation(itemsMap: {
+        [key: string]: ItemData;
+    }): void;
+    isOnBoard(item: Item): boolean;
+    getMaxFrameSerial(): number;
+    setInterfaceType(interfaceType: InterfaceType): void;
+    getInterfaceType(): InterfaceType;
+    setName(name: string | undefined): void;
+    getName(): string | undefined;
+    setIsOpen(isOpen: boolean): void;
+    getIsOpen(): boolean;
+    cleanup(): void;
+}
+export interface BoardSnapshot {
+    items: (ItemData & {
+        id: string;
+    })[];
+    events: SyncBoardEvent[];
+    lastIndex: number;
+}

package/dist/types/BoardCommand.d.ts

@@ -0,0 +1,13 @@
+import { Command } from './Events';
+import { BoardOps } from './BoardOperations';
+import { Board } from 'Board';
+export declare class BoardCommand implements Command {
+    private board;
+    private operation;
+    private reverse;
+    constructor(board: Board, operation: BoardOps);
+    apply(): void;
+    revert(): void;
+    getReverse(): BoardOps | BoardOps[];
+    merge(op: BoardOps): this;
+}

package/dist/types/BoardOperations.d.ts

@@ -0,0 +1,70 @@
+import { ItemData } from "./Items";
+import { GroupData } from "./Items/Group";
+export type ItemsIndexRecord = Record<string, number>;
+interface BoardOp {
+    class: "Board";
+}
+interface SingleItemBoardOp extends BoardOp {
+    item: string;
+}
+interface MultiItemBoardOp extends BoardOp {
+    item: string[];
+}
+type DataMap = {
+    [key: string]: ItemData;
+};
+interface ItemMapBoardOp extends BoardOp {
+    itemsMap: DataMap;
+}
+interface ItemCreation {
+    method: "add";
+    timeStamp?: number;
+}
+export type CreateItem = ItemCreation & ((SingleItemBoardOp & {
+    data: ItemData;
+}) | (MultiItemBoardOp & {
+    data: DataMap;
+}));
+export interface CreateLockedGroupItem extends SingleItemBoardOp {
+    method: "addLockedGroup";
+    data: GroupData;
+}
+export interface RemoveItem extends MultiItemBoardOp {
+    method: "remove";
+}
+export interface RemoveLockedGroup extends MultiItemBoardOp {
+    method: "removeLockedGroup";
+}
+interface MoveToZIndex extends SingleItemBoardOp {
+    method: "moveToZIndex";
+    zIndex: number;
+}
+interface MoveManyToZIndex extends BoardOp {
+    method: "moveManyToZIndex";
+    item: ItemsIndexRecord;
+}
+interface MoveSecondBeforeFirst extends SingleItemBoardOp {
+    method: "moveSecondBeforeFirst";
+    secondItem: string;
+}
+interface MoveSecondAfterFirst extends SingleItemBoardOp {
+    method: "moveSecondAfterFirst";
+    secondItem: string;
+}
+interface BringToFront extends MultiItemBoardOp {
+    method: "bringToFront";
+    prevZIndex: ItemsIndexRecord;
+}
+interface SendToBack extends MultiItemBoardOp {
+    method: "sendToBack";
+    prevZIndex: ItemsIndexRecord;
+}
+interface Paste extends ItemMapBoardOp {
+    method: "paste";
+    select: boolean;
+}
+interface Duplicate extends ItemMapBoardOp {
+    method: "duplicate";
+}
+export type BoardOps = CreateItem | CreateLockedGroupItem | RemoveItem | RemoveLockedGroup | MoveToZIndex | MoveManyToZIndex | MoveSecondBeforeFirst | MoveSecondAfterFirst | BringToFront | SendToBack | Paste | Duplicate;
+export {};

package/dist/types/Camera/Camera.d.ts

@@ -0,0 +1,88 @@
+import { Matrix, Point, Mbr, Item } from 'Items';
+import { Keyboard } from 'Keyboard';
+import { Pointer } from 'Pointer';
+import { Subject } from 'Subject';
+export declare class Camera {
+    private boardPointer;
+    subject: Subject<Camera>;
+    resizeSubject: Subject<Camera>;
+    scaleLevels: readonly [10, 9, 8, 7, 6, 5, 4, 3, 2.5, 2, 1.5, 1.25, 1, 0.75, 0.5, 0.33, 0.2, 0.15, 0.1, 0.05, 0.03, 0.02, 0.01];
+    maxScale: number;
+    minScale: number;
+    matrix: Matrix;
+    readonly pointer: Point;
+    window: {
+        width: number;
+        height: number;
+        dpi: number;
+        getMbr: () => Mbr;
+    };
+    private touchEvents;
+    private previousDistance;
+    private previousPositions;
+    boardId: string;
+    private observableItem;
+    private throttledZoom;
+    private isAnimating;
+    constructor(boardPointer?: Pointer);
+    getMbr(): Mbr;
+    getNotInverseMbr(): Mbr;
+    getUntransformedMbr(): Mbr;
+    unsubscribeFromItem(): void;
+    subscribeToItem(item: Item): void;
+    private observeItem;
+    private getScaleOneLevelIn;
+    private getScaleOneLevelOut;
+    private limitScale;
+    view(_left: number, _top: number, _scale: number): void;
+    zoomRelativeToPointerBy(scale: number): void;
+    zoomRelativeToPointBy(scale: number, x: number, y: number, duration?: number): void;
+    saveDownEvent(event: PointerEvent): void;
+    getMatrixSnapshot(): Matrix | undefined;
+    saveMatrixSnapshot(): void;
+    setBoardId(id: string): this;
+    applyMatrix(matrix: Matrix): void;
+    /** Returns true if found and used saved snapshot, false otherwise */
+    useSavedSnapshot(optionalMatrix?: Matrix): boolean;
+    updatePositions(): void;
+    updateDistance(): void;
+    removeDownEvent(event: PointerEvent): void;
+    updateDownEvent(event: PointerEvent): void;
+    isTwoPointers(): boolean;
+    getPinchCenter(): {
+        x: number;
+        y: number;
+    };
+    isPinch(): boolean;
+    getPinchScale(): number;
+    getPanDelta(): {
+        x: number;
+        y: number;
+    };
+    private calculateDistance;
+    zoomToViewCenter(scale: number): void;
+    zoomInToViewCenter(): void;
+    zoomOutFromViewCenter(): void;
+    addToView(mbr: Mbr, inView: Item[]): void;
+    viewRectangle(mbr: Mbr, offsetInPercent?: number, duration?: number): void;
+    private lerp;
+    private easeOutQuad;
+    zoomToFit(rect: Mbr, offsetInPercent?: number, duration?: number): void;
+    getViewPointer(): {
+        x: number;
+        y: number;
+    };
+    translateTo(x: number, y: number): void;
+    translateBy(x: number, y: number): void;
+    getTranslation(): {
+        x: number;
+        y: number;
+    };
+    getScale(): number;
+    getMatrix(): Matrix;
+    private updateBoardPointer;
+    pointTo(x: number, y: number): void;
+    onWindowResize(): void;
+    smoothTranslateTo(keyboard: Keyboard, shouldTranslate: boolean): void;
+}
+export declare function throttle<T extends (...args: any[]) => unknown>(func: T, delay: number): (...args: Parameters<T>) => void;

package/dist/types/Camera/index.d.ts

@@ -0,0 +1 @@
+export { Camera } from "./Camera";

package/dist/types/Events/Command.d.ts

@@ -0,0 +1,7 @@
+import { Board } from 'Board';
+import { Operation } from './EventsOperations';
+export interface Command {
+    apply(): void;
+    revert(): void;
+}
+export declare function createCommand(board: Board, operation: Operation): Command;

package/dist/types/Events/Events.d.ts

@@ -0,0 +1,93 @@
+import { Connection } from 'App/Connection';
+import { Board } from 'Board';
+import { Subject } from 'Subject';
+import { Command } from './Command';
+import { EventsLog } from './Log';
+import { Operation } from './EventsOperations';
+import { PresenceEventType } from 'Presence/Events';
+export interface BoardEvent {
+    order: number;
+    body: BoardEventBody;
+}
+export interface BoardEventBody {
+    eventId: string;
+    userId: number;
+    boardId: string;
+    operation: Operation;
+}
+export interface BoardEventPack {
+    order: number;
+    body: BoardEventPackBody;
+}
+export interface BoardEventPackBody {
+    eventId: string;
+    userId: number;
+    boardId: string;
+    operations: (Operation & {
+        actualId?: string;
+    })[];
+}
+export interface SyncBoardEvent extends BoardEvent {
+    lastKnownOrder: number;
+    userId: string;
+}
+interface SyncBoardEventPackBody extends BoardEventPackBody {
+    lastKnownOrder: number;
+}
+export interface SyncBoardEventPack extends BoardEventPack {
+    body: SyncBoardEventPackBody;
+}
+export type SyncEvent = SyncBoardEvent | SyncBoardEventPack;
+export declare class Events {
+    subject: Subject<BoardEvent>;
+    log: EventsLog;
+    board: Board;
+    connection: Connection | undefined;
+    private latestEvent;
+    private eventCounter;
+    constructor(board: Board, connection: Connection | undefined, lastIndex: number);
+    /**
+     * Emits an operation event to the board's event system
+     * @param operation The operation to emit
+     * @param command Optional command associated with the operation
+     */
+    emit(operation: Operation, command?: Command): void;
+    /**
+     * Applies an operation and then emits the corresponding event
+     * @param operation The operation to apply and emit
+     */
+    applyAndEmit(operation: Operation): void;
+    /**
+     * Undoes the last operation performed by the current user
+     * @param apply Whether to apply the undo operation (defaults to true)
+     */
+    undo(): void;
+    /**
+     * Redoes a previously undone operation
+     * @param apply Whether to apply the redo operation (defaults to true)
+     */
+    redo(): void;
+    /**
+     * Checks if there's an operation that can be undone by the current user
+     * @returns Whether an undo operation is possible
+     */
+    canUndo(): boolean;
+    /**
+     * Checks if there's an operation that can be redone by the current user
+     * @returns Whether a redo operation is possible
+     */
+    canRedo(): boolean;
+    /**
+     * Publishes a presence event to notify other users about activity on the board
+     * @param event The presence event to publish
+     */
+    sendPresenceEvent(event: PresenceEventType): void;
+    private canUndoEvent;
+    private setLatestUserEvent;
+    private getOpKey;
+    private getUserId;
+    private getNextEventId;
+}
+export declare function createEvents(board: Board, connection: Connection | undefined, // undefined for node or local
+lastIndex: number): Events;
+export {};

package/dist/types/Events/EventsCommand.d.ts

@@ -0,0 +1,13 @@
+import { EventsOperation } from "./EventsOperations";
+import { Command } from "./Command";
+import { Board } from "Board";
+export declare class EventsCommand implements Command {
+    private board;
+    private operation;
+    private reverse;
+    constructor(board: Board, operation: EventsOperation);
+    apply(): void;
+    revert(): void;
+    getReverse(): EventsOperation;
+}
+export declare const EventsOperationHandlers: Record<string, (board: Board, operation: EventsOperation) => void | false>;

package/dist/types/Events/EventsOperations.d.ts

@@ -0,0 +1,31 @@
+import { TransformationOperation } from "../Items";
+import { ShapeOperation } from "../Items/Shape";
+import { RichTextOperation } from "../Items";
+import { BoardOps } from "../BoardOperations";
+import { ConnectorOperation } from "../Items/Connector";
+import { DrawingOperation } from "Items/Drawing/DrawingOperation";
+import { StickerOperation } from "../Items/Sticker/StickerOperation";
+import { FrameOperation } from "../Items/Frame";
+import { LinkToOperation } from "../Items/LinkTo/LinkToOperation";
+import { PlaceholderOperation } from "Items/Placeholder/PlaceholderOperation";
+import { GroupOperation } from "Items/Group/GroupOperation";
+import { CommentOperation } from "../Items/Comment";
+import { ImageOperation } from "Items/Image";
+import { VideoOperation } from "Items/Video/VideoOperation";
+import { AudioOperation } from "Items/Audio/AudioOperation";
+interface Undo {
+    class: "Events";
+    method: "undo";
+    eventId: string;
+}
+interface Redo {
+    class: "Events";
+    method: "redo";
+    eventId: string;
+}
+export type EventsOperation = Undo | Redo;
+export type ItemOperation = LinkToOperation | TransformationOperation | ShapeOperation | StickerOperation | RichTextOperation | ConnectorOperation | DrawingOperation | FrameOperation | PlaceholderOperation | GroupOperation | CommentOperation | ImageOperation | VideoOperation | AudioOperation;
+export type UndoableOperation = BoardOps | ItemOperation;
+export type Operation = UndoableOperation | EventsOperation;
+export type MethodType = Operation["method"];
+export {};

package/dist/types/Events/Log/EventsLog.d.ts

@@ -0,0 +1,87 @@
+import { Board, BoardSnapshot } from 'Board';
+import { BoardEvent, BoardEventPack, SyncBoardEvent, SyncEvent } from '../Events';
+import { EventsList } from './createEventsList';
+import { Command } from 'Plugin';
+export interface HistoryRecord {
+    event: BoardEvent;
+    command: Command;
+}
+export interface RawHistoryRecords {
+    confirmedRecords: HistoryRecord[];
+    recordsToSend: HistoryRecord[];
+    newRecords: HistoryRecord[];
+}
+/**
+ * Manages the board's event log, handling event recording, synchronization, and history management
+ */
+export declare class EventsLog {
+    list: EventsList;
+    private board;
+    currentSequenceNumber: number;
+    pendingEvent: {
+        event: BoardEventPack;
+        sequenceNumber: number;
+        lastSentTime: number;
+    } | null;
+    firstSentTime: number | null;
+    publishIntervalTimer: NodeJS.Timeout | null;
+    resendIntervalTimer: NodeJS.Timeout | null;
+    saveFileTimeout: NodeJS.Timeout | null;
+    constructor(board: Board);
+    /**
+     * Inserts new events into the events log, handling transformations and merging
+     */
+    insertEventsFromOtherConnections(events: SyncEvent | SyncEvent[]): void;
+    /**
+     * Adds a new record to the events log
+     */
+    insertNewLocalEventRecordAfterEmit(record: HistoryRecord): HistoryRecord;
+    /**
+     * Confirms events that have been sent, updating their status in the log
+     * Note: Implementation treats the parameter as BoardEventPack
+     */
+    confirmSentLocalEvent(event: BoardEvent | BoardEventPack): void;
+    /**
+     * Retrieves unordered records (records to send and new records)
+     */
+    getUnorderedRecords(): HistoryRecord[];
+    /**
+     * Finds the most recent undoable record for a specific user
+     */
+    getUndoRecord(userId: number): HistoryRecord | null;
+    /**
+     * Finds the most recent redoable record for a specific user
+     */
+    getRedoRecord(userId: number): HistoryRecord | null;
+    /**
+     * Retrieves a specific record by its event ID
+     */
+    getRecordById(id: string): HistoryRecord | undefined;
+    /**
+     * Deserializes events and adds them to the confirmed records
+     * Note: Implementation uses SyncBoardEvent[] rather than BoardEvent[]
+     */
+    deserialize(events: SyncBoardEvent[]): void;
+    /**
+     * Deserializes events, applies them to the board, and adds them to confirmed records
+     * Note: Implementation uses SyncBoardEvent[] rather than BoardEvent[]
+     */
+    deserializeAndApply(events: SyncBoardEvent[]): void;
+    /**
+     * Creates a snapshot of the current board state, including events and items
+     */
+    getSnapshot(): BoardSnapshot;
+    /**
+     * Retrieves unpublished events ready to be sent
+     */
+    getUnpublishedEvent(): BoardEventPack | null;
+    /**
+     * Gets the latest event order, considering both confirmed events and snapshot index
+     */
+    getLastIndex(): number;
+    /**
+     * Retrieves the most recently confirmed event
+     */
+    getLastConfirmed(): BoardEvent | null;
+}
+export declare function createEventsLog(board: Board): EventsLog;

package/dist/types/Events/Log/createEventsList.d.ts

@@ -0,0 +1,36 @@
+import { Command } from "Plugin";
+import { BoardEvent } from "../Events";
+import { SyncLog, SyncLogSubject } from "../SyncLog";
+import { HistoryRecord } from "./EventsLog";
+export type FilterPredicate = (value: HistoryRecord, index: number, array: HistoryRecord[]) => boolean;
+export interface EventsList {
+    addConfirmedRecords(records: HistoryRecord[]): void;
+    addNewRecords(records: HistoryRecord[]): void;
+    confirmSentRecords(records: BoardEvent[]): void;
+    getConfirmedRecords(): HistoryRecord[];
+    getRecordsToSend(): HistoryRecord[];
+    getNewRecords(): HistoryRecord[];
+    getAllRecords(): HistoryRecord[];
+    prepareRecordsToSend(): HistoryRecord[];
+    forwardIterable(): Iterable<HistoryRecord>;
+    backwardIterable(): Iterable<HistoryRecord>;
+    /** Reverts all unconfirmed events (records to send and new records) in reverse order
+     * @argument filter - function that filters records to revert*/
+    revertUnconfirmed(predicate?: FilterPredicate): void;
+    /** Applies all unconfirmed events, transforming them if necessary
+     * @argument filter - function that filters records to apply*/
+    applyUnconfirmed(predicate?: FilterPredicate): void;
+    justConfirmed: HistoryRecord[];
+    getSyncLog(): SyncLog;
+    syncLogSubject: SyncLogSubject;
+    clear(): void;
+    clearConfirmedRecords(): void;
+    removeUnconfirmedEventsByItems(itemIds: string[]): void;
+    isAllEventsConfirmed(): boolean;
+    /**
+     * Sets the last known index for snapshots
+     */
+    setSnapshotLastIndex(index: number): void;
+    getSnapshotLastIndex(): number;
+}
+export declare function createEventsList(createCommand: (BoardOps: any) => Command): EventsList;

package/dist/types/Events/Log/deserializeAndApplyToList.d.ts

@@ -0,0 +1,4 @@
+import { Board } from "Board";
+import { SyncBoardEvent } from "../Events";
+import { EventsList } from "./createEventsList";
+export declare function deserializeAndApplyToList(events: SyncBoardEvent[], list: EventsList, board: Board): void;

package/dist/types/Events/Log/deserializeIntoList.d.ts

@@ -0,0 +1,4 @@
+import { Board } from "Board";
+import { SyncBoardEvent } from "../Events";
+import { EventsList } from "./createEventsList";
+export declare function deserializeIntoList(events: SyncBoardEvent[], list: EventsList, board: Board): void;

package/dist/types/Events/Log/expandEvents.d.ts

@@ -0,0 +1,2 @@
+import { SyncEvent, SyncBoardEvent } from "../Events";
+export declare function expandEvents(events: SyncEvent[]): SyncBoardEvent[];

package/dist/types/Events/Log/getLastIndexFromList.d.ts

@@ -0,0 +1,2 @@
+import { EventsList } from "./createEventsList";
+export declare function getLastIndexFromList(list: EventsList): number;

package/dist/types/Events/Log/getRecordByIdFromList.d.ts

@@ -0,0 +1,3 @@
+import { EventsList } from "./createEventsList";
+import { HistoryRecord } from "./EventsLog";
+export declare function getRecordByIdFromList(id: string, list: EventsList): HistoryRecord | undefined;

package/dist/types/Events/Log/getRedoRecordFromList.d.ts

@@ -0,0 +1,3 @@
+import { EventsList } from "./createEventsList";
+import { HistoryRecord } from "./EventsLog";
+export declare function getRedoRecordFromList(userId: number, list: EventsList): HistoryRecord | null;

package/dist/types/Events/Log/getSnapshotFromList.d.ts

@@ -0,0 +1,2 @@
+import { BoardSnapshot } from 'Board';
+export declare function getSnapshotFromList(list: any, board: any): BoardSnapshot;

package/dist/types/Events/Log/getUndoRecordFromList.d.ts

@@ -0,0 +1,3 @@
+import { EventsList } from "./createEventsList";
+import { HistoryRecord } from "./EventsLog";
+export declare function getUndoRecordFromList(userId: number, list: EventsList): HistoryRecord | null;

package/dist/types/Events/Log/getUnpublishedEventFromList.d.ts

@@ -0,0 +1,7 @@
+import { BoardEventPack, BoardEvent } from "../Events";
+import { Operation } from "../EventsOperations";
+import { EventsList } from "./createEventsList";
+export declare function getUnpublishedEventFromList(list: EventsList): BoardEventPack | null;
+export declare function combineOperationsIntoPack(baseEvent: BoardEvent, operations: (Operation & {
+    actualId: string;
+})[]): BoardEventPack;

package/dist/types/Events/Log/index.d.ts

@@ -0,0 +1 @@
+export * from "./EventsLog";

package/dist/types/Events/Log/insertEventsFromOtherConnectionsIntoList.d.ts

@@ -0,0 +1,13 @@
+import { Board } from "Board";
+import { SyncEvent } from "../Events";
+import { EventsList } from "./createEventsList";
+/**
+ * Inserts events from other connections into the events list. This function is
+ * a core part of the Operational Transformation (OT) conflict resolution system
+ * and it handles synchronization of events across multiple connections.
+ *
+ * @param value - A single SyncEvent or an array of SyncEvents to be inserted
+ * @param list - The EventsList to insert the events into
+ * @param board - The Board instance that the events will be applied to
+ */
+export declare function insertEventsFromOtherConnectionsIntoList(value: SyncEvent | SyncEvent[], list: EventsList, board: Board): void;

package/dist/types/Events/Log/shouldSkipEvent.d.ts

@@ -0,0 +1,2 @@
+import { HistoryRecord } from "./EventsLog";
+export declare function shouldSkipEvent(record: HistoryRecord, userId: number): boolean;

package/dist/types/Events/Merge.d.ts

@@ -0,0 +1,3 @@
+import { Operation } from "./EventsOperations";
+export declare function canNotBeMerged(op: Operation): boolean;
+export declare function mergeOperations(opA: Operation, opB: Operation): Operation | undefined;

package/dist/types/Events/MessageRouter/createMessageRouter.d.ts

@@ -0,0 +1,9 @@
+import { EventsMsg } from "App/Connection";
+import { Board } from "Board";
+type MessageHandler<T extends EventsMsg = EventsMsg> = (message: T, board: Board) => void;
+export interface MessageRouter {
+    addHandler: <T extends EventsMsg>(type: string, handler: MessageHandler<T>) => void;
+    handleMessage: (message: EventsMsg, board: Board) => void;
+}
+export declare function createMessageRouter(): MessageRouter;
+export {};