document-drive 1.19.1 → 1.20.1

package/dist/src/utils/graphql.d.ts

@@ -0,0 +1,34 @@
+import { DocumentDriveLocalState, FileNode, FolderNode } from "#drive-document-model/gen/types";
+import { DocumentModelModule, DocumentModelState, OperationFromDocument, PHDocument } from "document-model";
+import { BuildSchemaOptions, GraphQLError, ParseOptions } from "graphql";
+import request from "graphql-request";
+export { gql } from "graphql-request";
+export type GraphQLResult<T> = {
+    [K in keyof T]: T[K] | null;
+} & {
+    errors?: GraphQLError[];
+};
+export declare function requestGraphql<T>(...args: Parameters<typeof request>): Promise<GraphQLResult<T>>;
+export type DriveInfo = {
+    id: string;
+    name: string;
+    slug: string;
+    icon?: string;
+    meta?: {
+        preferredEditor?: string;
+    };
+};
+export declare function generateDocumentStateQueryFields(documentModelState: DocumentModelState, options?: BuildSchemaOptions & ParseOptions): string;
+export declare function requestPublicDrive(url: string): Promise<DriveInfo>;
+export type DriveState = DriveInfo & Pick<DocumentDriveLocalState, "availableOffline" | "sharingType"> & {
+    nodes: Array<FolderNode | Omit<FileNode, "synchronizationUnits">>;
+};
+export type DocumentGraphQLResult<TDocument extends PHDocument> = TDocument & {
+    operations: (OperationFromDocument<TDocument> & {
+        inputText: string;
+    })[];
+};
+export declare function fetchDocument<TDocument extends PHDocument>(url: string, documentId: string, documentModelModule: DocumentModelModule<TDocument>): Promise<GraphQLResult<{
+    document: DocumentGraphQLResult<TDocument>;
+}>>;
+//# sourceMappingURL=graphql.d.ts.map

package/dist/src/utils/graphql.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphql.d.ts","sourceRoot":"","sources":["../../../src/utils/graphql.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,QAAQ,EACR,UAAU,EACX,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EACL,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,UAAU,EACX,MAAM,gBAAgB,CAAC;AACxB,OAAO,EACL,kBAAkB,EAClB,YAAY,EAOZ,YAAY,EAEb,MAAM,SAAS,CAAC;AACjB,OAAO,OAA+B,MAAM,iBAAiB,CAAC;AAG9D,OAAO,EAAE,GAAG,EAAE,MAAM,iBAAiB,CAAC;AAMtC,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI;CAAE,GAAG;IAC/D,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;CACzB,CAAC;AAGF,wBAAsB,cAAc,CAAC,CAAC,EACpC,GAAG,IAAI,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,GAClC,OAAO,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAc3B;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE;QACL,eAAe,CAAC,EAAE,MAAM,CAAC;KAC1B,CAAC;CACH,CAAC;AAkDF,wBAAgB,gCAAgC,CAC9C,kBAAkB,EAAE,kBAAkB,EACtC,OAAO,CAAC,EAAE,kBAAkB,GAAG,YAAY,GAC1C,MAAM,CAqBR;AAED,wBAAsB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC,CA6BxE;AAED,MAAM,MAAM,UAAU,GAAG,SAAS,GAChC,IAAI,CAAC,uBAAuB,EAAE,kBAAkB,GAAG,aAAa,CAAC,GAAG;IAClE,KAAK,EAAE,KAAK,CAAC,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,sBAAsB,CAAC,CAAC,CAAC;CACnE,CAAC;AAEJ,MAAM,MAAM,qBAAqB,CAAC,SAAS,SAAS,UAAU,IAAI,SAAS,GAAG;IAC5E,UAAU,EAAE,CAAC,qBAAqB,CAAC,SAAS,CAAC,GAAG;QAC9C,SAAS,EAAE,MAAM,CAAC;KACnB,CAAC,EAAE,CAAC;CACN,CAAC;AAEF,wBAAsB,aAAa,CAAC,SAAS,SAAS,UAAU,EAC9D,GAAG,EAAE,MAAM,EACX,UAAU,EAAE,MAAM,EAClB,mBAAmB,EAAE,mBAAmB,CAAC,SAAS,CAAC,GAClD,OAAO,CACR,aAAa,CAAC;IACZ,QAAQ,EAAE,qBAAqB,CAAC,SAAS,CAAC,CAAC;CAC5C,CAAC,CACH,CA0FA"}

