@rljson/db 0.0.8 → 0.0.10

package/dist/db.js

@@ -1,9 +1,93 @@
+import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, isTimeId, getTimeIdTimestamp, createSliceIdsTableCfg, createLayerTableCfg, createCakeTableCfg, createHeadsTableCfg } from "@rljson/rljson";
 import { rmhsh, hsh, Hash, hip } from "@rljson/hash";
 import { equals, merge } from "@rljson/json";
-import { timeId, createInsertHistoryTableCfg, Validate, BaseValidator, Route, isTimeId } from "@rljson/rljson";
 import { IoMem } from "@rljson/io";
 import { traverse } from "object-traversal";
 import { compileExpression } from "filtrex";
+class Connector {
+  constructor(_db, _route, _socket) {
+    this._db = _db;
+    this._route = _route;
+    this._socket = _socket;
+    this._origin = timeId();
+    this._init();
+  }
+  _origin;
+  _callbacks = [];
+  _isListening = false;
+  _sentRefs = /* @__PURE__ */ new Set();
+  _receivedRefs = /* @__PURE__ */ new Set();
+  send(ref) {
+    if (this._sentRefs.has(ref) || this._receivedRefs.has(ref)) return;
+    this._sentRefs.add(ref);
+    this.socket.emit(this.route.flat, {
+      o: this._origin,
+      r: ref
+    });
+  }
+  listen(callback) {
+    this._socket.on(this._route.flat, async (payload) => {
+      try {
+        await callback(payload.r);
+      } catch (error) {
+        console.error("Error in connector listener callback:", error);
+      }
+    });
+  }
+  _init() {
+    this._registerSocketObserver();
+    this._registerDbObserver();
+    this._isListening = true;
+  }
+  teardown() {
+    this._socket.removeAllListeners(this._route.flat);
+    this._db.unregisterAllObservers(this._route);
+    this._isListening = false;
+  }
+  _notifyCallbacks(ref) {
+    Promise.all(this._callbacks.map((cb) => cb(ref))).catch((err) => {
+      console.error(`Error notifying connector callbacks for ref ${ref}:`, err);
+    });
+  }
+  _registerSocketObserver() {
+    this.socket.on(this.route.flat, (p) => {
+      if (p.o === this._origin) {
+        return;
+      }
+      const ref = p.r;
+      if (this._receivedRefs.has(ref)) {
+        return;
+      }
+      this._receivedRefs.add(p.r);
+      this._notifyCallbacks(p.r);
+    });
+  }
+  _registerDbObserver() {
+    this._db.registerObserver(this._route, (ins) => {
+      return new Promise((resolve) => {
+        const ref = ins[this.route.root.tableKey + "Ref"];
+        if (this._sentRefs.has(ref)) {
+          resolve();
+          return;
+        }
+        this.send(ref);
+        resolve();
+      });
+    });
+  }
+  get socket() {
+    return this._socket;
+  }
+  get route() {
+    return this._route;
+  }
+  get origin() {
+    return this._origin;
+  }
+  get isListening() {
+    return this._isListening;
+  }
+}
 class BaseController {
   constructor(_core, _tableKey) {
     this._core = _core;
@@ -217,7 +301,8 @@ class ComponentController extends BaseController {
     "components",
     "edits",
     "editHistory",
-    "multiEdits"
+    "multiEdits",
+    "head"
   ];
   _resolvedColumns = null;
   _refTableKeyToColumnKeyMap = null;
@@ -888,6 +973,7 @@ const createController = async (type, core, tableKey, refs) => {
     case "edits":
     case "editHistory":
     case "multiEdits":
+    case "head":
       ctrl = new ComponentController(core, tableKey, refs);
       break;
     case "cakes":
@@ -950,8 +1036,8 @@ class Core {
    * @returns a dump of a table.
    * @throws when table name does not exist
    */
-  dumpTable(table) {
-    return this._io.dumpTable({ table });
+  async dumpTable(table) {
+    return await this._io.dumpTable({ table });
   }
   // ...........................................................................
   /**
@@ -980,8 +1066,7 @@ class Core {
   }
   // ...........................................................................
   async contentType(table) {
-    const t = await this._io.dumpTable({ table });
-    const contentType = t[table]?._type;
+    const contentType = await this._io.contentType({ table });
     return contentType;
   }
   // ...........................................................................
@@ -1001,12 +1086,12 @@ class Core {
   }
   // ...........................................................................
   /** Reads a specific row from a database table */
-  readRow(table, rowHash) {
-    return this._io.readRows({ table, where: { _hash: rowHash } });
+  async readRow(table, rowHash) {
+    return await this._io.readRows({ table, where: { _hash: rowHash } });
   }
   // ...........................................................................
-  readRows(table, where) {
-    return this._io.readRows({ table, where });
+  async readRows(table, where) {
+    return await this._io.readRows({ table, where });
   }
 }
 const inject = (tree, path, value) => {
@@ -2556,6 +2641,14 @@ class Notify {
     }
   }
   // ...........................................................................
+  /**
+   * Unregisters all callbacks for a specific route.
+   * @param route   The route to unregister all callbacks from.
+   */
+  unregisterAll(route) {
+    this._callbacks.delete(route.flat);
+  }
+  // ...........................................................................
   /**
    * Notifies all registered callbacks for a specific route with the provided edit protocol row.
    * @param route   The route to notify callbacks for.
@@ -2564,9 +2657,12 @@ class Notify {
   notify(route, insertHistoryRow) {
     const callbacks = this._callbacks.get(route.flat);
     if (callbacks) {
-      for (const cb of callbacks) {
-        cb(insertHistoryRow);
-      }
+      Promise.all(callbacks.map((cb) => cb(insertHistoryRow))).catch((err) => {
+        console.error(
+          `Error notifying callbacks for route ${route.flat}:`,
+          err
+        );
+      });
     }
   }
   // ...........................................................................
@@ -3278,9 +3374,13 @@ class Db {
           );
         }
       }
-      if (["components", "edits", "multiEdits"].includes(
-        nodeType
-      )) {
+      if ([
+        "components",
+        "edits",
+        "multiEdits",
+        "editHistory",
+        "head"
+      ].includes(nodeType)) {
         const runFn = runFns[nodeTableKey];
         const components = nodeTree._data;
         for (const component of components) {
@@ -3313,9 +3413,13 @@ class Db {
       }
     } else {
       const runFn = runFns[nodeTableKey];
-      if (["components", "edits", "multiEdits"].includes(
-        nodeType
-      )) {
+      if ([
+        "components",
+        "edits",
+        "multiEdits",
+        "editHistory",
+        "head"
+      ].includes(nodeType)) {
         const components = rmhsh(
           tree[nodeTableKey]
         );
@@ -3387,6 +3491,13 @@ class Db {
     this.notify.unregister(route, callback);
   }
   // ...........................................................................
+  /**
+   * Unregisters all observers from all routes
+   */
+  unregisterAllObservers(route) {
+    this.notify.unregisterAll(route);
+  }
+  // ...........................................................................
   /**
    * Get a controller for a specific table
    * @param tableKey - The key of the table to get the controller for
@@ -3435,6 +3546,116 @@ class Db {
     });
   }
   // ...........................................................................
+  /**
+   * Add a head revision for a cake
+   * @param cakeKey - The cake table key
+   * @param cakeRef - The cake reference
+   */
+  async addHeadRevision(cakeKey, cakeRef) {
+    const cakeHeadKey = cakeKey + "Heads";
+    const cakeHeadController = await this.getController(cakeHeadKey);
+    return await cakeHeadController.insert("add", {
+      cakeRef,
+      timeId: timeId(),
+      _hash: ""
+    });
+  }
+  // ...........................................................................
+  /**
+   * Add a multiEdit
+   * @param cakeKey - The cake table key
+   * @param multiEdit - The multiEdit to add
+   */
+  async addMultiEdit(cakeKey, multiEdit) {
+    return this.insert(
+      Route.fromFlat(cakeKey + "MultiEdits"),
+      {
+        [cakeKey + "MultiEdits"]: {
+          _data: [multiEdit],
+          _type: "multiEdits"
+        }
+      },
+      { skipHistory: true }
+    );
+  }
+  // ...........................................................................
+  /**
+   * Get multiEdits
+   * @param cakeKey - The cake table key
+   * @param where - The where clause to filter multiEdits
+   */
+  async getMultiEdits(cakeKey, where) {
+    const multiEditController = await this.getController(
+      cakeKey + "MultiEdits"
+    );
+    const { [cakeKey + "MultiEdits"]: result } = await multiEditController.get(
+      where
+    );
+    return result._data;
+  }
+  // ...........................................................................
+  /**
+   * Add an edit
+   * @param cakeKey - The cake table key
+   * @param edit - The edit to add
+   */
+  async addEdit(cakeKey, edit) {
+    return this.insert(
+      Route.fromFlat(cakeKey + "Edits"),
+      {
+        [cakeKey + "Edits"]: {
+          _data: [edit],
+          _type: "edits"
+        }
+      },
+      { skipHistory: true }
+    );
+  }
+  // ...........................................................................
+  /**
+   * Get edits
+   * @param cakeKey - The cake table key
+   * @param where - The where clause to filter edits
+   */
+  async getEdits(cakeKey, where) {
+    const editController = await this.getController(cakeKey + "Edits");
+    const { [cakeKey + "Edits"]: result } = await editController.get(where);
+    return result._data;
+  }
+  // ...........................................................................
+  /**
+   * Add an edit history entry
+   * @param cakeKey - The cake table key
+   * @param editHistory - The edit history entry to add
+   */
+  async addEditHistory(cakeKey, editHistory) {
+    return this.insert(
+      Route.fromFlat(cakeKey + "EditHistory"),
+      {
+        [cakeKey + "EditHistory"]: {
+          _data: [editHistory],
+          _type: "editHistory"
+        }
+      },
+      { skipHistory: true }
+    );
+  }
+  // ...........................................................................
+  /**
+   * Get edit history entries
+   * @param cakeKey - The cake table key
+   * @param where - The where clause to filter edit history entries
+   */
+  async getEditHistories(cakeKey, where) {
+    const editHistoryController = await this.getController(
+      cakeKey + "EditHistory"
+    );
+    const { [cakeKey + "EditHistory"]: result } = await editHistoryController.get(where);
+    return result._data.sort(
+      (h1, h2) => getTimeIdTimestamp(h2.timeId) - getTimeIdTimestamp(h1.timeId)
+    );
+  }
+  // ...........................................................................
   /**
    * Get the InsertHistory of a table
    * @param table - The table to get the InsertHistory for
@@ -3581,13 +3802,2073 @@ class Db {
     return result;
   }
   // ...........................................................................
+  /**
+   * Clone the Db instance with a new Io instance
+   * @param io - The new Io instance
+   * @returns A new Db instance with the same cache as the current instance
+   */
+  clone(io) {
+    const newDb = new Db(io);
+    newDb.setCache(new Map(this._cache));
+    return newDb;
+  }
+  // ...........................................................................
   /**
    * Get the current cache of the Db instance
    */
   get cache() {
     return this._cache;
   }
+  // ...........................................................................
+  /**
+   * Set the cache of the Db instance
+   * @param cache - The new cache to set
+   */
+  setCache(cache) {
+    this._cache = cache;
+  }
+}
+const exampleEditActionColumnSelection = () => ({
+  name: "Car Selection",
+  type: "selection",
+  data: {
+    columns: ColumnSelection.exampleCarsColumnSelection().columns
+  },
+  _hash: ""
+});
+const exampleEditActionColumnSelectionOnlySomeColumns = () => ({
+  name: "Car Selection - Some Columns",
+  type: "selection",
+  data: {
+    columns: ColumnSelection.exampleCarsColumnSelectionOnlySomeColumns().columns
+  },
+  _hash: ""
+});
+const exampleEditActionRowFilter = () => ({
+  name: "Electric Cars Filter",
+  type: "filter",
+  data: {
+    columnFilters: [
+      {
+        type: "boolean",
+        column: "carCake/carGeneralLayer/carGeneral/isElectric",
+        operator: "equals",
+        search: true,
+        _hash: ""
+      },
+      {
+        type: "number",
+        column: "carCake/carTechnicalLayer/carTechnical/carDimensions/length",
+        operator: "greaterThan",
+        search: 4e3,
+        _hash: ""
+      }
+    ],
+    operator: "and",
+    value: true,
+    _hash: ""
+  },
+  _hash: ""
+});
+const exampleEditActionSetValue = () => ({
+  name: "Set: Service Intervals to [15000, 30000, 45000, 60000]",
+  type: "setValue",
+  data: {
+    route: "carCake/carGeneralLayer/carGeneral/serviceIntervals",
+    value: [15e3, 3e4, 45e3, 6e4],
+    _hash: ""
+  },
+  _hash: ""
+});
+const exampleEditSetValueReferenced = () => ({
+  name: "Set: Length to 4200",
+  type: "setValue",
+  data: {
+    route: "carCake/carTechnicalLayer/carTechnical/carDimensions/length",
+    value: 4800,
+    _hash: ""
+  },
+  _hash: ""
+});
+const exampleEditActionRowSort = () => ({
+  name: "Sort By Brand Edit",
+  type: "sort",
+  data: {
+    ["carCake/carGeneralLayer/carGeneral/brand"]: "asc"
+  },
+  _hash: ""
+});
+class RowSort {
+  constructor(columnSorts) {
+    this._columnSorts = this._initColumnSorts(columnSorts);
+  }
+  // ...........................................................................
+  /**
+   * Sorts the rows of a join according to the sort configuration.
+   * @param join - The join to be sorted
+   * @returns Returns the row indices in a sorted manner
+   */
+  applyTo(join) {
+    if (join.rowCount === 0) {
+      return join.rowIndices;
+    }
+    this._throwOnWrongRoutes(join);
+    const routeHashes = join.columnSelection.routeHashes;
+    const sortIndices = [];
+    const sortOrders = [];
+    let hasSorts = false;
+    for (const item of this._columnSorts) {
+      const index = routeHashes.indexOf(item.routeHash);
+      sortIndices.push(index);
+      sortOrders.push(item.order);
+      hasSorts = true;
+    }
+    if (!hasSorts) {
+      return join.rowIndices;
+    }
+    return this._sortRows(join, sortIndices, sortOrders);
+  }
+  // ...........................................................................
+  /* v8 ignore next -- @preserve */
+  get columnSorts() {
+    const result = {};
+    for (const sort of this._columnSorts) {
+      result[sort.route] = sort.order;
+    }
+    return result;
+  }
+  // ######################
+  // Private
+  // ######################
+  _columnSorts;
+  // ...........................................................................
+  _initColumnSorts(columnSorts) {
+    const result = [];
+    const columns = Object.keys(columnSorts);
+    const columnSelection = ColumnSelection.fromRoutes(
+      columns.map((c) => Route.fromFlat(c))
+    );
+    const routes = columnSelection.routes;
+    const routeHashes = columnSelection.routeHashes;
+    for (let i = 0; i < routes.length; i++) {
+      const route = routes[i];
+      const routeHash = routeHashes[i];
+      result.push({
+        route,
+        routeHash,
+        order: columnSorts[route]
+      });
+    }
+    return result;
+  }
+  // ...........................................................................
+  _sortRows(join, sortIndices, sortOrders) {
+    const result = [...join.rowIndices];
+    return result.sort((a, b) => {
+      const rowA = join.row(a);
+      const rowB = join.row(b);
+      let i = 0;
+      for (const index of sortIndices) {
+        const sort = sortOrders[i++];
+        const rowAInsertValues = rowA[index].inserts ? Array.isArray(rowA[index].inserts[0].cell[0].value) ? rowA[index].inserts[0].cell[0].value : [rowA[index].inserts[0].cell[0].value] : null;
+        const rowAValue = rowA[index].value.cell[0].value ? Array.isArray(rowA[index].value?.cell[0].value) ? rowA[index].value.cell[0].value : [rowA[index].value.cell[0].value] : null;
+        const rowBInsertValues = rowB[index].inserts ? Array.isArray(rowB[index].inserts[0].cell[0].value) ? rowB[index].inserts[0].cell[0].value : [rowB[index].inserts[0].cell[0].value] : null;
+        const rowBValue = rowB[index].value.cell[0].value ? Array.isArray(rowB[index].value?.cell[0].value) ? rowB[index].value.cell[0].value : [rowB[index].value.cell[0].value] : null;
+        const vA = rowAInsertValues && rowAInsertValues[0] ? rowAInsertValues[0] : rowAValue ? rowAValue[0] : null;
+        const vB = rowBInsertValues && rowBInsertValues[0] ? rowBInsertValues[0] : rowBValue ? rowBValue[0] : null;
+        if (vA === vB) {
+          continue;
+        }
+        if (sort === "asc") {
+          return vA < vB ? -1 : 1;
+        } else {
+          return vA < vB ? 1 : -1;
+        }
+      }
+      return 0;
+    });
+  }
+  // ...........................................................................
+  _throwOnWrongRoutes(join) {
+    const availableRoutes = join.columnSelection.routes;
+    for (const item of Object.values(this._columnSorts)) {
+      const route = item.route;
+      if (availableRoutes.includes(route) === false) {
+        throw new Error(
+          `RowFilterProcessor: Error while applying sort to join: There is a sort entry for route "${route}", but the join does not have a column with this route.
+
+Available routes:
+${availableRoutes.map((a) => `- ${a}`).join("\n")}`
+        );
+      }
+    }
+  }
+}
+class MultiEditProcessor {
+  constructor(_db, _cakeKey, _cakeRef) {
+    this._db = _db;
+    this._cakeKey = _cakeKey;
+    this._cakeRef = _cakeRef;
+  }
+  _multiEdit = null;
+  _edits = [];
+  _join = null;
+  //...........................................................................
+  /**
+   * Create MultiEditProcessor from EditHistory
+   * @param db - Db instance
+   * @param cakeKey - Cake key
+   * @param editHistory - EditHistory
+   * @returns MultiEditProcessor
+   */
+  static async fromEditHistory(db, cakeKey, editHistory) {
+    if (!editHistory || !editHistory.multiEditRef) {
+      throw new Error("MultiEditProcessor: Invalid EditHistory provided.");
+    }
+    const cakeRef = editHistory.dataRef;
+    const multiEdits = await db.getMultiEdits(
+      cakeKey,
+      editHistory.multiEditRef
+    );
+    if (!multiEdits || multiEdits.length === 0) {
+      throw new Error(
+        `MultiEditProcessor: MultiEdit not found for ref ${editHistory.multiEditRef}`
+      );
+    }
+    if (multiEdits.length > 1) {
+      throw new Error(
+        `MultiEditProcessor: Multiple MultiEdits found for ref ${editHistory.multiEditRef}`
+      );
+    }
+    const multiEdit = multiEdits[0];
+    return MultiEditProcessor.fromMultiEdit(db, cakeKey, cakeRef, multiEdit);
+  }
+  //...........................................................................
+  /**
+   * Create MultiEditProcessor from MultiEdit
+   * @param db - Db instance
+   * @param cakeKey - Cake key
+   * @param cakeRef - Cake ref
+   * @param multiEdit - MultiEdit
+   * @returns MultiEditProcessor
+   */
+  static async fromMultiEdit(db, cakeKey, cakeRef, multiEdit) {
+    const processor = new MultiEditProcessor(db, cakeKey, cakeRef);
+    await processor._resolve(multiEdit);
+    await processor._processAll();
+    return processor;
+  }
+  get join() {
+    if (!this._join) {
+      throw new Error("MultiEditProcessor: Join not processed yet.");
+    }
+    return this._join;
+  }
+  get multiEdit() {
+    if (!this._multiEdit) {
+      throw new Error("MultiEditProcessor: MultiEdit not resolved yet.");
+    }
+    return this._multiEdit;
+  }
+  get cakeRef() {
+    return this._cakeRef;
+  }
+  //...........................................................................
+  /**
+   * Apply an Edit to the MultiEditProcessor
+   * @param edit - Edit to apply
+   * @returns MultiEditProcessor
+   */
+  async edit(edit) {
+    this._edits.push(edit);
+    this._join = await this._process(edit);
+    this._multiEdit = hip({
+      _hash: "",
+      edit: edit._hash,
+      previous: this.multiEdit ? this.multiEdit._hash : null
+    });
+    return this;
+  }
+  async applyEditHistory(editHistory) {
+    if (!editHistory || !editHistory.multiEditRef) {
+      throw new Error("MultiEditProcessor: Invalid EditHistory provided.");
+    }
+    const multiEdits = await this._db.getMultiEdits(
+      this._cakeKey,
+      editHistory.multiEditRef
+    );
+    if (!multiEdits || multiEdits.length === 0) {
+      throw new Error(
+        `MultiEditProcessor: MultiEdit not found for ref ${editHistory.multiEditRef}`
+      );
+    }
+    if (multiEdits.length > 1) {
+      throw new Error(
+        `MultiEditProcessor: Multiple MultiEdits found for ref ${editHistory.multiEditRef}`
+      );
+    }
+    const multiEdit = multiEdits[0];
+    await this._resolve(multiEdit);
+    await this._processAll();
+    return this;
+  }
+  //...........................................................................
+  /**
+   * Publish the MultiEditProcessor. Inserts the resulting Join as new data,
+   * updates the head revision, and saves the resulting MultiEdit.
+   * @param options - Publish options
+   * @returns MultiEditProcessor
+   */
+  async publish(options) {
+    const inserts = this.join.insert();
+    if (inserts.length === 0) {
+      throw new Error("MultiEditProcessor: No inserts to publish.");
+    }
+    if (inserts.length > 1) {
+      throw new Error(
+        "MultiEditProcessor: Multiple inserts not supported yet."
+      );
+    }
+    const insert = inserts[0];
+    const inserteds = await this._db.insert(insert.route, insert.tree);
+    if (inserteds.length === 0) {
+      throw new Error("MultiEditProcessor: No rows inserted.");
+    }
+    if (inserteds.length > 1) {
+      throw new Error(
+        "MultiEditProcessor: Multiple inserted rows not supported yet."
+      );
+    }
+    const inserted = inserteds[0];
+    const writtenCakeRef = inserted[this._cakeKey + "Ref"];
+    if (!options?.skipHeadUpdate) {
+      await this._db.addHeadRevision(this._cakeKey, writtenCakeRef);
+    }
+    if (!options?.skipSaveMultiEdit) {
+      await this._db.addMultiEdit(this._cakeKey, this._multiEdit);
+    }
+    return new MultiEditProcessor(this._db, this._cakeKey, writtenCakeRef);
+  }
+  //...........................................................................
+  /**
+   * Clone the MultiEditProcessor
+   * @returns Cloned MultiEditProcessor
+   */
+  clone() {
+    const clone = new MultiEditProcessor(
+      this._db,
+      this._cakeKey,
+      this._cakeRef
+    );
+    clone._multiEdit = this._multiEdit;
+    clone._edits = [...this._edits];
+    clone._join = this._join;
+    return clone;
+  }
+  //...........................................................................
+  /**
+   * Resolve MultiEdit chain recursively
+   * @param multiEdit - MultiEdit to resolve
+   * @returns Promise<void>
+   */
+  async _resolve(multiEdit) {
+    this._multiEdit = multiEdit;
+    const edits = await this._db.getEdits(this._cakeKey, multiEdit.edit);
+    if (edits.length === 0) {
+      throw new Error(
+        `MultiEditProcessor: Edit not found for ref ${multiEdit.edit}`
+      );
+    }
+    if (edits.length > 1) {
+      throw new Error(
+        `MultiEditProcessor: Multiple Edits found for ref ${multiEdit.edit}`
+      );
+    }
+    const edit = edits[0];
+    this._edits.push(edit);
+    if (multiEdit.previous) {
+      const previousMultiEdits = await this._db.getMultiEdits(
+        this._cakeKey,
+        multiEdit.previous
+      );
+      const previousMultiEdit = previousMultiEdits[0];
+      return this._resolve(previousMultiEdit);
+    }
+  }
+  //...........................................................................
+  /**
+   * Process all Edits in the MultiEditProcessor
+   * @returns Resulting Join
+   */
+  async _processAll() {
+    for (let i = this._edits.length - 1; i >= 0; i--) {
+      const edit = this._edits[i];
+      this._join = await this._process(edit);
+    }
+    return this._join;
+  }
+  //...........................................................................
+  /**
+   * Process a single Edit and update the Join
+   * @param edit - Edit to process
+   * @returns Resulting Join
+   */
+  async _process(edit) {
+    const action = edit.action;
+    if (!this._join) {
+      switch (action.type) {
+        case "selection":
+          const editColInfos = edit.action.data.columns;
+          const editColSelection = new ColumnSelection(editColInfos);
+          this._join = await this._db.join(
+            editColSelection,
+            this._cakeKey,
+            this._cakeRef
+          );
+          break;
+        case "setValue":
+          const editSetValue = edit.action.data;
+          const editSetValueKey = Route.fromFlat(editSetValue.route).segment().tableKey;
+          const editSetValueColumnInfo = {
+            key: editSetValueKey,
+            route: editSetValue.route,
+            alias: editSetValueKey,
+            titleLong: "",
+            titleShort: "",
+            type: "jsonValue",
+            _hash: ""
+          };
+          const editSetValueColSelection = new ColumnSelection([
+            editSetValueColumnInfo
+          ]);
+          this._join = (await this._db.join(
+            editSetValueColSelection,
+            this._cakeKey,
+            this._cakeRef
+          )).setValue(editSetValue);
+          break;
+        case "sort":
+          const editRowSort = rmhsh(edit).action.data;
+          const editRowSortColumnInfos = [];
+          for (const routeStr of Object.keys(editRowSort)) {
+            const route = Route.fromFlat(routeStr);
+            const tableKey = route.segment().tableKey;
+            const columnInfo = {
+              key: tableKey,
+              route: routeStr,
+              alias: tableKey,
+              titleLong: "",
+              titleShort: "",
+              type: "jsonValue",
+              _hash: ""
+            };
+            editRowSortColumnInfos.push(columnInfo);
+          }
+          const editRowSortColSelection = new ColumnSelection(
+            editRowSortColumnInfos
+          );
+          this._join = (await this._db.join(
+            editRowSortColSelection,
+            this._cakeKey,
+            this._cakeRef
+          )).sort(new RowSort(editRowSort));
+          break;
+        case "filter":
+          const editRowFilter = edit.action.data;
+          const editRowFilterColumnInfos = [];
+          for (const colFilter of editRowFilter.columnFilters) {
+            const route = Route.fromFlat(colFilter.column);
+            const tableKey = route.segment().tableKey;
+            const columnInfo = {
+              key: tableKey,
+              route: colFilter.column,
+              alias: tableKey,
+              titleLong: "",
+              titleShort: "",
+              type: "jsonValue",
+              _hash: ""
+            };
+            editRowFilterColumnInfos.push(columnInfo);
+          }
+          const editRowFilterColSelection = new ColumnSelection(
+            editRowFilterColumnInfos
+          );
+          this._join = (await this._db.join(
+            editRowFilterColSelection,
+            this._cakeKey,
+            this._cakeRef
+          )).filter(editRowFilter);
+          break;
+      }
+    } else {
+      switch (action.type) {
+        case "selection":
+          const editColInfos = edit.action.data.columns;
+          const editColSelection = new ColumnSelection(editColInfos);
+          this._join = this._join.select(editColSelection);
+          break;
+        case "setValue":
+          const editSetValue = rmhsh(
+            edit.action.data
+          );
+          this._join = this._join.setValue(editSetValue);
+          break;
+        case "sort":
+          const editRowSort = rmhsh(
+            edit.action.data
+          );
+          this._join = this._join.sort(new RowSort(editRowSort));
+          break;
+        case "filter":
+          const editRowFilter = rmhsh(
+            edit.action.data
+          );
+          this._join = this._join.filter(editRowFilter);
+          break;
+      }
+    }
+    return this._join;
+  }
 }
+class MultiEditManager {
+  constructor(_cakeKey, _db) {
+    this._cakeKey = _cakeKey;
+    this._db = _db;
+  }
+  _head = null;
+  _headListener = [];
+  _processors = /* @__PURE__ */ new Map();
+  _isListening = false;
+  init() {
+    const editHistoryKey = `${this._cakeKey}EditHistory`;
+    this._db.registerObserver(
+      Route.fromFlat(editHistoryKey),
+      (ins) => {
+        const editHistoryRef = ins[editHistoryKey + "Ref"];
+        return this.editHistoryRef(editHistoryRef);
+      }
+    );
+    this._isListening = true;
+  }
+  tearDown() {
+    const editHistoryKey = `${this._cakeKey}EditHistory`;
+    this._db.unregisterAllObservers(Route.fromFlat(editHistoryKey));
+    this._isListening = false;
+  }
+  async edit(edit, cakeRef) {
+    if (!this.head && !cakeRef) {
+      throw new Error(
+        "No head MultiEditProcessor available. Provide a cakeRef."
+      );
+    }
+    if (this.head && cakeRef) {
+      throw new Error(
+        "Head MultiEditProcessor already exists. Do not provide a cakeRef."
+      );
+    }
+    await this._persistEdit(edit);
+    let multiEditProc;
+    if (!this.head) {
+      const multiEdit = {
+        _hash: "",
+        edit: hsh(edit)._hash,
+        previous: null
+      };
+      await this._persistMultiEdit(multiEdit);
+      multiEditProc = await MultiEditProcessor.fromMultiEdit(
+        this._db,
+        this._cakeKey,
+        cakeRef,
+        multiEdit
+      );
+    } else {
+      multiEditProc = await this.head.processor.edit(edit);
+    }
+    const multiEditRef = await this._persistMultiEdit(multiEditProc.multiEdit);
+    const editHistoryRef = await this._persistEditHistory({
+      _hash: "",
+      dataRef: multiEditProc.cakeRef,
+      multiEditRef: await multiEditRef,
+      timeId: timeId(),
+      previous: !!this.head && this.head.editHistoryRef ? [this.head.editHistoryRef] : null
+    });
+    this._processors.set(editHistoryRef, multiEditProc);
+    this._head = {
+      editHistoryRef,
+      processor: multiEditProc
+    };
+    await this._notifyHeadListener(editHistoryRef);
+  }
+  async publish() {
+    if (!this.head) {
+      throw new Error("No head MultiEditProcessor available.");
+    }
+    return await this.head.processor.publish();
+  }
+  listenToHeadChanges(callback) {
+    this._headListener.push(callback);
+  }
+  _notifyHeadListener(editHistoryRef) {
+    return Promise.all(
+      this._headListener.map((cb) => cb(editHistoryRef))
+    ).catch((err) => {
+      console.error(
+        `Error notifying head observers for editHistoryRef ${editHistoryRef}:`,
+        err
+      );
+    });
+  }
+  async editHistoryRef(editHistoryRef) {
+    const editHistories = await this._db.getEditHistories(
+      this._cakeKey,
+      editHistoryRef
+    );
+    if (editHistories.length === 0) {
+      throw new Error(`EditHistory with ref ${editHistoryRef} not found.`);
+    }
+    if (editHistories.length > 1) {
+      throw new Error(
+        `Multiple EditHistories with ref ${editHistoryRef} found.`
+      );
+    }
+    const editHistory = editHistories[0];
+    if (this._processors.has(editHistoryRef)) {
+      const processor2 = this._processors.get(editHistoryRef);
+      this._head = {
+        editHistoryRef,
+        processor: processor2
+      };
+      await this._notifyHeadListener(editHistoryRef);
+      return processor2;
+    }
+    if (editHistory.previous && editHistory.previous.length > 0) {
+      if (editHistory.previous.length > 1) {
+        throw new Error(
+          `EditHistory with ref ${editHistoryRef} has multiple previous refs. Not supported.`
+        );
+      }
+      const previousEditHistoryRef = editHistory.previous[0];
+      const previousProcessor = await this.editHistoryRef(
+        previousEditHistoryRef
+      );
+      const previousProcessorCloned = previousProcessor.clone();
+      const processor2 = await previousProcessorCloned.applyEditHistory(
+        editHistory
+      );
+      this._processors.set(editHistoryRef, processor2);
+      this._head = {
+        editHistoryRef,
+        processor: processor2
+      };
+      await this._notifyHeadListener(editHistoryRef);
+      return processor2;
+    }
+    const processor = await MultiEditProcessor.fromEditHistory(
+      this._db,
+      this._cakeKey,
+      editHistory
+    );
+    this._processors.set(editHistoryRef, processor);
+    this._head = {
+      editHistoryRef,
+      processor
+    };
+    await this._notifyHeadListener(editHistoryRef);
+    return processor;
+  }
+  async _persistEdit(edit) {
+    const { [this._cakeKey + "EditsRef"]: editRef } = (await this._db.addEdit(this._cakeKey, edit))[0];
+    if (!editRef) {
+      throw new Error("MultiEditManager: Failed to create EditRef.");
+    }
+    return editRef;
+  }
+  async _persistMultiEdit(multiEdit) {
+    const { [this._cakeKey + "MultiEditsRef"]: multiEditRef } = (await this._db.addMultiEdit(this._cakeKey, multiEdit))[0];
+    if (!multiEditRef) {
+      throw new Error("MultiEditManager: Failed to create MultiEditRef.");
+    }
+    return multiEditRef;
+  }
+  async _persistEditHistory(editHistory) {
+    const { [this._cakeKey + "EditHistoryRef"]: editHistoryRef } = (await this._db.addEditHistory(this._cakeKey, editHistory))[0];
+    if (!editHistoryRef) {
+      throw new Error("MultiEditManager: Failed to create EditHistoryRef.");
+    }
+    return editHistoryRef;
+  }
+  get processors() {
+    return this._processors;
+  }
+  get head() {
+    return this._head;
+  }
+  get join() {
+    if (!this.head) {
+      throw new Error("No head MultiEditProcessor available.");
+    }
+    return this.head.processor.join;
+  }
+  get isListening() {
+    return this._isListening;
+  }
+}
+const chainLayers = (layers) => {
+  const chainedLayers = [];
+  for (let i = 0; i < layers.length; i++) {
+    const newLayer = { ...rmhsh(layers[i]) };
+    if (i == 0) {
+      chainedLayers.push(hsh(newLayer));
+      continue;
+    }
+    if (chainedLayers[i - 1]._hash) {
+      newLayer.base = chainedLayers[i - 1]._hash;
+    }
+    chainedLayers.push(hsh(newLayer));
+  }
+  return chainedLayers;
+};
+const chainSliceIds = (sliceIds) => {
+  const chainedSliceIds = [];
+  for (let i = 0; i < sliceIds.length; i++) {
+    const newSliceIds = { ...rmhsh(sliceIds[i]) };
+    if (i == 0) {
+      chainedSliceIds.push(hsh(newSliceIds));
+      continue;
+    }
+    if (chainedSliceIds[i - 1]._hash) {
+      newSliceIds.base = chainedSliceIds[i - 1]._hash;
+    }
+    chainedSliceIds.push(hsh(newSliceIds));
+  }
+  return chainedSliceIds;
+};
+const staticExample = () => {
+  const carSliceIdTableCfg = hip(
+    createSliceIdsTableCfg("carSliceId")
+  );
+  const carSliceIdData = [
+    {
+      add: ["VIN1", "VIN2", "VIN3", "VIN4", "VIN5", "VIN6", "VIN7", "VIN8"],
+      _hash: ""
+    },
+    {
+      add: ["VIN9", "VIN10"],
+      _hash: ""
+    },
+    {
+      add: ["VIN11", "VIN12"],
+      _hash: ""
+    }
+  ].map((sliceIds) => hsh(sliceIds));
+  const carSliceId = hip({
+    _tableCfg: carSliceIdTableCfg._hash,
+    _type: "sliceIds",
+    _data: chainSliceIds(carSliceIdData),
+    _hash: ""
+  });
+  const carGeneralTableCfg = hip({
+    key: "carGeneral",
+    type: "components",
+    columns: [
+      { key: "_hash", type: "string", titleLong: "Hash", titleShort: "Hash" },
+      { key: "brand", type: "string", titleLong: "Brand", titleShort: "Brand" },
+      { key: "type", type: "string", titleLong: "Type", titleShort: "Type" },
+      { key: "doors", type: "number", titleLong: "Doors", titleShort: "Doors" },
+      {
+        key: "energyConsumption",
+        type: "number",
+        titleLong: "Energy Consumption",
+        titleShort: "Energy"
+      },
+      {
+        key: "units",
+        type: "json",
+        titleLong: "Energy Unit",
+        titleShort: "Unit"
+      },
+      {
+        key: "serviceIntervals",
+        type: "jsonArray",
+        titleLong: "Service Intervals",
+        titleShort: "Intervals"
+      },
+      {
+        key: "isElectric",
+        type: "boolean",
+        titleLong: "Is Electric",
+        titleShort: "Electric"
+      },
+      {
+        key: "meta",
+        type: "jsonValue",
+        titleLong: "Meta Information",
+        titleShort: "Meta"
+      }
+    ],
+    isHead: false,
+    isRoot: false,
+    isShared: true
+  });
+  const carGeneral = hip({
+    _tableCfg: carGeneralTableCfg._hash,
+    _type: "components",
+    _data: [
+      {
+        brand: "Volkswagen",
+        type: "Polo",
+        doors: 5,
+        energyConsumption: 7.4,
+        units: {
+          energy: "l/100km",
+          _hash: ""
+        },
+        serviceIntervals: [15e3, 3e4, 45e3],
+        isElectric: false,
+        meta: {
+          pressText: "A popular compact car.",
+          _hash: ""
+        },
+        _hash: ""
+      },
+      {
+        brand: "Volkswagen",
+        type: "Golf",
+        doors: 3,
+        energyConsumption: 6.2,
+        units: {
+          energy: "l/100km",
+          _hash: ""
+        },
+        serviceIntervals: [15e3, 3e4, 45e3],
+        isElectric: false,
+        meta: {
+          pressText: "A well-known hatchback.",
+          _hash: ""
+        },
+        _hash: ""
+      },
+      {
+        brand: "Audi",
+        type: "Q4 E-tron",
+        doors: 5,
+        energyConsumption: 18,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [2e4, 4e4, 6e4],
+        isElectric: true,
+        meta: [
+          {
+            pressText: "A stylish electric SUV.",
+            _hash: ""
+          },
+          {
+            pressText: "Combines performance with sustainability.",
+            _hash: ""
+          }
+        ],
+        _hash: ""
+      },
+      {
+        brand: "Audi",
+        type: "Q6 E-tron",
+        doors: 5,
+        energyConsumption: 16,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [2e4, 4e4, 6e4],
+        isElectric: true,
+        meta: [
+          {
+            pressText: "A premium electric SUV with advanced features.",
+            _hash: ""
+          },
+          {
+            pressText: "Offers a blend of luxury and eco-friendliness.",
+            _hash: ""
+          }
+        ],
+        _hash: ""
+      },
+      {
+        brand: "BMW",
+        type: "i4",
+        doors: 5,
+        energyConsumption: 19.5,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [2e4, 4e4, 6e4],
+        isElectric: true,
+        meta: [
+          {
+            pressText: "A sporty electric sedan.",
+            _hash: ""
+          },
+          {
+            pressText: "Delivers dynamic performance with zero emissions.",
+            _hash: ""
+          }
+        ],
+        _hash: ""
+      },
+      {
+        brand: "BMW",
+        type: "3 Series",
+        doors: 4,
+        energyConsumption: 5.8,
+        units: {
+          energy: "l/100km",
+          _hash: ""
+        },
+        serviceIntervals: [15e3, 3e4, 45e3],
+        isElectric: false,
+        meta: {
+          pressText: "A classic executive car.",
+          _hash: ""
+        },
+        _hash: ""
+      },
+      {
+        brand: "Tesla",
+        type: "Model 3",
+        doors: 4,
+        energyConsumption: 15,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [25e3, 5e4, 75e3],
+        isElectric: true,
+        meta: {
+          pressText: "A revolutionary electric sedan.",
+          _hash: ""
+        },
+        _hash: ""
+      },
+      {
+        brand: "Tesla",
+        type: "Model Y",
+        doors: 5,
+        energyConsumption: 16.5,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [25e3, 5e4, 75e3],
+        isElectric: true,
+        meta: {
+          pressText: "A versatile electric SUV.",
+          _hash: ""
+        },
+        _hash: ""
+      },
+      {
+        brand: "Ford",
+        type: "Mustang Mach-E",
+        doors: 5,
+        energyConsumption: 17,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [2e4, 4e4, 6e4],
+        isElectric: true,
+        meta: {
+          pressText: "An electric SUV with Mustang heritage.",
+          _hash: ""
+        },
+        _hash: ""
+      },
+      {
+        brand: "Chevrolet",
+        type: "Bolt EV",
+        doors: 5,
+        energyConsumption: 14,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [2e4, 4e4, 6e4],
+        isElectric: true,
+        meta: {
+          pressText: "An affordable electric hatchback.",
+          _hash: ""
+        },
+        _hash: ""
+      },
+      {
+        brand: "Nissan",
+        type: "Leaf",
+        doors: 5,
+        energyConsumption: 15.5,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [2e4, 4e4, 6e4],
+        isElectric: true,
+        meta: {
+          pressText: "A pioneering electric vehicle.",
+          _hash: ""
+        },
+        _hash: ""
+      },
+      {
+        brand: "Hyundai",
+        type: "Kona Electric",
+        doors: 5,
+        energyConsumption: 14.5,
+        units: {
+          energy: "kWh/100km",
+          _hash: ""
+        },
+        serviceIntervals: [2e4, 4e4, 6e4],
+        isElectric: true,
+        meta: {
+          pressText: "A compact electric SUV.",
+          _hash: ""
+        },
+        _hash: ""
+      }
+    ],
+    _hash: ""
+  });
+  const carDimensionsTableCfg = hip({
+    key: "carDimensions",
+    type: "components",
+    columns: [
+      { key: "_hash", type: "string" },
+      { key: "height", type: "number" },
+      { key: "width", type: "number" },
+      { key: "length", type: "number" }
+    ],
+    isHead: false,
+    isRoot: false,
+    isShared: true
+  });
+  const carDimensions = hip({
+    _tableCfg: carDimensionsTableCfg._hash,
+    _type: "components",
+    _data: [
+      {
+        height: 1400,
+        width: 1800,
+        length: 4e3,
+        _hash: ""
+      },
+      {
+        height: 1450,
+        width: 1850,
+        length: 4100,
+        _hash: ""
+      },
+      {
+        height: 1600,
+        width: 1900,
+        length: 4500,
+        _hash: ""
+      },
+      {
+        height: 1650,
+        width: 1950,
+        length: 4700,
+        _hash: ""
+      },
+      {
+        height: 1500,
+        width: 1820,
+        length: 4200,
+        _hash: ""
+      },
+      {
+        height: 1550,
+        width: 1880,
+        length: 4300,
+        _hash: ""
+      },
+      {
+        height: 1450,
+        width: 1830,
+        length: 4150,
+        _hash: ""
+      },
+      {
+        height: 1700,
+        width: 2e3,
+        length: 4800,
+        _hash: ""
+      },
+      {
+        height: 1350,
+        width: 1750,
+        length: 3900,
+        _hash: ""
+      },
+      {
+        height: 1750,
+        width: 2050,
+        length: 4900,
+        _hash: ""
+      },
+      {
+        height: 1600,
+        width: 1920,
+        length: 4600,
+        _hash: ""
+      }
+    ],
+    _hash: ""
+  });
+  const carTechnicalTableCfg = hip({
+    key: "carTechnical",
+    type: "components",
+    columns: [
+      { key: "_hash", type: "string" },
+      { key: "engine", type: "string" },
+      { key: "transmission", type: "string" },
+      { key: "gears", type: "number" },
+      {
+        key: "dimensions",
+        type: "jsonValue",
+        ref: {
+          tableKey: "carDimensions",
+          type: "components"
+        }
+      },
+      { key: "repairedByWorkshop", type: "string" }
+    ],
+    isHead: false,
+    isRoot: false,
+    isShared: true
+  });
+  const carTechnical = hip({
+    _tableCfg: carTechnicalTableCfg._hash,
+    _type: "components",
+    _data: [
+      {
+        engine: "Diesel",
+        transmission: "Manual",
+        gears: 6,
+        dimensions: carDimensions._data[0]._hash,
+        _hash: ""
+      },
+      {
+        engine: "Petrol",
+        transmission: "Automatic",
+        gears: 7,
+        dimensions: carDimensions._data[1]._hash,
+        repairedByWorkshop: "Workshop A",
+        _hash: ""
+      },
+      {
+        engine: "Electric",
+        transmission: "Single-Speed",
+        gears: 1,
+        dimensions: [
+          carDimensions._data[1]._hash,
+          carDimensions._data[2]._hash
+        ],
+        _hash: ""
+      },
+      {
+        engine: "Electric",
+        transmission: "Single-Speed",
+        gears: 1,
+        dimensions: carDimensions._data[3]._hash,
+        repairedByWorkshop: "Workshop B",
+        _hash: ""
+      },
+      {
+        engine: "Electric",
+        transmission: "Single-Speed",
+        gears: 1,
+        dimensions: carDimensions._data[4]._hash,
+        _hash: ""
+      },
+      {
+        engine: "Petrol",
+        transmission: "Manual",
+        gears: 6,
+        dimensions: carDimensions._data[5]._hash,
+        repairedByWorkshop: "Workshop A",
+        _hash: ""
+      },
+      {
+        engine: "Electric",
+        transmission: "Single-Speed",
+        gears: 1,
+        dimensions: carDimensions._data[6]._hash,
+        _hash: ""
+      },
+      {
+        engine: "Electric",
+        transmission: "Single-Speed",
+        gears: 1,
+        dimensions: carDimensions._data[7]._hash,
+        repairedByWorkshop: "Workshop C",
+        _hash: ""
+      },
+      {
+        engine: "Electric",
+        transmission: "Single-Speed",
+        gears: 1,
+        dimensions: carDimensions._data[8]._hash,
+        _hash: ""
+      },
+      {
+        engine: "Electric",
+        transmission: "Single-Speed",
+        gears: 1,
+        dimensions: carDimensions._data[9]._hash,
+        repairedByWorkshop: "Workshop B",
+        _hash: ""
+      },
+      {
+        engine: "Electric",
+        transmission: "Single-Speed",
+        gears: 1,
+        dimensions: carDimensions._data[10]._hash,
+        _hash: ""
+      }
+    ],
+    _hash: ""
+  });
+  const carColorTableCfg = hip({
+    key: "carColor",
+    type: "components",
+    columns: [
+      { key: "_hash", type: "string" },
+      { key: "sides", type: "string" },
+      { key: "roof", type: "string" },
+      { key: "highlights", type: "string" }
+    ],
+    isHead: false,
+    isRoot: false,
+    isShared: true
+  });
+  const carColor = hip({
+    _tableCfg: carColorTableCfg._hash,
+    _type: "components",
+    _data: [
+      {
+        sides: "green",
+        roof: "white",
+        highlights: "chrome",
+        _hash: ""
+      },
+      {
+        sides: "blue",
+        roof: "black",
+        highlights: "chrome",
+        _hash: ""
+      },
+      {
+        sides: "red",
+        roof: "red",
+        highlights: "black",
+        _hash: ""
+      },
+      {
+        sides: "silver",
+        roof: "silver",
+        highlights: "chrome",
+        _hash: ""
+      },
+      {
+        sides: "black",
+        roof: "black",
+        highlights: "black",
+        _hash: ""
+      },
+      {
+        sides: "white",
+        roof: "white",
+        highlights: "chrome",
+        _hash: ""
+      },
+      {
+        sides: "grey",
+        roof: "black",
+        highlights: "chrome",
+        _hash: ""
+      },
+      {
+        sides: "red",
+        roof: "white",
+        highlights: "black",
+        _hash: ""
+      }
+    ],
+    _hash: ""
+  });
+  const carGeneralLayerTableCfg = hip(
+    createLayerTableCfg("carGeneralLayer")
+  );
+  const carGeneralLayerData = [
+    {
+      add: {
+        VIN1: carGeneral._data[0]._hash,
+        VIN2: carGeneral._data[1]._hash,
+        VIN3: carGeneral._data[2]._hash,
+        VIN4: carGeneral._data[3]._hash,
+        VIN5: carGeneral._data[4]._hash,
+        VIN6: carGeneral._data[5]._hash,
+        VIN7: carGeneral._data[6]._hash,
+        VIN8: carGeneral._data[7]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[0]._hash,
+      componentsTable: "carGeneral",
+      _hash: ""
+    },
+    {
+      add: {
+        VIN9: carGeneral._data[8]._hash,
+        VIN10: carGeneral._data[9]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[1]._hash,
+      componentsTable: "carGeneral",
+      _hash: ""
+    },
+    {
+      add: {
+        VIN11: carGeneral._data[10]._hash,
+        VIN12: carGeneral._data[11]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[2]._hash,
+      componentsTable: "carGeneral",
+      _hash: ""
+    }
+  ].map((layer) => hsh(layer));
+  const carGeneralLayer = hip({
+    _tableCfg: carGeneralLayerTableCfg._hash,
+    _type: "layers",
+    _data: chainLayers(carGeneralLayerData),
+    _hash: ""
+  });
+  const carTechnicalLayerTableCfg = hip(
+    createLayerTableCfg("carTechnicalLayer")
+  );
+  const carTechnicalLayerData = [
+    {
+      add: {
+        VIN1: carTechnical._data[0]._hash,
+        VIN2: carTechnical._data[1]._hash,
+        VIN3: carTechnical._data[2]._hash,
+        VIN4: carTechnical._data[2]._hash,
+        VIN5: carTechnical._data[4]._hash,
+        VIN6: carTechnical._data[5]._hash,
+        VIN7: carTechnical._data[6]._hash,
+        VIN8: carTechnical._data[2]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[0]._hash,
+      componentsTable: "carTechnical",
+      _hash: ""
+    },
+    {
+      add: {
+        VIN9: carTechnical._data[7]._hash,
+        VIN10: carTechnical._data[8]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[1]._hash,
+      componentsTable: "carTechnical",
+      _hash: ""
+    },
+    {
+      add: {
+        VIN11: carTechnical._data[9]._hash,
+        VIN12: carTechnical._data[10]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[2]._hash,
+      componentsTable: "carTechnical",
+      _hash: ""
+    }
+  ].map((layer) => hsh(layer));
+  const carTechnicalLayer = hip({
+    _tableCfg: carTechnicalLayerTableCfg._hash,
+    _type: "layers",
+    _data: chainLayers(carTechnicalLayerData),
+    _hash: ""
+  });
+  const carColorLayerTableCfg = hip(
+    createLayerTableCfg("carColorLayer")
+  );
+  const carColorLayerData = [
+    {
+      add: {
+        VIN1: carColor._data[0]._hash,
+        VIN2: carColor._data[1]._hash,
+        VIN3: carColor._data[2]._hash,
+        VIN4: carColor._data[3]._hash,
+        VIN5: carColor._data[4]._hash,
+        VIN6: carColor._data[5]._hash,
+        VIN7: carColor._data[6]._hash,
+        VIN8: carColor._data[7]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[0]._hash,
+      componentsTable: "carColor",
+      _hash: ""
+    },
+    {
+      add: {
+        VIN9: carColor._data[3]._hash,
+        VIN10: carColor._data[3]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[1]._hash,
+      componentsTable: "carColor",
+      _hash: ""
+    },
+    {
+      add: {
+        VIN11: carColor._data[7]._hash,
+        VIN12: carColor._data[4]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "carSliceId",
+      sliceIdsTableRow: carSliceId._data[2]._hash,
+      componentsTable: "carColor",
+      _hash: ""
+    }
+  ].map((layer) => hsh(layer));
+  const carColorLayer = hip({
+    _tableCfg: carColorLayerTableCfg._hash,
+    _type: "layers",
+    _data: chainLayers(carColorLayerData),
+    _hash: ""
+  });
+  const carCakeTableCfg = hip(
+    createCakeTableCfg("carCake")
+  );
+  const carCake = hip({
+    _tableCfg: carCakeTableCfg._hash,
+    _type: "cakes",
+    _data: [
+      {
+        sliceIdsTable: "carSliceId",
+        sliceIdsRow: carSliceId._data[0]._hash,
+        layers: {
+          carGeneralLayer: carGeneralLayer._data[0]._hash,
+          carTechnicalLayer: carTechnicalLayer._data[0]._hash,
+          carColorLayer: carColorLayer._data[0]._hash
+        }
+      },
+      {
+        sliceIdsTable: "carSliceId",
+        sliceIdsRow: carSliceId._data[1]._hash,
+        layers: {
+          carGeneralLayer: carGeneralLayer._data[1]._hash,
+          carTechnicalLayer: carTechnicalLayer._data[1]._hash,
+          carColorLayer: carColorLayer._data[1]._hash
+        }
+      },
+      {
+        sliceIdsTable: "carSliceId",
+        sliceIdsRow: carSliceId._data[2]._hash,
+        layers: {
+          carGeneralLayer: carGeneralLayer._data[2]._hash,
+          carTechnicalLayer: carTechnicalLayer._data[2]._hash,
+          carColorLayer: carColorLayer._data[2]._hash
+        }
+      }
+    ]
+  });
+  const carCakeHeadTableCfg = hip(
+    createHeadsTableCfg("carCake")
+  );
+  const carCakeHeads = hip({
+    _tableCfg: carCakeHeadTableCfg._hash,
+    _type: "head",
+    _data: [
+      {
+        timeId: "1764756756311:jkCG",
+        cakeRef: carCake._data[0]._hash
+      },
+      {
+        timeId: "1764756756312:1AGV",
+        cakeRef: carCake._data[1]._hash
+      },
+      {
+        timeId: "1764756756312:g8nh",
+        cakeRef: carCake._data[2]._hash
+      }
+    ]
+  });
+  const seriesSliceIdTableCfg = hip(
+    createSliceIdsTableCfg("seriesSliceId")
+  );
+  const seriesSliceIdData = [
+    {
+      add: ["Serie0", "Serie1", "Serie2", "Serie3"],
+      _hash: ""
+    },
+    {
+      add: ["Serie4", "Serie5", "Serie6", "Serie7"],
+      _hash: ""
+    },
+    {
+      add: ["Serie8", "Serie9", "Serie10", "Serie11"],
+      _hash: ""
+    }
+  ].map((sliceIds) => hsh(sliceIds));
+  const seriesSliceId = hip({
+    _tableCfg: seriesSliceIdTableCfg._hash,
+    _type: "sliceIds",
+    _data: chainSliceIds(seriesSliceIdData),
+    _hash: ""
+  });
+  const seriesGeneralTableCfg = hip({
+    key: "seriesGeneral",
+    type: "components",
+    columns: [
+      { key: "_hash", type: "string", titleShort: "Hash", titleLong: "Hash" },
+      { key: "name", type: "string", titleShort: "Name", titleLong: "Name" }
+    ],
+    isHead: false,
+    isRoot: false,
+    isShared: true
+  });
+  const seriesGeneral = hip({
+    _tableCfg: seriesGeneralTableCfg._hash,
+    _type: "components",
+    _data: [
+      {
+        name: "Polo",
+        _hash: ""
+      },
+      {
+        name: "Golf",
+        _hash: ""
+      },
+      {
+        name: "Q4",
+        _hash: ""
+      },
+      {
+        name: "Q6",
+        _hash: ""
+      },
+      {
+        name: "i4",
+        _hash: ""
+      },
+      {
+        name: "3",
+        _hash: ""
+      },
+      {
+        name: "Model 3",
+        _hash: ""
+      },
+      {
+        name: "Model Y",
+        _hash: ""
+      },
+      {
+        name: "Mustang",
+        _hash: ""
+      },
+      {
+        name: "Bolt",
+        _hash: ""
+      },
+      {
+        name: "Leaf",
+        _hash: ""
+      },
+      {
+        name: "Kona",
+        _hash: ""
+      }
+    ],
+    _hash: ""
+  });
+  const seriesCarsTableCfg = hip({
+    key: "seriesCars",
+    type: "components",
+    columns: [
+      { key: "_hash", type: "string", titleShort: "Hash", titleLong: "Hash" },
+      {
+        key: "cars",
+        type: "jsonArray",
+        titleShort: "Cars",
+        titleLong: "Cars References",
+        ref: {
+          tableKey: "carCake",
+          type: "cakes"
+        }
+      }
+    ],
+    isHead: false,
+    isRoot: false,
+    isShared: true
+  });
+  const seriesCars = hip({
+    _tableCfg: seriesCarsTableCfg._hash,
+    _type: "components",
+    _data: [
+      {
+        cars: [
+          {
+            ref: carCake._data[2]._hash,
+            sliceIds: ["VIN1"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[2]._hash,
+            sliceIds: ["VIN2"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[0]._hash,
+            sliceIds: ["VIN3"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[0]._hash,
+            sliceIds: ["VIN4"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[1]._hash,
+            sliceIds: ["VIN5"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[1]._hash,
+            sliceIds: ["VIN6"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[2]._hash,
+            sliceIds: ["VIN7"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[2]._hash,
+            sliceIds: ["VIN8"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[2]._hash,
+            sliceIds: ["VIN9"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[2]._hash,
+            sliceIds: ["VIN10"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[2]._hash,
+            sliceIds: ["VIN11"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        cars: [
+          {
+            ref: carCake._data[2]._hash,
+            sliceIds: ["VIN12"]
+          }
+        ],
+        _hash: ""
+      }
+    ],
+    _hash: ""
+  });
+  const seriesGeneralLayerTableCfg = hip(
+    createLayerTableCfg("seriesGeneralLayer")
+  );
+  const seriesGeneralLayerData = [
+    {
+      add: {
+        Serie0: seriesGeneral._data[0]._hash,
+        Serie1: seriesGeneral._data[1]._hash,
+        Serie2: seriesGeneral._data[2]._hash,
+        Serie3: seriesGeneral._data[3]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "seriesSliceId",
+      sliceIdsTableRow: seriesSliceId._data[0]._hash,
+      componentsTable: "seriesGeneral",
+      _hash: ""
+    },
+    {
+      add: {
+        Serie4: seriesGeneral._data[4]._hash,
+        Serie5: seriesGeneral._data[5]._hash,
+        Serie6: seriesGeneral._data[6]._hash,
+        Serie7: seriesGeneral._data[7]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "seriesSliceId",
+      sliceIdsTableRow: seriesSliceId._data[1]._hash,
+      componentsTable: "seriesGeneral",
+      _hash: ""
+    },
+    {
+      add: {
+        Serie8: seriesGeneral._data[8]._hash,
+        Serie9: seriesGeneral._data[9]._hash,
+        Serie10: seriesGeneral._data[10]._hash,
+        Serie11: seriesGeneral._data[11]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "seriesSliceId",
+      sliceIdsTableRow: seriesSliceId._data[2]._hash,
+      componentsTable: "seriesGeneral",
+      _hash: ""
+    }
+  ].map((layer) => hsh(layer));
+  const seriesGeneralLayer = hip({
+    _tableCfg: seriesGeneralLayerTableCfg._hash,
+    _type: "layers",
+    _data: chainLayers(seriesGeneralLayerData),
+    _hash: ""
+  });
+  const seriesCarsLayerTableCfg = hip(
+    createLayerTableCfg("seriesCarsLayer")
+  );
+  const seriesCarsLayerData = [
+    {
+      add: {
+        Serie0: seriesCars._data[0]._hash,
+        Serie1: seriesCars._data[1]._hash,
+        Serie2: seriesCars._data[2]._hash,
+        Serie3: seriesCars._data[3]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "seriesSliceId",
+      sliceIdsTableRow: seriesSliceId._data[0]._hash,
+      componentsTable: "seriesCars",
+      _hash: ""
+    },
+    {
+      add: {
+        Serie4: seriesCars._data[4]._hash,
+        Serie5: seriesCars._data[5]._hash,
+        Serie6: seriesCars._data[6]._hash,
+        Serie7: seriesCars._data[7]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "seriesSliceId",
+      sliceIdsTableRow: seriesSliceId._data[1]._hash,
+      componentsTable: "seriesCars",
+      _hash: ""
+    },
+    {
+      add: {
+        Serie8: seriesCars._data[8]._hash,
+        Serie9: seriesCars._data[9]._hash,
+        Serie10: seriesCars._data[10]._hash,
+        Serie11: seriesCars._data[11]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "seriesSliceId",
+      sliceIdsTableRow: seriesSliceId._data[2]._hash,
+      componentsTable: "seriesCars",
+      _hash: ""
+    }
+  ].map((layer) => hsh(layer));
+  const seriesCarsLayer = hip({
+    _tableCfg: seriesCarsLayerTableCfg._hash,
+    _type: "layers",
+    _data: chainLayers(seriesCarsLayerData)
+  });
+  const seriesCakeTableCfg = hip(
+    createCakeTableCfg("seriesCake")
+  );
+  const seriesCake = hip({
+    _tableCfg: seriesCakeTableCfg._hash,
+    _type: "cakes",
+    _data: [
+      {
+        sliceIdsTable: "seriesSliceId",
+        sliceIdsRow: seriesSliceId._data[0]._hash,
+        layers: {
+          seriesGeneralLayer: seriesGeneralLayer._data[0]._hash,
+          seriesCarsLayer: seriesCarsLayer._data[0]._hash
+        }
+      },
+      {
+        sliceIdsTable: "seriesSliceId",
+        sliceIdsRow: seriesSliceId._data[1]._hash,
+        layers: {
+          seriesGeneralLayer: seriesGeneralLayer._data[1]._hash,
+          seriesCarsLayer: seriesCarsLayer._data[1]._hash
+        }
+      },
+      {
+        sliceIdsTable: "seriesSliceId",
+        sliceIdsRow: seriesSliceId._data[2]._hash,
+        layers: {
+          seriesGeneralLayer: seriesGeneralLayer._data[2]._hash,
+          seriesCarsLayer: seriesCarsLayer._data[2]._hash
+        }
+      }
+    ]
+  });
+  const seriesCakeHeadTableCfg = hip(
+    createHeadsTableCfg("seriesCake")
+  );
+  const seriesCakeHeads = hip({
+    _tableCfg: seriesCakeHeadTableCfg._hash,
+    _type: "head",
+    _data: [
+      {
+        timeId: "1764756756315:L14y",
+        cakeRef: seriesCake._data[0]._hash
+      },
+      {
+        timeId: "1764756756315:xCXT",
+        cakeRef: seriesCake._data[1]._hash
+      },
+      {
+        timeId: "1764756756315:fZwA",
+        cakeRef: seriesCake._data[2]._hash
+      }
+    ]
+  });
+  const catalogSliceIdTableCfg = hip(
+    createSliceIdsTableCfg("catalogSliceId")
+  );
+  const catalogSliceIdData = [
+    {
+      add: ["Catalog0", "Catalog1"],
+      _hash: ""
+    }
+  ].map((sliceIds) => hsh(sliceIds));
+  const catalogSliceId = hip({
+    _tableCfg: catalogSliceIdTableCfg._hash,
+    _type: "sliceIds",
+    _data: chainSliceIds(catalogSliceIdData),
+    _hash: ""
+  });
+  const catalogSeriesTableCfg = hip({
+    key: "catalogSeries",
+    type: "components",
+    columns: [
+      { key: "_hash", type: "string", titleShort: "Hash", titleLong: "Hash" },
+      {
+        key: "series",
+        type: "jsonArray",
+        titleShort: "Series",
+        titleLong: "Series References",
+        ref: {
+          tableKey: "seriesCake",
+          type: "cakes"
+        }
+      }
+    ],
+    isHead: false,
+    isRoot: false,
+    isShared: true
+  });
+  const catalogSeries = hip({
+    _tableCfg: catalogSeriesTableCfg._hash,
+    _type: "components",
+    _data: [
+      {
+        series: [
+          {
+            ref: seriesCake._data[0]._hash,
+            sliceIds: ["Serie0", "Serie1", "Serie2", "Serie3"]
+          },
+          {
+            ref: seriesCake._data[1]._hash,
+            sliceIds: ["Serie4", "Serie5", "Serie6", "Serie7"]
+          }
+        ],
+        _hash: ""
+      },
+      {
+        series: [
+          {
+            ref: seriesCake._data[2]._hash
+          }
+        ],
+        _hash: ""
+      }
+    ],
+    _hash: ""
+  });
+  const catalogSeriesLayerTableCfg = hip(
+    createLayerTableCfg("catalogSeriesLayer")
+  );
+  const catalogSeriesLayerData = [
+    {
+      add: {
+        Catalog0: catalogSeries._data[0]._hash,
+        Catalog1: catalogSeries._data[1]._hash,
+        _hash: ""
+      },
+      sliceIdsTable: "catalogSliceId",
+      sliceIdsTableRow: catalogSliceId._data[0]._hash,
+      componentsTable: "catalogSeries",
+      _hash: ""
+    }
+  ].map((layer) => hsh(layer));
+  const catalogSeriesLayer = hip({
+    _tableCfg: catalogSeriesLayerTableCfg._hash,
+    _type: "layers",
+    _data: chainLayers(catalogSeriesLayerData),
+    _hash: ""
+  });
+  const catalogCakeTableCfg = hip(
+    createCakeTableCfg("catalogCake")
+  );
+  const catalogCake = hip({
+    _tableCfg: catalogCakeTableCfg._hash,
+    _type: "cakes",
+    _data: [
+      {
+        sliceIdsTable: "catalogSliceId",
+        sliceIdsRow: catalogSliceId._data[0]._hash,
+        layers: {
+          catalogSeriesLayer: catalogSeriesLayer._data[0]._hash
+        }
+      }
+    ]
+  });
+  const catalogCakeHeadTableCfg = hip(
+    createHeadsTableCfg("catalogCake")
+  );
+  const catalogCakeHeads = hip({
+    _tableCfg: catalogCakeHeadTableCfg._hash,
+    _type: "head",
+    _data: [
+      {
+        timeId: "1764756756317:5UTy",
+        cakeRef: catalogCake._data[0]._hash
+      }
+    ]
+  });
+  const tableCfgs = {
+    _data: [
+      carSliceIdTableCfg,
+      carGeneralTableCfg,
+      carDimensionsTableCfg,
+      carTechnicalTableCfg,
+      carColorTableCfg,
+      carGeneralLayerTableCfg,
+      carTechnicalLayerTableCfg,
+      carColorLayerTableCfg,
+      carCakeTableCfg,
+      carCakeHeadTableCfg,
+      seriesSliceIdTableCfg,
+      seriesGeneralTableCfg,
+      seriesCarsTableCfg,
+      seriesGeneralLayerTableCfg,
+      seriesCarsLayerTableCfg,
+      seriesCakeTableCfg,
+      seriesCakeHeadTableCfg,
+      catalogSliceIdTableCfg,
+      catalogSeriesTableCfg,
+      catalogSeriesLayerTableCfg,
+      catalogCakeTableCfg,
+      catalogCakeHeadTableCfg
+    ]
+  };
+  const staticExample2 = {
+    carSliceId,
+    carGeneral,
+    carDimensions,
+    carTechnical,
+    carColor,
+    carGeneralLayer,
+    carTechnicalLayer,
+    carColorLayer,
+    carCake,
+    carCakeHeads,
+    seriesSliceId,
+    seriesGeneral,
+    seriesCars,
+    seriesGeneralLayer,
+    seriesCarsLayer,
+    seriesCake,
+    seriesCakeHeads,
+    catalogSliceId,
+    catalogSeries,
+    catalogSeriesLayer,
+    catalogCake,
+    catalogCakeHeads,
+    tableCfgs
+  };
+  return staticExample2;
+};
 export {
-  Db as RljsonDb
+  Connector,
+  Db,
+  Join,
+  MultiEditManager,
+  exampleEditActionColumnSelection,
+  exampleEditActionColumnSelectionOnlySomeColumns,
+  exampleEditActionRowFilter,
+  exampleEditActionRowSort,
+  exampleEditActionSetValue,
+  exampleEditSetValueReferenced,
+  staticExample
 };
+//# sourceMappingURL=db.js.map