@rljson/db 0.0.8 → 0.0.10

package/dist/edit/edit-action.d.ts

@@ -0,0 +1,53 @@
+import { EditAction } from '@rljson/rljson';
+import { RowFilter } from '../join/filter/row-filter.ts';
+import { ColumnInfo } from '../join/selection/column-selection.ts';
+import { SetValue } from '../join/set-value/set-value.ts';
+import { RowSortType } from '../join/sort/row-sort.ts';
+export interface EditActionColumnSelection extends EditAction {
+    type: 'selection';
+    data: {
+        columns: ColumnInfo[];
+    };
+}
+export interface EditActionRowFilter extends EditAction {
+    type: 'filter';
+    data: RowFilter;
+}
+export interface EditActionSetValue extends EditAction {
+    type: 'setValue';
+    data: SetValue;
+}
+export interface EditActionRowSort extends EditAction {
+    type: 'sort';
+    data: RowSortType;
+}
+/**
+ * Example EditAction of type 'selection'
+ * @returns An example EditAction representing a column selection
+ */
+export declare const exampleEditActionColumnSelection: () => EditActionColumnSelection;
+/**
+ * Example EditAction of type 'selection' with only some columns
+ * @returns An example EditAction representing a column selection with limited columns
+ */
+export declare const exampleEditActionColumnSelectionOnlySomeColumns: () => EditActionColumnSelection;
+/**
+ * Example EditAction of type 'filter'
+ * @returns An example EditAction representing a row filter
+ */
+export declare const exampleEditActionRowFilter: () => EditActionRowFilter;
+/**
+ * Example EditAction of type 'setValue'
+ * @returns An example EditAction representing a set value action
+ */
+export declare const exampleEditActionSetValue: () => EditActionSetValue;
+/**
+ * Example EditAction of type 'setValue' for a referenced column
+ * @returns An example EditAction representing a set value action for a referenced column
+ */
+export declare const exampleEditSetValueReferenced: () => EditActionSetValue;
+/**
+ * Example EditAction of type 'sort'
+ * @returns An example EditAction representing a row sort action
+ */
+export declare const exampleEditActionRowSort: () => EditActionRowSort;

package/dist/edit/edit.d.ts

@@ -0,0 +1,23 @@
+import { Edit } from '@rljson/rljson';
+import { EditActionColumnSelection, EditActionRowFilter, EditActionRowSort, EditActionSetValue } from './edit-action.ts';
+export interface EditColumnSelection extends Edit {
+    name: string;
+    action: EditActionColumnSelection;
+    _hash: string;
+}
+export interface EditRowFilter extends Edit {
+    name: string;
+    action: EditActionRowFilter;
+    _hash: string;
+}
+export interface EditSetValue extends Edit {
+    name: string;
+    action: EditActionSetValue;
+    _hash: string;
+}
+export interface EditRowSort extends Edit {
+    name: string;
+    action: EditActionRowSort;
+    _hash: string;
+}
+export declare const exampleEditColumnSelection: () => Edit;

package/dist/edit/multi-edit-manager.d.ts

@@ -0,0 +1,30 @@
+import { Edit } from '@rljson/rljson';
+import { Db } from '../db.ts';
+import { Join } from '../join/join.ts';
+import { MultiEditProcessor } from './multi-edit-processor.ts';
+export declare class MultiEditManager {
+    private readonly _cakeKey;
+    private readonly _db;
+    private _head;
+    private _headListener;
+    private _processors;
+    private _isListening;
+    constructor(_cakeKey: string, _db: Db);
+    init(): void;
+    tearDown(): void;
+    edit(edit: Edit, cakeRef?: string): Promise<void>;
+    publish(): Promise<MultiEditProcessor>;
+    listenToHeadChanges(callback: (editHistoryRef: string) => Promise<void>): void;
+    private _notifyHeadListener;
+    editHistoryRef(editHistoryRef: string): Promise<MultiEditProcessor>;
+    private _persistEdit;
+    private _persistMultiEdit;
+    private _persistEditHistory;
+    get processors(): Map<string, MultiEditProcessor>;
+    get head(): {
+        editHistoryRef: string;
+        processor: MultiEditProcessor;
+    } | null;
+    get join(): Join;
+    get isListening(): boolean;
+}

package/dist/edit/multi-edit-processor.d.ts

