@dom-expressions/runtime 0.50.0-next.15

package/src/reconcile.d.ts

@@ -0,0 +1 @@
+export default function reconcileArrays(parentNode: Node, a: Node[], b: Node[]): void;

package/src/reconcile.js

@@ -0,0 +1,149 @@
+// Slightly modified version of: https://github.com/WebReflection/udomdiff/blob/master/index.js
+import { $$SLOT } from "./constants";
+
+export default function reconcileArrays(parentNode, a, b, marker) {
+  let bLength = b.length,
+    aEnd = a.length,
+    bEnd = bLength,
+    aStart = 0,
+    bStart = 0,
+    tail = a[aEnd - 1],
+    tailTag = tail[$$SLOT],
+    // Ownership tag: an unclaimed node (no `$$SLOT`) is fair game; a tagged
+    // node belongs only to the slot whose marker matches. If `a`'s tail has
+    // migrated to another slot — same parent or otherwise — `tail.nextSibling`
+    // points into a region we don't own, so fall back to `marker`. `marker ||
+    // null` keeps non-multi (root-mode) callers happy.
+    after =
+      tail.parentNode === parentNode && (!tailTag || tailTag === marker)
+        ? tail.nextSibling
+        : marker || null,
+    map = null,
+    anchor,
+    anchorTag;
+
+  while (aStart < aEnd || bStart < bEnd) {
+    // common prefix
+    if (a[aStart] === b[bStart]) {
+      aStart++;
+      bStart++;
+      continue;
+    }
+    // common suffix
+    while (a[aEnd - 1] === b[bEnd - 1]) {
+      aEnd--;
+      bEnd--;
+    }
+    // append
+    if (aEnd === aStart) {
+      let node;
+      if (bEnd < bLength) {
+        if (bStart) {
+          const prev = b[bStart - 1];
+          const prevTag = prev[$$SLOT];
+          node =
+            prev.parentNode === parentNode && (!prevTag || prevTag === marker)
+              ? prev.nextSibling
+              : after;
+        } else node = b[bEnd - bStart];
+      } else node = after;
+
+      while (bStart < bEnd) {
+        const n = b[bStart++];
+        parentNode.insertBefore(n, node);
+        if (marker) n[$$SLOT] = marker;
+      }
+      // remove
+    } else if (bEnd === bStart) {
+      while (aStart < aEnd) {
+        const n = a[aStart++];
+        if (!map || !map.has(n)) {
+          const tag = n[$$SLOT];
+          if (n.parentNode === parentNode && (!tag || tag === marker)) n.remove();
+        }
+      }
+      // swap backward — symmetric end-swap detected. Walk inward with a single
+      // stable front anchor (a[aStart]); each move targets the same DOM-position
+      // so the browser's adjacency cache stays warm and per-call native
+      // `insertBefore` cost drops sharply on reorder-heavy patterns (e.g. reverse).
+      // Only optimize when the anchor still belongs to us; otherwise fall through
+      // to the map branch which gates each destructive op. The anchor and its
+      // tag are read once per detected swap and reused — important on hot
+      // reorder benches (`reconcile-permute reverse`) where this branch fires
+      // on every inner-loop step.
+    } else if (
+      (anchor = a[aStart]) === b[bEnd - 1] &&
+      b[bStart] === a[aEnd - 1] &&
+      anchor.parentNode === parentNode &&
+      (!(anchorTag = anchor[$$SLOT]) || anchorTag === marker)
+    ) {
+      // Tightest inner loop in the file; one `insertBefore` per iter plus an
+      // end-condition probe. Splitting on `marker` avoids a per-iter branch in
+      // the hot path — js-framework-benchmark `05_swap1k` regresses ~6.5% when
+      // this is collapsed (validated 2026-05-16 on Chrome headless).
+      if (marker) {
+        do {
+          const n = a[--aEnd];
+          parentNode.insertBefore(n, anchor);
+          n[$$SLOT] = marker;
+          bStart++;
+          if (aStart >= aEnd - 1 || bStart >= bEnd) break;
+        } while (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]);
+      } else {
+        do {
+          parentNode.insertBefore(a[--aEnd], anchor);
+          bStart++;
+          if (aStart >= aEnd - 1 || bStart >= bEnd) break;
+        } while (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]);
+      }
+      // fallback to map
+    } 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 head = a[aStart];
+            const headTag = head[$$SLOT];
+            const node =
+              head.parentNode === parentNode && (!headTag || headTag === marker) ? head : after;
+            while (bStart < index) {
+              const n = b[bStart++];
+              parentNode.insertBefore(n, node);
+              if (marker) n[$$SLOT] = marker;
+            }
+          } else {
+            const oldNode = a[aStart++];
+            const newNode = b[bStart++];
+            const oldTag = oldNode[$$SLOT];
+            if (oldNode.parentNode === parentNode && (!oldTag || oldTag === marker)) {
+              parentNode.replaceChild(newNode, oldNode);
+            } else {
+              parentNode.insertBefore(newNode, after);
+            }
+            if (marker) newNode[$$SLOT] = marker;
+          }
+        } else aStart++;
+      } else {
+        const n = a[aStart++];
+        const nTag = n[$$SLOT];
+        if (n.parentNode === parentNode && (!nTag || nTag === marker)) n.remove();
+      }
+    }
+  }
+}

