@nexxtmove/ui 1.35.0 → 1.37.0

package/dist/nuxt.js

@@ -83,6 +83,8 @@ var s = {
 	NexxtEditorGap: "components/editor/molecules/EditorGap/EditorGap.vue",
 	NexxtEditorHeadingType: "components/editor/molecules/EditorHeadingType/EditorHeadingType.vue",
 	NexxtEditorJustifyContent: "components/editor/molecules/EditorJustifyContent/EditorJustifyContent.vue",
+	NexxtEditorLetterSpacing: "components/editor/molecules/EditorLetterSpacing/EditorLetterSpacing.vue",
+	NexxtEditorLineHeight: "components/editor/molecules/EditorLineHeight/EditorLineHeight.vue",
 	NexxtEditorMaxWidth: "components/editor/molecules/EditorMaxWidth/EditorMaxWidth.vue",
 	NexxtEditorPadding: "components/editor/molecules/EditorPadding/EditorPadding.vue",
 	NexxtEditorRadius: "components/editor/molecules/EditorRadius/EditorRadius.vue",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nexxtmove/ui",
   "type": "module",
-  "version": "1.35.0",
+  "version": "1.37.0",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",

package/src/components/editor/molecules/EditorColor/EditorColor.vue

@@ -7,18 +7,47 @@
  */
 export type EditorColorProperty = 'bg' | 'text'
 
+const ROLES = ['main', 'accent', 'background', 'heading', 'text'] as const
+
 /**
- * The colour as the editor needs it: a Tailwind arbitrary-value class such as
- * `'bg-[#1777EA]'`, so the consumer can put the model value straight on the
- * element it styles.
+ * A role of the customer's theme. A colour bound to a role follows the theme,
+ * where a literal colour stays what it was picked as.
  */
-export type EditorColorValue = `${EditorColorProperty}-[#${string}]`
+export type EditorColorRole = (typeof ROLES)[number]
+
+/** A literal colour: a Tailwind arbitrary-value class such as `'bg-[#1777EA]'`. */
+export type EditorColorLiteralValue = `${EditorColorProperty}-[#${string}]`
+
+/** A colour bound to a theme role: a token class such as `'bg-theme-main'`. */
+export type EditorColorRoleValue = `${EditorColorProperty}-theme-${EditorColorRole}`
+
+/**
+ * The colour as the editor needs it: the class to apply, so the consumer can
+ * put the model value straight on the element it styles. Either a literal
+ * colour or a theme role.
+ */
+export type EditorColorValue = EditorColorLiteralValue | EditorColorRoleValue
+
+export interface EditorColorThemeRole {
+  /** The role the class is written for: `'main'` becomes `bg-theme-main`. */
+  role: EditorColorRole
+  /** Name of the role as the user reads it, in the swatch's tooltip and in the trigger. */
+  label: string
+  /**
+   * The role's current colour as a 6- or 8-digit hex. Only used to paint the
+   * swatch: the library ships no CSS for the role classes, and the hex never
+   * reaches the model.
+   */
+  hex: string
+}
 
 export interface EditorColorMessages {
   /** Text shown while no colour is set. Defaults to `'Kies kleur...'`. */
   placeholder?: string
   /** Label shown above reusable colours. */
   suggestionsLabel?: string
+  /** Label shown above the theme roles. Defaults to `'Huisstijl'`. */
+  themeLabel?: string
 }
 
 export interface NexxtEditorColorProps {
@@ -47,26 +76,45 @@ export interface NexxtEditorColorProps {
   messages?: EditorColorMessages
   /** Hex colours available inside the picker panel as one-click suggestions. */
   suggestions?: string[]
+  /**
+   * Theme roles offered above the suggestions. Picking one writes the role
+   * class for the current `property` instead of a literal colour. Which roles
+   * are offered is up to the consumer; an entry whose `hex` is not a 6- or
+   * 8-digit hex is left out. Without roles the section is not rendered.
+   */
+  themeRoles?: EditorColorThemeRole[]
 }
 
 const DEFAULT_MESSAGES = {
   placeholder: 'Kies kleur...',
   suggestionsLabel: 'Gebruikte kleuren',
+  themeLabel: 'Huisstijl',
 } satisfies Required<EditorColorMessages>
 
 /**
- * A full model value: one of the two prefixes, then a 6- or 8-digit hex between
+ * A literal model value: one of the two prefixes, then a 6- or 8-digit hex between
  * brackets. A `border-[…]` class is therefore read as unparseable, the same as
  * any other class this component does not own. The
  * alpha pair is accepted on read so a stored `#1777EA80` survives a round trip,
  * even though the picker itself is opened without an alpha channel here.
  */
 const VALUE_PATTERN = /^(bg|text)-\[(#[0-9A-Fa-f]{6}(?:[0-9A-Fa-f]{2})?)\]$/
+
+/**
+ * A role class: one of the two prefixes, then `theme-` and one of the five
+ * roles. Either prefix takes every role. A tint such as `bg-theme-main/10` is
+ * not a value this component writes, so it is read as unparseable.
+ */
+const ROLE_PATTERN = new RegExp(`^(?:bg|text)-theme-(${ROLES.join('|')})$`)
+
+/** The picker throws on a colour it cannot read, so a role's hex is checked first. */
+const ROLE_HEX_PATTERN = /^#[0-9A-Fa-f]{6}(?:[0-9A-Fa-f]{2})?$/
 </script>
 
 <script lang="ts" setup>
 import { computed, watch } from 'vue'
 import NexxtEditorSettingsBlock from '../../atoms/EditorSettingsBlock/EditorSettingsBlock.vue'
+import NexxtTooltip from '../../../atoms/Tooltip/Tooltip.vue'
 import NexxtColorPicker from '../../../organisms/ColorPicker/ColorPicker.vue'
 
 defineOptions({ name: 'NexxtEditorColor' })
@@ -77,17 +125,21 @@ const {
   property = 'bg',
   messages,
   suggestions = [],
+  themeRoles = [],
 } = defineProps<NexxtEditorColorProps>()
 
 /**
  * The chosen colour, as the Tailwind class to apply.
  *
  * Beware: Tailwind only generates an arbitrary class for text it finds in the
- * source at build time. A value that arrives at runtime -- from a database,
- * say -- therefore gets no CSS of its own; the consumer either translates it
- * into an inline style or safelists the classes it can produce. The hex is
- * always parseable out of the string, which is what makes that translation
- * possible.
+ * source at build time. A literal value that arrives at runtime -- from a
+ * database, say -- therefore gets no CSS of its own; the consumer either
+ * translates it into an inline style or safelists the classes it can produce.
+ * The hex is always parseable out of a literal value, which is what makes that
+ * translation possible.
+ *
+ * A role class is a finite list, so it is static CSS -- but the consumer's:
+ * this library defines no `theme-*` colours.
  */
 const model = defineModel<EditorColorValue>({ required: true })
 
@@ -109,12 +161,36 @@ const hex = computed(() => {
   return captured && isHex(captured) ? captured : ''
 })
 
+/** The role out of the model, or `undefined` when it is not a role class. */
+const storedRole = computed(() => {
+  const captured = ROLE_PATTERN.exec(model.value)?.[1]
+  return ROLES.find((role) => role === captured)
+})
+
+const offeredRoles = computed(() => themeRoles.filter((entry) => ROLE_HEX_PATTERN.test(entry.hex)))
+
+/**
+ * The stored role as the consumer offers it. Only a role class selects a role:
+ * a literal colour that happens to equal a role's hex stays a literal.
+ */
+const activeRole = computed(() => offeredRoles.value.find(({ role }) => role === storedRole.value))
+
+/**
+ * Picking the role's own colour -- from the suggestions, or typed -- is how a
+ * colour is detached from the theme without changing how it looks. The picker
+ * reports nothing when it is told to pick the string it already has, so a role's
+ * hex is handed over in its 8-digit form: with `show-alpha` off the picker never
+ * reports an alpha pair, which makes every pick a change.
+ */
+const pickerHex = (roleHex: string) => (roleHex.length === 7 ? `${roleHex}ff` : roleHex)
+
 // An unparseable value -- empty, a token class such as `bg-red-500`, or copy
 // from before this component -- leaves the picker empty and its placeholder
 // visible, rather than being reported as a problem: the first pick writes a
-// valid class back.
+// valid class back. A role the consumer does not offer is shown the same way,
+// because there is no label or hex to show it with; it is not written back.
 const picked = computed({
-  get: () => hex.value,
+  get: () => (activeRole.value ? pickerHex(activeRole.value.hex) : hex.value),
   // The picker clears its own value in no flow it offers, but an empty string
   // would still wipe a perfectly good colour, so it is dropped rather than
   // written through. The picker keeps rendering the model's colour.
@@ -123,13 +199,18 @@ const picked = computed({
   },
 })
 
+const pickRole = (role: EditorColorRole) => {
+  model.value = `${property}-theme-${role}`
+}
+
 // `property` is a prop, so the parent can flip a background setting into a
 // text-colour one while a value is already set. Rewriting the prefix here is
 // what keeps the stored class and the prop from drifting apart.
 watch(
   () => property,
   (next) => {
-    if (hex.value) model.value = `${next}-[${hex.value}]`
+    if (storedRole.value) model.value = `${next}-theme-${storedRole.value}`
+    else if (hex.value) model.value = `${next}-[${hex.value}]`
   },
 )
 </script>
@@ -157,6 +238,42 @@ watch(
       :placeholder="copy.placeholder"
       :suggestions="{ hex: suggestions }"
       :suggestions-label="copy.suggestionsLabel"
-    />
+      :value-label="activeRole?.label"
+    >
+      <template v-if="offeredRoles.length" #presets>
+        <div class="flex flex-col gap-1">
+          <span class="extra-small-normal text-gray-500">{{ copy.themeLabel }}</span>
+          <!--
+            Same swatches and row as the picker's suggestions. Two roles often
+            share a hex (heading and text), so the tooltip is what tells them
+            apart; it repeats the accessible name rather than adding copy.
+          -->
+          <div class="flex flex-wrap gap-1.5">
+            <NexxtTooltip
+              v-for="{ role, label: roleLabel, hex: roleHex } in offeredRoles"
+              :key="role"
+              disable-closing-trigger
+            >
+              <button
+                type="button"
+                :aria-label="roleLabel"
+                :aria-pressed="role === activeRole?.role"
+                class="cursor-pointer rounded-md p-0.5 ring-gray-200 transition-shadow hover:ring-2 hover:ring-cornflower-blue-400 focus-visible:ring-2 focus-visible:ring-cornflower-blue-500 focus-visible:outline-none aria-pressed:ring-2 aria-pressed:ring-cornflower-blue-500"
+                @click="pickRole(role)"
+              >
+                <span
+                  aria-hidden="true"
+                  class="block size-6 rounded-sm shadow-[inset_0_0_0_1px_rgba(0,0,0,0.1)]"
+                  :style="{ backgroundColor: roleHex }"
+                />
+              </button>
+              <template #tooltip>
+                <span class="small-normal text-gray-900">{{ roleLabel }}</span>
+              </template>
+            </NexxtTooltip>
+          </div>
+        </div>
+      </template>
+    </NexxtColorPicker>
   </NexxtEditorSettingsBlock>
 </template>

package/src/components/editor/molecules/EditorLetterSpacing/EditorLetterSpacing.vue

@@ -0,0 +1,163 @@
+<script lang="ts">
+/**
+ * The steps the slider can land on, as the class they are stored as and the
+ * pixels that class is. Not a scale Tailwind has names for -- `tracking-wide`
+ * is an em and moves with the font size, and the editor shows every size in
+ * px -- so every step is an arbitrary-value class.
+ *
+ * The middle step is no class at all: zero is what the text already does, and
+ * storing nothing for it keeps the "no class means default" every other
+ * setting has. The negative side is there on purpose: tightening a large
+ * heading is a real need.
+ *
+ * The consumer stores these classes and lists them in an `@source inline` rule,
+ * so adding or renaming a token is a breaking change even though the component
+ * API stays the same.
+ */
+export const EDITOR_LETTER_SPACING_STEPS = [
+  { token: 'tracking-[-1px]', px: -1 },
+  { token: 'tracking-[-0.5px]', px: -0.5 },
+  { token: 'tracking-[-0.25px]', px: -0.25 },
+  { token: null, px: 0 },
+  { token: 'tracking-[0.25px]', px: 0.25 },
+  { token: 'tracking-[0.5px]', px: 0.5 },
+  { token: 'tracking-[1px]', px: 1 },
+  { token: 'tracking-[1.5px]', px: 1.5 },
+  { token: 'tracking-[2px]', px: 2 },
+] as const
+
+/**
+ * The letter spacing as the editor needs it: the Tailwind class itself, so the
+ * consumer can put the model value straight on the element it styles. The
+ * default step is `null` on the model, not a member of this type.
+ */
+export type EditorLetterSpacingValue = NonNullable<
+  (typeof EDITOR_LETTER_SPACING_STEPS)[number]['token']
+>
+
+/** Overridable copy of the value readout. Every key is optional. */
+export interface EditorLetterSpacingMessages {
+  /** Unit shown behind the value. Defaults to `'px'`. */
+  unit?: string
+  /** Decimal separator of the readout. Defaults to the Dutch `','`. */
+  decimalSeparator?: string
+}
+
+export interface NexxtEditorLetterSpacingProps {
+  /**
+   * Header text of the settings block. Defaults to the Dutch
+   * `'Letterafstand'`; the library has no i18n layer, so a consumer in another
+   * language passes its own copy in.
+   */
+  label?: string
+  /**
+   * Copy of the value readout. Merged per key, so overriding one key keeps the
+   * defaults of the others. Copy is never translated inside the component.
+   */
+  messages?: EditorLetterSpacingMessages
+}
+
+const DEFAULT_MESSAGES = {
+  unit: 'px',
+  decimalSeparator: ',',
+} satisfies Required<EditorLetterSpacingMessages>
+
+/** Index of the no-class step, the middle of the list. */
+const DEFAULT_INDEX = EDITOR_LETTER_SPACING_STEPS.findIndex(({ token }) => token === null)
+</script>
+
+<script lang="ts" setup>
+import { computed } from 'vue'
+import NexxtEditorSettingsBlock from '../../atoms/EditorSettingsBlock/EditorSettingsBlock.vue'
+import NexxtSlider from '../../../atoms/Slider/Slider.vue'
+
+defineOptions({ name: 'NexxtEditorLetterSpacing' })
+
+const { label = 'Letterafstand', messages } = defineProps<NexxtEditorLetterSpacingProps>()
+
+const emit = defineEmits<{
+  /**
+   * The slider was let go: the end of one drag, which a consumer can use to
+   * close an undo step. Arrow keys emit no pointerup.
+   */
+  pointerup: [event: PointerEvent]
+}>()
+
+/**
+ * The selected letter spacing, as the Tailwind class to apply. `null` -- also
+ * what an unset model is -- is the default step: no class at all, zero.
+ */
+const model = defineModel<EditorLetterSpacingValue | null>({ default: null })
+
+const copy = computed(() => ({ ...DEFAULT_MESSAGES, ...messages }))
+
+const maxIndex = EDITOR_LETTER_SPACING_STEPS.length - 1
+
+/**
+ * Position of the current value on the step list. A value that is not on the
+ * list -- a stored `tracking-wide`, say -- falls back to the default step
+ * rather than the first one: the first step here is the tightest spacing, and
+ * an unknown value is no reason to show text as squeezed. The first change
+ * writes a valid class back.
+ */
+const stepIndex = computed(() => {
+  const index = EDITOR_LETTER_SPACING_STEPS.findIndex(({ token }) => token === model.value)
+
+  return index === -1 ? DEFAULT_INDEX : index
+})
+
+// The slider moves over the index, not over the px value, so its model is
+// translated both ways here.
+const sliderValue = computed({
+  get: () => [stepIndex.value],
+  set: ([index]) => {
+    model.value = EDITOR_LETTER_SPACING_STEPS[index].token
+  },
+})
+
+/** `-0,5 px`: a plain hyphen-minus for the sign, the decimal separator from the copy. */
+const displayValue = computed(() => {
+  const { px } = EDITOR_LETTER_SPACING_STEPS[stepIndex.value]
+
+  return `${String(px).replace('.', copy.value.decimalSeparator)} ${copy.value.unit}`
+})
+</script>
+
+<template>
+  <NexxtEditorSettingsBlock :label="label">
+    <div class="flex items-center gap-4">
+      <!--
+        Slider's own `showValue` prints its model, which here is the step index
+        rather than the spacing, so the readout is rendered next to it instead.
+        The thumb has the same problem in `aria-valuenow`, which
+        `aria-valuetext` overrides with the string the readout shows. The block
+        label is a <p>, not a <label>, so the name goes on the thumb explicitly.
+        Slider binds `$attrs` on its root, so the pointerup listener lands there
+        and catches the release of the captured pointer.
+      -->
+      <NexxtSlider
+        v-model="sliderValue"
+        :min="0"
+        :max="maxIndex"
+        :step="1"
+        :aria-label="label"
+        :aria-valuetext="displayValue"
+        @pointerup="emit('pointerup', $event)"
+      />
+
+      <!--
+        `min-w-16` rather than the `min-w-12` of the other editor sliders:
+        `-0,25 px` does not fit in 12. That plus `shrink-0` fixes the width of
+        the box, so the slider keeps its size while dragging; `tabular-nums`
+        only stops the digits from jittering inside it.
+        gray-700, not the gray-500 Slider uses for its own readout: axe puts
+        gray-500 on white at 1.84:1, well under the 4.5:1 it needs at this size.
+      -->
+      <span
+        class="min-w-16 shrink-0 text-right small-normal whitespace-nowrap text-gray-700 tabular-nums"
+      >
+        {{ displayValue }}
+      </span>
+    </div>
+  </NexxtEditorSettingsBlock>
+</template>

package/src/components/editor/molecules/EditorLineHeight/EditorLineHeight.vue

@@ -0,0 +1,161 @@
+<script lang="ts">
+/**
+ * The steps the slider can land on, as the class they are stored as and the
+ * pixels that class is. The `leading-*` classes are Tailwind's spacing scale
+ * (calc of `--spacing`, 4px a step), so `leading-6` really is 24px -- and a
+ * line height set here does not scale with the font size; that is the deal the
+ * fixed steps make, and nothing here tries to compensate for it.
+ *
+ * The first step is no class at all: the element keeps its own line height.
+ * It has no px of its own, so the readout names it instead of measuring it.
+ *
+ * The consumer stores these classes and lists them in an `@source inline` rule,
+ * so adding or renaming a token is a breaking change even though the component
+ * API stays the same.
+ */
+export const EDITOR_LINE_HEIGHT_STEPS = [
+  { token: null, px: null },
+  { token: 'leading-3', px: 12 },
+  { token: 'leading-4', px: 16 },
+  { token: 'leading-5', px: 20 },
+  { token: 'leading-6', px: 24 },
+  { token: 'leading-7', px: 28 },
+  { token: 'leading-8', px: 32 },
+  { token: 'leading-9', px: 36 },
+  { token: 'leading-10', px: 40 },
+  { token: 'leading-11', px: 44 },
+  { token: 'leading-12', px: 48 },
+  { token: 'leading-14', px: 56 },
+  { token: 'leading-16', px: 64 },
+] as const
+
+/**
+ * The line height as the editor needs it: the Tailwind class itself, so the
+ * consumer can put the model value straight on the element it styles. The
+ * default step is `null` on the model, not a member of this type.
+ */
+export type EditorLineHeightValue = NonNullable<(typeof EDITOR_LINE_HEIGHT_STEPS)[number]['token']>
+
+/** Overridable copy of the value readout. Every key is optional. */
+export interface EditorLineHeightMessages {
+  /** Unit shown behind the value. Defaults to `'px'`. */
+  unit?: string
+  /**
+   * Readout of the first step, no class, which has no px size. Defaults to
+   * the Dutch `'Standaard'`.
+   */
+  default?: string
+}
+
+export interface NexxtEditorLineHeightProps {
+  /**
+   * Header text of the settings block. Defaults to the Dutch
+   * `'Regelafstand'`; the library has no i18n layer, so a consumer in another
+   * language passes its own copy in.
+   */
+  label?: string
+  /**
+   * Copy of the value readout. Merged per key, so overriding one key keeps the
+   * defaults of the others. Copy is never translated inside the component.
+   */
+  messages?: EditorLineHeightMessages
+}
+
+const DEFAULT_MESSAGES = {
+  unit: 'px',
+  default: 'Standaard',
+} satisfies Required<EditorLineHeightMessages>
+</script>
+
+<script lang="ts" setup>
+import { computed } from 'vue'
+import NexxtEditorSettingsBlock from '../../atoms/EditorSettingsBlock/EditorSettingsBlock.vue'
+import NexxtSlider from '../../../atoms/Slider/Slider.vue'
+
+defineOptions({ name: 'NexxtEditorLineHeight' })
+
+const { label = 'Regelafstand', messages } = defineProps<NexxtEditorLineHeightProps>()
+
+const emit = defineEmits<{
+  /**
+   * The slider was let go: the end of one drag, which a consumer can use to
+   * close an undo step. Arrow keys emit no pointerup.
+   */
+  pointerup: [event: PointerEvent]
+}>()
+
+/**
+ * The selected line height, as the Tailwind class to apply. `null` -- also
+ * what an unset model is -- is the default step: no class at all.
+ */
+const model = defineModel<EditorLineHeightValue | null>({ default: null })
+
+const copy = computed(() => ({ ...DEFAULT_MESSAGES, ...messages }))
+
+const maxIndex = EDITOR_LINE_HEIGHT_STEPS.length - 1
+
+/**
+ * Position of the current value on the step list. A value that is not on the
+ * list -- a stored `leading-13`, say -- falls back to the first step, the
+ * default, instead of leaving the thumb off the track; the first change writes
+ * a valid class back.
+ */
+const stepIndex = computed(() =>
+  Math.max(
+    0,
+    EDITOR_LINE_HEIGHT_STEPS.findIndex(({ token }) => token === model.value),
+  ),
+)
+
+// The slider moves over the index, not over the px value, so its model is
+// translated both ways here.
+const sliderValue = computed({
+  get: () => [stepIndex.value],
+  set: ([index]) => {
+    model.value = EDITOR_LINE_HEIGHT_STEPS[index].token
+  },
+})
+
+const displayValue = computed(() => {
+  const { px } = EDITOR_LINE_HEIGHT_STEPS[stepIndex.value]
+
+  return px === null ? copy.value.default : `${px} ${copy.value.unit}`
+})
+</script>
+
+<template>
+  <NexxtEditorSettingsBlock :label="label">
+    <div class="flex items-center gap-4">
+      <!--
+        Slider's own `showValue` prints its model, which here is the step index
+        rather than the line height, so the readout is rendered next to it
+        instead. The thumb has the same problem in `aria-valuenow`, which
+        `aria-valuetext` overrides with the string the readout shows. The block
+        label is a <p>, not a <label>, so the name goes on the thumb explicitly.
+        Slider binds `$attrs` on its root, so the pointerup listener lands there
+        and catches the release of the captured pointer.
+      -->
+      <NexxtSlider
+        v-model="sliderValue"
+        :min="0"
+        :max="maxIndex"
+        :step="1"
+        :aria-label="label"
+        :aria-valuetext="displayValue"
+        @pointerup="emit('pointerup', $event)"
+      />
+
+      <!--
+        `min-w-16` so `Standaard` fits and the slider keeps its size moving off
+        the default step; `tabular-nums` stops the digits from jittering.
+        gray-700, not the gray-500 Slider uses for its own readout: axe puts
+        gray-500 on white at 1.84:1, well under the 4.5:1 it needs at this size.
+      -->
+      <span
+        class="min-w-16 shrink-0 text-right small-normal whitespace-nowrap text-gray-700 tabular-nums"
+      >
+        {{ displayValue }}
+      </span>
+    </div>
+  </NexxtEditorSettingsBlock>
+</template>

package/src/components/organisms/ColorPicker/ColorPicker.vue

@@ -35,10 +35,20 @@ export interface NexxtColorPickerProps {
   suggestions?: ColorSuggestions
   /** Accessible and visible label for the suggestions. */
   suggestionsLabel?: string
+  /**
+   * Text shown in the trigger in place of the formatted colour, for a value that has a name of
+   * its own, such as a theme role. Only shown while a colour is set.
+   */
+  valueLabel?: string
 }
 
 defineOptions({ name: 'NexxtColorPicker' })
 
+defineSlots<{
+  /** Named colours a wrapper offers next to the free picker; rendered above the suggestions. */
+  presets?(): unknown
+}>()
+
 const PICKER_ID = 'color-picker-' + Math.random().toString(36).slice(2, 10)
 
 const props = withDefaults(defineProps<NexxtColorPickerProps>(), {
@@ -84,7 +94,9 @@ const hexInputError = ref('')
 const channelInputErrors = ref<Partial<Record<ColorChannel, string>>>({})
 
 const hexColor = computed(() => colorToString(colorObj.value, 'hex'))
-const displayValue = computed(() => (model.value ? fmt(colorObj.value, activeFormat.value) : ''))
+const displayValue = computed(() =>
+  model.value ? props.valueLabel || fmt(colorObj.value, activeFormat.value) : '',
+)
 const colorSuggestions = computed(() => {
   const values = new Set<string>()
 
@@ -443,6 +455,7 @@ watch(
               </ColorFieldRoot>
             </div>
           </div>
+          <slot name="presets" />
           <div v-if="colorSuggestions.length" class="flex flex-col gap-1">
             <span class="extra-small-normal text-gray-500">{{ suggestionsLabel }}</span>
             <div class="flex flex-wrap gap-1.5">

package/src/components.json

@@ -80,6 +80,8 @@
   "NexxtEditorGap": "components/editor/molecules/EditorGap/EditorGap.vue",
   "NexxtEditorHeadingType": "components/editor/molecules/EditorHeadingType/EditorHeadingType.vue",
   "NexxtEditorJustifyContent": "components/editor/molecules/EditorJustifyContent/EditorJustifyContent.vue",
+  "NexxtEditorLetterSpacing": "components/editor/molecules/EditorLetterSpacing/EditorLetterSpacing.vue",
+  "NexxtEditorLineHeight": "components/editor/molecules/EditorLineHeight/EditorLineHeight.vue",
   "NexxtEditorMaxWidth": "components/editor/molecules/EditorMaxWidth/EditorMaxWidth.vue",
   "NexxtEditorPadding": "components/editor/molecules/EditorPadding/EditorPadding.vue",
   "NexxtEditorRadius": "components/editor/molecules/EditorRadius/EditorRadius.vue",

package/src/env.d.ts

@@ -1,6 +1,11 @@
 /// <reference types="vite/client" />
 
-declare module '*.svg' {
+// vite-svg-loader compiles a plain SVG import to a Vue component, but
+// vite/client above declares `*.svg` as a URL string, and of two identical
+// wildcard patterns the one loaded first wins. TypeScript picks the pattern
+// with the longest prefix, so the library's own `@ui-assets` SVGs get their
+// component type here regardless of load order.
+declare module '@ui-assets/*.svg' {
   import type { DefineComponent } from 'vue'
   const component: DefineComponent<object, object, unknown>
   export default component

package/src/index.ts

@@ -49,8 +49,12 @@ export type {
   EditorGapValue,
 } from './components/editor/molecules/EditorGap/EditorGap.vue'
 export type {
+  EditorColorLiteralValue,
   EditorColorMessages,
   EditorColorProperty,
+  EditorColorRole,
+  EditorColorRoleValue,
+  EditorColorThemeRole,
   EditorColorValue,
 } from './components/editor/molecules/EditorColor/EditorColor.vue'
 export type {
@@ -79,6 +83,16 @@ export type {
   EditorMaxWidthMessages,
   EditorMaxWidthValue,
 } from './components/editor/molecules/EditorMaxWidth/EditorMaxWidth.vue'
+export { EDITOR_LINE_HEIGHT_STEPS } from './components/editor/molecules/EditorLineHeight/EditorLineHeight.vue'
+export type {
+  EditorLineHeightMessages,
+  EditorLineHeightValue,
+} from './components/editor/molecules/EditorLineHeight/EditorLineHeight.vue'
+export { EDITOR_LETTER_SPACING_STEPS } from './components/editor/molecules/EditorLetterSpacing/EditorLetterSpacing.vue'
+export type {
+  EditorLetterSpacingMessages,
+  EditorLetterSpacingValue,
+} from './components/editor/molecules/EditorLetterSpacing/EditorLetterSpacing.vue'
 export type { EditorPaddingMessages } from './components/editor/molecules/EditorPadding/EditorPadding.vue'
 export type {
   NexxtTemplateCardContentFeature,
@@ -111,6 +125,8 @@ export { default as NexxtEditorFlexDirection } from './components/editor/molecul
 export { default as NexxtEditorGap } from './components/editor/molecules/EditorGap/EditorGap.vue'
 export { default as NexxtEditorHeadingType } from './components/editor/molecules/EditorHeadingType/EditorHeadingType.vue'
 export { default as NexxtEditorJustifyContent } from './components/editor/molecules/EditorJustifyContent/EditorJustifyContent.vue'
+export { default as NexxtEditorLetterSpacing } from './components/editor/molecules/EditorLetterSpacing/EditorLetterSpacing.vue'
+export { default as NexxtEditorLineHeight } from './components/editor/molecules/EditorLineHeight/EditorLineHeight.vue'
 export { default as NexxtEditorMaxWidth } from './components/editor/molecules/EditorMaxWidth/EditorMaxWidth.vue'
 export { default as NexxtEditorPadding } from './components/editor/molecules/EditorPadding/EditorPadding.vue'
 export { default as NexxtEditorRadius } from './components/editor/molecules/EditorRadius/EditorRadius.vue'