@blockbite/ui 1.0.0

package/dist/node_modules/@wordpress/block-editor/build-module/components/global-styles/use-global-styles-output.js

@@ -0,0 +1,418 @@
+import "../../../../blocks/build-module/store/index.js";
+import "@wordpress/element";
+import { getCSSRules as k } from "../../../../style-engine/build-module/index.js";
+import { privateApis as Z } from "@wordpress/components";
+import { scopeSelector as v, getBlockStyleVariationSelector as q, ROOT_BLOCK_SELECTOR as _, scopeFeatureSelectors as H, ROOT_CSS_PROPERTIES_SELECTOR as I, getResolvedValue as B, appendToSelector as Q, PRESET_METADATA as K } from "./utils.js";
+import { getBlockCSSSelector as W } from "./get-block-css-selector.js";
+import { getTypographyFontSizeValue as N } from "./typography-utils.js";
+import { setBackgroundStyleDefaults as tt } from "../../hooks/background.js";
+import "../../store/index.js";
+import { LAYOUT_DEFINITIONS as et } from "../../layouts/definitions.js";
+import { getValueFromObjectPath as w, setImmutably as ot } from "../../utils/object.js";
+import { unlock as st } from "../../lock-unlock.js";
+import { __EXPERIMENTAL_ELEMENTS as j, __EXPERIMENTAL_STYLE_PROPERTY as rt } from "../../../../blocks/build-module/api/constants.js";
+import { getCSSValueFromRawStyle as M } from "../../../../style-engine/build-module/styles/utils.js";
+import { getBlockSupport as nt } from "../../../../blocks/build-module/api/registration.js";
+const it = {
+  button: "wp-element-button",
+  caption: "wp-element-caption"
+}, at = {
+  __experimentalBorder: "border",
+  color: "color",
+  spacing: "spacing",
+  typography: "typography"
+}, {
+  kebabCase: D
+} = st(Z);
+function ct(t = "*", o = {}) {
+  return K.reduce((n, {
+    path: s,
+    cssVarInfix: i,
+    classes: r
+  }) => {
+    if (!r)
+      return n;
+    const l = w(o, s, []);
+    return ["default", "theme", "custom"].forEach((a) => {
+      l[a] && l[a].forEach(({
+        slug: c
+      }) => {
+        r.forEach(({
+          classSuffix: f,
+          propertyName: u
+        }) => {
+          const p = `.has-${D(c)}-${f}`, h = t.split(",").map((e) => `${e}${p}`).join(","), d = `var(--wp--preset--${i}--${D(c)})`;
+          n += `${h}{${u}: ${d} !important;}`;
+        });
+      });
+    }), n;
+  }, "");
+}
+function lt(t, o) {
+  const n = t.split(","), s = [];
+  return n.forEach((i) => {
+    s.push(`${o.trim()}${i.trim()}`);
+  }), s.join(", ");
+}
+const U = (t, o) => {
+  const n = {};
+  return Object.entries(t).forEach(([s, i]) => {
+    if (s === "root" || !o?.[s])
+      return;
+    const r = typeof i == "string";
+    if (r || Object.entries(i).forEach(([l, a]) => {
+      if (l === "root" || !o?.[s][l])
+        return;
+      const c = {
+        [s]: {
+          [l]: o[s][l]
+        }
+      }, f = R(c);
+      n[a] = [...n[a] || [], ...f], delete o[s][l];
+    }), r || i.root) {
+      const l = r ? i : i.root, a = {
+        [s]: o[s]
+      }, c = R(a);
+      n[l] = [...n[l] || [], ...c], delete o[s];
+    }
+  }), n;
+};
+function R(t = {}, o = "", n, s = {}, i = !1) {
+  const r = _ === o, l = Object.entries(rt).reduce((c, [f, {
+    value: u,
+    properties: p,
+    useEngine: h,
+    rootOnly: d
+  }]) => {
+    if (d && !r)
+      return c;
+    const e = u;
+    if (e[0] === "elements" || h)
+      return c;
+    const g = w(t, e);
+    if (f === "--wp--style--root--padding" && (typeof g == "string" || !n))
+      return c;
+    if (p && typeof g != "string")
+      Object.entries(p).forEach((E) => {
+        const [m, y] = E;
+        if (!w(g, [y], !1))
+          return;
+        const L = m.startsWith("--") ? m : D(m);
+        c.push(`${L}: ${M(w(g, [y]))}`);
+      });
+    else if (w(t, e, !1)) {
+      const E = f.startsWith("--") ? f : D(f);
+      c.push(`${E}: ${M(w(t, e))}`);
+    }
+    return c;
+  }, []);
+  return t.background && (t.background?.backgroundImage && (t.background.backgroundImage = B(t.background.backgroundImage, s)), !r && t.background?.backgroundImage?.id && (t = {
+    ...t,
+    background: {
+      ...t.background,
+      ...tt(t.background)
+    }
+  })), k(t).forEach((c) => {
+    if (r && (n || i) && c.key.startsWith("padding"))
+      return;
+    const f = c.key.startsWith("--") ? c.key : D(c.key);
+    let u = B(c.value, s);
+    f === "font-size" && (u = N({
+      size: u
+    }, s?.settings)), f === "aspect-ratio" && l.push("min-height: unset"), l.push(`${f}: ${u}`);
+  }), l;
+}
+function ft({
+  layoutDefinitions: t = et,
+  style: o,
+  selector: n,
+  hasBlockGapSupport: s,
+  hasFallbackGapSupport: i,
+  fallbackGapValue: r
+}) {
+  let l = "", a = "";
+  if (n === _ ? a = a || "0.5em" : r && (a = r), a && t && Object.values(t).forEach(({
+    className: c,
+    name: f,
+    spacingStyles: u
+  }) => {
+    f !== "flex" && f !== "grid" || u?.length && u.forEach((p) => {
+      const h = [];
+      if (p.rules && Object.entries(p.rules).forEach(([d, e]) => {
+        h.push(`${d}: ${e || a}`);
+      }), h.length) {
+        let d = "";
+        d = n === _ ? `:where(.${c}${p?.selector || ""})` : `:where(${n}.${c}${p?.selector || ""})`, l += `${d} { ${h.join("; ")}; }`;
+      }
+    });
+  }), n === _ && t) {
+    const c = ["block", "flex", "grid"];
+    Object.values(t).forEach(({
+      className: f,
+      displayMode: u,
+      baseStyles: p
+    }) => {
+      u && c.includes(u) && (l += `${n} .${f} { display:${u}; }`), p?.length && p.forEach((h) => {
+        const d = [];
+        if (h.rules && Object.entries(h.rules).forEach(([e, g]) => {
+          d.push(`${e}: ${g}`);
+        }), d.length) {
+          const e = `.${f}${h?.selector || ""}`;
+          l += `${e} { ${d.join("; ")}; }`;
+        }
+      });
+    });
+  }
+  return l;
+}
+const ut = ["border", "color", "dimensions", "spacing", "typography", "filter", "outline", "shadow", "background"];
+function T(t) {
+  if (!t)
+    return {};
+  const s = Object.entries(t).filter(([i]) => ut.includes(i)).map(([i, r]) => [i, JSON.parse(JSON.stringify(r))]);
+  return Object.fromEntries(s);
+}
+const pt = (t, o) => {
+  var n;
+  const s = [];
+  if (!t?.styles)
+    return s;
+  const i = T(t.styles);
+  return i && s.push({
+    styles: i,
+    selector: _,
+    // Root selector (body) styles should not be wrapped in `:root where()` to keep
+    // specificity at (0,0,1) and maintain backwards compatibility.
+    skipSelectorWrapper: !0
+  }), Object.entries(j).forEach(([r, l]) => {
+    t.styles?.elements?.[r] && s.push({
+      styles: t.styles?.elements?.[r],
+      selector: l,
+      // Top level elements that don't use a class name should not receive the
+      // `:root :where()` wrapper to maintain backwards compatibility.
+      skipSelectorWrapper: !it[r]
+    });
+  }), Object.entries((n = t.styles?.blocks) !== null && n !== void 0 ? n : {}).forEach(([r, l]) => {
+    var a;
+    const c = T(l);
+    if (l?.variations) {
+      const f = {};
+      Object.entries(l.variations).forEach(([u, p]) => {
+        var h, d;
+        f[u] = T(p), p?.css && (f[u].css = p.css);
+        const e = o[r]?.styleVariationSelectors?.[u];
+        Object.entries((h = p?.elements) !== null && h !== void 0 ? h : {}).forEach(([g, E]) => {
+          E && j[g] && s.push({
+            styles: E,
+            selector: v(e, j[g])
+          });
+        }), Object.entries((d = p?.blocks) !== null && d !== void 0 ? d : {}).forEach(([g, E]) => {
+          var m;
+          const y = v(e, o[g]?.selector), L = v(e, o[g]?.duotoneSelector), b = H(e, o[g]?.featureSelectors), P = T(E);
+          E?.css && (P.css = E.css), s.push({
+            selector: y,
+            duotoneSelector: L,
+            featureSelectors: b,
+            fallbackGapValue: o[g]?.fallbackGapValue,
+            hasLayoutSupport: o[g]?.hasLayoutSupport,
+            styles: P
+          }), Object.entries((m = E.elements) !== null && m !== void 0 ? m : {}).forEach(([A, V]) => {
+            V && j[A] && s.push({
+              styles: V,
+              selector: v(y, j[A])
+            });
+          });
+        });
+      }), c.variations = f;
+    }
+    o?.[r]?.selector && s.push({
+      duotoneSelector: o[r].duotoneSelector,
+      fallbackGapValue: o[r].fallbackGapValue,
+      hasLayoutSupport: o[r].hasLayoutSupport,
+      selector: o[r].selector,
+      styles: c,
+      featureSelectors: o[r].featureSelectors,
+      styleVariationSelectors: o[r].styleVariationSelectors
+    }), Object.entries((a = l?.elements) !== null && a !== void 0 ? a : {}).forEach(([f, u]) => {
+      u && o?.[r] && j[f] && s.push({
+        styles: u,
+        selector: o[r]?.selector.split(",").map((p) => j[f].split(",").map((d) => p + " " + d)).join(",")
+      });
+    });
+  }), s;
+}, gt = (t, o) => {
+  var n;
+  const s = [];
+  if (!t?.settings)
+    return s;
+  const i = (a) => {
+    let c = {};
+    return K.forEach(({
+      path: f
+    }) => {
+      const u = w(a, f, !1);
+      u !== !1 && (c = ot(c, f, u));
+    }), c;
+  }, r = i(t.settings), l = t.settings?.custom;
+  return (Object.keys(r).length > 0 || l) && s.push({
+    presets: r,
+    custom: l,
+    selector: I
+  }), Object.entries((n = t.settings?.blocks) !== null && n !== void 0 ? n : {}).forEach(([a, c]) => {
+    const f = i(c), u = c.custom;
+    (Object.keys(f).length > 0 || u) && s.push({
+      presets: f,
+      custom: u,
+      selector: o[a]?.selector
+    });
+  }), s;
+}, Vt = (t, o, n, s, i = !1, r = !1, l = void 0) => {
+  const a = {
+    blockStyles: !0,
+    layoutStyles: !0,
+    marginReset: !0,
+    presets: !0,
+    rootPadding: !0,
+    variationStyles: !1,
+    ...l
+  }, c = pt(t, o), f = gt(t, o), u = t?.settings?.useRootPaddingAwareAlignments, {
+    contentSize: p,
+    wideSize: h
+  } = t?.settings?.layout || {}, d = a.marginReset || a.rootPadding || a.layoutStyles;
+  let e = "";
+  return a.presets && (p || h) && (e += `${I} {`, e = p ? e + ` --wp--style--global--content-size: ${p};` : e, e = h ? e + ` --wp--style--global--wide-size: ${h};` : e, e += "}"), d && (e += ":where(body) {margin: 0;", a.rootPadding && u && (e += `padding-right: 0; padding-left: 0; padding-top: var(--wp--style--root--padding-top); padding-bottom: var(--wp--style--root--padding-bottom) }
+				.has-global-padding { padding-right: var(--wp--style--root--padding-right); padding-left: var(--wp--style--root--padding-left); }
+				.has-global-padding > .alignfull { margin-right: calc(var(--wp--style--root--padding-right) * -1); margin-left: calc(var(--wp--style--root--padding-left) * -1); }
+				.has-global-padding :where(:not(.alignfull.is-layout-flow) > .has-global-padding:not(.wp-block-block, .alignfull)) { padding-right: 0; padding-left: 0; }
+				.has-global-padding :where(:not(.alignfull.is-layout-flow) > .has-global-padding:not(.wp-block-block, .alignfull)) > .alignfull { margin-left: 0; margin-right: 0;
+				`), e += "}"), a.blockStyles && c.forEach(({
+    selector: g,
+    duotoneSelector: E,
+    styles: m,
+    fallbackGapValue: y,
+    hasLayoutSupport: L,
+    featureSelectors: b,
+    styleVariationSelectors: P,
+    skipSelectorWrapper: A
+  }) => {
+    if (b) {
+      const $ = U(b, m);
+      Object.entries($).forEach(([S, O]) => {
+        if (O.length) {
+          const C = O.join(";");
+          e += `:root :where(${S}){${C};}`;
+        }
+      });
+    }
+    if (E) {
+      const $ = {};
+      m?.filter && ($.filter = m.filter, delete m.filter);
+      const S = R($);
+      S.length && (e += `${E}{${S.join(";")};}`);
+    }
+    !i && (_ === g || L) && (e += ft({
+      style: m,
+      selector: g,
+      hasBlockGapSupport: n,
+      hasFallbackGapSupport: s,
+      fallbackGapValue: y
+    }));
+    const V = R(m, g, u, t, r);
+    if (V?.length) {
+      const $ = A ? g : `:root :where(${g})`;
+      e += `${$}{${V.join(";")};}`;
+    }
+    m?.css && (e += Y(m.css, `:root :where(${g})`)), a.variationStyles && P && Object.entries(P).forEach(([$, S]) => {
+      const O = m?.variations?.[$];
+      if (O) {
+        if (b) {
+          const x = U(b, O);
+          Object.entries(x).forEach(([F, G]) => {
+            if (G.length) {
+              const J = lt(F, S), X = G.join(";");
+              e += `:root :where(${J}){${X};}`;
+            }
+          });
+        }
+        const C = R(O, S, u, t);
+        C.length && (e += `:root :where(${S}){${C.join(";")};}`), O?.css && (e += Y(O.css, `:root :where(${S})`));
+      }
+    });
+    const z = Object.entries(m).filter(([$]) => $.startsWith(":"));
+    z?.length && z.forEach(([$, S]) => {
+      const O = R(S);
+      if (!O?.length)
+        return;
+      const x = `:root :where(${g.split(",").map((F) => F + $).join(",")}){${O.join(";")};}`;
+      e += x;
+    });
+  }), a.layoutStyles && (e = e + ".wp-site-blocks > .alignleft { float: left; margin-right: 2em; }", e = e + ".wp-site-blocks > .alignright { float: right; margin-left: 2em; }", e = e + ".wp-site-blocks > .aligncenter { justify-content: center; margin-left: auto; margin-right: auto; }"), a.presets && f.forEach(({
+    selector: g,
+    presets: E
+  }) => {
+    (_ === g || I === g) && (g = "");
+    const m = ct(g, E);
+    m.length > 0 && (e += m);
+  }), e;
+}, ht = (t, o) => {
+  if (t?.selectors && Object.keys(t.selectors).length > 0)
+    return t.selectors;
+  const n = {
+    root: o
+  };
+  return Object.entries(at).forEach(([s, i]) => {
+    const r = W(t, s);
+    r && (n[i] = r);
+  }), n;
+}, Ct = (t, o, n) => {
+  const s = {};
+  return t.forEach((i) => {
+    const r = i.name, l = W(i);
+    let a = W(i, "filter.duotone");
+    if (!a) {
+      const d = W(i), e = nt(i, "color.__experimentalDuotone", !1);
+      a = e && v(d, e);
+    }
+    const c = !!i?.supports?.layout || !!i?.supports?.__experimentalLayout, f = i?.supports?.spacing?.blockGap?.__experimentalDefault, u = o(r), p = {};
+    u?.forEach((d) => {
+      const e = n ? `-${n}` : "", g = `${d.name}${e}`, E = q(g, l);
+      p[g] = E;
+    });
+    const h = ht(i, l);
+    s[r] = {
+      duotoneSelector: a,
+      fallbackGapValue: f,
+      featureSelectors: Object.keys(h).length ? h : void 0,
+      hasLayoutSupport: c,
+      name: r,
+      selector: l,
+      styleVariationSelectors: u?.length ? p : void 0
+    };
+  }), s;
+};
+function Y(t, o) {
+  let n = "";
+  return !t || t.trim() === "" || t.split("&").forEach((i) => {
+    if (!i || i.trim() === "")
+      return;
+    if (!i.includes("{"))
+      n += `:root :where(${o}){${i.trim()}}`;
+    else {
+      const l = i.replace("}", "").split("{");
+      if (l.length !== 2)
+        return;
+      const [a, c] = l, f = a.match(/([>+~\s]*::[a-zA-Z-]+)/), u = f ? f[1] : "", p = f ? a.replace(u, "").trim() : a.trim();
+      let h;
+      p === "" ? h = o : h = a.startsWith(" ") ? v(o, p) : Q(o, p), n += `:root :where(${h})${u}{${c.trim()}}`;
+    }
+  }), n;
+}
+export {
+  Ct as getBlockSelectors,
+  ft as getLayoutStyles,
+  gt as getNodesWithSettings,
+  pt as getNodesWithStyles,
+  R as getStylesDeclarations,
+  Y as processCSSNesting,
+  Vt as toStyles
+};

