@cr_docs_t/dts 0.0.1

package/biome.jsonc

@@ -0,0 +1,12 @@
+{
+  "formatter": {
+    "indentStyle": "space", // default is `tab`
+    "lineWidth": 120, // default is `80`
+    "indentWidth": 4, // default is `2`
+  },
+  "json": {
+    "formatter": {
+      "enabled": false,
+    },
+  },
+}

package/dist/CausalTree/CTNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CTNode {
+    uid; //userId @ lamport timestamp
+    character;
+    cause; //the causal prior?
+    constructor(uid) {
+        this.uid = uid;
+    }
+}
+exports.default = CTNode;

package/dist/CausalTree/CausalTree.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class CasualTree {
+    /*
+    This is the fug crdt
+    It is a tree
+    It has a root
+    
+    We can insert into the tree
+    Delete from the tree
+    Display the characters...
+    Maybe add a build method from a list of operations...
+    */
+    root;
+    constructor(root) {
+        this.root = root;
+    }
+}
+exports.default = CasualTree;

package/dist/Fugue/FNode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class FNode {
+    value;
+    position;
+    constructor(position, value) {
+        this.value = value;
+        this.position = position;
+    }
+}
+exports.default = FNode;

package/dist/Fugue/FugueList.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const FNode_1 = __importDefault(require("./FNode"));
+/**
+ * A Fugue List CRDT, with insert and delete operations
+ */
+class FugueList {
+    state = [];
+    totalOrder;
+    positionCounter = 0;
+    constructor(totalOrder) {
+        this.totalOrder = totalOrder;
+    }
+    /**
+     * Inserts new element with 'value' at 'index' in the list
+     * @param index - Index to insert 'value' at
+     * @param value - Value to insert
+     */
+    insert(index, value) {
+        if (index >= this.state.length)
+            this.state.push([]);
+        let i = this.state.length - 1;
+        while (i > index) {
+            this.state[i] = this.state[i - 1];
+            i--;
+        }
+        const atIndex = this.state[index];
+        if (index > 0 && index < this.state.length - 1) {
+            const before = this.state[index - 1];
+            const after = this.state[index + 1];
+            if (atIndex.length == 0) {
+                atIndex.push(new FNode_1.default(this.totalOrder.createBetween(before[before.length - 1].position), value));
+            }
+            else {
+                const a = atIndex[atIndex.length - 1];
+                atIndex.push(new FNode_1.default(this.totalOrder.createBetween(a.position, after[after.length - 1].position), value));
+            }
+        }
+        else {
+            if (atIndex.length == 0) {
+                atIndex.push(new FNode_1.default(this.totalOrder.createBetween(), value));
+            }
+            else {
+                const a = atIndex[atIndex.length - 1];
+                atIndex.push(new FNode_1.default(this.totalOrder.createBetween(a.position), value));
+            }
+        }
+    }
+    /**
+     * Delete value in the list at index
+     * @param index - Index of the value to delete
+     */
+    delete(index) {
+        let i = index;
+        while (i < this.state.length) {
+            this.state[i] = this.state[i + 1];
+            i++;
+        }
+        this.state.pop();
+    }
+    observe() {
+        let res = new String();
+        for (const idx of this.state) {
+            if (idx.length > 1) {
+                res += idx
+                    .sort((a, b) => this.totalOrder.compare(a.position, b.position))
+                    .map((node) => node?.value || "ð")
+                    .join("");
+            }
+            else {
+                res += idx[0]?.value || "ð";
+            }
+        }
+        return res.toString();
+    }
+}
+exports.default = FugueList;

package/dist/Fugue/FugueTest.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const FugueList_1 = __importDefault(require("./FugueList"));
+const utils_1 = require("./utils");
+const test1 = new FugueList_1.default(new utils_1.StringTotalOrder((0, utils_1.randomString)(5)));
+const test2 = new FugueList_1.default(new utils_1.StringTotalOrder((0, utils_1.randomString)(5)));
+const word1 = "SHADOW WIZARD MONEY GANG";
+const word2 = "BALLING";
+// Randomly insert words into the list from different simulated users
+async function simulateUser(list, word) {
+    for (let i = 0; i < word.length; i++) {
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 150));
+        list.insert(i, word.charAt(i));
+        console.log(list.observe());
+        console.log(list.state);
+    }
+}
+Promise.all([
+    simulateUser(test1, word1), //
+    simulateUser(test2, word2),
+])
+    .then(() => console.log(`Done:\t${test1.observe()}\n\t${test2.observe()}`))
+    .catch(console.error);

