@fusion.dev/helix-templates 0.138.0 → 0.139.0

package/templates/angular/src/app/signup-form.html

@@ -0,0 +1,91 @@
+<header class="hero">
+  <helix-text emphasis="muted" variant="label">Form</helix-text>
+  <helix-text as="h1" variant="heading">Join the roster</helix-text>
+  <helix-text as="p" class="lede" emphasis="muted" variant="body">
+    Five controls, and a <helix-code>&lt;form&gt;</helix-code> reads every one of them the way
+    it reads an <helix-code>input</helix-code>.
+  </helix-text>
+</header>
+
+<!-- The form takes a column of its own and the notes take what is left. At
+     390 the two stack, and the notes read as a postscript. -->
+<div class="split">
+  <form class="form" (submit)="join($event)">
+    <helix-input autocomplete="name" label="Name" name="name" required></helix-input>
+
+    <!-- Validation is the platform's: `type` and `required` are set on the
+         real input inside, and its own message shows once the reader has
+         touched the field. Set `feedback` to say it in your own words. -->
+    <helix-input
+      hint="Where we send the welcome note."
+      label="Email"
+      name="email"
+      required
+      type="email"
+    ></helix-input>
+
+    <!-- `(helix-before-change)` binds with `addEventListener`, so it takes
+         the event's own name. -->
+    <helix-input
+      hint="Lowercase and hyphens, whatever you type."
+      label="Handle"
+      name="handle"
+      [value]="handle()"
+      (helix-before-change)="takeHandle($event)"
+    ></helix-input>
+
+    <helix-select label="Team" name="team" placeholder="Pick one" required>
+      @for (team of teams; track team) {
+        <helix-option [value]="team">{{ team }}</helix-option>
+      }
+    </helix-select>
+
+    <!-- A switch is a thing happening now, which is why it says on and off.
+         It still submits, as `on`. -->
+    <helix-switch label="Send me the weekly digest" name="digest"></helix-switch>
+
+    <helix-button emphasis="solid" tone="primary" type="submit">Join</helix-button>
+  </form>
+
+  <aside class="notes">
+    <!-- The one fact you need before typing your name into a page you have
+         had for five minutes, so it is a callout. `tone` is the meaning,
+         and the component draws it with a tint and a bar on the inline
+         start, so it survives being read in grayscale. -->
+    <helix-callout tone="info">
+      Nothing is posted anywhere. Submit it and the message shows exactly what a server would
+      have been handed.
+    </helix-callout>
+    <helix-text as="h2" variant="title">What this is showing</helix-text>
+    <helix-text as="p" emphasis="muted" variant="body">
+      Every control is a form-associated custom element, so the submit reads them with
+      <helix-code>new FormData(form)</helix-code> and nothing gathers the answers by hand.
+      Reset the form and they all go back, the way an <helix-code>input</helix-code> does.
+    </helix-text>
+    <helix-text as="p" emphasis="muted" variant="body">
+      Leave the email wrong and the complaint is the browser's own, in the reader's language.
+      Handle is the controlled one: it refuses the change and writes back what it will accept.
+    </helix-text>
+    <a data-link [href]="docs.forms">Forms</a>
+  </aside>
+</div>
+
+<!-- **The region is rendered whether or not there is anything in it.**
+     Assistive technology subscribes to a live region, and one that arrives
+     already holding its message is often never announced. A dismissed
+     message asks to go through `helix-dismiss`. -->
+<helix-toast>
+  @for (message of messages(); track message.id) {
+    <helix-toast-item
+      dismissible
+      [duration]="8000"
+      tone="success"
+      (helix-dismiss)="dismiss(message.id)"
+    >
+      <helix-flex direction="column" gap="2xs">
+        <helix-text variant="body-strong">Read by the form</helix-text>
+        <helix-text variant="code">{{ message.text }}</helix-text>
+      </helix-flex>
+    </helix-toast-item>
+  }
+</helix-toast>

package/templates/angular/src/app/signup-form.ts