package/src/serializer.d.ts

@@ -0,0 +1,3 @@
+import { Serializer } from "seroval";
+
+export default function createSerializer(onData: (value: string) => void): Serializer;

package/src/serializer.js

@@ -0,0 +1,54 @@
+import { Feature, Serializer, getCrossReferenceHeader } from "seroval";
+import {
+  AbortSignalPlugin,
+  CustomEventPlugin,
+  DOMExceptionPlugin,
+  EventPlugin,
+  FormDataPlugin,
+  HeadersPlugin,
+  ReadableStreamPlugin,
+  RequestPlugin,
+  ResponsePlugin,
+  URLPlugin,
+  URLSearchParamsPlugin
+} from "seroval-plugins/web";
+
+const ES2017FLAG =
+  Feature.AggregateError | // ES2021
+  Feature.BigIntTypedArray; // ES2020;
+
+const GLOBAL_IDENTIFIER = "_$HY.r"; // TODO this is a pending name
+
+export function createSerializer({ onData, onDone, scopeId, onError, plugins: customPlugins }) {
+  const defaultPlugins = [
+    AbortSignalPlugin,
+    // BlobPlugin,
+    CustomEventPlugin,
+    DOMExceptionPlugin,
+    EventPlugin,
+    // FilePlugin,
+    FormDataPlugin,
+    HeadersPlugin,
+    ReadableStreamPlugin,
+    RequestPlugin,
+    ResponsePlugin,
+    URLSearchParamsPlugin,
+    URLPlugin
+  ];
+
+  const allPlugins = customPlugins ? [...customPlugins, ...defaultPlugins] : defaultPlugins;
+
+  return new Serializer({
+    scopeId,
+    plugins: allPlugins,
+    globalIdentifier: GLOBAL_IDENTIFIER,
+    disabledFeatures: ES2017FLAG,
+    onData,
+    onDone,
+    onError
+  });
+}
+
+export function getLocalHeaderScript(id) {
+  return getCrossReferenceHeader(id) + ";";
+}

package/src/server.d.ts