@@ -0,0 +1,75 @@
+import { Edit, EditHistory, MultiEdit } from '@rljson/rljson';
+import { Db } from '../db.ts';
+import { Join, JoinRowsHashed } from '../join/join.ts';
+import { ColumnSelection } from '../join/selection/column-selection.ts';
+export type MultiEditColumnSelection = ColumnSelection;
+export type MultiEditRowHashed = JoinRowsHashed;
+export type MultiEditRows = any[][];
+export declare class MultiEditProcessor {
+    private readonly _db;
+    private readonly _cakeKey;
+    private readonly _cakeRef;
+    private _multiEdit;
+    private _edits;
+    private _join;
+    constructor(_db: Db, _cakeKey: string, _cakeRef: string);
+    /**
+     * Create MultiEditProcessor from EditHistory
+     * @param db - Db instance
+     * @param cakeKey - Cake key
+     * @param editHistory - EditHistory
+     * @returns MultiEditProcessor
+     */
+    static fromEditHistory(db: Db, cakeKey: string, editHistory: EditHistory): Promise<MultiEditProcessor>;
+    /**
+     * Create MultiEditProcessor from MultiEdit
+     * @param db - Db instance
+     * @param cakeKey - Cake key
+     * @param cakeRef - Cake ref
+     * @param multiEdit - MultiEdit
+     * @returns MultiEditProcessor
+     */
+    static fromMultiEdit(db: Db, cakeKey: string, cakeRef: string, multiEdit: MultiEdit): Promise<MultiEditProcessor>;
+    get join(): Join;
+    get multiEdit(): MultiEdit;
+    get cakeRef(): string;
+    /**
+     * Apply an Edit to the MultiEditProcessor
+     * @param edit - Edit to apply
+     * @returns MultiEditProcessor
+     */
+    edit(edit: Edit): Promise<MultiEditProcessor>;
+    applyEditHistory(editHistory: EditHistory): Promise<MultiEditProcessor>;
+    /**
+     * 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
+     */
+    publish(options?: {
+        skipHeadUpdate?: boolean;
+        skipSaveMultiEdit?: boolean;
+    }): Promise<MultiEditProcessor>;
+    /**
+     * Clone the MultiEditProcessor
+     * @returns Cloned MultiEditProcessor
+     */
+    clone(): MultiEditProcessor;
+    /**
+     * Resolve MultiEdit chain recursively
+     * @param multiEdit - MultiEdit to resolve
+     * @returns Promise<void>
+     */
+    private _resolve;
+    /**
+     * Process all Edits in the MultiEditProcessor
+     * @returns Resulting Join
+     */
+    private _processAll;
+    /**
+     * Process a single Edit and update the Join
+     * @param edit - Edit to process
+     * @returns Resulting Join
+     */
+    private _process;
+}

package/dist/example-static/example-static.d.ts

@@ -0,0 +1,45 @@
+import { Json, JsonH, JsonValueH } from '@rljson/json';
+import { CakesTable, ComponentsTable, LayersTable, Rljson, SliceIdsTable, TablesCfgTable } from '@rljson/rljson';
+export interface StaticExample extends Rljson {
+    carSliceId: SliceIdsTable;
+    carGeneral: ComponentsTable<CarGeneral>;
+    carTechnical: ComponentsTable<Json>;
+    carColor: ComponentsTable<Json>;
+    carDimensions: ComponentsTable<CarDimension>;
+    carGeneralLayer: LayersTable;
+    carTechnicalLayer: LayersTable;
+    carColorLayer: LayersTable;
+    carCake: CakesTable;
+    seriesSliceId: SliceIdsTable;
+    seriesGeneral: ComponentsTable<Json>;
+    seriesCars: ComponentsTable<Json>;
+    seriesGeneralLayer: LayersTable;
+    seriesCarsLayer: LayersTable;
+    seriesCake: CakesTable;
+    catalogSliceId: SliceIdsTable;
+    catalogSeries: ComponentsTable<Json>;
+    catalogSeriesLayer: LayersTable;
+    catalogCake: CakesTable;
+    tableCfgs: TablesCfgTable;
+}
+export interface CarGeneral extends JsonH {
+    brand: string;
+    type: string;
+    doors: number;
+    energyConsumption: number;
+    units: JsonValueH;
+    serviceIntervals: number[];
+    isElectric: boolean;
+}
+export interface CarDimension extends JsonH {
+    height: number;
+    width: number;
+    length: number;
+}
+export interface CarTechnical extends JsonH {
+    engine: string;
+    transmission: string;
+    gears: number;
+    carDimensionsRef: string;
+}
+export declare const staticExample: () => StaticExample;

