@manuscripts/track-changes-plugin 1.7.2 → 1.7.3-LEAN-2832-v4

package/dist/types/ChangeSet.d.ts

@@ -0,0 +1,28 @@
+import { IncompleteChange, NodeAttrChange, NodeChange, TextChange, TrackedAttrs, TrackedChange } from './types/change';
+export declare class ChangeSet {
+    #private;
+    constructor(changes?: (TrackedChange | IncompleteChange)[]);
+    get changes(): TrackedChange[];
+    get invalidChanges(): (TrackedChange | IncompleteChange)[];
+    get changeTree(): TrackedChange[];
+    get pending(): TrackedChange[];
+    get accepted(): TrackedChange[];
+    get rejected(): TrackedChange[];
+    get textChanges(): TrackedChange[];
+    get nodeChanges(): TrackedChange[];
+    get nodeAttrChanges(): TrackedChange[];
+    get bothNodeChanges(): TrackedChange[];
+    get isEmpty(): boolean;
+    get hasInconsistentData(): boolean;
+    get hasDuplicateIds(): boolean;
+    get hasIncompleteAttrs(): boolean;
+    get(id: string): TrackedChange | IncompleteChange | undefined;
+    getIn(ids: string[]): (TrackedChange | IncompleteChange)[];
+    getNotIn(ids: string[]): (TrackedChange | IncompleteChange)[];
+    static flattenTreeToIds(changes: TrackedChange[]): string[];
+    static shouldDeleteChange(change: TrackedChange): boolean;
+    static isValidDataTracked(dataTracked?: Partial<TrackedAttrs>): boolean;
+    static isTextChange(change: TrackedChange): change is TextChange;
+    static isNodeChange(change: TrackedChange): change is NodeChange;
+    static isNodeAttrChange(change: TrackedChange): change is NodeAttrChange;
+}

package/dist/{actions.d.ts → types/actions.d.ts}

@@ -1,60 +1,27 @@
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Transaction } from 'prosemirror-state';
-import { CHANGE_STATUS } from './types/change';
-import { TrackChangesStatus } from './types/track';
-export declare enum TrackChangesAction {
-    skipTrack = "track-changes-skip-tracking",
-    setUserID = "track-changes-set-user-id",
-    setPluginStatus = "track-changes-set-track-status",
-    setChangeStatuses = "track-changes-set-change-statuses",
-    refreshChanges = "track-changes-refresh-changes",
-    applyAndRemoveChanges = "track-changes-apply-remove-changes",
-    updateMetaNode = "track-changes-update-meta-node"
-}
-export declare type TrackChangesActionParams = {
-    [TrackChangesAction.skipTrack]: boolean;
-    [TrackChangesAction.setUserID]: string;
-    [TrackChangesAction.setPluginStatus]: TrackChangesStatus;
-    [TrackChangesAction.setChangeStatuses]: {
-        status: CHANGE_STATUS;
-        ids: string[];
-    };
-    [TrackChangesAction.refreshChanges]: boolean;
-    [TrackChangesAction.applyAndRemoveChanges]: boolean;
-    [TrackChangesAction.updateMetaNode]: boolean;
-};
-/**
- * Gets the value of a meta field, action payload, of a defined track-changes action.
- * @param tr
- * @param action
- */
-export declare function getAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K): TrackChangesActionParams[K] | undefined;
-/**
- * Use this function to set meta keys to transactions that are consumed by the track-changes-plugin.
- * For example, you can skip tracking of a transaction with setAction(tr, TrackChangesAction.skipTrack, true)
- * @param tr
- * @param action
- * @param payload
- */
-export declare function setAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K, payload: TrackChangesActionParams[K]): Transaction;
-/**
- * Skip tracking for a transaction, use this with caution to avoid race-conditions or just to otherwise
- * omitting applying of track attributes or marks.
- * @param tr
- * @returns
- */
-export declare const skipTracking: (tr: Transaction) => Transaction;
+import { Transaction } from 'prosemirror-state';
+import { CHANGE_STATUS } from './types/change';
+import { TrackChangesStatus } from './types/track';
+export declare enum TrackChangesAction {
+    skipTrack = "track-changes-skip-tracking",
+    setUserID = "track-changes-set-user-id",
+    setPluginStatus = "track-changes-set-track-status",
+    setChangeStatuses = "track-changes-set-change-statuses",
+    refreshChanges = "track-changes-refresh-changes",
+    applyAndRemoveChanges = "track-changes-apply-remove-changes",
+    updateMetaNode = "track-changes-update-meta-node"
+}
+export type TrackChangesActionParams = {
+    [TrackChangesAction.skipTrack]: boolean;
+    [TrackChangesAction.setUserID]: string;
+    [TrackChangesAction.setPluginStatus]: TrackChangesStatus;
+    [TrackChangesAction.setChangeStatuses]: {
+        status: CHANGE_STATUS;
+        ids: string[];
+    };
+    [TrackChangesAction.refreshChanges]: boolean;
+    [TrackChangesAction.applyAndRemoveChanges]: boolean;
+    [TrackChangesAction.updateMetaNode]: boolean;
+};
+export declare function getAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K): TrackChangesActionParams[K] | undefined;
+export declare function setAction<K extends keyof TrackChangesActionParams>(tr: Transaction, action: K, payload: TrackChangesActionParams[K]): Transaction;
+export declare const skipTracking: (tr: Transaction) => Transaction;

