marko
Version:
Optimized runtime for Marko templates.
293 lines (292 loc) • 14.2 kB
JavaScript
import { $ as _html, $t as queueEffect, A as _attr_select_value, At as _id, B as _attr_class, Bt as _assert_init, C as _attr_input_checked_default, Ct as _closure_get, D as _attr_input_value_default, Dt as _for_selector, E as _attr_input_value_attribute_default, Et as _for_closure, F as _controllable_select, Ft as _return, G as _attr_style, Gt as _on, H as _attr_class_items, Ht as insertBranchBefore, I as _controllable_textarea, It as _return_change, J as _attrs, K as _attr_style_item, Kt as $signal, Lt as _script, M as _attr_select_value_script, Mt as _let, N as _controllable_input, Nt as _let_change, O as _attr_input_value_dynamic_default, Ot as _hoist, P as _controllable_open, Pt as _or, Q as _attrs_script, Qt as queueAsyncRender, Rt as _var, S as _attr_input_checkedValue_script, St as _closure, T as _attr_input_value, Tn as TagVariable, Tt as _el_read, U as _attr_content, Ut as removeAndDestroyBranch, V as _attr_class_item, Vt as destroyBranch, W as _attr_nonce, Wt as syncGen, X as _attrs_partial, Y as _attrs_content, Z as _attrs_partial_content, Zt as prepareEffects, _ as _attr_details_or_dialog_open_default, _n as EndNode, _t as getRegisteredWithScope, a as _for_in, an as forTo, at as _to_text, b as _attr_input_checkedValue, bn as Load, bt as ready, c as _for_until, cn as _call, ct as _content, d as _show, dn as Params, dt as createAndSetupBranch, en as run, et as _lifecycle, f as _try, fn as Setup, ft as createBranch, g as _attr_details_or_dialog_open, gt as _var_resume, h as renderCatch, ht as _resume, i as _dynamic_tag_content, in as forOf, it as _text_content, j as _attr_select_value_default, jt as _if_closure, k as _attr_input_value_script, kt as _hoist_resume, l as _if, ln as Clone, lt as _content_closures, m as patchDynamicTag, mt as _el, n as _await_promise, nn as runId, nt as _style_shell, o as _for_of, on as forUntil, ot as insertChildNodes, p as addAwaitCounter, pt as setupBranch, q as _attr_style_items, qt as $signalReset, r as _dynamic_tag, rn as forIn, rt as _text, s as _for_to, sn as _assert_hoist, st as toInsertNode, t as _await_content, tn as runEffects, tt as _style_rule_item, u as _resume_dynamic_tag, un as Owner, ut as _content_resume, v as _attr_details_or_dialog_open_script, vt as init, w as _attr_input_checked_script, wn as StartNode, wt as _const, x as _attr_input_checkedValue_default, xt as _child_setup, y as _attr_input_checked, yn as Global, yt as initEmbedded, z as _attr, zt as _var_change } from "./dom-BJ93mcSe.mjs";
//#region src/common/attr-tag.ts
const empty = [];
const rest = Symbol("Attribute Tag");
function attrTag(attrs) {
attrs[Symbol.iterator] = attrTagIterator;
attrs[rest] = empty;
return attrs;
}
function attrTags(first, attrs) {
if (first) {
if (first[rest] === empty) first[rest] = [attrs];
else first[rest].push(attrs);
return first;
}
return attrTag(attrs);
}
function* attrTagIterator() {
yield this;
yield* this[rest];
}
//#endregion
//#region src/common/constants/load-signal-value.debug.ts
const Value = "value";
const Signal = "signal";
//#endregion
//#region src/common/compat-meta.ts
const SET_SCOPE_REGISTER_ID = "$compat_setScope";
const RENDER_BODY_ID = "$compat_renderBody";
//#endregion
//#region src/dom/compat.ts
const classIdToBranch = /* @__PURE__ */ new Map();
let classEventResolver;
const scopesByRender = /* @__PURE__ */ new WeakMap();
const getRenderScopes = ($global) => {
const render = self[$global.runtimeId]?.[$global.renderId];
let scopes = render && scopesByRender.get(render);
if (render && !scopes) scopesByRender.set(render, scopes = {});
return scopes;
};
const compat = {
patchDynamicTag,
queueEffect,
init(warp10Noop) {
_resume(SET_SCOPE_REGISTER_ID, (scope) => {
getRenderScopes(scope[Global])[scope["#Id"]] = scope;
if (scope.m5c) classIdToBranch.set(scope.m5c, scope);
if (classEventResolver) for (const key in scope) {
const resolved = classEventResolver(scope[key], scope);
if (resolved !== scope[key]) scope[key] = resolved;
}
});
_resume(RENDER_BODY_ID, warp10Noop);
},
setClassEventResolver(fn) {
classEventResolver = fn;
},
getScope($global, scopeId) {
return getRenderScopes($global)?.[scopeId];
},
setRendererId(renderer, id) {
renderer["id"] = id;
},
isRenderer(renderer) {
return renderer[Clone];
},
getStartNode(branch) {
return branch[StartNode];
},
getEndNode(branch) {
return branch[EndNode];
},
setScopeNodes(branch, startNode, endNode) {
branch[StartNode] = startNode;
branch[EndNode] = endNode;
},
runComponentEffects() {
if (this.effects) runEffects(this.effects);
},
runComponentDestroy() {
if (this.scope) destroyBranch(this.scope);
},
resolveRegistered(value, $global) {
if (Array.isArray(value) && typeof value[0] === "string") return getRegisteredWithScope(value[0], getRenderScopes($global)?.[value[1]]);
return value;
},
createRenderer(params, clone) {
const renderer = _content("", 0, 0, 0, params)();
renderer[Clone] = (branch) => {
const cloned = clone();
branch[StartNode] = cloned.startNode;
branch[EndNode] = cloned.endNode;
};
return renderer;
},
render(out, component, renderer, args) {
let branch = component.scope;
let created = 0;
if (!branch && (branch = classIdToBranch.get(component.id))) {
component.scope = branch;
classIdToBranch.delete(component.id);
}
if (args[0] && typeof args[0] === "object" && "renderBody" in args[0]) {
const input = args[0];
const normalizedInput = args[0] = {};
for (const key in input) normalizedInput[key === "renderBody" ? "content" : key] = input[key];
}
component.effects = prepareEffects(() => {
if (!branch) {
created = 1;
branch = component.scope = createAndSetupBranch(out.global, renderer, renderer[Owner], document.body);
}
renderer[Params]?.(branch, renderer._ ? args[0] : args);
});
if (created) return toInsertNode(branch[StartNode], branch[EndNode]);
}
};
//#endregion
//#region src/dom/template.ts
const _template = (id, template, walks, setup, inputSignal) => {
const renderer = _content(id, template, walks, setup, inputSignal)();
renderer.mount = mount;
renderer._ = renderer;
renderer.render = () => {
throw new Error(`render() is not implemented for the DOM compilation of a Marko template`);
};
return _resume(id, renderer);
};
function mount(input = {}, reference, position) {
let branch;
let parentNode = reference;
let nextSibling = null;
let { $global } = input;
if ($global) {
({$global, ...input} = input);
$global = {
runtimeId: "M",
renderId: "_",
...$global
};
if (!String($global.runtimeId).match(/^[_a-z][_a-z0-9]*$/i)) throw new Error(`Invalid runtimeId: "${$global.runtimeId}". The runtimeId must start with a letter or underscore and only contain letters, numbers, and underscores.`);
if (!String($global.renderId).match(/^[_a-z][_a-z0-9]*$/i)) throw new Error(`Invalid renderId: "${$global.renderId}". The renderId must start with a letter or underscore and only contain letters, numbers, and underscores.`);
} else $global = {
runtimeId: "M",
renderId: "_"
};
switch (position) {
case "beforebegin":
parentNode = reference.parentNode;
nextSibling = reference;
break;
case "afterbegin":
nextSibling = reference.firstChild;
break;
case "afterend":
parentNode = reference.parentNode;
nextSibling = reference.nextSibling;
break;
}
let curValue;
const args = this[Params];
const effects = prepareEffects(() => {
branch = createBranch($global, this, void 0, parentNode);
branch[TagVariable] = (newValue) => {
curValue = newValue;
};
this[Setup]?.(branch);
args?.(branch, input);
});
insertChildNodes(parentNode, nextSibling, branch[StartNode], branch[EndNode]);
runEffects(effects);
return {
get value() {
return curValue;
},
set value(newValue) {
_var_change(branch, newValue);
},
update(newInput = {}) {
if (args) {
if (newInput.$global) ({$global, ...newInput} = newInput);
runEffects(prepareEffects(() => {
args(branch, newInput);
}));
}
},
destroy() {
removeAndDestroyBranch(branch);
}
};
}
//#endregion
//#region src/dom/load.ts
function _load_template(id, load) {
let pending;
const lazyTemplate = _template(id, 0, 0, (branch) => {
const awaitCounter = addAwaitCounter(branch);
branch[Load] ||= /* @__PURE__ */ new Map();
(pending ||= load()).then((renderer) => {
Object.assign(lazyTemplate, renderer);
queueAsyncRender(branch, (branch) => insertLoaded(renderer, branch, branch[StartNode], awaitCounter));
}, loadFailed(branch, awaitCounter));
}, _load_signal(() => (pending ||= load()).then((r) => ({ _: r[Params] }))));
return lazyTemplate;
}
function _load_setup(nodeAccessor, childScopeAccessor, load) {
let pending;
let renderer;
return (owner) => {
const child = owner[childScopeAccessor];
if (renderer) insertLoaded(renderer, child, owner[nodeAccessor]);
else {
const awaitCounter = addAwaitCounter(owner);
child[Load] ||= /* @__PURE__ */ new Map();
(pending ||= load()).then((mod) => {
renderer = _content("", ...mod._)();
queueAsyncRender(child, (child) => insertLoaded(renderer, child, owner[nodeAccessor], awaitCounter));
}, loadFailed(child, awaitCounter));
}
};
}
function insertLoaded(renderer, branch, marker, awaitCounter) {
const parent = marker.parentNode, values = branch[Load], insert = () => {
insertBranchBefore(branch, parent, marker);
marker.remove();
awaitCounter?.c();
};
let remaining;
syncGen(branch);
renderer[Clone](branch, parent.namespaceURI);
branch[Load] = 0;
if (remaining = values?.size) {
const fail = loadFailed(branch, awaitCounter);
for (const [promise, entry] of values) promise.then((signal) => {
entry[Signal] = signal;
if (!--remaining) queueAsyncRender(branch, (branch) => {
syncGen(branch);
renderer[Setup]?.(branch);
values.forEach((e) => e[Signal]._(branch, e[Value]));
insert();
});
}, (error) => remaining > 0 && (remaining = 0, fail(error)));
} else {
setupBranch(renderer, branch);
insert();
}
}
function loadFailed(scope, awaitCounter) {
return (error) => {
if (awaitCounter) if (awaitCounter.m) awaitCounter.i = 0;
else awaitCounter.c();
queueAsyncRender(scope, renderCatch, error);
};
}
function _load_signal(load) {
let pending;
let signal;
return (scope, value) => {
pending ||= load();
if (scope["#Load"] || !("#Load" in scope) && scope["#Gen"] === runId) (scope[Load] ||= /* @__PURE__ */ new Map()).set(pending, { [Value]: value });
else if (signal) signal(scope, value);
else pending.then((mod) => queueAsyncRender(scope, signal = mod._, value), () => 0);
};
}
function _load_visible_trigger(selector, options) {
let pending;
let el;
return (load) => () => (pending ||= new Promise((resolve) => (el = getSelectorOrResolve(selector, resolve)) && new IntersectionObserver((entries, io) => entries.some((entry) => entry.isIntersecting) && resolve(io.disconnect()), options).observe(el))).then(load);
}
function _load_idle_trigger(options) {
let pending;
return (load) => () => (pending ||= new Promise((resolve) => (self.requestIdleCallback || resolve)(resolve, options))).then(load);
}
function _load_event_trigger(event, selector) {
let pending;
return (load) => () => (pending ||= new Promise((resolve) => getSelectorOrResolve(selector, resolve)?.addEventListener(event, resolve, { once: true }))).then(load);
}
function _load_media_trigger(query) {
let pending;
let mql;
return (load) => () => (pending ||= new Promise((resolve) => (mql = matchMedia(query)).matches ? resolve() : mql.addEventListener("change", resolve, { once: true }))).then(load);
}
function _load_race_trigger(...triggers) {
const noop = () => Promise.resolve();
let pending;
return (load) => () => (pending ||= Promise.race(triggers.map((t) => t(noop)()))).then(load);
}
function getSelectorOrResolve(selector, resolve) {
return document.querySelector(selector) || (console.warn(`A lazy load trigger could not find an element matching "${selector}". The module was loaded immediately.`), resolve());
}
//#endregion
export { $signal, $signalReset, _assert_hoist, _assert_init, _attr, _attr_class, _attr_class_item, _attr_class_items, _attr_content, _attr_details_or_dialog_open as _attr_details_open, _attr_details_or_dialog_open as _attr_dialog_open, _attr_details_or_dialog_open_default as _attr_details_open_default, _attr_details_or_dialog_open_default as _attr_dialog_open_default, _attr_details_or_dialog_open_script as _attr_details_open_script, _attr_details_or_dialog_open_script as _attr_dialog_open_script, _attr_input_checked, _attr_input_checkedValue, _attr_input_checkedValue_default, _attr_input_checkedValue_script, _attr_input_checked_default, _attr_input_checked_script, _attr_input_value, _attr_input_value as _attr_textarea_value, _attr_input_value_attribute_default, _attr_input_value_default, _attr_input_value_default as _attr_textarea_value_default, _attr_input_value_dynamic_default, _attr_input_value_script, _attr_input_value_script as _attr_textarea_value_script, _attr_nonce, _attr_select_value, _attr_select_value_default, _attr_select_value_script, _attr_style, _attr_style_item, _attr_style_items, _attrs, _attrs_content, _attrs_partial, _attrs_partial_content, _attrs_script, _await_content, _await_promise, _call, _child_setup, _closure, _closure_get, _const, _content, _content_closures, _content_resume, _controllable_input, _controllable_open, _controllable_select, _controllable_textarea, _dynamic_tag, _dynamic_tag_content, _el, _el_read, _for_closure, _for_in, _for_of, _for_selector, _for_to, _for_until, _hoist, _hoist_resume, _html, _id, _if, _if_closure, _let, _let_change, _lifecycle, _load_event_trigger, _load_idle_trigger, _load_media_trigger, _load_race_trigger, _load_setup, _load_signal, _load_template, _load_visible_trigger, _on, _or, _resume, _resume_dynamic_tag, _return, _return_change, _script, _show, _style_rule_item, _style_shell, _template, _text, _text_content, _to_text, _try, _var, _var_change, _var_resume, attrTag, attrTags, compat, forIn, forOf, forTo, forUntil, init, initEmbedded, ready, run };