@opendaw/lib-box 0.0.6

package/dist/editing.js

@@ -0,0 +1,131 @@
+import { Arrays, assert, Option } from "@opendaw/lib-std";
+class EditingStep {
+    updates;
+    constructor(updates) {
+        this.updates = updates;
+    }
+    undo(graph) {
+        for (const update of this.updates.toReversed()) {
+            update.inverse(graph);
+        }
+    }
+    redo(graph) {
+        for (const update of this.updates) {
+            update.forward(graph);
+        }
+    }
+}
+export class Editing {
+    #graph;
+    #pending = [];
+    #history = [];
+    #modifying = false;
+    #historyIndex = 0;
+    constructor(graph) {
+        this.#graph = graph;
+    }
+    get graph() { return this.#graph; }
+    isEmpty() { return this.#history.length === 0 && this.#pending.length === 0; }
+    clear() {
+        assert(!this.#modifying, "Already modifying");
+        Arrays.clear(this.#pending);
+        Arrays.clear(this.#history);
+        this.#historyIndex = 0;
+    }
+    undo() {
+        if (this.#pending.length > 0) {
+            this.mark();
+        }
+        if (this.#historyIndex === 0) {
+            return false;
+        }
+        this.#graph.beginTransaction();
+        const editingStep = this.#history[--this.#historyIndex];
+        editingStep.undo(this.#graph);
+        this.#graph.endTransaction();
+        this.#graph.edges().validateRequirements();
+        return true;
+    }
+    redo() {
+        if (this.#historyIndex === this.#history.length) {
+            return false;
+        }
+        if (this.#pending.length > 0) {
+            console.warn("redo while having pending updates?");
+            return false;
+        }
+        this.#graph.beginTransaction();
+        this.#history[this.#historyIndex++].redo(this.#graph);
+        this.#graph.endTransaction();
+        this.#graph.edges().validateRequirements();
+        return true;
+    }
+    // TODO This is an option to clarify, if user actions meant to be run by a modifier or not.
+    //  See ParameterWrapper. Not the nicest solution. Probably coming back to this sooner or later.
+    canModify() { return !this.#graph.inTransaction(); }
+    modify(modifier, mark = true) {
+        if (this.#modifying) {
+            // we just keep adding new updates to the running modifier
+            return Option.wrap(modifier());
+        }
+        if (mark && this.#pending.length > 0) {
+            this.mark();
+        }
+        const result = Option.wrap(this.#modify(modifier));
+        if (mark) {
+            this.mark();
+        }
+        return result;
+    }
+    beginModification() {
+        this.#graph.beginTransaction();
+        this.#modifying = true;
+        const subscription = this.#graph.subscribeToAllUpdates({
+            onUpdate: (update) => this.#pending.push(update)
+        });
+        const complete = () => {
+            this.#graph.endTransaction();
+            subscription.terminate();
+            this.#modifying = false;
+            this.#graph.edges().validateRequirements();
+        };
+        return {
+            approve: () => { complete(); },
+            revert: () => {
+                this.clearPending();
+                complete();
+            }
+        };
+    }
+    #modify(modifier) {
+        assert(!this.#modifying, "Already modifying");
+        this.#modifying = true;
+        const subscription = this.#graph.subscribeToAllUpdates({
+            onUpdate: (update) => this.#pending.push(update)
+        });
+        this.#graph.beginTransaction();
+        const result = modifier();
+        this.#graph.endTransaction();
+        subscription.terminate();
+        this.#modifying = false;
+        this.#graph.edges().validateRequirements();
+        return result;
+    }
+    mark() {
+        if (this.#pending.length === 0) {
+            return;
+        }
+        if (this.#history.length - this.#historyIndex > 0) {
+            this.#history.splice(this.#historyIndex);
+        }
+        this.#history.push(new EditingStep(this.#pending.splice(0)));
+        this.#historyIndex = this.#history.length;
+    }
+    clearPending() {
+        if (this.#pending.length === 0) {
+            return;
+        }
+        this.#pending.reverse().forEach(update => update.inverse(this.#graph));
+        this.#pending.length = 0;
+    }
+}

package/dist/field.d.ts

@@ -0,0 +1,42 @@
+import { DataInput, DataOutput, Nullish, Option, short } from "@opendaw/lib-std";
+import { Address } from "./address";
+import { Box } from "./box";
+import { PointerRules, Vertex, VertexVisitor } from "./vertex";
+import { PointerTypes } from "./pointer";
+import { PointerHub } from "./pointer-hub";
+import { BoxGraph } from "./graph";
+export type FieldKey = number;
+export type FieldKeys = Readonly<Int16Array>;
+export type Fields = Record<FieldKey, Field>;
+export type FieldConstruct<T extends PointerTypes> = {
+    parent: Vertex;
+    fieldKey: FieldKey;
+    fieldName: string;
+    pointerRules: PointerRules<T>;
+};
+export declare class Field<P extends PointerTypes = PointerTypes, F extends Fields = Fields> implements Vertex<P, F> {
+    #private;
+    static hook<P extends PointerTypes>(construct: FieldConstruct<P>): Field<P, Fields>;
+    protected constructor({ parent, fieldKey, fieldName, pointerRules }: FieldConstruct<P>);
+    accept<RETURN>(visitor: VertexVisitor<RETURN>): Nullish<RETURN>;
+    get box(): Box;
+    get graph(): BoxGraph;
+    get parent(): Vertex;
+    get fieldKey(): short;
+    get fieldName(): string;
+    get pointerRules(): PointerRules<P>;
+    get pointerHub(): PointerHub;
+    get address(): Address;
+    get debugPath(): string;
+    isBox(): this is Box;
+    isField(): this is Field;
+    isAttached(): boolean;
+    fields(): Iterable<Field>;
+    getField(_key: keyof F): F[keyof F];
+    optField(_key: keyof F): Option<F[keyof F]>;
+    read(_input: DataInput): void;
+    write(_output: DataOutput): void;
+    disconnect(): void;
+    toString(): string;
+}
+//# sourceMappingURL=field.d.ts.map

package/dist/field.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field.d.ts","sourceRoot":"","sources":["../src/field.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,UAAU,EAAmB,OAAO,EAAE,MAAM,EAAsB,KAAK,EAAC,MAAM,kBAAkB,CAAA;AACnH,OAAO,EAAC,OAAO,EAAC,MAAM,WAAW,CAAA;AACjC,OAAO,EAAC,GAAG,EAAC,MAAM,OAAO,CAAA;AACzB,OAAO,EAAC,YAAY,EAAE,MAAM,EAAE,aAAa,EAAC,MAAM,UAAU,CAAA;AAC5D,OAAO,EAAC,YAAY,EAAC,MAAM,WAAW,CAAA;AACtC,OAAO,EAAC,UAAU,EAAC,MAAM,eAAe,CAAA;AACxC,OAAO,EAAC,QAAQ,EAAC,MAAM,SAAS,CAAA;AAEhC,MAAM,MAAM,QAAQ,GAAG,MAAM,CAAA;AAC7B,MAAM,MAAM,SAAS,GAAG,QAAQ,CAAC,UAAU,CAAC,CAAA;AAC5C,MAAM,MAAM,MAAM,GAAG,MAAM,CAAC,QAAQ,EAAE,KAAK,CAAC,CAAA;AAC5C,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,YAAY,IAAI;IACjD,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,QAAQ,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,YAAY,EAAE,YAAY,CAAC,CAAC,CAAC,CAAA;CAChC,CAAA;AAED,qBAAa,KAAK,CAAC,CAAC,SAAS,YAAY,GAAG,YAAY,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,YAAW,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;;IACxG,MAAM,CAAC,IAAI,CAAC,CAAC,SAAS,YAAY,EAAE,SAAS,EAAE,cAAc,CAAC,CAAC,CAAC;IAShE,SAAS,aAAa,EAAC,MAAM,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAC,EAAE,cAAc,CAAC,CAAC,CAAC;IASpF,MAAM,CAAC,MAAM,EAAE,OAAO,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAI/D,IAAI,GAAG,IAAI,GAAG,CAA0B;IACxC,IAAI,KAAK,IAAI,QAAQ,CAA4B;IACjD,IAAI,MAAM,IAAI,MAAM,CAAsB;IAC1C,IAAI,QAAQ,IAAI,KAAK,CAAwB;IAC7C,IAAI,SAAS,IAAI,MAAM,CAAyB;IAChD,IAAI,YAAY,IAAI,YAAY,CAAC,CAAC,CAAC,CAA4B;IAE/D,IACI,UAAU,IAAI,UAAU,CAA8B;IAE1D,IACI,OAAO,IAAI,OAAO,CAAqD;IAE3E,IACI,SAAS,IAAI,MAAM,CAEtB;IAED,KAAK,IAAI,IAAI,IAAI,GAAG;IACpB,OAAO,IAAI,IAAI,IAAI,KAAK;IACxB,UAAU,IAAI,OAAO;IACrB,MAAM,IAAI,QAAQ,CAAC,KAAK,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI;IAC7B,KAAK,CAAC,OAAO,EAAE,UAAU,GAAG,IAAI;IAChC,UAAU,IAAI,IAAI;IAUlB,QAAQ,IAAI,MAAM;CACrB"}

package/dist/field.js

@@ -0,0 +1,80 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { Iterables, Lazy, Option, panic, safeExecute } from "@opendaw/lib-std";
+import { Address } from "./address";
+import { PointerHub } from "./pointer-hub";
+export class Field {
+    static hook(construct) {
+        return new Field(construct);
+    }
+    #parent;
+    #fieldKey;
+    #fieldName;
+    #pointerRules;
+    constructor({ parent, fieldKey, fieldName, pointerRules }) {
+        this.#parent = parent;
+        this.#fieldKey = fieldKey;
+        this.#fieldName = fieldName;
+        this.#pointerRules = pointerRules;
+        if (pointerRules.mandatory) {
+            this.graph.edges().watchVertex(this);
+        }
+    }
+    accept(visitor) {
+        return safeExecute(visitor.visitField, this);
+    }
+    get box() { return this.#parent.box; }
+    get graph() { return this.#parent.graph; }
+    get parent() { return this.#parent; }
+    get fieldKey() { return this.#fieldKey; }
+    get fieldName() { return this.#fieldName; }
+    get pointerRules() { return this.#pointerRules; }
+    get pointerHub() { return new PointerHub(this); }
+    get address() { return this.#parent.address.append(this.#fieldKey); }
+    get debugPath() {
+        return `${this.box.name}:${this.box.mapFields(field => field.fieldName, ...this.address.fieldKeys).join("/")}`;
+    }
+    isBox() { return false; }
+    isField() { return true; }
+    isAttached() { return this.graph.findBox(this.address.uuid).nonEmpty(); }
+    fields() { return Iterables.empty(); }
+    getField(_key) { return panic(); }
+    optField(_key) { return Option.None; }
+    read(_input) { }
+    write(_output) { }
+    disconnect() {
+        if (this.pointerHub.isEmpty()) {
+            return;
+        }
+        const incoming = this.pointerHub.incoming();
+        incoming.forEach(pointer => {
+            pointer.defer();
+            if (pointer.mandatory || (this.pointerRules.mandatory && incoming.length === 1)) {
+                pointer.box.delete();
+            }
+        });
+    }
+    toString() { return `{${this.box.constructor.name}:${this.constructor.name} (${this.fieldName}) ${this.address.toString()}`; }
+}
+__decorate([
+    Lazy,
+    __metadata("design:type", PointerHub),
+    __metadata("design:paramtypes", [])
+], Field.prototype, "pointerHub", null);
+__decorate([
+    Lazy,
+    __metadata("design:type", Address),
+    __metadata("design:paramtypes", [])
+], Field.prototype, "address", null);
+__decorate([
+    Lazy,
+    __metadata("design:type", String),
+    __metadata("design:paramtypes", [])
+], Field.prototype, "debugPath", null);

package/dist/graph-edges.d.ts

@@ -0,0 +1,16 @@
+import { PointerField } from "./pointer";
+import { Vertex } from "./vertex";
+import { Box } from "./box";
+export declare class GraphEdges {
+    #private;
+    constructor();
+    watchVertex(vertex: Vertex | PointerField): void;
+    unwatchVerticesOf(...boxes: ReadonlyArray<Box>): void;
+    connect(source: PointerField, target: Vertex): void;
+    disconnect(source: PointerField): void;
+    outgoingEdgesOf(box: Box): ReadonlyArray<[PointerField, Vertex]>;
+    incomingEdgesOf(vertex: Box | Vertex): ReadonlyArray<PointerField>;
+    validateRequirements(): void;
+    verifyPointers(): void;
+}
+//# sourceMappingURL=graph-edges.d.ts.map

package/dist/graph-edges.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-edges.d.ts","sourceRoot":"","sources":["../src/graph-edges.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,YAAY,EAAC,MAAM,WAAW,CAAA;AACtC,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAA;AAC/B,OAAO,EAAC,GAAG,EAAC,MAAM,OAAO,CAAA;AAEzB,qBAAa,UAAU;;;IAanB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI;IAchD,iBAAiB,CAAC,GAAG,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,GAAG,IAAI;IAoBrD,OAAO,CAAC,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAQnD,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAOtC,eAAe,CAAC,GAAG,EAAE,GAAG,GAAG,aAAa,CAAC,CAAC,YAAY,EAAE,MAAM,CAAC,CAAC;IAIhE,eAAe,CAAC,MAAM,EAAE,GAAG,GAAG,MAAM,GAAG,aAAa,CAAC,YAAY,CAAC;IASlE,oBAAoB,IAAI,IAAI;IAqB5B,cAAc,IAAI,IAAI;CAczB"}

package/dist/graph-edges.js

@@ -0,0 +1,109 @@
+import { Arrays, assert, isDefined, isInstanceOf, panic } from "@opendaw/lib-std";
+import { Address } from "./address";
+import { PointerField } from "./pointer";
+export class GraphEdges {
+    #requiresTarget;
+    #requiresPointer;
+    #incoming;
+    #outgoing;
+    constructor() {
+        this.#requiresTarget = Address.newSet(source => source.address);
+        this.#requiresPointer = Address.newSet(vertex => vertex.address);
+        this.#incoming = Address.newSet(([vertex]) => vertex.address);
+        this.#outgoing = Address.newSet(([source]) => source.address);
+    }
+    watchVertex(vertex) {
+        if (isInstanceOf(vertex, PointerField)) {
+            if (!vertex.mandatory) {
+                return panic("watchVertex called but has no edge requirement");
+            }
+            this.#requiresTarget.add(vertex);
+        }
+        else {
+            if (!vertex.pointerRules.mandatory) {
+                return panic("watchVertex called but has no edge requirement");
+            }
+            this.#requiresPointer.add(vertex);
+        }
+    }
+    unwatchVerticesOf(...boxes) {
+        const map = ({ box: { address: { uuid } } }) => uuid;
+        for (const { address: { uuid } } of boxes) {
+            this.#removeSameBox(this.#requiresTarget, uuid, map);
+            this.#removeSameBox(this.#requiresPointer, uuid, map);
+        }
+        for (const box of boxes) {
+            const outgoingLinks = this.outgoingEdgesOf(box);
+            if (outgoingLinks.length > 0) {
+                return panic(`${box} has outgoing edges: ${outgoingLinks.map(([source, target]) => `[${source.toString()}, ${target.toString()}]`)}`);
+            }
+            const incomingPointers = this.incomingEdgesOf(box);
+            if (incomingPointers.length > 0) {
+                return panic(`${box} has incoming edges from: ${incomingPointers.map((source) => source.toString())}`);
+            }
+        }
+    }
+    connect(source, target) {
+        this.#outgoing.add([source, target]);
+        this.#incoming.opt(target.address).match({
+            none: () => this.#incoming.add([target, [source]]),
+            some: ([, sources]) => sources.push(source)
+        });
+    }
+    disconnect(source) {
+        const [, target] = this.#outgoing.removeByKey(source.address);
+        const [, sources] = this.#incoming.get(target.address);
+        Arrays.remove(sources, source);
+        if (sources.length === 0) {
+            this.#incoming.removeByKey(target.address);
+        }
+    }
+    outgoingEdgesOf(box) {
+        return this.#collectSameBox(this.#outgoing, box.address.uuid, ([{ box: { address: { uuid } } }]) => uuid);
+    }
+    incomingEdgesOf(vertex) {
+        if (vertex.isBox()) {
+            return this.#collectSameBox(this.#incoming, vertex.address.uuid, ([{ address: { uuid } }]) => uuid)
+                .flatMap(([_, pointers]) => pointers);
+        }
+        else {
+            return this.#incoming.opt(vertex.address).mapOr(([_, pointers]) => pointers, Arrays.empty());
+        }
+    }
+    validateRequirements() {
+        this.#requiresTarget.forEach(pointer => {
+            if (pointer.isEmpty()) {
+                if (pointer.mandatory) {
+                    return panic(`Pointer ${pointer.toString()} requires an edge.`);
+                }
+                else {
+                    return panic(`Illegal state: ${pointer} has no edge requirements.`);
+                }
+            }
+        });
+        this.#requiresPointer.forEach(target => {
+            if (target.pointerHub.isEmpty()) {
+                if (target.pointerRules.mandatory) {
+                    return panic(`Target ${target.toString()} requires an edge.`);
+                }
+                else {
+                    return panic(`Illegal state: ${target} has no edge requirements.`);
+                }
+            }
+        });
+    }
+    verifyPointers() {
+        this.#requiresTarget.forEach(pointer => assert(pointer.isAttached(), `${pointer.address.toString()} is not attached`));
+        this.#requiresPointer.forEach(pointer => assert(pointer.isAttached(), `${pointer.address.toString()} is not attached`));
+    }
+    #collectSameBox(set, id, map) {
+        const range = Address.boxRange(set, id, map);
+        return isDefined(range) ? set.values().slice(range[0], range[1]) : Arrays.empty();
+    }
+    #removeSameBox(set, id, map) {
+        const range = Address.boxRange(set, id, map);
+        if (isDefined(range)) {
+            set.removeRange(range[0], range[1]);
+        }
+    }
+}

package/dist/graph.d.ts

@@ -0,0 +1,55 @@
+import { Exec, int, Option, Procedure, Subscription, UUID } from "@opendaw/lib-std";
+import { Vertex } from "./vertex";
+import { Box } from "./box";
+import { Address } from "./address";
+import { PointerField } from "./pointer";
+import { PrimitiveField, PrimitiveValues } from "./primitive";
+import { Propagation } from "./dispatchers";
+import { Update } from "./updates";
+import { GraphEdges } from "./graph-edges";
+export type BoxFactory<BoxMap> = (name: keyof BoxMap, graph: BoxGraph<BoxMap>, uuid: UUID.Format, constructor: Procedure<Box>) => Box;
+export interface TransactionListener {
+    onBeginTransaction(): void;
+    onEndTransaction(): void;
+}
+export interface UpdateListener {
+    onUpdate(update: Update): void;
+}
+export type Dependencies = {
+    boxes: Iterable<Box>;
+    pointers: Iterable<PointerField>;
+};
+export declare class BoxGraph<BoxMap = any> {
+    #private;
+    constructor(boxFactory?: Option<BoxFactory<BoxMap>>);
+    beginTransaction(): void;
+    endTransaction(): void;
+    inTransaction(): boolean;
+    constructingBox(): boolean;
+    resolvePointers(): void;
+    createBox(name: keyof BoxMap, uuid: UUID.Format, constructor: Procedure<Box>): void;
+    stageBox<B extends Box>(box: B, constructor?: Procedure<B>): B;
+    subscribeTransaction(listener: TransactionListener): Subscription;
+    subscribeToAllUpdates(listener: UpdateListener): Subscription;
+    subscribeToAllUpdatesImmediate(listener: UpdateListener): Subscription;
+    subscribeVertexUpdates(propagation: Propagation, address: Address, procedure: Procedure<Update>): Subscription;
+    subscribeEndTransaction(observer: Exec): void;
+    unstageBox(box: Box): void;
+    findBox<B extends Box = Box>(uuid: UUID.Format): Option<B>;
+    findVertex(address: Address): Option<Vertex>;
+    boxes(): ReadonlyArray<Box>;
+    edges(): GraphEdges;
+    checksum(): Int8Array;
+    onPrimitiveValueUpdate<V extends PrimitiveValues>(field: PrimitiveField<V, any>, oldValue: V, newValue: V): void;
+    onPointerAddressUpdated(pointerField: PointerField, oldValue: Option<Address>, newValue: Option<Address>): void;
+    dependenciesOf(box: Box): Dependencies;
+    verifyPointers(): {
+        count: int;
+    };
+    debugBoxes(): void;
+    debugDependencies(): void;
+    addressToDebugPath(address: Option<Address>): Option<string>;
+    toArrayBuffer(): ArrayBufferLike;
+    fromArrayBuffer(arrayBuffer: ArrayBuffer): void;
+}
+//# sourceMappingURL=graph.d.ts.map

package/dist/graph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph.d.ts","sourceRoot":"","sources":["../src/graph.ts"],"names":[],"mappings":"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"}