octane 0.4.2 → 0.5.0

package/dist/behavior-root.js

@@ -1,6 +1,23 @@
 import { adoptBindings, mountBindings, unbound } from "./dom-bindings.js";
+import { captureFormSubmissions } from "./behavior-form-submissions.js";
 const documentRegistries = /* @__PURE__ */ new WeakMap();
-const CANCELED = /* @__PURE__ */ Symbol("octane.behavior.canceled");
+const DEFAULT_DOM = {
+  element: isElement,
+  parent: (node) => node.parentElement,
+  contains: (container, element, document) => element.ownerDocument === document && (element === container || container.contains(element)),
+  matches: (element, selector) => element.matches(selector),
+  query: (element, selector) => element.querySelectorAll(selector),
+  target: targetElement
+};
+function registryFor(document) {
+  let registry = documentRegistries.get(document);
+  if (registry === void 0) {
+    registry = { roots: /* @__PURE__ */ new Map(), ranges: /* @__PURE__ */ new Map() };
+    documentRegistries.set(document, registry);
+  }
+  return registry;
+}
+const CANCELED = /* @__PURE__ */ Symbol("behavior.canceled");
 function createReadiness() {
   let resolvePromise;
   let rejectPromise;
@@ -41,44 +58,30 @@ function linkSignal(signal, controller) {
 function waitUntilReady(source, signal) {
   if (signal.aborted) {
     void Promise.resolve(source).then(void 0, () => void 0);
-    return Promise.resolve(CANCELED);
+    return Promise.resolve();
   }
   return new Promise((resolve, reject) => {
-    let settled = false;
-    const cancel = () => {
-      if (settled) return;
-      settled = true;
-      resolve(CANCELED);
+    const complete = () => {
+      signal.removeEventListener("abort", complete);
+      resolve();
     };
-    signal.addEventListener("abort", cancel, { once: true });
-    Promise.resolve(source).then(
-      (value) => {
-        if (settled) return;
-        settled = true;
-        signal.removeEventListener("abort", cancel);
-        resolve(value);
-      },
-      (error) => {
-        if (settled) return;
-        settled = true;
-        signal.removeEventListener("abort", cancel);
-        reject(error);
-      }
-    );
+    signal.addEventListener("abort", complete);
+    Promise.resolve(source).then(complete, (error) => {
+      signal.removeEventListener("abort", complete);
+      reject(error);
+    });
   });
 }
 function trackPending(root, promise) {
   root.pending.add(promise);
-  void promise.then(
-    () => root.pending.delete(promise),
-    () => root.pending.delete(promise)
-  );
+  const remove = () => root.pending.delete(promise);
+  void promise.then(remove, remove);
 }
 function isElement(value) {
   return typeof value === "object" && value !== null && value.nodeType === 1;
 }
-function contains(root, element) {
-  return element.ownerDocument === root.document && (element === root.container || root.container.contains(element));
+function contains(root, element, container = root.container) {
+  return root.dom.contains(container, element, root.document);
 }
 function assertActiveRoot(root) {
   if (root.disposed || root.controller.signal.aborted) {
@@ -86,7 +89,7 @@ function assertActiveRoot(root) {
   }
 }
 function assertContainedElement(root, element, label) {
-  if (!isElement(element) || !contains(root, element)) {
+  if (!root.dom.element(element) || !contains(root, element)) {
     throw new Error(`${label} must belong to the behavior root container and document.`);
   }
 }
@@ -98,28 +101,28 @@ function nearestRange(root, element) {
       return range;
     }
     if (current === root.container) return void 0;
-    current = current.parentElement;
+    current = root.dom.parent(current);
   }
   return void 0;
 }
 function matchesTarget(record, element) {
-  return typeof record.entry.target === "string" ? element.matches(record.entry.target) : record.entry.target === element;
+  return typeof record.entry.target === "string" ? record.root.dom.matches(element, record.entry.target) : record.entry.target === element;
 }
 function rangeMatches(record, range) {
   return record.entry.owner === void 0 || range !== void 0 && Object.is(record.entry.owner, range.owner);
 }
 function dependsOnRange(record, range) {
-  if (record.waitingRanges.has(range)) return true;
+  if (record.waiting.has(range)) return true;
   if (record.entry.owner === void 0 || !Object.is(record.entry.owner, range.owner) || !contains(record.root, range.element)) {
     return false;
   }
   if (typeof record.entry.target !== "string") {
-    return range.element.contains(record.entry.target) && nearestRange(record.root, record.entry.target) === range;
+    return contains(record.root, record.entry.target, range.element) && nearestRange(record.root, record.entry.target) === range;
   }
-  if (range.element.matches(record.entry.target) && nearestRange(record.root, range.element) === range) {
+  if (record.root.dom.matches(range.element, record.entry.target) && nearestRange(record.root, range.element) === range) {
     return true;
   }
-  for (const element of range.element.querySelectorAll(record.entry.target)) {
+  for (const element of record.root.dom.query(range.element, record.entry.target)) {
     if (nearestRange(record.root, element) === range) return true;
   }
   return false;
@@ -135,7 +138,7 @@ function adoptionContext(adoption, event) {
 function finishPendingAdoption(adoption) {
   if (!adoption.pending) return;
   adoption.pending = false;
-  adoption.entry.pendingAdoptionCount--;
+  adoption.entry.pendingCount--;
 }
 function disposeAdoption(adoption) {
   if (adoption.disposed) return;
@@ -151,19 +154,19 @@ function disposeAdoption(adoption) {
 }
 function flushQueuedEvents(record) {
   if (record.status !== "active" || record.captureDepth) return;
-  const queue = record.queuedEvents;
-  record.queuedEventFlushDepth++;
+  const queue = record.queue;
+  record.flushDepth++;
   try {
-    while (record.queuedEventHead < queue.length) {
-      const index = record.queuedEventHead;
+    while (record.head < queue.length) {
+      const index = record.head;
       const queued = queue[index];
-      if (queued.payload === CANCELED || !contains(record.root, queued.element)) {
-        record.queuedEventHead = index + 1;
+      if (queued.payload === CANCELED || !(queued.valid?.() ?? contains(record.root, queued.element))) {
+        record.head = index + 1;
         continue;
       }
       const range = nearestRange(record.root, queued.element);
       if (range !== queued.range || !rangeMatches(record, range)) {
-        record.queuedEventHead = index + 1;
+        record.head = index + 1;
         continue;
       }
       if (range?.status === "pending") return;
@@ -172,8 +175,9 @@ function flushQueuedEvents(record) {
         adoption = adoptElement(record, queued.element, range, queued.event);
       }
       if (adoption === void 0 || adoption.pending) return;
-      if (record.queuedEventHead !== index || queue[index] !== queued) continue;
-      record.queuedEventHead = index + 1;
+      if (record.head !== index || queue[index] !== queued) continue;
+      record.head = index + 1;
+      if (queued.valid?.() === false) continue;
       record.entry.handleEvent?.(
         queued.event,
         queued.element,
@@ -182,34 +186,34 @@ function flushQueuedEvents(record) {
       );
     }
   } finally {
-    record.queuedEventFlushDepth--;
-    if (record.queuedEventFlushDepth === 0 && record.queuedEventHead !== 0) {
-      const consumed = record.queuedEventHead;
+    record.flushDepth--;
+    if (record.flushDepth === 0 && record.head !== 0) {
+      const consumed = record.head;
       if (consumed >= queue.length) {
         queue.length = 0;
-        record.queuedEventHead = 0;
+        record.head = 0;
       } else if (consumed >= queue.length - consumed) {
         queue.splice(0, consumed);
-        record.queuedEventHead = 0;
+        record.head = 0;
       }
     }
   }
 }
 function completeBehavior(record) {
-  if (record.status !== "active" || !record.initialScanComplete) return;
-  for (const range of [...record.waitingRanges]) {
+  if (record.status !== "active" || !record.scanned) return;
+  for (const range of record.waiting) {
     if (range.status === "pending") return;
-    record.waitingRanges.delete(range);
+    record.waiting.delete(range);
   }
-  if (record.pendingAdoptionCount !== 0) return;
+  if (record.pendingCount !== 0) return;
   flushQueuedEvents(record);
-  if (record.queuedEvents.length !== 0) return;
-  record.readiness.resolve();
+  if (record.queue.length !== 0) return;
+  record.ready.resolve();
 }
 function failBehavior(record, error) {
   if (record.status === "disposed" || record.status === "failed") return;
   record.status = "failed";
-  record.readiness.reject(error);
+  record.ready.reject(error);
   disposeBehavior(record);
 }
 function adoptElement(record, element, range, event) {
@@ -217,7 +221,7 @@ function adoptElement(record, element, range, event) {
     return void 0;
   }
   if (range?.status === "pending") {
-    record.waitingRanges.add(range);
+    record.waiting.add(range);
     return void 0;
   }
   const existing = record.adoptions.get(element);
@@ -251,7 +255,7 @@ function adoptElement(record, element, range, event) {
   }
   if (typeof result === "object" && result !== null && typeof result.then === "function") {
     adoption.pending = true;
-    record.pendingAdoptionCount++;
+    record.pendingCount++;
     const settled = Promise.resolve(result).then(
       (cleanup) => {
         finishPendingAdoption(adoption);
@@ -271,24 +275,26 @@ function adoptElement(record, element, range, event) {
         failBehavior(record, error);
       }
     );
-    const cancelable = waitUntilReady(settled, adoption.controller.signal).then(() => void 0);
+    const cancelable = waitUntilReady(settled, adoption.controller.signal);
     trackPending(record.root, cancelable);
   }
   return adoption;
 }
 function reconcileBehavior(record) {
   if (record.status !== "active") return;
-  record.waitingRanges.clear();
+  record.waiting.clear();
   for (const [element, adoption] of [...record.adoptions]) {
-    const range = contains(record.root, element) ? nearestRange(record.root, element) : void 0;
-    if (!contains(record.root, element) || !matchesTarget(record, element) || !rangeMatches(record, range) || range !== adoption.range || range?.status === "pending") {
+    const contained = contains(record.root, element);
+    const range = contained ? nearestRange(record.root, element) : void 0;
+    if (!contained || !matchesTarget(record, element) || !rangeMatches(record, range) || range !== adoption.range || range?.status === "pending") {
       disposeAdoption(adoption);
     }
   }
   let elements;
   if (typeof record.entry.target === "string") {
-    elements = Array.from(record.root.container.querySelectorAll(record.entry.target));
-    if (record.root.container.matches(record.entry.target)) elements.unshift(record.root.container);
+    elements = Array.from(record.root.dom.query(record.root.container, record.entry.target));
+    if (record.root.dom.matches(record.root.container, record.entry.target))
+      elements.unshift(record.root.container);
   } else {
     elements = contains(record.root, record.entry.target) ? [record.entry.target] : [];
   }
@@ -296,15 +302,16 @@ function reconcileBehavior(record) {
     const range = nearestRange(record.root, element);
     if (!rangeMatches(record, range)) continue;
     if (range?.status === "pending") {
-      record.waitingRanges.add(range);
+      record.waiting.add(range);
       continue;
     }
     adoptElement(record, element, range);
   }
-  record.initialScanComplete = true;
+  record.scanned = true;
   completeBehavior(record);
 }
 function refreshDocument(registry) {
+  registry.capture?.flush();
   for (const root of [...registry.roots.values()]) {
     if (root.disposed) continue;
     for (const record of [...root.behaviors]) reconcileBehavior(record);
@@ -327,7 +334,8 @@ function targetElement(event) {
 }
 function handleDelegatedEvent(root, event) {
   if (root.disposed) return;
-  const target = targetElement(event);
+  if (root.registry.capture?.skip(root, event)) return;
+  const target = root.dom.target(event);
   if (target === null || !contains(root, target)) return;
   for (const record of [...root.behaviors]) {
     if (record.status === "disposed" || record.status === "failed" || !record.entry.events?.includes(event.type)) {
@@ -339,15 +347,15 @@ function handleDelegatedEvent(root, event) {
         matched = null;
         break;
       }
-      matched = matched.parentElement;
+      matched = root.dom.parent(matched);
     }
     if (matched === null || !contains(root, matched)) continue;
     const range = nearestRange(root, matched);
     if (!rangeMatches(record, range)) continue;
     if (record.entry.captureEvent !== void 0) {
       const queued = { event, element: matched, range, payload: CANCELED };
-      record.queuedEvents.push(queued);
-      if (range?.status === "pending") record.waitingRanges.add(range);
+      record.queue.push(queued);
+      if (range?.status === "pending") record.waiting.add(range);
       record.captureDepth = (record.captureDepth ?? 0) + 1;
       try {
         const payload = record.entry.captureEvent(event, matched);
@@ -363,13 +371,13 @@ function handleDelegatedEvent(root, event) {
       continue;
     }
     if (record.status !== "active" || range?.status === "pending") {
-      record.queuedEvents.push({ event, element: matched, range });
-      if (range?.status === "pending") record.waitingRanges.add(range);
+      record.queue.push({ event, element: matched, range });
+      if (range?.status === "pending") record.waiting.add(range);
       continue;
     }
     const adoption = record.adoptions.get(matched) ?? adoptElement(record, matched, range, event);
-    if (adoption === void 0 || adoption.pending || record.queuedEvents.length !== 0) {
-      record.queuedEvents.push({ event, element: matched, range });
+    if (adoption === void 0 || adoption.pending || record.queue.length !== 0) {
+      record.queue.push({ event, element: matched, range });
       flushQueuedEvents(record);
       continue;
     }
@@ -408,18 +416,19 @@ function removeUnusedListeners(root) {
 }
 function disposeBehavior(record) {
   if (record.status === "disposed") return;
+  record.root.registry.capture?.release(record);
   const failed = record.status === "failed";
   record.status = "disposed";
   record.controller.abort();
   for (const unlink of record.unlinks) unlink();
   record.unlinks.length = 0;
   record.root.behaviors.delete(record);
-  if (record.entry.id !== void 0 && record.root.behaviorsById.get(record.entry.id) === record) {
-    record.root.behaviorsById.delete(record.entry.id);
+  if (record.entry.id !== void 0 && record.root.byId.get(record.entry.id) === record) {
+    record.root.byId.delete(record.entry.id);
   }
-  record.queuedEvents.length = 0;
-  record.queuedEventHead = 0;
-  record.waitingRanges.clear();
+  record.queue.length = 0;
+  record.head = 0;
+  record.waiting.clear();
   let firstError;
   for (const adoption of [...record.adoptions.values()]) {
     try {
@@ -428,7 +437,7 @@ function disposeBehavior(record) {
       firstError ??= error;
     }
   }
-  if (!failed) record.readiness.resolve();
+  if (!failed) record.ready.resolve();
   removeUnusedListeners(record.root);
   if (firstError !== void 0) throw firstError;
 }
@@ -445,14 +454,14 @@ function registerBehavior(root, entry) {
   if (typeof entry.target !== "string") {
     assertContainedElement(root, entry.target, "A behavior target");
   } else {
-    root.container.matches(entry.target);
+    root.dom.matches(root.container, entry.target);
   }
-  if (entry.id !== void 0 && root.behaviorsById.has(entry.id)) {
+  if (entry.id !== void 0 && root.byId.has(entry.id)) {
     throw new Error(`A behavior with identity ${JSON.stringify(entry.id)} is already registered.`);
   }
   const dependencies = [];
   for (const id of entry.dependencies ?? []) {
-    const dependency = root.behaviorsById.get(id);
+    const dependency = root.byId.get(id);
     if (dependency === void 0) {
       throw new Error(`Behavior dependency ${JSON.stringify(id)} is not registered.`);
     }
@@ -469,16 +478,16 @@ function registerBehavior(root, entry) {
     root,
     entry,
     controller,
-    readiness,
+    ready: readiness,
     status: "pending",
     adoptions: /* @__PURE__ */ new Map(),
-    pendingAdoptionCount: 0,
-    waitingRanges: /* @__PURE__ */ new Set(),
-    queuedEvents: [],
-    queuedEventHead: 0,
-    queuedEventFlushDepth: 0,
+    pendingCount: 0,
+    waiting: /* @__PURE__ */ new Set(),
+    queue: [],
+    head: 0,
+    flushDepth: 0,
     unlinks: [linkSignal(root.controller.signal, controller)],
-    initialScanComplete: false
+    scanned: false
   };
   const registration = {
     ...entry.id === void 0 ? {} : { id: entry.id },
@@ -492,11 +501,12 @@ function registerBehavior(root, entry) {
     return registration;
   }
   root.behaviors.add(record);
-  if (entry.id !== void 0) root.behaviorsById.set(entry.id, record);
+  if (entry.id !== void 0) root.byId.set(entry.id, record);
   controller.signal.addEventListener("abort", () => disposeBehavior(record), { once: true });
   try {
     installListeners(root, entry.events);
     ensureObserver(root);
+    root.registry.capture?.flush();
   } catch (error) {
     disposeBehavior(record);
     throw error;
@@ -504,7 +514,7 @@ function registerBehavior(root, entry) {
   const blockers = [];
   if (entry.ready !== void 0) blockers.push(entry.ready);
   for (const dependency of dependencies) {
-    if (!dependency.readiness.settled) blockers.push(dependency.readiness.promise);
+    if (!dependency.ready.settled) blockers.push(dependency.ready.promise);
   }
   if (blockers.length === 0) {
     activateBehavior(record);
@@ -512,10 +522,7 @@ function registerBehavior(root, entry) {
     const gate = Promise.all(
       blockers.map((blocker) => waitUntilReady(blocker, controller.signal))
     ).then(
-      (results) => {
-        if (results.includes(CANCELED) || controller.signal.aborted) return;
-        activateBehavior(record);
-      },
+      () => activateBehavior(record),
       (error) => {
         if (!controller.signal.aborted) failBehavior(record, error);
       }
@@ -535,7 +542,7 @@ function disposeRange(record) {
   if (record.root.registry.ranges.get(record.element) === record) {
     record.root.registry.ranges.delete(record.element);
   }
-  if (!failed) record.readiness.resolve();
+  if (!failed) record.ready.resolve();
   if (!record.root.disposed) refreshDocument(record.root.registry);
 }
 function registerExternalRange(root, element, options) {
@@ -561,7 +568,7 @@ function registerExternalRange(root, element, options) {
     element,
     owner: options.owner,
     controller,
-    readiness,
+    ready: readiness,
     status: options.ready === void 0 ? "ready" : "pending",
     unlinks: [linkSignal(root.controller.signal, controller)],
     publicRange: void 0
@@ -587,8 +594,8 @@ function registerExternalRange(root, element, options) {
     readiness.resolve();
   } else {
     const gate = waitUntilReady(options.ready, controller.signal).then(
-      (result) => {
-        if (result === CANCELED || record.status !== "pending") return;
+      () => {
+        if (record.status !== "pending") return;
         record.status = "ready";
         refreshDocument(root.registry);
         readiness.resolve();
@@ -621,6 +628,7 @@ function registerExternalRange(root, element, options) {
 }
 function disposeRoot(root, options = {}) {
   if (root.disposed) return;
+  root.registry.capture?.dispose(root);
   const releasedExternalOwnership = root.ranges.size !== 0;
   root.disposed = true;
   root.controller.abort();
@@ -664,40 +672,33 @@ function disposeRoot(root, options = {}) {
   if (firstError !== void 0) throw firstError;
 }
 function attachBehaviorRoot(container, options = {}) {
-  if (!isElement(container) || container.ownerDocument === null) {
+  const capture = options.formSubmissions;
+  const document = capture === void 0 ? isElement(container) ? container.ownerDocument : null : capture.document(container);
+  if (document === null) {
     throw new Error("A behavior root requires an element with an owner document.");
   }
-  const document = container.ownerDocument;
-  let registry = documentRegistries.get(document);
-  if (registry === void 0) {
-    registry = { roots: /* @__PURE__ */ new Map(), ranges: /* @__PURE__ */ new Map() };
-    documentRegistries.set(document, registry);
-  }
+  let registry = registryFor(document);
   const existing = registry.roots.get(container);
-  const canceledReplacement = existing !== void 0 && options.replace && options.signal?.aborted;
   if (existing !== void 0) {
     if (!options.replace) {
       throw new Error(
         "This container already has a behavior root; pass replace: true to replace it."
       );
     }
-    if (!canceledReplacement) {
+    if (!options.signal?.aborted) {
       disposeRoot(existing);
-      registry = documentRegistries.get(document);
-      if (registry === void 0) {
-        registry = { roots: /* @__PURE__ */ new Map(), ranges: /* @__PURE__ */ new Map() };
-        documentRegistries.set(document, registry);
-      }
+      registry = registryFor(document);
     }
   }
   const controller = createController(document);
   const record = {
     container,
     document,
+    dom: DEFAULT_DOM,
     registry,
     controller,
     behaviors: /* @__PURE__ */ new Set(),
-    behaviorsById: /* @__PURE__ */ new Map(),
+    byId: /* @__PURE__ */ new Map(),
     ranges: /* @__PURE__ */ new Set(),
     pending: /* @__PURE__ */ new Set(),
     listeners: /* @__PURE__ */ new Map(),
@@ -710,8 +711,8 @@ function attachBehaviorRoot(container, options = {}) {
     signal: controller.signal,
     get ready() {
       const waiting = [...record.pending];
-      for (const range of record.ranges) waiting.push(range.readiness.promise);
-      for (const behavior of record.behaviors) waiting.push(behavior.readiness.promise);
+      for (const range of record.ranges) waiting.push(range.ready.promise);
+      for (const behavior of record.behaviors) waiting.push(behavior.ready.promise);
       const ready = Promise.all(waiting).then(() => void 0);
       void ready.catch(() => void 0);
       return ready;
@@ -720,18 +721,26 @@ function attachBehaviorRoot(container, options = {}) {
     registerBehavior: (entry) => registerBehavior(record, entry),
     dispose: (disposeOptions) => disposeRoot(record, disposeOptions)
   };
-  if (!canceledReplacement) registry.roots.set(container, record);
   if (options.signal !== void 0) record.unlinkSignal = linkSignal(options.signal, controller);
   if (controller.signal.aborted) {
     disposeRoot(record);
   } else {
+    registry.roots.set(container, record);
+    try {
+      capture?.(record, flushQueuedEvents, failBehavior, nearestRange, rangeMatches, CANCELED);
+    } catch (error) {
+      disposeRoot(record);
+      throw error;
+    }
     controller.signal.addEventListener("abort", () => disposeRoot(record), { once: true });
+    if (controller.signal.aborted) disposeRoot(record);
   }
   return root;
 }
 export {
   adoptBindings,
   attachBehaviorRoot,
+  captureFormSubmissions,
   mountBindings,
   unbound
 };