#custom elements | Explore Tumblr posts and blogs

jcmarchi · 2 months ago

Text

6 Best Custom Gutenberg Blocks Plugins for WordPress — Speckyboy

New Post has been published on https://thedigitalinsider.com/6-best-custom-gutenberg-blocks-plugins-for-wordpress-speckyboy/

6 Best Custom Gutenberg Blocks Plugins for WordPress — Speckyboy

One of the most promising aspects of the Gutenberg block editor is the ability to add your own custom blocks. They can consist of just about any type of formatted content or functionality you can imagine.

And while you can certainly build your own custom blocks, sometimes that’s a bit like reinventing the wheel. This is especially the case when you want to add a common element such as a testimonial, post listing, or timeline. Most likely, these blocks already exist and can be easily added to your website.

Since Gutenberg’s inclusion in WordPress core, the developer community has released a number of different block plugins. Most tend to include a collection of blocks that could come in handy while building your site.

Today, we’ll introduce you to some of the top custom block collections available for WordPress. Let’s get started!

WordPress.com vs. WordPress.org – What’s the difference?

We get this question all the time, and we’re happy to help.

WordPress.org is the most powerful website building software on the web. You will need to find a hosting provider if you want that site online.

WordPress.com is our preferred hosting provider for medium-large traffic websites.

If you want to know why WordPress.com is our preferred host for ambitious passion projects and large website projects, read our review:

Ultimate Addons for Gutenberg includes 20+ custom blocks that cover a wide range of use cases. When it comes to layout, the Advanced Columns block lets you create a highly customized multicolumn row.

There are also blocks for adding Google Maps, icons, CTAs, post carousels, and more. That’s just scratching the surface of what this free plugin can do.

Backed by GoDaddy, CoBlocks is a free WordPress plugin that supercharges Gutenberg. While it offers a number of handy custom blocks (accordion, alert, hero, logos, masonry gallery, pricing table, etc.), its big selling point is in page layout.

Offering a more page builder-like experience, rows, and columns can be dragged to size and customized for responsive layouts. Typography is also highly-tweakable as well.

EditorsKit is a bit different than the other plugins in this collection, as it’s more about extending the blocks already included in Gutenberg. The rich text formatting features allow you to further style your content or wipe out all custom styles with a single click. You can also control the visibility of blocks based on device, login state, or even custom field values.

In addition, there are a ton of productivity tweaks, like support for markdown, code editor syntax highlighting, and the ability to import or export specific blocks. With so many goodies, it may just make Gutenberg feel like a completely different experience.

Kadence Blocks offers a dozen custom blocks that cover common needs. Included are row layouts, advanced galleries, tabs, info boxes, and testimonials – among others.

It also aims to solve one of the more frustrating issues with Gutenberg – the editor’s width on the back end. The plugin contains preset widths that enable content creators to get a better representation of what pages will look like on the front end.

With an aim to both speed up content creation and add different content types, Gutenberg Blocks and Template Library is a compelling option. Much like Atomic Blocks above, the included Section block offers a number of pre-designed templates and layouts.

There are also several customizable elements such as Google Maps, post grids, author info, and a block for Font Awesome icons.

Sure, Advanced Gutenberg comes packed with several custom blocks (post sliders, WooCommerce products, advanced tables, advanced lists, etc.). Those are all nice and handy. But the really interesting feature here is the ability to create “edition” profiles, which allow you to turn blocks on or off for specific users or user roles.

For example, if you only want administrators to have access to the Column Manager block, you can easily set it up. This helps to ensure that lower-level users don’t wreak havoc on your designs.

Get Some New Building Blocks

The default blocks that come with Gutenberg are useful and are constantly being refined. But to create a true page-building experience, you’ll want to add some custom elements.

That’s where the plugins above can help take your website to greater heights. Not only can you add different types of functionality and content, but you can also take greater charge of the editor as a whole.

The bottom line is that if you’re going to use Gutenberg for complex page layouts, you might as well go all in. These plugins will help you do just that.

Read more articles by Eric Karkovack

1 note · View note

jcmarchi · 11 months ago

Text

HTML Web Components Make Progressive Enhancement and CSS Encapsulation Easier!

