Canvas Paragraphs

Design paragraph and taxonomy term layouts visually in Drupal Canvas, not just nodes.

Drupal Canvas lets you drag Single Directory Components (SDCs) onto a canvas
and map an entity's fields to component props. No Twig, no preprocess code. Out of the box,
this only works for nodes.

Most sites build pages out of Paragraphs too, using things like hero banners,
callouts, and card grids — and reference other content, like tagging with
taxonomy terms, whose display Canvas als still
render through hand-written Twig.

Canvas Paragraphs fixes that: it makes paragraph types and taxonomy term
bundles first-class in the Canvas editor. Design a Content Template for either just like you
would for a node, and every entity of that bundle renders through it automatically, everywhere
it's used.

Not a migration tool

This module doesn't replace Paragraphs or Taxonomy, or change your content model. It just lets
you author paragraph and taxonomy term view modes visually with Canvas, while
Paragraphs and Taxonomy keep working exactly as they do today.

Features

• Content Template tab on a paragraph ts Manage
  Display page, with a "Create with Canvas" shortcut when no template exists.
• Full visual editing: drag components, map fields to props, preview live.
• Paragraph Field component: renders a m a parent
  node/paragraph's template. Each referenced paragraph renders through its own template, so
  designs nest as deep as you need.
• Entity Reference Field component: the same idea for plain entity reference
  fields, e.g. a field_tags field pointing at taxonomy_term. Each
  referenced term renders through its own Content Template.
• Admin screen at Structure > Content Templates (Non-node) to open,
  generate sample content, or delete any bridged template in one click.
• Drush commands for bulk template creation, listing bundles/templates, and
  generating sample content, handy for CI/build pipelines.
• Enum field fix: list_string/list_integer fields
  (e.g. button variants) on any bridged bundle — paragraph or taxonomy term — now
  map cleanly to SDC enum props, which Canvas can't normally do.
• Clean markup: drops the default
  .paragraph.paragraph--type--X wrapper when a template is active, so your
  component's own root element (<section>, <a>, etc.)
  becomes the real DOM root. Matters for flex/grid layouts.
• Safe by default: every template starts disabled. Nothing changes for
  visitors until you explicitly publish it in the Canvas editor.

Setup

1. Enable it:

   drush en canvas_paragraphs

2. Define fields on your paragraph type or taxonomy vocabulary (Structure >
   Paragraph types, or Structure > Taxonomy) to match your design system's component props,
   e.g. field_heading,

   field_body</cod
       <code>field_variant

   .

3. Create a Content Template, using any of these three ways (steps below use
   paragraphs as the example — taxonomy terms follow the exact same flow, swap
   paragraph for taxonomy_term):
   • UI: Structure > Content Templates (Non-node) → pick entity type, bundle,
     view mode → Create.
   • The "Create with Canvas" button on Manage Displa
   • Drush:

     drush canvas-paragraphs:create-templatet
     drush canvas-paragraphs:create-template paragraph --all

4. Design it at /canvas/template/paragraph/{bundle}/{view_mode}
   (or /canvas/template/taxonomy_term/{bundle}/{view_mode}). No content yet?
   Generate placeholders:

   drush canvas-paragraphs:create-sample paragraph <bundle>

5. Render nested reference fields from a node or parent template: for
   paragraph reference fields, add the Paragraph plain
   entity reference fields (e.g. taxonomy terms), add the Entity Reference Field
   component. Set field_name to your reference field (e.g.
   field_content_sections or field_tags), optionally set
   view_mode (default: default).

   Same thing in Twig:

   {{ sdc_render_field('field_content_sections', 'default') }}

6. Publish when ready. Until then, the entity renders as before.

Other Drush commands:

drush canvas-paragraphs:list-templates
# list all bridged templates

drush canvas-paragraphs:list-bundles paragraph
# list bundles/view modes

Roadmap

The SupportedEntityTypes service controls which entity types are bridged; today it
lists paragraph and taxonomy_term. When Canvas natively supports an
entity type (core issue #3498525 tracks paragraph), that entity is
removed from the SupportedEntityTypes list; once the list is empty, this module
becomes a no-op.

Requirements

• Drupal 10.3+ or Drupal 11
• PHP 8.3+
• Canvas (provides Content Templates)
• Paragraphs
• Field UI, Navigation, and Taxonomy (all included in Drupal core)

Project status

Experimental, matches Canvas's own alpha status. The API and supported entity types may change
as Canvas evolves.