package/dist/{change-steps → types/change-steps}/diffChangeSteps.d.ts

@@ -1,2 +1,2 @@
-import { ChangeStep, InsertSliceStep } from '../types/step';
-export declare function diffChangeSteps(deleted: ChangeStep[], inserted: InsertSliceStep[]): ChangeStep[];
+import { ChangeStep, InsertSliceStep } from '../types/step';
+export declare function diffChangeSteps(deleted: ChangeStep[], inserted: InsertSliceStep[]): ChangeStep[];

package/dist/types/change-steps/matchInserted.d.ts

@@ -0,0 +1,3 @@
+import { ExposedFragment } from '../types/pm';
+import { ChangeStep } from '../types/step';
+export declare function matchInserted(matchedDeleted: number, deleted: ChangeStep[], inserted: ExposedFragment): [number, ChangeStep[]];

package/dist/types/change-steps/processChangeSteps.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'prosemirror-model';
+import type { Transaction } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+import { ChangeStep } from '../types/step';
+import { NewEmptyAttrs } from '../types/track';
+export declare function processChangeSteps(changes: ChangeStep[], startPos: number, newTr: Transaction, emptyAttrs: NewEmptyAttrs, schema: Schema): [Mapping, number];

package/dist/types/changes/applyChanges.d.ts

@@ -0,0 +1,5 @@
+import { Schema } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+import { TrackedChange } from '../types/change';
+export declare function applyAcceptedRejectedChanges(tr: Transaction, schema: Schema, changes: TrackedChange[], deleteMap?: Mapping): Mapping;

package/dist/types/changes/findChanges.d.ts

@@ -0,0 +1,3 @@
+import { EditorState } from 'prosemirror-state';
+import { ChangeSet } from '../ChangeSet';
+export declare function findChanges(state: EditorState): ChangeSet;

package/dist/types/changes/fixInconsistentChanges.d.ts

@@ -0,0 +1,4 @@
+import { Schema } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { ChangeSet } from '../ChangeSet';
+export declare function fixInconsistentChanges(changeSet: ChangeSet, currentUserID: string, newTr: Transaction, schema: Schema): boolean;

package/dist/types/changes/updateChangeAttrs.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+import { IncompleteChange, TrackedAttrs, TrackedChange } from '../types/change';
+export declare function updateChangeAttrs(tr: Transaction, change: IncompleteChange, trackedAttrs: Partial<TrackedAttrs>, schema: Schema): Transaction;
+export declare function updateChangeChildrenAttributes(changes: TrackedChange[], tr: Transaction, mapping: Mapping): void;

package/dist/types/commands.d.ts

@@ -0,0 +1,8 @@
+import { Command } from 'prosemirror-state';
+import { CHANGE_STATUS } from './types/change';
+import { TrackChangesStatus } from './types/track';
+export declare const setTrackingStatus: (status?: TrackChangesStatus) => Command;
+export declare const setChangeStatuses: (status: CHANGE_STATUS, ids: string[]) => Command;
+export declare const setUserID: (userID: string) => Command;
+export declare const applyAndRemoveChanges: () => Command;
+export declare const refreshChanges: () => Command;

