@cr_docs_t/dts 0.0.12 → 0.2.1

package/dist/Fugue/FugueList.d.ts

@@ -9,8 +9,15 @@ export declare class FugueList<P> {
     totalOrder: UniquelyDenseTotalOrder<P>;
     positionCounter: number;
     ws: WebSocket | null;
-    constructor(totalOrder: UniquelyDenseTotalOrder<P>, ws: WebSocket | null);
+    documentID: string;
+    readonly batchSize = 100;
+    constructor(totalOrder: UniquelyDenseTotalOrder<P>, ws: WebSocket | null, documentID: string);
+    /**
+     * Propagates message or messages to replicas
+     * @param msg - Message or messages to propagate to replicas
+     */
     private propagate;
+    private binarySearchPosition;
     /**
      * Inserts a value at a given position
      * @param position - Position to insert at
@@ -29,6 +36,13 @@ export declare class FugueList<P> {
      * @param value - Value to insert
      */
     insert(index: number, value: string): void;
+    /**
+     * Inserts multiple characters at given index, this
+     * handles large insertions by batching messages
+     * @param index - Index to insert at
+     * @param value - Value to insert
+     */
+    insertMultiple(index: number, value: string): void;
     /**
      *  Deletes value at given position
      * @param position - Position to delete at
@@ -52,12 +66,37 @@ export declare class FugueList<P> {
      * @param index - Index of the value to delete
      */
     delete(index: number): void;
+    /**
+     * Deletes multiple values starting from index, this
+     * handles large deletions by batching messages
+     * @param index - Starting index to delete from
+     * @param count -  Number of values to delete
+     */
+    deleteMultiple(index: number, count: number): void;
     /**
      * Observes the current visible state of the list
      * @returns The current visible state of the list as a string
      */
     observe(): string;
-    effect(msg: FugueMessage<P>): void;
+    /**
+     * Applies a single effect message to the list
+     * @param msg - Message to apply effect for
+     */
+    private singleEffect;
+    /**
+     * Applies batched effect messages to the list
+     * @param msgs - Messages to apply effect for in batch
+     */
+    private batchEffect;
+    /**
+     * Applies effect messages to the list
+     * @param msg - Message or messages to apply effect for, can be batched
+     */
+    effect(msg: FugueMessage<P> | FugueMessage<P>[]): void;
     replicaId(): string;
+    /**
+     * Performs garbage collection by removing tombstoned nodes from the state
+     */
+    garbageCollect(): void;
 }
 //# sourceMappingURL=FugueList.d.ts.map

