125 lines
3.5 KiB
TypeScript
125 lines
3.5 KiB
TypeScript
// This file is used to integrate Marko into the Clover Engine and Sitegen
|
|
// To use, replace the "marko/html" import with this file.
|
|
export * from "#marko/html";
|
|
|
|
interface BodyContentObject {
|
|
[x: PropertyKey]: unknown;
|
|
content: ServerRenderer;
|
|
}
|
|
|
|
export const createTemplate = (
|
|
templateId: string,
|
|
renderer: ServerRenderer,
|
|
) => {
|
|
const { render } = marko.createTemplate(templateId, renderer);
|
|
function wrap(props: Record<string, unknown>, n: number) {
|
|
// Marko components
|
|
const cloverAsyncMarker = { isAsync: false };
|
|
let r: engine.Render | undefined = undefined;
|
|
try {
|
|
r = engine.getCurrentRender();
|
|
} catch {}
|
|
// Support using Marko outside of Clover SSR
|
|
if (r) {
|
|
const markoResult = render.call(renderer, {
|
|
...props,
|
|
$global: { clover: r, cloverAsyncMarker },
|
|
});
|
|
if (cloverAsyncMarker.isAsync) {
|
|
return markoResult.then(engine.html);
|
|
}
|
|
const rr = markoResult.toString();
|
|
return engine.html(rr);
|
|
} else {
|
|
return renderer(props, n);
|
|
}
|
|
}
|
|
wrap.render = render;
|
|
wrap.unwrapped = renderer;
|
|
return wrap;
|
|
};
|
|
|
|
export const dynamicTag = (
|
|
scopeId: number,
|
|
accessor: Accessor,
|
|
tag: unknown | string | ServerRenderer | BodyContentObject,
|
|
inputOrArgs: unknown,
|
|
content?: (() => void) | 0,
|
|
inputIsArgs?: 1,
|
|
serializeReason?: 1 | 0,
|
|
) => {
|
|
marko.dynamicTag;
|
|
if (typeof tag === "function") {
|
|
clover: {
|
|
const unwrapped = (tag as any).unwrapped;
|
|
if (unwrapped) {
|
|
tag = unwrapped;
|
|
break clover;
|
|
}
|
|
let r: engine.Render;
|
|
try {
|
|
r = engine.getCurrentRender();
|
|
if (!r) throw 0;
|
|
} catch {
|
|
r = marko.$global().clover as engine.Render;
|
|
}
|
|
if (!r) throw new Error("No Clover Render Active");
|
|
const subRender = engine.initRender(r.async !== -1, r.addon);
|
|
const resolved = engine.resolveNode(subRender, [
|
|
engine.kElement,
|
|
tag,
|
|
inputOrArgs,
|
|
]);
|
|
|
|
if (subRender.async > 0) {
|
|
const marker = marko.$global().cloverAsyncMarker;
|
|
marker.isAsync = true;
|
|
|
|
// Wait for async work to finish
|
|
const { resolve, reject, promise } = Promise.withResolvers<string>();
|
|
subRender.asyncDone = () => {
|
|
const rejections = subRender.rejections;
|
|
if (!rejections) return resolve(engine.renderNode(resolved));
|
|
(r.rejections ??= []).push(...rejections);
|
|
return reject(new Error("Render had errors"));
|
|
};
|
|
marko.fork(
|
|
scopeId,
|
|
accessor,
|
|
promise,
|
|
(string: string) => marko.write(string),
|
|
0,
|
|
);
|
|
} else {
|
|
marko.write(engine.renderNode(resolved));
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
return marko.dynamicTag(
|
|
scopeId,
|
|
accessor,
|
|
tag,
|
|
inputOrArgs,
|
|
content,
|
|
inputIsArgs,
|
|
serializeReason,
|
|
);
|
|
};
|
|
|
|
export function fork(
|
|
scopeId: string,
|
|
accessor: Accessor,
|
|
promise: Promise<unknown>,
|
|
callback: (data: unknown) => void,
|
|
serializeMarker?: 0 | 1,
|
|
) {
|
|
const marker = marko.$global().cloverAsyncMarker;
|
|
marker.isAsync = true;
|
|
marko.fork(scopeId, accessor, promise, callback, serializeMarker);
|
|
}
|
|
|
|
import * as engine from "./ssr.ts";
|
|
import type { ServerRenderer } from "marko/html/template";
|
|
import { type Accessor } from "marko/common/types";
|
|
import * as marko from "#marko/html";
|