@opendaw/studio-core 0.0.6

package/dist/sync-log/Commit.d.ts

@@ -0,0 +1,26 @@
+import { ByteArrayInput } from "@opendaw/lib-std";
+import { Update } from "@opendaw/lib-box";
+import { Project } from "../Project";
+export declare const enum CommitType {
+    Init = 0,
+    Open = 1,
+    Updates = 2,
+    NewVersion = 3
+}
+export declare class Commit {
+    #private;
+    readonly type: CommitType;
+    readonly prevHash: ArrayBuffer;
+    readonly thisHash: ArrayBuffer;
+    readonly payload: ArrayBuffer;
+    readonly date: number;
+    static readonly VERSION = 1;
+    static createFirst(project: Project): Promise<Commit>;
+    static createOpen(prevHash: ArrayBuffer): Promise<Commit>;
+    static createUpdate(prevHash: ArrayBuffer, updates: ReadonlyArray<Update>): Promise<Commit>;
+    static deserialize(input: ByteArrayInput): Commit;
+    private constructor();
+    serialize(): ArrayBuffer;
+    toString(): string;
+}
+//# sourceMappingURL=Commit.d.ts.map

package/dist/sync-log/Commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Commit.d.ts","sourceRoot":"","sources":["../../src/sync-log/Commit.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,cAAc,EAAwB,MAAM,kBAAkB,CAAA;AAC9E,OAAO,EAAC,MAAM,EAAC,MAAM,kBAAkB,CAAA;AACvC,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAElC,0BAAkB,UAAU;IAAG,IAAI,IAAA;IAAE,IAAI,IAAA;IAAE,OAAO,IAAA;IAAE,UAAU,IAAA;CAAE;AAEhE,qBAAa,MAAM;;IAiDK,QAAQ,CAAC,IAAI,EAAE,UAAU;IACzB,QAAQ,CAAC,QAAQ,EAAE,WAAW;IAC9B,QAAQ,CAAC,QAAQ,EAAE,WAAW;IAC9B,QAAQ,CAAC,OAAO,EAAE,WAAW;IAC7B,QAAQ,CAAC,IAAI,EAAE,MAAM;IApDzC,MAAM,CAAC,QAAQ,CAAC,OAAO,KAAI;IAK3B,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAKrD,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC;WAI5C,YAAY,CAAC,QAAQ,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAejG,MAAM,CAAC,WAAW,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM;IAmBjD,OAAO;IAMP,SAAS,IAAI,WAAW;IAYxB,QAAQ,IAAI,MAAM;CAGrB"}

package/dist/sync-log/Commit.js

@@ -0,0 +1,76 @@
+import { assert, ByteArrayOutput, Hash } from "@opendaw/lib-std";
+export var CommitType;
+(function (CommitType) {
+    CommitType[CommitType["Init"] = 0] = "Init";
+    CommitType[CommitType["Open"] = 1] = "Open";
+    CommitType[CommitType["Updates"] = 2] = "Updates";
+    CommitType[CommitType["NewVersion"] = 3] = "NewVersion";
+})(CommitType || (CommitType = {}));
+export class Commit {
+    type;
+    prevHash;
+    thisHash;
+    payload;
+    date;
+    static VERSION = 1; // For devs: walk your way to dynamic versioning from here
+    static #NO_PAYLOAD = new Uint8Array(1).buffer;
+    static #EMPTY_HASH = new Uint8Array(32).buffer;
+    static createFirst(project) {
+        const payload = project.toArrayBuffer();
+        return this.#create(CommitType.Init, Commit.#EMPTY_HASH, payload);
+    }
+    static createOpen(prevHash) {
+        return this.#create(CommitType.Open, prevHash, Commit.#NO_PAYLOAD);
+    }
+    static async createUpdate(prevHash, updates) {
+        const output = ByteArrayOutput.create();
+        output.writeInt(updates.length);
+        updates.forEach(update => update.write(output));
+        return this.#create(CommitType.Updates, prevHash, output.toArrayBuffer());
+    }
+    static async #create(type, prevHash, payload) {
+        const date = Date.now();
+        const output = ByteArrayOutput.create();
+        const data = output.toArrayBuffer();
+        const thisHash = await Hash.fromBuffers(data, prevHash, new Float64Array([date]).buffer);
+        return new Commit(type, prevHash, thisHash, payload, date);
+    }
+    static deserialize(input) {
+        const type = input.readInt();
+        assert(type === CommitType.Init
+            || type === CommitType.Open
+            || type === CommitType.Updates
+            || type === CommitType.NewVersion, `Unknown commit type "${type}"`);
+        const version = input.readInt();
+        assert(version === Commit.VERSION, "version mismatch");
+        const prevHash = new Int8Array(32);
+        input.readBytes(prevHash);
+        const thisHash = new Int8Array(32);
+        input.readBytes(thisHash);
+        const data = new Int8Array(input.readInt());
+        input.readBytes(data);
+        const date = input.readDouble();
+        return new Commit(type, prevHash.buffer, thisHash.buffer, data.buffer, date);
+    }
+    constructor(type, prevHash, thisHash, payload, date) {
+        this.type = type;
+        this.prevHash = prevHash;
+        this.thisHash = thisHash;
+        this.payload = payload;
+        this.date = date;
+    }
+    serialize() {
+        const output = ByteArrayOutput.create();
+        output.writeInt(this.type);
+        output.writeInt(Commit.VERSION);
+        output.writeBytes(new Int8Array(this.prevHash));
+        output.writeBytes(new Int8Array(this.thisHash));
+        output.writeInt(this.payload.byteLength);
+        output.writeBytes(new Int8Array(this.payload));
+        output.writeDouble(this.date);
+        return output.toArrayBuffer();
+    }
+    toString() {
+        return `{prevHash: ${Hash.toString(this.prevHash)}, thisHash: ${Hash.toString(this.thisHash)}, payload: ${this.payload.byteLength}bytes}`;
+    }
+}