New Post has been published on https://thedigitalinsider.com/html-web-components-make-progressive-enhancement-and-css-encapsulation-easier/

HTML Web Components Make Progressive Enhancement and CSS Encapsulation Easier!

I have to thank Jeremy Keith and his wonderfully insightful article from late last year that introduced me to the concept of HTML Web Components. This was the “a-ha!” moment for me:

When you wrap some existing markup in a custom element and then apply some new behaviour with JavaScript, technically you’re not doing anything you couldn’t have done before with some DOM traversal and event handling. But it’s less fragile to do it with a web component. It’s portable. It obeys the single responsibility principle. It only does one thing but it does it well.

Until then, I’d been under the false assumption that all web components rely solely on the presence of JavaScript in conjunction with the rather scary-sounding Shadow DOM. While it is indeed possible to author web components this way, there is yet another way. A better way, perhaps? Especially if you, like me, advocate for progressive enhancement. HTML Web Components are, after all, just HTML.

While it’s outside the exact scope of what we’re discussing here, Any Bell has a recent write-up that offers his (excellent) take on what progressive enhancement means.

Let’s look at three specific examples that show off what I think are the key features of HTML Web Components — CSS style encapsulation and opportunities for progressive enhancement — without being forced to depend on JavaScript to work out of the box. We will most definitely use JavaScript, but the components ought to work without it.

The examples can all be found in my Web UI Boilerplate component library (built using Storybook), along with the associated source code in GitHub.

Example 1: <webui-disclosure>

Live demo

I really like how Chris Ferdinandi teaches building a web component from scratch, using a disclosure (show/hide) pattern as an example. This first example extends his demo.

Let’s start with the first-class citizen, HTML. Web components allow us to establish custom elements with our own naming, which is the case in this example with a <webui-disclosure> tag we’re using to hold a <button> designed to show/hide a block of text and a <div> that holds the <p> of text we want to show and hide.

<webui-disclosure data-bind-escape-key data-bind-click-outside > <button type="button" class="button button--text" data-trigger hidden > Show / Hide </button> <div data-content> <p>Content to be shown/hidden.</p> </div> </webui-disclosure>

If JavaScript is disabled or doesn’t execute (for any number of possible reasons), the button is hidden by default — thanks to the hidden attribute on it— and the content inside of the div is simply displayed by default.

Nice. That’s a really simple example of progressive enhancement at work. A visitor can view the content with or without the <button>.

I mentioned that this example extends Chris Ferdinandi’s initial demo. The key difference is that you can close the element either by clicking the keyboard’s ESC key or clicking anywhere outside the element. That’s what the two [data-attribute]s on the <webui-disclosure tag are for.

We start by defining the custom element so that the browser knows what to do with our made-up tag name:

customElements.define('webui-disclosure', WebUIDisclosure);

Custom elements must be named with a dashed-ident, such as <my-pizza> or whatever, but as Jim Neilsen notes, by way of Scott Jehl, that doesn’t exactly mean that the dash has to go between two words.

I typically prefer using TypeScript for writing JavaScript to help eliminate stupid errors and enforce some degree of “defensive” programming. But for the sake of simplicity, the structure of the web component’s ES Module looks like this in plain JavaScript:

