octane 0.2.11 → 0.2.13

package/dist/cjs/dom-binding-protocol.cjs

@@ -0,0 +1,115 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dom_binding_protocol_exports = {};
+__export(dom_binding_protocol_exports, {
+  decodeBindingKey: () => decodeBindingKey,
+  encodeBindingKey: () => encodeBindingKey,
+  isBindingOpenComment: () => isBindingOpenComment,
+  parseBindingMarker: () => parseBindingMarker
+});
+module.exports = __toCommonJS(dom_binding_protocol_exports);
+function encodeBindingKey(key) {
+  if (typeof key === "string")
+    return "s:" + JSON.stringify(key).replace(/-/g, "\\u002d").replace(/</g, "\\u003c");
+  if (typeof key === "number" && Number.isFinite(key)) return "n:" + String(key);
+  throw new TypeError("A DOM presentation key must be a string or finite number.");
+}
+function decodeBindingKey(encoded) {
+  let key;
+  try {
+    key = JSON.parse(encoded.slice(2));
+  } catch {
+    throw new TypeError("A DOM presentation key has invalid serialized identity.");
+  }
+  if (encoded.startsWith("s:") && typeof key === "string" || encoded.startsWith("n:") && typeof key === "number" && Number.isFinite(key)) {
+    if (encodeBindingKey(key) === encoded) return key;
+  }
+  throw new TypeError("A DOM presentation key has invalid serialized identity.");
+}
+function parseBindingMarker(data) {
+  if (data.startsWith("[f0;b;") || data.startsWith("[f1;b;")) {
+    const separator = data.indexOf(";", 6);
+    if (separator <= 6 || separator === data.length - 1) return null;
+    return {
+      id: data.slice(6, separator),
+      site: data.slice(separator + 1),
+      kind: "for",
+      arm: data.charCodeAt(2) - 48
+    };
+  }
+  if (!data.startsWith("[b;")) return null;
+  const idEnd = data.indexOf(";", 3);
+  if (idEnd <= 3 || idEnd === data.length - 1) return null;
+  const id = data.slice(3, idEnd);
+  if (data.slice(idEnd + 1) === "root") return { id, site: "root", kind: "root" };
+  const siteEnd = data.indexOf(";", idEnd + 1);
+  if (siteEnd <= idEnd + 1 || siteEnd === data.length - 1) return null;
+  const site = data.slice(idEnd + 1, siteEnd);
+  const kind = data.slice(siteEnd + 1);
+  if (kind === "t") return { id, site, kind: "text" };
+  if (kind === "v") return { id, site, kind: "view" };
+  if (kind === "s") return { id, site, kind: "slot" };
+  if (kind === "o") return { id, site, kind: "opaque" };
+  if (kind.startsWith("k;")) {
+    const key = kind.slice(2);
+    try {
+      decodeBindingKey(key);
+    } catch {
+      return null;
+    }
+    return { id, site, kind: "item", key };
+  }
+  if (/^(?:-1|0|[1-9]\d*)$/.test(kind)) {
+    const arm = Number(kind);
+    if (Number.isSafeInteger(arm)) return { id, site, kind: "if", arm };
+  }
+  return null;
+}
+function isBindingOpenComment(data) {
+  const list = data.startsWith("[f0;b;") || data.startsWith("[f1;b;");
+  if (!list && !data.startsWith("[b;")) return false;
+  const idStart = list ? 6 : 3;
+  const idEnd = data.indexOf(";", idStart);
+  if (idEnd <= idStart || idEnd === data.length - 1) return false;
+  if (list) return data.indexOf(";", idEnd + 1) === -1;
+  if (data.length - idEnd === 5 && data.endsWith(";root")) return true;
+  const siteEnd = data.indexOf(";", idEnd + 1);
+  if (siteEnd <= idEnd + 1 || siteEnd === data.length - 1) return false;
+  const tail = siteEnd + 1;
+  if (data.length === tail + 1) {
+    const code = data.charCodeAt(tail);
+    return code === 116 || code === 118 || code === 115 || code === 111 || code >= 48 && code <= 57;
+  }
+  if (data.charCodeAt(tail) === 107 && data.charCodeAt(tail + 1) === 59)
+    return (data.charCodeAt(tail + 2) === 115 || data.charCodeAt(tail + 2) === 110) && data.charCodeAt(tail + 3) === 58 && data.length > tail + 4;
+  if (data.length === tail + 2 && data.endsWith("-1")) return true;
+  if (data.charCodeAt(tail) < 49 || data.charCodeAt(tail) > 57) return false;
+  for (let index = tail + 1; index < data.length; index++) {
+    const code = data.charCodeAt(index);
+    if (code < 48 || code > 57) return false;
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodeBindingKey,
+  encodeBindingKey,
+  isBindingOpenComment,
+  parseBindingMarker
+});