package/dist/sync-log/SyncLogReader.d.ts

@@ -0,0 +1,12 @@
+import { int } from "@opendaw/lib-std";
+import { Project } from "../Project";
+import { Commit } from "./Commit";
+import { ProjectEnv } from "../ProjectEnv";
+export declare class SyncLogReader {
+    static unwrap(env: ProjectEnv, buffer: ArrayBuffer): Promise<{
+        project: Project;
+        lastCommit: Commit;
+        numCommits: int;
+    }>;
+}
+//# sourceMappingURL=SyncLogReader.d.ts.map

package/dist/sync-log/SyncLogReader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncLogReader.d.ts","sourceRoot":"","sources":["../../src/sync-log/SyncLogReader.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,GAAG,EAAW,MAAM,kBAAkB,CAAA;AAG5E,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,MAAM,EAAa,MAAM,UAAU,CAAA;AAC3C,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAA;AAExC,qBAAa,aAAa;WACT,MAAM,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC;QAC/D,OAAO,EAAE,OAAO,CAAC;QACjB,UAAU,EAAE,MAAM,CAAC;QACnB,UAAU,EAAE,GAAG,CAAA;KAClB,CAAC;CA2CL"}

package/dist/sync-log/SyncLogReader.js

@@ -0,0 +1,51 @@
+import { assert, ByteArrayInput, Hash, tryCatch } from "@opendaw/lib-std";
+import { Updates } from "@opendaw/lib-box";
+import { Wait } from "@opendaw/lib-runtime";
+import { Project } from "../Project";
+import { Commit, CommitType } from "./Commit";
+export class SyncLogReader {
+    static async unwrap(env, buffer) {
+        console.debug("SyncLogReader.unwrapping begin");
+        const input = new ByteArrayInput(buffer);
+        const firstCommit = Commit.deserialize(input);
+        assert(firstCommit.type === CommitType.Init, "First commit must be typed with CommitType.Init");
+        const project = Project.load(env, firstCommit.payload);
+        const { boxGraph } = project;
+        const label = document.createElement("div");
+        label.style.margin = "1em 0";
+        let prevCommit = firstCommit;
+        let lastFrame = Date.now();
+        let numCommits = 0 | 0;
+        while (true) {
+            const { status, error, value: nextCommit } = tryCatch(() => Commit.deserialize(input));
+            numCommits++;
+            label.textContent = `${numCommits} commits unwrapped.`;
+            if (status === "failure") {
+                if (error instanceof RangeError) { // end of log
+                    break;
+                }
+                throw error;
+            }
+            assert(Hash.equals(prevCommit.thisHash, nextCommit.prevHash), "SyncLog inconsistency");
+            // We have not implemented any other types, so let's accept only updates
+            if (nextCommit.type === CommitType.Open) {
+                console.debug("Opened at", new Date(nextCommit.date).toISOString());
+            }
+            else if (nextCommit.type === CommitType.Updates) {
+                const updates = Updates.decode(new ByteArrayInput(nextCommit.payload));
+                boxGraph.beginTransaction();
+                updates.forEach(update => update.forward(boxGraph));
+                boxGraph.endTransaction();
+            }
+            prevCommit = nextCommit;
+            const now = Date.now();
+            if (now - lastFrame > 16) {
+                console.debug("Pause unwrapping to allow browser to render a frame.");
+                await Wait.frame();
+                lastFrame = now;
+            }
+        }
+        console.debug("SyncLogReader.unwrapping complete");
+        return Promise.resolve({ project, lastCommit: prevCommit, numCommits });
+    }
+}