default class WebUIDisclosure extends HTMLElement constructor() super(); this.trigger = this.querySelector('[data-trigger]'); this.content = this.querySelector('[data-content]'); this.bindEscapeKey = this.hasAttribute('data-bind-escape-key'); this.bindClickOutside = this.hasAttribute('data-bind-click-outside'); if (!this.trigger setupA11y() // Add ARIA props/state to button. // Handle constructor() event listeners. handleEvent(e) // 1. Toggle visibility of content. // 2. Toggle ARIA expanded state on button. // Handle event listeners which are not part of this Web Component. connectedCallback() document.addEventListener('keyup', (e) => // Handle ESC key. ); document.addEventListener('click', (e) => // Handle clicking outside. ); disconnectedCallback() // Remove event listeners.

Are you wondering about those event listeners? The first one is defined in the constructor() function, while the rest are in the connectedCallback() function. Hawk Ticehurst explains the rationale much more eloquently than I can.

This JavaScript isn’t required for the web component to “work” but it does sprinkle in some nice functionality, not to mention accessibility considerations, to help with the progressive enhancement that allows the <button> to show and hide the content. For example, JavaScript injects the appropriate aria-expanded and aria-controls attributes enabling those who rely on screen readers to understand the button’s purpose.

That’s the progressive enhancement piece to this example.

For simplicity, I have not written any additional CSS for this component. The styling you see is simply inherited from existing global scope or component styles (e.g., typography and button).

However, the next example does have some extra scoped CSS.

Example 2: <webui-tabs>

That first example lays out the progressive enhancement benefits of HTML Web Components. Another benefit we get is that CSS styles are encapsulated, which is a fancy way of saying the CSS doesn’t leak out of the component. The styles are scoped purely to the web component and those styles will not conflict with other styles applied to the current page.

Let’s turn to a second example, this time demonstrating the style encapsulating powers of web components and how they support progressive enhancement in user experiences. We’ll be using a tabbed component for organizing content in “panels” that are revealed when a panel’s corresponding tab is clicked — the same sort of thing you’ll find in many component libraries.

Live demo

Starting with the HTML structure:

<webui-tabs> <div data-tablist> <a href="#tab1" data-tab>Tab 1</a> <a href="#tab2" data-tab>Tab 2</a> <a href="#tab3" data-tab>Tab 3</a> </div> <div id="tab1" data-tabpanel> <p>1 - Lorem ipsum dolor sit amet consectetur.</p> </div> <div id="tab2" data-tabpanel> <p>2 - Lorem ipsum dolor sit amet consectetur.</p> </div> <div id="tab3" data-tabpanel> <p>3 - Lorem ipsum dolor sit amet consectetur.</p> </div> </webui-tabs>

You get the idea: three links styled as tabs that, when clicked, open a tab panel holding content. Note that each [data-tab] in the tab list targets an anchor link matching a tab panel ID, e.g., #tab1, #tab2, etc.

We’ll look at the style encapsulation stuff first since we didn’t go there in the last example. Let’s say the CSS is organized like this:

webui-tabs [data-tablist] /* Default styles without JavaScript */ [data-tab] /* Default styles without JavaScript */ [role='tablist'] /* Style role added by JavaScript */ [role='tab'] /* Style role added by JavaScript */ [role='tabpanel'] /* Style role added by JavaScript */

See what’s happening here? We have two style rules — [data-tablist] and [data-tab] — that contain the web component’s default styles. In other words, these styles are there regardless of whether JavaScript loads or not. Meanwhile, the other three style rules are selectors that are injected into the component as long as JavaScript is enabled and supported. This way, the last three style rules are only applied if JavaScript plops the **role** attribute on those elements in the HTML. Right there, we’re already supplying a touch of progressive enhancement by setting styles only when JavasScript is needed.

All these styles are fully encapsulated, or scoped, to the <webui-tabs> web component. There is no “leakage” so to speak that would bleed into the styles of other web components, or even to anything else on the page within the global scope. We can even choose to forego classnames, complex selectors, and methodologies like BEM in favour of simple descendent selectors for the component’s children, allowing us to write styles more declaratively on semantic elements.

Quickly: “Light” DOM versus Shadow DOM

For most web projects, I generally prefer to bundle CSS (including the web component Sass partials) into a single CSS file so that the component’s default styles are available in the global scope, even if the JavaScript doesn’t execute.

However, it is possible to import a stylesheet via JavaScript that is only consumed by this web component if JavaScript is available:

import styles from './styles.css'; class WebUITabs extends HTMLElement constructor() super(); this.adoptedStyleSheets = [styles]; customElements.define('webui-tabs', WebUITabs);

Alternatively, we could inject a <style> tag containing the component’s styles instead:

class WebUITabs extends HTMLElement connectedCallback() this.attachShadow( mode: 'open' ); // Required for JavaScript access this.shadowRoot.innerHTML = ` <style>  </style> // etc. `; customElements.define('webui-tabs', WebUITabs);

Whichever method you choose, these styles are scoped directly to the web component, preventing component styles from leaking out, but allowing global styles to be inherited.

Now consider this simple example. Everything we write in between the component’s opening and closing tags is considered part of the “Light” DOM.

<my-web-component>  <div> <p>Some content... styles are inherited from the global scope</p> </div> ----------- Shadow DOM Boundary ------------- |  | --------------------------------------------- </my-web-component>

Dave Rupert has an excellent write-up that makes it really easy to see how external styles are able to “pierce” the Shadow DOM and select an element in the Light DOM. Notice how the <button> element that is written in between the custom element’s tags receives the button selector’s styles in the global CSS, while the <button> injected via JavaScript is left untouched.

If we want to style the Shadow DOM <button> we’d have to do that with internal styles like the examples above for importing a stylesheet or injecting an inline <style> block.

That doesn’t mean that all CSS style properties are blocked by the Shadow DOM. In fact, Dave outlines 37 properties that web components inherit, mostly along the lines of text, list, and table formatting.

Progressively enhance the tabbed component with JavaScript

Even though this second example is more about style encapsulation, it’s still a good opportunity to see the progressive enhancement we get practically for free from web components. Let’s step into the JavaScript now so we can see how we can support progressive enhancement. The full code is quite lengthy, so I’ve abbreviated things a bit to help make the points a little clearer.

default class WebUITabs extends HTMLElement constructor() this.tabpanels.length === 0 createTabs() // 1. Hide all tabpanels initially. // 2. Add ARIA props/state to tabs & tabpanels. bindClickEvent(e) e.preventDefault(); // Show clicked tab and update ARIA props/state. bindKeyboardEvent(e, index) e.preventDefault(); // Handle keyboard ARROW/HOME/END keys. customElements.define('webui-tabs', WebUITabs);

The JavaScript injects ARIA roles, states, and props to the tabs and content blocks for screen reader users, as well as extra keyboard bindings so we can navigate between tabs with the keyboard; for example, the TAB key is reserved for accessing the component’s active tab and any focusable content inside the active tabpanel, and the tabs can be traversed with the ARROW keys. So, if JavaScript fails to load, the default experience is still an accessible one where the tabs still anchor link to their respective panels, and those panels naturally stack vertically, one on top of the other.

And if JavaScript is enabled and supported? We get an enhanced experience, complete with updated accessibility considerations.

Example 3: <webui-ajax-loader>

Live demo

This final example differs from the previous two in that it is entirely generated by JavaScript, and uses the Shadow DOM. This is because it is only used to indicate a “loading” state for Ajax requests, and is therefore only needed when JavaScript is enabled.

The HTML markup is just the opening and closing component tags:

<webui-ajax-loader></webui-ajax-loader>

The simplified JavaScript structure:

default class WebUIAjaxLoader extends HTMLElement constructor() super(); const shadow = this.attachShadow( mode: 'open' ); shadow.innerHTML = ` <svg role="img" part="svg"> <title>loading</title> <circle cx="50" cy="50" r="47" /> </svg> `; customElements.define('webui-ajax-loader',WebUIAjaxLoader);

Notice right out of the gate that everything in between the <webui-ajax-loader> tags is injected with JavaScript, meaning it’s all in the Shadow DOM, encapsulated from other scripts and styles not directly bundled with the component.

But also notice the part attribute that’s set on the <svg> element. Here’s where we’ll zoom in:

That’s yet another way we have to style the custom element: named parts. Now we can style that SVG from outside of the template literal we used to establish the element. There’s a ::part pseudo-selector to make that happen:

webui-ajax-loader::part(svg) // Shadow DOM styles for the SVG...

And here’s something cool: that selector can access CSS custom properties, whether they are scoped globally or locally to the element.

webui-ajax-loader --fill: orangered; webui-ajax-loader::part(svg) fill: var(--fill);

As far as progressive enhancement goes, JavaScript supplies all of the HTML. That means the loader is only rendered if JavaScript is enabled and supported. And when it is, the SVG is added, complete with an accessible title and all.

Wrapping up

That’s it for the examples! What I hope is that you now have the same sort of epiphany that I had when reading Jeremy Keith’s post: HTML Web Components are an HTML-first feature.

Of course, JavaScript does play a big role, but only as big as needed. Need more encapsulation? Want to sprinkle in some UX goodness when a visitor’s browser supports it? That’s what JavaScript is for and that’s what makes HTML Web Components such a great addition to the web platform — they rely on vanilla web languages to do what they were designed to do all along, and without leaning too heavily on one or the other.

0 notes