package/dist/index.d.ts

@@ -1 +1,7 @@
-export { Db as RljsonDb } from './db.ts';
+export { Connector } from './connector/connector.ts';
+export type { ConnectorCallback, ConnectorPayload, } from './connector/connector.ts';
+export { Db } from './db.ts';
+export { exampleEditActionColumnSelection, exampleEditActionColumnSelectionOnlySomeColumns, exampleEditActionRowFilter, exampleEditActionRowSort, exampleEditActionSetValue, exampleEditSetValueReferenced, } from './edit/edit-action.ts';
+export { MultiEditManager } from './edit/multi-edit-manager.ts';
+export { staticExample } from './example-static/example-static.ts';
+export { Join } from './join/join.ts';

package/dist/join/filter/boolean-filter-processor.d.ts

@@ -0,0 +1,13 @@
+import { BooleanFilter } from './boolean-filter.ts';
+import { ColumnFilterProcessor } from './column-filter-processor.ts';
+export declare class BooleanFilterProcessor implements ColumnFilterProcessor {
+    readonly operator: BoolOperator;
+    constructor(operator: BoolOperator, search: boolean | string | number | null);
+    search: boolean | null;
+    static fromModel(model: BooleanFilter): BooleanFilterProcessor;
+    equals(other: ColumnFilterProcessor): boolean;
+    static readonly allOperators: BoolOperator[];
+    matches(cellValue: any): boolean;
+    static get example(): BooleanFilterProcessor;
+}
+export type BoolOperator = 'equals' | 'notEquals';

package/dist/join/filter/boolean-filter.d.ts

@@ -0,0 +1,15 @@
+import { BoolOperator } from './boolean-filter-processor.ts';
+import { ColumnFilter } from './column-filter.ts';
+export interface BooleanFilter extends ColumnFilter<boolean> {
+    type: 'boolean';
+    operator: BoolOperator;
+}
+export declare const trueValues: string[];
+export declare const falseValues: string[];
+/**
+ * Parses a boolean search
+ * @param search The search value to be parsed
+ * @returns the parse result
+ */
+export declare const parseBooleanSearch: (search: any) => boolean | null;
+export declare const exampleBooleanFilter: () => BooleanFilter;

package/dist/join/filter/column-filter-processor.d.ts

@@ -0,0 +1,9 @@
+import { ColumnFilter } from './column-filter.ts';
+export declare class ColumnFilterProcessor {
+    matches(_cellValue: string): boolean;
+    equals(_other: ColumnFilterProcessor): boolean;
+    static fromModel(model: ColumnFilter<any>): ColumnFilterProcessor;
+    static operatorsForType(type: string): string[];
+    static translationsForType(type: string, language: 'de' | 'en'): string[];
+    static translateOperator(operator: string, language: 'de' | 'en'): string;
+}

package/dist/join/filter/column-filter.d.ts

@@ -0,0 +1,18 @@
+import { Json, JsonValue } from '@rljson/json';
+import { BoolOperator } from './boolean-filter-processor.ts';
+import { NumberOperator } from './number-filter-processor.ts';
+import { StringOperator } from './string-filter-processor.ts';
+/** Describes a particularly filter setting  */
+export interface ColumnFilter<T extends JsonValue> extends Json {
+    /** The data type of the filter value. */
+    type: 'number' | 'string' | 'boolean';
+    /** The address of the column, the filter is applied to.  */
+    column: string;
+    /** The operator the filter is using.  */
+    operator: NumberOperator | StringOperator | BoolOperator;
+    /** The value the data are filtered / searched for. */
+    search: T;
+    /** The json hash of the filter */
+    _hash: string;
+}
+export declare const exampleColumnFilter: () => ColumnFilter<number>;

package/dist/join/filter/number-filter-processor.d.ts

@@ -0,0 +1,16 @@
+import { ColumnFilterProcessor } from './column-filter-processor.ts';
+import { NumberFilter } from './number-filter.ts';
+export declare class NumberFilterProcessor implements ColumnFilterProcessor {
+    readonly operator: NumberOperator;
+    constructor(operator: NumberOperator, search: number | string);
+    static fromModel(model: NumberFilter): NumberFilterProcessor;
+    equals(other: ColumnFilterProcessor): boolean;
+    static readonly allOperators: NumberOperator[];
+    matches(cellValue: any): boolean;
+    search: number | string;
+    static get example(): NumberFilterProcessor;
+    private _expression;
+    private _initFiltrex;
+    private _evalExpression;
+}
+export type NumberOperator = 'equals' | 'notEquals' | 'greaterThan' | 'greaterThanOrEquals' | 'lessThan' | 'lessThanOrEquals' | 'filtrex';