@@ -0,0 +1,65 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, signal } from '@angular/core'
+import { teams } from './data'
+import { DOCS } from './docs'
+
+/** One message in the toast region, and what it says. */
+interface Message {
+  readonly id: number
+  readonly text: string
+}
+
+/**
+ * The form.
+ *
+ * **Every control here is a form-associated custom element**, so a `<form>`
+ * collects them, resets them, and validates them the way it does an `<input>`.
+ * The submit proves it: it reads the answers with `new FormData(form)`, and
+ * nothing gathers them by hand. No `FormsModule` is involved.
+ *
+ * There is no wrapping `Field` component. A label in one shadow root cannot
+ * name a control in another, so every control renders its own `label`, `hint`,
+ * and `feedback`.
+ */
+@Component({
+  host: { class: 'stack' },
+  schemas: [CUSTOM_ELEMENTS_SCHEMA],
+  selector: 'div[app-signup-form]',
+  templateUrl: './signup-form.html',
+})
+export class SignupForm {
+  protected readonly docs = DOCS
+  protected readonly teams = teams
+  protected readonly handle = signal('')
+  protected readonly messages = signal<readonly Message[]>([])
+
+  /**
+   * The page takes the submit, so nothing navigates. Remove `preventDefault()`
+   * and the form posts to the server like any other, with the same names.
+   */
+  protected join(event: SubmitEvent): void {
+    event.preventDefault()
+    const answers = [...new FormData(event.currentTarget as HTMLFormElement).entries()]
+      .map(([field, value]) => `${field}=${value}`)
+      .join('  ')
+    this.messages.update((sent) => [...sent, { id: Date.now(), text: answers }])
+  }
+
+  /**
+   * **A controlled value, which is the one habit to unlearn.** A Helix element
+   * is not read-only: writing `value` seeds it, and the element goes on
+   * applying its own changes. So taking the decision means refusing the change
+   * with `preventDefault()`, then setting the value you want. Leaving `handle`
+   * as it was does not refuse anything.
+   *
+   * No typings ship for Angular, so the event's detail is named here.
+   */
+  protected takeHandle(event: Event): void {
+    event.preventDefault()
+    const { value } = (event as CustomEvent<{ value: string }>).detail
+    this.handle.set(value.toLowerCase().replaceAll(/[^a-z0-9-]/g, ''))
+  }
+
+  protected dismiss(id: number): void {
+    this.messages.update((sent) => sent.filter((one) => one.id !== id))
+  }
+}

package/templates/angular/src/app/site-footer.html

@@ -0,0 +1,10 @@
+<div class="footer-row">
+  <helix-text as="p" emphasis="subtle" variant="caption">
+    Every component in here, with its API, its parts and its examples, has a page.
+  </helix-text>
+  <div class="footer-links">
+    <a data-link="subtle" [href]="docs.gallery">Components</a>
+    <a data-link="subtle" [href]="docs.elements">Documentation</a>
+    <a data-link="subtle" [href]="docs.angular">Angular</a>
+  </div>
+</div>

package/templates/angular/src/app/site-footer.ts

@@ -0,0 +1,22 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core'
+import { DOCS } from './docs'
+
+/**
+ * The bar's counterpart, on every route.
+ *
+ * **It puts a floor under the content.** The overview is a heading, a table,
+ * and a caption, which on a tall window left the bottom third of the screen
+ * empty. The footer is also where the links you want once belong.
+ *
+ * `data-link="subtle"` reads as body text until it is hovered, which suits a
+ * row of links under a rule.
+ */
+@Component({
+  host: { class: 'site-footer' },
+  schemas: [CUSTOM_ELEMENTS_SCHEMA],
+  selector: 'footer[app-site-footer]',
+  templateUrl: './site-footer.html',
+})
+export class SiteFooter {
+  protected readonly docs = DOCS
+}

package/templates/angular/src/app/site-header.html

@@ -0,0 +1,30 @@
+<helix-app-header material="glass" sticky>
+  <!-- The wordmark is the way back to the first page, so there is no third
+       destination in the bar saying the same thing. It is also the only name
+       of the project on the screen. The mark is a placeholder for your own,
+       drawn in `--helix-color-brand-mark`, the token for the brand as a
+       graphic. -->
+  <a class="wordmark" data-link="quiet" href="#/" slot="start">
+    <helix-icon name="cube"></helix-icon>
+    <helix-text variant="body-strong">__PROJECT_NAME__</helix-text>
+  </a>
+
+  <!-- The links are yours. Navigation owns the marker that travels between
+       them and renders no anchors of its own. The base layer styles them,
+       `aria-current="page"` included. -->
+  <helix-navigation label="Pages">
+    <a [attr.aria-current]="path() === '/overview' ? 'page' : null" href="#/overview">Overview</a>
+    <a [attr.aria-current]="path() === '/join' ? 'page' : null" href="#/join">Join</a>
+  </helix-navigation>
+
+  <!-- An icon with no words has no accessible name until it is given one,
+       which is why this is its own element. -->
+  <helix-icon-button
+    [label]="'Color mode: ' + mode()"
+    slot="end"
+    [title]="'Color mode: ' + mode()"
+    (click)="cycle()"
+  >
+    <helix-icon [name]="marks[mode()]"></helix-icon>
+  </helix-icon-button>
+</helix-app-header>

