diff --git a/solid-js-web-common.js b/solid-js-web-common.js new file mode 100644 index 0000000..ef0c2cf --- /dev/null +++ b/solid-js-web-common.js @@ -0,0 +1,733 @@ +import {a as createMemo, b as createRoot, d as createRenderEffect, s as sharedConfig, e as createSignal, o as onCleanup, f as splitProps, u as untrack, E as ErrorBoundary, F as For, I as Index, M as Match, S as Show, g as Suspense, h as SuspenseList, i as Switch, c as createComponent, j as getOwner, m as mergeProps} from "./solid-js-common.js"; +const booleans = ["allowfullscreen", "async", "autofocus", "autoplay", "checked", "controls", "default", "disabled", "formnovalidate", "hidden", "indeterminate", "ismap", "loop", "multiple", "muted", "nomodule", "novalidate", "open", "playsinline", "readonly", "required", "reversed", "seamless", "selected"]; +const Properties = new Set(["className", "value", "readOnly", "formNoValidate", "isMap", "noModule", "playsInline", ...booleans]); +const ChildProperties = new Set(["innerHTML", "textContent", "innerText", "children"]); +const Aliases = { + className: "class", + htmlFor: "for" +}; +const PropAliases = { + class: "className", + formnovalidate: "formNoValidate", + ismap: "isMap", + nomodule: "noModule", + playsinline: "playsInline", + readonly: "readOnly" +}; +const DelegatedEvents = new Set(["beforeinput", "click", "dblclick", "focusin", "focusout", "input", "keydown", "keyup", "mousedown", "mousemove", "mouseout", "mouseover", "mouseup", "pointerdown", "pointermove", "pointerout", "pointerover", "pointerup", "touchend", "touchmove", "touchstart"]); +const SVGElements = new Set([ + "altGlyph", + "altGlyphDef", + "altGlyphItem", + "animate", + "animateColor", + "animateMotion", + "animateTransform", + "circle", + "clipPath", + "color-profile", + "cursor", + "defs", + "desc", + "ellipse", + "feBlend", + "feColorMatrix", + "feComponentTransfer", + "feComposite", + "feConvolveMatrix", + "feDiffuseLighting", + "feDisplacementMap", + "feDistantLight", + "feFlood", + "feFuncA", + "feFuncB", + "feFuncG", + "feFuncR", + "feGaussianBlur", + "feImage", + "feMerge", + "feMergeNode", + "feMorphology", + "feOffset", + "fePointLight", + "feSpecularLighting", + "feSpotLight", + "feTile", + "feTurbulence", + "filter", + "font", + "font-face", + "font-face-format", + "font-face-name", + "font-face-src", + "font-face-uri", + "foreignObject", + "g", + "glyph", + "glyphRef", + "hkern", + "image", + "line", + "linearGradient", + "marker", + "mask", + "metadata", + "missing-glyph", + "mpath", + "path", + "pattern", + "polygon", + "polyline", + "radialGradient", + "rect", + "set", + "stop", + "svg", + "switch", + "symbol", + "text", + "textPath", + "tref", + "tspan", + "use", + "view", + "vkern" +]); +const SVGNamespace = { + xlink: "http://www.w3.org/1999/xlink", + xml: "http://www.w3.org/XML/1998/namespace" +}; +function memo(fn, equals) { + return createMemo(fn, void 0, !equals ? { + equals + } : void 0); +} +function reconcileArrays(parentNode, a, b) { + let bLength = b.length, aEnd = a.length, bEnd = bLength, aStart = 0, bStart = 0, after = a[aEnd - 1].nextSibling, map = null; + while (aStart < aEnd || bStart < bEnd) { + if (a[aStart] === b[bStart]) { + aStart++; + bStart++; + continue; + } + while (a[aEnd - 1] === b[bEnd - 1]) { + aEnd--; + bEnd--; + } + if (aEnd === aStart) { + const node = bEnd < bLength ? bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart] : after; + while (bStart < bEnd) + parentNode.insertBefore(b[bStart++], node); + } else if (bEnd === bStart) { + while (aStart < aEnd) { + if (!map || !map.has(a[aStart])) + parentNode.removeChild(a[aStart]); + aStart++; + } + } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) { + const node = a[--aEnd].nextSibling; + parentNode.insertBefore(b[bStart++], a[aStart++].nextSibling); + parentNode.insertBefore(b[--bEnd], node); + a[aEnd] = b[bEnd]; + } else { + if (!map) { + map = new Map(); + let i = bStart; + while (i < bEnd) + map.set(b[i], i++); + } + const index = map.get(a[aStart]); + if (index != null) { + if (bStart < index && index < bEnd) { + let i = aStart, sequence = 1, t; + while (++i < aEnd && i < bEnd) { + if ((t = map.get(a[i])) == null || t !== index + sequence) + break; + sequence++; + } + if (sequence > index - bStart) { + const node = a[aStart]; + while (bStart < index) + parentNode.insertBefore(b[bStart++], node); + } else + parentNode.replaceChild(b[bStart++], a[aStart++]); + } else + aStart++; + } else + parentNode.removeChild(a[aStart++]); + } + } +} +const $$EVENTS = "_$DX_DELEGATE"; +function render(code, element, init) { + let disposer; + createRoot((dispose) => { + disposer = dispose; + insert(element, code(), element.firstChild ? null : void 0, init); + }); + return () => { + disposer(); + element.textContent = ""; + }; +} +function template(html, check, isSVG) { + const t = document.createElement("template"); + t.innerHTML = html; + let node = t.content.firstChild; + if (isSVG) + node = node.firstChild; + return node; +} +function delegateEvents(eventNames, document2 = window.document) { + const e = document2[$$EVENTS] || (document2[$$EVENTS] = new Set()); + for (let i = 0, l = eventNames.length; i < l; i++) { + const name = eventNames[i]; + if (!e.has(name)) { + e.add(name); + document2.addEventListener(name, eventHandler); + } + } +} +function clearDelegatedEvents(document2 = window.document) { + if (document2[$$EVENTS]) { + for (let name of document2[$$EVENTS].keys()) + document2.removeEventListener(name, eventHandler); + delete document2[$$EVENTS]; + } +} +function setAttribute(node, name, value) { + if (value == null) + node.removeAttribute(name); + else + node.setAttribute(name, value); +} +function setAttributeNS(node, namespace, name, value) { + if (value == null) + node.removeAttributeNS(namespace, name); + else + node.setAttributeNS(namespace, name, value); +} +function addEventListener(node, name, handler, delegate) { + if (delegate) { + if (Array.isArray(handler)) { + node[`$$${name}`] = handler[0]; + node[`$$${name}Data`] = handler[1]; + } else + node[`$$${name}`] = handler; + } else if (Array.isArray(handler)) { + node.addEventListener(name, (e) => handler[0](handler[1], e)); + } else + node.addEventListener(name, handler); +} +function classList(node, value, prev = {}) { + const classKeys = Object.keys(value || {}), prevKeys = Object.keys(prev); + let i, len; + for (i = 0, len = prevKeys.length; i < len; i++) { + const key = prevKeys[i]; + if (!key || key === "undefined" || value[key]) + continue; + toggleClassKey(node, key, false); + delete prev[key]; + } + for (i = 0, len = classKeys.length; i < len; i++) { + const key = classKeys[i], classValue = !!value[key]; + if (!key || key === "undefined" || prev[key] === classValue || !classValue) + continue; + toggleClassKey(node, key, true); + prev[key] = classValue; + } + return prev; +} +function style(node, value, prev = {}) { + const nodeStyle = node.style; + if (value == null || typeof value === "string") + return nodeStyle.cssText = value; + typeof prev === "string" && (prev = {}); + let v, s; + for (s in prev) { + value[s] == null && nodeStyle.removeProperty(s); + delete prev[s]; + } + for (s in value) { + v = value[s]; + if (v !== prev[s]) { + nodeStyle.setProperty(s, v); + prev[s] = v; + } + } + return prev; +} +function spread(node, accessor, isSVG, skipChildren) { + if (typeof accessor === "function") { + createRenderEffect((current) => spreadExpression(node, accessor(), current, isSVG, skipChildren)); + } else + spreadExpression(node, accessor, void 0, isSVG, skipChildren); +} +function dynamicProperty(props, key) { + const src = props[key]; + Object.defineProperty(props, key, { + get() { + return src(); + }, + enumerable: true + }); + return props; +} +function insert(parent, accessor, marker, initial) { + if (marker !== void 0 && !initial) + initial = []; + if (typeof accessor !== "function") + return insertExpression(parent, accessor, initial, marker); + createRenderEffect((current) => insertExpression(parent, accessor(), current, marker), initial); +} +function assign(node, props, isSVG, skipChildren, prevProps = {}) { + for (const prop in prevProps) { + if (!(prop in props)) { + if (prop === "children") + continue; + assignProp(node, prop, null, prevProps[prop], isSVG); + } + } + for (const prop in props) { + if (prop === "children") { + if (!skipChildren) + insertExpression(node, props.children); + continue; + } + const value = props[prop]; + prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG); + } +} +function hydrate(code, element) { + sharedConfig.resources = globalThis._$HYDRATION.resources; + sharedConfig.completed = globalThis._$HYDRATION.completed; + sharedConfig.events = globalThis._$HYDRATION.events; + sharedConfig.context = { + id: "", + count: 0, + loadResource: globalThis._$HYDRATION.loadResource + }; + sharedConfig.registry = new Map(); + gatherHydratable(element); + const dispose = render(code, element, [...element.childNodes]); + sharedConfig.context = null; + return dispose; +} +function gatherHydratable(element) { + const templates = element.querySelectorAll(`*[data-hk]`); + for (let i = 0; i < templates.length; i++) { + const node = templates[i]; + sharedConfig.registry.set(node.getAttribute("data-hk"), node); + } +} +function getNextElement(template2) { + let node, key; + if (!sharedConfig.context || !(node = sharedConfig.registry.get(key = getHydrationKey()))) { + return template2.cloneNode(true); + } + if (sharedConfig.completed) + sharedConfig.completed.add(node); + sharedConfig.registry.delete(key); + return node; +} +function getNextMatch(el, nodeName) { + while (el && el.localName !== nodeName) + el = el.nextSibling; + return el; +} +function getNextMarker(start) { + let end = start, count = 0, current = []; + if (sharedConfig.context) { + while (end) { + if (end.nodeType === 8) { + const v = end.nodeValue; + if (v === "#") + count++; + else if (v === "/") { + if (count === 0) + return [end, current]; + count--; + } + } + current.push(end); + end = end.nextSibling; + } + } + return [end, current]; +} +function runHydrationEvents() { + if (sharedConfig.events && !sharedConfig.events.queued) { + queueMicrotask(() => { + const { + completed, + events + } = sharedConfig; + events.queued = false; + while (events.length) { + const [el, e] = events[0]; + if (!completed.has(el)) + return; + eventHandler(e); + events.shift(); + } + }); + sharedConfig.events.queued = true; + } +} +function toPropertyName(name) { + return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase()); +} +function toggleClassKey(node, key, value) { + const classNames = key.trim().split(/\s+/); + for (let i = 0, nameLen = classNames.length; i < nameLen; i++) + node.classList.toggle(classNames[i], value); +} +function assignProp(node, prop, value, prev, isSVG) { + let isCE, isProp, isChildProp; + if (prop === "style") + return style(node, value, prev); + if (prop === "classList") + return classList(node, value, prev); + if (value === prev) + return prev; + if (prop === "ref") { + value(node); + } else if (prop.slice(0, 3) === "on:") { + node.addEventListener(prop.slice(3), value); + } else if (prop.slice(0, 10) === "oncapture:") { + node.addEventListener(prop.slice(10), value, true); + } else if (prop.slice(0, 2) === "on") { + const name = prop.slice(2).toLowerCase(); + const delegate = DelegatedEvents.has(name); + addEventListener(node, name, value, delegate); + delegate && delegateEvents([name]); + } else if ((isChildProp = ChildProperties.has(prop)) || !isSVG && (PropAliases[prop] || (isProp = Properties.has(prop))) || (isCE = node.nodeName.includes("-"))) { + if (isCE && !isProp && !isChildProp) + node[toPropertyName(prop)] = value; + else + node[PropAliases[prop] || prop] = value; + } else { + const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]]; + if (ns) + setAttributeNS(node, ns, prop, value); + else + setAttribute(node, Aliases[prop] || prop, value); + } + return value; +} +function eventHandler(e) { + const key = `$$${e.type}`; + let node = e.composedPath && e.composedPath()[0] || e.target; + if (e.target !== node) { + Object.defineProperty(e, "target", { + configurable: true, + value: node + }); + } + Object.defineProperty(e, "currentTarget", { + configurable: true, + get() { + return node; + } + }); + while (node !== null) { + const handler = node[key]; + if (handler && !node.disabled) { + const data = node[`${key}Data`]; + data !== void 0 ? handler(data, e) : handler(e); + if (e.cancelBubble) + return; + } + node = node.host && node.host !== node && node.host instanceof Node ? node.host : node.parentNode; + } +} +function spreadExpression(node, props, prevProps = {}, isSVG, skipChildren) { + if (!skipChildren && "children" in props) { + createRenderEffect(() => prevProps.children = insertExpression(node, props.children, prevProps.children)); + } + createRenderEffect(() => assign(node, props, isSVG, true, prevProps)); + return prevProps; +} +function insertExpression(parent, value, current, marker, unwrapArray) { + while (typeof current === "function") + current = current(); + if (value === current) + return current; + const t = typeof value, multi = marker !== void 0; + parent = multi && current[0] && current[0].parentNode || parent; + if (t === "string" || t === "number") { + if (t === "number") + value = value.toString(); + if (multi) { + let node = current[0]; + if (node && node.nodeType === 3) { + node.data = value; + } else + node = document.createTextNode(value); + current = cleanChildren(parent, current, marker, node); + } else { + if (current !== "" && typeof current === "string") { + current = parent.firstChild.data = value; + } else + current = parent.textContent = value; + } + } else if (value == null || t === "boolean") { + if (sharedConfig.context) + return current; + current = cleanChildren(parent, current, marker); + } else if (t === "function") { + createRenderEffect(() => { + let v = value(); + while (typeof v === "function") + v = v(); + current = insertExpression(parent, v, current, marker); + }); + return () => current; + } else if (Array.isArray(value)) { + const array = []; + if (normalizeIncomingArray(array, value, unwrapArray)) { + createRenderEffect(() => current = insertExpression(parent, array, current, marker, true)); + return () => current; + } + if (sharedConfig.context && current && current.length) + return current; + if (array.length === 0) { + current = cleanChildren(parent, current, marker); + if (multi) + return current; + } else { + if (Array.isArray(current)) { + if (current.length === 0) { + appendNodes(parent, array, marker); + } else + reconcileArrays(parent, current, array); + } else if (current == null || current === "") { + appendNodes(parent, array); + } else { + reconcileArrays(parent, multi && current || [parent.firstChild], array); + } + } + current = array; + } else if (value instanceof Node) { + if (Array.isArray(current)) { + if (multi) + return current = cleanChildren(parent, current, marker, value); + cleanChildren(parent, current, null, value); + } else if (current == null || current === "" || !parent.firstChild) { + parent.appendChild(value); + } else + parent.replaceChild(value, parent.firstChild); + current = value; + } else + ; + return current; +} +function normalizeIncomingArray(normalized, array, unwrap) { + let dynamic = false; + for (let i = 0, len = array.length; i < len; i++) { + let item = array[i], t; + if (item instanceof Node) { + normalized.push(item); + } else if (item == null || item === true || item === false) + ; + else if (Array.isArray(item)) { + dynamic = normalizeIncomingArray(normalized, item) || dynamic; + } else if ((t = typeof item) === "string") { + normalized.push(document.createTextNode(item)); + } else if (t === "function") { + if (unwrap) { + while (typeof item === "function") + item = item(); + dynamic = normalizeIncomingArray(normalized, Array.isArray(item) ? item : [item]) || dynamic; + } else { + normalized.push(item); + dynamic = true; + } + } else + normalized.push(document.createTextNode(item.toString())); + } + return dynamic; +} +function appendNodes(parent, array, marker) { + for (let i = 0, len = array.length; i < len; i++) + parent.insertBefore(array[i], marker); +} +function cleanChildren(parent, current, marker, replacement) { + if (marker === void 0) + return parent.textContent = ""; + const node = replacement || document.createTextNode(""); + if (current.length) { + let inserted = false; + for (let i = current.length - 1; i >= 0; i--) { + const el = current[i]; + if (node !== el) { + const isParent = el.parentNode === parent; + if (!inserted && !i) + isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker); + else + isParent && parent.removeChild(el); + } else + inserted = true; + } + } else + parent.insertBefore(node, marker); + return [node]; +} +function getHydrationKey() { + const hydrate2 = sharedConfig.context; + return `${hydrate2.id}${hydrate2.count++}`; +} +function Assets() { + return; +} +function NoHydration(props) { + return sharedConfig.context ? void 0 : props.children; +} +function renderToString(fn, options) { +} +function renderToStringAsync(fn, options) { +} +function pipeToNodeWritable(fn, writable, options) { +} +function pipeToWritable(fn, writable, options) { +} +function ssr(template2, ...nodes) { +} +function resolveSSRNode(node) { +} +function ssrClassList(value) { +} +function ssrStyle(value) { +} +function ssrSpread(accessor) { +} +function ssrBoolean(key, value) { +} +function ssrHydrationKey() { +} +function escape(html) { +} +function generateHydrationScript() { +} +const isServer = false; +const SVG_NAMESPACE = "http://www.w3.org/2000/svg"; +function createElement(tagName, isSVG = false) { + return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName); +} +function Portal(props) { + const { + useShadow + } = props, marker = document.createTextNode(""), mount = props.mount || document.body; + function renderPortal() { + if (sharedConfig.context) { + const [s, set] = createSignal(false); + queueMicrotask(() => set(true)); + return () => s() && props.children; + } else + return () => props.children; + } + if (mount instanceof HTMLHeadElement) { + const [clean, setClean] = createSignal(false); + const cleanup = () => setClean(true); + createRoot((dispose) => insert(mount, () => !clean() ? renderPortal()() : dispose(), null)); + onCleanup(() => { + if (sharedConfig.context) + queueMicrotask(cleanup); + else + cleanup(); + }); + } else { + const container = createElement(props.isSVG ? "g" : "div", props.isSVG), renderRoot = useShadow && container.attachShadow ? container.attachShadow({ + mode: "open" + }) : container; + Object.defineProperty(container, "host", { + get() { + return marker.parentNode; + } + }); + insert(renderRoot, renderPortal()); + mount.appendChild(container); + props.ref && props.ref(container); + onCleanup(() => mount.removeChild(container)); + } + return marker; +} +function Dynamic(props) { + const [p, others] = splitProps(props, ["component"]); + return createMemo(() => { + const component = p.component; + switch (typeof component) { + case "function": + return untrack(() => component(others)); + case "string": + const isSvg = SVGElements.has(component); + const el = sharedConfig.context ? getNextElement() : createElement(component, isSvg); + spread(el, others, isSvg); + return el; + } + }); +} +var web = /* @__PURE__ */ Object.freeze({ + __proto__: null, + Aliases, + Assets, + ChildProperties, + DelegatedEvents, + Dynamic, + HydrationScript: Assets, + NoHydration, + Portal, + PropAliases, + Properties, + SVGElements, + SVGNamespace, + addEventListener, + assign, + classList, + clearDelegatedEvents, + delegateEvents, + dynamicProperty, + escape, + gatherHydratable, + generateHydrationScript, + getHydrationKey, + getNextElement, + getNextMarker, + getNextMatch, + hydrate, + insert, + isServer, + memo, + pipeToNodeWritable, + pipeToWritable, + render, + renderToString, + renderToStringAsync, + resolveSSRNode, + runHydrationEvents, + setAttribute, + setAttributeNS, + spread, + ssr, + ssrBoolean, + ssrClassList, + ssrHydrationKey, + ssrSpread, + ssrStyle, + style, + template, + ErrorBoundary, + For, + Index, + Match, + Show, + Suspense, + SuspenseList, + Switch, + createComponent, + effect: createRenderEffect, + getOwner, + mergeProps +}); +export {Aliases as A, memo as B, ChildProperties as C, DelegatedEvents as D, pipeToNodeWritable as E, pipeToWritable as F, render as G, renderToString as H, renderToStringAsync as I, resolveSSRNode as J, runHydrationEvents as K, ssr as L, ssrBoolean as M, NoHydration as N, ssrClassList as O, PropAliases as P, ssrHydrationKey as Q, ssrSpread as R, SVGElements as S, ssrStyle as T, template as U, assign as a, style as b, delegateEvents as c, dynamicProperty as d, classList as e, setAttribute as f, setAttributeNS as g, addEventListener as h, insert as i, Properties as j, SVGNamespace as k, Assets as l, Dynamic as m, Portal as n, clearDelegatedEvents as o, escape as p, gatherHydratable as q, generateHydrationScript as r, spread as s, getHydrationKey as t, getNextElement as u, getNextMarker as v, web as w, getNextMatch as x, hydrate as y, isServer as z}; +export default null;