elegance-js 2.1.36 → 3.0.0

package/dist/client.js

@@ -0,0 +1,677 @@
+{
+  const _s = document.querySelector('script[data-tag="iav"]');
+  if (_s) try {
+    globalThis.__initialAtomValues = JSON.parse(_s.textContent || "{}").atoms || {};
+  } catch {
+  }
+}
+const CHUNK_SIZE = 512;
+let currentInst = null;
+function atom(id, initial) {
+  let _v = initial;
+  const _L = /* @__PURE__ */ new Set();
+  const _C = /* @__PURE__ */ new Set();
+  const self = {
+    id,
+    get value() {
+      if (currentInst) {
+        _L.add(currentInst);
+        currentInst._deps.add(self);
+      }
+      return _v;
+    },
+    set value(n) {
+      if (!Object.is(_v, n)) {
+        _v = n;
+        _L.forEach((c) => c._markDirty());
+        _C.forEach((c) => c(n));
+      }
+    },
+    _removeListener(c) {
+      _L.delete(c);
+    },
+    _addUserCallback(c) {
+      _C.add(c);
+    },
+    _removeUserCallback(c) {
+      _C.delete(c);
+    }
+  };
+  return self;
+}
+const atomRegistry = /* @__PURE__ */ new Map();
+function _getAtom(id, initial) {
+  if (atomRegistry.has(id)) return atomRegistry.get(id);
+  const sv = globalThis.__initialAtomValues?.[id];
+  const a = atom(id, sv !== void 0 ? sv : initial);
+  atomRegistry.set(id, a);
+  return a;
+}
+const track = (a, cb) => a._addUserCallback(cb);
+const untrack = (a, cb) => a._removeUserCallback(cb);
+const componentConfigs = /* @__PURE__ */ new Map();
+const instanceMap = /* @__PURE__ */ new Map();
+const rootInstanceIds = {};
+const view = (fn) => fn;
+;
+function component(cfg) {
+  const { __id, view: viewFn } = cfg;
+  if (!viewFn) {
+    console.error(`Component "${__id}": did not provide a view() method.`);
+    return;
+  }
+  componentConfigs.set(__id, cfg);
+  return (props, children) => {
+    const counters = currentInst ? currentInst._childCounters ??= {} : rootInstanceIds;
+    const idx = counters[__id] ?? 0;
+    counters[__id] = idx + 1;
+    return {
+      __type: "live",
+      __componentId: __id,
+      __instanceId: `${__id}#${idx}`,
+      props: props ?? {},
+      children
+    };
+  };
+}
+const rawHTML = (content) => ({ content, __rawHTML: true });
+const pageLoadCallbacks = [];
+const cleanupFns = /* @__PURE__ */ new Map();
+let navigationCallbacks = [];
+const onPageLoad = (cb, options = {}) => pageLoadCallbacks.push({ pathname: location.pathname, cb, options });
+function runPageCleanup() {
+  for (const [scope, fns] of cleanupFns) {
+    if (!location.pathname.startsWith(scope)) {
+      fns.forEach((f) => f());
+      cleanupFns.delete(scope);
+    }
+  }
+}
+function runPageCallbacks() {
+  const current = location.pathname;
+  for (const { pathname, cb, options } of pageLoadCallbacks) {
+    const scoped = options?.type === "scoped";
+    const unscoped = !options?.type || options.type === "unscoped";
+    if (unscoped) {
+      const cleanup2 = cb();
+      if (typeof cleanup2 === "function") cleanupFns.get("/")?.push(cleanup2);
+      continue;
+    }
+    const scope = scoped ? pathname.slice(0, pathname.lastIndexOf("/")) || "/" : pathname;
+    if (!current.startsWith(scope)) continue;
+    if (scoped && cleanupFns.has(scope)) continue;
+    if (!cleanupFns.has(scope)) cleanupFns.set(scope, []);
+    const cleanup = cb();
+    if (typeof cleanup === "function") cleanupFns.get(scope).push(cleanup);
+  }
+}
+const delegatedHandlers = /* @__PURE__ */ new WeakMap();
+function _delegatedListener(e) {
+  let target = e.target;
+  while (target && target instanceof Element) {
+    const meta = delegatedHandlers.get(target);
+    if (meta?.handlers[e.type]) {
+      Object.defineProperties(e, {
+        currentTarget: { configurable: true, value: target },
+        target: { configurable: true, value: target },
+        delegateTarget: { configurable: true, value: target }
+      });
+      meta.handlers[e.type].call(target, meta.inst?._self ?? null, e);
+      return;
+    }
+    target = target.parentElement;
+  }
+}
+const _registeredEventTypes = /* @__PURE__ */ new Set();
+function ensureEventDelegated(eventType) {
+  if (_registeredEventTypes.has(eventType)) return;
+  _registeredEventTypes.add(eventType);
+  document.addEventListener(eventType, _delegatedListener, true);
+}
+for (const et of [
+  "click",
+  "input",
+  "change",
+  "submit",
+  "keydown",
+  "keyup",
+  "mousemove",
+  "mousedown",
+  "mouseup",
+  "mouseenter",
+  "mouseleave",
+  "mouseover",
+  "mouseout",
+  "focus",
+  "blur",
+  "pointerdown",
+  "pointerup",
+  "pointermove"
+]) {
+  ensureEventDelegated(et);
+}
+function applyOptions(el, options, owner, isHydrate = false) {
+  for (let [k, v] of Object.entries(options)) {
+    if (k === "className") k = "class";
+    if (k === "key") continue;
+    if (k.startsWith("on") && typeof v === "function") {
+      let m = delegatedHandlers.get(el);
+      if (!m) delegatedHandlers.set(el, m = { inst: owner, handlers: {} });
+      else m.inst = owner;
+      const eventType = k.slice(2).toLowerCase();
+      ensureEventDelegated(eventType);
+      m.handlers[eventType] = v;
+    } else if (!isHydrate) {
+      if (typeof v === "boolean") el.toggleAttribute(k, v);
+      else if (v !== "false") {
+        const s = String(v);
+        if (el.getAttribute(k) !== s) el.setAttribute(k, s);
+      }
+    }
+  }
+}
+function getVKey(vn) {
+  if (vn == null || typeof vn !== "object") return null;
+  if (vn.__type === "element" && vn.options?.key != null) return String(vn.options.key);
+  if (vn.__type === "live" && vn.props?.key != null) return String(vn.props.key);
+  return null;
+}
+function vnodeToDom(node, owner) {
+  if (typeof node === "string" || typeof node === "number") return document.createTextNode(String(node));
+  if (node === null || node === false || node === void 0) return document.createTextNode("");
+  if (node.__rawHTML) return document.createRange().createContextualFragment(node.content).firstElementChild;
+  if (node.__type === "element") {
+    const el = document.createElement(node.tag);
+    const k = getVKey(node);
+    if (k !== null) el.__vkey = k;
+    applyOptions(el, node.options ?? {}, owner, false);
+    for (const child of node.children ?? []) el.appendChild(vnodeToDom(child, owner));
+    return el;
+  }
+  if (node.__type === "live") return mount(node);
+  return document.createDocumentFragment();
+}
+function patchChildren(el, vc, owner) {
+  const hasKeys = vc.some((c) => getVKey(c) !== null);
+  if (hasKeys) {
+    const keyedDom = /* @__PURE__ */ new Map();
+    for (const child of Array.from(el.childNodes)) {
+      const k = child.__vkey;
+      if (k != null) keyedDom.set(k, child);
+    }
+    const newChildren = [];
+    for (const vchild of vc) {
+      const k = getVKey(vchild);
+      if (k !== null && keyedDom.has(k)) {
+        const existing = keyedDom.get(k);
+        keyedDom.delete(k);
+        newChildren.push(patch(existing, vchild, owner));
+      } else {
+        const fresh = vnodeToDom(vchild, owner);
+        if (k !== null) fresh.__vkey = k;
+        newChildren.push(fresh);
+      }
+    }
+    for (const stale of keyedDom.values()) stale.__instance?._destroy();
+    for (let i = 0; i < newChildren.length; i++) {
+      const desired = newChildren[i];
+      const current = el.childNodes[i] ?? null;
+      if (current !== desired) el.insertBefore(desired, current);
+    }
+    while (el.childNodes.length > newChildren.length) {
+      const last = el.lastChild;
+      last.__instance?._destroy();
+      el.removeChild(last);
+    }
+  } else {
+    const dc = Array.from(el.childNodes);
+    const common = Math.min(dc.length, vc.length);
+    for (let i = 0; i < common; i++) patch(dc[i], vc[i], owner);
+    for (let i = common; i < vc.length; i++) el.appendChild(vnodeToDom(vc[i], owner));
+    for (let i = dc.length - 1; i >= vc.length; i--) {
+      dc[i].__instance?._destroy();
+      el.removeChild(dc[i]);
+    }
+  }
+}
+function patch(dom, vn, owner) {
+  if (vn === null || vn === false) {
+    if (dom.nodeType === Node.TEXT_NODE && dom.nodeValue === "") return dom;
+    const t = document.createTextNode("");
+    dom.__instance?._destroy();
+    dom.parentNode?.replaceChild(t, dom);
+    return t;
+  }
+  if (typeof vn === "string" || typeof vn === "number") {
+    const s = String(vn);
+    if (dom.nodeType === Node.TEXT_NODE) {
+      if (dom.nodeValue !== s) dom.nodeValue = s;
+      return dom;
+    }
+    const t = document.createTextNode(s);
+    dom.parentNode?.replaceChild(t, dom);
+    return t;
+  }
+  if (vn.__rawHTML) return document.createRange().createContextualFragment(vn.content).firstElementChild;
+  if (vn.__type === "element") {
+    if (dom.nodeType === Node.ELEMENT_NODE && dom.tagName.toLowerCase() === vn.tag) {
+      const el = dom;
+      const normOptions = {};
+      for (const [k2, v] of Object.entries(vn.options ?? {})) normOptions[k2 === "className" ? "class" : k2] = v;
+      const k = getVKey(vn);
+      if (k !== null) el.__vkey = k;
+      for (const name of el.getAttributeNames()) if (!(name in normOptions)) el.removeAttribute(name);
+      applyOptions(el, normOptions, owner, false);
+      patchChildren(el, vn.children ?? [], owner);
+      return el;
+    }
+    const fresh = vnodeToDom(vn, owner);
+    dom.parentNode?.replaceChild(fresh, dom);
+    return fresh;
+  }
+  if (vn.__type === "live") {
+    const ex = instanceMap.get(vn.__componentId + "::" + vn.__instanceId);
+    if (ex?.root === dom) {
+      ex.props = vn.props;
+      ex.children = vn.children ?? [];
+      ex._markDirty();
+      return dom;
+    }
+    const old = dom.__instance;
+    const rendered = mount(vn);
+    dom.parentNode?.replaceChild(rendered, dom);
+    old?._destroy();
+    return rendered;
+  }
+  return dom;
+}
+const flatten = (a) => a.flat(Infinity).filter((c) => c != null && c !== false && c !== "");
+function hydrateTree(vn, dom, owner) {
+  if (vn == null || vn === false || dom.nodeType === Node.TEXT_NODE || vn.__rawHTML) return;
+  if (Array.isArray(vn)) {
+    const flat = flatten(vn);
+    const dc = significantChildren(dom);
+    for (let i = 0; i < Math.min(flat.length, dc.length); i++) hydrateTree(flat[i], dc[i], owner);
+    return;
+  }
+  if (vn.__type === "element") {
+    applyOptions(dom, vn.options ?? {}, owner, true);
+    const dc = significantChildren(dom);
+    const vc = flatten(vn.children ?? []);
+    for (let i = 0; i < Math.min(dc.length, vc.length); i++) hydrateTree(vc[i], dc[i], owner);
+    return;
+  }
+  if (vn.__type === "live") bootstrapComponent(vn, dom);
+}
+function bootstrapComponent(desc, existingDom) {
+  const cid = desc.__componentId;
+  const instanceId = desc.__instanceId;
+  const cfg = componentConfigs.get(cid);
+  if (!cfg) return existingDom ?? document.createDocumentFragment();
+  const existing = instanceMap.get(instanceId);
+  if (existing && existingDom) {
+    existing.props = desc.props ?? {};
+    existing.children = desc.children ?? [];
+    existing.config = cfg;
+    existingDom.parentNode?.replaceChild(existing.root, existingDom);
+    existing._markDirty();
+    return existing;
+  }
+  const atomsObj = {};
+  if (cfg.atoms) for (const key in cfg.atoms) atomsObj[key] = _getAtom(`${cid}:${key}`, cfg.atoms[key]);
+  let inst;
+  const self = { get props() {
+    return inst.props;
+  }, get children() {
+    return inst.children;
+  } };
+  inst = {
+    cid,
+    instanceId,
+    config: cfg,
+    props: desc.props ?? {},
+    children: desc.children ?? [],
+    _deps: /* @__PURE__ */ new Set(),
+    _scheduled: false,
+    _self: self,
+    _atoms: atomsObj,
+    _navigationCallback: null,
+    root: existingDom || null,
+    _childCounters: {},
+    _markDirty() {
+      if (this._scheduled) return;
+      this._scheduled = true;
+      queueMicrotask(() => {
+        this._scheduled = false;
+        const vn2 = execView(this);
+        if (vn2 && typeof vn2 === "object" && (vn2.__type === "element" || vn2.__type === "live"))
+          this.root = patch(this.root, vn2, this);
+      });
+    },
+    _destroy() {
+      inst._onMountCleanup?.();
+      inst._onNavigateCleanup?.();
+      if (inst._navigationCallback)
+        navigationCallbacks.splice(navigationCallbacks.indexOf(inst._navigationCallback), 1);
+      cfg.onUnmount?.(self, atomsObj);
+      instanceMap.delete(instanceId);
+      for (const a of inst._deps) a._removeListener(inst);
+      inst._deps.clear();
+      inst.root?.remove();
+    }
+  };
+  instanceMap.set(instanceId, inst);
+  cfg.init?.(self, atomsObj);
+  const vn = execView(inst);
+  if (existingDom) {
+    hydrateTree(vn, existingDom, inst);
+    inst.root = existingDom;
+    existingDom.__instance = inst;
+  } else {
+    const dom = vnodeToDom(vn, inst);
+    inst.root = dom instanceof Element ? dom : document.createElement("div");
+    inst.root.__instance = inst;
+  }
+  if (cfg.onMount || cfg.onNavigate) queueMicrotask(() => {
+    const cleanup = cfg?.onMount?.(self, atomsObj);
+    if (typeof cleanup === "function") inst._onMountCleanup = cleanup;
+    const navigationCallback = () => {
+      if (typeof inst._onNavigateCleanup === "function") inst._onNavigateCleanup();
+      const cleanup2 = cfg?.onNavigate?.(self, atomsObj);
+      if (typeof cleanup2 === "function") inst._onNavigateCleanup = cleanup2;
+    };
+    inst._navigationCallback = navigationCallback;
+    navigationCallbacks.push(navigationCallback);
+    navigationCallback();
+  });
+  return inst;
+}
+function mount(desc) {
+  return bootstrapComponent(desc).root;
+}
+function execView(inst) {
+  inst._childCounters = {};
+  currentInst = inst;
+  for (const a of inst._deps) a._removeListener(inst);
+  inst._deps.clear();
+  try {
+    return inst.config.view({ self: inst._self, atoms: inst._atoms, children: inst.children });
+  } finally {
+    currentInst = null;
+  }
+}
+globalThis.__tags = new Proxy({}, {
+  get(_, tag) {
+    return (options, ...children) => {
+      const isOptions = options !== null && typeof options === "object" && !Array.isArray(options) && !options?.__type;
+      const kids = (isOptions ? children : [options, ...children]).flat(Infinity);
+      const merged = [];
+      for (const child of kids) {
+        if ((typeof child === "string" || typeof child === "number") && (typeof merged[merged.length - 1] === "string" || typeof merged[merged.length - 1] === "number")) {
+          merged[merged.length - 1] = String(merged[merged.length - 1]) + String(child);
+        } else {
+          merged.push(child);
+        }
+      }
+      return { __type: "element", tag, options: isOptions ? options : {}, children: merged };
+    };
+  }
+});
+const importBundle = (tag) => {
+  if (tag.src) return import(tag.src);
+  const blobCode = tag.textContent.replace(
+    /(['"])\/chunks\//g,
+    `$1${location.origin}/chunks/`
+  );
+  const blob = new Blob([blobCode], { type: "text/javascript" });
+  const url = URL.createObjectURL(blob);
+  return import(url);
+};
+async function drainBootstrapQueue(queue) {
+  let i = 0;
+  while (i < queue.length) {
+    const end = Math.min(i + CHUNK_SIZE, queue.length);
+    for (; i < end; i++) bootstrapComponent(queue[i].desc, queue[i].dom);
+    if (i < queue.length) await new Promise((r) => requestIdleCallback(r));
+  }
+}
+async function hydrateWithRegions(regions, handlers) {
+  const queue = [];
+  const instanceCounters = {};
+  for (const marker of document.body.querySelectorAll("template[data-region]")) {
+    const regionIdx = parseInt(marker.getAttribute("data-region"), 10);
+    if (isNaN(regionIdx)) continue;
+    const entries = regions[regionIdx];
+    if (!entries?.length) {
+      continue;
+    }
+    let sibling = marker.nextSibling;
+    for (const entry of entries) {
+      const cid = entry.__cid ?? entry.__componentId;
+      const count = entry.count ?? 1;
+      const props = entry.props ?? {};
+      for (let i = 0; i < count; i++) {
+        while (sibling?.nodeType === Node.TEXT_NODE && !(sibling.nodeValue ?? "").trim())
+          sibling = sibling.nextSibling;
+        const idx = instanceCounters[cid] ?? 0;
+        instanceCounters[cid] = idx + 1;
+        const syntheticDesc = { __type: "live", __componentId: cid, __instanceId: `${cid}#${idx}`, props };
+        if (sibling !== null) {
+          queue.push({ desc: syntheticDesc, dom: sibling });
+          sibling = sibling.nextSibling;
+        } else {
+          marker.parentNode?.insertBefore(mount(syntheticDesc), marker.nextSibling);
+        }
+      }
+    }
+  }
+  await drainBootstrapQueue(queue);
+  if (handlers) {
+    for (const { eid, h } of handlers) {
+      for (const { event } of h) ensureEventDelegated(event);
+      for (const el of document.querySelectorAll(`[e-id="${eid}"]`)) {
+        let m = delegatedHandlers.get(el);
+        if (!m) delegatedHandlers.set(el, m = { inst: null, handlers: {} });
+        for (const { event, fn } of h) {
+          if (typeof fn === "function") m.handlers[event] = fn;
+        }
+      }
+    }
+  }
+}
+function significantChildren(el) {
+  return Array.from(el.childNodes).filter(
+    (n) => !(n.nodeType === Node.TEXT_NODE && !(n.nodeValue ?? "").trim())
+  );
+}
+function detachNode(node) {
+  if (node.nodeType === Node.ELEMENT_NODE)
+    for (const child of Array.from(node.childNodes)) detachNode(child);
+  const inst = node.__instance;
+  if (inst) {
+    inst._destroy();
+  } else {
+    node.parentNode?.removeChild(node);
+  }
+}
+function syncOptions(from, to) {
+  const next = new Set(to.getAttributeNames());
+  for (const a of from.getAttributeNames()) if (!next.has(a)) from.removeAttribute(a);
+  for (const a of to.getAttributeNames()) {
+    const v = to.getAttribute(a);
+    if (from.getAttribute(a) !== v) from.setAttribute(a, v);
+  }
+}
+function morphKids(parent, incoming) {
+  const existing = significantChildren(parent);
+  const wanted = significantChildren(incoming);
+  const len = Math.max(existing.length, wanted.length);
+  for (let i = 0; i < len; i++) {
+    const cur = existing[i];
+    const want = wanted[i];
+    if (!want) {
+      detachNode(cur);
+    } else if (!cur) {
+      parent.appendChild(want.cloneNode(true));
+    } else if (cur.nodeType === Node.ELEMENT_NODE && want.nodeType === Node.ELEMENT_NODE && cur.tagName === want.tagName) {
+      const inst = cur.__instance;
+      if (!inst) {
+        syncOptions(cur, want);
+        morphKids(cur, want);
+      }
+    } else {
+      const inst = cur.__instance;
+      if (inst) {
+        inst._destroy();
+      } else {
+        parent.replaceChild(want.cloneNode(true), cur);
+      }
+    }
+  }
+}
+function patchHead(newHead) {
+  const newTitle = newHead.querySelector("title");
+  if (newTitle) {
+    let t = document.head.querySelector("title");
+    if (!t) {
+      t = document.createElement("title");
+      document.head.appendChild(t);
+    }
+    if (t.textContent !== newTitle.textContent) t.textContent = newTitle.textContent;
+  }
+  for (const nm of newHead.querySelectorAll("meta")) {
+    const name = nm.getAttribute("name");
+    const property = nm.getAttribute("property");
+    const equiv = nm.getAttribute("http-equiv");
+    const charset = nm.getAttribute("charset");
+    const sel = name ? `meta[name="${name}"]` : property ? `meta[property="${property}"]` : equiv ? `meta[http-equiv="${equiv}"]` : charset ? "meta[charset]" : null;
+    const existing = sel && document.head.querySelector(sel);
+    if (existing) {
+      for (const attr of nm.getAttributeNames()) existing.setAttribute(attr, nm.getAttribute(attr));
+    } else {
+      document.head.appendChild(nm.cloneNode(true));
+    }
+  }
+  const existingHrefs = new Set(
+    [...document.head.querySelectorAll("link[rel='stylesheet']")].map((l) => l.href)
+  );
+  for (const nl of newHead.querySelectorAll("link[rel='stylesheet']")) {
+    if (!existingHrefs.has(nl.href)) document.head.appendChild(nl.cloneNode(true));
+  }
+  const existingSrcs = new Set(
+    [...document.head.querySelectorAll("script[src]")].map((s) => s.src)
+  );
+  for (const ns of newHead.querySelectorAll("script[src]")) {
+    if (ns.getAttribute("data-bundle") === "true") continue;
+    if (existingSrcs.has(ns.src)) continue;
+    const s = document.createElement("script");
+    for (const attr of ns.getAttributeNames()) s.setAttribute(attr, ns.getAttribute(attr));
+    document.head.appendChild(s);
+  }
+}
+async function loadPage(url, regions, handlers, doc) {
+  if (!doc) {
+    doc = new DOMParser().parseFromString(
+      await (await fetch(url, { headers: { Accept: "text/html" } })).text(),
+      "text/html"
+    );
+  }
+  const hyd = doc.querySelector('script[data-tag="hydration"]');
+  if (hyd) try {
+    globalThis.__initialAtomValues = JSON.parse(hyd.textContent || "{}").atoms || {};
+  } catch {
+  }
+  patchHead(doc.head);
+  syncOptions(document.body, doc.body);
+  morphKids(document.body, doc.body);
+  await hydrateWithRegions(regions, handlers);
+}
+function scroll() {
+  if (location.hash) {
+    const el = document.querySelector(location.hash);
+    el?.scrollIntoView();
+  } else {
+    scrollTo(0, 0);
+  }
+}
+async function navigate(url, push = true) {
+  const { pathname } = new URL(url, location.href);
+  if (push && pathname === location.pathname) {
+    scroll();
+    return;
+  }
+  ;
+  if (push) history.pushState(null, "", url);
+  const bundleSelector = `script[data-bundle="true"][data-pathname="${pathname}"]`;
+  const localTag = document.querySelector(bundleSelector);
+  let mod;
+  let fetchedDoc;
+  if (localTag) {
+    mod = await importBundle(localTag);
+  } else {
+    const html = await (await fetch(url, { headers: { Accept: "text/html" } })).text();
+    fetchedDoc = new DOMParser().parseFromString(html, "text/html");
+    const remoteTag = fetchedDoc.querySelector(bundleSelector);
+    if (remoteTag) {
+      mod = await importBundle(remoteTag);
+    } else {
+      const bundlePath = (pathname === "/" ? "" : pathname) + "/bundle.js";
+      try {
+        mod = await import(bundlePath);
+      } catch {
+        console.error("navigate: no bundle found for this pathname.");
+        return;
+      }
+    }
+  }
+  runPageCleanup();
+  const result = (mod.default ?? (() => null))();
+  if (!Array.isArray(result?.regions)) {
+    console.error("navigate: target is not an Elegance page.");
+    return;
+  }
+  await loadPage(url, result.regions, result.handlers, fetchedDoc);
+  runPageCallbacks();
+  navigationCallbacks.forEach((f) => f());
+  scroll();
+}
+async function hydrate() {
+  const bundleTag = document.querySelector(
+    `script[data-bundle="true"][data-pathname="${location.pathname}"]`
+  );
+  if (!bundleTag) return;
+  const result = ((await importBundle(bundleTag)).default || (() => null))();
+  if (!Array.isArray(result?.regions)) return;
+  await hydrateWithRegions(result.regions, result.handlers);
+  runPageCallbacks();
+  scroll();
+  window.addEventListener("beforeunload", () => runPageCleanup());
+}
+window.addEventListener("popstate", () => navigate(location.pathname + location.search + location.hash, false));
+async function _action(target, params) {
+  const targetURL = `${location.origin}/__action`;
+  const res = await fetch(targetURL, {
+    method: "POST",
+    body: JSON.stringify(params ?? {}),
+    headers: {
+      "Content-Type": "application/json",
+      "Elegance-Action": target
+    }
+  });
+  if (!res.ok) {
+    return null;
+  }
+  const resJSON = await res.json();
+  return resJSON;
+}
+Object.assign(globalThis, { view, component, onPageLoad, track, untrack, navigate, rawHTML, _getAtom, _action });
+requestAnimationFrame(() => hydrate());
+{
+  const source = new EventSource(`http://${location.hostname}:4000/__reload`);
+  source.onmessage = (msg) => {
+    if (msg.data === "connected") return;
+    window.location.reload();
+  };
+  source.onerror = () => {
+  };
+}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+type DeepRequired<T> = {
+    [P in keyof T]-?: T[P] extends (...args: any[]) => any ? T[P] : T[P] extends object ? DeepRequired<NonNullable<T[P]>> : NonNullable<T[P]>;
+};
+type SafeEleganceConfig = DeepRequired<EleganceConfig>;
+export declare function getConfig(): Promise<SafeEleganceConfig>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,KAAK,YAAY,CAAC,CAAC,IAAI;KAClB,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,GAAG,GAChD,CAAC,CAAC,CAAC,CAAC,GACJ,CAAC,CAAC,CAAC,CAAC,SAAS,MAAM,GACf,YAAY,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAC/B,WAAW,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAC9B,CAAC;AAEF,KAAK,kBAAkB,GAAG,YAAY,CAAC,cAAc,CAAC,CAAC;AAiGvD,wBAAsB,SAAS,IAAI,OAAO,CAAC,kBAAkB,CAAC,CAM7D"}