octane 0.2.12 → 0.2.13

package/dist/signals/control-binding.js

@@ -0,0 +1,353 @@
+import {
+  consumeHydrationControl,
+  initializeHydrationControlCapture,
+  snapshotHydrationControl
+} from "../hydration/control-capture.js";
+import {
+  hasHydrationControlSignalWriter,
+  registerHydrationControlSignalWriter
+} from "./early-values.js";
+import { isSignalHandle, isWritableSignal } from "./handle-protocol.js";
+import { captureSignalOwner, currentSignalOwner } from "./owner-context.js";
+import {
+  forwardNativeTransitionConsumer,
+  NATIVE_TRANSITION_CONSUMER
+} from "./read-protocol.js";
+import { SIGNAL_BINDING_READ, SIGNAL_BINDING_SUBSCRIBE } from "./types.js";
+import { withoutSignalCandidate } from "./transition-state.js";
+const CONTROL_BINDINGS = /* @__PURE__ */ new WeakMap();
+const RADIO_WRITERS = /* @__PURE__ */ new WeakMap();
+function controlString(value) {
+  return typeof value === "string" ? value : typeof value === "function" || typeof value === "symbol" ? "" : String(value);
+}
+function publishRadioInput(input) {
+  const root = input.getRootNode();
+  const group = input.form !== null ? input.form.elements : root.nodeType === 9 ? root.getElementsByName(input.name) : root.querySelectorAll('input[type="radio"]');
+  const edits = [];
+  for (let index = 0; index < group.length; index++) {
+    const other = group[index];
+    if (other.localName !== "input" || other.type !== "radio" || other.name !== input.name || other.form !== input.form || other.getRootNode() !== root)
+      continue;
+    const write = RADIO_WRITERS.get(other);
+    if (write) edits.push([write, other.checked]);
+  }
+  for (const [write, checked] of edits) if (!checked) write(false);
+  for (const [write, checked] of edits) if (checked) write(true);
+}
+function __createBindingControls() {
+  const owner = currentSignalOwner();
+  const run = owner === null ? (callback) => callback() : captureSignalOwner(owner);
+  return {
+    claim(element, channel, notify) {
+      const control = element;
+      if (control?.nodeType !== 1 || channel !== "value" && channel !== "checked" || !["input", "textarea", "select"].includes(control.localName) || channel === "checked" && (control.localName !== "input" || !["checkbox", "radio"].includes(control.type)) || channel === "value" && control.localName === "input" && control.type === "file")
+        throw new TypeError(
+          "A signal control requires a native value/checked property and a signal."
+        );
+      if (CONTROL_BINDINGS.get(control)?.has(channel) || hasHydrationControlSignalWriter(control, channel))
+        throw new Error(
+          "This control property already has a signal binding. Dispose it before rebinding."
+        );
+      let channels = CONTROL_BINDINGS.get(control);
+      if (!channels) CONTROL_BINDINGS.set(control, channels = /* @__PURE__ */ new Set());
+      channels.add(channel);
+      let disposed = false;
+      let initialized = false;
+      let composing = false;
+      let raw;
+      let handle;
+      let active;
+      let unsubscribe;
+      let stopWriter;
+      let generation = 0;
+      let revision = 0;
+      const read = (value) => run(() => value[SIGNAL_BINDING_READ]());
+      const write = (value) => {
+        if (disposed || !isWritableSignal(active)) return;
+        const writable = active;
+        withoutSignalCandidate(
+          () => run(() => {
+            const previous = read(writable);
+            if (Object.is(previous, value) || Array.isArray(previous) && Array.isArray(value) && previous.length === value.length && previous.every((item, index) => item === value[index]))
+              return;
+            writable.set(value);
+          })
+        );
+      };
+      const nativeValue = () => {
+        const snapshot = snapshotHydrationControl(control);
+        return channel === "checked" ? snapshot.checked : snapshot.selectedValues ?? snapshot.value;
+      };
+      const input = () => {
+        if (disposed) return;
+        if (channel === "checked" && control.type === "radio" && control.name !== "")
+          publishRadioInput(control);
+        else write(nativeValue());
+      };
+      const compositionStart = () => {
+        composing = true;
+      };
+      const compositionEnd = () => {
+        if (disposed) return;
+        composing = false;
+        input();
+        if (!disposed) notify();
+      };
+      const dispose = () => {
+        if (disposed) return;
+        disposed = true;
+        generation++;
+        raw = void 0;
+        active = handle = void 0;
+        if (channel === "checked") RADIO_WRITERS.delete(control);
+        let failed = false;
+        let failure;
+        const attempt = (stop2) => {
+          try {
+            stop2?.();
+          } catch (error) {
+            if (!failed) {
+              failed = true;
+              failure = error;
+            }
+          }
+        };
+        const stop = unsubscribe;
+        unsubscribe = void 0;
+        attempt(stop);
+        attempt(stopWriter);
+        stopWriter = void 0;
+        control.removeEventListener("input", input);
+        control.removeEventListener("compositionstart", compositionStart);
+        control.removeEventListener("compositionend", compositionEnd);
+        channels.delete(channel);
+        if (channels.size === 0) CONTROL_BINDINGS.delete(control);
+        if (failed) throw failure;
+      };
+      const prepare = (next, preview = false) => {
+        if (disposed) return { validate: () => false, discard() {
+        }, publish() {
+        }, commit() {
+        } };
+        if (isSignalHandle(next) && (typeof next[SIGNAL_BINDING_READ] !== "function" || typeof next[SIGNAL_BINDING_SUBSCRIBE] !== "function"))
+          throw new TypeError(
+            "A signal control requires a native value/checked property and a signal."
+          );
+        if (!preview && raw !== next) {
+          const ticket2 = ++generation;
+          const stop = unsubscribe;
+          unsubscribe = void 0;
+          handle = void 0;
+          stop?.();
+          if (disposed) return { validate: () => false, discard() {
+          }, publish() {
+          }, commit() {
+          } };
+          raw = next;
+          handle = isSignalHandle(next) ? next : void 0;
+          if (handle) {
+            const candidate2 = handle;
+            const stopNext = run(
+              () => candidate2[SIGNAL_BINDING_SUBSCRIBE](
+                forwardNativeTransitionConsumer(notify, () => {
+                  if (!disposed && generation === ticket2) {
+                    revision++;
+                    notify();
+                  }
+                }),
+                () => {
+                  if (!disposed && generation === ticket2) dispose();
+                }
+              )
+            );
+            if (typeof stopNext !== "function")
+              throw new TypeError("A signal control subscription must return cleanup.");
+            if (disposed || generation !== ticket2) stopNext();
+            else unsubscribe = stopNext;
+          }
+        }
+        if (disposed) return { validate: () => false, discard() {
+        }, publish() {
+        }, commit() {
+        } };
+        const candidate = preview ? isSignalHandle(next) ? next : void 0 : handle;
+        const value = candidate ? read(candidate) : next;
+        if (disposed) return { validate: () => false, discard() {
+        }, publish() {
+        }, commit() {
+        } };
+        const multiple = control.localName === "select" && control.multiple;
+        if (candidate && (channel === "checked" ? typeof value !== "boolean" : multiple ? !Array.isArray(value) : typeof value !== "string"))
+          throw new TypeError(
+            channel === "checked" ? "A checked signal must contain a boolean." : multiple ? "A multiple select signal must contain an array." : "A value signal must contain a string."
+          );
+        let selected;
+        if (multiple && Array.isArray(value)) {
+          selected = /* @__PURE__ */ new Set();
+          for (const item of value) selected.add(candidate ? item : controlString(item));
+        }
+        const normalized = channel === "checked" ? !!value : value == null || multiple ? "" : controlString(value);
+        let ticket = generation;
+        const version = revision;
+        let accepted = !preview;
+        let retired = false;
+        let invalid = false;
+        let staged = preview && candidate && candidate !== handle ? run(
+          () => candidate[SIGNAL_BINDING_SUBSCRIBE](
+            forwardNativeTransitionConsumer(notify, () => {
+              if (retired || disposed) return;
+              if (!accepted) invalid = true;
+              else if (generation === ticket) {
+                revision++;
+                notify();
+              }
+            }),
+            () => {
+              if (!accepted) invalid = true;
+              else if (!disposed && generation === ticket) dispose();
+            }
+          )
+        ) : void 0;
+        const prepared = {
+          publish() {
+            if (retired || disposed || ticket !== generation) return;
+            if (!accepted) {
+              accepted = true;
+              if (raw !== next) {
+                const stop = unsubscribe;
+                ticket = ++generation;
+                raw = next;
+                handle = candidate;
+                unsubscribe = staged;
+                staged = void 0;
+                stop?.();
+              }
+            }
+            active = candidate;
+            if (isWritableSignal(active)) {
+              stopWriter ??= registerHydrationControlSignalWriter(
+                control,
+                channel,
+                channel === "checked" && control.type === "radio" ? input : write
+              );
+              if (channel === "checked" && control.type === "radio")
+                RADIO_WRITERS.set(control, write);
+            } else {
+              stopWriter?.();
+              stopWriter = void 0;
+              if (channel === "checked") RADIO_WRITERS.delete(control);
+            }
+            if (initialized) return;
+            initializeHydrationControlCapture(control.ownerDocument);
+            control.addEventListener("input", input);
+            control.addEventListener("compositionstart", compositionStart);
+            control.addEventListener("compositionend", compositionEnd);
+            initialized = true;
+            if (!isWritableSignal(active)) return;
+            let snapshot;
+            do {
+              snapshot = snapshotHydrationControl(control);
+              if (snapshot.editRevision > 0 && isWritableSignal(active)) write(nativeValue());
+              if (disposed) return;
+            } while (!consumeHydrationControl(control, snapshot.revision));
+          },
+          commit() {
+            if (retired || disposed || value == null || multiple && selected === void 0 || ticket !== generation || version !== revision || active !== candidate || composing || snapshotHydrationControl(control).composing)
+              return;
+            if (channel === "checked") {
+              if (control.checked !== normalized)
+                control.checked = normalized;
+            } else if (selected) {
+              for (const option of control.options) {
+                if (disposed) return;
+                const next2 = selected.has(option.value);
+                if (option.selected !== next2) option.selected = next2;
+              }
+            } else if (!candidate && control.localName === "input" && control.type === "number" ? (
+              // Preserve a user's "1.0" for sampled numeric 1, but show zero over an empty edit.
+              value === 0 && control.value === "" || control.value != value
+            ) : control.value !== normalized)
+              control.value = normalized;
+          }
+        };
+        return preview ? Object.assign(prepared, {
+          validate: () => !retired && !invalid && !disposed && ticket === generation && version === revision,
+          discard() {
+            if (accepted || retired) return;
+            retired = true;
+            staged?.();
+            staged = void 0;
+          }
+        }) : prepared;
+      };
+      return {
+        prepare,
+        preview: (value) => prepare(value, true),
+        prepareCurrent: () => prepare(raw),
+        dispose
+      };
+    }
+  };
+}
+function bindSignalControl(control, channel, handle$) {
+  if (!isSignalHandle(handle$))
+    throw new TypeError("A signal control requires a native value/checked property and a signal.");
+  let busy = false;
+  let dirty = false;
+  let disposed = false;
+  let lease;
+  const dispose = () => {
+    disposed = true;
+    lease.dispose();
+  };
+  const refresh = () => {
+    if (disposed) return;
+    dirty = true;
+    if (busy) return;
+    busy = true;
+    try {
+      while (dirty && !disposed) {
+        dirty = false;
+        const prepared = lease.prepare(handle$);
+        prepared.publish();
+        if (!dirty && !disposed) prepared.commit();
+      }
+    } catch (error) {
+      try {
+        dispose();
+      } catch {
+      }
+      throw error;
+    } finally {
+      busy = false;
+    }
+  };
+  refresh[NATIVE_TRANSITION_CONSUMER] = {
+    active: () => !disposed,
+    prepare: () => {
+      const prepared = lease.preview(handle$);
+      return {
+        validate: () => !disposed && !busy && prepared.validate(),
+        discard: prepared.discard,
+        commit() {
+          if (!disposed) {
+            busy = true;
+            try {
+              prepared.publish();
+              prepared.commit();
+            } finally {
+              busy = false;
+            }
+          }
+        }
+      };
+    }
+  };
+  lease = __createBindingControls().claim(control, channel, refresh);
+  refresh();
+  return dispose;
+}
+export {
+  __createBindingControls,
+  bindSignalControl
+};

