domflax 0.1.0

package/dist/pattern-kit.cjs

@@ -0,0 +1,630 @@
+"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);
+
+// src/pattern-kit.ts
+var pattern_kit_exports = {};
+__export(pattern_kit_exports, {
+  and: () => and,
+  computed: () => computed,
+  createNormalizer: () => createNormalizer,
+  definePattern: () => definePattern,
+  emptyStyleMap: () => emptyStyleMap,
+  foldInheritedStyles: () => foldInheritedStyles,
+  hasDynamicChildren: () => hasDynamicChildren,
+  hasDynamicClasses: () => hasDynamicClasses,
+  hasEventHandlers: () => hasEventHandlers,
+  hasOwnVisualStyle: () => hasOwnVisualStyle,
+  hasRef: () => hasRef,
+  hasSingleElementChild: () => hasSingleElementChild,
+  isElement: () => isElement,
+  isStyleSuperset: () => isStyleSuperset,
+  mergeStyle: () => mergeStyle,
+  normalizer: () => normalizer,
+  not: () => not,
+  or: () => or,
+  pattern: () => pattern,
+  removeNode: () => removeNode,
+  replaceWith: () => replaceWith,
+  targetedByCombinator: () => targetedByCombinator
+});
+module.exports = __toCommonJS(pattern_kit_exports);
+
+// ../pattern-kit/src/define.ts
+var PHASES = /* @__PURE__ */ new Set(["flatten", "compress", "extract"]);
+var SAFETY_LEVELS = /* @__PURE__ */ new Set([0, 1, 2, 3]);
+function fail(name, why) {
+  throw new Error(`definePattern(${name || "<anonymous>"}): ${why}`);
+}
+function definePattern(spec) {
+  if (spec == null || typeof spec !== "object") {
+    throw new Error("definePattern: spec must be an object");
+  }
+  const name = spec.name;
+  if (typeof name !== "string" || name.length === 0) {
+    fail(String(name), "name must be a non-empty string");
+  }
+  if (typeof spec.category !== "string" || !spec.category.includes("/")) {
+    fail(name, `category must be a "<phase>/<slug>" string (got ${JSON.stringify(spec.category)})`);
+  }
+  const phase = spec.category.split("/", 1)[0];
+  if (!PHASES.has(phase)) {
+    fail(name, `category phase must be one of flatten|compress|extract (got "${phase}")`);
+  }
+  if (!SAFETY_LEVELS.has(spec.safety)) {
+    fail(name, `safety must be 0|1|2|3 (got ${JSON.stringify(spec.safety)})`);
+  }
+  if (typeof spec.evaluate !== "function") {
+    fail(name, "evaluate must be a function");
+  }
+  if (spec.priority !== void 0 && !Number.isFinite(spec.priority)) {
+    fail(name, "priority must be a finite number when provided");
+  }
+  return Object.freeze({ ...spec });
+}
+
+// ../core/src/builders.ts
+var BASE_CONDITION = { media: "", states: [], pseudoElement: "" };
+function conditionKey(c) {
+  const states = [...c.states].sort().join(",");
+  return `${c.media}|${states}|${c.pseudoElement}`;
+}
+var BASE_CONDITION_KEY = conditionKey(BASE_CONDITION);
+function emptyStyleMap() {
+  return { blocks: /* @__PURE__ */ new Map() };
+}
+
+// ../pattern-kit/src/normalize.ts
+var INHERITED_PROPERTIES = [
+  "azimuth",
+  "border-collapse",
+  "border-spacing",
+  "caption-side",
+  "color",
+  "cursor",
+  "direction",
+  "empty-cells",
+  "font-family",
+  "font-feature-settings",
+  "font-kerning",
+  "font-size",
+  "font-size-adjust",
+  "font-stretch",
+  "font-style",
+  "font-variant",
+  "font-variant-caps",
+  "font-variant-numeric",
+  "font-weight",
+  "hyphens",
+  "letter-spacing",
+  "line-height",
+  "list-style-image",
+  "list-style-position",
+  "list-style-type",
+  "orphans",
+  "overflow-wrap",
+  "quotes",
+  "tab-size",
+  "text-align",
+  "text-align-last",
+  "text-decoration-color",
+  "text-indent",
+  "text-justify",
+  "text-rendering",
+  "text-shadow",
+  "text-transform",
+  "text-underline-position",
+  "visibility",
+  "white-space",
+  "widows",
+  "word-break",
+  "word-spacing",
+  "writing-mode",
+  "-webkit-font-smoothing"
+];
+function createInheritedTable() {
+  const properties = new Set(INHERITED_PROPERTIES);
+  return {
+    version: "domflax-inherited@1",
+    properties,
+    isInherited(property) {
+      return String(property).startsWith("--") || properties.has(property);
+    }
+  };
+}
+var ZERO_LENGTH_RE = /\b0(?:px|em|rem|ex|ch|vh|vw|vmin|vmax|vi|vb|pt|pc|cm|mm|in|q|lh|rlh|fr|deg|rad|turn|s|ms|%)\b/g;
+var FUNC_ARGS_RE = /\b(rgba?|hsla?|hwb|lab|lch|oklab|oklch)\(([^()]*)\)/gi;
+var RELATIVE_UNIT_RE = /(?:\d*\.?\d+)(?:em|ex|ch|lh)\b|%/i;
+function canonValue(raw) {
+  let v = raw.trim().replace(/\s+/g, " ");
+  v = v.replace(/#([0-9a-fA-F]{3,8})\b/g, (_m, hex) => "#" + hex.toLowerCase());
+  v = v.replace(
+    /#([0-9a-f])([0-9a-f])([0-9a-f])(?![0-9a-f])/g,
+    (_m, r, g, b) => `#${r}${r}${g}${g}${b}${b}`
+  );
+  v = v.replace(/\btransparent\b/gi, "rgba(0, 0, 0, 0)");
+  v = v.replace(/#00000000\b/g, "rgba(0, 0, 0, 0)");
+  v = v.replace(ZERO_LENGTH_RE, "0");
+  v = v.replace(FUNC_ARGS_RE, (_m, fn, args) => {
+    const parts = args.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+    return `${fn.toLowerCase()}(${parts.join(", ")})`;
+  });
+  return v;
+}
+function isRelativeValue(value) {
+  return RELATIVE_UNIT_RE.test(value);
+}
+var BOX_SIDES = {
+  padding: ["padding-top", "padding-right", "padding-bottom", "padding-left"],
+  margin: ["margin-top", "margin-right", "margin-bottom", "margin-left"],
+  inset: ["top", "right", "bottom", "left"],
+  "border-width": [
+    "border-top-width",
+    "border-right-width",
+    "border-bottom-width",
+    "border-left-width"
+  ],
+  "border-style": [
+    "border-top-style",
+    "border-right-style",
+    "border-bottom-style",
+    "border-left-style"
+  ],
+  "border-color": [
+    "border-top-color",
+    "border-right-color",
+    "border-bottom-color",
+    "border-left-color"
+  ]
+};
+function splitTopLevel(value) {
+  const out = [];
+  let depth = 0;
+  let cur = "";
+  for (const ch of value) {
+    if (ch === "(") depth += 1;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    if (depth === 0 && /\s/.test(ch)) {
+      if (cur.length > 0) {
+        out.push(cur);
+        cur = "";
+      }
+      continue;
+    }
+    cur += ch;
+  }
+  if (cur.length > 0) out.push(cur);
+  return out;
+}
+function boxFourSides(values) {
+  const [a, b, c, d] = values;
+  switch (values.length) {
+    case 1:
+      return [a, a, a, a];
+    case 2:
+      return [a, b, a, b];
+    case 3:
+      return [a, b, c, b];
+    default:
+      return [a, b, c, d];
+  }
+}
+function expandShorthand(prop, value) {
+  const box = BOX_SIDES[prop];
+  if (box) {
+    const parts = splitTopLevel(value);
+    if (parts.length >= 1 && parts.length <= 4) {
+      const sides = boxFourSides(parts);
+      return box.map((p, i) => [p, sides[i]]);
+    }
+    return [[prop, value]];
+  }
+  if (prop === "gap" || prop === "grid-gap") {
+    const parts = splitTopLevel(value);
+    if (parts.length === 1) {
+      return [
+        ["row-gap", parts[0]],
+        ["column-gap", parts[0]]
+      ];
+    }
+    if (parts.length === 2) {
+      return [
+        ["row-gap", parts[0]],
+        ["column-gap", parts[1]]
+      ];
+    }
+    return [[prop, value]];
+  }
+  return [[prop, value]];
+}
+function makeDecl(table, prop, rawValue, important) {
+  const property = prop.trim().toLowerCase();
+  const value = canonValue(rawValue);
+  return {
+    property,
+    value,
+    important,
+    relativeToParent: isRelativeValue(value),
+    inherited: table.isInherited(property)
+  };
+}
+function createNormalizer() {
+  const inherited = createInheritedTable();
+  const normalizeDeclaration = (prop, value, important) => {
+    const p = prop.trim().toLowerCase();
+    const expanded = expandShorthand(p, value.trim());
+    return expanded.map(([lp, lv]) => makeDecl(inherited, lp, lv, important));
+  };
+  const normalizeValue = (prop, raw) => {
+    void prop;
+    return canonValue(raw);
+  };
+  const normalizeStyleMap = (sm) => {
+    const blocks = /* @__PURE__ */ new Map();
+    for (const block of sm.blocks.values()) {
+      const decls = /* @__PURE__ */ new Map();
+      for (const decl of block.decls.values()) {
+        const next = {
+          ...decl,
+          value: canonValue(String(decl.value)),
+          relativeToParent: isRelativeValue(String(decl.value)),
+          inherited: inherited.isInherited(decl.property)
+        };
+        decls.set(next.property, next);
+      }
+      const sorted = new Map(
+        [...decls.entries()].sort((a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0)
+      );
+      const key = conditionKey(block.condition);
+      blocks.set(key, { condition: block.condition, decls: sorted });
+    }
+    return { blocks };
+  };
+  const equals = (a, b) => {
+    const na = normalizeStyleMap(a);
+    const nb = normalizeStyleMap(b);
+    if (na.blocks.size !== nb.blocks.size) return false;
+    for (const [key, blockA] of na.blocks) {
+      const blockB = nb.blocks.get(key);
+      if (!blockB) return false;
+      if (blockA.decls.size !== blockB.decls.size) return false;
+      for (const [prop, declA] of blockA.decls) {
+        const declB = blockB.decls.get(prop);
+        if (!declB) return false;
+        if (declA.value !== declB.value || declA.important !== declB.important) return false;
+      }
+    }
+    return true;
+  };
+  return {
+    version: "domflax-normalizer@1",
+    normalizeDeclaration,
+    normalizeValue,
+    normalizeStyleMap,
+    equals,
+    inherited
+  };
+}
+var normalizer = createNormalizer();
+function isStyleSuperset(full, partial, norm = normalizer) {
+  const nf = norm.normalizeStyleMap(full);
+  const np = norm.normalizeStyleMap(partial);
+  for (const [key, want] of np.blocks) {
+    const have = nf.blocks.get(key) ?? nf.blocks.get(conditionKey(want.condition));
+    if (!have) return false;
+    for (const [prop, decl] of want.decls) {
+      const got = have.decls.get(prop);
+      if (!got || got.value !== decl.value) return false;
+    }
+  }
+  return true;
+}
+
+// ../pattern-kit/src/combinators.ts
+function asElement(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+function elementChildrenOf(el, ctx) {
+  const out = [];
+  for (const childId of el.children) {
+    const child = ctx.doc.nodes.get(childId);
+    if (child && child.kind === "element") out.push(child);
+  }
+  return out;
+}
+function and(...matchers) {
+  return (node, ctx) => matchers.every((m) => m(node, ctx));
+}
+function or(...matchers) {
+  return (node, ctx) => matchers.some((m) => m(node, ctx));
+}
+function not(matcher) {
+  return (node, ctx) => !matcher(node, ctx);
+}
+function isElement(tag) {
+  const want = tag?.toLowerCase();
+  return (node) => {
+    const el = asElement(node);
+    if (!el) return false;
+    return want === void 0 || el.tag.toLowerCase() === want;
+  };
+}
+var hasSingleElementChild = (node, ctx) => {
+  const el = asElement(node);
+  if (!el) return false;
+  return elementChildrenOf(el, ctx).length === 1;
+};
+function computed(partial) {
+  return (node, ctx) => {
+    const el = asElement(node);
+    if (!el) return false;
+    const full = ctx.computedOf(el) ?? el.computed;
+    return isStyleSuperset(full, partial, normalizer);
+  };
+}
+var VISUAL_PROPERTIES = /* @__PURE__ */ new Set([
+  "background",
+  "background-color",
+  "background-image",
+  "border-top-width",
+  "border-right-width",
+  "border-bottom-width",
+  "border-left-width",
+  "border-top-style",
+  "border-right-style",
+  "border-bottom-style",
+  "border-left-style",
+  "border-top-color",
+  "border-right-color",
+  "border-bottom-color",
+  "border-left-color",
+  "border-radius",
+  "box-shadow",
+  "outline",
+  "outline-width",
+  "outline-style",
+  "outline-color",
+  "text-shadow",
+  "filter",
+  "backdrop-filter",
+  "mix-blend-mode",
+  "opacity"
+]);
+var EMPTY_VISUAL_VALUES = /* @__PURE__ */ new Set([
+  "none",
+  "0",
+  "normal",
+  "transparent",
+  "rgba(0, 0, 0, 0)",
+  "initial",
+  "unset",
+  "auto"
+]);
+var hasOwnVisualStyle = (node, ctx) => {
+  const el = asElement(node);
+  if (!el) return false;
+  if (el.meta.hasOwnVisualStyle) return true;
+  const computedMap = ctx.computedOf(el) ?? el.computed;
+  const norm = normalizer.normalizeStyleMap(computedMap);
+  for (const block of norm.blocks.values()) {
+    for (const decl of block.decls.values()) {
+      if (!VISUAL_PROPERTIES.has(String(decl.property))) continue;
+      if (!EMPTY_VISUAL_VALUES.has(String(decl.value))) return true;
+    }
+  }
+  return false;
+};
+var hasRef = (node) => asElement(node)?.meta.hasRef ?? false;
+var hasEventHandlers = (node) => asElement(node)?.meta.hasEventHandlers ?? false;
+var hasDynamicChildren = (node) => asElement(node)?.meta.hasDynamicChildren ?? false;
+var hasDynamicClasses = (node) => asElement(node)?.classes.hasDynamic ?? false;
+var targetedByCombinator = (node, ctx) => {
+  const el = asElement(node);
+  if (!el) return false;
+  if (el.meta.targetedByCombinator) return true;
+  return ctx.selectors.targetedByCombinator(el.id);
+};
+
+// ../pattern-kit/src/ops.ts
+function idOf(ref) {
+  return typeof ref === "number" ? ref : ref.id;
+}
+function mergeStyle(target, source, style, onConflict = "abort") {
+  return {
+    op: "mergeStyle",
+    target: idOf(target),
+    source: source == null ? null : idOf(source),
+    style,
+    onConflict
+  };
+}
+function foldInheritedStyles(from, into, opts) {
+  const list = Array.isArray(into) ? into : [into];
+  return {
+    op: "foldInheritedStyles",
+    from: idOf(from),
+    into: list.map(idOf),
+    properties: opts?.only ?? "all-inherited",
+    conditions: opts?.conditions ?? "base"
+  };
+}
+function replaceWith(target, replacement) {
+  return { op: "replaceWith", target: idOf(target), replacement };
+}
+function removeNode(target) {
+  return { op: "removeNode", target: idOf(target) };
+}
+
+// ../pattern-kit/src/pattern.ts
+function camelToKebab(key) {
+  if (key.startsWith("--")) return key;
+  return key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`);
+}
+function plainToStyleMap(style) {
+  const decls = /* @__PURE__ */ new Map();
+  for (const [rawKey, rawValue] of Object.entries(style)) {
+    const prop = camelToKebab(rawKey);
+    for (const decl of normalizer.normalizeDeclaration(prop, String(rawValue), false)) {
+      decls.set(decl.property, decl);
+    }
+  }
+  const block = { condition: BASE_CONDITION, decls };
+  return { blocks: /* @__PURE__ */ new Map([[conditionKey(BASE_CONDITION), block]]) };
+}
+function asElement2(node) {
+  const n = node;
+  return n.kind === "element" ? n : null;
+}
+function metaFlag(flag) {
+  return (node) => Boolean(asElement2(node)?.meta[flag]);
+}
+var hasRawHtml = metaFlag("hasDangerousHtml");
+var affectsSelectorMatching = (node, ctx) => {
+  const el = asElement2(node);
+  if (!el) return false;
+  return ctx.selectors.reparentImpact(el.id).size > 0;
+};
+var FLATTEN_GUARDS = and(
+  not(hasRef),
+  not(hasEventHandlers),
+  not(hasDynamicChildren),
+  not(hasRawHtml),
+  not(targetedByCombinator),
+  not(affectsSelectorMatching)
+);
+function isFlattenCategory(category) {
+  return category.split("/", 1)[0] === "flatten";
+}
+function compileDeclarativeMatch(m) {
+  const parts = [isElement(m.tag)];
+  if (m.style) parts.push(computed(plainToStyleMap(m.style)));
+  if (m.onlyChild === "element") parts.push(hasSingleElementChild);
+  if (m.paintsNothing) parts.push(not(hasOwnVisualStyle));
+  if (m.where) {
+    const extra = Array.isArray(m.where) ? m.where : [m.where];
+    for (const w of extra) parts.push(w);
+  }
+  return and(...parts);
+}
+function compileMatch(match, category) {
+  if (typeof match === "function") return match;
+  const declarative = compileDeclarativeMatch(match ?? {});
+  const guarded = isFlattenCategory(category) ? and(declarative, FLATTEN_GUARDS) : declarative;
+  return (node, ctx) => guarded(node, ctx);
+}
+function pruneShadowed(sm, drop) {
+  const blocks = /* @__PURE__ */ new Map();
+  for (const [key, block] of sm.blocks) {
+    const decls = /* @__PURE__ */ new Map();
+    for (const [prop, decl] of block.decls) {
+      const filtered = (decl.shadowed ?? []).filter(
+        (o) => !(o.kind === "class" && drop.has(o.className))
+      );
+      const rest = { ...decl };
+      delete rest.shadowed;
+      const next = filtered.length > 0 ? { ...rest, shadowed: filtered } : rest;
+      decls.set(prop, next);
+    }
+    blocks.set(key, { condition: block.condition, decls });
+  }
+  return { blocks };
+}
+function compileFlattenInto(recipe) {
+  const childGains = recipe.childGains ? plainToStyleMap(recipe.childGains) : null;
+  const fold = recipe.foldInherited !== false;
+  return (ctx, rw) => {
+    const wrapper = ctx.node;
+    const child = ctx.onlyElementChild();
+    if (!child) return null;
+    const ops = [];
+    if (fold) ops.push(rw.foldInheritedStyles(wrapper, child, { conditions: "all" }));
+    if (childGains) ops.push(rw.mergeStyle(child, null, childGains, "source-wins"));
+    ops.push(rw.unwrap(wrapper));
+    return ops;
+  };
+}
+function compileRewrite(rewrite) {
+  if (typeof rewrite === "function") return rewrite;
+  if ("flattenInto" in rewrite) return compileFlattenInto(rewrite);
+  if ("rewriteClasses" in rewrite) {
+    const preserveOpaque = rewrite.preserveOpaque ?? true;
+    return (ctx, rw) => {
+      const next = rewrite.rewriteClasses(ctx.computed(), ctx);
+      if (!next) return null;
+      return [rw.setClassList(ctx.node, next, preserveOpaque)];
+    };
+  }
+  if ("dropClasses" in rewrite) {
+    const preserveOpaque = rewrite.preserveOpaque ?? true;
+    return (ctx, rw) => {
+      const drop = new Set(rewrite.dropClasses(ctx.computed(), ctx));
+      if (drop.size === 0) return null;
+      return [rw.setClassList(ctx.node, pruneShadowed(ctx.computed(), drop), preserveOpaque)];
+    };
+  }
+  const style = plainToStyleMap(rewrite.mergeStyle);
+  const onConflict = rewrite.onConflict ?? "abort";
+  return (ctx, rw) => [rw.mergeStyle(ctx.node, null, style, onConflict)];
+}
+function pattern(config) {
+  const matchFn = compileMatch(config.match, config.category);
+  const rewriteFn = compileRewrite(config.rewrite);
+  const spec = {
+    name: config.name,
+    category: config.category,
+    safety: config.safety,
+    priority: config.priority,
+    precondition: config.precondition,
+    doc: config.doc,
+    examples: config.examples,
+    evaluate(ctx, rw) {
+      if (!matchFn(ctx.node, ctx)) return null;
+      const ops = rewriteFn(ctx, rw);
+      if (!ops || ops.length === 0) return null;
+      return { ops };
+    }
+  };
+  return definePattern(spec);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  and,
+  computed,
+  createNormalizer,
+  definePattern,
+  emptyStyleMap,
+  foldInheritedStyles,
+  hasDynamicChildren,
+  hasDynamicClasses,
+  hasEventHandlers,
+  hasOwnVisualStyle,
+  hasRef,
+  hasSingleElementChild,
+  isElement,
+  isStyleSuperset,
+  mergeStyle,
+  normalizer,
+  not,
+  or,
+  pattern,
+  removeNode,
+  replaceWith,
+  targetedByCombinator
+});
+//# sourceMappingURL=pattern-kit.cjs.map