package/dist/Fugue/utils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringTotalOrder = void 0;
+exports.randomString = randomString;
+class StringTotalOrder {
+    replicaID;
+    counter = 0;
+    compare(a, b) {
+        return a.localeCompare(b);
+    }
+    constructor(replicaID) {
+        this.replicaID = replicaID;
+    }
+    createBetween(a, b) {
+        // Create a wholly unique string using a causal dot, i.e. (replicaID, counter)
+        const uniqueStr = `${this.replicaID}${this.counter++}`;
+        // If node is the first ever position in the document
+        if (!a && !b) {
+            return uniqueStr + "R";
+        }
+        // If node is the first position at that index
+        if (!a) {
+            return b + uniqueStr + "R";
+        }
+        // If node is the last position at that index
+        if (!b) {
+            return a + uniqueStr + "R";
+        }
+        const isAPrefixOfB = b.substring(0, a.length).localeCompare(a);
+        // If a is not a prefix of b append a globally unique new string to a and return that +R
+        if (!isAPrefixOfB) {
+            return a + uniqueStr + "R";
+        }
+        else {
+            // If a is a prefix of b replace the R at the end of b with L.
+            // Then append a globally unique string to it and return it  +R.
+            return b.slice(0, -1) + "L" + uniqueStr + "R";
+        }
+    }
+}
+exports.StringTotalOrder = StringTotalOrder;
+function randomString(length = 10) {
+    let res = new Array(length);
+    for (let i = 0; i < length; i++)
+        res[i] = String.fromCharCode(97 + Math.floor(Math.random() * 26));
+    return res.join("");
+}

package/dist/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@cr_docs_t/dts",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "publish": "npm run build && npm publish --access public"
+  },
+  "keywords": [],
+  "author": [
+    "Madiba Hudson-Quansah",
+    "Tanitoluwa Olamiji Adebayo"
+  ],
+  "license": "ISC",
+  "packageManager": "pnpm@10.20.0",
+  "devDependencies": {
+    "@types/node": "^24.10.1",
+    "typescript": "^5.9.3"
+  }
+}

package/src/CausalTree/CTNode.ts

@@ -0,0 +1,12 @@
+class CTNode {
+    uid: string; //userId @ lamport timestamp
+    character?: string;
+    cause?: CTNode; //the causal prior?
+
+    constructor(uid: string) {
+        this.uid = uid;
+    }
+}
+
+export default CTNode;
+

package/src/CausalTree/CausalTree.ts

@@ -0,0 +1,21 @@
+import CTNode from "./CTNode";
+
+class CasualTree {
+    /* 
+    This is the fug crdt
+    It is a tree
+    It has a root 
+    
+    We can insert into the tree
+    Delete from the tree
+    Display the characters...
+    Maybe add a build method from a list of operations...
+    */
+    root: CTNode;
+
+    constructor(root: CTNode) {
+        this.root = root;
+    }
+}
+
+export default CasualTree;

package/src/Fugue/FNode.ts

@@ -0,0 +1,11 @@
+class FNode<P> {
+    value?: string;
+    position: P;
+
+    constructor(position: P, value?: string) {
+        this.value = value;
+        this.position = position;
+    }
+}
+
+export default FNode;

package/src/Fugue/FugueList.ts

@@ -0,0 +1,82 @@
+import FNode from "./FNode";
+import { StringTotalOrder, UniquelyDenseTotalOrder } from "./utils";
+
+/**
+ * A Fugue List CRDT, with insert and delete operations
+ */
+class FugueList<P> {
+    state: FNode<P>[][] = [];
+    totalOrder: UniquelyDenseTotalOrder<P>;
+    positionCounter = 0;
+
+    constructor(totalOrder: UniquelyDenseTotalOrder<P>) {
+        this.totalOrder = totalOrder;
+    }
+
+    /**
+     * Inserts new element with 'value' at 'index' in the list
+     * @param index - Index to insert 'value' at
+     * @param value - Value to insert
+     */
+    insert(index: number, value: string) {
+        if (index >= this.state.length) this.state.push([]);
+
+        let i = this.state.length - 1;
+        while (i > index) {
+            this.state[i] = this.state[i - 1];
+            i--;
+        }
+
+        const atIndex = this.state[index];
+        if (index > 0 && index < this.state.length - 1) {
+            const before = this.state[index - 1];
+            const after = this.state[index + 1];
+            if (atIndex.length == 0) {
+                atIndex.push(new FNode<P>(this.totalOrder.createBetween(before[before.length - 1].position), value));
+            } else {
+                const a = atIndex[atIndex.length - 1];
+                atIndex.push(
+                    new FNode<P>(this.totalOrder.createBetween(a.position, after[after.length - 1].position), value),
+                );
+            }
+        } else {
+            if (atIndex.length == 0) {
+                atIndex.push(new FNode<P>(this.totalOrder.createBetween(), value));
+            } else {
+                const a = atIndex[atIndex.length - 1];
+                atIndex.push(new FNode<P>(this.totalOrder.createBetween(a.position), value));
+            }
+        }
+    }
+
+    /**
+     * Delete value in the list at index
+     * @param index - Index of the value to delete
+     */
+    delete(index: number) {
+        let i = index;
+        while (i < this.state.length) {
+            this.state[i] = this.state[i + 1];
+            i++;
+        }
+        this.state.pop();
+    }
+
+    observe(): string {
+        let res = new String();
+        for (const idx of this.state) {
+            if (idx.length > 1) {
+                res += idx
+                    .sort((a, b) => this.totalOrder.compare(a.position, b.position))
+                    .map((node) => node?.value || "ð")
+                    .join("");
+            } else {
+                res += idx[0]?.value || "ð";
+            }
+        }
+
+        return res.toString();
+    }
+}
+
+export default FugueList;

