domflax 0.1.1 → 0.1.4

package/dist/{chunk-DWLB7FRR.js → chunk-H5KTGI3A.js}

@@ -1,6 +1,6 @@
 import {
   init_esm_shims
-} from "./chunk-6WVVF6AD.js";
+} from "./chunk-U5GOONKV.js";
 
 // ../core/src/builders.ts
 init_esm_shims();
@@ -72,6 +72,7 @@ function defaultMeta(safetyFloor = 0) {
     declaresCustomProperties: false,
     whitespaceSensitive: false,
     touched: false,
+    styleDirty: false,
     synthetic: false,
     safetyFloor
   };
@@ -286,6 +287,14 @@ function markTouched(state, id) {
     state.touched.add(id);
   }
 }
+function markStyleDirty(state, id) {
+  const n = state.doc.nodes.get(id);
+  if (n) {
+    n.meta.touched = true;
+    n.meta.styleDirty = true;
+    state.touched.add(id);
+  }
+}
 function removeSubtree(state, id) {
   const node = state.doc.nodes.get(id);
   if (!node) return;
@@ -578,7 +587,7 @@ function applyOne(state, op) {
         return [precond(op, op.target, "setClassList target is not an element")];
       }
       el.computed = cloneStyleMap(op.style);
-      markTouched(state, op.target);
+      markStyleDirty(state, op.target);
       return [];
     }
     case "mergeStyle": {
@@ -601,7 +610,7 @@ function applyOne(state, op) {
         const src = doc.nodes.get(op.source);
         if (src) markTouched(state, op.source);
       }
-      markTouched(state, op.target);
+      markStyleDirty(state, op.target);
       return [];
     }
     case "foldInheritedStyles":
@@ -652,7 +661,7 @@ function applyFold(state, op) {
     }
     if (folded) {
       into.computed = { blocks: nextBlocks };
-      markTouched(state, intoId);
+      markStyleDirty(state, intoId);
     }
   }
   for (const d of issues) state.diagnostics.push(d);
@@ -990,8 +999,123 @@ init_esm_shims();
 var DISPLAY = "display";
 var POSITION = "position";
 var TRANSFORM = "transform";
+var ALIGN_ITEMS = "align-items";
+var JUSTIFY_CONTENT = "justify-content";
+var JUSTIFY_ITEMS = "justify-items";
+var PLACE_ITEMS = "place-items";
+var PLACE_SELF = "place-self";
 var CONTEXT_SAFE_DISPLAYS = /* @__PURE__ */ new Set(["block", "contents", ""]);
 var STATIC_POSITIONS = /* @__PURE__ */ new Set(["static", ""]);
