@knotx/data 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,314 @@
+import { Subject, OperatorFunction, BehaviorSubject, Observable } from 'rxjs';
+
+interface IData {
+    id: string;
+}
+interface DataOperationPipe<T extends IData = IData> {
+    /**
+     * 用于转换操作，最先执行
+     */
+    transform?: (operations$: Subject<DataOperation<T>>) => OperatorFunction<DataOperation<T>, DataOperation<T>>;
+    /**
+     * 操作执行前处理，操作在此阶段不应该被转换
+     */
+    preOperation?: (operations$: Subject<DataOperation<T>>) => OperatorFunction<DataOperation<T>, DataOperation<T>>;
+    /**
+     * 操作执行后处理，操作在此阶段不应该被转换
+     */
+    postOperation?: (operations$: Subject<DataOperation<T>>) => OperatorFunction<{
+        dataMap: Map<string, T>;
+        operations: DataOperation<T>[];
+    }, {
+        dataMap: Map<string, T>;
+        operations: DataOperation<T>[];
+    }>;
+}
+interface DataAddOperation<T extends IData = IData> {
+    type: 'add';
+    data: T;
+}
+interface DataRemoveOperation<_T extends IData = IData> {
+    type: 'remove';
+    id: string;
+}
+interface DataUpdateOperation<T extends IData = IData> {
+    type: 'update';
+    id: string;
+    data: Partial<T>;
+}
+interface DataBatchOperation<T extends IData = IData> {
+    type: 'batch';
+    operations: DataOperation<T>[];
+    isInit?: boolean;
+}
+interface DataStartDraftOperation<_T extends IData = IData> {
+    type: 'startDraft';
+    draftId: string;
+}
+interface DataCommitDraftOperation<_T extends IData = IData> {
+    type: 'commitDraft';
+    draftId: string;
+}
+interface DataDiscardDraftOperation<_T extends IData = IData> {
+    type: 'discardDraft';
+    draftId: string;
+}
+interface DataDraftOperation<T extends IData = IData> {
+    type: 'draftOperation';
+    draftId: string;
+    operation: Exclude<DataOperation<T>, {
+        draftId: string;
+    }>;
+}
+type DataOperation<T extends IData = IData> = DataAddOperation<T> | DataRemoveOperation<T> | DataUpdateOperation<T> | DataBatchOperation<T> | DataStartDraftOperation<T> | DataCommitDraftOperation<T> | DataDiscardDraftOperation<T> | DataDraftOperation<T>;
+declare class DataManager<TData extends IData = IData, TTag extends string = any> {
+    readonly tag: TTag;
+    private operations$;
+    private operationPipes$;
+    private drafts$;
+    readonly dataMap$: BehaviorSubject<Map<string, TData>>;
+    readonly currentDraftDataMap$: BehaviorSubject<Map<string, false | TData> | undefined>;
+    /**
+     * 数据版本号，用于标识数据的变化，数据更新时，patchVersion 会递增
+     */
+    readonly patchVersion$: BehaviorSubject<number>;
+    /**
+     * 数据版本号，用于标识数据的变化，数据增删时，mapVersion 会递增
+     */
+    readonly mapVersion$: BehaviorSubject<number>;
+    get version(): number;
+    private _patchVersionUpdating;
+    private _mapVersionUpdating;
+    constructor(tag: TTag);
+    getDataList$(): Observable<TData[]>;
+    getDataList(): TData[];
+    getData$(id: string, equal?: (a?: TData, b?: TData) => boolean): Observable<TData | undefined>;
+    getData(id: string): TData | undefined;
+    addDataOperationPipe(pipe: DataOperationPipe<TData>): void;
+    init(initialDataList?: TData[]): void;
+    getOperations$(): Observable<DataOperation<TData>>;
+    dispatch(operation: DataOperation<TData>): void;
+    getDraftDataList(draftId: string): TData[] | undefined;
+    getDraftData(draftId: string, dataId: string): TData | undefined;
+    getCurrentDraftData(dataId: string): TData | undefined;
+    private applyOperation;
+    private updateVersion;
+    private isPatchOperation;
+    private isMapOperation;
+}
+
+/**
+ * 变更类型枚举
+ */
+declare enum ChangeType {
+    ADD = "add",
+    REMOVE = "remove"
+}
+/**
+ * 变更记录接口
+ */
+interface ChangeRecord<P, C> {
+    parent: P;
+    children: C[];
+    type: ChangeType;
+    timestamp: number;
+}
+/**
+ * DualRelation配置接口
+ */
+interface DualRelationOptions {
+    /**
+     * 是否允许父节点没有子节点
+     */
+    allowEmptyParent?: boolean;
+    /**
+     * 历史变更记录的最大数量
+     */
+    historyDepth?: number;
+}
+/**
+ * DualRelation 类用于管理父子节点之间的双向关系
+ * @template P 父节点类型
+ * @template C 子节点类型
+ */
+declare class DualRelation<P, C> {
+    private parentToChildren;
+    private childToParent;
+    private _version;
+    private _versionSubject;
+    private _batchUpdateMode;
+    private _hasPendingChanges;
+    private _changeHistory;
+    private _options;
+    private _pendingChanges;
+    private _nodeLevels;
+    private _needsLevelRecalculation;
+    /**
+     * 获取版本变更的Observable
+     */
+    get version(): BehaviorSubject<number>;
+    /**
+     * 获取变更历史记录
+     */
+    get changeHistory(): ReadonlyArray<ChangeRecord<P, C>>;
+    constructor(options?: DualRelationOptions);
+    /**
+     * 更新配置选项
+     * @param options 新的配置选项
+     */
+    updateOptions(options: Partial<DualRelationOptions>): void;
+    /**
+     * 获取节点的层级
+     * 层级定义：
+     * 0: 不在关系中的节点
+     * 1: 顶层父节点(没有父节点的节点)
+     * n > 1: 子节点的层级是其父节点的层级 + 1
+     * @param node 要查询的节点
+     * @returns 节点的层级
+     */
+    getNodeLevel(node: P | C): number;
+    /**
+     * 重新计算所有节点的层级
+     * @private
+     */
+    private recalculateAllLevels;
+    /**
+     * 更新节点层级
+     * @param node 要更新的节点
+     * @param parent 节点的父节点
+     * @private
+     */
+    private updateNodeLevel;
+    /**
+     * 递归更新所有子节点的层级
+     * @param parent 父节点
+     * @param parentLevel 父节点的层级
+     * @private
+     */
+    private updateChildrenLevels;
+    /**
+     * 记录变更
+     * @param parent 父节点
+     * @param children 子节点数组
+     * @param type 变更类型
+     * @private
+     */
+    private recordChange;
+    /**
+     * 更新版本号，用于通知外部关系发生了变化
+     * @private
+     */
+    private updateVersion;
+    /**
+     * 开始批量更新操作
+     * 在此模式下，所有导致版本变更的操作将被延迟，直到调用commitBatch
+     */
+    beginBatch(): void;
+    /**
+     * 提交批量更新，如果有变更则更新版本
+     * @returns 是否有变更被提交
+     */
+    commitBatch(): boolean;
+    /**
+     * 回滚批量更新，取消所有未提交的变更
+     * 注意：此方法不会撤销已执行的关系变更，只会阻止版本更新
+     */
+    rollbackBatch(): void;
+    /**
+     * 在批量模式中执行多个操作并自动提交
+     * @param operations 要执行的函数
+     * @returns 批量操作是否导致了版本变更
+     */
+    batch(operations: () => void): boolean;
+    /**
+     * 添加父子关系
+     * @param parent 父节点
+     * @param child 子节点
+     */
+    add(parent: P, child: C): void;
+    /**
+     * 移除子节点及其父关系
+     * @param child 子节点
+     * @returns 是否成功移除
+     */
+    removeChild(child: C): boolean;
+    /**
+     * 移除父节点及其所有子节点的关系
+     * @param parent 父节点
+     * @returns 是否成功移除
+     */
+    removeParent(parent: P): boolean;
+    /**
+     * 清空所有关系并清除历史记录
+     * @param clearHistory 是否清除历史记录，默认为true
+     */
+    clear(clearHistory?: boolean): void;
+    /**
+     * 获取所有子节点
+     * @param parent 父节点
+     * @returns 子节点集合
+     */
+    getChildren(parent: P): Set<C>;
+    /**
+     * 获取父节点
+     * @param child 子节点
+     * @returns 父节点，如果不存在则返回undefined
+     */
+    getParent(child: C): P | undefined;
+    /**
+     * 获取根节点
+     * @param node 子节点
+     * @returns 根节点，如果节点无父节点则返回该节点本身，如果检测到循环引用则返回null
+     */
+    getRootParent(node: C): P | C | null;
+    /**
+     * 检查是否存在循环引用
+     * @returns 是否存在循环引用
+     */
+    hasCircularReference(): boolean;
+    /**
+     * 添加父子关系，但会检查是否会形成循环引用
+     * @param parent 父节点
+     * @param child 子节点
+     * @returns 是否成功添加关系（如果会形成循环引用则返回false）
+     */
+    addSafe(parent: P, child: C): boolean;
+    /**
+     * 检查节点A是否是节点B的祖先节点
+     * @param nodeA 可能的祖先节点
+     * @param nodeB 待检查节点
+     * @returns 是否是祖先关系
+     */
+    private isAncestorOf;
+    /**
+     * 获取所有父节点
+     * @returns 父节点集合
+     */
+    getAllParents(): Set<P>;
+    /**
+     * 获取所有子节点
+     * @returns 子节点集合
+     */
+    getAllChildren(): Set<C>;
+    /**
+     * 检查父子关系是否存在
+     * @param parent 父节点
+     * @param child 子节点
+     * @returns 是否存在关系
+     */
+    hasRelation(parent: P, child: C): boolean;
+    /**
+     * 获取关系数量
+     * @returns 关系数量
+     */
+    size(): number;
+    /**
+     * 获取指定节点的所有后代节点（包括子节点、孙节点等）
+     * @param parent 父节点
+     * @param includeSelf 是否包含自身，默认为false
+     * @returns 所有后代节点的集合
+     */
+    getDescendants(parent: P, includeSelf?: boolean): Set<C>;
+}
+
+export { type ChangeRecord, ChangeType, type DataAddOperation, type DataBatchOperation, type DataCommitDraftOperation, type DataDiscardDraftOperation, type DataDraftOperation, DataManager, type DataOperation, type DataOperationPipe, type DataRemoveOperation, type DataStartDraftOperation, type DataUpdateOperation, DualRelation, type DualRelationOptions, type IData };