package/src/Fugue/FugueTest.ts

@@ -0,0 +1,25 @@
+import FugueList from "./FugueList";
+import { randomString, StringTotalOrder } from "./utils";
+
+const test1 = new FugueList(new StringTotalOrder(randomString(5)));
+const test2 = new FugueList(new StringTotalOrder(randomString(5)));
+
+const word1 = "SHADOW WIZARD MONEY GANG";
+const word2 = "BALLING";
+
+// Randomly insert words into the list from different simulated users
+async function simulateUser(list: FugueList<string>, word: string) {
+    for (let i = 0; i < word.length; i++) {
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 150));
+        list.insert(i, word.charAt(i));
+        console.log(list.observe());
+        console.log(list.state);
+    }
+}
+
+Promise.all([
+    simulateUser(test1, word1), //
+    simulateUser(test2, word2),
+])
+    .then(() => console.log(`Done:\t${test1.observe()}\n\t${test2.observe()}`))
+    .catch(console.error);

package/src/Fugue/utils.ts

@@ -0,0 +1,75 @@
+/**
+ * Helper interface for sorting and creating unique immutable positions,
+ * suitable for use in a List CRDT. Taken from mattweidner.com/2022/10/21/basic-list-crdt.html
+ *
+ * @type P The type of positions. Treated as immutable.
+ */
+export interface UniquelyDenseTotalOrder<P> {
+    /**
+     * Usual compare function for sorts: returns negative if a < b in
+     * their sort order, positive if a > b.
+     */
+    compare(a: P, b: P): number;
+
+    /**
+     * Returns a globally unique new position c such that a < c < b.
+     *
+     * "Globally unique" means that the created position must be distinct
+     * from all other created positions, including ones created concurrently
+     * by other users.
+     *
+     * When a is undefined, it is treated as the start of the list, i.e.,
+     * this returns c such that c < b. Likewise, undefined b is treated
+     * as the end of the list.
+     */
+    createBetween(a?: P, b?: P): P;
+}
+
+export class StringTotalOrder implements UniquelyDenseTotalOrder<string> {
+    readonly replicaID: string;
+    private counter = 0;
+
+    compare(a: string, b: string): number {
+        return a.localeCompare(b);
+    }
+
+    constructor(replicaID: string) {
+        this.replicaID = replicaID;
+    }
+
+    createBetween(a?: string, b?: string): string {
+        // Create a wholly unique string using a causal dot, i.e. (replicaID, counter)
+        const uniqueStr = `${this.replicaID}${this.counter++}`;
+
+        // If node is the first ever position in the document
+        if (!a && !b) {
+            return uniqueStr + "R";
+        }
+
+        // If node is the first position at that index
+        if (!a) {
+            return b + uniqueStr + "R";
+        }
+
+        // If node is the last position at that index
+        if (!b) {
+            return a + uniqueStr + "R";
+        }
+
+        const isAPrefixOfB = b.substring(0, a.length).localeCompare(a);
+        // If a is not a prefix of b append a globally unique new string to a and return that +R
+        if (!isAPrefixOfB) {
+            return a + uniqueStr + "R";
+        } else {
+            // If a is a prefix of b replace the R at the end of b with L.
+            // Then append a globally unique string to it and return it  +R.
+            return b.slice(0, -1) + "L" + uniqueStr + "R";
+        }
+    }
+}
+
+export function randomString(length: number = 10): string {
+    let res = new Array<string>(length);
+    for (let i = 0; i < length; i++) res[i] = String.fromCharCode(97 + Math.floor(Math.random() * 26));
+    return res.join("");
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+import FugueList from "./Fugue/FugueList";
+import CausalTree from "./CausalTree/CausalTree";

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  // Visit https://aka.ms/tsconfig to read more about this file
+  "compilerOptions": {
+    "module": "nodenext",
+    "target": "esnext",
+    "rootDir": "./src",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+  }
+}