mirror of
https://github.com/wavetermdev/waveterm.git
synced 2025-03-02 04:02:13 +01:00
f12e246c15
I am updating the layout node setup to write to its own wave object. The existing setup requires me to plumb the layout updates through every time the tab gets updated, which produces a lot of annoying and unintuitive design patterns. With this new setup, the tab object doesn't get written to when the layout changes, only the layout object will get written to. This prevents collisions when both the tab object and the layout node object are getting updated, such as when a new block is added or deleted.
138 lines
3.5 KiB
TypeScript
138 lines
3.5 KiB
TypeScript
// Copyright 2024, Command Line Inc.
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
import { WritableAtom } from "jotai";
|
|
import { DropDirection, FlexDirection } from "./utils.js";
|
|
|
|
/**
|
|
* Represents an operation to insert a node into a tree.
|
|
*/
|
|
export type MoveOperation<T> = {
|
|
/**
|
|
* The index at which the node will be inserted in the parent.
|
|
*/
|
|
index: number;
|
|
|
|
/**
|
|
* The parent node. Undefined if inserting at root.
|
|
*/
|
|
parentId?: string;
|
|
|
|
/**
|
|
* Whether the node will be inserted at the root of the tree.
|
|
*/
|
|
insertAtRoot?: boolean;
|
|
|
|
/**
|
|
* The node to insert.
|
|
*/
|
|
node: LayoutNode<T>;
|
|
};
|
|
|
|
/**
|
|
* Types of actions that modify the layout tree.
|
|
*/
|
|
export enum LayoutTreeActionType {
|
|
ComputeMove = "computeMove",
|
|
Move = "move",
|
|
CommitPendingAction = "commit",
|
|
ResizeNode = "resize",
|
|
InsertNode = "insert",
|
|
DeleteNode = "delete",
|
|
}
|
|
|
|
/**
|
|
* Base class for actions that modify the layout tree.
|
|
*/
|
|
export interface LayoutTreeAction {
|
|
type: LayoutTreeActionType;
|
|
}
|
|
|
|
/**
|
|
* Action for computing a move operation and saving it as a pending action in the tree state.
|
|
*
|
|
* @template T The type of data associated with the nodes of the tree.
|
|
* @see MoveOperation
|
|
* @see LayoutTreeMoveNodeAction
|
|
*/
|
|
export interface LayoutTreeComputeMoveNodeAction<T> extends LayoutTreeAction {
|
|
type: LayoutTreeActionType.ComputeMove;
|
|
node: LayoutNode<T>;
|
|
nodeToMove: LayoutNode<T>;
|
|
direction: DropDirection;
|
|
}
|
|
|
|
/**
|
|
* Action for moving a node within the layout tree.
|
|
*
|
|
* @template T The type of data associated with the nodes of the tree.
|
|
* @see MoveOperation
|
|
*/
|
|
export interface LayoutTreeMoveNodeAction<T> extends LayoutTreeAction, MoveOperation<T> {
|
|
type: LayoutTreeActionType.Move;
|
|
}
|
|
|
|
/**
|
|
* Action for committing a pending action to the layout tree.
|
|
*/
|
|
export interface LayoutTreeCommitPendingAction extends LayoutTreeAction {
|
|
type: LayoutTreeActionType.CommitPendingAction;
|
|
}
|
|
|
|
/**
|
|
* Action for inserting a new node to the layout tree.
|
|
*
|
|
* @template T The type of data associated with the nodes of the tree.
|
|
*/
|
|
export interface LayoutTreeInsertNodeAction<T> extends LayoutTreeAction {
|
|
type: LayoutTreeActionType.InsertNode;
|
|
node: LayoutNode<T>;
|
|
}
|
|
|
|
/**
|
|
* Action for deleting a node from the layout tree.
|
|
*/
|
|
export interface LayoutTreeDeleteNodeAction extends LayoutTreeAction {
|
|
type: LayoutTreeActionType.DeleteNode;
|
|
nodeId: string;
|
|
}
|
|
|
|
/**
|
|
* Represents the state of a layout tree.
|
|
*
|
|
* @template T The type of data associated with the nodes of the tree.
|
|
*/
|
|
export type LayoutTreeState<T> = {
|
|
rootNode: LayoutNode<T>;
|
|
leafs: LayoutNode<T>[];
|
|
pendingAction: LayoutTreeAction;
|
|
};
|
|
|
|
/**
|
|
* Represents a single node in the layout tree.
|
|
* @template T The type of data associated with the node.
|
|
*/
|
|
export interface LayoutNode<T> {
|
|
id: string;
|
|
data?: T;
|
|
children?: LayoutNode<T>[];
|
|
flexDirection: FlexDirection;
|
|
size?: number;
|
|
}
|
|
|
|
/**
|
|
* An abstraction of the type definition for a writable layout node atom.
|
|
*/
|
|
export type WritableLayoutNodeAtom<T> = WritableAtom<LayoutNode<T>, [value: LayoutNode<T>], void>;
|
|
|
|
/**
|
|
* An abstraction of the type definition for a writable layout tree state atom.
|
|
*/
|
|
export type WritableLayoutTreeStateAtom<T> = WritableAtom<LayoutTreeState<T>, [value: LayoutTreeState<T>], void>;
|
|
|
|
export type ContentRenderer<T> = (data: T, ready: boolean, onClose?: () => void) => React.ReactNode;
|
|
|
|
export interface LayoutNodeWaveObj<T> extends WaveObj {
|
|
node: LayoutNode<T>;
|
|
}
|