package/dist/signals/derived-facade.d.ts

@@ -0,0 +1,3 @@
+import type { DerivedCompute, DerivedOptions, DerivedSignal, SignalOptions } from './types.js';
+export declare function __derivedAt<T>(site: string | undefined, compute: DerivedCompute<T>, options?: DerivedOptions & SignalOptions): DerivedSignal<T>;
+export declare function derived$<T>(compute: DerivedCompute<T>, options?: DerivedOptions & SignalOptions): DerivedSignal<T>;

package/dist/signals/derived-facade.js

@@ -0,0 +1,25 @@
+import { createDeclaredDerivedCell } from "./computations.js";
+import { DerivedDescriptor, descriptorKey, signalOptionsKey } from "./facade.js";
+import { runWithSignalOwner } from "./owner-context.js";
+function __derivedAt(site, compute, options) {
+  if (typeof compute !== "function") throw new TypeError("derived$ requires a function.");
+  const explicit = signalOptionsKey(options);
+  site ??= explicit;
+  const key = descriptorKey(site, explicit);
+  return new DerivedDescriptor(
+    key,
+    "derived",
+    (owner) => {
+      const wrapped = compute.length ? (context) => runWithSignalOwner(owner, () => compute(context)) : () => runWithSignalOwner(owner, () => compute());
+      return createDeclaredDerivedCell(owner, key, wrapped, options);
+    },
+    site
+  );
+}
+function derived$(compute, options) {
+  return __derivedAt(void 0, compute, options);
+}
+export {
+  __derivedAt,
+  derived$
+};

