syntaxmatrix 2.6.4.4__py3-none-any.whl → 3.0.1__py3-none-any.whl

syntaxmatrix/page_layout_contract.py

@@ -150,10 +150,32 @@ def _s(x: Any) -> str:
     return x.strip() if isinstance(x, str) else ""
 
 def _clean_ws(s: str) -> str:
-    s = s.replace("\x00", "")
+    """Single-line clean (titles, ids, etc.)."""
+    s = (s or "").strip()
     s = re.sub(r"\s+", " ", s).strip()
     return s
 
+
+def _clean_text_block(s: str) -> str:
+    """
+    Preserve new lines for body text.
+    - Normalise line endings
+    - Collapse repeated spaces/tabs *within a line*
+    - Keep paragraph breaks
+    """
+    s = (s or "")
+    s = s.replace("\r\n", "\n").replace("\r", "\n")
+
+    lines = []
+    for ln in s.split("\n"):
+        ln = re.sub(r"[ \t]{2,}", " ", ln).rstrip()
+        lines.append(ln)
+
+    out = "\n".join(lines).strip()
+    out = re.sub(r"\n{3,}", "\n\n", out)  # cap huge blank gaps
+    return out
+
+
 def _has_dangerous(s: str) -> bool:
     return bool(DANGEROUS_RE.search(s or ""))
 