package/dist/src/utils/graphql.js

@@ -0,0 +1,183 @@
+import { pascalCase } from "change-case";
+import { GraphQLError, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLUnionType, buildSchema, } from "graphql";
+import { GraphQLClient, gql } from "graphql-request";
+import { logger } from "./logger.js";
+export { gql } from "graphql-request";
+// replaces fetch so it can be used in Node and Browser envs
+export async function requestGraphql(...args) {
+    const [url, ...requestArgs] = args;
+    const client = new GraphQLClient(url, { fetch });
+    const { errors, ...response } = await client.request(...requestArgs);
+    const result = { ...response };
+    if (errors?.length) {
+        result.errors = errors.map(({ message, ...options }) => new GraphQLError(message, options));
+    }
+    return result;
+}
+function getFields(type) {
+    if (type instanceof GraphQLObjectType) {
+        return Object.entries(type.getFields())
+            .map(([fieldName, field]) => {
+            const fieldType = field.type instanceof GraphQLNonNull ? field.type.ofType : field.type;
+            if (fieldType instanceof GraphQLObjectType ||
+                fieldType instanceof GraphQLUnionType) {
+                return `${fieldName} { ${getFields(fieldType)} }`;
+            }
+            if (fieldType instanceof GraphQLList) {
+                const listItemType = fieldType.ofType instanceof GraphQLNonNull
+                    ? fieldType.ofType.ofType
+                    : fieldType.ofType;
+                if (listItemType instanceof GraphQLScalarType) {
+                    return fieldName;
+                }
+                else if (listItemType instanceof GraphQLObjectType ||
+                    listItemType instanceof GraphQLUnionType) {
+                    return `${fieldName} { ${getFields(listItemType)} }`;
+                }
+                else {
+                    throw new Error(`List item type ${listItemType.toString()} is not handled`);
+                }
+            }
+            return fieldName;
+        })
+            .join(" ");
+    }
+    else if (type instanceof GraphQLUnionType) {
+        return type
+            .getTypes()
+            .map((unionType) => {
+            return `... on ${unionType.name} { ${getFields(unionType)} }`;
+        })
+            .join(" ");
+    }
+    return "";
+}
+export function generateDocumentStateQueryFields(documentModelState, options) {
+    const name = pascalCase(documentModelState.name);
+    const spec = documentModelState.specifications.at(-1);
+    if (!spec) {
+        throw new Error("No document model specification found");
+    }
+    const source = `${spec.state.global.schema} type Query { ${name}: ${name}State }`;
+    const schema = buildSchema(source, options);
+    const queryType = schema.getQueryType();
+    if (!queryType) {
+        throw new Error("No query type found");
+    }
+    const fields = queryType.getFields();
+    const stateQuery = fields[name];
+    if (!stateQuery) {
+        throw new Error("No state query found");
+    }
+    const queryFields = getFields(stateQuery.type);
+    return queryFields;
+}
+export async function requestPublicDrive(url) {
+    let drive;
+    try {
+        const result = await requestGraphql(url, gql `
+        query getDrive {
+          drive {
+            id
+            name
+            icon
+            slug
+            meta {
+              preferredEditor
+            }
+          }
+        }
+      `);
+        if (result.errors?.length || !result.drive) {
+            throw result.errors?.at(0) ?? new Error("Drive not found");
+        }
+        drive = result.drive;
+    }
+    catch (e) {
+        logger.error(e);
+        throw new Error("Couldn't find drive info");
+    }
+    return drive;
+}
+export async function fetchDocument(url, documentId, documentModelModule) {
+    const { documentModel, utils } = documentModelModule;
+    const stateFields = generateDocumentStateQueryFields(documentModel);
+    const name = pascalCase(documentModel.name);
+    const result = await requestGraphql(url, gql `
+            query ($id: String!) {
+                document(id: $id) {
+                    id
+                    name
+                    created
+                    documentType
+                    lastModified
+                    revision
+                    operations {
+                        id
+                        error
+                        hash
+                        index
+                        skip
+                        timestamp
+                        type
+                        inputText
+                        context {
+                            signer {
+                                user {
+                                    address
+                                    networkId
+                                    chainId
+                                }
+                                app {
+                                    name
+                                    key
+                                }
+                                signatures
+                            }
+                        }
+                    }
+                    ... on ${name} {
+                        state {
+                            ${stateFields}
+                        }
+                        initialState {
+                            ${stateFields}
+                        }
+                    }
+                }
+            }
+        `, { id: documentId });
+    const document = result.document
+        ? {
+            ...result.document,
+            revision: {
+                global: result.document.revision.global,
+                local: 0,
+            },
+            state: result.document.state,
+            operations: {
+                global: result.document.operations.map(({ inputText, ...o }) => ({
+                    ...o,
+                    error: o.error ?? undefined,
+                    scope: "global",
+                    input: JSON.parse(inputText),
+                })),
+                local: [],
+            },
+            attachments: {},
+            initialState: utils.createExtendedState({
+                // TODO: getDocument should return all the initial state fields
+                created: result.document.created,
+                lastModified: result.document.created,
+                state: utils.createState({
+                    global: result.document.initialState.state.global,
+                }),
+            }),
+            clipboard: [],
+        }
+        : null;
+    return {
+        ...result,
+        document,
+    };
+}