package/templates/angular/src/app/site-header.ts

@@ -0,0 +1,58 @@
+import { Component, CUSTOM_ELEMENTS_SCHEMA, inject, signal } from '@angular/core'
+import { Pathname } from './pathname'
+
+/** What the page can follow, in the order the control cycles them. */
+const MODES = ['system', 'light', 'dark'] as const
+
+type Mode = (typeof MODES)[number]
+
+/** The glyph each mode is announced and drawn with. */
+const MARKS: Record<Mode, string> = { dark: 'moon', light: 'sun', system: 'monitor' }
+
+/**
+ * The bar across the top: the wordmark, the destinations, and the color mode.
+ *
+ * `CUSTOM_ELEMENTS_SCHEMA` is what lets Angular compile a template holding
+ * tags it does not know. It turns off the unknown-element check for this
+ * template alone, so keep it on the components that render Helix.
+ *
+ * **A tag of its own, drawn as no box.** Selected by an attribute on
+ * `helix-app-header`, the component would leave that attribute on a Helix
+ * element, which Helix diagnostics reports as one the element does not take.
+ * `display: contents` makes the bar a child of the shell's column again, which
+ * a sticky header needs: it sticks only within its parent's box.
+ */
+@Component({
+  host: { style: 'display: contents' },
+  schemas: [CUSTOM_ELEMENTS_SCHEMA],
+  selector: 'app-site-header',
+  templateUrl: './site-header.html',
+})
+export class SiteHeader {
+  protected readonly path = inject(Pathname).current
+  protected readonly marks = MARKS
+  /* `system` is the resting state, so the control draws the same glyph before
+     and after the reader first touches it. */
+  protected readonly mode = signal<Mode>('system')
+
+  /**
+   * One attribute, two modes, and no second stylesheet.
+   *
+   * Every Helix token is written once as a `light-dark()` pair, so
+   * `color-scheme` decides which half resolves. `data-color-mode` sets it, and
+   * since `color-scheme` inherits, the attribute works on any element: put it
+   * on a panel for a light preview inside a dark page.
+   *
+   * `system` removes the attribute. Writing out whichever mode is current would
+   * freeze the page there the moment the reader's machine changed.
+   */
+  protected cycle(): void {
+    const next = MODES[(MODES.indexOf(this.mode()) + 1) % MODES.length] ?? 'system'
+    this.mode.set(next)
+    if (next === 'system') {
+      delete document.documentElement.dataset['colorMode']
+      return
+    }
+    document.documentElement.dataset['colorMode'] = next
+  }
+}

package/templates/angular/src/app.css

