How to calculate the estimated reading time of your text using an ONLYOFFICE macro

Estimating reading time is a valuable feature in text editors, allowing users to determine how long it might take to read a document. One of our interns, Vukasin created a quirky yet effective macro that calculates the estimated reading time within the ONLYOFFICE Document Editor. In this article, we’ll break down the macro, explaining how each function works and how they come together to provide an accurate reading time estimate.

Building the macro

First we retrieve the document object using the Api.GetDocument() method:

try {
        const document = Api.GetDocument();

Defining constants

      // Constants for reading speed calculations
        const WORDS_PER_MINUTE = 238; // Average adult reading speed
        const COMPLEX_WORD_LENGTH = 7; // Words with this many chars or more are considered complex

Here, two constants are defined:

• WORDS_PER_MINUTE: The average reading speed of an adult (238 words per minute).
• COMPLEX_WORD_LENGTH: A threshold  to determine if a word is complex.

Counting words

Then the countWords function splits the given text into words based on white spaces and counts the number of non-empty words:

 function countWords(text) {
            if (!text) return 0;
            return text.split(/\s+/).filter((word) => word.length > 0).length;
        }

Estimating complexity

To estimate the complexity we use the estimatedComplexety function:

   function estimateComplexity(text) {
            if (!text) return 0;
            const words = text.split(/\s+/).filter((word) => word.length > 0);
            if (words.length === 0) return 0;


            const complexWords = words.filter(
                (word) => word.length >= COMPLEX_WORD_LENGTH
            ).length;
            return complexWords / words.length;
        }

This function determines the complexity of the text by:

1. Splitting it into words.
2. Filtering out words that have fewer than 7 characters.
3. Calculating the ratio of complex words to the total word count.

Retrieving and processing paragraphs

Then we continue processing the text:

        const paragraphs = document.GetAllParagraphs();
        let totalWords = 0;
        let totalText = "";


        paragraphs.forEach((paragraph) => {
            const text = paragraph.GetText();
            totalWords += countWords(text);
            totalText += text + " ";
        });

In this section we do the following:

1. Retrieve all paragraphs from the document.
2. Loop through each paragraph to extract text.
3. Count the words in each paragraph and accumulate the total word count.
4. Store all text for complexity estimation.

Adjusting for complexity

Here, the complexity factor is used to adjust the reading speed. A higher complexity results in a lower effective reading speed:

        const complexityFactor = estimateComplexity(totalText);
        const complexityAdjustment = 1 - complexityFactor * 0.3;
        const effectiveWPM = WORDS_PER_MINUTE * complexityAdjustment;

Calculating reading time

Then we convert the total words into minutes and further into hours:

        const readingTimeMinutes = totalWords / effectiveWPM;
        const readingTimeHours = readingTimeMinutes / 60;

Formatting the output

After that, we format the reading time output based on the calculated time.

    let readingTimeText;
        if (readingTimeMinutes < 1) {
            readingTimeText = `less than 1 minute`;
        } else if (readingTimeMinutes < 60) {
            readingTimeText = `${Math.ceil(readingTimeMinutes)} minute${Math.ceil(readingTimeMinutes) !== 1 ? "s" : ""
                }`;
        } else {
            const hours = Math.floor(readingTimeHours);
            const remainingMinutes = Math.ceil((readingTimeHours - hours) * 60);
            readingTimeText = `${hours} hour${hours !== 1 ? "s" : ""}${remainingMinutes > 0
                    ? ` and ${remainingMinutes} minute${remainingMinutes !== 1 ? "s" : ""
                    }`
                    : ""
                }`;
        }

Inserting output

Then we insert the formatted output:

      const infoText = `Reading Time: ${readingTimeText} (${totalWords} words at ${Math.round(
            effectiveWPM
        )} words per minute)`;


        const oParagraph = Api.CreateParagraph();
        oParagraph.AddText(infoText);
        oParagraph.SetBold(true);
        oParagraph.SetItalic(true);
        oParagraph.SetFontFamily("Arial");
        document.InsertContent([oParagraph], 0);
    } catch (error) {
        console.log("Error: " + error.message);
    }
})();

This section:

1. Creates a formatted string with reading time details.
2. Creates a new paragraph object and adds text to it.
3. Applies styling (bold, italic, and Arial font).
4. Inserts the paragraph at the beginning of the document.

The entire macro code is the following:

(function () {
    try {
        const document = Api.GetDocument();
        // Constants for reading speed calculations
        const WORDS_PER_MINUTE = 238; // Average adult reading speed
        const COMPLEX_WORD_LENGTH = 7; // Words with this many chars or more are considered complex


        function countWords(text) {
            if (!text) return 0;
            return text.split(/\s+/).filter((word) => word.length > 0).length;
        }


        function estimateComplexity(text) {
            if (!text) return 0;
            const words = text.split(/\s+/).filter((word) => word.length > 0);
            if (words.length === 0) return 0;


            const complexWords = words.filter(
                (word) => word.length >= COMPLEX_WORD_LENGTH
            ).length;
            return complexWords / words.length;
        }


        const paragraphs = document.GetAllParagraphs();
        let totalWords = 0;
        let totalText = "";


        paragraphs.forEach((paragraph) => {
            const text = paragraph.GetText();
            totalWords += countWords(text);
            totalText += text + " ";
        });


        const complexityFactor = estimateComplexity(totalText);


        const complexityAdjustment = 1 - complexityFactor * 0.3;
        const effectiveWPM = WORDS_PER_MINUTE * complexityAdjustment;


        const readingTimeMinutes = totalWords / effectiveWPM;
        const readingTimeHours = readingTimeMinutes / 60;


        let readingTimeText;
        if (readingTimeMinutes < 1) {
            readingTimeText = `less than 1 minute`;
        } else if (readingTimeMinutes < 60) {
            readingTimeText = `${Math.ceil(readingTimeMinutes)} minute${Math.ceil(readingTimeMinutes) !== 1 ? "s" : ""
                }`;
        } else {
            const hours = Math.floor(readingTimeHours);
            const remainingMinutes = Math.ceil((readingTimeHours - hours) * 60);
            readingTimeText = `${hours} hour${hours !== 1 ? "s" : ""}${remainingMinutes > 0
                    ? ` and ${remainingMinutes} minute${remainingMinutes !== 1 ? "s" : ""
                    }`
                    : ""
                }`;
        }


        const infoText = `Reading Time: ${readingTimeText} (${totalWords} words at ${Math.round(
            effectiveWPM
        )} words per minute)`;


        const oParagraph = Api.CreateParagraph();
        oParagraph.AddText(infoText);
        oParagraph.SetBold(true);
        oParagraph.SetItalic(true);
        oParagraph.SetFontFamily("Arial");
        document.InsertContent([oParagraph], 0);
    } catch (error) {
        console.log("Error: " + error.message);
    }
})();

Now let’s run our macro and see how it works!

This macro provides a smart way to estimate reading time in ONLYOFFICE and we hope it will become a useful addition to your work kit. ONLYOFFICE macros are versatile tools that help significantly enhance the default functionality and craft scripts that are tailored specifically to your needs. We encourage you to explore our API methods library and develop your own macros. If you have any questions or ideas, feel free to reach out! We’re always open to feedback and collaboration. Best of luck in your exploratory endeavors!

About the macro author