package/dist/join/filter/number-filter.d.ts

@@ -0,0 +1,7 @@
+import { ColumnFilter } from './column-filter.ts';
+import { NumberOperator } from './number-filter-processor.ts';
+export interface NumberFilter extends ColumnFilter<number> {
+    type: 'number';
+    operator: NumberOperator;
+}
+export declare const exampleNumberFilter: () => NumberFilter;

package/dist/join/filter/row-filter-processor.d.ts

@@ -0,0 +1,19 @@
+import { Join, JoinRowsHashed } from '../join.ts';
+import { ColumnFilterProcessor } from './column-filter-processor.ts';
+import { RowFilter } from './row-filter.ts';
+export declare class RowFilterProcessor {
+    readonly operator: 'and' | 'or';
+    constructor(columnFilters: Record<string, ColumnFilterProcessor>, operator?: 'and' | 'or');
+    static fromModel(model: RowFilter): RowFilterProcessor;
+    get processors(): ColumnFilterProcessor[];
+    static get empty(): RowFilterProcessor;
+    equals(other: RowFilterProcessor): boolean;
+    applyTo(join: Join): JoinRowsHashed;
+    private readonly _columnFilters;
+    private _initColumnFilters;
+    private _filterRowsAnd;
+    private _filterColumnAnd;
+    private _filterRowsOr;
+    private _filterColumnOr;
+    private _throwOnWrongRoutes;
+}

package/dist/join/filter/row-filter.d.ts

@@ -0,0 +1,19 @@
+import { Json } from '@rljson/json';
+import { ColumnFilter } from './column-filter.ts';
+/** Describes the data of a row filter */
+export interface RowFilter extends Json {
+    /**
+     * The filters applied to specific columns of the table.
+     */
+    columnFilters: ColumnFilter<any>[];
+    /**
+     * The operator the column filters are combined with.
+     */
+    operator: 'and' | 'or';
+    /** The json hash of the object */
+    _hash: string;
+}
+/** An example row filter for test purposes */
+export declare const exampleRowFilter: () => RowFilter;
+/** En empty row filter doing nothing */
+export declare const emptyRowFilter: RowFilter;

package/dist/join/filter/string-filter-processor.d.ts

@@ -0,0 +1,15 @@
+import { ColumnFilterProcessor } from './column-filter-processor.ts';
+import { StringFilter } from './string-filter.ts';
+export declare class StringFilterProcessor implements ColumnFilterProcessor {
+    readonly operator: StringOperator;
+    readonly matchCase: boolean;
+    constructor(operator: StringOperator, search: string, matchCase?: boolean);
+    static fromModel(model: StringFilter): StringFilterProcessor;
+    search: string;
+    regExp: RegExp | null;
+    equals(other: ColumnFilterProcessor): boolean;
+    static readonly allOperators: StringOperator[];
+    matches(cellValue: any): boolean;
+    static get example(): StringFilterProcessor;
+}
+export type StringOperator = 'startsWith' | 'contains' | 'endsWith' | 'equals' | 'notEquals' | 'notContains' | 'regExp';

package/dist/join/filter/string-filter.d.ts

@@ -0,0 +1,8 @@
+import { ColumnFilter } from './column-filter.ts';
+import { StringOperator } from './string-filter-processor.ts';
+export interface StringFilter extends ColumnFilter<string> {
+    type: 'string';
+    operator: StringOperator;
+    matchCase?: boolean;
+}
+export declare const exampleStringFilter: () => StringFilter;

package/dist/join/join.d.ts