package/dist/src/utils/logger.d.ts

@@ -0,0 +1,27 @@
+type LogLevel = "verbose" | "debug" | "info" | "warn" | "error" | "silent";
+export type ILogger = Pick<Console, "log" | "info" | "warn" | "error" | "debug"> & {
+    level: LogLevel | "env";
+    errorHandler: LoggerErrorHandler | undefined;
+    verbose: (message?: any, ...optionalParams: any[]) => void;
+};
+export type LoggerErrorHandler = (...data: any[]) => void;
+export declare class ConsoleLogger implements ILogger {
+    #private;
+    constructor(tags?: string[], errorHandler?: LoggerErrorHandler);
+    get level(): LogLevel | "env";
+    set level(level: LogLevel | "env");
+    get errorHandler(): LoggerErrorHandler | undefined;
+    set errorHandler(handler: LoggerErrorHandler | undefined);
+    log(...data: any[]): void;
+    verbose(...data: any[]): void;
+    debug(...data: any[]): void;
+    info(...data: any[]): void;
+    warn(...data: any[]): void;
+    error(...data: any[]): void;
+}
+export declare const logger: ILogger;
+export declare const setErrorHandler: (handler: LoggerErrorHandler) => void;
+export declare const setLogLevel: (level: LogLevel | "env") => void;
+export declare const childLogger: (tags: string[]) => ConsoleLogger;
+export {};
+//# sourceMappingURL=logger.d.ts.map

package/dist/src/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../src/utils/logger.ts"],"names":[],"mappings":"AAEA,KAAK,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE3E,MAAM,MAAM,OAAO,GAAG,IAAI,CACxB,OAAO,EACP,KAAK,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAC5C,GAAG;IACF,KAAK,EAAE,QAAQ,GAAG,KAAK,CAAC;IACxB,YAAY,EAAE,kBAAkB,GAAG,SAAS,CAAC;IAE7C,OAAO,EAAE,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,GAAG,cAAc,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;CAC5D,CAAC;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,IAAI,CAAC;AAW1D,qBAAa,aAAc,YAAW,OAAO;;gBAK/B,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,YAAY,CAAC,EAAE,kBAAkB;IAa9D,IAAI,KAAK,IAAI,QAAQ,GAAG,KAAK,CAE5B;IAED,IAAI,KAAK,CAAC,KAAK,EAAE,QAAQ,GAAG,KAAK,EAEhC;IAED,IAAI,YAAY,IAAI,kBAAkB,GAAG,SAAS,CAEjD;IAED,IAAI,YAAY,CAAC,OAAO,EAAE,kBAAkB,GAAG,SAAS,EAEvD;IAmBD,GAAG,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAIzB,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAQ7B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAQ3B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAQ1B,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;IAQ1B,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI;CAW5B;AASD,eAAO,MAAM,MAAM,EAAE,OAAwB,CAAC;AAE9C,eAAO,MAAM,eAAe,YAAa,kBAAkB,SAG1D,CAAC;AAEF,eAAO,MAAM,WAAW,UAAW,QAAQ,GAAG,KAAK,SAGlD,CAAC;AAEF,eAAO,MAAM,WAAW,SAAU,MAAM,EAAE,kBAKzC,CAAC"}

package/dist/src/utils/logger.js