package/dist/cjs/dom-binding-styles.cjs

@@ -0,0 +1,292 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dom_binding_styles_exports = {};
+__export(dom_binding_styles_exports, {
+  __createBindingStyles: () => __createBindingStyles,
+  __normalizeBindingStyle: () => __normalizeBindingStyle,
+  __prepareBindingSources: () => __prepareBindingSources
+});
+module.exports = __toCommonJS(dom_binding_styles_exports);
+var import_style_values = require("./style-values.cjs");
+var import_dom_bindings = require("./dom-bindings.cjs");
+var import_owner_context = require("./signals/owner-context.cjs");
+var import_read_protocol = require("./signals/read-protocol.cjs");
+function __prepareBindingSources(reads, subscriptions, notify, active, run) {
+  const previous = new Map(subscriptions);
+  const acquired = /* @__PURE__ */ new Map();
+  let accepted = false;
+  let retired = false;
+  let invalid = false;
+  try {
+    for (const source of reads.keys()) {
+      if (previous.has(source)) continue;
+      let live = true;
+      const stop = run(
+        () => source.subscribe(
+          (0, import_read_protocol.forwardNativeTransitionConsumer)(notify, () => {
+            if (!live || retired || !active()) return;
+            if (!accepted) invalid = true;
+            else notify();
+          })
+        )
+      );
+      acquired.set(source, () => {
+        live = false;
+        stop();
+      });
+    }
+  } catch (error) {
+    for (const stop of acquired.values()) stop();
+    throw error;
+  }
+  return {
+    validate: () => !retired && !invalid && active() && subscriptions.size === previous.size && [...previous].every(([source, stop]) => subscriptions.get(source) === stop) && [...reads].every(([source, version]) => source.getVersion() === version),
+    commit() {
+      if (accepted || retired || !active()) return;
+      accepted = true;
+      for (const [source, stop] of acquired) subscriptions.set(source, stop);
+      for (const [source, stop] of previous) {
+        if (reads.has(source)) continue;
+        subscriptions.delete(source);
+        stop();
+      }
+    },
+    discard() {
+      if (accepted || retired) return;
+      retired = true;
+      for (const stop of acquired.values()) stop();
+    }
+  };
+}
+function __normalizeBindingStyle(value) {
+  if (value == null || value === false || value === "") return null;
+  if (typeof value === "string") return value;
+  if (typeof value !== "object")
+    throw new TypeError("A whole-style DOM binding requires a style object, CSS text or null.");
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const name in value) {
+    const property = value[name];
+    result[name] = property == null || typeof property === "boolean" ? null : (0, import_style_values.cssStyleValue)(name, property);
+  }
+  return result;
+}
+function __createBindingStyles() {
+  const owner = (0, import_owner_context.currentSignalOwner)();
+  const run = owner === null ? (callback) => callback() : (0, import_owner_context.captureSignalOwner)(owner);
+  return {
+    connect(node, notify, restoreStyles = false) {
+      let raw;
+      let disposed = false;
+      const subscriptions = /* @__PURE__ */ new Map();
+      let previous = null;
+      let firstWrite = true;
+      const style = node.style;
+      let restorations;
+      let baseline;
+      let expected;
+      let probe;
+      const snapshotDOM = () => {
+        const result = /* @__PURE__ */ Object.create(null);
+        for (let i = 0; i < style.length; i++) {
+          const name = style.item(i);
+          result[name] = style.getPropertyValue(name) + (style.getPropertyPriority(name) ? " !important" : "");
+        }
+        return result;
+      };
+      previous = snapshotDOM();
+      const get = () => {
+        if (disposed) return null;
+        const reads = /* @__PURE__ */ new Map();
+        const previousObserver = (0, import_read_protocol.setNativeReadObserver)(
+          (source, version) => reads.set(source, version)
+        );
+        const guard = (0, import_read_protocol.beginNativeWriteGuard)();
+        let value;
+        try {
+          value = run(() => __normalizeBindingStyle((0, import_read_protocol.readNativeDomStyle)(raw)));
+        } finally {
+          (0, import_read_protocol.endNativeWriteGuard)(guard);
+          (0, import_read_protocol.setNativeReadObserver)(previousObserver);
+        }
+        for (const [source, stop] of subscriptions) {
+          if (reads.has(source)) continue;
+          subscriptions.delete(source);
+          stop();
+        }
+        for (const [source, version] of reads) {
+          if (disposed) break;
+          if (!subscriptions.has(source)) {
+            let active = true;
+            const stop = run(
+              () => source.subscribe(
+                (0, import_read_protocol.forwardNativeTransitionConsumer)(notify, () => {
+                  if (active && !disposed) notify();
+                })
+              )
+            );
+            if (typeof stop !== "function")
+              throw new TypeError("A DOM style subscription must return cleanup.");
+            const disposeSource = () => {
+              active = false;
+              stop();
+            };
+            if (disposed) disposeSource();
+            else subscriptions.set(source, disposeSource);
+          }
+          if (!disposed && source.getVersion() !== version) notify();
+        }
+        return value;
+      };
+      const writeProperty = (name, value) => {
+        if (disposed) return;
+        name = (0, import_style_values.hyphenateStyleName)(name);
+        const operation = [0, "styleProperty", name];
+        if (restoreStyles) {
+          if (!baseline) {
+            baseline = node.ownerDocument.createElement("i");
+            expected = node.ownerDocument.createElement("i");
+            baseline.style.cssText = expected.style.cssText = style.cssText;
+            restorations = /* @__PURE__ */ new Set();
+          }
+          restorations.add(name);
+          (0, import_dom_bindings.__writeBinding)(expected, operation, value);
+        }
+        (0, import_dom_bindings.__writeBinding)(node, operation, value);
+      };
+      const restore = () => {
+        if (!restorations) return;
+        const owned = [...restorations].filter(
+          (name) => style.getPropertyValue(name) === expected.style.getPropertyValue(name) && style.getPropertyPriority(name) === expected.style.getPropertyPriority(name)
+        );
+        let failed = false;
+        let failure;
+        for (const name of owned) {
+          try {
+            const value = baseline.style.getPropertyValue(name);
+            if (value === "") style.removeProperty(name);
+            else style.setProperty(name, value, baseline.style.getPropertyPriority(name));
+          } catch (error) {
+            if (!failed) {
+              failed = true;
+              failure = error;
+            }
+          }
+        }
+        if (failed) throw failure;
+      };
+      return {
+        get,
+        preview(value) {
+          const reads = /* @__PURE__ */ new Map();
+          const previousObserver = (0, import_read_protocol.setNativeReadObserver)((source, version) => {
+            if (!reads.has(source)) reads.set(source, version);
+          });
+          const guard = (0, import_read_protocol.beginNativeWriteGuard)();
+          let projected;
+          try {
+            projected = run(() => __normalizeBindingStyle((0, import_read_protocol.readNativeDomStyle)(value)));
+          } finally {
+            (0, import_read_protocol.endNativeWriteGuard)(guard);
+            (0, import_read_protocol.setNativeReadObserver)(previousObserver);
+          }
+          const prepared = __prepareBindingSources(
+            reads,
+            subscriptions,
+            notify,
+            () => !disposed,
+            run
+          );
+          return {
+            value: projected,
+            validate: prepared.validate,
+            discard: prepared.discard,
+            commit() {
+              raw = value;
+              prepared.commit();
+            }
+          };
+        },
+        read(value) {
+          raw = value;
+          return get();
+        },
+        write(value) {
+          if (disposed) return;
+          let next = value;
+          let old = typeof previous === "string" ? snapshotDOM() : previous;
+          const writeAll = firstWrite || typeof previous === "string" || typeof value === "string";
+          if (typeof next === "string") {
+            probe ??= node.ownerDocument.createElement("i");
+            probe.style.cssText = next;
+            const parsed = /* @__PURE__ */ Object.create(null);
+            for (let i = 0; i < probe.style.length; i++) {
+              const name = probe.style.item(i);
+              parsed[name] = probe.style.getPropertyValue(name) + (probe.style.getPropertyPriority(name) ? " !important" : "");
+            }
+            next = parsed;
+            old = snapshotDOM();
+          }
+          previous = typeof value === "string" ? value : next;
+          const initialNames = firstWrite && next && typeof next === "object" ? new Set(Object.keys(next).map(import_style_values.hyphenateStyleName)) : null;
+          firstWrite = false;
+          if (old && typeof old === "object") {
+            for (const name in old)
+              if (next === null || (initialNames ? !initialNames.has(name) : !(name in next)))
+                writeProperty(name, null);
+          }
+          if (next && typeof next === "object") {
+            for (const name in next)
+              if (writeAll || old === null || typeof old !== "object" || next[name] !== old[name])
+                writeProperty(name, next[name]);
+          }
+        },
+        dispose(preservePresentation) {
+          if (disposed) return;
+          disposed = true;
+          raw = previous = null;
+          let failed = false;
+          let failure;
+          for (const stop of [
+            ...subscriptions.values(),
+            ...preservePresentation ? [] : [restore]
+          ]) {
+            try {
+              stop();
+            } catch (error) {
+              if (!failed) {
+                failed = true;
+                failure = error;
+              }
+            }
+          }
+          subscriptions.clear();
+          restorations?.clear();
+          probe = baseline = expected = void 0;
+          if (failed) throw failure;
+        }
+      };
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  __createBindingStyles,
+  __normalizeBindingStyle,
+  __prepareBindingSources
+});