Skip to content

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

6.9 KB
Raw Blame
export const mergeEntryOrder = (defaultOrder: string[], savedOrder?: string[]) => {
    const defaultKeys = new Set(defaultOrder);
    const result = (savedOrder || []).filter((key, index, order) =>
        defaultKeys.has(key) && order.indexOf(key) === index);
    defaultOrder.forEach((key, defaultIndex) => {
        if (result.includes(key)) {
            return;
        }
        const previousKey = defaultOrder.slice(0, defaultIndex).reverse().find((item) => result.includes(item));
        if (previousKey) {
            result.splice(result.indexOf(previousKey) + 1, 0, key);
            return;
        }
        const nextKey = defaultOrder.slice(defaultIndex + 1).find((item) => result.includes(item));
        result.splice(nextKey ? result.indexOf(nextKey) : result.length, 0, key);
    });
    return result;
};

const findValidEntryOrderInterleave = (knownOrder: string[], unknownOrder: string[], slotKinds: boolean[],
                                       separatorKeys: Set<string>) => {
    const memo = new Map<string, string[] | null>();
    const visit = (knownIndex: number, unknownIndex: number, previousSeparator: boolean): string[] | undefined => {
        if (knownIndex === knownOrder.length && unknownIndex === unknownOrder.length) {
            return previousSeparator ? undefined : [];
        }
        const state = `${knownIndex}:${unknownIndex}:${previousSeparator ? 1 : 0}`;
        if (memo.has(state)) {
            return memo.get(state) || undefined;
        }
        const preferUnknown = slotKinds[knownIndex + unknownIndex] === true;
        const sources: Array<"known" | "unknown"> = preferUnknown ? ["unknown", "known"] : ["known", "unknown"];
        for (const source of sources) {
            const item = source === "known" ? knownOrder[knownIndex] : unknownOrder[unknownIndex];
            if (typeof item !== "string") {
                continue;
            }
            const separator = separatorKeys.has(item);
            if (separator && (knownIndex + unknownIndex === 0 || previousSeparator)) {
                continue;
            }
            const tail = source === "known"
                ? visit(knownIndex + 1, unknownIndex, separator)
                : visit(knownIndex, unknownIndex + 1, separator);
            if (tail) {
                const result = [item, ...tail];
                memo.set(state, result);
                return result;
            }
        }
        memo.set(state, null);
        return undefined;
    };
    return visit(0, 0, false);
};

export const mergeEntryOrderPreservingUnknown = (defaultOrder: string[], savedOrder?: string[],
                                                   knownOrder?: string[], separatorKeys?: Set<string>) => {
    const knownKeys = new Set(defaultOrder);
    const mergedKnownOrder = mergeEntryOrder(defaultOrder, knownOrder ?? savedOrder);
    let knownIndex = 0;
    const savedUniqueOrder = (savedOrder || []).filter((key, index, order) => order.indexOf(key) === index);
    const result = savedUniqueOrder
        .map((key) => {
            if (!knownKeys.has(key)) {
                return key;
            }
            return mergedKnownOrder[knownIndex++];
        })
        .filter((key): key is string => typeof key === "string");
    result.push(...mergedKnownOrder.slice(knownIndex));
    if (separatorKeys && !isValidEntryOrder(result, separatorKeys)) {
        const unknownOrder = savedUniqueOrder.filter((key) => !knownKeys.has(key));
        const slotKinds = savedUniqueOrder.map((key) => !knownKeys.has(key));
        return findValidEntryOrderInterleave(mergedKnownOrder, unknownOrder, slotKinds, separatorKeys) || result;
    }
    return result;
};

export const isValidEntryOrder = (order: string[], separatorKeys: Set<string>) => {
    if (order.length === 0 || separatorKeys.has(order[0]) || separatorKeys.has(order[order.length - 1])) {
        return false;
    }
    return !order.some((key, index) => separatorKeys.has(key) && separatorKeys.has(order[index - 1]));
};

export const resolveEntryOrder = (defaultOrder: string[], savedOrder: string[] | undefined,
                                  separatorKeys: Set<string>) => {
    const merged = mergeEntryOrder(defaultOrder, savedOrder);
    return isValidEntryOrder(merged, separatorKeys) ? merged : [...defaultOrder];
};

export const resolveEntryOrderWithBoundaryDefaults = (
    defaultOrder: string[],
    savedOrder: string[] | undefined,
    boundaryKey: string,
    separatorKeys: Set<string>,
) => {
    const result = resolveEntryOrder(defaultOrder, savedOrder, separatorKeys);
    const defaultBoundaryIndex = defaultOrder.indexOf(boundaryKey);
    const boundaryIndex = result.indexOf(boundaryKey);
    if (defaultBoundaryIndex < 0 || boundaryIndex < 0) {
        return result;
    }
    const savedKeys = new Set(savedOrder || []);
    const moveBefore = defaultOrder.slice(0, defaultBoundaryIndex).filter((key) =>
        !savedKeys.has(key) && result.indexOf(key) > boundaryIndex);
    const moveAfter = defaultOrder.slice(defaultBoundaryIndex + 1).filter((key) =>
        !savedKeys.has(key) && result.indexOf(key) < boundaryIndex);
    if (moveBefore.length === 0 && moveAfter.length === 0) {
        return result;
    }
    const movedKeys = new Set([...moveBefore, ...moveAfter]);
    const constrained = result.filter((key) => !movedKeys.has(key));
    const constrainedBoundaryIndex = constrained.indexOf(boundaryKey);
    constrained.splice(constrainedBoundaryIndex, 0, ...moveBefore);
    constrained.splice(constrained.indexOf(boundaryKey) + 1, 0, ...moveAfter);
    return isValidEntryOrder(constrained, separatorKeys) ? constrained : result;
};

export const moveEntryOrder = (order: string[], sourceKey: string, targetKey: string, after: boolean,
                               separatorKeys: Set<string>) => {
    if (sourceKey === targetKey || !order.includes(sourceKey) || !order.includes(targetKey)) {
        return;
    }
    const result = order.filter((key) => key !== sourceKey);
    const targetIndex = result.indexOf(targetKey);
    result.splice(targetIndex + (after ? 1 : 0), 0, sourceKey);
    return isValidEntryOrder(result, separatorKeys) ? result : undefined;
};

export const reorderEntrySlots = <T>(items: T[], order: string[], getKey: (item: T) => string | undefined) => {
    const orderIndexes = new Map(order.map((key, index) => [key, index]));
    const configurableIndexes: number[] = [];
    const configurableItems: T[] = [];
    items.forEach((item, index) => {
        if (orderIndexes.has(getKey(item))) {
            configurableIndexes.push(index);
            configurableItems.push(item);
        }
    });
    configurableItems.sort((itemA, itemB) =>
        (orderIndexes.get(getKey(itemA)) ?? Number.MAX_SAFE_INTEGER) -
        (orderIndexes.get(getKey(itemB)) ?? Number.MAX_SAFE_INTEGER));
    const result = [...items];
    configurableIndexes.forEach((index, configurableIndex) => {
        result[index] = configurableItems[configurableIndex];
    });
    return result;
};