package/dist/node_modules/@wordpress/block-editor/build-module/components/global-styles/utils.js

@@ -0,0 +1,190 @@
+import { getTypographyFontSizeValue as y } from "./typography-utils.js";
+import { getValueFromObjectPath as u } from "../../utils/object.js";
+import m from "../../../../compose/build-module/hooks/use-viewport-match/index.js";
+import { getCSSValueFromRawStyle as h } from "../../../../style-engine/build-module/styles/utils.js";
+const w = "body", I = ":root", S = [{
+  path: ["color", "palette"],
+  valueKey: "color",
+  cssVarInfix: "color",
+  classes: [{
+    classSuffix: "color",
+    propertyName: "color"
+  }, {
+    classSuffix: "background-color",
+    propertyName: "background-color"
+  }, {
+    classSuffix: "border-color",
+    propertyName: "border-color"
+  }]
+}, {
+  path: ["color", "gradients"],
+  valueKey: "gradient",
+  cssVarInfix: "gradient",
+  classes: [{
+    classSuffix: "gradient-background",
+    propertyName: "background"
+  }]
+}, {
+  path: ["color", "duotone"],
+  valueKey: "colors",
+  cssVarInfix: "duotone",
+  valueFunc: ({
+    slug: t
+  }) => `url( '#wp-duotone-${t}' )`,
+  classes: []
+}, {
+  path: ["shadow", "presets"],
+  valueKey: "shadow",
+  cssVarInfix: "shadow",
+  classes: []
+}, {
+  path: ["typography", "fontSizes"],
+  valueFunc: (t, e) => y(t, e),
+  valueKey: "size",
+  cssVarInfix: "font-size",
+  classes: [{
+    classSuffix: "font-size",
+    propertyName: "font-size"
+  }]
+}, {
+  path: ["typography", "fontFamilies"],
+  valueKey: "fontFamily",
+  cssVarInfix: "font-family",
+  classes: [{
+    classSuffix: "font-family",
+    propertyName: "font-family"
+  }]
+}, {
+  path: ["spacing", "spacingSizes"],
+  valueKey: "size",
+  cssVarInfix: "spacing",
+  valueFunc: ({
+    size: t
+  }) => t,
+  classes: []
+}];
+function j() {
+  return m("medium", "<") ? {} : {
+    popoverProps: {
+      placement: "left-start",
+      // For non-mobile, inner sidebar width (248px) - button width (24px) - border (1px) + padding (16px) + spacing (20px)
+      offset: 259
+    }
+  };
+}
+function E(t, e, s, n, o) {
+  const r = [u(t, ["blocks", e, ...s]), u(t, s)];
+  for (const i of r)
+    if (i) {
+      const c = ["custom", "theme", "default"];
+      for (const f of c) {
+        const a = i[f];
+        if (a) {
+          const p = a.find((g) => g[n] === o);
+          if (p)
+            return p;
+        }
+      }
+    }
+}
+function V(t, e, s, [n, o]) {
+  const r = S.find((c) => c.cssVarInfix === n);
+  if (!r)
+    return s;
+  const i = E(t.settings, e, r.path, "slug", o);
+  if (i) {
+    const {
+      valueKey: c
+    } = r, f = i[c];
+    return d(t, e, f);
+  }
+  return s;
+}
+function x(t, e, s, n) {
+  var o;
+  const r = (o = u(t.settings, ["blocks", e, "custom", ...n])) !== null && o !== void 0 ? o : u(t.settings, ["custom", ...n]);
+  return r ? d(t, e, r) : s;
+}
+function d(t, e, s) {
+  if (!s || typeof s != "string")
+    if (typeof s?.ref == "string") {
+      if (s = u(t, s.ref), !s || s?.ref)
+        return s;
+    } else
+      return s;
+  const n = "var:", o = "var(--wp--", r = ")";
+  let i;
+  if (s.startsWith(n))
+    i = s.slice(n.length).split("|");
+  else if (s.startsWith(o) && s.endsWith(r))
+    i = s.slice(o.length, -r.length).split("--");
+  else
+    return s;
+  const [c, ...f] = i;
+  return c === "preset" ? V(t, e, s, f) : c === "custom" ? x(t, e, s, f) : s;
+}
+function l(t, e) {
+  if (!t || !e)
+    return e;
+  const s = t.split(","), n = e.split(","), o = [];
+  return s.forEach((r) => {
+    n.forEach((i) => {
+      o.push(`${r.trim()} ${i.trim()}`);
+    });
+  }), o.join(", ");
+}
+function K(t, e) {
+  if (!t || !e)
+    return;
+  const s = {};
+  return Object.entries(e).forEach(([n, o]) => {
+    typeof o == "string" && (s[n] = l(t, o)), typeof o == "object" && (s[n] = {}, Object.entries(o).forEach(([r, i]) => {
+      s[n][r] = l(t, i);
+    }));
+  }), s;
+}
+function z(t, e) {
+  return t.includes(",") ? t.split(",").map((o) => o + e).join(",") : t + e;
+}
+function C(t, e) {
+  const s = `.is-style-${t}`;
+  if (!e)
+    return s;
+  const n = /((?::\([^)]+\))?\s*)([^\s:]+)/, o = (i, c, f) => c + f + s;
+  return e.split(",").map((i) => i.replace(n, o)).join(",");
+}
+function F(t, e) {
+  if (!t || !e || !Array.isArray(e))
+    return t;
+  const s = e.find((n) => n?.name === t);
+  return s?.href ? s?.href : t;
+}
+function O(t, e) {
+  if (!t || !e)
+    return t;
+  if (typeof t != "string" && t?.ref) {
+    const s = h(u(e, t.ref));
+    return s?.ref ? void 0 : s === void 0 ? t : s;
+  }
+  return t;
+}
+function A(t, e) {
+  if (!t || !e)
+    return t;
+  const s = O(t, e);
+  return s?.url && (s.url = F(s.url, e?._links?.["wp:theme-file"])), s;
+}
+export {
+  S as PRESET_METADATA,
+  w as ROOT_BLOCK_SELECTOR,
+  I as ROOT_CSS_PROPERTIES_SELECTOR,
+  z as appendToSelector,
+  C as getBlockStyleVariationSelector,
+  O as getResolvedRefValue,
+  F as getResolvedThemeFilePath,
+  A as getResolvedValue,
+  d as getValueFromVariable,
+  K as scopeFeatureSelectors,
+  l as scopeSelector,
+  j as useToolsPanelDropdownMenuProps
+};

package/dist/node_modules/@wordpress/block-editor/build-module/components/gradients/use-gradient.js

@@ -0,0 +1,9 @@
+import "@wordpress/element";
+import "../../store/index.js";
+function t(e) {
+  if (e)
+    return `has-${e}-gradient-background`;
+}
+export {
+  t as __experimentalGetGradientClass
+};