@bokeh/bokehjs/build/js/lib/models/dom/value_ref.js

Interactive, novel data visualization

import { Placeholder, PlaceholderView, Formatter } from "./placeholder";
import { CustomJS } from "../callbacks/customjs";
import { CustomJSHover } from "../tools/inspectors/customjs_hover";
import { _get_column_value, MISSING, DEFAULT_FORMATTERS, Skip } from "../../core/util/templating";
import { execute, execute_sync } from "../../core/util/callbacks";
import { isArray, isBoolean } from "../../core/util/types";
import { Or, Func, Ref } from "../../core/kinds";
export const FilterDef = Or(Func(), Ref(CustomJS));
export class ValueRefView extends PlaceholderView {
    static __name__ = "ValueRefView";
    connect_signals() {
        super.connect_signals();
        const { filter } = this.model.properties;
        this.on_change(filter, () => this._update_filter());
    }
    async lazy_initialize() {
        await super.lazy_initialize();
        await this._update_filter();
    }
    async _update_filter() {
        const { filter } = this.model;
        for (const fn of isArray(filter) ? filter : [filter]) {
            if (fn instanceof CustomJS) {
                await fn.compile();
            }
        }
    }
    update(data_source, index, vars, _formatters) {
        const { field, format, formatter, filter } = this.model;
        const value = _get_column_value(field, data_source, index);
        const row = index != null ? data_source.get_row(index) : {};
        if (filter != null) {
            for (const fn of isArray(filter) ? filter : [filter]) {
                const args = { value, field, row, data_source, vars };
                const result = (() => {
                    if (fn instanceof CustomJS) {
                        return fn.execute_sync(this.model, args);
                    }
                    else {
                        return execute_sync(fn, this.model, args);
                    }
                })();
                if (isBoolean(result) && !result) {
                    throw new Skip();
                }
            }
        }
        const render = (output) => {
            if (output == null) {
                this.el.textContent = MISSING;
            }
            else if (output instanceof Node) {
                this.el.replaceChildren(output);
            }
            else if (isArray(output)) {
                this.el.replaceChildren(...output.map((item) => item instanceof Node ? item : `${item}`));
            }
            else {
                this.el.textContent = `${output}`;
            }
        };
        if (formatter instanceof CustomJS) {
            void (async () => {
                const output = await execute(formatter, this.model, { value, format, vars });
                render(output);
            })();
        }
        else {
            const output = (() => {
                if (format == null) {
                    return DEFAULT_FORMATTERS.basic(value, "", vars);
                }
                else {
                    if (formatter instanceof CustomJSHover) {
                        return formatter.format(value, format, vars);
                    }
                    else {
                        return DEFAULT_FORMATTERS[formatter](value, format, vars);
                    }
                }
            })();
            render(output);
        }
    }
}
export class ValueRef extends Placeholder {
    static __name__ = "ValueRef";
    constructor(attrs) {
        super(attrs);
    }
    static {
        this.prototype.default_view = ValueRefView;
        this.define(({ Str, Nullable, List, Or }) => ({
            field: [Str],
            format: [Nullable(Str), null],
            formatter: [Formatter, "raw"],
            filter: [Nullable(Or(FilterDef, List(FilterDef))), null], // XXX `any` cast because of CustomJS/Func types
        }));
    }
}
//# sourceMappingURL=value_ref.js.map