@@ -0,0 +1,363 @@
+/*
+ * The page around the components.
+ *
+ * Helix draws its own insides, so what is left to an app stylesheet is the
+ * measure, the rhythm between blocks, and the few things a component
+ * deliberately leaves open. Everything below is a Helix token or a documented
+ * hook, so a theme moves it and both color modes follow without a second copy
+ * of anything.
+ *
+ * **Color appears twice and both places are named.** The wordmark takes
+ * `--helix-color-brand-mark`, which is the token for the brand as a graphic
+ * rather than as a word, and a chosen row takes `--helix-color-primary-subtle`
+ * through the parts the table publishes. Everywhere else this page is ink on the
+ * background and the components carry their own.
+ */
+
+/*
+ * **The shell, and what stops a short route ending in a void.** The overview is
+ * a header, a table and a caption, which on a 1280 by 900 window left something
+ * like four hundred pixels of nothing under it: a page that stopped rather than
+ * a page that finished. A column the height of the window with the footer at the
+ * end of it puts a floor under every route.
+ *
+ * **Flex and not grid, because the bar is sticky.** A grid item's containing
+ * block is its own grid area, which is one row as tall as the bar, so a sticky
+ * header in a grid row sticks for nothing. A flex item's containing block is the
+ * flex container, which is the whole document.
+ */
+.shell {
+  display: flex;
+  flex-direction: column;
+  min-block-size: 100dvh;
+}
+
+/*
+ * **56rem, which is a measure rather than a maximum.** A page is as wide as its
+ * widest block can be read at, and the widest block here is a four-column table:
+ * given the whole of a 1280 window its first column came out 448 pixels across
+ * to hold a name, which reads as a table that has been stretched rather than
+ * laid out. The bar and the footer are centered in the same width, so the
+ * wordmark sits over the first column of the page rather than near it.
+ *
+ * `flex-grow` is what hands the slack to the page rather than to the footer.
+ */
+.page {
+  flex-grow: 1;
+  margin-inline: auto;
+  max-inline-size: 56rem;
+  padding-block: var(--helix-space-2xl) var(--helix-space-3xl);
+  padding-inline: var(--helix-space-lg);
+}
+
+/*
+ * Two documented hooks, and both are about agreeing with the page. The bar
+ * centers its row in the page's measure, so the wordmark sits over the first
+ * column rather than near it. And it draws no line under itself by default,
+ * because a header over a page that already has a surface does not need one:
+ * this page has no such surface, so it asks for one. A token rather than a
+ * color, so it follows the theme.
+ */
+helix-app-header {
+  --app-header-border-color: var(--helix-color-border);
+  --app-header-max-inline-size: 56rem;
+}
+
+/* The mark beside the project's name, which is the one graphic on the page and
+   the reason `--helix-color-brand-mark` exists: a mark answers to the 3:1 WCAG
+   asks of a graphic rather than to the 4.5 a word does, so it may sit closer to
+   the brand a theme was seeded with than any text color can. Swap the glyph, or
+   replace the whole element with your own logo. */
+.wordmark {
+  align-items: center;
+  display: inline-flex;
+  gap: var(--helix-space-xs);
+}
+
+.wordmark helix-icon {
+  color: var(--helix-color-brand-mark);
+}
+
+/*
+ * One rhythm between the blocks of a page, so no page states its own.
+ *
+ * **`minmax(0, 1fr)` and never a bare column, which is the trap in every grid
+ * here.** An implicit track is `auto`, and an `auto` track's minimum is its
+ * content's min-content size, so a child that would rather scroll itself widens
+ * the track instead and takes the page with it. Measured at 320: the table's
+ * columns floor at 344, the column it sits in should have been 288, and
+ * `documentElement.scrollWidth` came back 360 against a 320 viewport. The whole
+ * page scrolled sideways so that a table with its own scrollport would not have
+ * to. Zero as the minimum hands the overflow back to whoever is equipped for it.
+ */
+.stack,
+.section,
+.hero,
+.first-screen,
+.fact,
+.facts,
+.notes,
+.split {
+  grid-template-columns: minmax(0, 1fr);
+}
+
+/* One step between the blocks of a page and a smaller one inside them, which is
+   the whole of the rhythm: `3xl` here against the `md` a section puts between
+   its heading and its block, so a reader sees three groups rather than six
+   evenly spaced things. */
+.stack {
+  display: grid;
+  gap: var(--helix-space-3xl);
+}
+
+/*
+ * **The first screen is two things at once**, which is what makes it a screen
+ * rather than a stack: what this is, on the left, and the library doing it, on
+ * the right. Below 60rem there is no room for two columns that are both worth
+ * reading, so they become one and the panel reads as the thing the words were
+ * about.
+ *
+ * `start`, because a grid column stretches to its tallest sibling: the panel
+ * beside a taller block of words would otherwise grow to match it and spread its
+ * own regions out to fill the difference.
+ */
+.first-screen {
+  align-items: start;
+  display: grid;
+  gap: var(--helix-space-xl);
+}
+
+@media (width >= 60rem) {
+  .first-screen {
+    grid-template-columns: minmax(0, 1fr) minmax(0, 20rem);
+  }
+}
+
+/* A heading and the lines around it are one block, and the gap between them is
+   not the gap between blocks. Every route opens with one. */
+.hero {
+  display: grid;
+  gap: var(--helix-space-xs);
+  justify-items: start;
+}
+
+/* **A measure for the lede, which the page's own is too wide to be.** A line of
+   prose across 56rem is around 110 characters, and the readable range tops out
+   near 75. The heading above it is exempt: a heading is scanned rather than
+   read along. */
+.lede {
+  max-inline-size: 42rem;
+}
+
+.actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--helix-space-sm);
+  padding-block-start: var(--helix-space-md);
+}
+
+/*
+ * **The panel is the library rather than a picture of it**, so the only thing it
+ * needs from here is room. Two documented hooks: the figures come down a step
+ * from the display size, which is set for a figure on its own and is too loud
+ * for three of them in a 20rem column, and the rule between them comes in from
+ * `2xl`, which `divided` doubles and which would leave no column to put a
+ * number in.
+ */
+.specimen {
+  --stat-group-gap: var(--helix-space-md);
+  --stat-value-size: var(--helix-text-xl);
+}
+
+/* A section is its heading and its one block, closer together than two sections
+   are. */
+.section {
+  display: grid;
+  gap: var(--helix-space-md);
+}
+
+/*
+ * **Three facts about the library, and deliberately not three cards.** A row of
+ * identical outlined boxes is the shape a generated page takes, and it is also a
+ * claim: a box says each of these is its own object, when they are three
+ * paragraphs about the same installed thing. A rule over each column groups them
+ * at a fraction of the weight, and leaves the cards below to mean something,
+ * which is that they go somewhere.
+ *
+ * `border-thick` in the foreground rather than a hairline in the border color:
+ * this is a heading device rather than a container edge, and it is the one place
+ * the page draws in ink.
+ */
+.facts {
+  display: grid;
+  gap: var(--helix-space-lg);
+}
+
+@media (width >= 48rem) {
+  .facts {
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+  }
+}
+
+.fact {
+  align-content: start;
+  border-block-start: var(--helix-border-thick) solid var(--helix-color-foreground);
+  display: grid;
+  gap: var(--helix-space-xs);
+  justify-items: start;
+  padding-block-start: var(--helix-space-sm);
+}
+
+/*
+ * **The one departure the grids state.** `helix-grid` takes a fixed count as
+ * plain CSS, which is what keeps a server-rendered row of cards correct before
+ * any JavaScript arrives. Below this width there is only ever room for one
+ * column, and `--grid-columns` is the documented way to say so from outside the
+ * shadow root.
+ */
+@media (width < 48rem) {
+  helix-grid {
+    --grid-columns: minmax(0, 1fr);
+  }
+}
+
+/*
+ * **The cards keep `start`, which is `--card-align`'s resting value, and the
+ * alternative is worth naming because it looks right and is not.**
+ * `space-between` puts the last line of each card on its bottom edge, so a row
+ * of cards ends in a straight line. It gets there by sharing the slack out
+ * between every region, and the first thing that moves is the body: three cards
+ * of six, five and seven lines had their opening lines 50 pixels apart under
+ * headings that were level. A reader scans the first line of each, so that is
+ * the alignment worth keeping.
+ */
+
+/* The card fills the link that wraps it, so a row of destinations ends level:
+   the anchor is the grid item and stretches, and the card inside it does not.
+   The regions stay packed at the top, per `--card-align` above. */
+[data-card] > helix-card {
+  block-size: 100%;
+}
+
+/* A form is read straight down, and a field wider than about this stops being
+   scannable however much room the window has. */
+.form {
+  align-content: start;
+  display: grid;
+  gap: var(--helix-space-lg);
+  justify-items: start;
+  max-inline-size: 28rem;
+}
+
+/* Every control fills the column; the submit is as wide as its own words. */
+.form > :not(helix-button) {
+  inline-size: 100%;
+}
+
+/*
+ * **The form takes a column and the notes take the rest.** A 28rem form on a
+ * 1280 window is a third of a page and two thirds of nothing, which is what the
+ * measure above cannot fix on its own: the form has a right width and the page
+ * does not shrink to it. Narrow, the two stack and the notes read as a
+ * postscript, which is the order they are written in.
+ */
+.split {
+  display: grid;
+  gap: var(--helix-space-2xl);
+}
+
+@media (width >= 60rem) {
+  .split {
+    grid-template-columns: minmax(0, 28rem) minmax(0, 1fr);
+  }
+}
+
+/* `start`, because a grid column stretches to its tallest sibling and a
+   stretched grid shares the difference out between its own rows: beside a form
+   half a page long, three paragraphs came out 140 pixels apart. */
+.notes {
+  align-content: start;
+  display: grid;
+  gap: var(--helix-space-sm);
+  justify-items: start;
+  max-inline-size: 32rem;
+}
+
+/* The callout takes the column, which `start` above would otherwise size to its
+   own words: a notice narrower than the paragraph under it reads as a stray. The
+   link beside it is meant to be its own width. */
+.notes > helix-callout {
+  inline-size: 100%;
+}
+
+/*
+ * **The counterpart to the bar, and the reason every route now ends rather than
+ * stops.** The rule runs the window while its contents keep the page's measure,
+ * which is what a footer under a centered page looks like; the shell above is
+ * what holds it to the bottom of a window a route does not fill.
+ */
+.site-footer {
+  border-block-start: var(--helix-border-thin) solid var(--helix-color-border);
+}
+
+.footer-row {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--helix-space-md);
+  justify-content: space-between;
+  margin-inline: auto;
+  max-inline-size: 56rem;
+  padding-block: var(--helix-space-lg);
+  padding-inline: var(--helix-space-lg);
+}
+
+.footer-links {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--helix-space-md);
+}
+
+/*
+ * **Narrow, the gutter gives before the content does.** 24 pixels either side of
+ * a 390 window is 48 of 390 spent on margin, and the table needs 355 of what is
+ * left. At `md` it has 358 and fits; at `lg` it was 13 pixels short and the last
+ * column sat outside the box until the reader scrolled the table sideways.
+ */
+@media (width < 40rem) {
+  .page {
+    padding-block: var(--helix-space-xl) var(--helix-space-2xl);
+    padding-inline: var(--helix-space-md);
+  }
+
+  .footer-row {
+    padding-inline: var(--helix-space-md);
+  }
+}
+
+/*
+ * **The escape hatch, and the reason a component names its parts.** The table
+ * washes a chosen row at the strength `Tag` rests at; this page wants a row
+ * somebody has ticked to be findable from across the screen, and there is no
+ * token for "more than that". `::part` reaches the boxes the component drew
+ * without forking it, and a rule written out here beats the component's own
+ * however specific that one is.
+ *
+ * **Two parts and not one, because a row has no box.** The row is
+ * `display: contents` so that one grid can align every column across every row,
+ * which leaves the cells as the only thing a selection can be painted on. The
+ * table names both: the data cells and the cell holding the checkbox. Naming
+ * only the first leaves a pale stripe down the left of every chosen row.
+ *
+ * The values are still the library's, so a theme carries them like everything
+ * else. `primary-subtle` and not `primary-surface`: the second is the solid
+ * accent a button stands on and expects white on top of it, so a row painted
+ * with it puts the table's own ink on a saturated fill.
+ */
+helix-data-table::part(cell-selected),
+helix-data-table::part(select-selected) {
+  background-color: var(--helix-color-primary-subtle);
+}
+
+helix-data-table::part(cell-selected) {
+  font-weight: var(--helix-weight-semibold);
+}