@@ -0,0 +1,105 @@
+const LEVELS = {
+    verbose: 1,
+    debug: 2,
+    info: 3,
+    warn: 4,
+    error: 5,
+    silent: 6,
+};
+export class ConsoleLogger {
+    #tags;
+    #levelString = "env";
+    #errorHandler;
+    constructor(tags, errorHandler) {
+        this.#tags = (tags || []).map((tag) => `[${tag}]`);
+        this.#errorHandler = errorHandler;
+        // Bind all methods to the current instance
+        this.log = this.log.bind(this);
+        this.info = this.info.bind(this);
+        this.warn = this.warn.bind(this);
+        this.error = this.error.bind(this);
+        this.debug = this.debug.bind(this);
+        this.verbose = this.verbose.bind(this);
+    }
+    get level() {
+        return this.#levelString;
+    }
+    set level(level) {
+        this.#levelString = level;
+    }
+    get errorHandler() {
+        return this.#errorHandler;
+    }
+    set errorHandler(handler) {
+        this.#errorHandler = handler;
+    }
+    get #levelValue() {
+        if (this.#levelString === "env") {
+            const envLevel = process.env.LOG_LEVEL;
+            if (!envLevel) {
+                return LEVELS.debug;
+            }
+            if (!(envLevel in LEVELS)) {
+                return LEVELS.debug;
+            }
+            return LEVELS[envLevel];
+        }
+        return LEVELS[this.#levelString];
+    }
+    log(...data) {
+        return this.debug(...data);
+    }
+    verbose(...data) {
+        if (this.#levelValue > LEVELS.verbose) {
+            return;
+        }
+        return this.debug(...data);
+    }
+    debug(...data) {
+        if (this.#levelValue > LEVELS.debug) {
+            return;
+        }
+        return console.debug(...[...this.#tags, ...data]);
+    }
+    info(...data) {
+        if (this.#levelValue > LEVELS.info) {
+            return;
+        }
+        return console.info(...[...this.#tags, ...data]);
+    }
+    warn(...data) {
+        if (this.#levelValue > LEVELS.warn) {
+            return;
+        }
+        return console.warn(...[...this.#tags, ...data]);
+    }
+    error(...data) {
+        if (this.#levelValue > LEVELS.error) {
+            return;
+        }
+        if (this.#errorHandler) {
+            this.#errorHandler(...data);
+        }
+        return console.error(...[...this.#tags, ...data]);
+    }
+}
+const loggerInstance = new ConsoleLogger();
+let logLevel = "env";
+let errorHandler;
+loggerInstance.level = logLevel;
+loggerInstance.errorHandler = errorHandler;
+export const logger = loggerInstance;
+export const setErrorHandler = (handler) => {
+    errorHandler = handler;
+    loggerInstance.errorHandler = handler;
+};
+export const setLogLevel = (level) => {
+    logLevel = level;
+    loggerInstance.level = level;
+};
+export const childLogger = (tags) => {
+    const logger = new ConsoleLogger(tags);
+    logger.level = logLevel;
+    logger.errorHandler = errorHandler;
+    return logger;
+};

package/dist/src/utils/migrations.d.ts

@@ -0,0 +1,4 @@
+import { Operation, PHDocument } from "document-model";
+export declare function migrateDocumentOperationSignatures(document: PHDocument): PHDocument | undefined;
+export declare function migrateLegacyOperationSignature<TGlobalState, TLocalState>(operation: Operation): Operation;
+//# sourceMappingURL=migrations.d.ts.map

package/dist/src/utils/migrations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrations.d.ts","sourceRoot":"","sources":["../../../src/utils/migrations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EAET,UAAU,EAEX,MAAM,gBAAgB,CAAC;AAExB,wBAAgB,kCAAkC,CAChD,QAAQ,EAAE,UAAU,GACnB,UAAU,GAAG,SAAS,CAoBxB;AAED,wBAAgB,+BAA+B,CAAC,YAAY,EAAE,WAAW,EACvE,SAAS,EAAE,SAAS,GACnB,SAAS,CAuBX"}

package/dist/src/utils/migrations.js

@@ -0,0 +1,41 @@
+export function migrateDocumentOperationSignatures(document) {
+    let legacy = false;
+    const operations = Object.entries(document.operations).reduce((acc, [key, operations]) => {
+        const scope = key;
+        for (const op of operations) {
+            const newOp = migrateLegacyOperationSignature(op);
+            acc[scope].push(newOp);
+            if (newOp !== op) {
+                legacy = true;
+            }
+        }
+        return acc;
+    }, { global: [], local: [] });
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    return legacy ? { ...document, operations } : document;
+}
+export function migrateLegacyOperationSignature(operation) {
+    if (!operation.context?.signer || operation.context.signer.signatures) {
+        return operation;
+    }
+    const { signer } = operation.context;
+    if ("signature" in signer) {
+        const signature = signer.signature;
+        return {
+            ...operation,
+            context: {
+                ...operation.context,
+                signer: {
+                    user: signer.user,
+                    app: signer.app,
+                    signatures: (signature?.length
+                        ? [signature]
+                        : []),
+                },
+            },
+        };
+    }
+    else {
+        return operation;
+    }
+}

package/dist/src/utils/misc.d.ts

@@ -0,0 +1,11 @@
+import { Operation, OperationFromDocument, OperationsFromDocument, PHDocument } from "document-model";
+import { DocumentDriveDocument } from "#drive-document-model/gen/types";
+import { RunAsap } from "./run-asap.js";
+export declare const runAsap: typeof RunAsap.runAsap;
+export declare const runAsapAsync: typeof RunAsap.runAsapAsync;
+export declare function isDocumentDrive(document: PHDocument): document is DocumentDriveDocument;
+export declare function mergeOperations<TDocument extends PHDocument>(currentOperations: OperationsFromDocument<TDocument>, newOperations: OperationFromDocument<TDocument>[]): OperationsFromDocument<TDocument>;
+export declare function generateUUID(): string;
+export declare function isNoopUpdate(operation: Operation, latestOperation?: Operation): boolean;
+export declare function isBefore(dateA: Date | string, dateB: Date | string): boolean;
+//# sourceMappingURL=misc.d.ts.map

package/dist/src/utils/misc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../../src/utils/misc.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,SAAS,EACT,qBAAqB,EAErB,sBAAsB,EACtB,UAAU,EAEX,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EAAE,qBAAqB,EAAE,MAAM,iCAAiC,CAAC;AAExE,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAExC,eAAO,MAAM,OAAO,wBAAkB,CAAC;AACvC,eAAO,MAAM,YAAY,6BAAuB,CAAC;AAEjD,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,UAAU,GACnB,QAAQ,IAAI,qBAAqB,CAEnC;AAED,wBAAgB,eAAe,CAAC,SAAS,SAAS,UAAU,EAC1D,iBAAiB,EAAE,sBAAsB,CAAC,SAAS,CAAC,EACpD,aAAa,EAAE,qBAAqB,CAAC,SAAS,CAAC,EAAE,GAChD,sBAAsB,CAAC,SAAS,CAAC,CA0BnC;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC;AAED,wBAAgB,YAAY,CAC1B,SAAS,EAAE,SAAS,EACpB,eAAe,CAAC,EAAE,SAAS,WAc5B;AAGD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,IAAI,GAAG,MAAM,EAAE,KAAK,EAAE,IAAI,GAAG,MAAM,WAElE"}

package/dist/src/utils/misc.js

@@ -0,0 +1,43 @@
+import { generateId, } from "document-model";
+import { driveDocumentType } from "#drive-document-model/constants";
+import { OperationError } from "#server/error";
+import { RunAsap } from "./run-asap.js";
+export const runAsap = RunAsap.runAsap;
+export const runAsapAsync = RunAsap.runAsapAsync;
+export function isDocumentDrive(document) {
+    return document.documentType === driveDocumentType;
+}
+export function mergeOperations(currentOperations, newOperations) {
+    const minIndexByScope = Object.keys(currentOperations).reduce((acc, curr) => {
+        const scope = curr;
+        acc[scope] = currentOperations[scope].at(-1)?.index ?? 0;
+        return acc;
+    }, {});
+    const conflictOp = newOperations.find((op) => op.index < (minIndexByScope[op.scope] ?? 0));
+    if (conflictOp) {
+        throw new OperationError("ERROR", conflictOp, `Tried to add operation with index ${conflictOp.index} and document is at index ${minIndexByScope[conflictOp.scope]}`);
+    }
+    return newOperations
+        .sort((a, b) => a.index - b.index)
+        .reduce((acc, curr) => {
+        const existingOperations = acc[curr.scope] || [];
+        return { ...acc, [curr.scope]: [...existingOperations, curr] };
+    }, currentOperations);
+}
+export function generateUUID() {
+    return generateId();
+}
+export function isNoopUpdate(operation, latestOperation) {
+    if (!latestOperation) {
+        return false;
+    }
+    const isNoopOp = operation.type === "NOOP";
+    const isNoopLatestOp = latestOperation.type === "NOOP";
+    const isSameIndexOp = operation.index === latestOperation.index;
+    const isSkipOpGreaterThanLatestOp = operation.skip > latestOperation.skip;
+    return (isNoopOp && isNoopLatestOp && isSameIndexOp && isSkipOpGreaterThanLatestOp);
+}
+// return true if dateA is before dateB
+export function isBefore(dateA, dateB) {
+    return new Date(dateA) < new Date(dateB);
+}

package/dist/src/utils/run-asap.d.ts

@@ -0,0 +1,12 @@
+export declare namespace RunAsap {
+    type Task<T = void> = () => T;
+    type AbortTask = () => void;
+    type RunAsap<T> = (task: Task<T>) => AbortTask;
+    const useMessageChannel: Error | ((task: Task) => () => void);
+    const usePostMessage: Error | ((task: Task) => () => void);
+    const useSetImmediate: Error | ((task: Task) => () => void);
+    const useSetTimeout: (task: Task) => () => void;
+    function runAsap<T = void>(task: Task<T>): AbortTask;
+    function runAsapAsync<T = void>(task: RunAsap.Task<Promise<T>>, queueMethod?: RunAsap<void>): Promise<T>;
+}
+//# sourceMappingURL=run-asap.d.ts.map

package/dist/src/utils/run-asap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-asap.d.ts","sourceRoot":"","sources":["../../../src/utils/run-asap.ts"],"names":[],"mappings":"AACA,yBAAiB,OAAO,CAAC;IACvB,KAAY,IAAI,CAAC,CAAC,GAAG,IAAI,IAAI,MAAM,CAAC,CAAC;IACrC,KAAY,SAAS,GAAG,MAAM,IAAI,CAAC;IACnC,KAAY,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,SAAS,CAAC;IAE/C,MAAM,iBAAiB,kBAKd,IAAI,gBAiBhB,CAAC;IAEE,MAAM,cAAc,kBA0DX,IAAI,gBAQhB,CAAC;IAEE,MAAM,eAAe,kBAQZ,IAAI,gBAIhB,CAAC;IAEE,MAAM,aAAa,SACV,IAAI,eAIhB,CAAC;IAIL,SAAgB,OAAO,CAAC,CAAC,GAAG,IAAI,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,GAAG,SAAS,CAiB1D;IAED,SAAgB,YAAY,CAAC,CAAC,GAAG,IAAI,EACnC,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAC9B,WAAW,GAAE,OAAO,CAAC,IAAI,CAAW,GACnC,OAAO,CAAC,CAAC,CAAC,CAWZ;CACF"}

package/dist/src/utils/run-asap.js

@@ -0,0 +1,131 @@
+// eslint-disable-next-line @typescript-eslint/no-namespace
+export var RunAsap;
+(function (RunAsap) {
+    RunAsap.useMessageChannel = (() => {
+        if (typeof MessageChannel === "undefined") {
+            return new Error("MessageChannel is not supported");
+        }
+        return (task) => {
+            const controller = new AbortController();
+            const signal = controller.signal;
+            const mc = new MessageChannel();
+            mc.port1.postMessage(null);
+            mc.port2.addEventListener("message", () => {
+                task();
+                mc.port1.close();
+                mc.port2.close();
+            }, { once: true, signal: signal });
+            mc.port2.start();
+            return () => controller.abort();
+        };
+    })();
+    RunAsap.usePostMessage = (() => {
+        const _main = 
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        (typeof window === "object" && window) ||
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            (typeof global === "object" && global) ||
+            (typeof self === "object" && self);
+        if (!_main) {
+            return new Error("No global object found");
+        }
+        const main = _main;
+        if (
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        !main.postMessage ||
+            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            !main.addEventListener ||
+            main.importScripts // web workers can't this method
+        ) {
+            return new Error("postMessage is not supported");
+        }
+        let index = 0;
+        const tasks = new Map();
+        function getNewIndex() {
+            if (index === 9007199254740991) {
+                return 0;
+            }
+            return ++index;
+        }
+        const MESSAGE_PREFIX = "com.usePostMessage" + Math.random();
+        main.addEventListener("message", (e) => {
+            const event = e;
+            if (typeof event.data !== "string") {
+                return;
+            }
+            if (event.source !== main || !event.data.startsWith(MESSAGE_PREFIX)) {
+                return;
+            }
+            const index = event.data.split(":").at(1);
+            if (index === undefined) {
+                return;
+            }
+            const i = +index;
+            const task = tasks.get(i);
+            if (task) {
+                task();
+                tasks.delete(i);
+            }
+        }, false);
+        return (task) => {
+            const i = getNewIndex();
+            tasks.set(i, task);
+            main.postMessage(MESSAGE_PREFIX + ":" + i, { targetOrigin: "*" });
+            return () => {
+                tasks.delete(i);
+            };
+        };
+    })();
+    RunAsap.useSetImmediate = (() => {
+        if (typeof window !== "undefined") {
+            return new Error("setImmediate is not supported on the browser");
+        }
+        if (typeof setImmediate === "undefined") {
+            return new Error("setImmediate is not supported");
+        }
+        return (task) => {
+            const id = setImmediate(task);
+            return () => clearImmediate(id);
+        };
+    })();
+    RunAsap.useSetTimeout = (() => {
+        return (task) => {
+            const id = setTimeout(task, 0);
+            return () => clearTimeout(id);
+        };
+    })();
+    // queues the task in the macro tasks queue, so it doesn't
+    // prevent the event loop from movin on the next tick
+    function runAsap(task) {
+        // if on node use setImmediate
+        if (!(RunAsap.useSetImmediate instanceof Error)) {
+            return RunAsap.useSetImmediate(task);
+        }
+        // on browser use MessageChannel if available
+        else if (!(RunAsap.useMessageChannel instanceof Error)) {
+            return RunAsap.useMessageChannel(task);
+        }
+        // otherwise use window.postMessage
+        else if (!(RunAsap.usePostMessage instanceof Error)) {
+            return RunAsap.usePostMessage(task);
+        }
+        // fallback to setTimeout with 0 delay
+        else {
+            return RunAsap.useSetTimeout(task);
+        }
+    }
+    RunAsap.runAsap = runAsap;
+    function runAsapAsync(task, queueMethod = runAsap) {
+        if (queueMethod instanceof Error) {
+            throw new Error("queueMethod is not supported", {
+                cause: queueMethod,
+            });
+        }
+        return new Promise((resolve, reject) => {
+            queueMethod(() => {
+                task().then(resolve).catch(reject);
+            });
+        });
+    }
+    RunAsap.runAsapAsync = runAsapAsync;
+})(RunAsap || (RunAsap = {}));

package/dist/test/document-helpers/utils.d.ts

@@ -0,0 +1,8 @@
+import { Operation } from "document-model";
+export type InputOperation = Partial<Omit<Operation, "index" | "skip">> & {
+    index: number;
+    skip: number;
+};
+export declare const buildOperation: (input: InputOperation, shuffled?: boolean) => Operation;
+export declare const buildOperations: (inputs: InputOperation[], shuffled?: boolean) => Operation[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/test/document-helpers/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../test/document-helpers/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,CAAC,CAAC,GAAG;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAEF,eAAO,MAAM,cAAc,UAClB,cAAc,yBAEpB,SAoBF,CAAC;AAEF,eAAO,MAAM,eAAe,WAClB,cAAc,EAAE,yBAEvB,SAAS,EAAoD,CAAC"}

package/dist/test/document-helpers/utils.js

@@ -0,0 +1,21 @@
+export const buildOperation = (input, shuffled = false) => {
+    if (shuffled) {
+        return {
+            scope: "global",
+            type: "TEST",
+            timestamp: new Date().toISOString(),
+            input: {},
+            hash: `hash-${input.index}`,
+            ...input,
+        };
+    }
+    return {
+        hash: `hash-${input.index}`,
+        timestamp: new Date().toISOString(),
+        input: {},
+        scope: "global",
+        type: "TEST",
+        ...input,
+    };
+};
+export const buildOperations = (inputs, shuffled = false) => inputs.map((i) => buildOperation(i, shuffled));