@@ -284,7 +306,7 @@ def normalise_layout(
 
         # Strings
         s2["title"] = _clean_ws(_s(s2.get("title")))
-        s2["text"] = _clean_ws(_s(s2.get("text")))
+        s2["text"] = _clean_text_block(_s(s2.get("text")))
 
         # Items
         items = s2.get("items")
@@ -298,7 +320,7 @@ def normalise_layout(
             it2["id"] = _safe_id(_s(it2.get("id"))) or f"item_{sid}_{j+1}"
             it2["type"] = _safe_id(_s(it2.get("type"))) or "card"
             it2["title"] = _clean_ws(_s(it2.get("title")))
-            it2["text"] = _clean_ws(_s(it2.get("text")))
+            it2["text"] = _clean_text_block(_s(it2.get("text")))
             if "imageUrl" in it2:
                 it2["imageUrl"] = _clean_ws(_s(it2.get("imageUrl")))
             items2.append(it2)

syntaxmatrix/page_patch_publish.py

@@ -4,6 +4,76 @@ from typing import Any, Dict, Tuple, List, Optional
 from bs4 import BeautifulSoup
 
 
+_RICH_DROP_TAGS = {"script", "style", "iframe", "object", "embed", "link", "meta", "base"}
+
+def _safe_text_align(v: str) -> str:
+    v = (v or "").strip().lower()
+    if v == "centre":
+        v = "center"
+    return v if v in ("left", "center", "right", "justify") else ""
+
+def _sanitize_rich_fragment(html: str) -> str:
+    """
+    Best-effort sanitiser for rich text coming from the page editor.
+    Removes scripts/events and javascript/data URLs.
+    """
+    html = (html or "").strip()
+    if not html:
+        return ""
+
+    frag = BeautifulSoup(html, "html.parser")
+
+    # Drop dangerous container tags entirely
+    for t in frag.find_all(list(_RICH_DROP_TAGS)):
+        t.decompose()
+
+    # Scrub attributes
+    for tag in frag.find_all(True):
+        # remove inline on* handlers
+        for k in list(tag.attrs.keys()):
+            if k.lower().startswith("on"):
+                del tag.attrs[k]
+
+        # block javascript:/data: URLs
+        for url_attr in ("href", "src"):
+            if url_attr in tag.attrs:
+                v = str(tag.attrs.get(url_attr) or "").strip().lower()
+                if v.startswith("javascript:") or v.startswith("data:"):
+                    del tag.attrs[url_attr]
+
+        # scrub risky style content
+        if "style" in tag.attrs:
+            st = str(tag.attrs.get("style") or "")
+            low = st.lower()
+            if "expression(" in low or "javascript:" in low:
+                del tag.attrs["style"]
+            else:
+                # remove url(...) to avoid surprises
+                st = re.sub(r"url\s*\([^)]*\)", "", st, flags=re.IGNORECASE)
+                tag.attrs["style"] = st
+
+    return "".join(str(c) for c in frag.contents).strip()
+
+def _set_inner_html(tag, html: str):
+    tag.clear()
+    frag = BeautifulSoup(html or "", "html.parser")
+    for child in list(frag.contents):
+        tag.append(child)
+
+def _set_text_with_breaks(soup, tag, text: str):
+    """
+    Put plain text into an element but keep user newlines visible.
+    """
+    tag.clear()
+    text = text or ""
+    lines = text.splitlines()
+    for i, ln in enumerate(lines):
+        if i > 0:
+            tag.append(soup.new_tag("br"))
+        if ln:
+            tag.append(ln)
+
+
 _SECTION_BY_ID_RE = r'(<section\b[^>]*\bid="{sid}"[^>]*>)(.*?)(</section>)'
 _SECTION_OPEN_RE = re.compile(r"<section\b[^>]*\bid=['\"]([^'\"]+)['\"][^>]*>", re.IGNORECASE)
 
@@ -309,10 +379,24 @@ def _default_card_node(soup, it: Dict[str, Any]):
     row.append(h3)
     card.append(row)
 
-    p = soup.new_tag("p")
-    p["style"] = "margin-top:8px;"
-    p.string = it_text
-    card.append(p)
+    it_text_html = (it.get("textHtml") or "").strip()
+
+    # Body: prefer rich HTML if provided, otherwise plain text
+    if it_text_html:
+        body = soup.new_tag("div")
+        body["class"] = ["smx-rich"]
+        body["data-smx"] = "card-body"
+        body["style"] = "margin-top:8px;"
+        safe = _sanitize_rich_fragment(it_text_html)
+        if safe:
+            _set_inner_html(body, safe)
+        card.append(body)
+    else:
+        p = soup.new_tag("p")
+        p["data-smx"] = "card-text"
+        p["style"] = "margin-top:8px;"
+        _set_text_with_breaks(soup, p, it_text)
+        card.append(p)
 
     return card
 
@@ -363,11 +447,39 @@ def _patch_default_cards(sec, soup, items: List[Dict[str, Any]], cols: int) -> b
                 a.clear(); a.append(label); changed = True
             if a.get("href") != href:
                 a["href"] = href; changed = True
+            
+            # Open exported HTML results in a new tab (client docs assets)
+            href = str(it_href or "").strip()
+            auto_newtab = href.startswith("/docs/") and href.lower().endswith(".html")
+
+            open_new = bool(
+                auto_newtab
+                or it.get("openInNewTab")
+                or it.get("newTab")
+                or (str(it.get("target") or "").strip().lower() == "_blank")
+            )
+
+            if open_new:
+                if a.get("target") != "_blank":
+                    a["target"] = "_blank"; changed = True
+                # keep rel consistent
+                if a.get("rel") != "noopener":
+                    a["rel"] = "noopener"; changed = True
+            else:
+                if a.has_attr("target"):
+                    del a["target"]; changed = True
+                if a.has_attr("rel"):
+                    del a["rel"]; changed = True
+
             continue
 
-        # normal card patch (existing behaviour)
+        # normal card patch (existing behaviour)       
         it_title = (it.get("title") or "").strip()
         it_text  = (it.get("text") or "").strip()
+        it_text_html = (it.get("textHtml") or "").strip()
+        title_align = _safe_text_align(it.get("titleAlign") or it.get("title_align") or "")
+        body_align  = _safe_text_align(it.get("bodyAlign")  or it.get("body_align")  or "")
+       
         it_img   = (it.get("imageUrl") or "").strip()
         it_href  = _safe_href(it.get("href") or "")
         cta_lbl  = (it.get("ctaLabel") or "Read more").strip() or "Read more"
@@ -391,15 +503,65 @@ def _patch_default_cards(sec, soup, items: List[Dict[str, Any]], cols: int) -> b
 
         # title
         h = node.find(["h3", "h4"]) or node.find(["h2", "h3", "h4"])
-        if h and it_title and h.get_text(strip=True) != it_title:
-            h.clear(); h.append(it_title); changed = True
+        if h and it_title:
+            cur_title = h.get_text("\n", strip=False).strip()
+            if cur_title != it_title:
+                _set_text_with_breaks(soup, h, it_title)
+                changed = True
+            if title_align:
+                h["style"] = _merge_inline_style(h.get("style") or "", {"text-align": title_align})
+
+        # body (prefer rich)
+        body = (
+            node.find(attrs={"data-smx": "card-body"})
+            or node.find("div", class_=lambda c: c and "smx-rich" in str(c))
+            or node.find("p")
+        )
+
+        if it_text_html:
+            safe = _sanitize_rich_fragment(it_text_html)
+
+            # ensure we have a div container for rich HTML
+            if body is None or body.name != "div":
+                new_body = soup.new_tag("div")
+                new_body["class"] = ["smx-rich"]
+                new_body["data-smx"] = "card-body"
+                new_body["style"] = "margin-top:8px;"
+                if body is not None:
+                    body.replace_with(new_body)
+                else:
+                    node.append(new_body)
+                body = new_body
+                changed = True
+
+            cur_html = "".join(str(c) for c in body.contents).strip()
+            if safe and cur_html != safe:
+                _set_inner_html(body, safe)
+                changed = True
+
+        else:
+            # plain text path (keep newlines visible)
+            if body is None or body.name != "p":
+                new_p = soup.new_tag("p")
+                new_p["data-smx"] = "card-text"
+                new_p["style"] = "margin-top:8px;"
+                if body is not None:
+                    body.replace_with(new_p)
+                else:
+                    node.append(new_p)
+                body = new_p
+                changed = True
+
+            cur_text = body.get_text("\n", strip=False).strip()
+            if it_text and cur_text != it_text:
+                _set_text_with_breaks(soup, body, it_text)
+                changed = True
 
-        # text
-        p = node.find("p") or node.select_one(".mut")
-        if p and it_text and p.get_text(" ", strip=True) != it_text:
-            p.clear(); p.append(it_text); changed = True
+        # body alignment
+        if body_align and body is not None:
+            body["style"] = _merge_inline_style(body.get("style") or "", {"text-align": body_align})
 
-                # card CTA link (Read more) + alignment
+        # card CTA link (Read more) + alignment
         align = (it.get("ctaAlign") or it.get("cta_align") or "").strip().lower() or "left"
         if align == "centre":
             align = "center"
@@ -729,6 +891,104 @@ def _patch_testimonials(sec, soup, items: List[Dict[str, Any]], cols: int) -> bo
     grid["style"] = f"grid-template-columns:repeat({max(1, min(cols, 3))}, minmax(0,1fr));"
     return changed
 
+def _patch_gallery_items(sec, soup, items: List[Dict[str, Any]]) -> bool:
+    """
+    Patch a gallery section so image items render as true gallery tiles (figure.gimg)
+    compatible with compile_layout_to_html/gallery_js.
+    """
+    grid = sec.select_one(".grid")
+    if grid is None:
+        wrap = sec.select_one(".wrap") or sec
+        grid = soup.new_tag("div")
+        grid["class"] = ["grid"]
+        wrap.append(grid)
+
+    changed = False
+
+    # Only manage direct children of grid
+    children = [c for c in grid.find_all(True, recursive=False)]
+
+    def make_node(it: Dict[str, Any]):
+        it = it if isinstance(it, dict) else {}
+        it_type = (it.get("type") or "card").strip().lower()
+
+        title_plain = (it.get("title") or "").strip()
+        text_plain  = (it.get("text") or "").strip()
+
+        img_full  = (it.get("imageUrl") or "").strip()
+        img_thumb = (it.get("thumbUrl") or it.get("thumb_url") or "").strip()
+        src = img_thumb or img_full
+
+        # TRUE gallery image tile
+        if it_type == "image" and src:
+            fig = soup.new_tag("figure")
+            fig["class"] = ["gimg", "reveal"]
+            fig["data-item-type"] = "image"
+            fig["data-full"] = img_full or src
+            fig["data-title"] = title_plain
+            fig["data-caption"] = text_plain
+
+            im = soup.new_tag("img")
+            im["loading"] = "lazy"
+            im["decoding"] = "async"
+            im["src"] = src
+            im["data-full"] = img_full or src
+            im["alt"] = title_plain or "image"
+            fig.append(im)
+
+            if title_plain:
+                cap = soup.new_tag("figcaption")
+                cap.string = title_plain
+                fig.append(cap)
+
+            return fig
+
+        # Otherwise render as a normal card (content card inside rail)
+        node = _default_card_node(soup, it)
+        node["data-item-type"] = it_type or "card"
+        return node
+
+    n = len(items)
+
+    # Sync child count
+    if len(children) < n:
+        for i in range(len(children), n):
+            grid.append(make_node(items[i]))
+            changed = True
+        children = [c for c in grid.find_all(True, recursive=False)]
+
+    if len(children) > n:
+        for extra in children[n:]:
+            extra.decompose()
+            changed = True
+        children = [c for c in grid.find_all(True, recursive=False)]
+
+    # Patch / replace nodes if type mismatches
+    for i in range(n):
+        it = items[i] if isinstance(items[i], dict) else {}
+        want_type = (it.get("type") or "card").strip().lower()
+
+        node = children[i]
+        is_fig = (node.name == "figure" and "gimg" in (node.get("class") or []))
+        want_fig = (want_type == "image" and bool((it.get("thumbUrl") or it.get("thumb_url") or it.get("imageUrl") or "").strip()))
+
+        if want_fig and not is_fig:
+            node.replace_with(make_node(it))
+            changed = True
+            continue
+
+        if (not want_fig) and is_fig:
+            node.replace_with(make_node(it))
+            changed = True
+            continue
+
+        # For simplicity and correctness, refresh the node content by replacement
+        # (keeps behaviour consistent with compile_layout_to_html)
+        node.replace_with(make_node(it))
+        changed = True
+
+    return changed
+
 
 def _patch_items_in_section_by_id(
     html: str,
@@ -758,11 +1018,14 @@ def _patch_items_in_section_by_id(
         changed = _patch_testimonials(sec, soup, items, cols=cols)
         return str(soup), changed
 
+    if st == "gallery":
+        changed = _patch_gallery_items(sec, soup, items)
+        return str(soup), changed
+
     # default cards grid: features/gallery/cta/richtext/anything else that uses cards
     changed = _patch_default_cards(sec, soup, items, cols=cols)
     return str(soup), changed
 
-
 def _patch_hero(html: str, hero_section: Dict[str, Any]) -> Tuple[str, bool]:
     """
     Patch hero bg image + <h1> + lead paragraph inside the hero section.
@@ -1350,6 +1613,84 @@ def _patch_section_styles(existing_html: str, layout: dict) -> tuple[str, bool]:
     out = str(soup)
     return out, changed
 
+def _ensure_gallery_assets(layout: dict) -> tuple[dict, bool]:
+    """
+    Normalise gallery sections so that image additions behave like true gallery tiles.
+
+    Rule:
+    - In a section with type == "gallery", any item that has an image (imageUrl/thumbUrl/imgQuery)
+      but is typed as "card" (or missing type) is converted to type="image" by default.
+    - We preserve title/text, but keep them short (gallery tiles should be image-first).
+    """
+    changed = False
+    if not isinstance(layout, dict):
+        return layout, changed
+
+    secs = layout.get("sections")
+    if not isinstance(secs, list):
+        return layout, changed
+
+    def _has_img(it: dict) -> bool:
+        return bool(
+            (it.get("imageUrl") or "").strip()
+            or (it.get("thumbUrl") or it.get("thumb_url") or "").strip()
+            or (it.get("imgQuery") or "").strip()
+            or bool(it.get("needsImage"))
+        )
+
+    def _meaningful_text(s: str) -> bool:
+        s = (s or "").strip()
+        return len(s) >= 20  # heuristic: longer text suggests a content card
+
+    for sec in secs:
+        if not isinstance(sec, dict):
+            continue
+        if str(sec.get("type") or "").strip().lower() != "gallery":
+            continue
+
+        items = sec.get("items")
+        if not isinstance(items, list):
+            continue
+
+        for it in items:
+            if not isinstance(it, dict):
+                continue
+
+            it_type = str(it.get("type") or "").strip().lower()
+            if it_type == "image":
+                continue
+
+            if not _has_img(it):
+                continue
+
+            # If it looks like a content card (long text), leave it as card.
+            # Otherwise treat it as a gallery image tile.
+            title = (it.get("title") or "").strip()
+            text = (it.get("text") or "").strip()
+
+            if _meaningful_text(text):
+                # keep as card: someone likely wants a case-study style card inside the gallery rail
+                if not it_type:
+                    it["type"] = "card"
+                    changed = True
+                continue
+
+            it["type"] = "image"
+            changed = True
+
+            # Optional: keep gallery captions concise (avoid feature-card paragraphs)
+            if len(text) > 110:
+                it["text"] = text[:107].rstrip() + "…"
+
+            if len(title) > 60:
+                it["title"] = title[:57].rstrip() + "…"
+
+            # Ensure fields exist (helps downstream)
+            it.setdefault("thumbUrl", it.get("thumb_url", "") or "")
+            it.setdefault("imageUrl", it.get("imageUrl", "") or "")
+
+    return layout, changed
+
 
 def patch_page_publish(existing_html: str, layout: Dict[str, Any], page_slug: Optional[str] = None) -> Tuple[str, Dict[str, int]]:
     """
@@ -1360,6 +1701,11 @@ def patch_page_publish(existing_html: str, layout: Dict[str, Any], page_slug: Op
     stats = {"hero": 0, "sections": 0, "skipped": 0}
 
     if not existing_html or not isinstance(layout, dict):
+            # Inject Gallery rail + lightbox behaviour ONLY if this page has a gallery section
+        existing_html, gallery_injected = _ensure_gallery_assets(existing_html)
+        if gallery_injected:
+            stats["gallery_assets_injected"] = 1
+
         return existing_html, stats
 
     sections = layout.get("sections") if isinstance(layout.get("sections"), list) else []
@@ -1470,8 +1816,15 @@ def _remove_deleted_sections(existing_html: str, layout: Dict[str, Any], *, page
         if not sid:
             continue
 
-        # Only touch builder sections.
-        is_builder_section = sid.startswith("sec_") or sec.has_attr("data-section-type")
+        cls = [c for c in (sec.get("class") or []) if isinstance(c, str)]
+
+        # Treat generator sections as builder-owned even if the ID is custom.
+        is_builder_section = (
+            sid.startswith("sec_")
+            or sec.has_attr("data-section-type")
+            or ("sec" in cls)
+            or ("hero" in cls)
+        )
         if not is_builder_section:
             continue
 

syntaxmatrix/premium/__init__.py

@@ -1,10 +1,18 @@
 """Premium support.
 
 This package contains runtime plumbing for premium features (entitlements +
-plugin loading). The actual premium implementations should live in separate,
+plugin loading).
+
+Key idea:
+- FeatureGate reads a single entitlement dict from env/db/licence.json
+- ensure_premium_state() resolves trial + plan entitlements and writes them
+  into app_settings so the rest of the app can safely gate routes + navbar.
+
+Premium implementations (e.g. non-SQLite DB backends) should live in separate,
 private distributions.
 """
 
 from .gate import FeatureGate
+from .state import ensure_premium_state, PremiumState
 
-__all__ = ["FeatureGate"]
+__all__ = ["FeatureGate", "ensure_premium_state", "PremiumState"]

syntaxmatrix/premium/catalogue/__init__.py

@@ -0,0 +1,121 @@
+from __future__ import annotations
+
+import json
+import os
+from typing import Any, Dict, Optional, Tuple
+
+
+def _safe_json_loads(raw: str, default: Any) -> Any:
+    try:
+        return json.loads(raw)
+    except Exception:
+        return default
+
+
+def _read_json(path: str) -> Dict[str, Any]:
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except Exception:
+        return {}
+
+
+def _catalogue_dir() -> str:
+    return os.path.join(os.path.dirname(__file__))
+
+
+def load_index() -> Dict[str, Any]:
+    """Load catalogue index.json (safe, returns empty dict on failure)."""
+    return _read_json(os.path.join(_catalogue_dir(), "index.json"))
+
+
+def load_catalogue(version: Optional[str] = None) -> Tuple[Dict[str, Any], str]:
+    """Load a catalogue for the requested version.
+
+    Returns: (catalogue_dict, resolved_version)
+    """
+    idx = load_index()
+    resolved = (version or "").strip() or str(idx.get("default") or "").strip()
+    versions = idx.get("versions") if isinstance(idx.get("versions"), dict) else {}
+    fname = versions.get(resolved) if isinstance(versions, dict) else None
+
+    if not fname:
+        # Fall back to default file name if index is missing or version unknown.
+        fname = "catalogue.v1.json"
+
+    cat = _read_json(os.path.join(_catalogue_dir(), str(fname)))
+    # If the loaded file advertises a version, prefer that.
+    advertised = str(cat.get("version") or "").strip()
+    if advertised:
+        resolved = advertised
+    return cat, resolved
+
+
+def ui_labels(version: Optional[str] = None) -> Dict[str, Any]:
+    cat, _ = load_catalogue(version)
+    ui = cat.get("ui") if isinstance(cat.get("ui"), dict) else {}
+    labels = ui.get("labels") if isinstance(ui.get("labels"), dict) else {}
+    return labels if isinstance(labels, dict) else {}
+
+
+def resolve_entitlements(
+    *,
+    plan_id: str,
+    version: Optional[str] = None,
+    addons: Optional[list] = None,
+    custom_overrides: Optional[Dict[str, Any]] = None,
+) -> Dict[str, Any]:
+    """Resolve final entitlements from catalogue.
+
+    This keeps entitlements data-driven:
+    - base entitlements come from the plan in the catalogue
+    - optional add-ons apply deltas/overrides
+    - optional custom_overrides apply last
+    """
+    pid = (plan_id or "free").strip().lower() or "free"
+    cat, resolved_version = load_catalogue(version)
+
+    plans = cat.get("plans") if isinstance(cat.get("plans"), dict) else {}
+    p = plans.get(pid) if isinstance(plans, dict) else None
+    base = {}
+    if isinstance(p, dict) and isinstance(p.get("entitlements"), dict):
+        base = dict(p.get("entitlements") or {})
+
+    # Always stamp plan + version for UI/debugging.
+    base["plan"] = pid
+    base["entitlement_version"] = resolved_version
+
+    # Apply add-ons.
+    addons_list = addons if isinstance(addons, list) else []
+    if addons_list:
+        addons_def = cat.get("addons") if isinstance(cat.get("addons"), dict) else {}
+        for addon_id in addons_list:
+            aid = str(addon_id or "").strip()
+            if not aid:
+                continue
+            a = addons_def.get(aid) if isinstance(addons_def, dict) else None
+            if not isinstance(a, dict):
+                continue
+            delta = a.get("entitlements_delta") if isinstance(a.get("entitlements_delta"), dict) else {}
+            for k, v in (delta or {}).items():
+                # Support "+N" increment for numeric limits.
+                if isinstance(v, str) and v.strip().startswith("+"):
+                    try:
+                        inc = int(v.strip()[1:])
+                        cur = int(base.get(k) or 0)
+                        base[k] = cur + inc
+                        continue
+                    except Exception:
+                        pass
+                base[k] = v
+        base["addons"] = addons_list
+
+    # Apply overrides last.
+    if isinstance(custom_overrides, dict) and custom_overrides:
+        for k, v in custom_overrides.items():
+            if k in ("sig",):
+                continue
+            base[k] = v
+
+    return base