@odoo/o-spreadsheet 18.0.55 → 18.0.68

package/dist/types/types/clipboard.d.ts

@@ -0,0 +1,45 @@
+import { SpreadsheetClipboardData } from "../plugins/ui_stateful";
+import { ClipboardCell, HeaderIndex, UID, Zone } from "./misc";
+export declare enum ClipboardMIMEType {
+    PlainText = "text/plain",
+    Html = "text/html"
+}
+export type OSClipboardContent = {
+    [type in ClipboardMIMEType]?: string;
+};
+export type ParsedOSClipboardContent = {
+    text?: string;
+    data?: SpreadsheetClipboardData;
+};
+export interface ClipboardOptions {
+    isCutOperation: boolean;
+    pasteOption?: ClipboardPasteOptions;
+    selectTarget?: boolean;
+}
+export type ClipboardPasteOptions = "onlyFormat" | "asValue";
+export type ClipboardCopyOptions = "copyPaste" | "shiftCells";
+export type ClipboardOperation = "CUT" | "COPY";
+export type ClipboardCellData = {
+    sheetId: UID;
+    zones: Zone[];
+    rowsIndexes: HeaderIndex[];
+    columnsIndexes: HeaderIndex[];
+    clippedZones: Zone[];
+};
+export type ClipboardFigureData = {
+    sheetId: UID;
+    figureId: UID;
+};
+export type ClipboardData = ClipboardCellData | ClipboardFigureData;
+export type ClipboardPasteTarget = {
+    sheetId: UID;
+    zones: Zone[];
+    figureId?: UID;
+};
+export type MinimalClipboardData = {
+    sheetId?: UID;
+    cells?: ClipboardCell[][];
+    zones?: Zone[];
+    figureId?: UID;
+    [key: string]: unknown;
+};

package/dist/types/types/collaborative/revisions.d.ts

@@ -0,0 +1,7 @@
+import { CoreCommand, UID } from "..";
+import { ClientId } from "./session";
+export interface RevisionData {
+    readonly id: UID;
+    readonly clientId: ClientId;
+    readonly commands: readonly CoreCommand[];
+}

package/dist/types/types/collaborative/session.d.ts

@@ -0,0 +1,46 @@
+import { CoreCommand } from "../commands";
+import { HeaderIndex, UID } from "../misc";
+export type ClientId = string;
+export interface Client {
+    id: ClientId;
+    name: string;
+    position?: ClientPosition;
+}
+export interface ClientPosition {
+    sheetId: UID;
+    col: HeaderIndex;
+    row: HeaderIndex;
+}
+export interface RemoteRevisionReceivedEvent {
+    type: "remote-revision-received";
+    commands: readonly CoreCommand[];
+}
+export interface RevisionAcknowledgedEvent {
+    type: "revision-acknowledged";
+    revisionId: UID;
+}
+export interface RevisionUndone {
+    type: "revision-undone";
+    revisionId: UID;
+    commands: readonly CoreCommand[];
+}
+export interface RevisionRedone {
+    type: "revision-redone";
+    revisionId: UID;
+    commands: readonly CoreCommand[];
+}
+export interface CollaborativeEventReceived {
+    type: "collaborative-event-received";
+}
+export interface UnexpectedRevisionIdEvent {
+    type: "unexpected-revision-id";
+}
+export interface NewLocalStateUpdateEvent {
+    type: "new-local-state-update";
+    id: UID;
+}
+export interface SnapshotEvent {
+    type: "snapshot";
+}
+export type CollaborativeEvent = NewLocalStateUpdateEvent | UnexpectedRevisionIdEvent | RemoteRevisionReceivedEvent | RevisionAcknowledgedEvent | RevisionUndone | RevisionRedone | SnapshotEvent | CollaborativeEventReceived;
+export type CollaborativeEventTypes = CollaborativeEvent["type"];

package/dist/types/types/collaborative/transport_service.d.ts

@@ -0,0 +1,91 @@
+import { CoreCommand } from "../commands";
+import { UID } from "../misc";
+import { WorkbookData } from "../workbook_data";
+import { Client, ClientId } from "./session";
+interface AbstractMessage {
+    version: number;
+}
+export interface RemoteRevisionMessage extends AbstractMessage {
+    type: "REMOTE_REVISION";
+    clientId: ClientId;
+    commands: readonly CoreCommand[];
+    nextRevisionId: UID;
+    serverRevisionId: UID;
+    timestamp?: number;
+}
+export interface RevisionUndoneMessage extends AbstractMessage {
+    type: "REVISION_UNDONE";
+    undoneRevisionId: UID;
+    nextRevisionId: UID;
+    serverRevisionId: UID;
+}
+export interface RevisionRedoneMessage extends AbstractMessage {
+    type: "REVISION_REDONE";
+    redoneRevisionId: UID;
+    nextRevisionId: UID;
+    serverRevisionId: UID;
+}
+export interface ClientJoinedMessage extends AbstractMessage {
+    type: "CLIENT_JOINED";
+    client: Required<Client>;
+}
+export interface ClientLeftMessage extends AbstractMessage {
+    type: "CLIENT_LEFT";
+    clientId: ClientId;
+}
+export interface ClientMovedMessage extends AbstractMessage {
+    type: "CLIENT_MOVED";
+    client: Required<Client>;
+}
+/**
+ * Send a snapshot of the spreadsheet to the collaborative server
+ */
+interface SnapshotMessage extends AbstractMessage {
+    type: "SNAPSHOT";
+    data: WorkbookData;
+    serverRevisionId: UID;
+    nextRevisionId: UID;
+}
+/**
+ * Notify all clients that the server has a new snapshot of the
+ * spreadsheet and that the previous history may be lost.
+ */
+export interface SnapshotCreatedMessage extends AbstractMessage {
+    type: "SNAPSHOT_CREATED";
+    serverRevisionId: UID;
+    nextRevisionId: UID;
+}
+export type CollaborationMessage = RevisionUndoneMessage | RevisionRedoneMessage | RemoteRevisionMessage | SnapshotMessage | SnapshotCreatedMessage | ClientMovedMessage | ClientJoinedMessage | ClientLeftMessage;
+export type StateUpdateMessage = Extract<CollaborationMessage, {
+    nextRevisionId: UID;
+}>;
+export type NewMessageCallback<T = any> = (message: T) => void;
+/**
+ * The transport service allows to communicate between multiple clients.
+ * A client can send any message to others.
+ * The service will handle all networking details internally.
+ */
+export interface TransportService<T = any> {
+    /**
+     * Send a message to all clients
+     */
+    sendMessage: (message: T) => Promise<void>;
+    /**
+     * Register a callback function which will be called each time
+     * a new message is received.
+     * The new message is given to the callback.
+     *
+     * ```js
+     * transportService.onNewMessage(id, (message) => {
+     *   // ... handle the new message
+     * })
+     * ```
+     * The `id` is used to unregister this callback when the session is closed.
+     */
+    onNewMessage: (id: UID, callback: NewMessageCallback<T>) => void;
+    /**
+     * Unregister a callback linked to the given id
+     */
+    leave: (id: UID) => void;
+}
+export {};