package/dist/Fugue/FugueList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FugueList.d.ts","sourceRoot":"","sources":["../../src/Fugue/FugueList.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACnF,OAAO,EAAE,YAAY,EAAa,MAAM,qBAAqB,CAAC;AAE9D;;GAEG;AACH,qBAAa,SAAS,CAAC,CAAC;IACpB,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAM;IAC1B,UAAU,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IACvC,eAAe,SAAK;IACpB,EAAE,EAAE,SAAS,GAAG,IAAI,CAAC;gBAET,UAAU,EAAE,uBAAuB,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,SAAS,GAAG,IAAI;IAKxE,OAAO,CAAC,SAAS;IAMjB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAiCxB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IASxB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAcnC;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;;;OAIG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAajD;;;;;OAKG;IACH,gBAAgB,CAAC,QAAQ,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS;IAejD;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IAoBpB;;;OAGG;IACH,OAAO,IAAI,MAAM;IAmBjB,MAAM,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC;IAc3B,SAAS,IAAI,MAAM;CAGtB"}
+{"version":3,"file":"FugueList.d.ts","sourceRoot":"","sources":["../../src/Fugue/FugueList.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAC/C,OAAO,EAAE,uBAAuB,EAAE,MAAM,0CAA0C,CAAC;AACnF,OAAO,EAAE,YAAY,EAAa,MAAM,qBAAqB,CAAC;AAE9D;;GAEG;AACH,qBAAa,SAAS,CAAC,CAAC;IACpB,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAM;IAC1B,UAAU,EAAE,uBAAuB,CAAC,CAAC,CAAC,CAAC;IACvC,eAAe,SAAK;IACpB,EAAE,EAAE,SAAS,GAAG,IAAI,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,SAAS,OAAO;gBAEb,UAAU,EAAE,uBAAuB,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,SAAS,GAAG,IAAI,EAAE,UAAU,EAAE,MAAM;IAM5F;;;OAGG;IACH,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,oBAAoB;IAmB5B;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAqBxB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IASxB;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAenC;;;;;OAKG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAgD3C;;;OAGG;IACH,OAAO,CAAC,gBAAgB;IAcxB;;;;OAIG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS;IAajD;;;;;OAKG;IACH,gBAAgB,CAAC,QAAQ,EAAE,CAAC,GAAG,MAAM,GAAG,SAAS;IAejD;;;OAGG;IACH,MAAM,CAAC,KAAK,EAAE,MAAM;IAqBpB;;;;;OAKG;IACH,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAoD3C;;;OAGG;IACH,OAAO,IAAI,MAAM;IAmBjB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAcpB;;;OAGG;IACH,OAAO,CAAC,WAAW;IAqGnB;;;OAGG;IACH,MAAM,CAAC,GAAG,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,EAAE;IAW/C,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,cAAc;CAOjB"}

package/dist/Fugue/FugueList.js

@@ -4,49 +4,65 @@ import { Operation } from "../types/Message.js";
  * A Fugue List CRDT, with insert and delete operations
  */
 export class FugueList {
-    constructor(totalOrder, ws) {
+    constructor(totalOrder, ws, documentID) {
         this.state = [];
         this.positionCounter = 0;
+        this.batchSize = 100;
         this.totalOrder = totalOrder;
         this.ws = ws;
+        this.documentID = documentID;
     }
+    /**
+     * Propagates message or messages to replicas
+     * @param msg - Message or messages to propagate to replicas
+     */
     propagate(msg) {
         if (!this.ws)
             return;
         this.ws.send(JSON.stringify(msg));
     }
+    binarySearchPosition(position) {
+        let low = 0;
+        let high = this.state.length - 1;
+        while (low <= high) {
+            const mid = Math.floor((low + high) / 2);
+            const midPos = this.state[mid][0].position;
+            const cmp = this.totalOrder.compare(midPos, position);
+            if (cmp === 0) {
+                return mid;
+            }
+            else if (cmp < 0) {
+                low = mid + 1;
+            }
+            else {
+                high = mid - 1;
+            }
+        }
+        // If not found, return the position where it can be inserted
+        return low;
+    }
     /**
      * Inserts a value at a given position
      * @param position - Position to insert at
      * @param value - Value to insert
      */
     insertAtPosition(position, value) {
-        let index = this.state.length;
-        for (let i = 0; i < this.state.length; ++i) {
-            const n = this.state[i][0];
-            // Compare positions, if the value should be
-            // ordered before this one, we found our index
-            // this should fix the issue with inserting in the
-            // middle messing up order
-            if (this.totalOrder.compare(position, n.position) < 0) {
-                index = i;
-                break;
+        let index = this.binarySearchPosition(position);
+        // Check if the position already exists at this index, i.e. there is a collision
+        if (index < this.state.length && this.totalOrder.compare(this.state[index][0].position, position) === 0) {
+            const cell = this.state[index];
+            const existing = cell.find((n) => this.totalOrder.compare(n.position, position) === 0);
+            // Don't insert if it already exists,
+            // TODO: ideally this should trigger a collision resolution
+            if (!existing) {
+                cell.push(new FNode(position, value));
+                cell.sort((a, b) => this.totalOrder.compare(a.position, b.position));
             }
         }
-        console.log({ insertIndex: index });
-        if (index >= this.state.length) {
-            this.state.push([]);
-        }
+        // Insert new cell at index
         else {
-            this.state.splice(index, 0, []);
+            this.state.splice(index, 0, [new FNode(position, value)]);
         }
-        // Check if this position already exists at this index
-        // If it does, we don't insert again
-        const cell = this.state[index];
-        const existing = cell.find((n) => this.totalOrder.compare(n.position, position) === 0);
-        if (existing)
-            return;
-        cell.push(new FNode(position, value));
     }
     /**
      * Generates unique position for new element at 'index'
@@ -71,12 +87,59 @@ export class FugueList {
         console.log({ index, pos });
         this.insertAtPosition(pos, value);
         this.propagate({
+            documentID: this.documentID,
             replicaId: this.totalOrder.getReplicaId(),
             operation: Operation.INSERT,
             position: pos,
             data: value,
         });
     }
+    /**
+     * Inserts multiple characters at given index, this
+     * handles large insertions by batching messages
+     * @param index - Index to insert at
+     * @param value - Value to insert
+     */
+    insertMultiple(index, value) {
+        if (value.length == 0)
+            return;
+        if (value.length == 1) {
+            this.insert(index, value);
+            return;
+        }
+        // Find left and right anchors
+        const lA = index > 0 ? this.findVisiblePosition(index - 1) : undefined;
+        const rA = this.findVisiblePosition(index);
+        const newCells = [];
+        let cL = lA;
+        let msgs = [];
+        for (const c of value) {
+            const pos = this.totalOrder.createBetween(cL, rA);
+            // Collect new cells
+            newCells.push([new FNode(pos, c)]);
+            // Batch propagate
+            msgs.push({
+                documentID: this.documentID,
+                replicaId: this.totalOrder.getReplicaId(),
+                operation: Operation.INSERT,
+                position: pos,
+                data: c,
+            });
+            cL = pos;
+            if (msgs.length >= this.batchSize) {
+                this.propagate(msgs);
+                msgs = [];
+            }
+        }
+        // Single splice to insert all new cells
+        const firstPos = newCells[0][0].position;
+        const insertIndex = this.binarySearchPosition(firstPos);
+        this.state.splice(insertIndex, 0, ...newCells);
+        // Propagate remaining
+        if (msgs.length > 0) {
+            this.propagate(msgs);
+        }
+    }
     /**
      *  Deletes value at given position
      * @param position - Position to delete at
@@ -143,12 +206,64 @@ export class FugueList {
         this.deleteAtPosition(position);
         // Send to replicas
         this.propagate({
+            documentID: this.documentID,
             replicaId: this.totalOrder.getReplicaId(),
             operation: Operation.DELETE,
             position: position,
             data: null,
         });
     }
+    /**
+     * Deletes multiple values starting from index, this
+     * handles large deletions by batching messages
+     * @param index - Starting index to delete from
+     * @param count -  Number of values to delete
+     */
+    deleteMultiple(index, count) {
+        if (count <= 0)
+            return;
+        if (count == 1) {
+            this.delete(index);
+            return;
+        }
+        let currentVisibleIndex = 0;
+        let deletedCount = 0;
+        let msgs = [];
+        outer: for (const c of this.state) {
+            for (const n of c) {
+                // Only consider visible nodes
+                if (n.value !== undefined) {
+                    if (currentVisibleIndex >= index) {
+                        const pos = n.position;
+                        // Tombstone the node
+                        n.value = undefined;
+                        deletedCount++;
+                        // Batch
+                        msgs.push({
+                            documentID: this.documentID,
+                            replicaId: this.totalOrder.getReplicaId(),
+                            operation: Operation.DELETE,
+                            position: pos,
+                            data: null,
+                        });
+                        if (msgs.length >= this.batchSize) {
+                            this.propagate(msgs);
+                            msgs = [];
+                        }
+                    }
+                    // Processed a visible node
+                    currentVisibleIndex++;
+                    // Check if we've deleted enough
+                    if (deletedCount >= count) {
+                        break outer;
+                    }
+                }
+            }
+        }
+        if (msgs.length > 0) {
+            this.propagate(msgs);
+        }
+    }
     /**
      * Observes the current visible state of the list
      * @returns The current visible state of the list as a string
@@ -168,7 +283,11 @@ export class FugueList {
         }
         return res.toString();
     }
-    effect(msg) {
+    /**
+     * Applies a single effect message to the list
+     * @param msg - Message to apply effect for
+     */
+    singleEffect(msg) {
         const { replicaId, operation, data, position } = msg;
         if (replicaId == this.totalOrder.getReplicaId())
             return;
@@ -182,7 +301,125 @@ export class FugueList {
         }
         throw Error("Invalid operation");
     }
+    /**
+     * Applies batched effect messages to the list
+     * @param msgs - Messages to apply effect for in batch
+     */
+    batchEffect(msgs) {
+        const inserts = [];
+        const deletes = new Set();
+        // Separate operations
+        for (const msg of msgs) {
+            const { replicaId, operation, position, data } = msg;
+            if (replicaId == this.totalOrder.getReplicaId())
+                continue;
+            switch (operation) {
+                case Operation.INSERT:
+                    if (!data)
+                        continue;
+                    inserts.push(msg);
+                    break;
+                case Operation.DELETE:
+                    deletes.add(JSON.stringify(position));
+                    break;
+            }
+        }
+        // Apply deletes first
+        if (deletes.size > 0) {
+            for (const posStr of deletes) {
+                // Parse the position back from the set
+                const pos = JSON.parse(posStr);
+                const idx = this.binarySearchPosition(pos);
+                // Check if we found the right cell
+                if (idx < this.state.length) {
+                    const cell = this.state[idx];
+                    // Find the specific node in the collision cell
+                    const node = cell.find((n) => this.totalOrder.compare(n.position, pos) === 0);
+                    if (node && node.value !== undefined) {
+                        node.value = undefined; // Tombstone
+                    }
+                }
+            }
+        }
+        // Then apply inserts
+        if (inserts.length > 0) {
+            inserts.sort((a, b) => this.totalOrder.compare(a.position, b.position));
+            // Group into chunks, of contiguous inserts
+            let batchCells = [];
+            let startIdx = -1;
+            for (const msg of inserts) {
+                const { position, data } = msg;
+                // Find the index to insert at
+                const idx = this.binarySearchPosition(position);
+                // Check for collision
+                //TODO: should trigger collision resolution
+                if (idx < this.state.length && this.totalOrder.compare(this.state[idx][0].position, position) === 0) {
+                    const cell = this.state[idx];
+                    const existing = cell.find((n) => this.totalOrder.compare(n.position, position) === 0);
+                    // Don't insert if it already exists
+                    if (!existing) {
+                        cell.push(new FNode(position, data ? data : undefined));
+                        cell.sort((a, b) => this.totalOrder.compare(a.position, b.position));
+                    }
+                }
+                else {
+                    // Start a new batch if:
+                    // - It's the first item
+                    // - This index is not contiguous with the previous group
+                    if (startIdx === -1) {
+                        startIdx = idx;
+                        batchCells = [[new FNode(position, data ? data : undefined)]];
+                    }
+                    // If the index is the same as startIdx, continue the batch
+                    else if (idx === startIdx) {
+                        batchCells.push([new FNode(position, data ? data : undefined)]);
+                    }
+                    // The index is different, i.e. not contiguous, so flush the current batch,
+                    // commit it and start a new one
+                    else {
+                        // Commit batch
+                        this.state.splice(startIdx, 0, ...batchCells);
+                        // Start new batch
+                        // Calculate the shift caused by the splice
+                        // If the new idx (calculated on old state) is after the splice point,
+                        // we must add the length of the batch we just inserted.
+                        const shift = idx >= startIdx ? batchCells.length : 0;
+                        startIdx = idx + shift;
+                        batchCells = [[new FNode(position, data ? data : undefined)]];
+                    }
+                }
+            }
+            // Commit any remaining batch
+            if (batchCells.length > 0)
+                this.state.splice(startIdx, 0, ...batchCells);
+        }
+    }
+    /**
+     * Applies effect messages to the list
+     * @param msg - Message or messages to apply effect for, can be batched
+     */
+    effect(msg) {
+        if (Array.isArray(msg)) {
+            this.batchEffect(msg);
+            // for (const m of msg) {
+            //     this.singleEffect(m);
+            // }
+        }
+        else {
+            this.singleEffect(msg);
+        }
+    }
     replicaId() {
         return this.totalOrder.getReplicaId();
     }
+    /**
+     * Performs garbage collection by removing tombstoned nodes from the state
+     */
+    garbageCollect() {
+        this.state = this.state.filter((cell) => {
+            // Check if cell has any visible nodes
+            const hasVisible = cell.some((n) => n.value !== undefined);
+            return hasVisible;
+        });
+    }
 }

package/dist/types/Message.d.ts

@@ -6,6 +6,7 @@ export declare enum Operation {
 }
 export type Data = string;
 export interface FugueMessage<P> {
+    documentID: string;
     replicaId: string;
     operation: Operation;
     position: P;

package/dist/types/Message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Message.d.ts","sourceRoot":"","sources":["../../src/types/Message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,oBAAY,SAAS;IACjB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,IAAI,IAAA;CACP;AAED,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,MAAM,WAAW,YAAY,CAAC,CAAC;IAC3B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,CAAC,CAAC;IACZ,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAC/B,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CACxB"}
+{"version":3,"file":"Message.d.ts","sourceRoot":"","sources":["../../src/types/Message.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAExC,oBAAY,SAAS;IACjB,MAAM,IAAA;IACN,MAAM,IAAA;IACN,IAAI,IAAA;CACP;AAED,MAAM,MAAM,IAAI,GAAG,MAAM,CAAC;AAE1B,MAAM,WAAW,YAAY,CAAC,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;IACrB,QAAQ,EAAE,CAAC,CAAC;IACZ,IAAI,EAAE,IAAI,GAAG,IAAI,CAAC;CACrB;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAC/B,KAAK,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;CACxB"}

package/package.json

@@ -1,12 +1,14 @@
 {
   "name": "@cr_docs_t/dts",
-  "version": "0.0.12",
+  "version": "0.2.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run build",
+    "ci": "npm install && npm run build",
+    "publish": "npm publish --access public"
   },
   "exports": {
     ".": {
@@ -15,6 +17,35 @@
       "types": "./dist/index.d.ts"
     }
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CRDT-Capstone/CRDocsT-dts.git"
+  },
+  "release": {
+    "branches": [
+      "master"
+    ],
+    "plugins": [
+      "@semantic-release/commit-analyzer",
+      "@semantic-release/release-notes-generator",
+      "@semantic-release/changelog",
+      "@semantic-release/npm",
+      "@semantic-release/github",
+      [
+        "@semantic-release/git",
+        {
+          "assets": [
+            "package.json",
+            "CHANGELOG.md"
+          ],
+          "message": "chore(release): ${nextRelease.version} [skip ci]\n\n${nextRelease.notes}"
+        }
+      ]
+    ]
+  },
   "keywords": [],
   "author": [
     "Madiba Hudson-Quansah",
@@ -23,7 +54,10 @@
   "license": "ISC",
   "packageManager": "pnpm@10.20.0",
   "devDependencies": {
+    "@semantic-release/changelog": "^6.0.3",
+    "@semantic-release/git": "^10.0.1",
     "@types/node": "^24.10.1",
+    "semantic-release": "^25.0.2",
     "typescript": "^5.9.3"
   },
   "files": [