An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作
TypeScript agentic-aiai-agentknowledge-baselocal-firstmarkdownmcpmindmapnote-takingself-hostedsiyuanworkspace
import {Constants} from "../../constants";
import {
getCenterMinimumSize,
type ICenterMinimumLayoutNode,
resolveDockResponsiveLayout,
resolveDockResponsiveWidth,
resolveResponsiveManualOverrideClearance,
} from "./responsiveLayout";
import {runWithoutDockTransitions} from "./responsiveTransition";
const EDITOR_MINIMUM_WIDTH = 480;
const RESPONSIVE_HYSTERESIS = 32;
let frameId = 0;
let applying = false;
interface IRuntimeLayoutNode {
direction?: Config.TUILayoutDirection,
children?: unknown[],
element?: HTMLElement,
}
const getLayoutNode = (item: IRuntimeLayoutNode): ICenterMinimumLayoutNode => {
const isLayout = item.direction === "lr" || item.direction === "tb";
return {
inactive: item.element?.classList.contains("fn__none"),
direction: isLayout ? item.direction : undefined,
children: isLayout ? item.children?.map((child) => getLayoutNode(child as IRuntimeLayoutNode)) : undefined,
};
};
const hasCenterMaximumWidth = (item: IRuntimeLayoutNode): boolean => {
return item.children?.some((child) => {
const childItem = child as IRuntimeLayoutNode;
if (childItem.element?.style.maxWidth ||
childItem.element?.hasAttribute(Constants.ATTRIBUTE_DOCK_WIDTH)) {
return true;
}
return (childItem.direction === "lr" || childItem.direction === "tb") &&
hasCenterMaximumWidth(childItem);
}) ?? false;
};
const getLayoutGap = () => {
const value = parseFloat(getComputedStyle(document.documentElement).getPropertyValue("--b3-layout-space"));
return Number.isFinite(value) ? Math.max(0, value) : 0;
};
const updateResponsiveWidth = (
dock: typeof window.siyuan.layout.leftDock,
preferredSize: number,
fixedSize: number,
active: boolean,
) => {
const element = dock.layout.element;
const hasResponsiveWidth = Boolean(element.style.maxWidth ||
element.hasAttribute(Constants.ATTRIBUTE_DOCK_WIDTH));
const result = resolveDockResponsiveWidth({
active,
preferredSize,
fixedSize,
floating: dock.isResponsiveFloating(),
constrained: hasResponsiveWidth,
});
if (result.clearConstraint) {
element.style.maxWidth = "";
element.removeAttribute(Constants.ATTRIBUTE_DOCK_WIDTH);
}
if (typeof result.width === "number") {
const width = result.width + "px";
if (element.style.width !== width) {
element.style.width = width;
}
}
if (typeof result.maximumWidth === "number") {
const preferredWidth = preferredSize.toString();
const maximumWidth = result.maximumWidth + "px";
if (element.getAttribute(Constants.ATTRIBUTE_DOCK_WIDTH) !== preferredWidth) {
element.setAttribute(Constants.ATTRIBUTE_DOCK_WIDTH, preferredWidth);
}
if (element.style.maxWidth !== maximumWidth) {
element.style.maxWidth = maximumWidth;
}
}
};
export const reconcileResponsiveDockLayout = () => {
if (applying) {
return;
}
const layout = window.siyuan?.layout;
const leftDock = layout?.leftDock;
const rightDock = layout?.rightDock;
const centerLayout = layout?.centerLayout;
const outerLayout = centerLayout?.parent;
if (!leftDock || !rightDock || !outerLayout || outerLayout.direction !== "lr") {
return;
}
const availableSize = outerLayout.element.clientWidth;
if (availableSize <= 0) {
return;
}
applying = true;
try {
const centerSizeBefore = centerLayout.element.clientWidth;
const gapSize = getLayoutGap();
const centerMinimumSize = Math.max(EDITOR_MINIMUM_WIDTH, getCenterMinimumSize(
getLayoutNode(centerLayout),
EDITOR_MINIMUM_WIDTH,
gapSize,
));
const leftPreferredSize = leftDock.getResponsivePreferredSize();
const rightPreferredSize = rightDock.getResponsivePreferredSize();
const leftActive = leftDock.hasActive();
const rightActive = rightDock.hasActive();
const leftParticipating = leftDock.pin && leftDock.isPanelVisible();
const rightParticipating = rightDock.pin && rightDock.isPanelVisible();
const overrideClearance = resolveResponsiveManualOverrideClearance(
availableSize, centerMinimumSize, gapSize, RESPONSIVE_HYSTERESIS,
{
preferredSize: leftPreferredSize,
pinned: leftDock.pin,
visible: leftDock.isPanelVisible(),
active: leftActive,
manualOverride: leftDock.hasResponsiveManualOverride(),
},
{
preferredSize: rightPreferredSize,
pinned: rightDock.pin,
visible: rightDock.isPanelVisible(),
active: rightActive,
manualOverride: rightDock.hasResponsiveManualOverride(),
},
);
if (overrideClearance.left) {
leftDock.clearResponsiveManualOverride();
}
if (overrideClearance.right) {
rightDock.clearResponsiveManualOverride();
}
const result = resolveDockResponsiveLayout({
availableSize,
centerMinimumSize,
gapSize,
hysteresis: RESPONSIVE_HYSTERESIS,
left: {
preferredSize: leftPreferredSize,
minimumSize: leftDock.getResponsiveMinimumSize(),
participating: leftParticipating,
autoFloating: leftDock.isResponsiveFloating(),
manualOverride: leftDock.hasResponsiveManualOverride(),
},
right: {
preferredSize: rightPreferredSize,
minimumSize: rightDock.getResponsiveMinimumSize(),
participating: rightParticipating,
autoFloating: rightDock.isResponsiveFloating(),
manualOverride: rightDock.hasResponsiveManualOverride(),
},
});
const floatingStateChanged = result.left.autoFloating !== leftDock.isResponsiveFloating() ||
result.right.autoFloating !== rightDock.isResponsiveFloating();
const applyResult = () => {
// 拉宽时先恢复左侧,再恢复右侧。
if (!result.left.autoFloating && leftDock.isResponsiveFloating()) {
leftDock.setResponsiveFloating(false, leftPreferredSize);
}
if (!result.right.autoFloating && rightDock.isResponsiveFloating()) {
rightDock.setResponsiveFloating(false, rightPreferredSize);
}
// 缩窄时先浮动右侧,再浮动左侧。
if (result.right.autoFloating && !rightDock.isResponsiveFloating()) {
rightDock.setResponsiveFloating(true, rightPreferredSize);
}
if (result.left.autoFloating && !leftDock.isResponsiveFloating()) {
leftDock.setResponsiveFloating(true, leftPreferredSize);
}
updateResponsiveWidth(leftDock, leftPreferredSize, result.left.fixedSize, leftActive);
updateResponsiveWidth(rightDock, rightPreferredSize, result.right.fixedSize, rightActive);
if (centerLayout.element.clientWidth !== centerSizeBefore && hasCenterMaximumWidth(centerLayout)) {
leftDock.adjustResponsiveCenterLayout();
}
};
if (floatingStateChanged) {
runWithoutDockTransitions([
leftDock.layout.element,
rightDock.layout.element,
], applyResult, () => {
void outerLayout.element.offsetWidth;
});
} else {
applyResult();
}
} finally {
applying = false;
}
};
export const requestResponsiveDockLayout = () => {
if (applying || frameId) {
return;
}
frameId = requestAnimationFrame(() => {
frameId = 0;
reconcileResponsiveDockLayout();
});
};