Apply character style based on Chapter Number. GREP maybe?

Hi @Tommy30053592w60v, I think this is an interesting script project, so have a look at this. You have to first configure this part of the script to match your document:

var delimiterParagraphStyleName = "Chapter Heading";
var colorMeStyleName = "Color Me";
var colorMyTableStyleName = "Color My Table";
var colorNames = [
    'Color1',
    'Color2',
    'Color3',
    'Color4',
    'Color5',
];

Then see further instructions in the script documentation.

Try it out on the attached "demo.indd".

This concept of this script is to faciliate various changes—coloring is just a simple example—based on chapter divisions. So this could be a starting point for a more elaborate script in the future. Let me know if you end up trying it out.

- Mark

/**
 * @file Color By Chapter.js
 *
 * Apply colors based on "chapter number", derived by
 * searching for a "Chapter Heading" Paragraph Style.
 * 
 * Includes two example implementations:
 * 1. color texts set in character style "Color Me"
 * 2. color tables containing text set in character style "Color My Table"
 * 
 * Configure for your own document, or try with "demo.indd" at URL below.
 *
 * @author m1b
 * @version 2024-08-25
 * @discussion https://community.adobe.com/t5/indesign-discussions/apply-character-style-based-on-chapter-number-grep-maybe/m-p/14819501
 */
function main() {

    // set these to match your document:

    var delimiterParagraphStyleName = "Chapter Heading";
    var colorMeStyleName = "Color Me";
    var colorMyTableStyleName = "Color My Table";
    var colorNames = [
        'Color1',
        'Color2',
        'Color3',
        'Color4',
        'Color5',
        // add extra colors here
    ];

    // script starts here:

    var doc = app.activeDocument;

    // a color for each chapter
    var chapterColors = getColors(doc, colorNames);
    if (!chapterColors)
        return;

    // this paragraph style delimits chapters
    var chapterStyle = doc.paragraphStyles.itemByName(delimiterParagraphStyleName);

    if (!chapterStyle.isValid)
        return alert('Paragraph Style "' + delimiterParagraphStyleName + '" is invalid.');

    // find the chapter headings
    var chapterHeadings = findGrep(doc, { appliedParagraphStyle: chapterStyle });

    if (!chapterHeadings)
        return alert('No chapter paragraphs found!');

    // an array of all the chapter heading pages
    var chapterPages = getPages(chapterHeadings);

    // we make an allocator function based on chapter pages
    var allocateToChapters = makePageAllocator(doc.pages, chapterPages);

    // allocate the colors to all the pages
    var colorsByPage = allocateToChapters(chapterColors);

    /* ----------------------------- *
     * Example 1: color the text   *
     * ----------------------------- */
    colorMe();

    /* ----------------------------- *
     * Example 2: color the tables   *
     * ----------------------------- */
    colorTables();


    /**
     * Example 1: Color any text in "Color Me" character style.
     */
    function colorMe() {

        // get the "Color Me" character style
        var colorMeStyle = doc.characterStyles.itemByName(colorMeStyleName);

        if (!colorMeStyle.isValid)
            return alert('Character Style "' + colorMeStyleName + '" is invalid.');

        // find the "Color Me" texts
        var texts = findGrep(doc, { appliedCharacterStyle: colorMeStyle });

        if (texts) {

            for (var i = 0, color, page; i < texts.length; i++) {

                page = getPage(texts[i]);

                if (!page)
                    // on pasteboard
                    continue;

                color = colorsByPage[page.documentOffset];

                if (!color)
                    // before the first chapter heading
                    continue;

                // color the text
                texts[i].fillColor = color;

            }

        }

    };


    /**
     * Example 2: Color any table containing text in "Color My Table" character style.
     */
    function colorTables() {

        // get the "Color My Table" character style
        var colorMyTableStyle = doc.characterStyles.itemByName(colorMyTableStyleName);

        if (!colorMyTableStyle.isValid)
            return; // alert('Character Style "' + colorMyTableStyleName + '" is invalid.');

        // find the "Color My Table" texts
        var texts = findGrep(doc, { appliedCharacterStyle: colorMyTableStyle });

        if (!texts)
            return;

        for (var i = 0, color, page; i < texts.length; i++) {

            page = getPage(texts[i]);

            if (!page)
                // on pasteboard
                continue;

            color = colorsByPage[page.documentOffset];

            if (!color)
                // before the first chapter heading
                continue;

            // color the text's table
            var table = texts[i].parent.parent;

            if ('Table' !== table.constructor.name)
                return;

            // color the text's cell
            texts[i].parent.fillColor = color;

            // color the cell borders
            table.cells.everyItem().properties = {
                topEdgeStrokeColor: color,
                leftEdgeStrokeColor: color,
                bottomEdgeStrokeColor: color,
                rightEdgeStrokeColor: color,
            };

        }

    };

};