package/dist/signals/document-owner.d.ts

@@ -0,0 +1,10 @@
+import type { SignalOwner, SignalOwnerIdentity } from './types.js';
+/** @internal Actual document capability, shared with an optional renderer. */
+export declare let signalDocumentEnabled: boolean;
+export declare let streamedSignalOwnerActivator: ((owner: SignalOwner) => void) | undefined;
+/** @internal Shared document identity for state-only and component consumers. */
+export declare function documentSignalOwner(container: Node): SignalOwnerIdentity;
+/** @internal Compiler capability for global signals without a rendering engine. */
+export declare function enableSignalDocument(abi?: number): void;
+/** @internal Instance activation is optional; global results need no component root. */
+export declare function installStreamedSignalOwnerActivator(activate: (owner: SignalOwner) => void): () => void;

package/dist/signals/document-owner.js

@@ -0,0 +1,43 @@
+import { formatClientError } from "../error-codes.client.generated.js";
+import { registerSignalOwnerDocument } from "./early-values.js";
+import { installDefaultSignalOwner } from "./owner-context.js";
+const documentOwners = /* @__PURE__ */ new WeakMap();
+let defaultInstalled = false;
+let signalDocumentEnabled = false;
+let streamedSignalOwnerActivator;
+function documentSignalOwner(container) {
+  const ownerDocument = container.nodeType === 9 ? container : container.ownerDocument;
+  if (ownerDocument === null) throw new TypeError("A signal document owner requires a document.");
+  let owner = documentOwners.get(ownerDocument);
+  if (owner === void 0) {
+    owner = Object.freeze({ scopeKey: "octane:document" });
+    documentOwners.set(ownerDocument, owner);
+  }
+  registerSignalOwnerDocument(owner, ownerDocument);
+  return owner;
+}
+function enableSignalDocument(abi = 1) {
+  if (abi !== 1) throw new TypeError(formatClientError(74));
+  signalDocumentEnabled = true;
+  if (defaultInstalled) return;
+  defaultInstalled = true;
+  installDefaultSignalOwner(
+    () => typeof document === "undefined" ? null : documentSignalOwner(document)
+  );
+}
+function installStreamedSignalOwnerActivator(activate) {
+  if (streamedSignalOwnerActivator !== void 0) {
+    throw new Error("A streamed signal hydration owner is already installed.");
+  }
+  streamedSignalOwnerActivator = activate;
+  return () => {
+    if (streamedSignalOwnerActivator === activate) streamedSignalOwnerActivator = void 0;
+  };
+}
+export {
+  documentSignalOwner,
+  enableSignalDocument,
+  installStreamedSignalOwnerActivator,
+  signalDocumentEnabled,
+  streamedSignalOwnerActivator
+};

