Skip to content

An open-source, privacy-first, self-hosted knowledge workspace where humans and AI agents work together 开源、隐私优先、自托管的知识工作空间,让人与智能体在此协作

7.9 KB
Raw Blame
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();
    });
};