Renderer should be an interface

[maxandersen]

currently it is quite hard to customize how rendering happens.

i tried register with MimeType.ANY for Strings to let users return json in whatever type they wish - but current implementation (for good reasons) does not support such mimetype resoluton.

it would be good if Renderer could be made an interface so a kernel can fully control the rendering no matter mimetype rules.

[maxandersen]

here is what I found I had to do to be able to wire in ability to let user have any mimetype for a string:

package dev.jbang.jupyter;

import java.util.Map;

import org.dflib.jjava.jupyter.kernel.display.DisplayData;
import org.dflib.jjava.jupyter.kernel.display.RenderContext;
import org.dflib.jjava.jupyter.kernel.display.Renderer;
import org.dflib.jjava.jupyter.kernel.display.mime.MIMEType;

public class DelegateRenderer extends Renderer {

    private final Renderer renderer;

    public DelegateRenderer(Renderer renderer) {
        this.renderer = renderer;
    }

    @Override
    public <T> RenderRegistration<T> createRegistration(Class<T> type) {
        return renderer.createRegistration(type);
    }

    @Override
    public <T> void register(
            java.util.Set<org.dflib.jjava.jupyter.kernel.display.mime.MIMEType> supported,
            java.util.Set<org.dflib.jjava.jupyter.kernel.display.mime.MIMEType> preferred,
            java.util.Set<Class<? extends T>> types,
            org.dflib.jjava.jupyter.kernel.display.RenderFunction<T> function) {
        renderer.register(supported, preferred, types, function);
    }

    @Override
    public DisplayData render(Object value, Map<String, Object> params) {
        return renderer.render(value, params);
    }

    @Override
    public DisplayData render(Object value) {
        return renderer.render(value);
    }

    @Override
    public DisplayData renderAs(Object value, String... types) {
        return fixit(value,renderer.renderAs(value, types), types);
    }

    @Override
    public DisplayData renderAs(Object value, Map<String, Object> arg1, String... types) {
        return fixit(value,super.renderAs(value, arg1, types), types);
    }

    DisplayData fixit(Object value, DisplayData data, String[] types) {
         // allow string to be returned as any specific type
         if(value instanceof String) {
            for (String type : types) {
                MIMEType wanted = MIMEType.parse(type);
                if ((!wanted.isWildcard() && !wanted.subtypeIsWildcard()) && !data.hasDataForType(wanted)) {
                    data.putData(wanted,String.valueOf(value));
                }
            }
        }
        return data;
    }

}

[andrus]

I haven't looked at the renderers that deep yet. I get it how it picks a RenderFunction by object type, but the MIME types part is not entirely clear (like who requests a specific MIME for a given Java type? Is this always explicitly passed by the notebook user in BaseNotebookStatics.render(..) or is it determined in some other way?

I guess what I am getting at, is maybe there's a way to incorporate your needs in the core logic, but I am trying to understand the use case.

[maxandersen]

usecase is just that there are libraries that return a json string which would be nice to serve back to the notebook in its "native" format (i.e. vega-lite mimetype for graphs) but there isn't a way to do that without installing a custom renderer which can be somewhat of an overhead.

So ability to explicilty say if value is a string and there is a specific mimetype request - then just do that -make it easy; not hard to get the rendering you want.

[andrus]

This makes total sense, and feels like it should work out of the box. So does any of these pick the right renderer?

display(o, "application/vnd.vegalite.vX+json");
render(o, "application/vnd.vegalite.vX+json");

[maxandersen]

they don't today - unless I go explicitly add a renderer for string of that type.

What I'm trying to enable is that a string can be rendered to any mimetype without having to explicitly declare it.

I could do that by changing the mimetype lookup - but those aren't interfaces either thus thought it was more simple to start with the Renderer as it has the entry method API.