package/dist/signals/early-values.d.ts

@@ -0,0 +1,24 @@
+import type { SignalBindingIdentity, SignalOwner } from './types.js';
+type ControlChannel = 'value' | 'checked';
+type EarlyValue = {
+    revision: number;
+    value: unknown;
+};
+type ControlWriter = (value: unknown) => void;
+/** @internal Associate an engine-free signal owner with its browser document. */
+export declare function registerSignalOwnerDocument(owner: SignalOwner, ownerDocument: Document): void;
+/** @internal Read the last pre-activation edit before creating a writable cell. */
+export declare function readEarlySignalValue(owner: SignalOwner, binding: SignalBindingIdentity): EarlyValue | undefined;
+/** @internal Publish a native edit into both the pre-module buffer and any live binding. */
+export declare function publishHydrationControlSignalValues(control: Element, revision: number): void;
+/** @internal Let candidate application update the already-live writable cell directly. */
+export declare function registerHydrationControlSignalWriter(control: Element, channel: ControlChannel, write: ControlWriter): () => void;
+/** @internal A writable binding already provides this control's native input handler. */
+export declare function hasHydrationControlSignalWriter(control: Element, channel: ControlChannel): boolean;
+/** @internal Carry edit authority across module handoff, even after editing back to SSR. */
+export declare function readEarlyHydrationControlRevision(control: Element): number;
+/** @internal Retire the imported revision only after exact control-state adoption. */
+export declare function clearEarlyHydrationControlRevision(control: Element): void;
+/** @internal Module capture replaces the inline writer for this document. */
+export declare function claimEarlyHydrationControlCapture(ownerDocument: Document): void;
+export {};