package/dist/sync-log/SyncLogWriter.d.ts

@@ -0,0 +1,10 @@
+import { Observer, Terminable } from "@opendaw/lib-std";
+import { Project } from "../Project";
+import { Commit } from "./Commit";
+export declare class SyncLogWriter implements Terminable {
+    #private;
+    static attach(project: Project, observer: Observer<Commit>, lastCommit?: Commit): SyncLogWriter;
+    private constructor();
+    terminate(): void;
+}
+//# sourceMappingURL=SyncLogWriter.d.ts.map

package/dist/sync-log/SyncLogWriter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SyncLogWriter.d.ts","sourceRoot":"","sources":["../../src/sync-log/SyncLogWriter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAkB,QAAQ,EAAgB,UAAU,EAAC,MAAM,kBAAkB,CAAA;AAEpF,OAAO,EAAC,OAAO,EAAC,MAAM,YAAY,CAAA;AAClC,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAA;AAE/B,qBAAa,aAAc,YAAW,UAAU;;IAC5C,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa;IAW/F,OAAO;IAWP,SAAS,IAAI,IAAI;CA6BpB"}

package/dist/sync-log/SyncLogWriter.js

@@ -0,0 +1,49 @@
+import { isDefined, Terminable } from "@opendaw/lib-std";
+import { Commit } from "./Commit";
+export class SyncLogWriter {
+    static attach(project, observer, lastCommit) {
+        console.debug("SyncLogWriter.attach", project.rootBox.created.getValue(), isDefined(lastCommit) ? "append" : "new");
+        return project.own(new SyncLogWriter(project, observer, lastCommit));
+    }
+    #observer;
+    #subscription;
+    #transactionSubscription = Terminable.Empty;
+    #lastPromise;
+    constructor(project, observer, lastCommit) {
+        this.#observer = observer;
+        this.#lastPromise = Promise.resolve(lastCommit ?? Commit.createFirst(project).then(commit => {
+            this.#observer(commit);
+            return commit;
+        }));
+        this.#appendCommit(previous => Commit.createOpen(previous.thisHash));
+        this.#subscription = this.#listen(project.boxGraph);
+    }
+    terminate() {
+        console.debug("SyncLogWriter.terminate");
+        this.#subscription.terminate();
+    }
+    #appendCommit(factory) {
+        return this.#lastPromise = this.#lastPromise.then(async (previous) => {
+            const commit = await factory(previous);
+            this.#observer(commit);
+            return commit;
+        });
+    }
+    #listen(boxGraph) {
+        let updates = [];
+        return boxGraph.subscribeTransaction({
+            onBeginTransaction: () => this.#transactionSubscription =
+                boxGraph.subscribeToAllUpdatesImmediate({ onUpdate: (update) => updates.push(update) }),
+            onEndTransaction: () => {
+                this.#transactionSubscription.terminate();
+                this.#transactionSubscription = Terminable.Empty;
+                if (updates.length === 0) {
+                    return;
+                }
+                const ref = updates;
+                updates = [];
+                this.#appendCommit(previous => Commit.createUpdate(previous.thisHash, ref));
+            }
+        });
+    }
+}

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@opendaw/studio-core",
+  "version": "0.0.6",
+  "license": "LGPL-3.0-or-later",
+  "publishConfig": {
+    "access": "public"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./engine-processor.js": "./dist/engine-processor.js",
+    "./meter-processor.js": "./dist/meter-processor.js",
+    "./recording-processor.js": "./dist/recording-processor.js"
+  },
+  "files": [
+    "dist/**/*",
+    "dist/engine-processor.js",
+    "dist/meter-processor.js",
+    "dist/recording-processor.js"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "lint": "eslint \"**/*.ts\"",
+    "test": "echo \"No tests to run\""
+  },
+  "dependencies": {
+    "@opendaw/lib-box": "^0.0.6",
+    "@opendaw/lib-dom": "^0.0.6",
+    "@opendaw/lib-dsp": "^0.0.6",
+    "@opendaw/lib-fusion": "^0.0.6",
+    "@opendaw/lib-runtime": "^0.0.6",
+    "@opendaw/lib-std": "^0.0.6",
+    "@opendaw/studio-adapters": "^0.0.6",
+    "@opendaw/studio-boxes": "^0.0.6",
+    "@opendaw/studio-enums": "^0.0.6"
+  },
+  "devDependencies": {
+    "@opendaw/eslint-config": "^0.0.6",
+    "@opendaw/studio-core-processors": "^0.0.6",
+    "@opendaw/studio-forge-boxes": "^0.0.6",
+    "@opendaw/typescript-config": "^0.0.6"
+  },
+  "gitHead": "04e5363a9851c7e116a306c2e933c5f410980fbe"
+}