181 lines
8.8 KiB
HTML
181 lines
8.8 KiB
HTML
<script defer src="{{ .Site.Params.bergamotJsUrl }}"></script>
|
|
<script defer src="{{ .Site.Params.bergamotObjectLanguageJsUrl }}"></script>
|
|
{{ $style := resources.Get "scss/bergamot.scss" | resources.ToCSS | resources.Minify }}
|
|
<link rel="stylesheet" href="{{ $style.Permalink }}">
|
|
<script defer>
|
|
const loadedWidgets = {};
|
|
const getButtons = (inputGroup) => {
|
|
return {
|
|
play: inputGroup.querySelector(".bergamot-play"),
|
|
reset: inputGroup.querySelector(".bergamot-reset"),
|
|
close: inputGroup.querySelector(".bergamot-close"),
|
|
}
|
|
}
|
|
const setRunning = (inputGroup, running) => {
|
|
if (inputGroup !== null) {
|
|
const buttons = getButtons(inputGroup);
|
|
if (buttons.play) buttons.play.classList.toggle("bergamot-hidden", running);
|
|
if (buttons.reset) buttons.reset.classList.toggle("bergamot-hidden", !running);
|
|
if (buttons.close) buttons.close.classList.toggle("bergamot-hidden", !running);
|
|
}
|
|
}
|
|
|
|
// The object language parsing is handling by a separate standalone Elm
|
|
// application in the ObjectLanguage module, which has two ports:
|
|
//
|
|
// * `parseString` requests a string to be parsed
|
|
// * `parsedString` returns the parsed string, or null
|
|
//
|
|
// We want there to be a single global ObjectLanguage object, but it works
|
|
// on a "subscription" model (we have to give a callback to its port).
|
|
// Configure this callback to invoke `resolve` functions from a list,
|
|
// so that callers can just get a promise. This way we aren't continuously
|
|
// registering more and more handlers for each parsed string, and we can
|
|
// use a convenient promise API.
|
|
const parsingPromiseResolvers = {};
|
|
const ensureObjectLanguage = () => {
|
|
if (!window.Bergamot.ObjectLanguage) {
|
|
window.Bergamot.ObjectLanguage = Elm.Bergamot.ObjectLanguage.init({});
|
|
window.Bergamot.ObjectLanguage.ports.parsedString.subscribe(({ string, term }) => {
|
|
if (string in parsingPromiseResolvers) {
|
|
for (const resolver of parsingPromiseResolvers[string]) {
|
|
resolver(term);
|
|
}
|
|
parsingPromiseResolvers[string] = [];
|
|
}
|
|
});
|
|
}
|
|
return window.Bergamot.ObjectLanguage;
|
|
}
|
|
const parseString = (str) => {
|
|
if (!(str in parsingPromiseResolvers)) {
|
|
parsingPromiseResolvers[str] = [];
|
|
}
|
|
|
|
return new Promise(resolve => {
|
|
parsingPromiseResolvers[str].push(resolve);
|
|
ensureObjectLanguage().ports.parseString.send(str);
|
|
});
|
|
}
|
|
|
|
window.Bergamot = {};
|
|
window.Bergamot.run = (inputGroup, nodeId, inputPrompt, rules, renderPreset, input) => {
|
|
var app = Elm.Main.init({
|
|
node: document.getElementById(nodeId),
|
|
flags: {
|
|
inputModes: {
|
|
"Languge Term": { "custom": "Language Term" },
|
|
"Query": "query"
|
|
},
|
|
renderRules: window.Bergamot.renderPresets[renderPreset],
|
|
rules, input
|
|
}
|
|
});
|
|
app.ports.convertInput.subscribe(async ({ mode, input }) => {
|
|
let query = await parseString(input);
|
|
if (query !== null) {
|
|
query = inputPrompt.replace("TERM", query);
|
|
app.ports.receiveConverted.send({ input, result: { query } });
|
|
} else {
|
|
app.ports.receiveConverted.send({ input, result: { error: "Unable to parse object language term" } });
|
|
}
|
|
});
|
|
loadedWidgets[nodeId] = { app, parentNode: inputGroup ? inputGroup.parentElement : null };
|
|
setRunning(inputGroup, true);
|
|
};
|
|
window.Bergamot.runPreset = (inputGroup, nodeId, presetName) => {
|
|
const preset = window.Bergamot.presets[presetName];
|
|
window.Bergamot.run(inputGroup, nodeId, preset.inputPrompt, preset.rules, preset.renderPreset, preset.query || "");
|
|
};
|
|
window.Bergamot.close = (inputGroup, nodeId) => {
|
|
if (!(nodeId in loadedWidgets)) return;
|
|
|
|
const placeholderDiv = document.createElement('div');
|
|
placeholderDiv.id = nodeId;
|
|
|
|
const widget = loadedWidgets[nodeId];
|
|
const elmRoot = widget.parentNode.querySelector(".bergamot-root");
|
|
elmRoot.replaceWith(placeholderDiv)
|
|
delete loadedWidgets[nodeId];
|
|
setRunning(inputGroup, false);
|
|
}
|
|
window.Bergamot.presets = {};
|
|
window.Bergamot.renderPresets = {};
|
|
window.Bergamot.renderPresets["default"] =
|
|
`
|
|
PrecApp @ prec(app(?l, ?r), 100, left) <-;
|
|
PrecPlus @ prec(plus(?l, ?r), 80, either) <-;
|
|
PrecAbs @ prec(abs(?x, ?t, ?e), 0, right) <-;
|
|
PrecArr @ prec(tarr(?l, ?r), 0, right) <-;
|
|
|
|
SelectHead @ select(cons([?t, ?v], ?rest), ?default, ?v) <- ?t;
|
|
SelectTail @ select(cons([?t, ?v], ?rest), ?default, ?found) <- not(?t), select(?rest, ?default, ?found);
|
|
SelectEmpty @ select(nil, ?default, ?default) <-;
|
|
|
|
ParenthAssocLeft @ parenthassoc(?a_i, left, right) <-;
|
|
ParenthAssocRight @ parenthassoc(?a_i, right, left) <-;
|
|
ParenthAssocNone @ parenthassoc(?a_i, none, ?pos) <-;
|
|
ParenthAssocNeq @ parenthassoc(?a_i, ?a_o, ?pos) <- not(symeq(?a_i, ?a_o));
|
|
|
|
Parenth @ parenth(?inner, ?outer, ?pos, ?strin, ?strout) <-
|
|
prec(?inner, ?p_i, ?a_i), prec(?outer, ?p_o, ?a_o),
|
|
join(["(", ?strin, ")"], ?strinparen),
|
|
select([ [less(?p_i, ?p_o), strinparen], [less(?p_o, ?p_i), ?strin], [ parenthassoc(?a_i, ?a_o, ?pos), ?strinparen ] ], ?strin, ?strout);
|
|
ParenthFallback @ parenth(?inner, ?outer, ?pos, ?strin, ?strin) <-;
|
|
|
|
LatexListNil @ latexlist(nil, nil) <-;
|
|
LatexListCons @ latexlist(cons(?x, ?xs), cons(?l_x, ?l_s)) <- latex(?x, ?l_x), latexlist(?xs, ?l_s);
|
|
|
|
IntercalateNil @ intercalate(?sep, nil, nil) <-;
|
|
IntercalateConsCons @ intercalate(?sep, cons(?x_1, cons(?x_2, ?xs)), cons(?x_1, cons(?sep, ?ys))) <- intercalate(?sep, cons(?x_2, ?xs), ?ys);
|
|
IntercalateConsNil @ intercalate(?sep, cons(?x, nil), cons(?x, nil)) <-;
|
|
|
|
NonEmpty @ nonempty(cons(?x, ?xs)) <-;
|
|
|
|
LatexInt @ latex(?i, ?l) <- int(?i), tostring(?i, ?l);
|
|
LatexFloat @ latex(?f, ?l) <- float(?f), tostring(?f, ?l);
|
|
LatexStr @ latex(?s, ?l) <- str(?s), escapestring(?s, ?l_1), latexifystring(?s, ?l_2), join(["\\\\texttt{\\"", ?l_2, "\\"}"], ?l);
|
|
LatexMeta @ latex(metavariable(?l), ?l) <-;
|
|
LatexLit @ latex(lit(?i), ?l) <- latex(?i, ?l);
|
|
LatexVar @ latex(var(?s), ?l) <- latex(?s, ?l);
|
|
LatexPlus @ latex(plus(?e_1, ?e_2), ?l) <-
|
|
latex(?e_1, ?l_1), latex(?e_2, ?l_2),
|
|
parenth(?e_1, plus(?e_1, ?e_2), left, ?l_1, ?lp_1),
|
|
parenth(?e_2, plus(?e_1, ?e_2), right, ?l_2, ?lp_2),
|
|
join([?lp_1, " + ", ?lp_2], ?l);
|
|
LatexPair @ latex(pair(?e_1, ?e_2), ?l) <- latex(?e_1, ?l_1), latex(?e_2, ?l_2), join(["(", ?l_1, ", ", ?l_2, ")"], ?l);
|
|
LatexAbs @ latex(abs(?x, ?t, ?e), ?l) <- latex(?e, ?l_e), latex(?t, ?l_t), latex(?x, ?l_x), join(["\\\\lambda ", ?l_x, " : ", ?l_t, " . ", ?l_e], ?l);
|
|
LatexApp @ latex(app(?e_1, ?e_2), ?l) <-
|
|
latex(?e_1, ?l_1), latex(?e_2, ?l_2),
|
|
parenth(?e_1, app(?e_1, ?e_2), left, ?l_1, ?lp_1),
|
|
parenth(?e_2, app(?e_1, ?e_2), right, ?l_2, ?lp_2),
|
|
join([?lp_1, " \\\\enspace ", ?lp_2], ?l);
|
|
|
|
LatexTInt @ latex(tint, "\\\\text{tint}") <-;
|
|
LatexTStr @ latex(tstr, "\\\\text{tstr}") <-;
|
|
LatexTArr @ latex(tarr(?t_1, ?t_2), ?l) <-
|
|
latex(?t_1, ?l_1), latex(?t_2, ?l_2),
|
|
parenth(?t_1, tarr(?t_1, ?t_2), left, ?l_1, ?lp_1),
|
|
parenth(?t_2, tarr(?t_1, ?t_2), right, ?l_2, ?lp_2),
|
|
join([?lp_1, " \\\\to ", ?lp_2], ?l);
|
|
LatexTPair @ latex(tpair(?t_1, ?t_2), ?l) <- latex(?t_1, ?l_1), latex(?t_2, ?l_2), join(["(", ?l_1, ", ", ?l_2, ")"], ?l);
|
|
|
|
LatexTypeEmpty @ latex(empty, "\\\\varnothing") <-;
|
|
LatexTypeExtend @ latex(extend(?a, ?b, ?c), ?l) <- latex(?a, ?l_a), latex(?b, ?l_b), latex(?c, ?l_c), join([?l_a, " , ", ?l_b, " : ", ?l_c], ?l);
|
|
LatexTypeInenv @ latex(inenv(?x, ?t, ?G), ?l) <-latex(?x, ?l_x), latex(?t, ?l_t), latex(?G, ?l_G), join([?l_x, " : ", ?l_t, " \\\\in ", ?l_G], ?l);
|
|
|
|
LatexTypeBin @ latex(type(?e, ?t), ?l) <- latex(?e, ?l_e), latex(?t, ?l_t), join([?l_e, " : ", ?l_t], ?l);
|
|
LatexTypeTer @ latex(type(?G, ?e, ?t), ?l) <- latex(?G, ?l_G), latex(?e, ?l_e), latex(?t, ?l_t), join([?l_G, " \\\\vdash ", ?l_e, " : ", ?l_t], ?l);
|
|
|
|
LatexConverts @ latex(converts(?f, ?t), ?l) <- latex(?f, ?l_f), latex(?t, ?l_t), join([?l_f, " \\\\preceq ", ?l_t], ?l);
|
|
|
|
LatexIsInt @ latex(int(?e), ?l) <- latex(?e, ?l_e), join([?l_e, " \\\\in \\\\texttt{Int}"], ?l);
|
|
LatexIsFloat @ latex(float(?e), ?l) <- latex(?e, ?l_e), join([?l_e, " \\\\in \\\\texttt{Float}"], ?l);
|
|
LatexIsNum @ latex(num(?e), ?l) <- latex(?e, ?l_e), join([?l_e, " \\\\in \\\\texttt{Num}"], ?l);
|
|
LatexIsStr @ latex(str(?e), ?l) <- latex(?e, ?l_e), join([?l_e, " \\\\in \\\\texttt{Str}"], ?l);
|
|
LatexSym @ latex(?s, ?l) <- sym(?s), tostring(?s, ?l_1), join(["\\\\text{", ?l_1,"}"], ?l);
|
|
LatexCall @ latex(?c, ?l) <- call(?c, ?n, ?ts), nonempty(?ts), latexlist(?ts, ?lts_1), intercalate(", ", ?lts_1, ?lts_2), join(?lts_2, ?lts_3), join(["\\\\text{", ?n, "}", "(", ?lts_3, ")"], ?l);
|
|
`;
|
|
|
|
</script>
|