Proyectos de Subversion Moodle

// This file is part of Moodle - http://moodle.org/

//

// Moodle is free software: you can redistribute it and/or modify

// it under the terms of the GNU General Public License as published by

// the Free Software Foundation, either version 3 of the License, or

// (at your option) any later version.

//

// Moodle is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

//

// You should have received a copy of the GNU General Public License

// along with Moodle.  If not, see <http://www.gnu.org/licenses/>.

/**

 * Tiny AI Mark Changed text.

 *

 * This module marks text that was returned by the AI service

 * and that has been changed by a human prior to being inserted.

 *

 * @module      tiny_aiplacement/textmark

 * @copyright   2023 Matt Porritt <matt.porritt@moodle.com>

 * @license     http://www.gnu.org/copyleft/gpl.html GNU GPL v3 or later

 */

export default class TinyAiTextMarker {

    /**

     * Finds the longest common subsequence of two strings.

     *

     * @param {string} a The first string.

     * @param {string} b The second string.

     * @returns {string} The longest common subsequence.

     */

    static longestCommonSubsequence(a, b) {

        const lengths = Array(a.length + 1)

            .fill(null)

            .map(() => Array(b.length + 1).fill(0));

        for (let i = 0; i < a.length; i++) {

            for (let j = 0; j < b.length; j++) {

                if (a[i] === b[j]) {

                    lengths[i + 1][j + 1] = lengths[i][j] + 1;

                } else {

                    lengths[i + 1][j + 1] = Math.max(lengths[i + 1][j], lengths[i][j + 1]);

                }

            }

        }

        let i = a.length;

        let j = b.length;

        let lcs = '';

        while (i > 0 && j > 0) {

            if (a[i - 1] === b[j - 1]) {

                lcs = a[i - 1] + lcs;

                i--;

                j--;

            } else if (lengths[i - 1][j] > lengths[i][j - 1]) {

                i--;

            } else {

                j--;

            }

        }

        return lcs;

    }

    /**

     * Finds the differences between the original and edited text using the LCS algorithm.

     *

     * @param {string} originalText The original text.

     * @param {string} editedText The edited text.

     * @returns {Array<Object>} An array of difference objects with start, end, and text properties.

     */

    static findDifferences(originalText, editedText) {

        const lcs = TinyAiTextMarker.longestCommonSubsequence(originalText, editedText);

        let differences = [];

        let i = 0;

        let j = 0;

        for (let k = 0; k < lcs.length; k++) {

            let commonChar = lcs[k];

            while (originalText[i] !== commonChar || editedText[j] !== commonChar) {

                let start = j;

                while (editedText[j] !== commonChar) {

                    j++;

                }

                let editedSection = editedText.slice(start, j);

                differences.push({start, end: j, text: editedSection});

                while (originalText[i] !== commonChar) {

                    i++;

                }

            }

            i++;

            j++;

        }

        if (j < editedText.length) {

            differences.push({start: j, end: editedText.length, text: editedText.slice(j)});

        }

        return differences;

    }

    /**

     * Wraps the given edited section in a span tag with a 'user-edited' class.

     *

     * @param {string} editedSection The edited section of the text.

     * @returns {Promise<string>} A promise that resolves with the wrapped edited section.

     */

    static async wrapInSpan(editedSection) {

        return new Promise((resolve, reject) => {

            try {

                let wrappedText = `<span class="user-edited">${editedSection}</span>`;

                resolve(wrappedText);

            } catch (error) {

                reject(error);

            }

        });

    }

    /**

     * Wraps the edited sections of the text in span tags with a 'user-edited' class.

     *

     * @param {string} originalText The original text.

     * @param {string} editedText The edited text.

     * @returns {Promise<string>} A promise that resolves with the edited text, where edited sections are wrapped in span tags.

     */

    static async wrapEditedSections(originalText, editedText) {

        let differences = TinyAiTextMarker.findDifferences(originalText, editedText);

        let wrappedText = editedText;

        for (let i = differences.length - 1; i >= 0; i--) {

            let {start, end, text} = differences[i];

            let wrappedSection = await TinyAiTextMarker.wrapInSpan(text);

            wrappedText = wrappedText.slice(0, start) + wrappedSection + wrappedText.slice(end);

        }

        return wrappedText;

    }

}