trakked 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,328 @@
+declare class TypedEvent<T> {
+    private readonly _handlers;
+    subscribe(handler: (event: T) => void): () => void;
+    unsubscribe(handler: (event: T) => void): void;
+    emit(event: T): void;
+}
+
+interface ITracked {
+    tracker: Tracker;
+    isDirty: boolean;
+    dirtyCounter: number;
+    validate(property: string, errorMessage: string | undefined): void;
+    destroy(): void;
+}
+
+declare enum PropertyType {
+    Boolean = 0,
+    String = 1,
+    Number = 2,
+    Collection = 3,
+    Object = 4,
+    Date = 5
+}
+
+declare class OperationProperties {
+    readonly trackedObject: ITracked;
+    readonly property: string | undefined;
+    readonly type: PropertyType;
+    readonly validator?: ((trackedObjects: any, newValue: any) => string | undefined) | undefined;
+    readonly noCoalesce?: boolean | undefined;
+    constructor(trackedObject: ITracked, property: string | undefined, type: PropertyType, validator?: ((trackedObjects: any, newValue: any) => string | undefined) | undefined, noCoalesce?: boolean | undefined);
+}
+
+declare class Change {
+    readonly number: number;
+    readonly redoAction: () => void;
+    readonly undoAction: () => void;
+    readonly properties: OperationProperties;
+    readonly time: Date;
+    constructor(number: number, redoAction: () => void, undoAction: () => void, properties: OperationProperties);
+}
+
+declare class Operation {
+    readonly time: Date;
+    readonly actions: Change[];
+    private _hasActions;
+    get hasActions(): boolean;
+    private set hasActions(value);
+    add(redoAction: () => void, undoAction: () => void, properties: OperationProperties): void;
+    updateOrAdd(redoAction: () => void, undoAction: () => void, properties: OperationProperties): void;
+    redo(): void;
+    undo(): void;
+}
+
+declare class TrackedCollection<T> implements Array<T>, ITracked {
+    readonly tracker: Tracker;
+    private readonly _validator?;
+    private _collection;
+    private _isDirty;
+    private _isValid;
+    private _dirtyCounter;
+    private _error;
+    get dirtyCounter(): number;
+    private set dirtyCounter(value);
+    get isDirty(): boolean;
+    private set isDirty(value);
+    get isValid(): boolean;
+    private set isValid(value);
+    get length(): number;
+    get lastItemIndex(): number | undefined;
+    get collection(): T[];
+    private set collection(value);
+    get [Symbol.iterator](): () => ArrayIterator<T>;
+    get [Symbol.unscopables](): {
+        [x: number]: boolean | undefined;
+        length?: boolean | undefined;
+        toString?: boolean | undefined;
+        toLocaleString?: boolean | undefined;
+        pop?: boolean | undefined;
+        push?: boolean | undefined;
+        concat?: boolean | undefined;
+        join?: boolean | undefined;
+        reverse?: boolean | undefined;
+        shift?: boolean | undefined;
+        slice?: boolean | undefined;
+        sort?: boolean | undefined;
+        splice?: boolean | undefined;
+        unshift?: boolean | undefined;
+        indexOf?: boolean | undefined;
+        lastIndexOf?: boolean | undefined;
+        every?: boolean | undefined;
+        some?: boolean | undefined;
+        forEach?: boolean | undefined;
+        map?: boolean | undefined;
+        filter?: boolean | undefined;
+        reduce?: boolean | undefined;
+        reduceRight?: boolean | undefined;
+        find?: boolean | undefined;
+        findIndex?: boolean | undefined;
+        fill?: boolean | undefined;
+        copyWithin?: boolean | undefined;
+        entries?: boolean | undefined;
+        keys?: boolean | undefined;
+        values?: boolean | undefined;
+        includes?: boolean | undefined;
+        flatMap?: boolean | undefined;
+        flat?: boolean | undefined;
+        at?: boolean | undefined;
+        findLast?: boolean | undefined;
+        findLastIndex?: boolean | undefined;
+        toReversed?: boolean | undefined;
+        toSorted?: boolean | undefined;
+        toSpliced?: boolean | undefined;
+        with?: boolean | undefined;
+        [Symbol.iterator]?: boolean | undefined;
+        readonly [Symbol.unscopables]?: boolean | undefined;
+    };
+    readonly changed: TypedEvent<TrackedCollectionChanged<T>>;
+    [n: number]: T;
+    get error(): string | undefined;
+    set error(value: string | undefined);
+    constructor(tracker: Tracker, items?: T[], _validator?: ((value: T[]) => string | undefined) | undefined);
+    validate(): void;
+    splice(start: number, deleteCount: number, ...items: T[]): T[];
+    private doSplice;
+    private trackRemovedObjectDeletions;
+    private trackAddedObjectInsertions;
+    private undoSplice;
+    reset(newItems: T[]): void;
+    reverse(): T[];
+    sort(compareFn?: (a: T, b: T) => number): this;
+    clear(): void;
+    remove(item: T): boolean;
+    replace(item: T, replace: T): boolean;
+    replaceAt(index: number, replace: T): void;
+    pop(): T | undefined;
+    push(...items: T[]): number;
+    concat(...items: (T | ConcatArray<T>)[]): T[];
+    join(separator?: string): string;
+    shift(): T | undefined;
+    slice(start?: number, end?: number): T[];
+    unshift(...items: T[]): number;
+    indexOf(searchElement: T, fromIndex?: number): number;
+    lastIndexOf(searchElement: T, fromIndex?: number): number;
+    every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
+    every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
+    forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
+    map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
+    filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
+    find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): T | undefined;
+    findIndex(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: any): number;
+    flatMap<U, This = undefined>(callback: (this: This, value: T, index: number, array: T[]) => U | ReadonlyArray<U>, thisArg?: This): U[];
+    includes(searchElement: T, fromIndex?: number): boolean;
+    toString(): string;
+    toLocaleString(): string;
+    entries(): ArrayIterator<[number, T]>;
+    keys(): ArrayIterator<number>;
+    values(): ArrayIterator<T>;
+    at(index: number): T | undefined;
+    fill(value: T, start?: number, end?: number): this;
+    copyWithin(target: number, start: number, end?: number): this;
+    reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue?: T): T;
+    flat<A, D extends number = 1>(this: A, depth?: D): FlatArray<A, D>[];
+    findLast(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T | undefined;
+    findLastIndex(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): number;
+    toReversed(): T[];
+    toSorted(compareFn?: (a: T, b: T) => number): T[];
+    toSpliced(start: number, deleteCount: number, ...items: T[]): T[];
+    with(index: number, value: T): T[];
+    first(): T | undefined;
+    destroy(): void;
+}
+declare class TrackedCollectionChanged<T> {
+    readonly added: T[];
+    readonly removed: T[];
+    readonly newCollection: T[];
+    constructor(added: T[], removed: T[], newCollection: T[]);
+}
+declare global {
+    interface ArrayIterator<T> extends IterableIterator<T> {
+        map<U>(callback: (value: T) => U): ArrayIterator<U>;
+        filter(predicate: (value: T) => boolean): ArrayIterator<T>;
+        take(count: number): ArrayIterator<T>;
+        drop(count: number): ArrayIterator<T>;
+        flatMap<U>(callback: (value: T) => U[]): ArrayIterator<U>;
+        reduce<U>(callback: (acc: U, value: T) => U, initialValue: U): U;
+        toArray(): T[];
+        forEach(callback: (value: T) => void): void;
+        some(predicate: (value: T) => boolean): boolean;
+        every(predicate: (value: T) => boolean): boolean;
+        find(predicate: (value: T) => boolean): T | undefined;
+    }
+}
+
+interface ExternalAssignment {
+    placeholder: number;
+    value: number;
+}
+declare function ExternallyAssigned<This extends object, Value>(_target: undefined, context: ClassFieldDecoratorContext<This, Value>): void;
+
+declare abstract class TrackedObjectBase implements ITracked {
+    readonly tracker: Tracker;
+    private _dirtyCounter;
+    private _validationMessages;
+    private _isValid;
+    get validationMessages(): Map<string, string | undefined>;
+    private set validationMessages(value);
+    get isValid(): boolean;
+    private set isValid(value);
+    get isDirty(): boolean;
+    get dirtyCounter(): number;
+    protected set dirtyCounter(value: number);
+    constructor(tracker: Tracker);
+    abstract onCommitted(lastOp?: Operation): void;
+    abstract markDeletion(): void;
+    abstract markAsNew(): void;
+    applyExternalAssignments(keys: ExternalAssignment[], lastOp?: Operation): void;
+    validate(property: string, errorMessage: string | undefined): void;
+    destroy(): void;
+}
+
+declare class Tracker {
+    private _currentOperation;
+    private readonly _redoOperations;
+    private readonly _undoOperations;
+    private _commitStateOperation;
+    private _isDirty;
+    private _canUndo;
+    private _canRedo;
+    private _suppressTrackingCounter;
+    private _currentOperationOwner;
+    private _currentOperationPropertyName;
+    private _isValid;
+    private _canCommit;
+    private _externallyAssignedPlaceholderCounter;
+    readonly coalescingWindowMs: number | undefined;
+    readonly trackedObjects: TrackedObjectBase[];
+    readonly trackedCollections: TrackedCollection<any>[];
+    get isDirty(): boolean;
+    set isDirty(value: boolean);
+    readonly isDirtyChanged: TypedEvent<boolean>;
+    get isValid(): boolean;
+    private set isValid(value);
+    readonly isValidChanged: TypedEvent<boolean>;
+    get canCommit(): boolean;
+    private set canCommit(value);
+    readonly canCommitChanged: TypedEvent<boolean>;
+    private updateCanCommit;
+    get canUndo(): boolean;
+    private set canUndo(value);
+    get canRedo(): boolean;
+    private set canRedo(value);
+    get isTrackingSuppressed(): boolean;
+    constructor(coalescingWindowMs?: number | undefined);
+    trackObject(trackedObject: TrackedObjectBase): void;
+    untrackObject(trackedObject: TrackedObjectBase): void;
+    trackCollection(trackedCollection: TrackedCollection<any>): void;
+    untrackCollection(trackedCollection: TrackedCollection<any>): void;
+    withTrackingSuppressed(action: () => void): void;
+    beginSuppressTracking(): void;
+    endSuppressTracking(): void;
+    doAndTrack(redoAction: () => void, undoAction: () => void, properties: OperationProperties): void;
+    private isEndingCurrentOperation;
+    private isStartingNewOperation;
+    private shouldCoalesceChanges;
+    private isCoalescibleType;
+    private hasLastOperation;
+    private lastOperationTargetsSameProperty;
+    private lastActionIsRecent;
+    onCommit(keys?: ExternalAssignment[]): void;
+    isInUndoStack(op: Operation): boolean;
+    beforeCommit(): void;
+    private reset;
+    undo(): void;
+    redo(): void;
+    revalidate(): void;
+}
+
+declare enum ObjectState {
+    New = "New",
+    Unchanged = "Unchanged",
+    Edited = "Edited",
+    Deleted = "Deleted"
+}
+
+declare abstract class TrackedObject extends TrackedObjectBase {
+    _committedState: ObjectState;
+    get state(): ObjectState;
+    constructor(tracker: Tracker, initialState?: ObjectState);
+    onCommitted(_lastOp?: Operation): void;
+    markDeletion(): void;
+    markAsNew(): void;
+}
+
+declare enum VersionedObjectState {
+    New = "New",
+    Unchanged = "Unchanged",
+    Edited = "Edited",
+    Deleted = "Deleted",
+    InsertReverted = "InsertReverted",
+    EditReverted = "EditReverted",
+    DeleteReverted = "DeleteReverted"
+}
+
+declare abstract class VersionedTrackedObject extends TrackedObjectBase {
+    _committedState: VersionedObjectState;
+    readonly pendingHardDeletes: Set<number>;
+    get state(): VersionedObjectState;
+    constructor(tracker: Tracker, initialState?: VersionedObjectState);
+    onCommitted(lastOp?: Operation): void;
+    applyExternalAssignments(keys: ExternalAssignment[], lastOp?: Operation): void;
+    markAsNew(): void;
+    markDeletion(): void;
+    private revertedStateFor;
+}
+
+declare function InitializeTracked<T extends new (...args: any[]) => any>(target: T, context: ClassDecoratorContext): T;
+
+declare function Tracked<T extends TrackedObjectBase, V>(validator?: (self: T, newValue: V) => string | undefined, options?: {
+    noCoalesce?: boolean;
+}): {
+    (target: ClassAccessorDecoratorTarget<T, V>, context: ClassAccessorDecoratorContext): ClassAccessorDecoratorResult<T, V>;
+    (target: (this: T, value: V) => void, context: ClassSetterDecoratorContext): (this: T, value: V) => void;
+};
+
+export { ExternallyAssigned, type ExternalAssignment as ExternallyAssignment, type ITracked, InitializeTracked, ObjectState, OperationProperties, PropertyType, Tracked, TrackedCollection, TrackedCollectionChanged, TrackedObject, TrackedObjectBase, Tracker, TypedEvent, VersionedObjectState, VersionedTrackedObject };