package/dist/{compute → types/compute}/nodeHelpers.d.ts

@@ -1,28 +1,13 @@
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Node as PMNode, Schema } from 'prosemirror-model';
-import { CHANGE_OPERATION, TrackedAttrs } from '../types/change';
-export declare function addTrackIdIfDoesntExist(attrs: Partial<TrackedAttrs>): Partial<TrackedAttrs>;
-export declare function getTextNodeTrackedMarkData(node: PMNode | undefined | null, schema: Schema): (Omit<Partial<TrackedAttrs>, "operation"> & {
-    operation: CHANGE_OPERATION;
-}) | undefined;
-export declare function getBlockInlineTrackedData(node: PMNode): Partial<TrackedAttrs>[] | undefined;
-export declare function getNodeTrackedData(node: PMNode | undefined | null, schema: Schema): Partial<TrackedAttrs>[] | undefined;
-export declare function equalMarks(n1: PMNode, n2: PMNode): boolean;
-export declare function shouldMergeTrackedAttributes(left?: Partial<TrackedAttrs>, right?: Partial<TrackedAttrs>): boolean;
-export declare function getMergeableMarkTrackedAttrs(node: PMNode | undefined | null, attrs: Partial<TrackedAttrs>, schema: Schema): (Omit<Partial<TrackedAttrs>, "operation"> & {
-    operation: CHANGE_OPERATION;
-}) | null;
+import { Node as PMNode, Schema } from 'prosemirror-model';
+import { CHANGE_OPERATION, TrackedAttrs } from '../types/change';
+export declare function addTrackIdIfDoesntExist(attrs: Partial<TrackedAttrs>): Partial<TrackedAttrs>;
+export declare function getTextNodeTrackedMarkData(node: PMNode | undefined | null, schema: Schema): (Omit<Partial<TrackedAttrs>, "operation"> & {
+    operation: CHANGE_OPERATION;
+}) | undefined;
+export declare function getBlockInlineTrackedData(node: PMNode): Partial<TrackedAttrs>[] | undefined;
+export declare function getNodeTrackedData(node: PMNode | undefined | null, schema: Schema): Partial<TrackedAttrs>[] | undefined;
+export declare function equalMarks(n1: PMNode, n2: PMNode): boolean;
+export declare function shouldMergeTrackedAttributes(left?: Partial<TrackedAttrs>, right?: Partial<TrackedAttrs>): boolean;
+export declare function getMergeableMarkTrackedAttrs(node: PMNode | undefined | null, attrs: Partial<TrackedAttrs>, schema: Schema): (Omit<Partial<TrackedAttrs>, "operation"> & {
+    operation: CHANGE_OPERATION;
+}) | null;

package/dist/types/compute/setFragmentAsInserted.d.ts

@@ -0,0 +1,3 @@
+import { Fragment, Schema } from 'prosemirror-model';
+import { NewInsertAttrs } from '../types/track';
+export declare function setFragmentAsInserted(inserted: Fragment, insertAttrs: NewInsertAttrs, schema: Schema): Fragment;

package/dist/types/compute/splitSliceIntoMergedParts.d.ts

@@ -0,0 +1,13 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { ExposedFragment, ExposedSlice } from '../types/pm';
+export declare function splitSliceIntoMergedParts(insertSlice: ExposedSlice, mergeEqualSides?: boolean): {
+    updatedSliceNodes: PMNode[];
+    firstMergedNode: {
+        mergedNodeContent: ExposedFragment;
+        unmergedContent: ExposedFragment | undefined;
+    } | undefined;
+    lastMergedNode: {
+        mergedNodeContent: ExposedFragment;
+        unmergedContent: ExposedFragment | undefined;
+    } | undefined;
+};

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export { trackChangesPluginKey, trackChangesPlugin } from './plugin';
+export { skipTracking } from './actions';
+export * as trackCommands from './commands';
+export { enableDebug } from './utils/logger';
+export { ChangeSet } from './ChangeSet';
+export * from './types/change';
+export * from './types/track';

package/dist/types/mutate/deleteAndMergeSplitNodes.d.ts

