From bde84e430099bfa9c11a6b6f0de2d1bbea3308ec Mon Sep 17 00:00:00 2001 From: "Anthony Fu (via agent)" Date: Wed, 18 Nov 2026 00:39:24 +0000 Subject: [PATCH 1/4] feat(overlay)!: use native dialog and popover for dialogs and tooltips OverlayModal, OverlayDrawer and OverlayConfirm are native s opened with showModal(). OverlayTooltip and v-tooltip are native popovers placed by CSS anchor positioning. vue-afloat is no longer a dependency. BREAKING CHANGE: the dialogs drop their `to` prop (they render in place in the top layer), `styles/vue-afloat.css` is replaced by `styles/tooltip.css` and `styles/dialog.css`, and the vue-afloat peer dependency is removed. --- .../components/Action/ActionIconButton.vue | 4 +- .../design/components/Display/DisplayDate.vue | 2 +- .../components/Display/DisplayFilePath.vue | 2 +- .../components/Overlay/OverlayConfirm.vue | 82 +++--- .../components/Overlay/OverlayDrawer.vue | 89 ++++--- .../components/Overlay/OverlayModal.vue | 95 ++++--- .../components/Overlay/OverlayTooltip.vue | 67 +++-- .../components/Utility/ShadowRoot.stories.ts | 2 +- packages/design/composables/dialog.ts | 131 +++++++++ packages/design/composables/index.ts | 2 + packages/design/composables/tooltip.ts | 252 ++++++++++++++++++ packages/design/package.json | 7 +- packages/design/styles/dialog.css | 106 ++++++++ packages/design/styles/index.css | 3 +- packages/design/styles/reka-ui.css | 84 +----- packages/design/styles/tooltip.css | 43 +++ packages/design/styles/vue-afloat.css | 38 --- packages/design/test/overlays.test.ts | 237 ++++++++++++++++ packages/design/test/portal.test.ts | 40 ++- packages/design/test/styles.test.ts | 35 +-- pnpm-lock.yaml | 19 -- pnpm-workspace.yaml | 2 - storybook/.storybook/preview.ts | 1 - storybook/package.json | 1 - 24 files changed, 1013 insertions(+), 331 deletions(-) create mode 100644 packages/design/composables/dialog.ts create mode 100644 packages/design/composables/tooltip.ts create mode 100644 packages/design/styles/dialog.css create mode 100644 packages/design/styles/tooltip.css delete mode 100644 packages/design/styles/vue-afloat.css create mode 100644 packages/design/test/overlays.test.ts diff --git a/packages/design/components/Action/ActionIconButton.vue b/packages/design/components/Action/ActionIconButton.vue index 94097e9..f73a274 100644 --- a/packages/design/components/Action/ActionIconButton.vue +++ b/packages/design/components/Action/ActionIconButton.vue @@ -1,7 +1,7 @@ diff --git a/packages/design/components/Overlay/OverlayDrawer.vue b/packages/design/components/Overlay/OverlayDrawer.vue index 8ea860d..51ba6b7 100644 --- a/packages/design/components/Overlay/OverlayDrawer.vue +++ b/packages/design/components/Overlay/OverlayDrawer.vue @@ -1,8 +1,7 @@ - + diff --git a/packages/design/components/Overlay/OverlayModal.vue b/packages/design/components/Overlay/OverlayModal.vue index 5c35d90..b14ae6f 100644 --- a/packages/design/components/Overlay/OverlayModal.vue +++ b/packages/design/components/Overlay/OverlayModal.vue @@ -1,62 +1,59 @@ - + diff --git a/packages/design/components/Overlay/OverlayTooltip.vue b/packages/design/components/Overlay/OverlayTooltip.vue index 4969fc3..9202171 100644 --- a/packages/design/components/Overlay/OverlayTooltip.vue +++ b/packages/design/components/Overlay/OverlayTooltip.vue @@ -1,18 +1,19 @@ - + diff --git a/packages/design/components/Utility/ShadowRoot.stories.ts b/packages/design/components/Utility/ShadowRoot.stories.ts index 230086a..5b89884 100644 --- a/packages/design/components/Utility/ShadowRoot.stories.ts +++ b/packages/design/components/Utility/ShadowRoot.stories.ts @@ -67,7 +67,7 @@ const Embedded = defineComponent({ Rendered inside the shadow root, so the glass surface and border tokens apply. - +

Scheme, surface and border tokens all resolve here.

diff --git a/packages/design/composables/dialog.ts b/packages/design/composables/dialog.ts new file mode 100644 index 0000000..458720e --- /dev/null +++ b/packages/design/composables/dialog.ts @@ -0,0 +1,131 @@ +/** + * Native modal dialogs: `` + `showModal()` gives the top layer, the + * focus trap, the inert page and Esc-to-close. Nothing teleports, so a dialog + * inside a shadow root stays there and keeps its styles. + * + * Triggers and close buttons use invoker commands (`commandfor` + + * `command="show-modal" | "close"`), with a click fallback where they're + * unsupported. Backdrop clicks close it via `closedby="any"`, with a JS + * fallback for browsers that don't support `closedby` yet. + */ +import type { FunctionalComponent, Ref, ShallowRef, VNode } from 'vue' +import { cloneVNode, Comment, Fragment, onBeforeUnmount, useId, watch } from 'vue' + +export interface NativeDialogOptions { + /** Close on a backdrop click. Default `true`; alert dialogs pass `false`. */ + lightDismiss?: boolean +} + +export interface NativeDialog { + /** Bind as `id` on the ``. */ + id: string + /** Bind as `closedby` on the ``. */ + closedby: 'any' | 'closerequest' + /** Props for a button that opens the dialog. */ + openProps: () => Record + /** Props for a button that closes the dialog. */ + closeProps: () => Record + /** Renders the slotted trigger with {@link NativeDialog.openProps} merged in. */ + Trigger: FunctionalComponent +} + +function supportsCommands(): boolean { + return typeof HTMLButtonElement !== 'undefined' && 'command' in HTMLButtonElement.prototype +} + +function supportsClosedBy(): boolean { + return typeof HTMLDialogElement !== 'undefined' && 'closedBy' in HTMLDialogElement.prototype +} + +/** + * Sync a `v-model:open` ref with a `` element. + * + * @example + * const native = useNativeDialog(useTemplateRef('dialog'), open) + * // + */ +export function useNativeDialog( + el: Readonly>, + open: Ref, + options: NativeDialogOptions = {}, +): NativeDialog { + const { lightDismiss = true } = options + const id = useId() + + // A close by any route (Esc, `command="close"`, backdrop) lands here. + const onClose = (): void => { + open.value = false + } + // An invoker opened it natively; reflect that in the model. + const onCommand = (event: Event): void => { + if ((event as Event & { command?: string }).command === 'show-modal') + open.value = true + } + // `closedby` fallback: a click whose target is the dialog itself, outside + // its box, is a click on the `::backdrop`. + const onClick = (event: MouseEvent): void => { + const dialog = el.value + if (!dialog || event.target !== dialog) + return + const r = dialog.getBoundingClientRect() + if (event.clientX < r.left || event.clientX > r.right || event.clientY < r.top || event.clientY > r.bottom) + dialog.close() + } + + watch(el, (dialog, previous) => { + previous?.removeEventListener('close', onClose) + previous?.removeEventListener('command', onCommand) + previous?.removeEventListener('click', onClick) + if (!dialog) + return + dialog.addEventListener('close', onClose) + dialog.addEventListener('command', onCommand) + if (lightDismiss && !supportsClosedBy()) + dialog.addEventListener('click', onClick) + }, { flush: 'post' }) + + watch([open, el], ([value, dialog]) => { + if (!dialog) + return + if (value && !dialog.open) + dialog.showModal() + else if (!value && dialog.open) + dialog.close() + }, { flush: 'post', immediate: true }) + + onBeforeUnmount(() => { + if (el.value?.open) + el.value.close() + }) + + const command = (name: 'show-modal' | 'close', fallback: () => void) => (): Record => + supportsCommands() + ? { type: 'button', commandfor: id, command: name } + : { type: 'button', onClick: fallback } + + const openProps = command('show-modal', () => { + open.value = true + }) + const closeProps = command('close', () => { + open.value = false + }) + + // `` renders as a Fragment, which can't take props: reach the + // elements/components inside it. + const withOpenProps = (vnodes: VNode[]): VNode[] => vnodes.flatMap(vnode => + vnode.type === Fragment && Array.isArray(vnode.children) + ? withOpenProps(vnode.children as VNode[]) + : vnode.type === Comment || typeof vnode.type === 'symbol' + ? [vnode] + : [cloneVNode(vnode, openProps(), true)]) + + const Trigger: FunctionalComponent = (_, { slots }) => withOpenProps(slots.default?.() ?? []) + + return { + id, + closedby: lightDismiss ? 'any' : 'closerequest', + openProps, + closeProps, + Trigger, + } +} diff --git a/packages/design/composables/index.ts b/packages/design/composables/index.ts index b0d60fa..3d086e3 100644 --- a/packages/design/composables/index.ts +++ b/packages/design/composables/index.ts @@ -1,3 +1,5 @@ export * from './colorScheme' +export * from './dialog' export * from './portalTarget' export * from './toast' +export * from './tooltip' diff --git a/packages/design/composables/tooltip.ts b/packages/design/composables/tooltip.ts new file mode 100644 index 0000000..e66ea55 --- /dev/null +++ b/packages/design/composables/tooltip.ts @@ -0,0 +1,252 @@ +/** + * Native tooltips: the Popover API puts the tooltip in the top layer, and CSS + * anchor positioning places it next to its trigger. No floating-ui, no + * Teleport, so a tooltip inside a shadow root stays there and keeps its styles. + * + * JS only wires the triggers (hover/focus/click) and the show/hide delays, + * until `interestfor` ships beyond Chromium. It uses `popover="hint"` where + * supported (light dismiss and Esc for free) and `popover="manual"` plus its + * own Esc handling elsewhere. + * + * The skin lives in `@antfu/design/styles/tooltip.css` (`[data-af-tooltip]`). + */ +import type { Directive } from 'vue' + +export type TooltipPlacement + = | 'top' | 'top-start' | 'top-end' + | 'bottom' | 'bottom-start' | 'bottom-end' + | 'left' | 'left-start' | 'left-end' + | 'right' | 'right-start' | 'right-end' + +export type TooltipTrigger = 'hover' | 'focus' | 'click' + +export interface TooltipOptions { + placement?: TooltipPlacement + /** Gap between trigger and tooltip, in px. Default `6`. */ + distance?: number + /** Show/hide delay in ms, or `{ show, hide }`. Default `0`. */ + delay?: number | { show?: number, hide?: number } + /** Default `['hover', 'focus']`. An empty list means manual control only. */ + triggers?: TooltipTrigger[] + disabled?: boolean +} + +export interface TooltipHandle { + show: () => void + hide: () => void + /** Remove every listener and the anchor name. */ + dispose: () => void +} + +// `position-area` for each placement. `start`/`end` align the tooltip's edge +// with the trigger's edge, so it spans away from that edge. +const AREA: Record = { + 'top': 'top', + 'top-start': 'top span-right', + 'top-end': 'top span-left', + 'bottom': 'bottom', + 'bottom-start': 'bottom span-right', + 'bottom-end': 'bottom span-left', + 'left': 'left', + 'left-start': 'left span-bottom', + 'left-end': 'left span-top', + 'right': 'right', + 'right-start': 'right span-bottom', + 'right-end': 'right span-top', +} + +let supportsHint: boolean | undefined +function popoverMode(): 'hint' | 'manual' { + if (supportsHint === undefined) { + const probe = document.createElement('div') + probe.setAttribute('popover', 'hint') + supportsHint = (probe as { popover?: string }).popover === 'hint' + } + return supportsHint ? 'hint' : 'manual' +} + +let counter = 0 + +/** + * Wire `popover` up as the tooltip of `anchor`. Options are read on every + * event, so a getter over reactive props stays current. + */ +export function bindTooltip( + anchor: HTMLElement, + popover: HTMLElement, + options: () => TooltipOptions, +): TooltipHandle { + const name = `--af-tooltip-${++counter}` + popover.id ||= `af-tooltip-${counter}` + popover.setAttribute('popover', popoverMode()) + popover.setAttribute('role', 'tooltip') + popover.dataset.afTooltip = '' + popover.dataset.state = 'closed' + anchor.style.setProperty('anchor-name', name) + popover.style.setProperty('position-anchor', name) + anchor.setAttribute('aria-describedby', popover.id) + + let timer: ReturnType | undefined + let shown = false + + function place(): void { + const { placement = 'top', distance = 6 } = options() + popover.style.setProperty('position-area', AREA[placement] ?? AREA.top) + popover.style.margin = `${distance}px` + } + + // Dismissible, per WCAG 1.4.13. Immediate, ignoring the hide delay. + function onEscape(event: KeyboardEvent): void { + if (event.key === 'Escape') { + clearTimeout(timer) + setShown(false) + } + } + + function setShown(value: boolean): void { + if (shown === value) + return + shown = value + popover.dataset.state = value ? 'open' : 'closed' + if (value) { + place() + popover.showPopover?.() + document.addEventListener('keydown', onEscape) + } + else { + popover.hidePopover?.() + document.removeEventListener('keydown', onEscape) + } + } + + function delayFor(kind: 'show' | 'hide'): number { + const { delay = 0 } = options() + return typeof delay === 'number' ? delay : delay[kind] ?? 0 + } + + function schedule(value: boolean): void { + clearTimeout(timer) + if (value && options().disabled) + return + const ms = delayFor(value ? 'show' : 'hide') + if (ms) + timer = setTimeout(setShown, ms, value) + else + setShown(value) + } + + const has = (trigger: TooltipTrigger): boolean => (options().triggers ?? ['hover', 'focus']).includes(trigger) + const on = (trigger: TooltipTrigger, value: boolean) => (): void => { + if (has(trigger)) + schedule(value) + } + const enter = on('hover', true) + const leave = on('hover', false) + const focus = on('focus', true) + const blur = on('focus', false) + const click = (event: Event): void => { + // The component nests the tooltip inside its trigger wrapper. + if (has('click') && !popover.contains(event.target as Node)) + schedule(!shown) + } + // Light dismiss (`hint` mode) closes it without us. + const toggle = (event: Event): void => { + if ((event as ToggleEvent).newState === 'closed') + setShown(false) + } + + anchor.addEventListener('pointerenter', enter) + anchor.addEventListener('pointerleave', leave) + // Hoverable, per WCAG 1.4.13: moving onto the tooltip keeps it open. + popover.addEventListener('pointerenter', enter) + popover.addEventListener('pointerleave', leave) + anchor.addEventListener('focusin', focus) + anchor.addEventListener('focusout', blur) + anchor.addEventListener('click', click) + popover.addEventListener('toggle', toggle) + + return { + show: () => schedule(true), + hide: () => schedule(false), + dispose() { + clearTimeout(timer) + setShown(false) + anchor.removeEventListener('pointerenter', enter) + anchor.removeEventListener('pointerleave', leave) + popover.removeEventListener('pointerenter', enter) + popover.removeEventListener('pointerleave', leave) + anchor.removeEventListener('focusin', focus) + anchor.removeEventListener('focusout', blur) + anchor.removeEventListener('click', click) + popover.removeEventListener('toggle', toggle) + anchor.style.removeProperty('anchor-name') + if (anchor.getAttribute('aria-describedby') === popover.id) + anchor.removeAttribute('aria-describedby') + }, + } +} + +/** `v-tooltip` value: the text, or the text plus options. Empty text disables it. */ +export type TooltipDirectiveValue = string | (TooltipOptions & { content: string }) + +interface TooltipState { + host: HTMLElement + popover: HTMLElement + handle: TooltipHandle + value: TooltipDirectiveValue +} + +const states = new WeakMap() + +function normalize(value: TooltipDirectiveValue): TooltipOptions & { content: string } { + return typeof value === 'string' ? { content: value } : value +} + +/** + * `v-tooltip="'Copy'"` or `v-tooltip="{ content: 'Copy', placement: 'bottom' }"`. + * + * The tooltip is appended to the trigger's root node (the document body, or + * the enclosing shadow root) rather than into the trigger, so it never becomes + * part of a button's accessible name. Its wrapper copies the `dark`/`light` + * class of the trigger's nearest scheme ancestor when shown. + */ +export const vTooltip: Directive = { + mounted(el, { value }) { + // `display: contents` costs no layout; the class is the scheme hook. + const host = document.createElement('div') + host.style.display = 'contents' + const popover = document.createElement('div') + host.append(popover) + const root = el.getRootNode() + ;(root instanceof ShadowRoot ? root : el.ownerDocument.body).append(host) + + const state: TooltipState = { host, popover, value, handle: undefined! } + const options = (): TooltipOptions => { + const { content, ...rest } = normalize(state.value) + return { ...rest, disabled: rest.disabled || !content } + } + state.handle = bindTooltip(el, popover, options) + popover.textContent = normalize(value).content + popover.addEventListener('beforetoggle', () => { + const scheme = el.closest('.dark, .light') + host.className = scheme ? (scheme.classList.contains('dark') ? 'dark' : 'light') : '' + }) + states.set(el, state) + }, + updated(el, { value }) { + const state = states.get(el) + if (!state) + return + state.value = value + const { content } = normalize(value) + state.popover.textContent = content + if (!content) + state.handle.hide() + }, + beforeUnmount(el) { + const state = states.get(el) + state?.handle.dispose() + state?.host.remove() + states.delete(el) + }, +} diff --git a/packages/design/package.json b/packages/design/package.json index d2ad9cf..a8c26a4 100644 --- a/packages/design/package.json +++ b/packages/design/package.json @@ -67,8 +67,7 @@ "reka-ui": "^2.0.0", "splitpanes": "^4.0.0", "unocss": ">=66.0.0", - "vue": "^3.5.0", - "vue-afloat": "^0.1.0" + "vue": "^3.5.0" }, "peerDependenciesMeta": { "@antfu/utils": { @@ -100,9 +99,6 @@ }, "splitpanes": { "optional": true - }, - "vue-afloat": { - "optional": true } }, "dependencies": { @@ -138,7 +134,6 @@ "unocss": "catalog:frontend", "unplugin-vue": "catalog:frontend", "vue": "catalog:frontend", - "vue-afloat": "catalog:frontend", "vue-tsc": "catalog:frontend" } } diff --git a/packages/design/styles/dialog.css b/packages/design/styles/dialog.css new file mode 100644 index 0000000..a317ac2 --- /dev/null +++ b/packages/design/styles/dialog.css @@ -0,0 +1,106 @@ +/** + * Native dialogs (`OverlayModal`, `OverlayConfirm` = `[data-af-modal]`, + * `OverlayDrawer` = `[data-af-drawer]`): `` opened with `showModal()`. + * + * Enter/exit are CSS transitions: `@starting-style` gives the enter frame, and + * `display`/`overlay` with `allow-discrete` keep the dialog in the top layer + * until the exit transition ends. No JS waits for animations. + */ + +[data-af-modal], +[data-af-drawer] { + transition: + opacity 0.15s ease, + scale 0.18s cubic-bezier(0.16, 1, 0.3, 1), + translate 0.22s cubic-bezier(0.32, 0.72, 0, 1), + display 0.22s allow-discrete, + overlay 0.22s allow-discrete; +} + +/* Modal: fade + scale. */ +[data-af-modal] { + opacity: 0; + scale: 0.96; +} +[data-af-modal][open] { + opacity: 1; + scale: 1; +} +@starting-style { + [data-af-modal][open] { + opacity: 0; + scale: 0.96; + } +} + +/* Drawer: slide in from its edge, back out on close. */ +[data-af-drawer][data-side='right'] { + translate: 100% 0; +} +[data-af-drawer][data-side='left'] { + translate: -100% 0; +} +[data-af-drawer][data-side='top'] { + translate: 0 -100%; +} +[data-af-drawer][data-side='bottom'] { + translate: 0 100%; +} +[data-af-drawer][open] { + translate: 0 0; +} +@starting-style { + [data-af-drawer][open][data-side='right'] { + translate: 100% 0; + } + [data-af-drawer][open][data-side='left'] { + translate: -100% 0; + } + [data-af-drawer][open][data-side='top'] { + translate: 0 -100%; + } + [data-af-drawer][open][data-side='bottom'] { + translate: 0 100%; + } +} + +/* Backdrop: a frosted tint that fades with the dialog. */ +[data-af-modal]::backdrop, +[data-af-drawer]::backdrop { + background: rgb(221 221 221 / 40%); + backdrop-filter: blur(4px); + opacity: 0; + transition: + opacity 0.15s ease, + display 0.22s allow-discrete, + overlay 0.22s allow-discrete; +} +/* `::backdrop` follows its dialog's tree, so a `.dark` ancestor applies. */ +.dark [data-af-modal]::backdrop, +.dark [data-af-drawer]::backdrop { + background: rgb(0 0 0 / 40%); +} +[data-af-modal][open]::backdrop, +[data-af-drawer][open]::backdrop { + opacity: 1; +} +@starting-style { + [data-af-modal][open]::backdrop, + [data-af-drawer][open]::backdrop { + opacity: 0; + } +} + +/* Lock page scroll behind a modal dialog. (Can't see into a shadow root.) */ +:root:has(:is([data-af-modal], [data-af-drawer]):modal) { + overflow: hidden; +} + +@media (prefers-reduced-motion: reduce) { + [data-af-modal], + [data-af-drawer], + [data-af-modal]::backdrop, + [data-af-drawer]::backdrop { + transition: none; + } +} diff --git a/packages/design/styles/index.css b/packages/design/styles/index.css index 946bfa0..8e699c7 100644 --- a/packages/design/styles/index.css +++ b/packages/design/styles/index.css @@ -3,5 +3,6 @@ @import './scrollbar.css'; @import './animations.css'; @import './reka-ui.css'; -@import './vue-afloat.css'; +@import './dialog.css'; +@import './tooltip.css'; @import './splitpanes.css'; diff --git a/packages/design/styles/reka-ui.css b/packages/design/styles/reka-ui.css index 00780bd..1bfe2de 100644 --- a/packages/design/styles/reka-ui.css +++ b/packages/design/styles/reka-ui.css @@ -1,7 +1,8 @@ /** * reka-ui ships headless (unstyled) — most styling lives on the components' - * own token classes. This file carries only the shared niceties: open/close - * transitions for overlays, and locking background scroll behind modals. + * own token classes. This file carries only the open/close animation of the + * poppers (dropdowns, menus, selects, hover cards). Dialogs are native + * ``s; see `dialog.css`. */ [data-reka-popper-content-wrapper] { @@ -14,7 +15,7 @@ * rather than transitions — otherwise the close (exit) frame never plays. */ -/* Backdrops + simple poppers (dropdowns): fade. */ +/* Poppers (dropdowns, menus): fade. */ [data-af-animate][data-state='open'] { animation: af-fade-in 0.15s ease both; } @@ -22,38 +23,6 @@ animation: af-fade-out 0.15s ease both; } -/* Modal content: fade + scale. Centering is the wrapper's flexbox job, so the - * keyframes stay pure scale — no translate to keep in sync (and nothing that - * can double up with a `translate`-property utility). */ -[data-af-modal][data-state='open'] { - animation: af-modal-in 0.18s cubic-bezier(0.16, 1, 0.3, 1) both; -} -[data-af-modal][data-state='closed'] { - animation: af-modal-out 0.15s ease both; -} - -/* Drawer content: slide from its edge; reverse on close. */ -[data-af-drawer] { - animation-duration: 0.22s; - animation-timing-function: cubic-bezier(0.32, 0.72, 0, 1); - animation-fill-mode: both; -} -[data-af-drawer][data-side='right'] { - animation-name: af-slide-right; -} -[data-af-drawer][data-side='left'] { - animation-name: af-slide-left; -} -[data-af-drawer][data-side='top'] { - animation-name: af-slide-top; -} -[data-af-drawer][data-side='bottom'] { - animation-name: af-slide-bottom; -} -[data-af-drawer][data-state='closed'] { - animation-direction: reverse; -} - @keyframes af-fade-in { from { opacity: 0; @@ -64,51 +33,8 @@ opacity: 0; } } -@keyframes af-modal-in { - from { - opacity: 0; - transform: scale(0.96); - } - to { - opacity: 1; - transform: scale(1); - } -} -@keyframes af-modal-out { - from { - opacity: 1; - transform: scale(1); - } - to { - opacity: 0; - transform: scale(0.96); - } -} -@keyframes af-slide-right { - from { - transform: translateX(100%); - } -} -@keyframes af-slide-left { - from { - transform: translateX(-100%); - } -} -@keyframes af-slide-top { - from { - transform: translateY(-100%); - } -} -@keyframes af-slide-bottom { - from { - transform: translateY(100%); - } -} - @media (prefers-reduced-motion: reduce) { - [data-af-animate], - [data-af-modal], - [data-af-drawer] { + [data-af-animate] { animation: none !important; } } diff --git a/packages/design/styles/tooltip.css b/packages/design/styles/tooltip.css new file mode 100644 index 0000000..35005d8 --- /dev/null +++ b/packages/design/styles/tooltip.css @@ -0,0 +1,43 @@ +/** + * Native tooltips (`OverlayTooltip`, `v-tooltip`): a `[popover]` in the top + * layer, placed by CSS anchor positioning. `composables/tooltip.ts` sets + * `position-anchor`, `position-area` and `margin` inline; this file is the + * skin plus the fallbacks that flip it when it would overflow the viewport. + * + * Uses `@apply`, so it needs `@unocss/transformer-directives`, like `base.css`. + */ + +[data-af-tooltip] { + @apply bg-tooltip color-base border border-base rounded-md text-sm; + /* Undo the UA `[popover]` box: it is centered with `inset: 0; margin: auto`. */ + inset: auto; + padding: 4px 8px; + max-width: min(20rem, calc(100vw - 16px)); + overflow-wrap: break-word; + box-shadow: 0 4px 16px rgb(0 0 0 / 12%); + position-try-fallbacks: + flip-block, + flip-inline, + flip-block flip-inline; + opacity: 0; + transition: + opacity 0.12s ease, + display 0.12s allow-discrete, + overlay 0.12s allow-discrete; +} + +[data-af-tooltip]:popover-open { + opacity: 1; +} + +@starting-style { + [data-af-tooltip]:popover-open { + opacity: 0; + } +} + +@media (prefers-reduced-motion: reduce) { + [data-af-tooltip] { + transition: none; + } +} diff --git a/packages/design/styles/vue-afloat.css b/packages/design/styles/vue-afloat.css deleted file mode 100644 index 02aeb80..0000000 --- a/packages/design/styles/vue-afloat.css +++ /dev/null @@ -1,38 +0,0 @@ -/** - * Theme vue-afloat's tooltips/dropdowns/menus through its `--vue-afloat-*` - * custom properties (see https://github.com/antfu/vue-afloat#styling) rather - * than restyling its internal `.vue-afloat__*` elements directly. vue-afloat - * dropped its theme registry, so these are plain CSS values — matching the - * design tokens' *default* palette (`bg-tooltip`, `color-base`, `border-base`, - * `rounded-md`) — not `@unocss/transformer-directives` output. If you - * customize `darkBackground`/`primary` via `presetAnthonyDesign()`, override - * these variables yourself to match. - */ - -.vue-afloat { - --vue-afloat-background: rgb(255 255 255); - --vue-afloat-color: oklch(26.9% 0 0); - --vue-afloat-border-color: rgb(153 153 153 / 13%); - --vue-afloat-border-radius: 0.375rem; - --vue-afloat-box-shadow: 0 4px 16px rgb(0 0 0 / 12%); - --vue-afloat-padding: 4px 8px; -} - -.dark .vue-afloat { - --vue-afloat-background: rgb(17 17 1); - --vue-afloat-color: oklch(92.2% 0 0); -} - -.vue-afloat-dropdown { - --vue-afloat-padding: 4px; -} - -.vue-afloat-menu { - --vue-afloat-background: rgb(255 255 255 / 75%); - --vue-afloat-backdrop-blur: 8px; -} - -.dark .vue-afloat-menu { - --vue-afloat-background: rgb(17 17 1); - --vue-afloat-color: oklch(92.2% 0 0); -} diff --git a/packages/design/test/overlays.test.ts b/packages/design/test/overlays.test.ts new file mode 100644 index 0000000..b4c2fc7 --- /dev/null +++ b/packages/design/test/overlays.test.ts @@ -0,0 +1,237 @@ +import { mount } from '@vue/test-utils' +import { afterEach, describe, expect, it, vi } from 'vitest' +import { defineComponent, h, nextTick, ref, withDirectives } from 'vue' +import OverlayConfirm from '../components/Overlay/OverlayConfirm.vue' +import OverlayDrawer from '../components/Overlay/OverlayDrawer.vue' +import OverlayModal from '../components/Overlay/OverlayModal.vue' +import OverlayTooltip from '../components/Overlay/OverlayTooltip.vue' +import { vTooltip } from '../composables/tooltip' + +afterEach(() => { + document.body.innerHTML = '' + vi.useRealTimers() +}) + +/** Mount a dialog component with a two-way `open` model. */ +function mountDialog(component: any, props: Record = {}, slots: Record unknown> = {}) { + const open = ref(false) + const events: string[] = [] + const wrapper = mount(defineComponent(() => () => h(component, { + ...props, + 'open': open.value, + 'onUpdate:open': (v: boolean) => open.value = v, + 'onConfirm': () => events.push('confirm'), + 'onCancel': () => events.push('cancel'), + }, slots)), { attachTo: document.body }) + const dialog = () => document.querySelector('dialog')! + return { open, events, wrapper, dialog } +} + +describe('native dialogs', () => { + it.each([ + ['modal', OverlayModal], + ['drawer', OverlayDrawer], + ['confirm', OverlayConfirm], + ])('%s opens with showModal() and syncs closes back to v-model', async (_, component) => { + const { open, dialog } = mountDialog(component, { title: 'Hello' }) + expect(dialog().open).toBe(false) + + open.value = true + await nextTick() + expect(dialog().open).toBe(true) + + // Esc, `command="close"` and backdrop clicks all end in a `close` event. + dialog().close() + await nextTick() + expect(open.value).toBe(false) + }) + + it('labels the dialog with its title and description', async () => { + mountDialog(OverlayModal, { title: 'Settings', description: 'Project options' }) + const dialog = document.querySelector('dialog')! + expect(document.getElementById(dialog.getAttribute('aria-labelledby')!)?.textContent?.trim()).toBe('Settings') + expect(document.getElementById(dialog.getAttribute('aria-describedby')!)?.textContent?.trim()).toBe('Project options') + }) + + it('opens from the #trigger slot and closes from the header button', async () => { + const { open, dialog } = mountDialog(OverlayModal, { title: 'T' }, { + trigger: () => h('button', { 'data-trigger': '' }, 'Open'), + default: () => 'Body', + }) + const trigger = document.querySelector('[data-trigger]')! + // Without invoker-command support (happy-dom), a click fallback is wired. + trigger.click() + await nextTick() + expect(open.value).toBe(true) + expect(dialog().open).toBe(true) + + document.querySelector('[aria-label="Close"]')!.click() + await nextTick() + expect(open.value).toBe(false) + expect(dialog().open).toBe(false) + }) + + it('wires invoker commands where the browser supports them', async () => { + Object.defineProperty(HTMLButtonElement.prototype, 'command', { configurable: true, value: '' }) + try { + const { dialog } = mountDialog(OverlayModal, { title: 'T' }, { trigger: () => h('button', { 'data-trigger': '' }, 'Open') }) + const trigger = document.querySelector('[data-trigger]')! + const close = document.querySelector('[aria-label="Close"]')! + expect(trigger.getAttribute('commandfor')).toBe(dialog().id) + expect(close.getAttribute('commandfor')).toBe(dialog().id) + } + finally { + delete (HTMLButtonElement.prototype as any).command + } + }) + + it('light-dismisses modals and drawers, but not the alert dialog', () => { + expect(mountDialog(OverlayModal).dialog().getAttribute('closedby')).toBe('any') + document.body.innerHTML = '' + expect(mountDialog(OverlayDrawer).dialog().getAttribute('closedby')).toBe('any') + document.body.innerHTML = '' + const confirm = mountDialog(OverlayConfirm).dialog() + expect(confirm.getAttribute('closedby')).toBe('closerequest') + expect(confirm.getAttribute('role')).toBe('alertdialog') + }) + + it('confirm emits its choice and closes', async () => { + const { open, events } = mountDialog(OverlayConfirm, { confirmLabel: 'Delete' }) + open.value = true + await nextTick() + const [cancel, confirm] = document.querySelectorAll('dialog button') + expect(cancel!.hasAttribute('autofocus')).toBe(true) + + confirm!.click() + await nextTick() + expect(events).toEqual(['confirm']) + expect(open.value).toBe(false) + }) +}) + +describe('native tooltips', () => { + function mountTooltip(props: Record = {}) { + const wrapper = mount(OverlayTooltip, { + props: { content: 'Copy', ...props }, + slots: { default: () => h('button', 'Trigger') }, + attachTo: document.body, + }) + const tip = () => document.querySelector('[data-af-tooltip]')! + const anchor = () => wrapper.element as HTMLElement + return { wrapper, tip, anchor } + } + + it('renders a popover tooltip anchored to its trigger', () => { + const { tip, anchor } = mountTooltip() + expect(tip().getAttribute('popover')).toMatch(/^(hint|manual)$/) + expect(tip().getAttribute('role')).toBe('tooltip') + expect(anchor().getAttribute('aria-describedby')).toBe(tip().id) + const name = anchor().style.getPropertyValue('anchor-name') + expect(name).toMatch(/^--af-tooltip-/) + expect(tip().style.getPropertyValue('position-anchor')).toBe(name) + }) + + it('shows on hover and focus, hides on leave, blur and Escape', async () => { + const { tip, anchor } = mountTooltip({ placement: 'bottom-start', distance: 8 }) + anchor().dispatchEvent(new PointerEvent('pointerenter')) + expect(tip().dataset.state).toBe('open') + expect(tip().style.getPropertyValue('position-area')).toBe('bottom span-right') + expect(tip().style.margin).toBe('8px') + anchor().dispatchEvent(new PointerEvent('pointerleave')) + expect(tip().dataset.state).toBe('closed') + + anchor().dispatchEvent(new FocusEvent('focusin')) + expect(tip().dataset.state).toBe('open') + document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape' })) + expect(tip().dataset.state).toBe('closed') + }) + + it('honors show/hide delays', () => { + vi.useFakeTimers() + const { tip, anchor } = mountTooltip({ delay: { show: 200, hide: 100 } }) + anchor().dispatchEvent(new PointerEvent('pointerenter')) + expect(tip().dataset.state).toBe('closed') + vi.advanceTimersByTime(200) + expect(tip().dataset.state).toBe('open') + anchor().dispatchEvent(new PointerEvent('pointerleave')) + vi.advanceTimersByTime(99) + expect(tip().dataset.state).toBe('open') + vi.advanceTimersByTime(1) + expect(tip().dataset.state).toBe('closed') + }) + + it('toggles on click with `triggers: [\'click\']`, and ignores hover', () => { + const { tip, anchor } = mountTooltip({ triggers: ['click'] }) + anchor().dispatchEvent(new PointerEvent('pointerenter')) + expect(tip().dataset.state).toBe('closed') + anchor().querySelector('button')!.click() + expect(tip().dataset.state).toBe('open') + // A click inside the tooltip itself doesn't toggle it. + tip().click() + expect(tip().dataset.state).toBe('open') + anchor().querySelector('button')!.click() + expect(tip().dataset.state).toBe('closed') + }) + + it('follows `shown`, bypassing triggers, and never shows while disabled', async () => { + const { wrapper, tip, anchor } = mountTooltip({ shown: true }) + await nextTick() + expect(tip().dataset.state).toBe('open') + anchor().dispatchEvent(new PointerEvent('pointerleave')) + expect(tip().dataset.state).toBe('open') + await wrapper.setProps({ shown: false }) + expect(tip().dataset.state).toBe('closed') + + await wrapper.setProps({ shown: undefined, disabled: true }) + anchor().dispatchEvent(new PointerEvent('pointerenter')) + expect(tip().dataset.state).toBe('closed') + }) + + it('anchors to a viewport coordinate', async () => { + const wrapper = mount(OverlayTooltip, { props: { content: 'Hi', anchor: { x: 120, y: 64 }, shown: true }, attachTo: document.body }) + await nextTick() + const marker = wrapper.find('span[aria-hidden="true"]').element as HTMLElement + expect(marker.style.getPropertyValue('anchor-name')).toMatch(/^--af-tooltip-/) + expect(document.querySelector('[data-af-tooltip]')!.dataset.state).toBe('open') + }) +}) + +describe('v-tooltip', () => { + const Host = defineComponent({ + props: { text: { type: String, default: 'Copy' } }, + setup: props => () => withDirectives(h('button', 'Trigger'), [[vTooltip, props.text]]), + }) + + it('appends the tooltip to the root node, outside the trigger', () => { + const wrapper = mount(Host, { attachTo: document.body }) + const tip = document.querySelector('[data-af-tooltip]')! + expect(tip.textContent).toBe('Copy') + expect(wrapper.element.contains(tip)).toBe(false) + expect(wrapper.element.getAttribute('aria-describedby')).toBe(tip.id) + }) + + it('stays inside an enclosing shadow root', () => { + const host = document.createElement('div') + document.body.append(host) + const shadow = host.attachShadow({ mode: 'open' }) + const point = document.createElement('div') + shadow.append(point) + mount(Host, { attachTo: point }) + expect(shadow.querySelector('[data-af-tooltip]')).toBeTruthy() + expect(document.body.querySelector('[data-af-tooltip]')).toBeNull() + }) + + it('updates its text, is disabled when empty, and cleans up on unmount', async () => { + const wrapper = mount(Host, { attachTo: document.body }) + const tip = document.querySelector('[data-af-tooltip]')! + await wrapper.setProps({ text: 'Copied' }) + expect(tip.textContent).toBe('Copied') + + await wrapper.setProps({ text: '' }) + wrapper.element.dispatchEvent(new PointerEvent('pointerenter')) + expect(tip.dataset.state).toBe('closed') + + wrapper.unmount() + expect(document.querySelector('[data-af-tooltip]')).toBeNull() + }) +}) diff --git a/packages/design/test/portal.test.ts b/packages/design/test/portal.test.ts index bbaea37..65d0734 100644 --- a/packages/design/test/portal.test.ts +++ b/packages/design/test/portal.test.ts @@ -40,9 +40,6 @@ async function fire(root: ParentNode, selector: string, event: Event) { } const cases: Case[] = [ - { name: 'modal', component: Modal, props: { open: true }, marker: '[data-af-modal]' }, - { name: 'drawer', component: Drawer, props: { open: true }, marker: '[data-af-drawer]' }, - { name: 'confirm', component: Confirm, props: { open: true }, marker: '[data-af-modal]' }, { name: 'toasts', component: Toasts, props: { items: [{ id: 1, message: 'hi' }] }, marker: '[role="region"]' }, { name: 'select', @@ -123,9 +120,11 @@ afterEach(() => { document.body.innerHTML = '' }) +const toasts = { items: [{ id: 1, message: 'hi' }] } + /** The container `usePortalTarget` appended to the shadow root. */ function portalContainer(shadow: ShadowRoot) { - return Array.from(shadow.children).find(child => child.querySelector('[data-af-modal]'))! + return Array.from(shadow.children).find(child => child.querySelector('[role="region"]'))! } describe('portals default to document.body', () => { @@ -161,12 +160,12 @@ describe('an explicit `to` wins over auto-detection', () => { const target = document.createElement('div') document.body.append(target) - mount(Modal, { attachTo: mountPoint, props: { open: true, to: target } }) + mount(Toasts, { attachTo: mountPoint, props: { ...toasts, to: target } }) await nextTick() await nextTick() - expect(target.querySelector('[data-af-modal]')).toBeTruthy() - expect(shadow.querySelector('[data-af-modal]')).toBeNull() + expect(target.querySelector('[role="region"]')).toBeTruthy() + expect(shadow.querySelector('[role="region"]')).toBeNull() }) }) @@ -175,7 +174,7 @@ describe('the portal container mirrors the scheme wrapper', () => { const { shadow, mountPoint } = shadowMountPoint() mountPoint.className = 'dark' - mount(Modal, { attachTo: mountPoint, props: { open: true } }) + mount(Toasts, { attachTo: mountPoint, props: toasts }) await nextTick() await nextTick() @@ -191,10 +190,33 @@ describe('the portal container mirrors the scheme wrapper', () => { it('leaves the container bare when there is no scheme wrapper', async () => { const { shadow, mountPoint } = shadowMountPoint() - mount(Modal, { attachTo: mountPoint, props: { open: true } }) + mount(Toasts, { attachTo: mountPoint, props: toasts }) await nextTick() await nextTick() expect(portalContainer(shadow).className).toBe('') }) }) + +// Native ``s open in the top layer *in place*: nothing teleports, so +// they need no portal target and can't escape a shadow root. +const dialogs = [ + { name: 'modal', component: Modal, marker: '[data-af-modal]' }, + { name: 'drawer', component: Drawer, marker: '[data-af-drawer]' }, + { name: 'confirm', component: Confirm, marker: '[data-af-modal]' }, +] + +describe('native dialogs render in place', () => { + it.each(dialogs)('$name stays inside its shadow root as a modal ', async ({ component, marker }) => { + const { shadow, mountPoint } = shadowMountPoint() + + mount(component, { attachTo: mountPoint, props: { open: true } }) + await nextTick() + + const dialog = shadow.querySelector(marker) + expect(dialog?.tagName).toBe('DIALOG') + expect(dialog?.open).toBe(true) + expect(mountPoint.contains(dialog!)).toBe(true) + expect(document.body.querySelector(marker)).toBeNull() + }) +}) diff --git a/packages/design/test/styles.test.ts b/packages/design/test/styles.test.ts index 007e4a2..b3a5c4f 100644 --- a/packages/design/test/styles.test.ts +++ b/packages/design/test/styles.test.ts @@ -39,31 +39,36 @@ describe('shipped styles use the design tokens via @unocss/transformer-directive }) it('leaves no `--af-*` token-mirror variables behind in any shipped style', () => { - for (const f of ['base.css', 'vue-afloat.css', 'splitpanes.css', 'reka-ui.css', 'scrollbar.css', 'animations.css']) + for (const f of ['base.css', 'tooltip.css', 'dialog.css', 'splitpanes.css', 'reka-ui.css', 'scrollbar.css', 'animations.css']) expect(readStyle(f)).not.toContain('--af-') }) }) -describe('vue-afloat.css themes via vue-afloat\'s own `--vue-afloat-*` custom properties', () => { - const css = readStyle('vue-afloat.css') - - it('sets the shared skin on `.vue-afloat` (applies to tooltip/dropdown/menu alike)', () => { - expect(css).toMatch(/\.vue-afloat\s*\{[^}]*--vue-afloat-background:/) +describe('tooltip.css skins native popover tooltips', () => { + it('expands the `bg-tooltip` token with a dark variant', async () => { + const out = await transform(readStyle('tooltip.css')) + expect(out).not.toMatch(/--(?:at-apply|uno)\s*:/) + expect(out).toContain('[data-af-tooltip]') + expect(out).toMatch(/\.dark\s+\[data-af-tooltip\]/) }) - it('blurs the backdrop only for `.vue-afloat-menu`, whose background is translucent', () => { - expect(css).toMatch(/\.vue-afloat-menu\s*\{[^}]*--vue-afloat-backdrop-blur:/) + it('undoes the UA popover centering and flips on overflow', () => { + const css = readStyle('tooltip.css') + expect(css).toMatch(/\[data-af-tooltip\]\s*\{[^}]*inset:\s*auto/) + expect(css).toContain('position-try-fallbacks') }) +}) - it('overrides the surface color under `.dark`, scoped to `.vue-afloat`', () => { - expect(css).toMatch(/\.dark\s+\.vue-afloat\s*\{[^}]*--vue-afloat-background:/) - }) +describe('dialog.css animates native dialogs without JS', () => { + const css = readStyle('dialog.css') - it('tightens padding for `.vue-afloat-dropdown`', () => { - expect(css).toMatch(/\.vue-afloat-dropdown\s*\{[^}]*--vue-afloat-padding:/) + it('enters via @starting-style and exits with discrete display/overlay', () => { + expect(css).toContain('@starting-style') + expect(css).toMatch(/display [\d.]+s allow-discrete/) + expect(css).toMatch(/overlay [\d.]+s allow-discrete/) }) - it('never uses `@unocss/transformer-directives` (no theme-registry dependency)', () => { - expect(css).not.toMatch(/--(?:at-apply|uno)\s*:/) + it('tints the ::backdrop, darker under `.dark`', () => { + expect(css).toMatch(/\.dark \[data-af-modal\]::backdrop/) }) }) diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 874edfe..8c64c1b 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -261,9 +261,6 @@ catalogs: vue: specifier: ^3.5.43 version: 3.5.43 - vue-afloat: - specifier: ^0.2.0 - version: 0.2.0 vue-tsc: specifier: ^3.3.11 version: 3.3.11 @@ -460,9 +457,6 @@ importers: vue: specifier: catalog:frontend version: 3.5.43(typescript@6.0.3) - vue-afloat: - specifier: catalog:frontend - version: 0.2.0(vue@3.5.43(typescript@6.0.3)) vue-tsc: specifier: catalog:frontend version: 3.3.11(typescript@6.0.3) @@ -550,9 +544,6 @@ importers: vue: specifier: catalog:frontend version: 3.5.43(typescript@6.0.3) - vue-afloat: - specifier: catalog:frontend - version: 0.2.0(vue@3.5.43(typescript@6.0.3)) vue-tsc: specifier: catalog:frontend version: 3.3.11(typescript@6.0.3) @@ -4704,11 +4695,6 @@ packages: vscode-uri@3.2.0: resolution: {integrity: sha512-m2gXo3bn0G1kT9InzMf07fTbqMbGtyckj3bH5ktLO+1Ssv+yiATZ4dhwaQv9UZWxJh6E9IFGnQyjgWVDWVBDrg==} - vue-afloat@0.2.0: - resolution: {integrity: sha512-tKDQlkB5VxKDk1CzS53xMig5NxfpT+Cmm2p8j4znyJKJrwuEmY5SuwsQ5i6d+2OQgNcu8ilJjr9LzCX1XCrMZg==} - peerDependencies: - vue: ^3.5.0 - vue-component-meta@3.3.11: resolution: {integrity: sha512-fskQZaIFOifwB4x+/J24795yvezOJ1TKaqn97/4PHybyvXpDNdcKn3oTcPrw6HnNoZWe343A+TiCFOcFv1/SuQ==} peerDependencies: @@ -9015,11 +9001,6 @@ snapshots: vscode-uri@3.2.0: {} - vue-afloat@0.2.0(vue@3.5.43(typescript@6.0.3)): - dependencies: - '@floating-ui/dom': 1.8.0 - vue: 3.5.43(typescript@6.0.3) - vue-component-meta@3.3.11(typescript@6.0.3): dependencies: '@volar/typescript': 2.4.28(typescript@6.0.3) diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index a7dd8cf..ff874fb 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -4,7 +4,6 @@ catalogMode: prefer minimumReleaseAgeExcludePrune: true minimumReleaseAgeExclude: - tsnapi@1.5.0 - - vue-afloat@0.2.0 - '@antfu/ni@30.6.0' - '@vitest/mocker@5.0.1' - '@vitest/spy@5.0.1' @@ -65,7 +64,6 @@ catalogs: unocss: ^66.10.5 unplugin-vue: ^8.0.0 vue: ^3.5.43 - vue-afloat: ^0.2.0 vue-tsc: ^3.3.11 inlined: '@antfu/utils': ^9.3.0 diff --git a/storybook/.storybook/preview.ts b/storybook/.storybook/preview.ts index a292b0a..c7edba7 100644 --- a/storybook/.storybook/preview.ts +++ b/storybook/.storybook/preview.ts @@ -3,7 +3,6 @@ import { GLOBALS_UPDATED } from 'storybook/internal/core-events' import { addons } from 'storybook/preview-api' import { h } from 'vue' import 'virtual:uno.css' -import 'vue-afloat/style.css' import '../../packages/design/styles/index.css' import './docs-dark.css' diff --git a/storybook/package.json b/storybook/package.json index 903c7e7..5809c71 100644 --- a/storybook/package.json +++ b/storybook/package.json @@ -23,7 +23,6 @@ "unocss": "catalog:frontend", "vite": "catalog:cli", "vue": "catalog:frontend", - "vue-afloat": "catalog:frontend", "vue-tsc": "catalog:frontend" } } From 1589f5458fa273fcee99bc28164d8032338556de Mon Sep 17 00:00:00 2001 From: "Anthony Fu (via agent)" Date: Wed, 18 Nov 2026 00:39:36 +0000 Subject: [PATCH 2/4] docs: describe native dialogs and tooltips --- AGENTS.md | 8 ++++- packages/design/README.md | 34 +++++++++---------- .../references/core-components.md | 14 ++++---- skills/antfu-design/references/core-setup.md | 18 +++------- skills/antfu-design/references/core-tokens.md | 2 +- 5 files changed, 37 insertions(+), 39 deletions(-) diff --git a/AGENTS.md b/AGENTS.md index e9dc1db..5a13f9f 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -13,7 +13,13 @@ still apply). the Phosphor set already installed via `presetIcons`) on a `