@@ -0,0 +1,193 @@
+import { JSX } from "./jsx.js";
+export const DOMWithState: Record<string, Record<string, 1 | 2>>;
+export const ChildProperties: Set<string>;
+export const DelegatedEvents: Set<string>;
+export const DOMElements: Set<string>;
+export const SVGElements: Set<string>;
+export const MathMLElements: Set<string>;
+export const VoidElements: Set<string>;
+export const RawTextElements: Set<string>;
+export const Namespaces: Record<string, string>;
+
+type MountableElement = Element | Document | ShadowRoot | DocumentFragment | Node;
+
+export function renderToString<T>(
+  fn: () => T,
+  options?: {
+    nonce?: string;
+    renderId?: string;
+    noScripts?: boolean;
+    plugins?: any[];
+    manifest?: Record<
+      string,
+      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
+    > & { _base?: string };
+    onError?: (err: any) => void;
+  }
+): string;
+/** @deprecated use renderToStream which also returns a promise */
+export function renderToStringAsync<T>(
+  fn: () => T,
+  options?: {
+    timeoutMs?: number;
+    nonce?: string;
+    renderId?: string;
+    noScripts?: boolean;
+    plugins?: any[];
+    manifest?: Record<
+      string,
+      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
+    > & { _base?: string };
+    onError?: (err: any) => void;
+  }
+): Promise<string>;
+export function renderToStream<T>(
+  fn: () => T,
+  options?: {
+    nonce?: string;
+    renderId?: string;
+    noScripts?: boolean;
+    plugins?: any[];
+    manifest?: Record<
+      string,
+      { file: string; css?: string[]; isEntry?: boolean; imports?: string[] }
+    > & { _base?: string };
+    onCompleteShell?: (info: { write: (v: string) => void }) => void;
+    onCompleteAll?: (info: { write: (v: string) => void }) => void;
+    onError?: (err: any) => void;
+  }
+): {
+  then: (fn: (html: string) => void) => void;
+  pipe: (writable: { write: (v: string) => void; end: () => void }) => void;
+  pipeTo: (writable: WritableStream) => Promise<void>;
+};
+
+export function HydrationScript(props: { nonce?: string; eventNames?: string[] }): JSX.Element;
+export function ssr(template: string[] | string, ...nodes: any[]): { t: string };
+export function ssrElement(
+  name: string,
+  props: any,
+  children: any,
+  needsId: boolean
+): { t: string };
+export function ssrClassName(value: string | { [k: string]: boolean } | Array<any>): string;
+export function ssrStyle(value: string | { [k: string]: string }): string;
+export function ssrStyleProperty(name: string, value: any): string;
+export function ssrAttribute(key: string, value: any): string;
+export function ssrGroup<T extends () => any[]>(fn: T, n: number): T;
+export function ssrHydrationKey(): string;
+export function resolveSSRNode(node: any, result?: any, top?: boolean): any;
+export function escape(s: any, attr?: boolean): any;
+export function applyRef(
+  r: ((element: any) => void) | ((element: any) => void)[],
+  element: any
+): void;
+export function useAssets(fn: () => JSX.Element): void;
+export function getAssets(): string;
+export function getHydrationKey(): string | undefined;
+export function effect<T>(fn: (prev?: T) => T, effect: (value: T, prev?: T) => void): void;
+export function memo<T>(fn: () => T, equal: boolean): () => T;
+export function createComponent<T>(Comp: (props: T) => JSX.Element, props: T): JSX.Element;
+export function mergeProps(...sources: unknown[]): unknown;
+export function getOwner(): unknown;
+export function generateHydrationScript(options?: {
+  nonce?: string;
+  eventNames?: string[];
+}): string;
+export declare const RequestContext: unique symbol;
+export interface RequestEvent {
+  request: Request;
+  locals: Record<string | number | symbol, any>;
+}
+export function getRequestEvent(): RequestEvent | undefined;
+
+export function Assets(props: { children?: JSX.Element }): JSX.Element;
+export function untrack<T>(fn: () => T): T;
+
+// client-only APIs
+
+/** @deprecated not supported on the server side */
+export function style(
+  node: Element,
+  value: { [k: string]: string },
+  prev?: { [k: string]: string }
+): void;
+
+/** @deprecated not supported on the server side */
+export function insert<T>(
+  parent: MountableElement,
+  accessor: (() => T) | T,
+  marker?: Node | null,
+  init?: JSX.Element
+): JSX.Element;
+
+/** @deprecated not supported on the server side */
+export function spread<T>(node: Element, accessor: T, skipChildren?: Boolean): void;
+
+/** @deprecated not supported on the server side */
+export function delegateEvents(eventNames: string[]): void;
+/** @deprecated not supported on the server side */
+export function registerDelegatedRoot(root: MountableElement): void;
+/** @deprecated not supported on the server side */
+export function unregisterDelegatedRoot(root: MountableElement): void;
+/** @deprecated not supported on the server side */
+export function registerDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+/** @deprecated not supported on the server side */
+export function unregisterDelegatedContainer(
+  container: MountableElement,
+  owner?: MountableElement
+): void;
+/** @deprecated not supported on the server side */
+export function getDelegatedRoot(node: MountableElement): MountableElement | undefined;
+/** @deprecated not supported on the server side */
+export function dynamicProperty(props: unknown, key: string): unknown;
+/** @deprecated not supported on the server side */
+export function setAttribute(node: Element, name: string, value: string): void;
+/** @deprecated not supported on the server side */
+export function setAttributeNS(node: Element, namespace: string, name: string, value: string): void;
+
+/** @deprecated not supported on the server side */
+export function addEvent(node: Element, name: string, handler: () => void, delegate: boolean): void;
+
+/** @deprecated not supported on the server side */
+export function render(code: () => JSX.Element, element: MountableElement): () => void;
+/**
+ * @deprecated not supported on the server side
+ * @param flag
+ * - `undefined` — clone the template as-is (uses `cloneNode`).
+ * - `1` — use `document.importNode` instead of `cloneNode`.
+ * - `2` — the template html is wrapped; the outer tag is stripped at clone time.
+ */
+export function template(html: string, flag?: 1 | 2): () => Element;
+/** @deprecated not supported on the server side */
+export function setProperty(node: Element, name: string, value: any): void;
+/** @deprecated not supported on the server side */
+export function className(node: Element, value: string): void;
+/** @deprecated not supported on the server side */
+export function assign(node: Element, props: any, skipChildren?: Boolean): void;
+
+/** @deprecated not supported on the server side */
+export function hydrate(
+  fn: () => JSX.Element,
+  node: MountableElement,
+  options?: { renderId?: string; owner?: unknown }
+): () => void;
+
+/** @deprecated not supported on the server side */
+export function getNextElement(template?: () => Element): Element;
+/** @deprecated not supported on the server side */
+export function getNextMatch(start: Node, elementName: string): Element;
+/** @deprecated not supported on the server side */
+export function getNextMarker(start: Node): [Node, Array<Node>];
+/** @deprecated not supported on the server side */
+export function runHydrationEvents(): void;
+/** @deprecated not supported on the server side */
+export function ref(
+  fn: () => ((element: Element) => void) | ((element: Element) => void)[],
+  element: Element
+): void;
+/** @deprecated not supported on the server side */
+export function setStyleProperty(node: Element, name: string, value: any): void;