@@ -0,0 +1,13 @@
+import { Fragment, Node as PMNode, Schema } from 'prosemirror-model';
+import type { Transaction } from 'prosemirror-state';
+import { ExposedSlice } from '../types/pm';
+import { ChangeStep } from '../types/step';
+import { NewEmptyAttrs } from '../types/track';
+export declare function deleteAndMergeSplitNodes(from: number, to: number, gap: {
+    start: number;
+    end: number;
+} | undefined, startDoc: PMNode, newTr: Transaction, schema: Schema, trackAttrs: NewEmptyAttrs, insertSlice: ExposedSlice): {
+    sliceWasSplit: boolean;
+    newSliceContent: Fragment;
+    steps: ChangeStep[];
+};

package/dist/types/mutate/deleteNode.d.ts

@@ -0,0 +1,5 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+import { NewDeleteAttrs } from '../types/track';
+export declare function deleteNode(node: PMNode, pos: number, tr: Transaction): Transaction;
+export declare function deleteOrSetNodeDeleted(node: PMNode, pos: number, newTr: Transaction, deleteAttrs: NewDeleteAttrs): Transaction | undefined;

package/dist/types/mutate/deleteText.d.ts

@@ -0,0 +1,4 @@
+import { Node as PMNode, Schema } from 'prosemirror-model';
+import type { Transaction } from 'prosemirror-state';
+import { NewDeleteAttrs } from '../types/track';
+export declare function deleteTextIfInserted(node: PMNode, pos: number, newTr: Transaction, schema: Schema, deleteAttrs: NewDeleteAttrs, from?: number, to?: number): number;

package/dist/types/mutate/mergeNode.d.ts

@@ -0,0 +1,3 @@
+import { Node as PMNode } from 'prosemirror-model';
+import { Transaction } from 'prosemirror-state';
+export declare function mergeNode(node: PMNode, pos: number, tr: Transaction): Transaction | undefined;

package/dist/types/mutate/mergeTrackedMarks.d.ts

@@ -0,0 +1,3 @@
+import { Node as PMNode, Schema } from 'prosemirror-model';
+import type { Transaction } from 'prosemirror-state';
+export declare function mergeTrackedMarks(pos: number, doc: PMNode, newTr: Transaction, schema: Schema): void;

package/dist/types/plugin.d.ts

@@ -0,0 +1,4 @@
+import { Plugin, PluginKey } from 'prosemirror-state';
+import { TrackChangesOptions, TrackChangesState } from './types/track';
+export declare const trackChangesPluginKey: PluginKey<TrackChangesState>;
+export declare const trackChangesPlugin: (opts?: TrackChangesOptions) => Plugin<TrackChangesState>;

package/dist/{steps → types/steps}/trackReplaceAroundStep.d.ts

@@ -1,5 +1,5 @@
-import type { EditorState, Transaction } from 'prosemirror-state';
-import { ReplaceAroundStep } from 'prosemirror-transform';
-import { NewEmptyAttrs } from '../types/track';
-import { ChangeStep } from '../types/step';
-export declare function trackReplaceAroundStep(step: ReplaceAroundStep, oldState: EditorState, tr: Transaction, newTr: Transaction, attrs: NewEmptyAttrs): ChangeStep[];
+import type { EditorState, Transaction } from 'prosemirror-state';
+import { ReplaceAroundStep } from 'prosemirror-transform';
+import { ChangeStep } from '../types/step';
+import { NewEmptyAttrs } from '../types/track';
+export declare function trackReplaceAroundStep(step: ReplaceAroundStep, oldState: EditorState, tr: Transaction, newTr: Transaction, attrs: NewEmptyAttrs): ChangeStep[];

package/dist/types/steps/trackReplaceStep.d.ts

@@ -0,0 +1,6 @@
+import { Node as PMNode } from 'prosemirror-model';
+import type { EditorState, Transaction } from 'prosemirror-state';
+import { ReplaceStep, StepResult } from 'prosemirror-transform';
+import { ChangeStep } from '../types/step';
+import { NewEmptyAttrs } from '../types/track';
+export declare function trackReplaceStep(step: ReplaceStep, oldState: EditorState, newTr: Transaction, attrs: NewEmptyAttrs, stepResult: StepResult, currentStepDoc: PMNode): [ChangeStep[], number];