@@ -0,0 +1,141 @@
+import { Json, JsonValue, JsonValueType } from '@rljson/json';
+import { Ref, Route, SliceId } from '@rljson/rljson';
+import { Container } from '../db.ts';
+import { RowFilter } from './filter/row-filter.ts';
+import { ColumnSelection } from './selection/column-selection.ts';
+import { SetValue } from './set-value/set-value.ts';
+import { RowSort } from './sort/row-sort.ts';
+export declare const joinPreserveKeys: string[];
+export type JoinProcessType = 'filter' | 'setValue' | 'selection' | 'sort';
+export type JoinProcess = {
+    type: JoinProcessType;
+    instance: RowFilter | SetValue | ColumnSelection | RowSort;
+    data: JoinRowsHashed;
+    columnSelection: ColumnSelection;
+};
+export interface JoinColumn {
+    route: Route;
+    value: Container;
+    inserts: Container[] | null;
+}
+export type JoinRow = JoinColumn[];
+export type JoinRows = Record<SliceId, JoinRow>;
+export type JoinRowHashed = {
+    rowHash: Ref;
+    columns: JoinColumn[];
+};
+export type JoinRowsHashed = Record<SliceId, JoinRowHashed>;
+export declare class Join {
+    private _base;
+    private _baseColumnSelection;
+    private _processes;
+    constructor(rows: JoinRows, columnSelection: ColumnSelection);
+    /**
+     * Applies a filter to the join and returns the filtered view
+     *
+     * @param filter The filter to apply
+     */
+    filter(filter: RowFilter): Join;
+    /**
+     * Applies a set value action to the join and returns the edited join
+     *
+     * @param setValue The set value action to apply
+     */
+    setValue(setValue: SetValue): Join;
+    /**
+     * Applies multiple set value actions to the join and returns the edited join
+     *
+     * @param setValues The set value actions to apply
+     */
+    setValues(setValues: SetValue[]): Join;
+    /**
+     * Selects columns from the join and returns the resulting join
+     *
+     * @param columnSelection The column selection to apply
+     */
+    select(columnSelection: ColumnSelection): Join;
+    /**
+     * Sorts the join rows and returns the sorted join
+     *
+     * @param rowSort The row sort to apply
+     */
+    sort(rowSort: RowSort): Join;
+    /**
+     * Returns insert Object of the join
+     */
+    insert(): {
+        route: Route;
+        tree: Json;
+    }[];
+    /**
+     * Returns the value at the given row and column index
+     *
+     * @param row The row index
+     * @param column The column index
+     * @returns The value at the given row and column
+     */
+    value(row: number, column: number): JsonValue[];
+    /**
+     * Clones the join
+     *
+     * @returns The cloned join
+     */
+    clone(): Join;
+    /**
+     * Returns all component routes of the join
+     */
+    get componentRoutes(): Route[];
+    /**
+     * Returns all layer routes of the join
+     */
+    get layerRoutes(): Route[];
+    /**
+     * Returns the cake route of the join
+     */
+    get cakeRoute(): Route;
+    /**
+     * Returns the number of rows in the join
+     */
+    get rowCount(): number;
+    /**
+     * Returns the number of columns in the join
+     */
+    get columnCount(): number;
+    /**
+     * Returns the row indices (sliceIds) of the join
+     */
+    get rowIndices(): SliceId[];
+    /**
+     * Returns the join row for the given slice id
+     *
+     * @param sliceId - The slice id
+     * @returns The join row
+     */
+    row(sliceId: SliceId): JoinRow;
+    /**
+     * Returns the data of the join
+     */
+    get data(): JoinRowsHashed;
+    /**
+     * Returns the column types of the join
+     */
+    get columnTypes(): JsonValueType[];
+    /**
+     * Returns the column selection of the join
+     */
+    get columnSelection(): ColumnSelection;
+    /**
+     * Returns all rows of the join w/ nulled missing values
+     *
+     * @return The rows of the join
+     */
+    get rows(): any[][];
+    static empty(): Join;
+    /**
+     * Hashes the given join rows. If insert value is present, it is used for hashing.
+     *
+     * @param rows The join rows to hash
+     * @returns The hashed join rows
+     */
+    private _hashedRows;
+}

package/dist/join/selection/column-selection.d.ts