app.doScript(main, ScriptLanguage.JAVASCRIPT, undefined, UndoModes.ENTIRE_SCRIPT, 'Color By Chapter');

/**
 * Returns an array with members corresponding to `allPages`,
 * and with payload distributed within, such that:
 *   - no payload before the first dividerPage
 *   - the first payload repeated at each array index
 *     until the second dividerPage
 *   - the second payload repeated at each array index
 *     until the third dividerPage
 *   - and so on ...
 *
 * Example: allocate colors across a document, using
 * chapter start pages as dividers. Each chapter will
 * have its own color.
 *
 * @author m1b
 * @version 2024-08-25
 * @param {Array<Page>|Pages} allPages - every page of the distribution.
 * @param {Array<Page>|Pages} dividerPages - pages which delimit areas, eg. chapters.
 * @param {Array<*>} items - the things to distribute.
 * @returns {Function}
 */
function makePageAllocator(allPages, dividerPages) {

    return (function (pages, dividers) {

        return function allocate(items) {

            var allocated = [];

            var itemIndex = -1;
            var dividerIndex = 0;
            var dividerPage = dividers[dividerIndex];

            pageLoop:
            for (var i = 0, page; i < pages.length; i++) {

                page = pages[i];

                while (
                    dividerIndex < dividers.length
                    && page.documentOffset >= dividerPage.documentOffset
                ) {

                    // next divider, next item
                    dividerIndex++;
                    itemIndex++;

                    if (itemIndex >= items.length)
                        // ran out of items
                        break pageLoop;

                    if (dividerIndex < dividers.length)
                        dividerPage = dividers[dividerIndex];

                }

                if (itemIndex < 0) {
                    // no item before the first divider
                    continue;
                }

                // add the item here
                allocated[i] = items[itemIndex];

            }

            return allocated;

        };

    })(allPages, dividerPages);

};

/**
 * Returns an array of `things` pages.
 * @author m1b
 * @version 2024-08-25
 * @param {Array<*>} things - array of things on a page.
 * @returns {Array<Page>}
 */
function getPages(things) {

    var pages = [];

    for (var i = 0, page; i < things.length; i++) {

        page = getPage(things[i]);

        if (page && page.isValid)
            pages.push(page);

    }

    return pages;

};

/**
 * Returns `thing`'s Page, if possible.
 * @author m1b
 * @version 2024-08-25
 * @param {*} thing - a thing with a Page.
 * @returns {Page?}
 */
function getPage(thing) {

    var page;

    if (thing.hasOwnProperty('parentPage'))
        page = thing.parentPage;

    else if (
        thing.hasOwnProperty('parentTextFrames')
        && thing.parentTextFrames.length > 0
    )
        page = thing.parentTextFrames[0].parentPage;

    else if (thing.hasOwnProperty('parent'))
        return getPage(thing.parent);

    if (
        undefined != page
        && page.isValid
    )
        return page;

};

/**
 * Returns `target`.findGrep result with the given `props`.
 * @author m1b
 * @version 2024-08-25
 * @param {App|Document|Story|TextFrame} target - the findGrep target.
 * @param {Object} props - an object with findGrepPreferences properties.
 * @returns {Array<Text>}
 */
function findGrep(target, props) {

    resetFindGrep();
    app.findGrepPreferences.properties = props;

    return target.findGrep();

};

/**
 * Resets grep preferences.
 */
function resetFindGrep() {

    // reset grep prefs
    app.findGrepPreferences = NothingEnum.NOTHING;
    app.changeGrepPreferences = NothingEnum.NOTHING;

    // find grep options
    app.findChangeGrepOptions.includeFootnotes = false;
    app.findChangeGrepOptions.includeHiddenLayers = false;
    app.findChangeGrepOptions.includeLockedLayersForFind = false;
    app.findChangeGrepOptions.includeLockedStoriesForFind = false;
    app.findChangeGrepOptions.includeMasterPages = false;

};

/**
 * Returns array of swatches matching `names`.
 * @author m1b
 * @version 2024-08-25
 * @param {Document} doc - an Indesign Document.
 * @param {Array<String>} names - the color names.
 * @returns {Array<Swatch>}
 */
function getColors(doc, names) {

    var found = [];

    for (var i = 0, c; i < names.length; i++) {

        c = doc.swatches.itemByName(names[i]);

        if (!c.isValid)
            return alert('Swatch "' + names[i] + '" is invalid.');

        found.push(c)

    }

    return found;

};