package/dist/types/steps/trackTransaction.d.ts

@@ -0,0 +1,2 @@
+import type { EditorState, Transaction } from 'prosemirror-state';
+export declare function trackTransaction(tr: Transaction, oldState: EditorState, newTr: Transaction, authorID: string): Transaction;

package/dist/types/types/change.d.ts

@@ -0,0 +1,62 @@
+export declare enum CHANGE_OPERATION {
+    insert = "insert",
+    delete = "delete",
+    set_node_attributes = "set_attrs"
+}
+export declare enum CHANGE_STATUS {
+    accepted = "accepted",
+    rejected = "rejected",
+    pending = "pending"
+}
+type InsertDeleteAttrs = {
+    id: string;
+    authorID: string;
+    reviewedByID: string | null;
+    operation: CHANGE_OPERATION.insert | CHANGE_OPERATION.delete;
+    status: CHANGE_STATUS;
+    statusUpdateAt: number;
+    createdAt: number;
+    updatedAt: number;
+};
+export type UpdateAttrs = Omit<InsertDeleteAttrs, 'operation'> & {
+    operation: CHANGE_OPERATION.set_node_attributes;
+    oldAttrs: Record<string, any>;
+};
+export type TrackedAttrs = InsertDeleteAttrs | UpdateAttrs;
+type Change = {
+    id: string;
+    from: number;
+    to: number;
+    dataTracked: TrackedAttrs;
+};
+export type TextChange = Change & {
+    type: 'text-change';
+    text: string;
+};
+export type NodeChange = Change & {
+    type: 'node-change';
+    nodeType: string;
+    children: TrackedChange[];
+};
+export type NodeAttrChange = Change & {
+    type: 'node-attr-change';
+    nodeType: string;
+    oldAttrs: Record<string, any>;
+    newAttrs: Record<string, any>;
+};
+export type WrapChange = Change & {
+    type: 'wrap-change';
+    wrapperNode: string;
+};
+export type MarkChange = Change & {
+    type: 'mark-change';
+};
+export type TrackedChange = TextChange | NodeChange | NodeAttrChange | WrapChange | MarkChange;
+export type PartialChange<T extends TrackedChange> = Omit<T, 'dataTracked'> & {
+    dataTracked: Partial<TrackedAttrs>;
+};
+export type IncompleteChange = Omit<TrackedChange, 'dataTracked'> & {
+    dataTracked: Partial<TrackedAttrs>;
+};
+export type ChangeType = TrackedChange['type'];
+export {};

package/dist/types/types/pm.d.ts

@@ -0,0 +1,12 @@
+import { Fragment, Node as PMNode, Slice } from 'prosemirror-model';
+import { ReplaceStep } from 'prosemirror-transform';
+export type ExposedReplaceStep = ReplaceStep & {
+    slice: ExposedSlice;
+};
+export type ExposedSlice = Slice & {
+    content: ExposedFragment;
+    insertAt(pos: number, fragment: Fragment | ExposedFragment): ExposedSlice;
+};
+export type ExposedFragment = Fragment & {
+    content: PMNode[];
+};

package/dist/types/{step.d.ts → types/step.d.ts}

