kuinetic 0.1.3 → 0.2.0

package/dist/esm/chunk-AEQGC2KM.mjs

@@ -0,0 +1,189 @@
+// src/core/owned-styles.ts
+function createStyleLedger(el) {
+  const style = el.style;
+  const previous = /* @__PURE__ */ new Map();
+  const authoredStyleAttribute = el.hasAttribute("style");
+  function remember(property) {
+    if (previous.has(property)) return;
+    const existing = style.getPropertyValue(property);
+    previous.set(
+      property,
+      existing === "" ? void 0 : { value: existing, priority: style.getPropertyPriority(property) }
+    );
+  }
+  return {
+    set(property, value) {
+      remember(property);
+      style.setProperty(property, value);
+    },
+    claim: remember,
+    restore() {
+      for (const [property, previousValue] of previous) {
+        if (previousValue === void 0) style.removeProperty(property);
+        else style.setProperty(property, previousValue.value, previousValue.priority);
+      }
+      previous.clear();
+      if (!authoredStyleAttribute && style.length === 0 && !el.getAttribute("style"))
+        el.removeAttribute("style");
+    },
+    owned: () => [...previous.keys()],
+    peek(property) {
+      if (!previous.has(property)) return void 0;
+      const previousValue = previous.get(property);
+      return previousValue === void 0 ? "" : previousValue.value;
+    }
+  };
+}
+function createAttributeLedger(el) {
+  const previous = /* @__PURE__ */ new Map();
+  return {
+    set(name, value) {
+      if (!previous.has(name)) previous.set(name, el.getAttribute(name));
+      el.setAttribute(name, value);
+    },
+    remove(name) {
+      if (!previous.has(name)) previous.set(name, el.getAttribute(name));
+      el.removeAttribute(name);
+    },
+    restore() {
+      for (const [name, value] of previous) {
+        if (value === null) el.removeAttribute(name);
+        else el.setAttribute(name, value);
+      }
+      previous.clear();
+    }
+  };
+}
+var REGISTRY = Symbol.for("kuinetic.owned-styles.1");
+function entriesOf(el) {
+  const carrier = el;
+  let entries = carrier[REGISTRY];
+  if (!entries) {
+    entries = /* @__PURE__ */ new Map();
+    Object.defineProperty(el, REGISTRY, { value: entries, configurable: true, writable: true });
+  }
+  return entries;
+}
+function entryFor(el, kind, make) {
+  const entries = entriesOf(el);
+  let entry = entries.get(kind);
+  if (!entry) {
+    entry = { ledger: make(el), owners: /* @__PURE__ */ new Set() };
+    entries.set(kind, entry);
+  }
+  return entry;
+}
+function openClaimBook(kind, make) {
+  const owner = {};
+  const held = /* @__PURE__ */ new Map();
+  return {
+    join(el) {
+      let entry = held.get(el);
+      if (!entry) {
+        entry = entryFor(el, kind, make);
+        entry.owners.add(owner);
+        held.set(el, entry);
+      }
+      return entry.ledger;
+    },
+    held: (el) => held.get(el)?.ledger ?? null,
+    leave(el) {
+      const entry = held.get(el);
+      if (!entry) return;
+      held.delete(el);
+      entry.owners.delete(owner);
+      if (entry.owners.size > 0) return;
+      entriesOf(el).delete(kind);
+      entry.ledger.restore();
+    },
+    elements: () => [...held.keys()]
+  };
+}
+function createStyleClaim() {
+  const book = openClaimBook("style", createStyleLedger);
+  const handles = /* @__PURE__ */ new WeakMap();
+  function handleFor(el) {
+    return {
+      set: (property, value) => {
+        book.join(el).set(property, value);
+      },
+      claim: (property) => {
+        book.join(el).claim(property);
+      },
+      restore: () => {
+        book.leave(el);
+      },
+      owned: () => book.held(el)?.owned() ?? [],
+      peek: (property) => book.held(el)?.peek(property)
+    };
+  }
+  return {
+    style(el) {
+      let handle = handles.get(el);
+      if (!handle) {
+        handle = handleFor(el);
+        handles.set(el, handle);
+      }
+      book.join(el);
+      return handle;
+    },
+    release: (el) => {
+      book.leave(el);
+    },
+    elements: () => book.elements()
+  };
+}
+function createAttributeClaim() {
+  const book = openClaimBook("attributes", createAttributeLedger);
+  const handles = /* @__PURE__ */ new WeakMap();
+  function handleFor(el) {
+    return {
+      set: (name, value) => {
+        book.join(el).set(name, value);
+      },
+      restore: () => {
+        book.leave(el);
+      }
+    };
+  }
+  return {
+    attributes(el) {
+      let handle = handles.get(el);
+      if (!handle) {
+        handle = handleFor(el);
+        handles.set(el, handle);
+      }
+      book.join(el);
+      return handle;
+    },
+    release: (el) => {
+      book.leave(el);
+    },
+    elements: () => book.elements()
+  };
+}
+function createLedgerSet(host) {
+  const styles = createStyleClaim();
+  const attributes = createAttributeClaim();
+  function restoreOne(el) {
+    styles.release(el);
+    attributes.release(el);
+  }
+  return {
+    style: (el) => styles.style(el),
+    attributes: (el) => attributes.attributes(el),
+    restore() {
+      for (const el of /* @__PURE__ */ new Set([...styles.elements(), ...attributes.elements()])) {
+        if (el !== host) restoreOne(el);
+      }
+      restoreOne(host);
+    }
+  };
+}
+
+export {
+  createStyleLedger,
+  createAttributeLedger,
+  createStyleClaim,
+  createLedgerSet
+};