Spaces:
Running
Running
| """Building new YOOtheme layout, rather than only editing what is already there. | |
| The editor could read a layout, rewrite any prop and move whole sections, but it | |
| could not *make* anything: a new section was a clone of an existing one, and | |
| there was no way to add an element at all. This is the missing half. | |
| Two sources of truth, neither of them invented here: | |
| * the element shapes are YOOtheme's own — `type` plus a `props` dict, sections | |
| holding rows holding columns holding elements. Get the nesting wrong and the | |
| builder renders an empty band, so `place` refuses it rather than writing it. | |
| * the presets are real sections lifted whole from sites that shipped. A preset | |
| beats a constructor for anything with more than a couple of elements in it, | |
| which is why the catalogue leads with them. | |
| Everything returns a plain node. Nothing here writes; the caller splices and | |
| saves through the one write path, same as every other edit. | |
| """ | |
| import json | |
| from pathlib import Path | |
| import vocabulary | |
| PRESETS = Path(__file__).parent / "presets" | |
| # What may contain what. The builder's own contract, and the reason a section | |
| # full of elements with no column renders as nothing at all. | |
| CONTAINS = { | |
| "layout": {"section"}, | |
| "section": {"row"}, | |
| "row": {"column"}, | |
| # A column takes any element, and also a row — nested grids are ordinary | |
| # YOOtheme, which the shipped hero presets use for their button rows. What it | |
| # cannot hold is a section or another column. | |
| "column": None, | |
| } | |
| NOT_IN_COLUMN = {"section", "column", "layout"} | |
| WIDTHS = {1: ["1-1"], 2: ["1-2", "1-2"], 3: ["1-3", "1-3", "1-3"], | |
| 4: ["1-4", "1-4", "1-4", "1-4"]} | |
| def section(props=None, children=None): | |
| return {"type": "section", "props": props or {}, "children": children or []} | |
| def row(props=None, children=None): | |
| return {"type": "row", "props": props or {"gutter": "medium"}, "children": children or []} | |
| def column(width="1-1", props=None, children=None): | |
| props = dict(props or {}) | |
| props.setdefault("width_default", width) | |
| return {"type": "column", "props": props, "children": children or []} | |
| def headline(content, element="h2", style="heading-large"): | |
| return {"type": "headline", "props": {"content": content, | |
| "title_element": element, | |
| "title_style": style}} | |
| def text(content, cls=""): | |
| props = {"content": content} | |
| if cls: | |
| props["class"] = cls | |
| return {"type": "text", "props": props} | |
| def button(label, link="#", style="primary"): | |
| return {"type": "button", "props": {"content": label, "link": link, | |
| "button_style": style}} | |
| def image(src, alt=""): | |
| return {"type": "image", "props": {"image": src, "image_alt": alt}} | |
| def panel(title, content, style="card-default"): | |
| return {"type": "panel", "props": {"title": title, "content": content, | |
| "panel_style": style, "hover": True}} | |
| def divider(): | |
| return {"type": "divider", "props": {}} | |
| ELEMENTS = {"headline": headline, "text": text, "button": button, | |
| "image": image, "panel": panel, "divider": divider} | |
| def grid(columns, gutter="medium", widths=None): | |
| """A row of columns from a list of children-lists. Widths default to even.""" | |
| widths = widths or WIDTHS.get(len(columns), ["1-1"] * len(columns)) | |
| return row({"gutter": gutter}, | |
| [column(widths[i] if i < len(widths) else "1-1", children=kids) | |
| for i, kids in enumerate(columns)]) | |
| def element(kind, **props): | |
| """One element by name, with the constructor's own defaults.""" | |
| if kind not in ELEMENTS: | |
| raise ValueError(f"unknown element {kind!r} — have: {', '.join(sorted(ELEMENTS))}") | |
| make = ELEMENTS[kind] | |
| try: | |
| return make(**props) | |
| except TypeError as e: | |
| raise ValueError(f"{kind}: {e}") from None | |
| # ── presets ─────────────────────────────────────────────────────────────────── | |
| def _manifest(): | |
| path = PRESETS / "presets.manifest.json" | |
| if not path.exists(): | |
| return {} | |
| try: | |
| return json.loads(path.read_text()) | |
| except (ValueError, OSError): | |
| return {} | |
| def catalogue(): | |
| """Everything that can be built, described. This is what a builder needs to | |
| know before it starts, and it is generated from what is actually on disk — | |
| a preset listed but missing is worse than one that was never offered. | |
| `constructors` are what this module can build directly. `known` is every | |
| element proven by a real layout, with its real prop keys, which `edit_page` | |
| can write even where there is no constructor. `documented` is named by | |
| YOOtheme but never yet seen, so its slug is unverified — look for it, do not | |
| assume it.""" | |
| man = _manifest() | |
| out = {"elements": sorted(ELEMENTS), | |
| "constructors": sorted(ELEMENTS), | |
| "known": {k: vocabulary.props(k) for k in vocabulary.confirmed()}, | |
| "documented": sorted(vocabulary.documented()), | |
| "sections": [], "templates": []} | |
| for group, key in (("sections", "sections"), ("templates", "full_templates")): | |
| for entry in man.get(key) or []: | |
| if (PRESETS / entry.get("file", "")).exists(): | |
| out[group].append({"name": entry.get("name"), | |
| "category": entry.get("category", ""), | |
| "description": entry.get("description", "")}) | |
| return out | |
| def preset(name): | |
| """A preset section, fresh each time — callers mutate what they get back.""" | |
| man = _manifest() | |
| for key in ("sections", "full_templates"): | |
| for entry in man.get(key) or []: | |
| if entry.get("name") == name: | |
| path = PRESETS / entry["file"] | |
| if not path.exists(): | |
| raise KeyError(f"preset {name!r} is listed but its file is missing") | |
| return json.loads(path.read_text()) | |
| raise KeyError(f"no preset {name!r}") | |
| # ── placement ───────────────────────────────────────────────────────────────── | |
| def check(parent, node): | |
| """Whether `node` may live inside `parent`. Refusing here is the point. | |
| A headline dropped straight into a section is not an error YOOtheme reports | |
| — it renders nothing, and the operator is left looking at a blank band | |
| wondering which of their changes broke the page. | |
| """ | |
| if parent.get("type") not in CONTAINS: | |
| # A composite element — a button holding button_items, an accordion | |
| # holding panels, a gallery holding images. Its children are its own | |
| # contract, not this one's, and inventing a rule for an element we do not | |
| # model would reject layouts YOOtheme renders perfectly well. | |
| return True | |
| allowed = CONTAINS[parent["type"]] | |
| if allowed is None: # a column | |
| if node.get("type") in NOT_IN_COLUMN: | |
| raise ValueError(f"a {node.get('type')} cannot go inside a column") | |
| return True | |
| kind = node.get("type") | |
| if kind not in allowed: | |
| raise ValueError( | |
| f"a {kind} cannot go directly inside a {parent.get('type')} — " | |
| f"that holds {', '.join(sorted(allowed))}") | |
| return True | |
| def place(parent, node, index=None): | |
| """Insert a node into a parent, at the end unless told otherwise.""" | |
| check(parent, node) | |
| kids = parent.setdefault("children", []) | |
| kids.insert(len(kids) if index is None else max(0, min(index, len(kids))), node) | |
| return node | |
| def move(parent, from_index, to_index): | |
| """Reorder within one parent — the sibling move the section planner never | |
| covered, because it only ever rebuilt the top level.""" | |
| kids = parent.get("children") or [] | |
| if not 0 <= from_index < len(kids): | |
| raise ValueError(f"no child at index {from_index}") | |
| node = kids.pop(from_index) | |
| kids.insert(max(0, min(to_index, len(kids))), node) | |
| return node | |
| def wrap(node): | |
| """Give a bare element the row and column it needs to render. | |
| Convenience with a purpose: the common request is "add a button to this | |
| section", and the honest answer is that a button needs a column, so build | |
| the column rather than refusing the request. | |
| """ | |
| if node.get("type") == "section": | |
| return node | |
| if node.get("type") == "row": | |
| return section(children=[node]) | |
| if node.get("type") == "column": | |
| return section(children=[row(children=[node])]) | |
| return section(children=[row(children=[column(children=[node])])]) | |