@@ -1,53 +1,38 @@
-/*!
- * © 2021 Atypon Systems LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *    http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Node as PMNode } from 'prosemirror-model';
-import { ExposedFragment, ExposedSlice } from './pm';
-export interface DeleteNodeStep {
-    pos: number;
-    nodeEnd: number;
-    type: 'delete-node';
-    node: PMNode;
-}
-export interface DeleteTextStep {
-    pos: number;
-    from: number;
-    to: number;
-    type: 'delete-text';
-    node: PMNode;
-}
-export interface MergeFragmentStep {
-    pos: number;
-    mergePos: number;
-    from: number;
-    to: number;
-    type: 'merge-fragment';
-    node: PMNode;
-    fragment: ExposedFragment;
-}
-export interface InsertSliceStep {
-    from: number;
-    to: number;
-    sliceWasSplit: boolean;
-    type: 'insert-slice';
-    slice: ExposedSlice;
-}
-export interface UpdateNodeAttrsStep {
-    pos: number;
-    type: 'update-node-attrs';
-    node: PMNode;
-    newAttrs: Record<string, any>;
-}
-export declare type ChangeStep = DeleteNodeStep | DeleteTextStep | MergeFragmentStep | InsertSliceStep | UpdateNodeAttrsStep;
+import { Node as PMNode } from 'prosemirror-model';
+import { ExposedFragment, ExposedSlice } from './pm';
+export interface DeleteNodeStep {
+    pos: number;
+    nodeEnd: number;
+    type: 'delete-node';
+    node: PMNode;
+}
+export interface DeleteTextStep {
+    pos: number;
+    from: number;
+    to: number;
+    type: 'delete-text';
+    node: PMNode;
+}
+export interface MergeFragmentStep {
+    pos: number;
+    mergePos: number;
+    from: number;
+    to: number;
+    type: 'merge-fragment';
+    node: PMNode;
+    fragment: ExposedFragment;
+}
+export interface InsertSliceStep {
+    from: number;
+    to: number;
+    sliceWasSplit: boolean;
+    type: 'insert-slice';
+    slice: ExposedSlice;
+}
+export interface UpdateNodeAttrsStep {
+    pos: number;
+    type: 'update-node-attrs';
+    node: PMNode;
+    newAttrs: Record<string, any>;
+}
+export type ChangeStep = DeleteNodeStep | DeleteTextStep | MergeFragmentStep | InsertSliceStep | UpdateNodeAttrsStep;

package/dist/types/types/track.d.ts

@@ -0,0 +1,30 @@
+import type { PluginKey } from 'prosemirror-state';
+import { ChangeSet } from '../ChangeSet';
+import { CHANGE_OPERATION, TrackedAttrs } from './change';
+export interface TrackChangesOptions {
+    debug?: boolean;
+    userID: string;
+    skipTrsWithMetas?: (PluginKey | string)[];
+}
+export interface TrackChangesState {
+    status: TrackChangesStatus;
+    userID: string;
+    changeSet: ChangeSet;
+}
+export type NewEmptyAttrs = Omit<TrackedAttrs, 'id' | 'operation'>;
+export type NewInsertAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.insert;
+};
+export type NewDeleteAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.delete;
+};
+export type NewUpdateAttrs = Omit<TrackedAttrs, 'id' | 'operation'> & {
+    operation: CHANGE_OPERATION.set_node_attributes;
+    oldAttrs: Record<string, any>;
+};
+export type NewTrackedAttrs = NewInsertAttrs | NewDeleteAttrs | NewUpdateAttrs;
+export declare enum TrackChangesStatus {
+    enabled = "enabled",
+    viewSnapshots = "view-snapshots",
+    disabled = "disabled"
+}

package/dist/types/utils/logger.d.ts

@@ -0,0 +1,8 @@
+import debug from 'debug';
+export declare const logger: debug.Debugger;
+export declare const log: {
+    info(str: string, obj?: any): void;
+    warn(str: string, obj?: any): void;
+    error(str: string, obj?: any): void;
+};
+export declare const enableDebug: (enabled: boolean) => void;

package/dist/{utils → types/utils}/track-utils.d.ts

@@ -1,4 +1,4 @@
-import { NewDeleteAttrs, NewEmptyAttrs, NewInsertAttrs, NewUpdateAttrs } from '../types/track';
-export declare function createNewInsertAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
-export declare function createNewDeleteAttrs(attrs: NewEmptyAttrs): NewDeleteAttrs;
-export declare function createNewUpdateAttrs(attrs: NewEmptyAttrs, oldAttrs: Record<string, any>): NewUpdateAttrs;
+import { NewDeleteAttrs, NewEmptyAttrs, NewInsertAttrs, NewUpdateAttrs } from '../types/track';
+export declare function createNewInsertAttrs(attrs: NewEmptyAttrs): NewInsertAttrs;
+export declare function createNewDeleteAttrs(attrs: NewEmptyAttrs): NewDeleteAttrs;
+export declare function createNewUpdateAttrs(attrs: NewEmptyAttrs, oldAttrs: Record<string, any>): NewUpdateAttrs;

package/dist/types/utils/uuidv4.d.ts

@@ -0,0 +1 @@
+export declare function uuidv4(): string;