Skip to content

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

6.6 KB
Raw Blame
import {describe, it} from "node:test";
import * as assert from "node:assert/strict";
import {
    beginFlashcardLoad,
    createFlashcardRevealState,
    type FlashcardCreationConfig,
    hasFlashcardAnswer,
    hideFlashcardAnswer,
    revealFlashcardAfterUnfold,
    showFlashcardAnswer
} from "./flashcardMode";

const createClassElement = () => {
    const classes = new Set<string>();
    const element = {
        classList: {
            add: (...classNames: string[]) => classNames.forEach((className) => classes.add(className)),
            remove: (...classNames: string[]) => classNames.forEach((className) => classes.delete(className)),
        },
    } as unknown as Element;
    return {classes, element};
};

const createFlashcardConfig = (overrides: Partial<FlashcardCreationConfig> = {}): FlashcardCreationConfig => ({
    blockquote: false,
    callout: false,
    heading: false,
    list: false,
    mark: false,
    superBlock: false,
    ...overrides,
});

describe("flashcardMode", () => {
    it("ignores ordinary lists in document flashcards", () => {
        const element = {
            querySelector(selector: string) {
                return selector === ".list, .li" ? {} : null;
            },
        } as unknown as Element;

        assert.equal(hasFlashcardAnswer(element, createFlashcardConfig({list: true})), false);
    });

    it("detects list flashcard answers instead of leaf list cards", () => {
        const answerSelector = ".list[custom-riff-decks] .li > .list, .li[custom-riff-decks] > .list";
        const answerElement = {
            querySelector(selector: string) {
                return selector === answerSelector ? {} : null;
            },
        } as unknown as Element;
        const leafElement = {
            querySelector(selector: string) {
                return selector === ".list[custom-riff-decks], .li[custom-riff-decks]" ? {} : null;
            },
        } as unknown as Element;

        assert.equal(hasFlashcardAnswer(answerElement, createFlashcardConfig({list: true})), true);
        assert.equal(hasFlashcardAnswer(leafElement, createFlashcardConfig({list: true})), false);
    });

    it("detects structural flashcard answers", () => {
        const selectors: Array<[keyof FlashcardCreationConfig, string]> = [
            ["superBlock", ":scope > .sb[custom-riff-decks] > div:nth-of-type(n+2):not(.protyle-attr)"],
            ["blockquote", ":scope > .bq[custom-riff-decks] > [data-node-id] ~ [data-node-id]"],
            ["callout", ":scope > .callout[custom-riff-decks] > .callout-content > [data-node-id]"],
            ["heading", ":scope > div[data-type=\"NodeHeading\"][custom-riff-decks] ~ div"],
        ];

        selectors.forEach(([key, answerSelector]) => {
            const element = {
                querySelector(selector: string) {
                    return selector === answerSelector ? {} : null;
                },
            } as unknown as Element;
            assert.equal(hasFlashcardAnswer(element, createFlashcardConfig({[key]: true})), true);
        });
    });

    it("ignores ordinary structural blocks", () => {
        const ordinarySelectors = new Set([
            ":scope > .sb",
            ":scope > [data-type=\"NodeHeading\"]",
        ]);
        const element = {
            querySelector(selector: string) {
                return ordinarySelectors.has(selector) ? {} : null;
            },
        } as unknown as Element;

        assert.equal(hasFlashcardAnswer(element, createFlashcardConfig({
            heading: true,
            superBlock: true,
        })), false);
    });

    it("detects marks and skips disabled modes", () => {
        let queryCount = 0;
        const element = {
            querySelector(selector: string) {
                queryCount++;
                return selector === "span[data-type~=\"mark\"]" ? {} : null;
            },
        } as unknown as Element;

        assert.equal(hasFlashcardAnswer(element, createFlashcardConfig()), false);
        assert.equal(queryCount, 0);
        assert.equal(hasFlashcardAnswer(element, createFlashcardConfig({mark: true})), true);
    });

    it("hides and reveals the callout answer", () => {
        const {classes, element} = createClassElement();
        hideFlashcardAnswer(element, {
            blockquote: false,
            callout: true,
            heading: false,
            list: false,
            mark: false,
            superBlock: false,
        });
        assert.deepEqual([...classes], ["card__block--hidecallout"]);

        showFlashcardAnswer(element);
        assert.equal(classes.size, 0);
    });

    it("reveals an unfolded card immediately", () => {
        const state = createFlashcardRevealState();
        const generation = beginFlashcardLoad(state);
        let revealed = 0;

        assert.equal(revealFlashcardAfterUnfold({
            state,
            generation,
            reveal: () => revealed++,
        }), true);
        assert.equal(revealed, 1);
    });

    it("waits for a folded card to finish unfolding", () => {
        const state = createFlashcardRevealState();
        const generation = beginFlashcardLoad(state);
        let done: () => void;
        let revealed = 0;

        assert.equal(revealFlashcardAfterUnfold({
            state,
            generation,
            unfold: (callback) => {
                done = callback;
            },
            reveal: () => revealed++,
        }), true);
        assert.equal(revealed, 0);

        done();
        assert.equal(revealed, 1);
    });

    it("ignores repeated reveals while unfolding", () => {
        const state = createFlashcardRevealState();
        const generation = beginFlashcardLoad(state);
        let done: () => void;
        let revealed = 0;

        revealFlashcardAfterUnfold({
            state,
            generation,
            unfold: (callback) => {
                done = callback;
            },
            reveal: () => revealed++,
        });
        assert.equal(revealFlashcardAfterUnfold({
            state,
            generation,
            reveal: () => revealed++,
        }), false);

        done();
        done();
        assert.equal(revealed, 1);
    });

    it("ignores an unfold callback after loading another card", () => {
        const state = createFlashcardRevealState();
        const generation = beginFlashcardLoad(state);
        let done: () => void;
        let revealed = 0;

        revealFlashcardAfterUnfold({
            state,
            generation,
            unfold: (callback) => {
                done = callback;
            },
            reveal: () => revealed++,
        });
        beginFlashcardLoad(state);
        done();

        assert.equal(revealed, 0);
    });
});