+var CENTERING_DISPLAYS = /* @__PURE__ */ new Set(["flex", "grid"]);
+var GRID_PARENT_DISPLAYS = /* @__PURE__ */ new Set(["grid"]);
+var STRETCHY_ITEM_ALIGN = /* @__PURE__ */ new Set(["normal", "stretch"]);
+var PARENT_ITEMS_ALIGN_PROPS = [ALIGN_ITEMS, JUSTIFY_ITEMS, PLACE_ITEMS];
+function isBaseCondition(block) {
+  const c = block.condition;
+  return c.media === "" && c.states.length === 0 && c.pseudoElement === "";
+}
+function baseValue(sm, prop) {
+  for (const block of sm.blocks.values()) {
+    if (!isBaseCondition(block)) continue;
+    const d = block.decls.get(prop);
+    return d ? String(d.value) : null;
+  }
+  return null;
+}
+function parentIsFillingGrid(before, wrapper, norm) {
+  if (wrapper.parent == null) return false;
+  const p = before.nodes.get(wrapper.parent);
+  if (!p || p.kind !== "element") return false;
+  const pc = norm.normalizeStyleMap(p.computed);
+  let baseIsGrid = false;
+  for (const block of pc.blocks.values()) {
+    const disp = block.decls.get(DISPLAY);
+    if (disp) {
+      if (!GRID_PARENT_DISPLAYS.has(String(disp.value))) return false;
+      if (isBaseCondition(block)) baseIsGrid = true;
+    }
+    for (const prop of PARENT_ITEMS_ALIGN_PROPS) {
+      const d = block.decls.get(prop);
+      if (d && !STRETCHY_ITEM_ALIGN.has(String(d.value))) return false;
+    }
+  }
+  return baseIsGrid;
+}
+function wrapperHasOnlyCenteringStyle(wrapperComputed, childComputed, norm) {
+  for (const block of wrapperComputed.blocks.values()) {
+    const base = isBaseCondition(block);
+    const ck = conditionKey(block.condition);
+    for (const [prop, decl] of block.decls) {
+      const val = String(decl.value);
+      if (prop === DISPLAY) {
+        if (base && CENTERING_DISPLAYS.has(val)) continue;
+        return false;
+      }
+      if (prop === ALIGN_ITEMS) {
+        if (base && val === "center") continue;
+        return false;
+      }
+      if (prop === JUSTIFY_CONTENT) {
+        if (base && val === "center") continue;
+        return false;
+      }
+      if (prop === POSITION) {
+        if (STATIC_POSITIONS.has(val)) continue;
+        return false;
+      }
+      if (prop === TRANSFORM) {
+        if (val === "none") continue;
+        return false;
+      }
+      if (isInherited2(decl, norm)) continue;
+      if (childReproduces(childComputed, ck, prop, val)) continue;
+      return false;
+    }
+  }
+  return true;
+}
+function wrapperCentersSingleElement(before, wrapper) {
+  let elements = 0;
+  for (const cid of wrapper.children) {
+    const n = before.nodes.get(cid);
+    if (!n) continue;
+    if (n.kind === "element") {
+      elements += 1;
+      continue;
+    }
+    if (n.kind === "comment") continue;
+    if (n.kind === "text" && n.value.trim() === "") continue;
+    return false;
+  }
+  return elements === 1;
+}
+function childHasSelfAlign(childBefore, norm) {
+  if (!childBefore) return false;
+  const sm = norm.normalizeStyleMap(childBefore);
+  for (const block of sm.blocks.values()) {
+    for (const prop of SELF_ALIGN_PROPS) {
+      const d = block.decls.get(prop);
+      if (d && !NEUTRAL_ALIGN.has(String(d.value))) return true;
+    }
+  }
+  return false;
+}
+function childGainsPlaceSelfCenter(childAfter) {
+  if (baseValue(childAfter, PLACE_SELF) === "center") return true;
+  return baseValue(childAfter, "align-self") === "center" && baseValue(childAfter, "justify-self") === "center";
+}
+function isContextCompensatedCentering(before, wrapper, wrapperComputed, childBefore, childAfter, norm) {
+  if (!childAfter) return false;
+  if (!CENTERING_DISPLAYS.has(baseValue(wrapperComputed, DISPLAY) ?? "")) return false;
+  if (baseValue(wrapperComputed, ALIGN_ITEMS) !== "center") return false;
+  if (baseValue(wrapperComputed, JUSTIFY_CONTENT) !== "center") return false;
+  const childAfterNorm = norm.normalizeStyleMap(childAfter);
+  if (!childGainsPlaceSelfCenter(childAfterNorm)) return false;
+  if (!wrapperHasOnlyCenteringStyle(wrapperComputed, childAfterNorm, norm)) return false;
+  if (!wrapperCentersSingleElement(before, wrapper)) return false;
+  if (childHasSelfAlign(childBefore, norm)) return false;
+  return parentIsFillingGrid(before, wrapper, norm);
+}
 var SELF_ALIGN_PROPS = [
   "place-self",
   "align-self",
@@ -1091,6 +1215,9 @@ function classifyFlattenOps(before, after, ops, norm) {
   const wrapperComputed = norm.normalizeStyleMap(wrapper.computed);
   const childAfter = childId != null ? getElement(after, childId)?.computed ?? null : null;
   const childBefore = childId != null ? getElement(before, childId)?.computed ?? null : null;
+  if (isContextCompensatedCentering(before, wrapper, wrapperComputed, childBefore, childAfter, norm)) {
+    return { kind: "provably-safe", wrapperId, childId };
+  }
   if (establishesChildContext(wrapperComputed)) {
     return { kind: "needs-verification", wrapperId, childId };
   }
@@ -1529,15 +1656,34 @@ function sameTokens(a, b) {
   for (let i = 0; i < a.length; i += 1) if (a[i] !== b[i]) return false;
   return true;
 }
+function residualStyle(computed2, covered, norm) {
+  const cov = norm.normalizeStyleMap(covered);
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of norm.normalizeStyleMap(computed2).blocks) {
+    const covBlock = cov.blocks.get(key);
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      const covDecl = covBlock?.decls.get(prop);
+      if (covDecl && covDecl.value === decl.value && covDecl.important === decl.important) continue;
+      decls.set(prop, decl);
+    }
+    if (decls.size > 0) blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
 function syncClassesFromComputed(doc, resolver, norm) {
   const sink = createSyntheticSink();
   for (const id of elementIds(doc)) {
     const el = getElement(doc, id);
-    if (!el || !el.meta.touched) continue;
+    if (!el) continue;
+    if (!el.meta.styleDirty) continue;
     if (el.classes.opaque || el.classes.hasDynamic) continue;
     const tokens = staticTokensOf(el.classes);
+    const retained = tokens.filter((t) => !resolver.selectorUsage(t).droppable);
+    const covered = retained.length > 0 ? resolver.resolve({ classes: retained }).styles : null;
+    const target = covered ? residualStyle(el.computed, covered, norm) : el.computed;
     const ctx = { normalizer: norm, sink };
-    const emitted = resolver.emit(el.computed, ctx).classes;
+    const emitted = resolver.emit(target, ctx).classes;
     if (emitted.length === 0) continue;
     const emittedSet = new Set(emitted);
     const next = [];
@@ -2209,4 +2355,4 @@ export {
   definePattern,
   pattern
 };
-//# sourceMappingURL=chunk-DWLB7FRR.js.map
+//# sourceMappingURL=chunk-H5KTGI3A.js.map