package/templates/angular/src/diagnostics.ts

@@ -0,0 +1,24 @@
+/**
+ * Helix diagnostics, which `main.ts` loads in development only.
+ *
+ * It finds the Helix mistakes that are valid CSS and therefore silent, such as
+ * a `::part()` naming a part nothing publishes, and an attribute value outside
+ * the set a component takes. Each finding prints once in DevTools, and a badge
+ * in the corner of the page lists them while there are any.
+ *
+ * **Checked against the Helix you installed**, from the lint data it ships, so
+ * nothing is loaded from the network.
+ *
+ * To print the findings in your terminal as well, run `npx helix diagnostics`
+ * from `@fusion.dev/helix-cli` beside the dev server, and add
+ * `sinks: { relay: true }` below.
+ */
+import { initDiagnostics } from '@fusion.dev/helix-diagnostics'
+import lint from '@fusion.dev/helix/lint.json'
+
+initDiagnostics({
+  environment: 'development',
+  /* The route is in the hash, so each page's findings are kept apart. */
+  page: () => window.location.hash.slice(1) || '/',
+  tiers: [{ lint }],
+})

package/templates/angular/src/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>__PROJECT_NAME__</title>
+    <base href="/" />
+  </head>
+  <body>
+    <app-root></app-root>
+  </body>
+</html>