@@ -0,0 +1,48 @@
+import { ColumnCfgWithRoute, Ref, Route } from '@rljson/rljson';
+export type ColumnRoute = string | string[] | number;
+export interface ColumnInfo extends ColumnCfgWithRoute {
+    alias: string;
+    routeHash?: Ref;
+    index?: number;
+    value?: any;
+}
+export declare class ColumnSelection {
+    constructor(columns: ColumnInfo[]);
+    /**
+     * Returns unique routes from a list of routes
+     * @param routes - The list of routes
+     * @returns Unique routes
+     */
+    static uniqueRoutes(routes: Route[]): Route[];
+    /**
+     * Returns a ColumnSelection from a list of route segments
+     * @param routeSegmentsList - A list of route segments
+     * @returns A ColumnSelection object
+     */
+    static fromRoutes(routes: Route[]): ColumnSelection;
+    readonly columns: ColumnInfo[];
+    readonly routes: string[];
+    readonly aliases: string[];
+    readonly routeHashes: string[];
+    metadata(key: string): any[];
+    static merge(columnSelections: ColumnSelection[]): ColumnSelection;
+    static calcHash(str: string): string;
+    route(aliasRouteOrHash: ColumnRoute): string;
+    alias(aliasRouteOrHash: ColumnRoute): string;
+    columnIndex(hashAliasOrRoute: ColumnRoute, throwIfNotExisting?: boolean): number;
+    /***
+     * Returns the column config for a specific alias, route or hash.
+     */
+    column(aliasRouteOrHash: ColumnRoute): ColumnInfo;
+    get count(): number;
+    addedColumns(columnSelection: ColumnSelection): string[];
+    static check(aliases: string[], routes: string[]): void;
+    private _throwOnWrongAlias;
+    private _initColumns;
+    static example(): ColumnSelection;
+    static exampleBroken(): ColumnInfo[];
+    static exampleCarsColumnSelection(): ColumnSelection;
+    static exampleCarsDeeplyNestedColumnSelection(): ColumnSelection;
+    static exampleCarsColumnSelectionOnlySomeColumns(): ColumnSelection;
+    static empty(): ColumnSelection;
+}

package/dist/join/set-value/set-value.d.ts

@@ -0,0 +1,11 @@
+import { Json } from '@rljson/json';
+/**
+ * Describes an set value that is applied to a specific route.
+ */
+export interface SetValue extends Json {
+    /**
+     * The route to the column the value is set to.
+     */
+    route: string;
+    value: any;
+}

package/dist/join/sort/row-sort.d.ts

@@ -0,0 +1,18 @@
+import { RouteRef, SliceId } from '@rljson/rljson';
+import { Join } from '../join.ts';
+export type RowSortOrder = 'asc' | 'desc';
+export type RowSortType = Record<RouteRef, RowSortOrder>;
+export declare class RowSort {
+    constructor(columnSorts: Record<string, 'asc' | 'desc'>);
+    /**
+     * 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: Join): SliceId[];
+    get columnSorts(): Record<string, 'asc' | 'desc'>;
+    private readonly _columnSorts;
+    private _initColumnSorts;
+    private _sortRows;
+    private _throwOnWrongRoutes;
+}

package/dist/notify.d.ts

@@ -1,5 +1,5 @@
 import { InsertHistoryRow, Route } from '@rljson/rljson';
-type NotifyCallback<N extends string> = (InsertHistoryRow: InsertHistoryRow<N>) => void;
+export type NotifyCallback<N extends string> = (InsertHistoryRow: InsertHistoryRow<N>) => Promise<any>;
 /**
  * Notification system to manage callbacks for specific routes and notify them with edit protocol rows.
  */
@@ -18,6 +18,11 @@ export declare class Notify {
      * @param callback  The callback function to be removed.
      */
     unregister(route: Route, callback: NotifyCallback<any>): void;
+    /**
+     * Unregisters all callbacks for a specific route.
+     * @param route   The route to unregister all callbacks from.
+     */
+    unregisterAll(route: Route): void;
     /**
      * Notifies all registered callbacks for a specific route with the provided edit protocol row.
      * @param route   The route to notify callbacks for.
@@ -36,4 +41,3 @@ export declare class Notify {
      */
     getCallBacksForRoute(route: Route): NotifyCallback<any>[];
 }
-export {};

package/dist/tools/inject.d.ts

@@ -0,0 +1 @@
+export declare const inject: (tree: any, path: (string | number)[], value: any) => void;

package/dist/tools/isolate.d.ts

@@ -0,0 +1 @@
+export declare const isolate: (tree: any, path: (string | number)[], preservedKeys?: string[]) => any;

package/dist/tools/make-unique.d.ts

@@ -0,0 +1,4 @@
+import { JsonH } from '@rljson/json';
+import { Rljson } from '@rljson/rljson';
+export declare const makeUniqueArrayByHash: <T extends JsonH>(arr: T[]) => T[];
+export declare const makeUnique: (rljson: Rljson) => Rljson;

package/dist/tools/merge-trees.d.ts

@@ -0,0 +1,5 @@
+import { Json } from '@rljson/json';
+export declare const mergeTrees: (trees: {
+    tree: Json;
+    path: Array<string | number>;
+}[]) => Json;