@katn30/trakr 1.0.0

package/dist/dev/index.d.ts

@@ -0,0 +1,369 @@
+declare class TypedEvent<T> {
+    private readonly _handlers;
+    subscribe(handler: (event: T) => void): () => void;
+    unsubscribe(handler: (event: T) => void): void;
+    emit(event: T): void;
+}
+
+declare enum State {
+    Unchanged = "Unchanged",
+    Insert = "Insert",
+    Changed = "Changed",
+    Deleted = "Deleted"
+}
+
+interface ITracked {
+    tracker: Tracker;
+    isDirty: boolean;
+    dirtyCounter: number;
+    state: State;
+    /** @internal */
+    _setState(value: State): void;
+    /** @internal */
+    _validate(property: string, errorMessage: string | undefined): void;
+    /** @internal */
+    _applyValidation(messages: Map<string, string>): 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 coalesceWithin?: number | undefined;
+    constructor(trackedObject: ITracked, property: string | undefined, type: PropertyType, validator?: ((trackedObjects: any, newValue: any) => string | undefined) | undefined, coalesceWithin?: number | 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;
+    private readAccess;
+    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>>;
+    readonly trackedChanged: 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);
+    /** @internal */
+    readonly state: State;
+    /** @internal */
+    _setState(_value: State): void;
+    /** @internal */
+    _validate(): void;
+    /** @internal */
+    _applyValidation(_messages: Map<string, string>): 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 IdAssignment {
+    placeholder: number;
+    value: number;
+}
+declare function AutoId<This extends object, Value>(_target: undefined, context: ClassFieldDecoratorContext<This, Value>): void;
+
+interface StateTarget {
+    idPlaceholder: number | null;
+    state: State;
+    _setState(value: State): void;
+    _getDirtyCounter(): number;
+    _setDirtyCounter(value: number): void;
+    readonly tracker: {
+        _nextPlaceholder(): number;
+    };
+}
+
+interface TrackedPropertyChanged {
+    property: string;
+    oldValue: unknown;
+    newValue: unknown;
+}
+declare abstract class TrackedObject implements ITracked, StateTarget {
+    readonly tracker: Tracker;
+    private _dirtyCounter;
+    private _validationMessages;
+    private _isValid;
+    private _state;
+    idPlaceholder: number | null;
+    readonly changed: TypedEvent<TrackedPropertyChanged>;
+    readonly trackedChanged: TypedEvent<TrackedPropertyChanged>;
+    /** @internal */
+    get state(): State;
+    /** @internal */
+    _setState(value: State): void;
+    /** @internal */
+    _getDirtyCounter(): number;
+    /** @internal */
+    _setDirtyCounter(value: number): void;
+    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);
+    /** @internal */
+    _onCommitted(lastOp?: Operation, keys?: IdAssignment[]): void;
+    /** @internal */
+    _markRemoved(): void;
+    /** @internal */
+    _markAdded(): void;
+    /** @internal */
+    _validate(property: string, errorMessage: string | undefined): void;
+    /** @internal */
+    _applyValidation(messages: Map<string, string>): 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 _placeholderCounter;
+    private _invalidCount;
+    private _constructionDepth;
+    private _composingBaseIndex;
+    private _composingRedoLength;
+    private _version;
+    _isReplaying: boolean;
+    readonly trackedObjects: TrackedObject[];
+    get deletedObjects(): TrackedObject[];
+    readonly trackedCollections: TrackedCollection<any>[];
+    get isDirty(): boolean;
+    set isDirty(value: boolean);
+    readonly isDirtyChanged: TypedEvent<boolean>;
+    get version(): number;
+    readonly versionChanged: TypedEvent<number>;
+    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);
+    /** @internal */
+    get _isTrackingSuppressed(): boolean;
+    /** @internal */
+    get _isConstructing(): boolean;
+    constructor();
+    /** @internal */
+    _trackObject(trackedObject: TrackedObject): void;
+    /** @internal */
+    _untrackObject(trackedObject: TrackedObject): void;
+    /** @internal */
+    _trackCollection(trackedCollection: TrackedCollection<any>): void;
+    /** @internal */
+    _untrackCollection(trackedCollection: TrackedCollection<any>): void;
+    /** @internal */
+    _onValidityChanged(wasValid: boolean, isNowValid: boolean): void;
+    construct<T>(action: () => T): T;
+    withTrackingSuppressed(action: () => void): void;
+    beginSuppressTracking(): void;
+    endSuppressTracking(): void;
+    /** @internal */
+    _doAndTrack(redoAction: () => void, undoAction: () => void, properties: OperationProperties): void;
+    private revalidateTargeted;
+    private isEndingCurrentOperation;
+    private isStartingNewOperation;
+    private shouldCoalesceChanges;
+    private isCoalescibleType;
+    private hasLastOperation;
+    private lastOperationTargetsSameProperty;
+    private lastActionIsRecent;
+    /** @internal */
+    _nextPlaceholder(): number;
+    onCommit(keys?: IdAssignment[]): void;
+    /** @internal */
+    _isInUndoStack(op: Operation): boolean;
+    private reset;
+    startComposing(): void;
+    endComposing(): void;
+    rollbackComposing(): void;
+    undo(): void;
+    redo(): void;
+    revalidate(): void;
+}
+
+declare function Tracked(validator?: (self: any, newValue: any) => string | undefined, onChange?: (self: any, newValue: any, oldValue: any) => void, options?: {
+    coalesceWithin?: number;
+}): {
+    <T extends TrackedObject, V>(target: ClassAccessorDecoratorTarget<T, V>, context: ClassAccessorDecoratorContext<T, V>): ClassAccessorDecoratorResult<T, V>;
+    <T extends TrackedObject, V>(target: (this: T, value: V) => void, context: ClassSetterDecoratorContext<T, V>): (this: T, value: V) => void;
+    <T extends TrackedObject, V>(target: (this: T) => V, context: ClassGetterDecoratorContext<T, V>): (this: T) => V;
+};
+
+export { AutoId, type ITracked, type IdAssignment, State, Tracked, TrackedCollection, TrackedCollectionChanged, TrackedObject, type TrackedPropertyChanged, Tracker, TypedEvent };