package/dist/signals/early-values.js

@@ -0,0 +1,124 @@
+import { SIGNAL_CONTROL_ATTR } from "../hydration-markers.js";
+const OWNER_DOCUMENTS = /* @__PURE__ */ new WeakMap();
+const DOCUMENT_VALUES = /* @__PURE__ */ new WeakMap();
+const CONTROL_WRITERS = /* @__PURE__ */ new WeakMap();
+const EARLY_CONTROL_REVISIONS = /* @__PURE__ */ new WeakMap();
+const CLAIMED_CONTROL_DOCUMENTS = /* @__PURE__ */ new WeakSet();
+function rendererOwner(owner) {
+  return typeof owner === "object" && owner !== null && "documentOwner" in owner;
+}
+function ownerObject(owner) {
+  return rendererOwner(owner) ? owner.instanceOwner : owner;
+}
+function valueKey(ownerKey, instanceKey, nodeKey) {
+  return JSON.stringify([ownerKey, instanceKey, nodeKey]);
+}
+function registerSignalOwnerDocument(owner, ownerDocument) {
+  OWNER_DOCUMENTS.set(ownerObject(owner), ownerDocument);
+  if (rendererOwner(owner)) OWNER_DOCUMENTS.set(owner.documentOwner, ownerDocument);
+}
+function documentForOwner(owner) {
+  return OWNER_DOCUMENTS.get(ownerObject(owner));
+}
+function bindingKey(owner, binding) {
+  const ownerKey = rendererOwner(owner) ? owner.documentOwner.scopeKey : owner.scopeKey;
+  const instanceKey = binding.scope === "instance" && rendererOwner(owner) ? owner.instanceKey : "";
+  return valueKey(ownerKey, instanceKey, binding.nodeKey);
+}
+function readEarlySignalValue(owner, binding) {
+  const ownerDocument = documentForOwner(owner);
+  return ownerDocument === void 0 ? void 0 : DOCUMENT_VALUES.get(ownerDocument)?.get(bindingKey(owner, binding));
+}
+function parseControlBindings(control) {
+  const raw = control.getAttribute(SIGNAL_CONTROL_ATTR);
+  if (raw === null) return null;
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed) || parsed.length !== 3 || parsed[0] !== 1) return null;
+    if (typeof parsed[1] !== "string" || !Array.isArray(parsed[2])) return null;
+    const bindings = [];
+    for (const entry of parsed[2]) {
+      if (!Array.isArray(entry) || entry.length !== 3 || typeof entry[0] !== "string" || typeof entry[1] !== "string" || entry[2] !== "value" && entry[2] !== "checked") {
+        return null;
+      }
+      bindings.push(entry);
+    }
+    return { ownerKey: parsed[1], bindings };
+  } catch {
+    return null;
+  }
+}
+function controlValue(control, channel) {
+  if (channel === "checked") return control.checked;
+  if (control.localName === "select" && control.multiple) {
+    return Array.from(control.selectedOptions, (option) => option.value);
+  }
+  return control.value;
+}
+function publishHydrationControlSignalValues(control, revision) {
+  const metadata = parseControlBindings(control);
+  if (metadata !== null) {
+    let values = DOCUMENT_VALUES.get(control.ownerDocument);
+    if (values === void 0) DOCUMENT_VALUES.set(control.ownerDocument, values = /* @__PURE__ */ new Map());
+    for (const [instanceKey, nodeKey, channel] of metadata.bindings) {
+      const key = valueKey(metadata.ownerKey, instanceKey, nodeKey);
+      const previous = values.get(key);
+      if (CLAIMED_CONTROL_DOCUMENTS.has(control.ownerDocument) || previous === void 0 || revision >= previous.revision) {
+        values.set(key, { revision, value: controlValue(control, channel) });
+      }
+    }
+  }
+  const writers = CONTROL_WRITERS.get(control);
+  if (writers !== void 0) {
+    for (const [channel, write] of writers) write(controlValue(control, channel));
+  }
+}
+function registerHydrationControlSignalWriter(control, channel, write) {
+  let writers = CONTROL_WRITERS.get(control);
+  if (writers === void 0) CONTROL_WRITERS.set(control, writers = /* @__PURE__ */ new Map());
+  writers.set(channel, write);
+  return () => {
+    if (writers.get(channel) !== write) return;
+    writers.delete(channel);
+    if (writers.size === 0) CONTROL_WRITERS.delete(control);
+  };
+}
+function hasHydrationControlSignalWriter(control, channel) {
+  return CONTROL_WRITERS.get(control)?.has(channel) ?? false;
+}
+function readEarlyHydrationControlRevision(control) {
+  return EARLY_CONTROL_REVISIONS.get(control) ?? 0;
+}
+function clearEarlyHydrationControlRevision(control) {
+  EARLY_CONTROL_REVISIONS.delete(control);
+}
+function claimEarlyHydrationControlCapture(ownerDocument) {
+  CLAIMED_CONTROL_DOCUMENTS.add(ownerDocument);
+}
+function publishEarlyHydrationControlSignalValues(control, revision) {
+  if (CLAIMED_CONTROL_DOCUMENTS.has(control.ownerDocument)) return;
+  EARLY_CONTROL_REVISIONS.set(control, revision);
+  publishHydrationControlSignalValues(control, revision);
+}
+if (typeof globalThis !== "undefined") {
+  const host = globalThis;
+  host.__octanePublishSignalControl = publishEarlyHydrationControlSignalValues;
+  const mailbox = host.__octaneEarlySignalControls;
+  if (mailbox !== void 0) {
+    mailbox.p = publishEarlyHydrationControlSignalValues;
+    const queued = mailbox.q.splice(0);
+    for (const [control, revision] of queued) {
+      publishEarlyHydrationControlSignalValues(control, revision);
+    }
+  }
+}
+export {
+  claimEarlyHydrationControlCapture,
+  clearEarlyHydrationControlRevision,
+  hasHydrationControlSignalWriter,
+  publishHydrationControlSignalValues,
+  readEarlyHydrationControlRevision,
+  readEarlySignalValue,
+  registerHydrationControlSignalWriter,
+  registerSignalOwnerDocument
+};

package/dist/signals/encoding.d.ts

@@ -1,3 +1 @@
-import type { EncodedSignalValue } from './types.js';
-export declare function encodeSignalValue(value: unknown, ancestors?: Set<object>): EncodedSignalValue;
-export declare function decodeSignalValue(encoded: EncodedSignalValue): unknown;
+export { decodeSignalValue, encodeSignalValue, snapshotSignalValue } from '../data-encoding.js';