octane 0.4.3 → 0.6.0

package/dist/behavior-form-submissions.d.ts

@@ -0,0 +1,12 @@
+declare const FORM_SUBMISSION_CAPTURE: unique symbol;
+/** Opaque synchronous opt-in produced by captureFormSubmissions(). */
+export interface FormSubmissionCapture {
+    readonly [FORM_SUBMISSION_CAPTURE]: true;
+}
+/**
+ * Explicitly connect parser-time commands to this behavior root before any
+ * registration can adopt its DOM. Unconfigured nested roots reserve their own
+ * scope and keep the ordinary two-argument native captureEvent contract.
+ */
+export declare function captureFormSubmissions(): FormSubmissionCapture;
+export {};

package/dist/behavior-form-submissions.js

@@ -0,0 +1,228 @@
+import {
+  FORM_SUBMISSION_ATTR,
+  getEarlyFormSubmissionMailbox,
+  isEarlyFormSubmissionCurrent,
+  isEarlyFormSubmitActivation
+} from "./form-submission.js";
+import {
+  HYDRATE_ID_ATTR,
+  HYDRATE_INDEPENDENT_ATTR,
+  HYDRATE_WHEN_ATTR
+} from "./hydration-markers.js";
+import {
+  EARLY_HYDRATION_INTENTS_KEY,
+  HYDRATE_INTERACTION_EVENTS_ATTR
+} from "./hydration/interaction-config.js";
+import {
+  captureNativeHydrationIntent,
+  initializeHydrationEventCapture
+} from "./hydration/event-capture.js";
+import {
+  getNativeHydrationCapture,
+  getNativeHydrationDocument,
+  getNativeHydrationDOM,
+  NATIVE_HYDRATION_CAPTURE_KEY
+} from "./hydration/native-intent.js";
+let earlySubmissionRanges;
+let earlySubmissionRoots;
+let controllers;
+function captureFormSubmissions() {
+  const capture = (root, flush, fail, range, matches, canceled) => {
+    root.dom = getNativeHydrationDOM(root.document);
+    const mailbox = getEarlyFormSubmissionMailbox(root.document);
+    if (mailbox === void 0) return;
+    const services = { flush, fail, range, matches, canceled };
+    installFormSubmissionActivation(root.document, mailbox);
+    let controller = controllers?.get(root.registry);
+    if (controller === void 0) {
+      controller = createSubmissionController(root, mailbox, services);
+      (controllers ??= /* @__PURE__ */ new WeakMap()).set(root.registry, controller);
+      root.registry.capture = controller;
+    }
+    controller.enabledRoots.add(root);
+    controller.flush();
+  };
+  capture.document = getNativeHydrationDocument;
+  return capture;
+}
+function installFormSubmissionActivation(document, mailbox) {
+  let feature = getNativeHydrationCapture(document);
+  if (feature?.push !== void 0) return;
+  if (feature === void 0) {
+    feature = { skip: isEarlyFormSubmitActivation };
+    document[NATIVE_HYDRATION_CAPTURE_KEY] = feature;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  const elementPrototype = formSubmissionElementPrototype(document);
+  const dom = getNativeHydrationDOM(document);
+  const queued = (packet) => {
+    const [event, form, boundary, id, when, events] = packet;
+    if (!packet[8] || seen.has(event)) return;
+    seen.add(event);
+    const record = mailbox.q.find((submission) => submission.event === event);
+    const parent = record === void 0 ? dom.parent(form) : record.parent;
+    const key = record?.key ?? elementPrototype.getAttribute.call(form, FORM_SUBMISSION_ATTR);
+    const current = () => !record?.discarded && (record?.valid?.() ?? true) && mailbox.captures(form) && event.target === form && dom.connected(form) && dom.connected(boundary) && dom.owner(form) === document && dom.owner(boundary) === document && dom.parent(form) === parent && elementPrototype.getAttribute.call(form, FORM_SUBMISSION_ATTR) === key && elementPrototype.closest.call(form, `[${HYDRATE_INDEPENDENT_ATTR}]`) === boundary && elementPrototype.getAttribute.call(boundary, HYDRATE_ID_ATTR) === id && (when === "interaction" || when === "dynamic") && elementPrototype.getAttribute.call(boundary, HYDRATE_WHEN_ATTR) === when && elementPrototype.getAttribute.call(boundary, HYDRATE_INTERACTION_EVENTS_ATTR) === events;
+    captureNativeHydrationIntent(boundary, event, current);
+  };
+  feature.push = queued;
+  initializeHydrationEventCapture(document);
+  const host = document;
+  const intents = host[EARLY_HYDRATION_INTENTS_KEY];
+  for (const packet of intents?.q.splice(0) ?? []) queued(packet);
+  for (const submission of mailbox.q) {
+    if (seen.has(submission.event) || submission.boundary === null || submission.boundaryId === null)
+      continue;
+    intents?.capture?.([
+      submission.event,
+      submission.form,
+      submission.boundary,
+      submission.boundaryId,
+      submission.boundaryWhen,
+      submission.boundaryEvents,
+      void 0,
+      void 0,
+      true,
+      submission.sequence
+    ]);
+  }
+}
+function createSubmissionController(root, mailbox, services) {
+  const registry = root.registry;
+  const document = root.document;
+  const enabledRoots = /* @__PURE__ */ new Set();
+  const receive = (submission) => receiveEarlyFormSubmission(document, registry, mailbox, submission, enabledRoots, services);
+  const controller = {
+    enabledRoots,
+    flush: () => mailbox.flush(),
+    skip: (owner, event) => enabledRoots.has(owner) && mailbox.has(event),
+    release: (entry) => {
+      if (enabledRoots.has(entry.root)) releaseBehaviorSubmissions(entry, services);
+    },
+    dispose: (owner) => {
+      if (registry.roots.get(owner.container) !== owner) return;
+      if (enabledRoots.has(owner)) {
+        for (const entry of owner.behaviors) releaseBehaviorSubmissions(entry, services);
+      }
+      for (const submission of [...mailbox.q]) {
+        if (containsFormSubmission(owner, submission.form) && !hasNestedSubmissionOwner(owner, submission.form))
+          mailbox.release(submission.form);
+      }
+      enabledRoots.delete(owner);
+      if (enabledRoots.size === 0) {
+        if (mailbox.receive === receive) mailbox.receive = void 0;
+        if (registry.capture === controller) registry.capture = void 0;
+        controllers?.delete(registry);
+      }
+    }
+  };
+  mailbox.receive = receive;
+  return controller;
+}
+function formSubmissionElementPrototype(document) {
+  return (document.defaultView?.Element ?? globalThis.Element).prototype;
+}
+function containsFormSubmission(root, form) {
+  return getNativeHydrationDOM(root.document).contains(root.container, form);
+}
+function matchesFormSubmissionTarget(record, form) {
+  return typeof record.entry.target === "string" ? formSubmissionElementPrototype(record.root.document).matches.call(form, record.entry.target) : record.entry.target === form;
+}
+function receiveEarlyFormSubmission(document, registry, mailbox, submission, enabledRoots, services) {
+  if (submission.snapshot === void 0) return false;
+  if (!isEarlyFormSubmissionCurrent(submission, document)) return true;
+  const previousRoot = earlySubmissionRoots?.get(submission);
+  if (previousRoot !== void 0 && (previousRoot.disposed || previousRoot.controller.signal.aborted || !containsFormSubmission(previousRoot, submission.form))) {
+    submission.discarded = true;
+    return true;
+  }
+  let rangeElement = submission.form;
+  let acceptedRange;
+  while (rangeElement !== null) {
+    acceptedRange = registry.ranges.get(rangeElement);
+    if (acceptedRange !== void 0) break;
+    rangeElement = getNativeHydrationDOM(document).parent(rangeElement);
+  }
+  const previousRange = earlySubmissionRanges?.get(submission);
+  if (previousRange !== void 0 && previousRange !== acceptedRange) {
+    submission.discarded = true;
+    return true;
+  }
+  if (acceptedRange !== void 0 && previousRange === void 0)
+    (earlySubmissionRanges ??= /* @__PURE__ */ new WeakMap()).set(submission, acceptedRange);
+  let ownerRoot;
+  for (const root of registry.roots.values()) {
+    if (root.disposed || !containsFormSubmission(root, submission.form)) continue;
+    if (ownerRoot === void 0 || formSubmissionElementPrototype(document).contains.call(ownerRoot.container, root.container))
+      ownerRoot = root;
+  }
+  if (ownerRoot !== void 0 && previousRoot === void 0)
+    (earlySubmissionRoots ??= /* @__PURE__ */ new WeakMap()).set(submission, ownerRoot);
+  const record = ownerRoot !== void 0 && enabledRoots.has(ownerRoot) ? ownerRoot.byId.get(submission.key) : void 0;
+  if (record === void 0 || record.controller.signal.aborted || !record.entry.events?.includes("submit") || record.entry.captureEvent === void 0 || !matchesFormSubmissionTarget(record, submission.form) || !services.matches(record, services.range(record.root, submission.form)))
+    return false;
+  const range = services.range(record.root, submission.form);
+  const queued = {
+    event: submission.event,
+    element: submission.form,
+    range,
+    payload: services.canceled,
+    valid: () => {
+      const valid = !submission.discarded && !record.controller.signal.aborted && !record.root.controller.signal.aborted && mailbox.captures(submission.form) && containsFormSubmission(record.root, submission.form) && isEarlyFormSubmissionCurrent(submission, document) && services.range(record.root, submission.form) === range;
+      if (!valid) submission.discarded = true;
+      return valid;
+    }
+  };
+  submission.valid = queued.valid;
+  record.queue.push(queued);
+  if (range?.status === "pending") record.waiting.add(range);
+  record.captureDepth = (record.captureDepth ?? 0) + 1;
+  try {
+    const payload = record.entry.captureEvent(
+      submission.event,
+      submission.form,
+      submission.snapshot
+    );
+    if (!record.controller.signal.aborted && containsFormSubmission(record.root, submission.form) && matchesFormSubmissionTarget(record, submission.form) && services.range(record.root, submission.form) === range && isEarlyFormSubmissionCurrent(submission, document))
+      queued.payload = payload;
+  } catch (error) {
+    services.fail(record, error);
+    throw error;
+  } finally {
+    record.captureDepth--;
+  }
+  submission.snapshot = void 0;
+  if (queued.payload === services.canceled) submission.discarded = true;
+  services.flush(record);
+  return true;
+}
+function hasNestedSubmissionOwner(root, form) {
+  for (const nested of root.registry.roots.values()) {
+    if (nested === root || nested.disposed || !formSubmissionElementPrototype(root.document).contains.call(
+      root.container,
+      nested.container
+    ) || !containsFormSubmission(nested, form))
+      continue;
+    return true;
+  }
+  return false;
+}
+function releaseBehaviorSubmissions(record, services) {
+  if (record.entry.id === void 0 || !record.entry.events?.includes("submit") || record.entry.captureEvent === void 0)
+    return;
+  const mailbox = getEarlyFormSubmissionMailbox(record.root.document);
+  if (mailbox === void 0) return;
+  const elementPrototype = formSubmissionElementPrototype(record.root.document);
+  for (const form of elementPrototype.querySelectorAll.call(
+    record.root.container,
+    `form[${FORM_SUBMISSION_ATTR}]`
+  )) {
+    if (elementPrototype.getAttribute.call(form, FORM_SUBMISSION_ATTR) === record.entry.id && matchesFormSubmissionTarget(record, form) && services.matches(record, services.range(record.root, form)) && !hasNestedSubmissionOwner(record.root, form))
+      mailbox.release(form);
+  }
+  if (elementPrototype.matches.call(record.root.container, "form") && elementPrototype.getAttribute.call(record.root.container, FORM_SUBMISSION_ATTR) === record.entry.id && matchesFormSubmissionTarget(record, record.root.container) && services.matches(record, services.range(record.root, record.root.container)) && !hasNestedSubmissionOwner(record.root, record.root.container))
+    mailbox.release(record.root.container);
+}
+export {
+  captureFormSubmissions
+};

package/dist/behavior-root-types.d.ts

@@ -0,0 +1,93 @@
+import type { BehaviorCleanup, BehaviorEntry, ExternalRange } from './behavior-root.js';
+import type { NativeHydrationDOM } from './hydration/native-intent.js';
+export type Readiness = {
+    promise: Promise<void>;
+    resolve: () => void;
+    reject: (reason: unknown) => void;
+    settled: boolean;
+};
+export type DocumentRegistry = {
+    roots: Map<Element, RootRecord>;
+    ranges: Map<Element, RangeRecord>;
+    capture?: BehaviorCaptureHooks;
+};
+export type BehaviorDOM = Pick<NativeHydrationDOM, 'element' | 'parent' | 'matches' | 'query' | 'target'> & {
+    contains(container: Element, element: Element, document: Document): boolean;
+};
+export type RootRecord = {
+    container: Element;
+    document: Document;
+    dom: BehaviorDOM;
+    registry: DocumentRegistry;
+    controller: AbortController;
+    behaviors: Set<EntryRecord>;
+    byId: Map<string, EntryRecord>;
+    ranges: Set<RangeRecord>;
+    pending: Set<Promise<void>>;
+    listeners: Map<string, EventListener>;
+    observer: MutationObserver | null;
+    disposed: boolean;
+    unlinkSignal: (() => void) | null;
+};
+export type RangeRecord = {
+    root: RootRecord;
+    element: Element;
+    owner: unknown;
+    controller: AbortController;
+    ready: Readiness;
+    status: 'pending' | 'ready' | 'failed' | 'disposed';
+    unlinks: Array<() => void>;
+    publicRange: ExternalRange;
+};
+export type EntryRecord = {
+    root: RootRecord;
+    entry: BehaviorEntry;
+    controller: AbortController;
+    ready: Readiness;
+    status: 'pending' | 'active' | 'failed' | 'disposed';
+    adoptions: Map<Element, AdoptionRecord>;
+    pendingCount: number;
+    waiting: Set<RangeRecord>;
+    queue: Array<{
+        event: Event;
+        element: Element;
+        range: RangeRecord | undefined;
+        payload?: unknown;
+        valid?: () => boolean;
+    }>;
+    head: number;
+    flushDepth: number;
+    captureDepth?: number;
+    unlinks: Array<() => void>;
+    scanned: boolean;
+};
+/** @internal Optional native command ingress; implementations stay outside the core. */
+export type BehaviorCaptureHooks = {
+    flush(): void;
+    skip(root: RootRecord, event: Event): boolean;
+    release(entry: EntryRecord): void;
+    dispose(root: RootRecord): void;
+};
+/** @internal Existing FIFO/readiness operations supplied only to an opted-in root. */
+export type BehaviorCaptureServices = {
+    range(root: RootRecord, element: Element): RangeRecord | undefined;
+    matches(entry: EntryRecord, range: RangeRecord | undefined): boolean;
+    flush(entry: EntryRecord): void;
+    fail(entry: EntryRecord, error: unknown): void;
+    canceled: unknown;
+};
+/** @internal Callable representation of the public opaque capture configuration. */
+export type BehaviorCaptureFactory = {
+    (root: RootRecord, flush: BehaviorCaptureServices['flush'], fail: BehaviorCaptureServices['fail'], range: BehaviorCaptureServices['range'], matches: BehaviorCaptureServices['matches'], canceled: unknown): void;
+    document(container: unknown): Document | null;
+};
+export type AdoptionRecord = {
+    entry: EntryRecord;
+    element: Element;
+    range: RangeRecord | undefined;
+    controller: AbortController;
+    unlinks: Array<() => void>;
+    cleanup: BehaviorCleanup | undefined;
+    pending: boolean;
+    disposed: boolean;
+};

package/dist/behavior-root.d.ts

@@ -1,12 +1,19 @@
 export { adoptBindings, mountBindings, unbound } from './dom-bindings.js';
 export type { BindingSource, BindingOptions, BindingHandle } from './dom-bindings.js';
 export type { BindingRange, BindingMountTarget } from './dom-binding-program.js';
+import type { CapturedFormSubmission } from './form-submission.js';
+import type { FormSubmissionCapture } from './behavior-form-submissions.js';
+export type { FormSubmissionCapture } from './behavior-form-submissions.js';
+export { captureFormSubmissions } from './behavior-form-submissions.js';
+export type { CapturedFormSubmission } from './form-submission.js';
 /** A behavior-only root observes existing DOM without taking reconciliation ownership. */
 export interface BehaviorRootOptions {
     /** Dispose this root when the enclosing page or document lifetime ends. */
     signal?: AbortSignal;
     /** Explicitly dispose an existing behavior root attached to this container. */
     replace?: boolean;
+    /** Explicit synchronous parser-command ingress for this root. */
+    formSubmissions?: FormSubmissionCapture;
 }
 export interface BehaviorDisposeOptions {
     /** Existing DOM is retained unless its removal is explicitly requested. */
@@ -46,10 +53,11 @@ export interface BehaviorEntry<Payload = unknown> {
     /**
      * Synchronously capture detached, immutable command arguments on the original
      * native event, before readiness or adoption. Register eagerly; this cannot
-     * recover values from interactions that happened before registration.
+     * recover earlier values unless the form opted into parser-time submit capture.
+     * Its third argument is the accepted snapshot for those native submissions.
      * May preventDefault(), but must not return live DOM/state or a promise.
      */
-    captureEvent?(event: Event, element: Element): Payload;
+    captureEvent?(event: Event, element: Element, submission?: CapturedFormSubmission): Payload;
     ready?: PromiseLike<unknown>;
     dependencies?: readonly string[];
     conflicts?: readonly string[];