Frontend Livingdoc
A frontend site content editing tool built in top of the LivingDocs engine., (*1)
Takes the lead from some of the work from https://github.com/wolfv/silverstripe-livingdocsfield
and https://github.com/guru-digital/frontend-admin, (*2)
Overview
This module allows you to edit structured HTML components from the frontend of the site. These
components can be defined with editable regions allowing content "directives" to be inserted using, (*3)
- WYSIWYG html editing
- Raw html editing
- Image selection
- Embedded items (using shortcodes)
- Containers - lists of other components
Components can be moved around the page and nested inside others, meaning content authors can
define full page structures in-place without needing convoluted CMS managed object structures., (*4)
Getting started
The module ships with the LivingPage
page type that can be created in the CMS. After creation, click the
Edit this page in-place
link to start modifying the page on the frontend of the site., (*5)
To enable global global shortcode configuration that can be added on all pages, add the following
configuration (depending on whether you're using multisites or not), (*6)
---
Name: componentpage_config
---
SilverStripe\SiteConfig\SiteConfig:
extensions:
- Symbiote\Frontend\LivingPage\Extension\LivingPageSettingsExtension
Page templates
By default the ComponentPage will render within the global page layout defined for
your site. To take full control of rendering the whole page, define a top level
templates/ComponentPage.ss
file that removes everything from the body
tag except the $Layout keyword., (*7)
To make this futher configurable by users, set the ComponentPage.allow_full_page_mode: true
config
property to allow editors to select to control the full page layout,
then change your ComponentPage.ss
template to check whether the $FullPageMode variable
is set when determining whether to only output the $Layout keyword., (*8)
Symbiote\Frontend\LivingPage\Page\ComponentPage:
allow_full_page_mode: true
<% if $FullPageMode %>
$Layout
<% else %>
<header>
<nav><etc></nav>
</header>
$Layout
<% end_if %>
Note: to properly make use of re-usable components, you'll likely want
to define either some shortcodes to output repeatable parts of the site (see the ShortcodeMenu
example) and
wrap them in PageComponent objects via the CMS, or make use of the User Templates
module and define these templates directly in the CMS too. See below for more
on components, (*9)
CMS capabilities
From the CMS you can define several things to help the page editing process, (*10)
Shortcodes for embedding content in pages
These can be configured on the SiteConfig, or Site object for Multisites users, which will cascade throughout that site. Additional shortcodes can be specified on a per-page basis; these will override any defined at a global level. Specify a key value pair, where the 'key' is the label shown to the user, and the value is the shortcode to output. Note that users may add attributes for the shortcode from the frontend of the site., (*11)
-
livingpage_childlist
- displays the list of child items of a page (uses the 'current' page as the default)
-
livingpage_show_field
- shows the fields of an object (current page is the default). Supports resolution of
subfields and parameters
- `[livingpage_show_field field="OriginalPublishDate.format" args="Y/m/d"]
Adding new shortcodes to a system is the normal SilverStripe method, eg, (*12)
ShortcodeParser::get('default')->register('listing', array('PageShortcodes', 'listing_content'));
, (*13)
On the frontend of the site, shortcodes are added using the "Embed" component., (*14)
ComponentPageStructure
To provide some structure to pages, you can define a "Component Page Structure" in the CMS at admin/componentpage. When creating this structure, you can choose an existing Component Page to extract the content structure from., (*15)
Then, when you create a Component Page object in the Site Tree, you can choose the template structure to provide the initial content., (*16)
Page Component and Compound Component
Creating new components in the CMS is somewhat more straight forward than in a design file. From the
Component pages section create a new Page Component, (*17)
- The title is what users see in the toolbar
- A name is auto generated
- The 'group' is where it is displayed in the toolbar
- The markup is HTML with additional directives (see below) for highlighting editable areas
In many cases it may be simpler to create re-usable components from existing structures defined on
a page. To do this, create a new Compound component. The initial fields have the same
meaning as the Page component; however the markup should be copied from a set of components.
Go to the component page, select a container of some sort, and click ctrl+c. (You'll see a small notice
in the bottom right corner). Paste that into the markup area., (*18)
Compound Component
Image Paste
You can paste clipboard images in a few different contexts;, (*19)
- When editing in a wysiwyg paragraph, a new image is inserted as a sibling component
- When an existing image is selected, it will replace that image
- When a container is selected, a new image is inserted at the end of that container
Custom designs
The module comes with a base "design" which is a set of components defined in JavaScript
that define the HTML structure of those components, as well as which parts of those components are
editable., (*20)
Components are made up of plain HTML, with a few specific directive
attributes that indicate to
livingdocs the editable areas of the structure. In addition to the HTML structure, components may have
componentProperties
applied to them, which are surfaced as CSS classes, as well as arbitrary data
fields.
One specific data
field is the data_attributes
map, which is applied as attributes against the element., (*21)
An example component:, (*22)
{
"name": "image",
"html": "<figure>\n\
<img doc-image=\"image\" class=\"img-responsive\">\n\
<figcaption doc-editable=\"caption\">\n\
Caption.\n\
</figcaption>\n</figure>",
"label": "Image"
}
The key points are that, (*23)
- The top level element (
<figure>
) is the element that would have any css classes applied to it
- There are two directives used;
doc-image
and doc-editable
- The
html
for the component can use nested elements and directives
Creating a new design
Assuming the default base bootstrap-design.js file is used, you can simply update
those definitions by iterating the design object;, (*24)
$(document).on('updateLivingdocsDesign', function (e, design) { });
The design.components
collection can then be iterated to change the existing definitions, or
have new definitions pushed onto its list., (*25)
To specify your own custom design, you may like to start with the bootstrap design and update it,
then bind it into configuration via, (*26)
---
Name: custom_designs
---
Symbiote\Frontend\LivingPage\Extension\LivingPageExtension:
living_designs:
my_theme_name: 'path/to/my/design.js'
Directives
The page editor supports several directive types, (*27)
-
doc-editable
: A WYSIWYG editor that provides in-place editing of content, with simple formatting options and
content insertion (link) plugins.
-
doc-image
: In-place image insertion
-
doc-container
: Allows the definition of an area that can have multiple child components inserted. For example, a
split-panel
component may have two 'div' elements, each with their own children, which would be flagged by having
a separate container in each.
<div class="col-md-6" doc-container="left-column"></div><div class="col-md-6" doc-container="right-column"></div>
-
doc-html
: Raw HTML editing using ACE editor. A special markdown component exists that allows the use of
markdown for simpler content entry.
-
doc-embeditem
: A SilverStripe only directive that allows the embedding of content that is sourced from a
code-defined shortcode. These must be created as a normal SilverStripe PHP-based shortcode, and configured to be
usable on the page.
Component groups
To simplify the interface, components can be grouped together under a common heading. See the groups
key in the
design file, (*28)
Pre-defined component structures
In some cases it is desireable to always have a specific tree of components automatically created when a specific
type of component is created. An example of this is a table
component; it is almost always going to be the case that
creating a <table>
should also have headers and rows created., (*29)
There are two mechanisms for defining these, both of which use the same internal structure, (*30)
-
prefilledComponents
: when the component of a particular type is created, the child type structure is automatically
created. For example, table
automatically has a tablehead
and tablebody
child containers populated
-
structures
: Creates a new dropdown in the UI that allows the selection of a named custom structure. For example, a
Content section
structure, in a bootstrap design, is a section
component filled with a row
component, filled with
column
component, filled with a p
component.
Building new bundles
- cd vendor/nyeholt/silverstripe-frontend-livingdoc/app
- yarn install
- yarn watch
Limitations
The components in the current implemented design is based on Bootstrap 4, with the available components
all based on a specific implementation that I needed at the time., (*31)
You can hook into the updateLivingdocsDesign JS event and change things there
prior to it being loaded., (*32)
Key API parts
Get the current selected component, (*33)
LivingDocState.activeComponent
, (*34)
Future work
- Better migration of changed component structures