Compare commits

..

21 Commits

Author SHA1 Message Date
MIKITA KAVALIOU
f3b14e6431 chore: abort signal second review fixes
- add the xen-api breaking change entry

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
2f2ff49857 fix(backups): abort signal review fixes
- abortableMap(): waits for the other executions (Promise.allSettled) after aborting them, before
  rethrowing the first failure, so the failure cleanup of importIncrementalVm() does not run while
  they are still uploading
- abortableMap(): back in its own module, _abortableMap.mjs, with its test next to it
- engines: node >=22.19, AbortSignal.any() needs Node 20.3

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
3b16209f8b fix(xen-api): abort signal second review fixes
- callAsync(): the signal is no longer part of the cache key, so a call hashes the same with or without
  a signal; computeCacheKey() is unchanged
- getResource(), putResource(): recheck the abort right before the request that drives the task; an abort
  before it marks the task as cancelled instead of sending task.cancel to a task nothing drives
- callAsync(): rejects with the signal reason once aborted, like an abort before the call
- putResource(): settles when the upload is aborted after XAPI has sent its early 200, it used to never
  settle; needed to wait for the other transfers when one fails
- tests: abort while Async.* creates the task, during _autoTask(), _setHostAddressInUrl() and the
  redirections; upload aborted once the first chunk is received, asserting an AbortError
- docs: document the leading AbortSignal, the signal, cache, method order and the CancelToken removal

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
b3ac4b97d7 chore: abort signal review fixes
Release @vates/types as major: renaming the cancelToken option to signal
breaks compatibility.

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
d30de831c3 fix(@vates/types): abort signal review fixes
Declare the signal option of exportVmOva(), which xo-server already accepts.

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
a5975cfb1e fix(xen-api): abort signal review fixes
Treat a leading null like undefined, as an empty signal slot. Before, a
leading null was taken as the cache by the next decorator and the call failed.

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
6df327e702 chore: update CHANGELOG.unreleased.md
See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
8075e28118 refactor(@vates/types): replace cancelToken with signal
`$snapshot()`, `VM_export()`, `VDI_exportContent()` and
`VDI_importContent()` take `signal?: AbortSignal` instead of
`cancelToken?: unknown`.

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
959587f004 refactor(xo-server): pass an AbortSignal to job executors
- jobs: each run uses an `AbortController`, executors receive `signal`
  instead of `cancelToken`, and `cancelJobRun()` (`job.cancel`) aborts it
- metadata backups: `signal.throwIfAborted()` replaces
  `cancelToken.throwIfRequested()`
- backups-ng: rename the unused `cancelToken` to `signal` (cancelling a
  backup job run still does not stop the backup)
- `exportVmOva()`, `exportVdiAsVmdk()`, `exportVdiAsQcow2()`,
  `exportPoolMetadata()` and `importPoolMetadata()` take an optional
  `signal` option instead of a `CancelToken`
- `_hubKubernetesCluster`: pass the download signal down instead of
  bridging it to a `CancelToken`

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
409005ece0 refactor(backups): replace cancelableMap with an AbortSignal based helper
`exportIncrementalVm()` and `importIncrementalVm()` take an optional
`signal` (`AbortSignal`) instead of `cancelToken`.

`_cancelableMap.mjs` is replaced by `abortableMap()`, which keeps its
semantics: when one disk transfer fails, the others are aborted. Each item
gets a child signal that follows the parent signal (`AbortSignal.any()`)
and is aborted on the first failure, which is rethrown without waiting for
the other items.

BREAKING CHANGE: the `cancelToken` option of `exportIncrementalVm()` and
`importIncrementalVm()` is replaced by `signal`.

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
98aaaeba40 refactor(xapi): replace cancelToken option with signal
`VDI_exportContent()`, `VDI_importContent()`, `VM_checkpoint()`,
`VM_export()` and `VM_snapshot()` take an optional `signal` (`AbortSignal`)
instead of `cancelToken`, and pass it to `xen-api`.

BREAKING CHANGE: the `cancelToken` option of these methods is replaced by
`signal`.

See XO-3350
2026-11-18 18:13:36 +01:00
MIKITA KAVALIOU
381dacfa9a refactor(xen-api): replace CancelToken with AbortSignal
`callAsync()`, `getResource()` and `putResource()` accept an optional
`AbortSignal` (or `undefined`) as first argument instead of a
promise-toolbox `CancelToken`. The new `abortable` decorator replaces
`cancelable` and keeps the call order `[signal?, cache?, method, ...args]`,
so callers that pass no signal are unchanged.

- `callAsync()`: an already aborted signal starts nothing; on abort, the
  XAPI task is cancelled; the abort listener is removed once the task has
  ended (fixes the "do not trigger if the task is already over" TODO)
- `getResource()`/`putResource()`: an already aborted signal creates no
  task and sends no request, and a task passed by the caller is marked as
  cancelled (`task.cancel` would leave it pending forever, since no request
  drives it); on abort, the HTTP request is closed and the linked XAPI task
  is cancelled (errors ignored)
- a leading `CancelToken` is rejected with a `TypeError` instead of being
  taken as the next argument
- `cancel()` no longer waits for the XAPI task: callers that need it
  await the operation

BREAKING CHANGE: `callAsync()`, `getResource()` and `putResource()` no
longer accept a `CancelToken`, pass an `AbortSignal` instead.

See XO-3350
2026-11-18 18:13:36 +01:00
MikitaKavaliouVates
845e73b610 feat(mixins/Tasks): lifecycle of external tasks (#10778)
* feat(mixins/Tasks): lifecycle of external tasks

External tasks (backups, metadata backups and restores, fed through
createExternalProgressHandler()) now have the same lifecycle as internal ones:

- watch() resolves for them: live root logs are kept from their first event
  until their final state is persisted, so GET /rest/v0/tasks/{id}?wait=true
  now answers at the end of a backup; tasks.get(id) answers them from their
  latest state, even before their first write
- createExternalProgressHandler({ abort }): tasks.abort(id) calls the given
  function; without it, aborting a running external task fails with
  forbiddenOperation instead of noSuchObject
- handler.end(status = 'interrupted', reason) ends the open tasks of a source
  that disappeared, through the caller's hooks; once the root task ended, it
  does nothing

Also fixes, for all tasks:

- a watch() between the end of a task and its persistence never resolved
- an error from the caller's onRootTaskEnd (forwardResult() on a failed
  backup) skipped the buffering of the final state: the log stayed pending
  until restart
- watchers of a clearLogOnSuccess task never saw its end
- a throwing watcher stopped the other watchers and the persistence of task
  logs until restart

No backup executor passes abort or calls end() yet (XO-3352 onward).

Introduced by e66bdda6a (#7841) and 8939a2dee (#9901)

See XO-3351

* docs(changelog): add PR link

See XO-3351

* fix(mixins/Tasks): external task lifecycle review fixes

- handler.end(): the root task end error wins over an earlier subtask hook error, like in feed(),
  and each dropped error is logged
- tests: assert the exact end timestamp of a task instead of only checking it is defined
- tests: name each test by what it checks, without the internal labels (B1, B2, 5.1…)

See XO-3351

* fix(mixins/Tasks): external task lifecycle review fixes

- handler: warn only for the first event sent after end(), drop the next ones silently
- deleteLog: rethrow store errors other than NotFoundError, so a failed read no longer
  drops the live log of a clear-on-success task while the store still holds its pending
  state; #gc logs them
- deleteLog: also delete the live log of a task, which may not be stored yet (first write
  pending or failed), so DELETE /rest/v0/tasks/{id} no longer answers 204 without
  deleting anything

See XO-3351

* chore: external task lifecycle review fixes

- changelog: mention that aborting a running backup task that can't be aborted answers 403
  instead of 404

See XO-3351

* fix(mixins/Tasks): external task lifecycle review fixes

- get(): look at the live logs again when the store says not found, as the first
  event of the task may have arrived while the store was read
- watch(): same check after reading the store, so it follows a task that started
  meanwhile until it ends, instead of answering once with its pending state
- createExternalProgressHandler(): doc says only the first late event is logged

See XO-3351

* fix(rest-api): external task lifecycle review fixes

- DELETE /rest/v0/tasks: log a failed deletion and go on with the others, as
  tasks.deleteLog() now rethrows store errors and the client could not tell
  which deletions went through

See XO-3351

* fix(mixins/Tasks): external task lifecycle review fixes

- get(): copy a live log with the safe encoder when it holds a circular value, as
  xo-server's store saves it, instead of failing
- 'remove' events go through #emitSafely: a throwing listener no longer fails a
  deletion that went through, nor keeps the live log of a cleared task
- handler.end() takes { status, reason }: end('source lost') no longer sets the
  status to the reason
- deleteLog(): say that the log of a running task can be deleted, as XO 5 offers it
  for any task, and test that its next event writes it again

See XO-3351

* fix(mixins/Tasks): external task lifecycle review fixes

- handler.end() walks the log trees of the open root tasks instead of mirroring the
  tasks makeOnProgress tracks; a root still open keeps its open tasks when another
  root of the same source ends
- handler.end(): serialize an Error given as the reason, like the result of an event
  sent by a worker or a proxy; the update hook then rethrows the same object as the
  root end hook (handleBackupLog() and forwardResult() for backups)
- warn about an update hook error after a failed root end only if it is another
  error: handleBackupLog() rethrows the result of a failed backup, like
  forwardResult()
- #gc: call cb when the log to delete is already gone, so a clean no longer hangs
  when a log is deleted between its listing and its deletion
- list(): answer the live tasks in their latest state, like get(), including the
  ones not stored yet; a stored pending log without a live task is read again, or
  skipped if it is gone; the start pass reads the store only, so it never marks a
  live task interrupted
- watch(): every path honours the stop function, including the ones answering the
  final state of a task
- tests: remove is sent once the stored log of a clear-on-success task is deleted,
  and neither update nor remove for one that ends before its first write

See XO-3351

* fix(rest-api): external task lifecycle review fixes

- DELETE /rest/v0/tasks: answer the error again when a deletion fails, as on master;
  Promise.all already lets the other deletions finish

See XO-3351

* chore: external task lifecycle review fixes

- changelog: the 403 instead of 404 on abort applies with sync=true; without it, the
  abort task fails with forbidden operation instead of no such task

See XO-3351

---------

Co-authored-by: Mathieu Piton <mathieu.piton@vates.tech>
2026-11-18 17:50:33 +01:00
Thierry Goettelmann
f647fe0fc6 feat(web-core/table-selection): allow providing the selected ids (#10836)
A table selection always started empty and lived inside the composable,
so a table could not open with rows already selected, nor have its
selection driven from outside (a `defineModel` for example).

A collection flag can now be backed by an external `ids` ref, which
`useTableSelection` exposes as the `selectedIds` option. IDs matching no
item are kept, so the selection can be set before the items are loaded.

Flags are now toggled in batch, so "select all" writes the ref once
instead of once per item.

See XO-3443
2026-11-18 17:22:16 +01:00
Joris K
3ad84220a3 fix(xo6/lite/web-core): restore query builder modal width and fix modal, form and menu button UI (#10832) 2026-11-18 16:03:07 +01:00
Joris K
b5ec15c0c3 feat(xo6/lite/web-core): show an error instead of disabling the type-to-confirm button (#10826) 2026-11-18 15:37:05 +01:00
Joris K
6e5e5e95eb feat(xo6/lite/web-core): open submenus on hover and use menus with the keyboard (#10827) 2026-11-18 15:15:39 +01:00
Joris K
92cb48378b fix(xo6/plugins): render the line breaks and links of plugin descriptions (#10825) 2026-11-18 14:53:42 +01:00
Joris K
7d1e113d32 feat(web-core): navigate modals and menus with the keyboard (#10828) 2026-11-18 14:33:41 +01:00
Elise-F
d93fa3d4de feat(xo6): add edit order action within network for traffic rules (#10706)
* feat(xo6): add edit order action within network for traffic rules

* update changelog

* move reorder logic from drawer to useTrafficRulesOrder

* dedicated column set for the edit order drawer

* test getTrafficRulePriorityUpdates directly

* reserve the default priority of rules without one

* never give priority 0, reserved by XAPI (#10738)

* share traffic rule policy label and accent with useTrafficRulePolicy

* add changelog entry for #10750

* use VtsActionButton for traffic rule edit and delete actions
2026-11-18 11:08:56 +01:00
OlivierFL
dd2b8f227c fix(web-core): vertically center the VtsSuccessStateHero actions (#10824) 2026-11-18 10:47:50 +01:00
140 changed files with 7360 additions and 673 deletions

View File

@@ -78,6 +78,7 @@ module.exports = {
typescript: true,
'eslint-import-resolver-custom-alias': {
alias: {
'@core-test': '../web-core/test',
'@core': '../web-core/lib',
'@': './src',
},
@@ -102,6 +103,7 @@ module.exports = {
{ pattern: '@core/packages/*', action: 'ignore' }, // barrel files
{ pattern: '@core/icons', action: 'ignore' },
{ pattern: '@core/**', action: 'enforce' },
{ pattern: '@core-test/**', action: 'enforce' },
{ pattern: '@/**', action: 'enforce' },
],
},
@@ -123,6 +125,10 @@ module.exports = {
pattern: '@core/**',
group: 'internal',
},
{
pattern: '@core-test/**',
group: 'internal',
},
],
},
],

View File

@@ -190,7 +190,7 @@ export interface Xapi {
deleteNetwork(id: XoNetwork['id']): Promise<void>
deleteVif(vifId: XoVif['id']): Promise<void>
disconnectVif(vifId: XoVif['id']): Promise<void>
exportVmOva(vmRef: XenApiVm['$ref']): Promise<PassThrough>
exportVmOva(vmRef: XenApiVm['$ref'], opts?: { signal?: AbortSignal }): Promise<PassThrough>
emergencyShutdownHost(hostId: XoHost['id']): Promise<void>
ejectHostFromPool(hostId: XoHost['id']): Promise<void>
host_smartReboot(
@@ -352,7 +352,7 @@ export interface Xapi {
): Promise<void>
VM_export(
vmRef: XenApiVm['$ref'],
opts?: { cancelToken?: unknown; compress?: boolean | 'zstd' | 'gzip'; useSnapshot?: boolean }
opts?: { signal?: AbortSignal; compress?: boolean | 'zstd' | 'gzip'; useSnapshot?: boolean }
): ReturnType<Xapi['getResource']>
VM_import(
stream: Readable,
@@ -455,12 +455,12 @@ export interface Xapi {
VDI_destroyCloudInitConfig(vdiRef: XenApiVdi['$ref'], opts?: { timeLimit?: number }): Promise<void>
VDI_exportContent(
vdiRef: XenApiVdi['$ref'],
opts: { baseRef?: string; cancelToken?: unknown; format: SUPPORTED_VDI_FORMAT }
opts: { baseRef?: string; signal?: AbortSignal; format: SUPPORTED_VDI_FORMAT }
): Promise<Readable & { length?: number }>
VDI_importContent(
vdiRef: XenApiVdi['$ref'],
stream: Readable | Buffer,
opts: { cancelToken?: unknown; format: SUPPORTED_VDI_FORMAT }
opts: { signal?: AbortSignal; format: SUPPORTED_VDI_FORMAT }
): Promise<void>
VIF_create(
options: {

View File

@@ -85,7 +85,7 @@ type WrapperXenApi<T, Type extends string, Fn = { (): void }> = T & {
$pool: XenApiPool
$type: Type
$snapshot(params: {
cancelToken?: unknown
signal?: AbortSignal
ignoredVdisTag?: string
name_label?: string
unplugVusbs?: boolean

View File

@@ -0,0 +1,21 @@
// Similar to `Promise.all` + `map` but passes an abort signal to the callback
//
// If any of the executions fails, the signal is aborted (it also follows the optional parent `signal`) and, once the
// other executions have settled, the first reason is rejected: the caller does not clean up while they are still
// running.
export async function abortableMap(signal, iterable, callback) {
const controller = new AbortController()
const childSignal = signal === undefined ? controller.signal : AbortSignal.any([signal, controller.signal])
const promises = []
try {
for (const item of iterable) {
promises.push(callback(childSignal, item))
}
return await Promise.all(promises)
} catch (error) {
controller.abort(error)
await Promise.allSettled(promises)
throw error
}
}

View File

@@ -0,0 +1,93 @@
import { describe, it } from 'node:test'
import { strict as assert } from 'node:assert'
import { abortableMap } from './_abortableMap.mjs'
const tick = () => new Promise(resolve => setImmediate(resolve))
// resolves once `signal` is aborted
const aborted = signal => new Promise(resolve => signal.addEventListener('abort', resolve, { once: true }))
describe('abortableMap()', () => {
it('works without a parent signal', async () => {
const signals = []
const result = await abortableMap(undefined, [1, 2, 3], async (signal, item) => {
signals.push(signal)
return item * 2
})
assert.deepEqual(result, [2, 4, 6])
assert.ok(signals.every(signal => signal instanceof AbortSignal && !signal.aborted))
})
it('aborts the other items and rejects with the first failure once they have settled', async () => {
const error = new Error('first failure')
const signals = []
const stopped = []
await assert.rejects(
abortableMap(undefined, [1, 2, 3], async (signal, item) => {
signals.push(signal)
if (item === 2) {
throw error
}
await aborted(signal)
await tick() // winds down after the abort
stopped.push(item)
throw new Error(`item ${item} aborted`)
}),
error
)
assert.equal(signals.length, 3)
assert.ok(signals.every(signal => signal.aborted))
// the other items have stopped before the rejection
assert.deepEqual(stopped.sort(), [1, 3])
})
it('stops at a synchronous failure, and aborts and waits for the items already started', async () => {
const error = new Error('synchronous failure')
const started = []
const stopped = []
await assert.rejects(
abortableMap(undefined, [1, 2, 3], (signal, item) => {
if (item === 2) {
throw error
}
started.push(item)
return aborted(signal).then(() => {
stopped.push(item)
})
}),
error
)
assert.deepEqual(started, [1])
assert.deepEqual(stopped, [1])
})
it('aborts every item when the parent signal is aborted', async () => {
const parent = new AbortController()
const signals = []
const promise = abortableMap(parent.signal, [1, 2], (signal, item) => {
signals.push(signal)
return new Promise((resolve, reject) => signal.addEventListener('abort', () => reject(signal.reason)))
})
await tick()
assert.ok(signals.every(signal => !signal.aborted))
const reason = new Error('cancelled')
parent.abort(reason)
await assert.rejects(promise, reason)
assert.ok(signals.every(signal => signal.aborted))
})
it('does not abort the parent signal on failure', async () => {
const parent = new AbortController()
await assert.rejects(abortableMap(parent.signal, [1], async () => Promise.reject(new Error('fail'))))
assert.equal(parent.signal.aborted, false)
})
})

View File

@@ -1,20 +0,0 @@
import cancelable from 'promise-toolbox/cancelable'
import CancelToken from 'promise-toolbox/CancelToken'
// Similar to `Promise.all` + `map` but pass a cancel token to the callback
//
// If any of the executions fails, the cancel token will be triggered and the
// first reason will be rejected.
export const cancelableMap = cancelable(async function cancelableMap($cancelToken, iterable, callback) {
const { cancel, token } = CancelToken.source([$cancelToken])
try {
return await Promise.all(
Array.from(iterable, function (item) {
return callback.call(this, token, item)
})
)
} catch (error) {
await cancel()
throw error
}
})

View File

@@ -1,12 +1,11 @@
import groupBy from 'lodash/groupBy.js'
import ignoreErrors from 'promise-toolbox/ignoreErrors'
import { asyncMap } from '@xen-orchestra/async-map'
import { CancelToken } from 'promise-toolbox'
import { compareVersions } from 'compare-versions'
import { defer } from 'golike-defer'
import { Task } from '@vates/task'
import { cancelableMap } from './_cancelableMap.mjs'
import { abortableMap } from './_abortableMap.mjs'
import pick from 'lodash/pick.js'
import { BASE_DELTA_VDI, CONTENT_KEY, COPY_OF, VM_UUID } from './_otherConfig.mjs'
@@ -27,17 +26,13 @@ export async function updateMemoryFields(xapi, targetVm, vmRecord) {
await xapi.call('VM.set_memory_limits', targetVm.$ref, staticMin, staticMax, dynamicMin, dynamicMax)
}
export async function exportIncrementalVm(
vm,
baseVdis = {},
{ cancelToken = CancelToken.none, nbdConcurrency = 1, preferNbd } = {}
) {
export async function exportIncrementalVm(vm, baseVdis = {}, { signal, nbdConcurrency = 1, preferNbd } = {}) {
// refs of VM's VDIs → base's VDIs.
const disks = {}
const vdis = {}
const vbds = {}
await cancelableMap(cancelToken, vm.$VBDs, async (cancelToken, vbd) => {
await abortableMap(signal, vm.$VBDs, async (signal, vbd) => {
let vdi
if (vbd.type !== 'Disk' || !(vdi = vbd.$VDI)) {
// Ignore this VBD.
@@ -135,12 +130,7 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
$defer,
incrementalVm,
sr,
{
cancelToken = CancelToken.none,
newMacAddresses = false,
targetRef = undefined,
vmNamePrefix = '[Importing…] ',
} = {}
{ signal, newMacAddresses = false, targetRef = undefined, vmNamePrefix = '[Importing…] ' } = {}
) {
const { version } = incrementalVm
if (compareVersions(version, '1.0.0') < 0) {
@@ -341,7 +331,7 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
const { disks } = incrementalVm
await Promise.all([
// Import VDI contents.
cancelableMap(cancelToken, Object.entries(newVdis), async (cancelToken, [id, vdi]) => {
abortableMap(signal, Object.entries(newVdis), async (signal, [id, vdi]) => {
for (const disk of ensureArray(disks[id])) {
if (disk === null) {
// we restore a backup and reuse completely a local snapshot
@@ -358,7 +348,7 @@ export const importIncrementalVm = defer(async function importIncrementalVm(
format = 'vhd'
}
await vdi.$importContent(stream, { cancelToken, format })
await vdi.$importContent(stream, { signal, format })
await xapi.setField('VDI', vdi.$ref, 'name_label', vdiRecords[id].name_label)
}

View File

@@ -10,7 +10,7 @@
},
"version": "0.78.0",
"engines": {
"node": ">=14.18"
"node": ">=22.19"
},
"scripts": {
"postversion": "npm publish --access public",

View File

@@ -1,8 +1,9 @@
<template>
<VtsResponsiveMenu :title="t('account')" :section-title="t('menu')" placement="bottom-end">
<template #trigger="{ open, isOpen }">
<template #trigger="{ open, isOpen, bindings }">
<UiAccountMenuButton
v-tooltip="isOpen ? false : { content: t('settings'), placement: 'left' }"
v-bind="bindings"
:selected="isOpen"
size="medium"
@click="open($event)"

View File

@@ -14,8 +14,14 @@
<UiTabItem v-bind="tab(TAB.SLOTS, slotParams)">Slots</UiTabItem>
<UiTabItem v-bind="tab(TAB.SETTINGS, settingParams)">Settings</UiTabItem>
<MenuList placement="bottom">
<template #trigger="{ open, isOpen }">
<UiTabItem :active="isOpen" :disabled="presets === undefined" class="preset-tab" @click="open">
<template #trigger="{ open, isOpen, bindings }">
<UiTabItem
v-bind="bindings"
:active="isOpen"
:disabled="presets === undefined"
class="preset-tab"
@click="open"
>
<VtsIcon name="fa:sliders" size="medium" />
Presets
</UiTabItem>

View File

@@ -1,7 +1,8 @@
<template>
<VtsMobileMenu v-if="uiStore.isSmall" :title="t('actions')">
<template #trigger="{ isOpen, open }">
<template #trigger="{ isOpen, open, bindings }">
<UiButtonIcon
v-bind="bindings"
accent="brand"
size="small"
:disabled="selectedRefs.length === 0"

View File

@@ -4,8 +4,10 @@
<PoolNetworksTable :networks="networksWithPifs" :busy="!isReady" :error="hasError">
<template #title-actions>
<VtsResponsiveMenu :title="t('new')" placement="bottom-end">
<template #trigger="{ open }">
<UiDropdownButton size="medium" variant="primary" @click="open($event)">{{ t('new') }}</UiDropdownButton>
<template #trigger="{ open, bindings }">
<UiDropdownButton v-bind="bindings" size="medium" variant="primary" @click="open($event)">
{{ t('new') }}
</UiDropdownButton>
</template>
<MenuItem accent="neutral">
<UiLink class="new-network-link" :to="{ name: '/network/new' }" icon="fa:plus" size="medium">

View File

@@ -20,8 +20,8 @@
]"
>
<MenuList v-if="settings.inMenu" placement="bottom-start">
<template #trigger="{ open }">
<UiButtonIcon accent="brand" icon="action:more-actions" size="medium" @click="open($event)" />
<template #trigger="{ open, bindings }">
<UiButtonIcon v-bind="bindings" accent="brand" icon="action:more-actions" size="medium" @click="open($event)" />
</template>
<VtsActionButton v-bind="properties">{{ settings.label }}</VtsActionButton>
</MenuList>

View File

@@ -1,8 +1,8 @@
<template>
<ComponentStory :params="[slot().help('Power state actions, shown in the submenu')]">
<MenuList placement="bottom-start">
<template #trigger="{ open }">
<UiButtonIcon accent="brand" icon="action:more-actions" size="medium" @click="open($event)" />
<template #trigger="{ open, bindings }">
<UiButtonIcon v-bind="bindings" accent="brand" icon="action:more-actions" size="medium" @click="open($event)" />
</template>
<VtsChangeStateMenuItem>
<MenuItem accent="neutral" icon="fa:play" :on-click>Start</MenuItem>

View File

@@ -5,13 +5,13 @@
prop('title').str().required().preset('More actions').widget(),
prop('sectionTitle').str().preset('Actions').widget(),
event('action').help('Emitted when a menu item closes the menu after its action'),
slot('trigger').prop('open', '() => void').prop('isOpen', 'boolean'),
slot('trigger').prop('open', '() => void').prop('isOpen', 'boolean').prop('bindings', 'MenuTriggerBindings'),
slot().help('Menu items, a submenu opens in place'),
]"
>
<VtsMobileMenu v-bind="properties">
<template #trigger="{ open }">
<UiButtonIcon accent="brand" icon="action:more-actions" size="medium" @click="open()" />
<template #trigger="{ open, bindings }">
<UiButtonIcon v-bind="bindings" accent="brand" icon="action:more-actions" size="medium" @click="open()" />
</template>
<MenuItem accent="brand" icon="action:change-state">
Change state

View File

@@ -7,13 +7,16 @@
prop('placement').str().preset('bottom-start').widget().help('Placement of the dropdown on desktop'),
prop('disabled').bool().widget(),
event('action').help('Emitted on mobile when a menu item closes the menu after its action'),
slot('trigger').prop('open', '(event: MouseEvent) => void').prop('isOpen', 'boolean'),
slot('trigger')
.prop('open', '(event: MouseEvent) => void')
.prop('isOpen', 'boolean')
.prop('bindings', 'MenuTriggerBindings'),
slot().help('Menu items'),
]"
>
<VtsResponsiveMenu v-bind="properties">
<template #trigger="{ open, isOpen }">
<UiDropdownButton variant="primary" size="medium" :selected="isOpen" @click="open($event)">
<template #trigger="{ open, isOpen, bindings }">
<UiDropdownButton v-bind="bindings" variant="primary" size="medium" :selected="isOpen" @click="open($event)">
New
</UiDropdownButton>
</template>

View File

@@ -14,6 +14,7 @@
prop('disabled').bool().widget().ctx(),
prop('lockIcon').bool().widget(),
iconProp('leftIcon'),
iconProp('rightIcon'),
setting('label').preset('Click me').widget(),
]"
:presets="{

View File

@@ -1,8 +1,9 @@
import { createLogger } from '@xen-orchestra/log'
import { EventEmitter } from 'node:events'
import { makeOnProgress } from '@vates/task/combineEvents'
import { noSuchObject } from 'xo-common/api-errors.js'
import { forbiddenOperation, noSuchObject } from 'xo-common/api-errors.js'
import { Task, serializeError } from '@vates/task'
import jsonStringifySafe from 'json-stringify-safe'
import iteratee from 'lodash/iteratee.js'
import stubTrue from 'lodash/stubTrue.js'
@@ -10,7 +11,30 @@ export { Task }
const { warn } = createLogger('xo:mixins:Tasks')
const noop = Function.prototype
// a copy, as the store returns: a live log keeps changing, and must not be changed by the caller. Like the store of
// xo-server when it saves a log, circular references are replaced instead of making the copy fail.
const copyLog = log => {
let json
try {
json = JSON.stringify(log)
} catch {
json = jsonStringifySafe(log)
}
return JSON.parse(json)
}
// the tasks of a log tree that have not ended, each one after its subtasks
function* openTasks(taskLog) {
const { tasks } = taskLog
if (tasks !== undefined) {
for (const subtask of tasks) {
yield* openTasks(subtask)
}
}
if (taskLog.status === 'pending') {
yield taskLog
}
}
const DEFAULT_BACKUP_LOG_KEEP_DURATION = 31 * 24 * 60 * 60 * 1000
@@ -38,33 +62,73 @@ export default class Tasks extends EventEmitter {
#onProgressBuffer = new Map()
#handleOnProgressScheduled = false
// root logs of live tasks (internal and external), from their first event until their final state is persisted
#liveLogs = new Map()
// a watcher must not prevent the other watchers from being notified, nor the persistence of the other updates
#emitSafely(event, taskLog) {
for (const listener of this.rawListeners(event)) {
try {
listener.call(this, taskLog)
} catch (error) {
warn('failure in task watcher', { error, event, taskLog })
}
}
}
#handleOnProgressBuffer = async () => {
const buf = this.#onProgressBuffer
const liveLogs = this.#liveLogs
const store = this.#store
do {
for (const [id, taskLog] of buf) {
buf.delete(id)
if (taskLog === null) {
try {
await this.deleteLog(id)
} catch (error) {
warn('failure on deleting task log from store', { error, taskLog })
}
} else {
this.emit(id, taskLog)
this.emit('update', taskLog)
try {
do {
for (const [id, taskLog] of buf) {
buf.delete(id)
try {
await store.put(id, taskLog)
} catch (error) {
warn('failure on saving task log in store', { error, taskLog })
// read before the write: an event arriving during the write changes the log and buffers the id again
const { status } = taskLog
const isFinal = status !== 'pending'
const deleteAfterNotify = isFinal && this.#logsToClearOnSuccess.delete(id) && status === 'success'
// the final state of a clear-on-success task is notified on its id, then its log is deleted
let written = false
this.#emitSafely(id, taskLog)
if (deleteAfterNotify) {
try {
const storedLog = await this.#deleteStored(id)
if (storedLog !== undefined) {
this.#emitSafely('remove', storedLog)
}
written = true
} catch (error) {
warn('failure on deleting task log from store', { error, taskLog })
}
} else {
this.#emitSafely('update', taskLog)
try {
await store.put(id, taskLog)
written = true
} catch (error) {
warn('failure on saving task log in store', { error, taskLog })
}
}
// keep the live entry until the final state is persisted: a newer state of the same task may be buffered,
// and if the write failed the store still holds an older state, which watchers must not get
// (the entry then stays until restart, which marks the stored log interrupted)
if (isFinal && written && !buf.has(id)) {
liveLogs.delete(id)
}
}
}
} while (buf.size !== 0) // new events may have been added during iteration
this.#handleOnProgressScheduled = false
} while (buf.size !== 0) // new events may have been added during iteration
} finally {
// re-armed right after the last check of the buffer, with no await in between: an event buffered after it
// schedules a new flush. Also re-armed if the flush failed, otherwise nothing is persisted until restart.
this.#handleOnProgressScheduled = false
}
}
#bufferTaskUpdate = taskLog => {
@@ -85,16 +149,8 @@ export default class Tasks extends EventEmitter {
}
const { $root } = taskLog
const { status, id } = $root
if (status !== 'pending') {
if (this.#logsToClearOnSuccess.has(id)) {
this.#logsToClearOnSuccess.delete(id)
if (status === 'success') {
return buf.set(id, null)
}
}
}
const { id } = $root
this.#liveLogs.set(id, $root)
$root.updatedAt = Date.now()
buf.set(id, $root)
@@ -128,10 +184,13 @@ export default class Tasks extends EventEmitter {
.on('start', async () => {
this.#store = await app.getStore('tasks')
for await (const taskLog of this.list({ filter: _ => _.status === 'pending' })) {
taskLog.status = 'interrupted'
taskLog.updatedAt = Date.now()
await this.#store.put(taskLog.id, taskLog)
// from the store only: list() also returns the live tasks, which must not be marked interrupted
for await (const [, taskLog] of this.#store.iterator()) {
if (taskLog.status === 'pending') {
taskLog.status = 'interrupted'
taskLog.updatedAt = Date.now()
await this.#store.put(taskLog.id, taskLog)
}
}
return () => this.#store.close()
@@ -158,7 +217,18 @@ export default class Tasks extends EventEmitter {
const deleteEntry = data => {
++count
this.deleteLog(data.key, cb)
// cb may already have been called by the store if the error comes after the deletion
let done = false
const once = () => {
if (!done) {
done = true
cb()
}
}
this.deleteLog(data.key, once).catch(error => {
warn('failure on deleting task log from store', { error, id: data.key })
once()
})
}
const stream = db.createReadStream({
@@ -193,26 +263,156 @@ export default class Tasks extends EventEmitter {
* Each call returns an independent makeOnProgress context (isolated taskLogs
* Map), so concurrent backup jobs don't interfere with each other.
*
* Abort support for external tasks is not implemented — the external process
* controls its own lifecycle.
* Options:
* - abort: `(reason) => …` called by `tasks.abort(rootId, reason)` while the
* root task runs. Without it, aborting the task fails with `forbiddenOperation`.
*
* The returned handler has an `end({ status = 'interrupted', reason })` method for
* a source that disappeared without ending its root task. It ends the open
* tasks, innermost first, through the same path as the events of the source,
* so the caller's hooks run and may change the status (for backups,
* `handleBackupLog` recomputes it). Hook errors are rethrown once every open
* task is ended. Once `end()` has ended the open tasks, later events are
* dropped: the first one with a warning, the next ones silently. Called
* before the first event or after the root task ended, it does nothing.
*/
createExternalProgressHandler({ onRootTaskEnd, onRootTaskStart, onTaskUpdate } = {}) {
return makeOnProgress({
onRootTaskEnd,
onRootTaskStart,
createExternalProgressHandler({ abort, onRootTaskEnd, onRootTaskStart, onTaskUpdate } = {}) {
// error thrown by the caller's onRootTaskEnd: the final state must still be buffered (see onTaskUpdate below)
let rootEndError
// logs of the root tasks accepted by makeOnProgress and not yet ended: end() walks their trees
const openRoots = new Set()
let closed = false
// a source that keeps sending events after end() is reported once
let warnedAfterClose = false
const onProgress = makeOnProgress({
onRootTaskEnd: (taskLog, event) => {
// the task can no longer be aborted once it ended
this.#tasks.delete(taskLog.id)
// subtasks the source left open end with their root: end() no longer sees them
openRoots.delete(taskLog)
try {
onRootTaskEnd?.(taskLog, event)
} catch (error) {
rootEndError = { error }
}
},
onRootTaskStart: (taskLog, event) => {
// tracked here, once makeOnProgress has registered it, in case the caller's hook throws
openRoots.add(taskLog)
if (abort !== undefined) {
this.#tasks.set(taskLog.id, { abort })
}
onRootTaskStart?.(taskLog, event)
},
onTaskUpdate: (taskLog, event) => {
// a subtask whose start had an unknown parent is registered by makeOnProgress, which then throws before
// calling this hook: it has no root, so its later events are ignored
if (taskLog.$root === undefined) {
warn('event of a task without root task ignored', { event })
return
}
this.#bufferTaskUpdate(taskLog)
onTaskUpdate?.(taskLog, event)
},
})
// feeds one event, then rethrows the error of the root end hook, if any
const feed = event => {
try {
onProgress(event)
} catch (error) {
// the root end error carries the result of the task: it wins over a later hook error (onTaskUpdate),
// and must not be thrown on a later, unrelated event
if (rootEndError !== undefined) {
const rootError = rootEndError.error
rootEndError = undefined
// the update hook may rethrow the same error, like handleBackupLog() and forwardResult() for backups: only
// another error is worth a warning
if (error !== rootError) {
warn('failure in task update hook after the root task end hook failed', { error, event })
}
throw rootError
}
throw error
}
if (rootEndError !== undefined) {
const { error } = rootEndError
rootEndError = undefined
throw error
}
}
function handler(event) {
if (closed) {
if (!warnedAfterClose) {
warnedAfterClose = true
warn('event received after the external task was ended, later ones are dropped silently', { event })
}
return
}
feed(event)
}
function end({ status = 'interrupted', reason } = {}) {
// nothing to end: not started yet, or already ended
if (openRoots.size === 0) {
return
}
closed = true
// like the result of an event sent by a worker or a proxy: the update hook then rethrows the same object as the
// root end hook (handleBackupLog() and forwardResult() for backups), which the log keeps serialized
const result = reason instanceof Error ? serializeError(reason) : reason
let thrown
for (const root of [...openRoots]) {
// listed before ending them, as ending a task may sort the subtasks of its parent (handleBackupLog)
for (const { id } of [...openTasks(root)]) {
try {
feed({ type: 'end', id, timestamp: Date.now(), status, result })
} catch (error) {
// a root end error carries the result of its task: the first one wins, like in feed(); the others are
// logged
const isRoot = id === root.id
if (thrown === undefined) {
thrown = { error, id, isRoot }
} else if (isRoot && !thrown.isRoot) {
warn('failure in task end hook, superseded by the root task error', {
error: thrown.error,
id: thrown.id,
})
thrown = { error, id, isRoot }
} else {
warn('failure in task end hook', { error, id })
}
}
}
}
if (thrown !== undefined) {
throw thrown.error
}
}
return Object.assign(handler, { end })
}
async abort(id, reason) {
const task = this.#tasks.get(id)
if (task === undefined) {
throw noSuchObject(id, 'task')
if (task !== undefined) {
return task.abort(reason)
}
return task.abort(reason)
// running external task without abort option
const liveLog = this.#liveLogs.get(id)
if (liveLog !== undefined && liveLog.status === 'pending') {
throw forbiddenOperation('abort', 'this task cannot be aborted')
}
throw noSuchObject(id, 'task')
}
async clearLogs() {
@@ -245,16 +445,64 @@ export default class Tasks extends EventEmitter {
return task
}
/**
* Deletes the log of a task, stored or live: a live task may not be stored yet, or only in an older state if its
* last write failed.
*
* The log of a running task can be deleted too (XO 5 offers it for any task): the next event of the task writes it
* again.
*/
async deleteLog(id, cb) {
const log = await this.get(id).catch(noop)
const storedLog = await this.#deleteStored(id, cb)
const liveLog = this.#liveLogs.get(id)
this.#liveLogs.delete(id)
const log = liveLog ?? storedLog
if (log !== undefined) {
await this.#store.del(id, cb)
this.emit('remove', log)
this.#emitSafely('remove', log)
}
}
// deletes the stored log of a task and returns it, undefined if there is none; other store errors are thrown
async #deleteStored(id, cb) {
let log
try {
log = await this.#getStored(id)
} catch (error) {
if (noSuchObject.is(error)) {
// nothing to delete, but #gc waits for cb
cb?.()
return
}
throw error
}
await this.#store.del(id, cb)
return log
}
/**
* Returns the log of a task: its latest state if it is live, even if not yet persisted (e.g. an external task
* between its first event and its first write), its stored state otherwise.
*/
async get(id) {
const liveLog = this.#liveLogs.get(id)
if (liveLog !== undefined) {
return copyLog(liveLog)
}
try {
return await this.#getStored(id)
} catch (error) {
// the first event of the task may have arrived while the store was read
const liveLog = this.#liveLogs.get(id)
if (liveLog !== undefined && noSuchObject.is(error)) {
return copyLog(liveLog)
}
throw error
}
}
async #getStored(id) {
try {
return await this.#store.get(id)
} catch (error) {
@@ -265,37 +513,107 @@ export default class Tasks extends EventEmitter {
}
}
/**
* Lists the logs of the tasks: a live task in its latest state, like get(), even if it is not stored yet.
*/
async *list({ filter, limit = Infinity } = {}) {
const predicate = filter === undefined ? stubTrue : typeof filter === 'function' ? filter : iteratee(filter)
const liveLogs = this.#liveLogs
for await (const [, taskLog] of this.#store.iterator()) {
// ids of the live tasks already listed from the store
const listed = new Set()
for await (const [, storedLog] of this.#store.iterator()) {
const { id } = storedLog
const liveLog = liveLogs.get(id)
let taskLog = storedLog
if (liveLog !== undefined) {
listed.add(id)
taskLog = copyLog(liveLog)
} else if (storedLog.status === 'pending') {
// pending logs of the previous runs are marked interrupted at start: this one belongs to a task that ended or
// was deleted since the listing read the store
try {
taskLog = await this.#getStored(id)
} catch (error) {
if (noSuchObject.is(error)) {
continue
}
throw error
}
}
if (predicate(taskLog)) {
yield taskLog
if (--limit < 1) {
break
return
}
}
}
// live tasks the store did not list: not stored yet, or stored after the listing started
for (const [id, liveLog] of liveLogs) {
if (!listed.has(id)) {
const taskLog = copyLog(liveLog)
if (predicate(taskLog)) {
yield taskLog
if (--limit < 1) {
return
}
}
}
}
}
async watch(id, cb) {
// live task
if (this.#tasks.has(id)) {
this.on(id, cb)
// always called later: the caller may use the value returned by watch() in cb (e.g. to stop watching), and an
// error of cb must not escape as an uncaught exception
let stopped = false
const stop = () => {
stopped = true
}
const callLater = taskLog =>
setImmediate(() => {
if (stopped) {
return
}
try {
cb(taskLog)
} catch (error) {
warn('failure in task watcher', { error, id, taskLog })
}
})
let stopWatch = () => {
this.off(id, cb)
stopWatch = noop
// returns the function to stop watching if the task is live, undefined otherwise
const watchLive = () => {
// live task whose final state is already known, even if not yet persisted
const liveLog = this.#liveLogs.get(id)
if (liveLog !== undefined && liveLog.status !== 'pending') {
callLater(liveLog)
return stop
}
return () => stopWatch()
// live task
if (liveLog !== undefined || this.#tasks.has(id)) {
// the flush of updates may run before the caller gets the return value of watch()
this.on(id, callLater)
return () => {
stop()
this.off(id, callLater)
}
}
}
const stopLive = watchLive()
if (stopLive !== undefined) {
return stopLive
}
// unknown task will throw noSuchObject
const taskLog = await this.get(id)
// finished task
setImmediate(cb, taskLog)
return noop
// the first event of the task may have arrived while the store was read: watch it until it ends
return watchLive() ?? (callLater(taskLog), stop)
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -30,6 +30,7 @@
"app-conf": "^3.0.0",
"fast-xml-parser": "^4.0.0",
"golike-defer": "^0.5.1",
"json-stringify-safe": "^5.0.1",
"lodash": "^4.18.0",
"promise-toolbox": "^0.21.0",
"xo-common": "^0.11.0"

View File

@@ -2,12 +2,15 @@
Testing uses **Vitest 4** with a single `unit` project (see `vitest.config.ts`): every test matches `**/*.unit.test.ts` and runs on `happy-dom`, CLI-only, no browser. Conventions follow the [XO 6 test docs](../../web/docs/tests.md).
| Path | Role |
| ---------------------- | ------------------------------------------------------------------------- |
| `vitest.config.ts` | Runner config: `vue` + `vue-i18n` plugins, `@core` alias, `globals: true` |
| `test/setup.ts` | Global setup: auto-unmounts every mounted wrapper after each test |
| `tsconfig.vitest.json` | Type-checks test files with the Vitest globals |
| `tsconfig.app.json` | Type-checks the library, test files excluded |
| Path | Role |
| ----------------------------------- | ----------------------------------------------------------------------------------------------------- |
| `vitest.config.ts` | Runner config: `vue` + `vue-i18n` plugins, `@core` / `@core-test` aliases, `globals: true` |
| `test/setup.ts` | Global setup: auto-unmounts every mounted wrapper after each test |
| `test/create-global-test-config.ts` | `global` mount options: the real `vue-i18n`, a Pinia and a router (needed by `useUiStore`) |
| `test/i18n.ts` | The `t` of that `vue-i18n` instance, to build expected texts from their translation key |
| `test/mount-composable.ts` | `mountComposable`: runs a composable inside a mounted component, its result read through `wrapper.vm` |
| `tsconfig.vitest.json` | Type-checks test files with the Vitest globals and the `@core-test` alias |
| `tsconfig.app.json` | Type-checks the library, test files excluded |
Test files sit next to the code they test, as `lib/**/*.unit.test.ts`. Shared test infrastructure lives in `test/`, outside `lib/`. The shared `scripts/npmignore` keeps all of it out of the published package.

View File

@@ -1,11 +1,12 @@
<template>
<VtsResponsiveMenu :title="t('action:copy-all')" placement="bottom-end">
<template #trigger="{ open }">
<template #trigger="{ open, bindings }">
<UiButtonIcon
v-tooltip="{
placement: 'left',
content: tooltipContent,
}"
v-bind="bindings"
:icon
accent="brand"
size="small"

View File

@@ -0,0 +1,66 @@
import VtsInputWrapper, { type InputWrapperMessage } from '@core/components/input-wrapper/VtsInputWrapper.vue'
import UiFileUploader from '@core/components/ui/file-uploader/UiFileUploader.vue'
import UiInput from '@core/components/ui/input/UiInput.vue'
import { createGlobalTestConfig } from '@core-test/create-global-test-config.ts'
import { mount, type VueWrapper } from '@vue/test-utils'
import { h } from 'vue'
function mountInputWrapper(message?: InputWrapperMessage) {
return mount(VtsInputWrapper, {
global: createGlobalTestConfig(),
props: { label: 'Name', message },
slots: { default: () => h(UiInput, { modelValue: '', accent: 'brand' }) },
})
}
function findMessageIds(wrapper: VueWrapper) {
return wrapper.findAll('.ui-info').map(message => message.attributes('id'))
}
describe('VtsInputWrapper', () => {
it('leaves the input undescribed and valid without message', () => {
const input = mountInputWrapper().get('input')
expect(input.attributes('aria-describedby')).toBeUndefined()
expect(input.attributes('aria-invalid')).toBeUndefined()
})
it('describes the input with every message', () => {
const wrapper = mountInputWrapper(['Info', { content: 'Warning', accent: 'warning' }])
const messageIds = findMessageIds(wrapper)
expect(messageIds).toHaveLength(2)
expect(wrapper.get('input').attributes('aria-describedby')).toBe(messageIds.join(' '))
})
it.each([
{ accent: 'info', expected: undefined },
{ accent: 'success', expected: undefined },
{ accent: 'warning', expected: undefined },
{ accent: 'muted', expected: undefined },
{ accent: 'danger', expected: 'true' },
] as const)('sets aria-invalid to $expected for a $accent message', ({ accent, expected }) => {
const input = mountInputWrapper({ content: 'Message', accent }).get('input')
expect(input.attributes('aria-invalid')).toBe(expected)
})
it('marks the input as invalid when a danger message sits beside other messages', () => {
const input = mountInputWrapper([
{ content: 'Error', accent: 'danger' },
{ content: 'Warning', accent: 'warning' },
]).get('input')
expect(input.attributes('aria-invalid')).toBe('true')
})
it('describes the file uploader with its messages', () => {
const wrapper = mount(VtsInputWrapper, {
global: createGlobalTestConfig(),
props: { label: 'File', message: 'Info' },
slots: { default: () => h(UiFileUploader, { accent: 'neutral' }) },
})
expect(wrapper.get('button.dropzone').attributes('aria-describedby')).toBe(findMessageIds(wrapper).join(' '))
})
})

View File

@@ -4,7 +4,13 @@
<slot name="label">{{ label }}</slot>
</UiLabel>
<slot />
<UiInfo v-for="{ content, accent } of messages" :key="content" :accent :wrap="wrapMessage">
<UiInfo
v-for="({ content, accent }, index) of messages"
:id="messageIds[index]"
:key="content"
:accent
:wrap="wrapMessage"
>
<slot name="message" :content :accent>{{ content }}</slot>
</UiInfo>
</div>
@@ -19,7 +25,7 @@ import type { MaybeArray } from '@core/types/utility.type.ts'
import { IK_INPUT_WRAPPER_CONTROLLER } from '@core/utils/injection-keys.util.ts'
import { toArray } from '@core/utils/to-array.utils.ts'
import { useArrayMap } from '@vueuse/core'
import { provide, reactive, useId } from 'vue'
import { computed, provide, reactive, useId } from 'vue'
export type InputWrapperMessage = MaybeArray<string | { content: string; accent?: InfoAccent }>
@@ -27,6 +33,8 @@ export type InputWrapperController = {
id: string
labelAccent: LabelAccent
required: boolean
describedBy: string | undefined
invalid: boolean
}
const { message: rawMessage } = defineProps<{
@@ -66,10 +74,18 @@ const labelAccent = useMapper<InfoAccent, LabelAccent>(
'info'
)
const messageIds = computed(() => messages.value.map((_, index) => `${id}-message-${index}`))
const describedBy = computed(() => (messageIds.value.length > 0 ? messageIds.value.join(' ') : undefined))
const invalid = computed(() => messages.value.some(({ accent }) => accent === 'danger'))
const wrapperController = reactive({
id,
labelAccent,
required: false,
describedBy,
invalid,
}) satisfies InputWrapperController
provide(IK_INPUT_WRAPPER_CONTROLLER, wrapperController)

View File

@@ -1,6 +1,6 @@
<!-- v1.0 -->
<template>
<li class="menu-item">
<li class="menu-item" role="none">
<MenuTrigger
v-if="!slots.submenu || mobileMenu"
:accent
@@ -10,20 +10,27 @@
:icon
class="typo-body-bold-small"
@click="handleClick()"
@pointermove="(event: PointerEvent) => handlePointerMove(event)"
@pointerleave="(event: PointerEvent) => handlePointerLeave(event)"
>
<slot />
<VtsIcon v-if="slots.submenu" name="fa:angle-right" size="medium" />
</MenuTrigger>
<MenuList v-else :disabled="isDisabled">
<template #trigger="{ open, isOpen }">
<MenuList v-else ref="submenu" v-model:open="isSubmenuOpen" :anchor="triggerElement" :disabled="isDisabled">
<template #trigger="{ bindings }">
<MenuTrigger
ref="trigger"
v-bind="bindings"
:accent
:active="isOpen"
:busy="isBusy"
:disabled="isDisabled"
class="typo-body-bold-small"
:icon
@click="open"
:selected="isSubmenuOpen"
class="typo-body-bold-small"
@click="openSubmenu()"
@keydown="(event: KeyboardEvent) => openSubmenuOnKeydown(event)"
@pointermove="(event: PointerEvent) => handlePointerMove(event)"
@pointerleave="(event: PointerEvent) => handlePointerLeave(event)"
>
<slot />
<VtsIcon :name="submenuIcon" size="medium" class="submenu-icon" />
@@ -39,9 +46,11 @@ import VtsIcon from '@core/components/icon/VtsIcon.vue'
import MenuList from '@core/components/menu/MenuList.vue'
import MenuTrigger from '@core/components/menu/MenuTrigger.vue'
import { useDisabled } from '@core/composables/disabled.composable.ts'
import { useMenuLevel } from '@core/composables/menu-level.composable.ts'
import type { IconName } from '@core/icons'
import { IK_CLOSE_MENU, IK_MENU_HORIZONTAL, IK_MOBILE_MENU } from '@core/utils/injection-keys.util.ts'
import { computed, inject, ref } from 'vue'
import { IK_CLOSE_MENU, IK_MENU_HORIZONTAL, IK_MENU_LEVEL, IK_MOBILE_MENU } from '@core/utils/injection-keys.util.ts'
import { unrefElement } from '@vueuse/core'
import { computed, inject, nextTick, ref, useId, useTemplateRef } from 'vue'
export type MenuItemAccent = 'neutral' | 'brand' | 'danger' | 'warning'
@@ -66,11 +75,29 @@ const isDisabled = useDisabled(() => disabled)
const submenuIcon = computed((): IconName => (isParentHorizontal.value ? 'fa:angle-down' : 'fa:angle-right'))
const submenuKey = computed(() => (isParentHorizontal.value ? 'ArrowDown' : 'ArrowRight'))
const isHandlingClick = ref(false)
const isBusy = computed(() => isHandlingClick.value || busy === true)
const closeMenu = inject(IK_CLOSE_MENU, undefined)
const mobileMenu = inject(IK_MOBILE_MENU, undefined)
const id = useId()
const level = inject(IK_MENU_LEVEL, () => useMenuLevel({ isPopup: false, horizontal: false }), true)
const trigger = useTemplateRef('trigger')
const submenu = useTemplateRef('submenu')
const triggerElement = computed(() => {
const element = unrefElement(trigger)
return element instanceof HTMLElement ? element : undefined
})
const isSubmenuOpen = computed({
get: () => level.openedItemId.value === id,
set: isOpen => (isOpen ? level.openItem(id) : level.closeItem(id)),
})
const handleClick = async () => {
if (isDisabled.value || isBusy.value) {
return
@@ -89,6 +116,43 @@ const handleClick = async () => {
isHandlingClick.value = false
}
}
async function openSubmenu() {
if (isDisabled.value) {
return
}
level.openItem(id)
await nextTick()
submenu.value?.focusFirstItem()
}
function openSubmenuOnKeydown(event: KeyboardEvent) {
if (event.key !== submenuKey.value) {
return
}
event.preventDefault()
openSubmenu()
}
function handlePointerMove(event: PointerEvent) {
if (event.pointerType !== 'mouse') {
return
}
level.hoverItem(
{ itemId: id, hasSubmenu: slots.submenu !== undefined && mobileMenu === undefined && !isDisabled.value },
event
)
}
function handlePointerLeave(event: PointerEvent) {
if (event.pointerType === 'mouse') {
level.leaveItem(id, event)
}
}
</script>
<style lang="postcss" scoped>

View File

@@ -1,13 +1,17 @@
<!-- v1.0 -->
<template>
<slot :is-open="isOpen" :open="open" name="trigger" />
<slot :bindings="triggerBindings" :is-open="isOpen" :open="open" name="trigger" />
<Teleport :disabled="!hasTrigger" to="body">
<ul
v-if="!hasTrigger || isOpen"
:id="menuId"
ref="menu"
:aria-orientation="horizontal ? 'horizontal' : undefined"
:class="{ horizontal, border: !noBorder }"
class="menu-list"
role="menu"
v-bind="$attrs"
@pointerenter="parentLevel?.enterSubmenu()"
>
<slot />
</ul>
@@ -16,45 +20,68 @@
<script lang="ts" setup>
import { useDisabled } from '@core/composables/disabled.composable.ts'
import { useMenuLevel } from '@core/composables/menu-level.composable.ts'
import { useMenuListNavigation } from '@core/composables/menu-list-navigation.composable.ts'
import { useMenuPopup } from '@core/composables/menu-popup.composable.ts'
import {
IK_CLOSE_MENU,
IK_IN_MENU,
IK_MENU_HORIZONTAL,
IK_MENU_LEVEL,
IK_MENU_PLACEMENT_SIDE,
} from '@core/utils/injection-keys.util.ts'
import { placeOverlay } from '@core/utils/placement.util.ts'
import { onClickOutside, unrefElement, whenever } from '@vueuse/core'
import type { Options } from 'placement.js'
import { computed, inject, nextTick, provide, ref, useSlots } from 'vue'
import { computed, inject, nextTick, provide, shallowRef, useId, useTemplateRef, watch } from 'vue'
export type MenuTriggerBindings = {
'aria-haspopup': 'menu' | 'dialog'
'aria-expanded': boolean
'aria-controls'?: string
}
defineOptions({
inheritAttrs: false,
})
const props = defineProps<{
const { horizontal, noBorder, disabled, placement, anchor } = defineProps<{
horizontal?: boolean
noBorder?: boolean
disabled?: boolean
placement?: Options['placement']
anchor?: HTMLElement
}>()
const slots = useSlots()
const isOpen = ref(false)
const menu = ref()
const isOpen = defineModel<boolean>('open', { default: false })
const slots = defineSlots<{
default(): any
trigger?(props: { isOpen: boolean; open: (event: Event) => void; bindings: MenuTriggerBindings }): any
}>()
const hasTrigger = slots.trigger !== undefined
const menu = useTemplateRef<HTMLElement>('menu')
const menuId = useId()
const triggerElement = shallowRef<HTMLElement>()
const anchorElement = computed(() => anchor ?? triggerElement.value)
const triggerBindings = computed<MenuTriggerBindings>(() => ({
'aria-haspopup': 'menu',
'aria-expanded': isOpen.value,
'aria-controls': isOpen.value ? menuId : undefined,
}))
const isParentHorizontal = inject(
IK_MENU_HORIZONTAL,
computed(() => false)
)
provide(
IK_MENU_HORIZONTAL,
computed(() => props.horizontal ?? false)
computed(() => horizontal)
)
useDisabled(() => props.disabled)
useDisabled(() => disabled)
const parentPlacementSide = inject(IK_MENU_PLACEMENT_SIDE, undefined)
const placementSide = ref<string>()
provide(IK_MENU_PLACEMENT_SIDE, placementSide)
const defaultPlacement = computed<Options['placement']>(() => {
if (isParentHorizontal.value) {
@@ -64,44 +91,58 @@ const defaultPlacement = computed<Options['placement']>(() => {
return parentPlacementSide?.value === 'left' ? 'left-start' : 'right-start'
})
let clearClickOutsideEvent: (() => void) | undefined
const hasTrigger = useSlots().trigger !== undefined
const parentLevel = inject(IK_MENU_LEVEL, undefined)
const isSubmenu = hasTrigger && parentLevel !== undefined
const level = useMenuLevel({ isPopup: hasTrigger, horizontal: () => horizontal })
provide(IK_MENU_LEVEL, level)
provide(IK_IN_MENU, true)
whenever(
() => !isOpen.value,
() => clearClickOutsideEvent?.()
)
if (slots.trigger && inject(IK_CLOSE_MENU, undefined) === undefined) {
provide(IK_CLOSE_MENU, () => (isOpen.value = false))
const { placementSide, close } = useMenuPopup(menu, {
isOpen,
anchor: anchorElement,
placement: () => placement ?? defaultPlacement.value,
closesOnClickOutside: hasTrigger && parentLevel?.isPopup !== true,
hasOpenSubmenu: () => level.openedItemId.value !== undefined,
onClosed: () => level.close(),
})
provide(IK_MENU_PLACEMENT_SIDE, placementSide)
const injectedCloseMenu = inject(IK_CLOSE_MENU, undefined)
const closeMenu = injectedCloseMenu ?? close
if (injectedCloseMenu === undefined) {
provide(IK_CLOSE_MENU, hasTrigger ? close : level.close)
}
const open = (event: MouseEvent) => {
const { focusFirstItem } = useMenuListNavigation({
target: () => (hasTrigger ? menu.value : undefined),
isHorizontal: () => horizontal,
canCloseWithArrowLeft: () => isSubmenu && !isParentHorizontal.value,
onClose: () => close(true),
onLeave: () => closeMenu(true),
})
async function open(event: Event) {
if (isOpen.value) {
return (isOpen.value = false)
isOpen.value = false
return
}
triggerElement.value = event.currentTarget as HTMLElement
isOpen.value = true
const trigger = event.currentTarget as HTMLElement
nextTick(() => {
clearClickOutsideEvent = onClickOutside(menu, () => (isOpen.value = false), {
ignore: () => [trigger, '.menu-list'],
controls: false,
})
const menuElement = unrefElement(menu)
placeOverlay(trigger, menuElement, {
placement: props.placement ?? defaultPlacement.value,
})
placementSide.value = menuElement.dataset.placement?.split('-')[0]
})
await nextTick()
focusFirstItem()
}
watch(menu, (menuElement, _, onCleanup) => {
if (menuElement !== null && isSubmenu) {
onCleanup(parentLevel.registerSubmenu(menuElement))
}
})
defineExpose({ focusFirstItem })
</script>
<style lang="postcss" scoped>

View File

@@ -1,6 +1,6 @@
<!-- v1.0 -->
<template>
<li :class="{ horizontal }" class="menu-separator" />
<li :class="{ horizontal }" class="menu-separator" role="separator" />
</template>
<script lang="ts" setup>

View File

@@ -1,6 +1,12 @@
<!-- v1.0 -->
<template>
<div :class="[{ active, disabled }, className]" class="menu-trigger">
<div
:aria-disabled="disabled || undefined"
:class="[{ active, selected, disabled }, className]"
class="menu-trigger"
role="menuitem"
tabindex="-1"
>
<VtsIcon :name="icon" size="medium" :busy />
<slot />
</div>
@@ -16,6 +22,7 @@ import { computed } from 'vue'
const { accent } = defineProps<{
accent: MenuItemAccent
active?: boolean
selected?: boolean
busy?: boolean
disabled?: boolean
icon?: IconName
@@ -26,12 +33,25 @@ const className = computed(() => toVariants({ accent }))
<style lang="postcss" scoped>
.menu-trigger {
position: relative;
display: flex;
align-items: center;
padding-inline: 1.6rem;
gap: 0.8rem;
height: 4.5rem;
&:focus-visible {
outline: none;
&::before {
content: '';
position: absolute;
inset: 0;
border: 0.2rem solid var(--color-brand-txt-base);
border-radius: 0.4rem;
}
}
&.disabled {
color: var(--color-neutral-txt-secondary);
background-color: var(--color-neutral-background-disabled);
@@ -40,6 +60,10 @@ const className = computed(() => toVariants({ accent }))
&:not(.disabled) {
cursor: pointer;
&.selected {
background-color: var(--color-brand-background-selected);
}
&:hover {
background-color: var(--color-brand-background-hover);
}
@@ -69,6 +93,10 @@ const className = computed(() => toVariants({ accent }))
&.accent--danger {
color: var(--color-danger-txt-base);
&.selected {
background-color: var(--color-danger-background-selected);
}
&:hover {
color: var(--color-danger-txt-hover);
background-color: var(--color-danger-background-hover);
@@ -84,6 +112,10 @@ const className = computed(() => toVariants({ accent }))
&.accent--warning {
color: var(--color-warning-txt-base);
&.selected {
background-color: var(--color-warning-background-selected);
}
&:hover {
color: var(--color-warning-txt-hover);
background-color: var(--color-warning-background-hover);

View File

@@ -5,12 +5,13 @@
:placement
@action="handleMenuAction?.()"
>
<template #trigger="{ open, isOpen }">
<template #trigger="{ open, isOpen, bindings }">
<UiButtonIcon
v-tooltip="{
placement: 'top',
content: resolvedLabel,
}"
v-bind="bindings"
:aria-label="resolvedLabel"
icon="action:more-actions"
accent="brand"

View File

@@ -1,17 +1,26 @@
<template>
<MenuList :placement>
<template #trigger="{ open }">
<template #trigger="{ open, bindings }">
<UiButton
v-if="isInPanel"
v-bind="bindings"
variant="tertiary"
accent="brand"
size="medium"
left-icon="action:change-state"
right-icon="fa:angle-down"
@click="open($event)"
>
{{ t('action:change-state') }}
</UiButton>
<UiDropdownButton v-else variant="secondary" size="medium" icon="action:change-state" @click="open($event)">
<UiDropdownButton
v-else
v-bind="bindings"
variant="secondary"
size="medium"
icon="action:change-state"
@click="open($event)"
>
{{ t('action:change-state') }}
</UiDropdownButton>
</template>

View File

@@ -1,5 +1,5 @@
<template>
<li>
<li role="none">
<VtsDropdownTitle>
<slot />
</VtsDropdownTitle>

View File

@@ -1,9 +1,10 @@
<template>
<slot :is-open :open name="trigger" />
<slot :bindings="triggerBindings" :is-open :open name="trigger" />
<Teleport to="body">
<Transition name="slide">
<UiPanel
v-if="isOpen"
:id="dialogId"
:aria-labelledby="titleId"
:style="{ transition: transformTransition }"
aria-modal="true"
@@ -36,7 +37,7 @@
<script lang="ts" setup>
import VtsDropdownTitle from '@core/components/dropdown/VtsDropdownTitle.vue'
import MenuList from '@core/components/menu/MenuList.vue'
import MenuList, { type MenuTriggerBindings } from '@core/components/menu/MenuList.vue'
import UiButtonIcon from '@core/components/ui/button-icon/UiButtonIcon.vue'
import UiPanel from '@core/components/ui/panel/UiPanel.vue'
import { useOverlayStore } from '@core/packages/overlay/use-overlay-store.ts'
@@ -66,7 +67,7 @@ const emit = defineEmits<{
defineSlots<{
default(): any
trigger(props: { open: () => void; isOpen: boolean }): any
trigger(props: { open: () => void; isOpen: boolean; bindings: MenuTriggerBindings }): any
}>()
const { t } = useI18n()
@@ -75,9 +76,17 @@ const overlayStore = useOverlayStore()
const titleId = useId()
const dialogId = useId()
const isOpen = ref(false)
const submenus = shallowRef<MobileSubmenu[]>([])
const triggerBindings = computed<MenuTriggerBindings>(() => ({
'aria-haspopup': 'dialog',
'aria-expanded': isOpen.value,
'aria-controls': isOpen.value ? dialogId : undefined,
}))
const currentSubmenu = computed(() => submenus.value.at(-1))
const backLabel = computed(() => (currentSubmenu.value ? t('action:go-back') : t('action:close')))

View File

@@ -1,20 +1,20 @@
<template>
<VtsMobileMenu v-if="uiStore.isSmall" :title :section-title @action="emit('action')">
<template #trigger="{ open, isOpen }">
<slot :is-open :open="() => open()" name="trigger" />
<template #trigger="{ open, isOpen, bindings }">
<slot :bindings :is-open :open="() => open()" name="trigger" />
</template>
<slot />
</VtsMobileMenu>
<MenuList v-else :placement>
<template #trigger="{ open, isOpen }">
<slot :is-open :open name="trigger" />
<template #trigger="{ open, isOpen, bindings }">
<slot :bindings :is-open :open name="trigger" />
</template>
<slot />
</MenuList>
</template>
<script lang="ts" setup>
import MenuList from '@core/components/menu/MenuList.vue'
import MenuList, { type MenuTriggerBindings } from '@core/components/menu/MenuList.vue'
import VtsMobileMenu from '@core/components/menu/VtsMobileMenu.vue'
import { useDisabled } from '@core/composables/disabled.composable.ts'
import { useUiStore } from '@core/stores/ui.store.ts'
@@ -33,7 +33,7 @@ const emit = defineEmits<{
defineSlots<{
default(): any
trigger(props: { open: (event: MouseEvent) => void; isOpen: boolean }): any
trigger(props: { open: (event: MouseEvent) => void; isOpen: boolean; bindings: MenuTriggerBindings }): any
}>()
const uiStore = useUiStore()

View File

@@ -0,0 +1,49 @@
import VtsActionModal from '@core/components/modal/VtsActionModal.vue'
import { createGlobalTestConfig } from '@core-test/create-global-test-config.ts'
import { t } from '@core-test/i18n.ts'
import { mount } from '@vue/test-utils'
function mountActionModal(confirmationText?: string) {
return mount(VtsActionModal, {
global: createGlobalTestConfig(),
props: {
object: 'vm',
action: 'shutdown',
vmCount: 2,
accent: 'danger',
icon: 'status:danger-circle',
confirmationText,
},
})
}
describe('VtsActionModal', () => {
it('confirms directly when no confirmation text is asked', async () => {
const wrapper = mountActionModal()
expect(wrapper.find('input').exists()).toBe(false)
await wrapper.get('form').trigger('submit')
expect(wrapper.emitted('confirm')).toHaveLength(1)
})
it('does not confirm with a wrong text and shows the error', async () => {
const wrapper = mountActionModal('2 VMs')
await wrapper.get('input').setValue('2 VM')
await wrapper.get('form').trigger('submit')
expect(wrapper.emitted('confirm')).toBeUndefined()
expect(wrapper.get('.ui-info').text()).toBe(t('form:error:must-match', { text: '2 VMs' }))
})
it('confirms with the confirmation text', async () => {
const wrapper = mountActionModal('2 VMs')
await wrapper.get('input').setValue('2 VMs')
await wrapper.get('form').trigger('submit')
expect(wrapper.emitted('confirm')).toHaveLength(1)
})
})

View File

@@ -1,21 +1,17 @@
<template>
<UiModal :accent :icon @confirm="isConfirmed && emit('confirm')" @dismiss="emit('cancel')">
<UiModal :accent :icon @confirm="handleConfirm()" @dismiss="emit('cancel')">
<template #title>
<span>{{ modalTexts.title }}</span>
</template>
<template #content>
<div class="vts-action-modal">
<p v-if="modalTexts.message">{{ modalTexts.message }}</p>
<VtsTypeToConfirmInput
v-if="confirmationText !== undefined"
v-model="isTypedTextConfirmed"
:confirmation-text
/>
<VtsTypeToConfirmInput v-if="confirmationText !== undefined" ref="typeToConfirmInput" :confirmation-text />
</div>
</template>
<template #buttons>
<VtsOverlayCancelButton @click="emit('cancel')">{{ t('action:go-back') }}</VtsOverlayCancelButton>
<VtsOverlayConfirmButton :disabled="!isConfirmed">
<VtsOverlayConfirmButton>
{{ modalTexts.action }}
</VtsOverlayConfirmButton>
</template>
@@ -31,7 +27,7 @@ import UiModal from '@core/components/ui/modal/UiModal.vue'
import type { IconName } from '@core/icons'
import { useMapper } from '@core/packages/mapper/use-mapper.ts'
import type { ActionsByObject, HostActions, ObjectType, VmActions } from '@core/types/object.type.ts'
import { computed, ref } from 'vue'
import { useTemplateRef } from 'vue'
import { useI18n } from 'vue-i18n'
type ActionTexts = {
@@ -176,9 +172,15 @@ const modalTexts = useMapper(
() => defaultActionByObject[object]
)
const isTypedTextConfirmed = ref(false)
const typeToConfirmInput = useTemplateRef('typeToConfirmInput')
const isConfirmed = computed(() => confirmationText === undefined || isTypedTextConfirmed.value)
function handleConfirm() {
if (confirmationText !== undefined && !typeToConfirmInput.value?.validate()) {
return
}
emit('confirm')
}
</script>
<style lang="postcss" scoped>

View File

@@ -0,0 +1,39 @@
import VtsTypeToConfirmModal from '@core/components/modal/VtsTypeToConfirmModal.vue'
import { createGlobalTestConfig } from '@core-test/create-global-test-config.ts'
import { t } from '@core-test/i18n.ts'
import { mount } from '@vue/test-utils'
function mountTypeToConfirmModal() {
return mount(VtsTypeToConfirmModal, {
global: createGlobalTestConfig(),
props: { accent: 'danger', title: 'Delete VMs', confirmationText: '2 VMs', confirmLabel: 'Delete 2 VMs' },
})
}
describe('VtsTypeToConfirmModal', () => {
it('keeps the confirm button enabled', () => {
expect(mountTypeToConfirmModal().get('button[type="submit"]').attributes('disabled')).toBeUndefined()
})
it.each([
{ label: 'an empty text', text: '' },
{ label: 'a wrong text', text: '2 VM' },
])('does not confirm with $label and shows the error', async ({ text }) => {
const wrapper = mountTypeToConfirmModal()
await wrapper.get('input').setValue(text)
await wrapper.get('form').trigger('submit')
expect(wrapper.emitted('confirm')).toBeUndefined()
expect(wrapper.get('.ui-info').text()).toBe(t('form:error:must-match', { text: '2 VMs' }))
})
it('confirms with the confirmation text', async () => {
const wrapper = mountTypeToConfirmModal()
await wrapper.get('input').setValue('2 VMs')
await wrapper.get('form').trigger('submit')
expect(wrapper.emitted('confirm')).toHaveLength(1)
})
})

View File

@@ -1,5 +1,5 @@
<template>
<UiModal :accent :icon @confirm="isConfirmed && emit('confirm')" @dismiss="emit('cancel')">
<UiModal :accent :icon @confirm="handleConfirm()" @dismiss="emit('cancel')">
<template #title>
{{ title }}
</template>
@@ -7,13 +7,13 @@
<template #content>
<div class="vts-type-to-confirm-modal">
<p v-if="description">{{ description }}</p>
<VtsTypeToConfirmInput v-model="isConfirmed" :confirmation-text />
<VtsTypeToConfirmInput ref="typeToConfirmInput" :confirmation-text />
</div>
</template>
<template #buttons>
<VtsOverlayCancelButton @click="emit('cancel')">{{ t('action:go-back') }}</VtsOverlayCancelButton>
<VtsOverlayConfirmButton :disabled="!isConfirmed">
<VtsOverlayConfirmButton>
{{ confirmLabel }}
</VtsOverlayConfirmButton>
</template>
@@ -27,7 +27,7 @@ import VtsTypeToConfirmInput from '@core/components/type-to-confirm-input/VtsTyp
import type { ModalAccent } from '@core/components/ui/modal/UiModal.vue'
import UiModal from '@core/components/ui/modal/UiModal.vue'
import type { IconName } from '@core/icons'
import { ref } from 'vue'
import { useTemplateRef } from 'vue'
import { useI18n } from 'vue-i18n'
defineProps<{
@@ -46,7 +46,15 @@ const emit = defineEmits<{
const { t } = useI18n()
const isConfirmed = ref(false)
const typeToConfirmInput = useTemplateRef('typeToConfirmInput')
function handleConfirm() {
if (!typeToConfirmInput.value?.validate()) {
return
}
emit('confirm')
}
</script>
<style lang="postcss" scoped>

View File

@@ -1,7 +1,7 @@
<template>
<div class="vts-overlay-list">
<div ref="root" class="vts-overlay-list">
<Transition name="fade">
<div v-if="overlayStore.overlays.length > 0" class="backdrop" />
<div v-if="hasOverlays" class="backdrop" />
</Transition>
<TransitionGroup tag="div" name="overlay" class="overlays">
@@ -11,6 +11,7 @@
class="overlay"
:overlay
:class="{ dimmed: !overlayStore.isCurrent(overlay.key) }"
:inert="!overlayStore.isCurrent(overlay.key)"
/>
</TransitionGroup>
</div>
@@ -19,8 +20,49 @@
<script lang="ts" setup>
import OverlayComponent from '@core/packages/overlay/OverlayComponent.vue'
import { useOverlayStore } from '@core/packages/overlay/use-overlay-store.ts'
import { computed, useTemplateRef, watch } from 'vue'
const overlayStore = useOverlayStore()
const hasOverlays = computed(() => overlayStore.overlays.length > 0)
const rootElement = useTemplateRef('root')
const inertElementsByOverlay = new Map<symbol, HTMLElement[]>()
function makeOutsideInert(root: HTMLElement) {
const inertElements: HTMLElement[] = []
for (let element = root; element !== document.body && element.parentElement; element = element.parentElement) {
for (const sibling of element.parentElement.children) {
if (sibling !== element && sibling instanceof HTMLElement && !sibling.inert) {
sibling.inert = true
inertElements.push(sibling)
}
}
}
return inertElements
}
watch([rootElement, () => overlayStore.overlays.map(overlay => overlay.key)], ([root, keys]) => {
inertElementsByOverlay.forEach((elements, key) => {
if (!keys.includes(key)) {
elements.forEach(element => (element.inert = false))
inertElementsByOverlay.delete(key)
}
})
if (root === null) {
return
}
keys.forEach(key => {
if (!inertElementsByOverlay.has(key)) {
inertElementsByOverlay.set(key, makeOutsideInert(root))
}
})
})
</script>
<style lang="postcss" scoped>

View File

@@ -6,9 +6,10 @@
<VtsSelect v-else-if="valueType === 'select'" :id="valueSelectId" class="value" accent="brand" />
<div>
<MenuList :placement="uiStore.isSmall ? 'bottom' : 'bottom-end'">
<template #trigger="{ open }">
<template #trigger="{ open, bindings }">
<UiButton
v-if="uiStore.isSmall"
v-bind="bindings"
class="actions-button"
variant="secondary"
icon="fa:ellipsis"
@@ -18,7 +19,7 @@
>
{{ t('filter-actions') }}
</UiButton>
<UiButtonIcon v-else icon="fa:ellipsis" size="medium" accent="brand" @click="open" />
<UiButtonIcon v-else v-bind="bindings" icon="fa:ellipsis" size="medium" accent="brand" @click="open" />
</template>
<MenuItem accent="neutral" icon="fa:clone" @click="emit('duplicate')">{{ t('action:duplicate') }}</MenuItem>
<MenuItem accent="neutral" icon="fa:layer-group" @click="emit('convertToGroup')">

View File

@@ -4,8 +4,8 @@
<div class="header">
<VtsSelect :id="groupOperatorSelectId" class="group-operator" accent="brand" />
<MenuList v-if="!root" placement="bottom-end">
<template #trigger="{ open }">
<UiButtonIcon size="medium" accent="brand" icon="fa:ellipsis" @click="open" />
<template #trigger="{ open, bindings }">
<UiButtonIcon v-bind="bindings" size="medium" accent="brand" icon="fa:ellipsis" @click="open" />
</template>
<MenuItem accent="neutral" @click="emit('duplicate')">{{ t('action:duplicate') }}</MenuItem>
<MenuItem accent="neutral" @click="emit('remove', true)">

View File

@@ -48,6 +48,12 @@ const uiStore = useUiStore()
}
}
@media (--medium-or-large) {
&:deep(.modal) {
max-width: min(95vw, 120rem);
}
}
&:deep(.modal) {
padding: 0;
gap: 0;

View File

@@ -0,0 +1,63 @@
import VtsSuccessStateHero from '@core/components/success-state-hero/VtsSuccessStateHero.vue'
import UiAlert from '@core/components/ui/alert/UiAlert.vue'
import { createGlobalTestConfig } from '@core-test/create-global-test-config.ts'
import { mount, type VueWrapper } from '@vue/test-utils'
import type { Window as HappyDomWindow } from 'happy-dom'
function mountSuccessStateHero({ width = 1024, title }: { width?: number; title?: string } = {}) {
;(window as unknown as HappyDomWindow).happyDOM.setViewport({ width })
return mount(VtsSuccessStateHero, {
global: createGlobalTestConfig(),
slots: {
default: 'Message',
actions: '<button>Action</button>',
...(title !== undefined && { title }),
},
})
}
function findTitle(wrapper: VueWrapper) {
const title = wrapper.find('.title')
return title.exists() ? title.text() : undefined
}
function findWidthClasses(wrapper: VueWrapper, selector: string) {
return wrapper
.get(selector)
.classes()
.filter(className => className === 'mobile' || className === 'medium')
}
describe('VtsSuccessStateHero', () => {
it.each([
{ label: 'renders the title when one is passed', title: 'Title', expected: 'Title' },
{ label: 'renders no title when none is passed', title: undefined, expected: undefined },
])('$label', ({ title, expected }) => {
expect(findTitle(mountSuccessStateHero({ title }))).toBe(expected)
})
it('renders the message in a success alert', () => {
const alert = mountSuccessStateHero().getComponent(UiAlert)
expect(alert.props('accent')).toBe('success')
expect(alert.text()).toBe('Message')
})
it('renders the actions', () => {
expect(mountSuccessStateHero().get('.action-buttons').text()).toBe('Action')
})
it.each([
{ width: 1023, content: ['mobile'], actions: ['mobile'] },
{ width: 1024, content: ['medium'], actions: [] },
{ width: 1440, content: ['medium'], actions: [] },
{ width: 1441, content: [], actions: [] },
])('sets the width classes of a $width px wide screen', ({ width, content, actions }) => {
const wrapper = mountSuccessStateHero({ width })
expect(findWidthClasses(wrapper, '.container > .content')).toEqual(content)
expect(findWidthClasses(wrapper, '.action-buttons')).toEqual(actions)
})
})

View File

@@ -2,7 +2,7 @@
<VtsStateHero class="vts-success-state-hero" type="all-good" format="card" size="medium">
<div class="container">
<div v-if="slots.title" class="typo-h1 title"><slot name="title" /></div>
<div class="content" :class="{ mobile: uiStore.isSmall, desktop: !uiStore.isLarge }">
<div class="content" :class="{ mobile: uiStore.isSmall, medium: !uiStore.isSmall && !uiStore.isLarge }">
<UiAlert accent="success"><slot /></UiAlert>
<div class="action-buttons" :class="{ mobile: uiStore.isSmall }">
<slot name="actions" />
@@ -46,7 +46,7 @@ const uiStore = useUiStore()
margin: 0 auto;
width: 65%;
&.desktop {
&.medium {
width: 80%;
}
@@ -57,6 +57,7 @@ const uiStore = useUiStore()
.action-buttons {
display: flex;
justify-content: center;
align-items: center;
gap: 2.4rem;
&.mobile {

View File

@@ -2,13 +2,15 @@
<UiTableActions :title="t('table-actions')">
<template v-for="(action, index) of resolvedActions" :key="index">
<VtsResponsiveMenu v-if="action.children" :title="action.label" placement="bottom-start">
<template #trigger="{ open }">
<template #trigger="{ open, bindings }">
<UiButton
v-tooltip="action.hint"
v-bind="bindings"
variant="tertiary"
:accent="action.buttonAccent"
size="medium"
:left-icon="action.icon"
right-icon="fa:angle-down"
:disabled="action.disabled"
:busy="action.busy"
@click="open($event)"

View File

@@ -0,0 +1,49 @@
<template>
<UiTableCell class="vts-button-icon-list-cell" align="center">
<div class="buttons">
<UiButtonIcon
v-for="(button, index) of buttons"
:key="index"
v-tooltip="button.label"
:aria-label="button.label"
:icon="button.icon"
:disabled="button.disabled"
:target-scale="1.5"
accent="brand"
size="small"
@click="button.onClick()"
/>
</div>
</UiTableCell>
</template>
<script lang="ts" setup>
import UiButtonIcon from '@core/components/ui/button-icon/UiButtonIcon.vue'
import UiTableCell from '@core/components/ui/table-cell/UiTableCell.vue'
import { vTooltip } from '@core/directives/tooltip.directive.ts'
import type { IconName } from '@core/icons'
export type ButtonIconItem = {
icon: IconName
label: string
onClick: () => void
disabled?: boolean
}
defineProps<{
buttons: ButtonIconItem[]
}>()
</script>
<style lang="postcss" scoped>
.vts-button-icon-list-cell {
width: 8rem;
padding: 0.8rem 1.6rem 0.8rem 0.8rem;
.buttons {
display: flex;
justify-content: center;
gap: 0.8rem;
}
}
</style>

View File

@@ -0,0 +1,56 @@
<template>
<UiTableCell class="vts-rank-cell">
<div class="content">
<span>{{ rank }}</span>
<span v-if="shiftIcon" class="shift">
<VtsIcon :name="shiftIcon" size="small" />
{{ shiftCount }}
</span>
</div>
</UiTableCell>
</template>
<script lang="ts" setup>
import VtsIcon from '@core/components/icon/VtsIcon.vue'
import UiTableCell from '@core/components/ui/table-cell/UiTableCell.vue'
import type { IconName } from '@core/icons'
import { computed } from 'vue'
const { shift = 0 } = defineProps<{
rank: number
shift?: number
}>()
const shiftIcon = computed<IconName | undefined>(() => {
if (shift > 0) {
return 'action:move-up'
}
if (shift < 0) {
return 'action:move-down'
}
return undefined
})
const shiftCount = computed(() => Math.abs(shift))
</script>
<style lang="postcss" scoped>
.vts-rank-cell {
width: 7rem;
.content {
display: flex;
justify-content: space-between;
gap: 0.8rem;
}
.shift {
display: flex;
align-items: center;
gap: 0.4rem;
color: var(--color-neutral-txt-secondary);
}
}
</style>

View File

@@ -0,0 +1,67 @@
import VtsTypeToConfirmInput from '@core/components/type-to-confirm-input/VtsTypeToConfirmInput.vue'
import { createGlobalTestConfig } from '@core-test/create-global-test-config.ts'
import { t } from '@core-test/i18n.ts'
import { mount } from '@vue/test-utils'
import { nextTick } from 'vue'
function mountTypeToConfirmInput() {
return mount(VtsTypeToConfirmInput, {
global: createGlobalTestConfig(),
props: { confirmationText: '2 VMs' },
attachTo: document.body,
})
}
describe('VtsTypeToConfirmInput', () => {
it('shows no error before validating', () => {
const wrapper = mountTypeToConfirmInput()
expect(wrapper.find('.ui-info').exists()).toBe(false)
expect(wrapper.get('input').attributes('aria-invalid')).toBeUndefined()
})
it.each([
{ label: 'an empty text', text: '' },
{ label: 'a wrong text', text: '2 VM' },
])('rejects $label, shows the error and focuses the field', async ({ text }) => {
const wrapper = mountTypeToConfirmInput()
const input = wrapper.get('input')
await input.setValue(text)
expect(wrapper.vm.validate()).toBe(false)
await nextTick()
const error = wrapper.get('.ui-info')
expect(error.text()).toBe(t('form:error:must-match', { text: '2 VMs' }))
expect(input.attributes('aria-invalid')).toBe('true')
expect(error.attributes('id')).toBeTruthy()
expect(input.attributes('aria-describedby')).toBe(error.attributes('id'))
expect(document.activeElement).toBe(input.element)
})
it('accepts the confirmation text', async () => {
const wrapper = mountTypeToConfirmInput()
await wrapper.get('input').setValue('2 VMs')
expect(wrapper.vm.validate()).toBe(true)
await nextTick()
expect(wrapper.find('.ui-info').exists()).toBe(false)
})
it('hides the error as soon as the text changes', async () => {
const wrapper = mountTypeToConfirmInput()
wrapper.vm.validate()
await wrapper.get('input').setValue('2')
expect(wrapper.find('.ui-info').exists()).toBe(false)
expect(wrapper.get('input').attributes('aria-invalid')).toBeUndefined()
})
})

View File

@@ -1,35 +1,54 @@
<template>
<div class="vts-type-to-confirm-input">
<VtsRequiredHint />
<VtsInputWrapper :label="t('type-x-to-confirm', { text: confirmationText })">
<UiInput v-model="typedText" accent="brand" required />
<VtsInputWrapper :label="t('type-x-to-confirm', { text: confirmationText })" :message="errorMessage">
<UiInput ref="input" v-model="typedText" accent="brand" required />
</VtsInputWrapper>
</div>
</template>
<script lang="ts" setup>
import VtsInputWrapper from '@core/components/input-wrapper/VtsInputWrapper.vue'
import VtsInputWrapper, { type InputWrapperMessage } from '@core/components/input-wrapper/VtsInputWrapper.vue'
import VtsRequiredHint from '@core/components/required-hint/VtsRequiredHint.vue'
import UiInput from '@core/components/ui/input/UiInput.vue'
import { ref, watch } from 'vue'
import { computed, ref, useTemplateRef, watch } from 'vue'
import { useI18n } from 'vue-i18n'
const { confirmationText } = defineProps<{
confirmationText: string
}>()
const isConfirmed = defineModel<boolean>({ required: true })
const { t } = useI18n()
const input = useTemplateRef('input')
const typedText = ref('')
watch(
() => typedText.value === confirmationText,
isMatching => {
isConfirmed.value = isMatching
}
const isErrorVisible = ref(false)
const errorMessage = computed<InputWrapperMessage | undefined>(() =>
isErrorVisible.value
? { content: t('form:error:must-match', { text: confirmationText }), accent: 'danger' }
: undefined
)
watch(typedText, () => {
isErrorVisible.value = false
})
function validate() {
const isMatching = typedText.value === confirmationText
isErrorVisible.value = !isMatching
if (!isMatching) {
input.value?.focus()
}
return isMatching
}
defineExpose({ validate })
</script>
<style lang="postcss" scoped>

View File

@@ -3,6 +3,7 @@
<button :class="classNames" :disabled="busy || isDisabled || lockIcon" class="ui-button" type="button">
<VtsIcon :name="leftIcon" class="icon" size="current" />
<slot />
<VtsIcon :name="rightIcon" class="icon" size="current" />
<UiLoader v-if="busy" class="icon" />
<VtsIcon v-if="lockIcon" name="fa:lock" size="medium" class="icon" />
</button>
@@ -28,6 +29,7 @@ export type ButtonProps = {
disabled?: boolean
lockIcon?: boolean
leftIcon?: IconName
rightIcon?: IconName
}
const { accent, variant, size, disabled, busy, lockIcon } = defineProps<ButtonProps>()

View File

@@ -1,10 +1,12 @@
<template>
<form novalidate class="ui-drawer" @click.self="emit('dismiss')" @submit.prevent="emit('confirm')">
<aside
ref="dialog"
:aria-labelledby="slots.title || title !== undefined ? titleId : undefined"
aria-modal="true"
class="drawer"
role="dialog"
tabindex="-1"
>
<div class="header">
<div v-if="slots.title || title !== undefined" :id="titleId" class="typo-h4">
@@ -35,7 +37,8 @@
import VtsButtonGroup from '@core/components/button-group/VtsButtonGroup.vue'
import UiButtonIcon from '@core/components/ui/button-icon/UiButtonIcon.vue'
import { useOverlayEscape } from '@core/packages/overlay/use-overlay-escape.ts'
import { useId } from 'vue'
import { useOverlayFocus } from '@core/packages/overlay/use-overlay-focus.ts'
import { useId, useTemplateRef } from 'vue'
defineProps<{
title?: string
@@ -55,6 +58,8 @@ const slots = defineSlots<{
useOverlayEscape(() => emit('dismiss'))
useOverlayFocus(useTemplateRef('dialog'))
const titleId = useId()
</script>
@@ -73,6 +78,7 @@ const titleId = useId()
max-width: 100%;
min-height: 100dvh;
background-color: var(--color-neutral-background-secondary);
outline: none;
.header {
display: flex;

View File

@@ -4,6 +4,7 @@
<button
:id="wrapperController?.id"
ref="dropZoneRef"
:aria-describedby="wrapperController?.describedBy"
type="button"
class="dropzone"
:class="{ 'is-over-dropzone': isOverDropZone }"

View File

@@ -19,6 +19,8 @@
:required
:type
:aria-busy="busy || undefined"
:aria-describedby="wrapperController?.describedBy"
:aria-invalid="wrapperController?.invalid || undefined"
class="typo-body-regular input text-ellipsis"
v-bind="attrs"
@input="event => handleInput(event)"

View File

@@ -1,7 +1,14 @@
<!-- v4 -->
<template>
<form :class="className" class="ui-modal" @click.self="emit('dismiss')" @submit.prevent="emit('confirm')">
<div :aria-labelledby="slots.title ? titleId : undefined" aria-modal="true" class="modal" role="dialog">
<form :class="className" class="ui-modal" novalidate @click.self="emit('dismiss')" @submit.prevent="emit('confirm')">
<div
ref="dialog"
:aria-labelledby="slots.title ? titleId : undefined"
aria-modal="true"
class="modal"
role="dialog"
tabindex="-1"
>
<UiButtonIcon
v-if="onDismiss"
:accent
@@ -33,9 +40,10 @@ import VtsIcon from '@core/components/icon/VtsIcon.vue'
import UiButtonIcon from '@core/components/ui/button-icon/UiButtonIcon.vue'
import type { IconName } from '@core/icons'
import { useOverlayEscape } from '@core/packages/overlay/use-overlay-escape.ts'
import { useOverlayFocus } from '@core/packages/overlay/use-overlay-focus.ts'
import { IK_OVERLAY_ACCENT } from '@core/utils/injection-keys.util.ts'
import { toVariants } from '@core/utils/to-variants.util.ts'
import { computed, provide, useId } from 'vue'
import { computed, provide, useId, useTemplateRef } from 'vue'
export type ModalAccent = 'info' | 'warning' | 'danger'
@@ -58,6 +66,8 @@ const slots = defineSlots<{
useOverlayEscape(() => emit('dismiss'))
useOverlayFocus(useTemplateRef('dialog'))
const titleId = useId()
const className = computed(() => toVariants({ accent }))
@@ -88,6 +98,7 @@ provide(
border-radius: 1rem;
border-width: 0.1rem;
border-style: solid;
outline: none;
&:not(:has(.buttons)) {
padding-bottom: 3.2rem;
@@ -120,6 +131,7 @@ provide(
.content {
width: 100%;
text-align: start;
}
}
}

View File

@@ -0,0 +1,199 @@
import { type MaybeRefOrGetter, onScopeDispose, readonly, ref, shallowRef, toValue } from 'vue'
const OPEN_DELAY = 150
const CLOSE_DELAY = 300
const SAFE_AREA_TIMEOUT = 300
const SAFE_AREA_BLEED = 4
type Point = { x: number; y: number }
type Triangle = [Point, Point, Point]
export type MenuLevelHover = {
itemId: string
hasSubmenu: boolean
}
export type MenuLevel = ReturnType<typeof useMenuLevel>
function cross(origin: Point, a: Point, b: Point) {
return (a.x - origin.x) * (b.y - origin.y) - (a.y - origin.y) * (b.x - origin.x)
}
function isPointInTriangle(point: Point, [a, b, c]: Triangle) {
const signs = [cross(point, a, b), cross(point, b, c), cross(point, c, a)]
return !(signs.some(sign => sign < 0) && signs.some(sign => sign > 0))
}
function getSafeArea(exit: Point, submenu: HTMLElement): Triangle | undefined {
const { top, right, bottom, left } = submenu.getBoundingClientRect()
switch (submenu.dataset.placement?.split('-')[0]) {
case 'right':
return [
{ x: exit.x - SAFE_AREA_BLEED, y: exit.y },
{ x: left, y: top },
{ x: left, y: bottom },
]
case 'left':
return [
{ x: exit.x + SAFE_AREA_BLEED, y: exit.y },
{ x: right, y: top },
{ x: right, y: bottom },
]
case 'bottom':
return [
{ x: exit.x, y: exit.y - SAFE_AREA_BLEED },
{ x: left, y: top },
{ x: right, y: top },
]
case 'top':
return [
{ x: exit.x, y: exit.y + SAFE_AREA_BLEED },
{ x: left, y: bottom },
{ x: right, y: bottom },
]
default:
return undefined
}
}
export function useMenuLevel({ isPopup, horizontal }: { isPopup: boolean; horizontal: MaybeRefOrGetter<boolean> }) {
const openedItemId = ref<string>()
const submenuElement = shallowRef<HTMLElement>()
let pendingTimeout: ReturnType<typeof setTimeout> | undefined
let pendingItemId: string | undefined
let safeArea: Triangle | undefined
let safeAreaTimeout: ReturnType<typeof setTimeout> | undefined
let hoveredItem: MenuLevelHover | undefined
function cancelPending() {
clearTimeout(pendingTimeout)
pendingTimeout = undefined
pendingItemId = undefined
}
function clearSafeArea() {
clearTimeout(safeAreaTimeout)
safeAreaTimeout = undefined
safeArea = undefined
}
function setOpenedItem(itemId: string | undefined) {
cancelPending()
clearSafeArea()
openedItemId.value = itemId
}
function schedule(itemId: string | undefined, delay: number) {
if (pendingTimeout !== undefined && pendingItemId === itemId) {
return
}
cancelPending()
pendingItemId = itemId
pendingTimeout = setTimeout(() => setOpenedItem(itemId), delay)
}
function evaluateHover({ itemId, hasSubmenu }: MenuLevelHover) {
const targetItemId = hasSubmenu ? itemId : undefined
if (targetItemId === openedItemId.value) {
cancelPending()
return
}
if (openedItemId.value !== undefined) {
schedule(targetItemId, CLOSE_DELAY)
return
}
if (isPopup || !toValue(horizontal)) {
schedule(targetItemId, OPEN_DELAY)
}
}
function startSafeAreaTimeout() {
clearTimeout(safeAreaTimeout)
safeAreaTimeout = setTimeout(() => {
clearSafeArea()
if (hoveredItem !== undefined) {
evaluateHover(hoveredItem)
}
}, SAFE_AREA_TIMEOUT)
}
function hoverItem(hover: MenuLevelHover, event: PointerEvent) {
hoveredItem = hover
if (safeArea !== undefined && isPointInTriangle({ x: event.clientX, y: event.clientY }, safeArea)) {
startSafeAreaTimeout()
return
}
clearSafeArea()
evaluateHover(hover)
}
function leaveItem(itemId: string, event: PointerEvent) {
hoveredItem = undefined
cancelPending()
if (openedItemId.value !== itemId || submenuElement.value === undefined) {
return
}
safeArea = getSafeArea({ x: event.clientX, y: event.clientY }, submenuElement.value)
startSafeAreaTimeout()
}
function enterSubmenu() {
cancelPending()
clearSafeArea()
}
function registerSubmenu(element: HTMLElement) {
submenuElement.value = element
return () => {
if (submenuElement.value === element) {
submenuElement.value = undefined
}
}
}
function closeItem(itemId: string) {
if (openedItemId.value === itemId) {
setOpenedItem(undefined)
}
}
onScopeDispose(() => {
cancelPending()
clearSafeArea()
})
return {
isPopup,
openedItemId: readonly(openedItemId),
openItem: (itemId: string) => setOpenedItem(itemId),
closeItem,
close: () => setOpenedItem(undefined),
hoverItem,
leaveItem,
enterSubmenu,
registerSubmenu,
}
}

View File

@@ -0,0 +1,193 @@
import { useMenuLevel } from '@core/composables/menu-level.composable.ts'
import { mountComposable } from '@core-test/mount-composable.ts'
type MountedLevel = ReturnType<typeof mountLevel>
function mountLevel({ isPopup = true, horizontal = false } = {}) {
return mountComposable(() => useMenuLevel({ isPopup, horizontal })).wrapper.vm
}
function pointer(x = 0, y = 0) {
return new PointerEvent('pointermove', { clientX: x, clientY: y })
}
function hover(level: MountedLevel, itemId: string, { hasSubmenu = true, x = 0, y = 0 } = {}) {
level.hoverItem({ itemId, hasSubmenu }, pointer(x, y))
}
function registerSubmenuOnTheRight(level: MountedLevel) {
const submenu = document.createElement('ul')
submenu.dataset.placement = 'right-start'
vi.spyOn(submenu, 'getBoundingClientRect').mockReturnValue(new DOMRect(200, 0, 100, 200))
level.registerSubmenu(submenu)
}
beforeEach(() => {
vi.useFakeTimers()
})
describe('useMenuLevel', () => {
it('opens the hovered submenu after 150 ms', () => {
const level = mountLevel()
hover(level, 'a')
vi.advanceTimersByTime(149)
expect(level.openedItemId).toBeUndefined()
vi.advanceTimersByTime(1)
expect(level.openedItemId).toBe('a')
})
it('does not restart the delay while the pointer keeps moving on the same item', () => {
const level = mountLevel()
hover(level, 'a')
vi.advanceTimersByTime(100)
hover(level, 'a', { x: 5 })
vi.advanceTimersByTime(50)
expect(level.openedItemId).toBe('a')
})
it('opens on hover in an inline vertical menu', () => {
const level = mountLevel({ isPopup: false })
hover(level, 'a')
vi.advanceTimersByTime(150)
expect(level.openedItemId).toBe('a')
})
it('needs a click to open a first submenu in an inline horizontal menu bar, then switches on hover', () => {
const level = mountLevel({ isPopup: false, horizontal: true })
hover(level, 'a')
vi.advanceTimersByTime(1000)
expect(level.openedItemId).toBeUndefined()
level.openItem('a')
hover(level, 'b')
vi.advanceTimersByTime(300)
expect(level.openedItemId).toBe('b')
})
it('closes the open submenu 300 ms after hovering an item without submenu', () => {
const level = mountLevel()
level.openItem('a')
hover(level, 'c', { hasSubmenu: false })
vi.advanceTimersByTime(299)
expect(level.openedItemId).toBe('a')
vi.advanceTimersByTime(1)
expect(level.openedItemId).toBeUndefined()
})
it('switches to the hovered submenu when the open one closes, after 300 ms', () => {
const level = mountLevel()
level.openItem('a')
hover(level, 'b')
vi.advanceTimersByTime(299)
expect(level.openedItemId).toBe('a')
vi.advanceTimersByTime(1)
expect(level.openedItemId).toBe('b')
})
it('cancels the pending change when the pointer leaves the item', () => {
const level = mountLevel()
level.openItem('a')
hover(level, 'c', { hasSubmenu: false })
level.leaveItem('c', pointer())
hover(level, 'b')
level.leaveItem('b', pointer())
vi.advanceTimersByTime(1000)
expect(level.openedItemId).toBe('a')
})
it('opens and closes right away on demand, cancelling the pending change', () => {
const level = mountLevel()
hover(level, 'b')
level.openItem('a')
vi.advanceTimersByTime(1000)
expect(level.openedItemId).toBe('a')
level.closeItem('b')
expect(level.openedItemId).toBe('a')
level.closeItem('a')
expect(level.openedItemId).toBeUndefined()
})
it('ignores the sibling items crossed inside the safe area towards the open submenu', () => {
const level = mountLevel()
level.openItem('a')
registerSubmenuOnTheRight(level)
level.leaveItem('a', pointer(150, 40))
hover(level, 'b', { x: 170, y: 60 })
vi.advanceTimersByTime(200)
hover(level, 'b', { x: 190, y: 70 })
vi.advanceTimersByTime(200)
level.leaveItem('b', pointer(195, 72))
level.enterSubmenu()
vi.advanceTimersByTime(1000)
expect(level.openedItemId).toBe('a')
})
it('switches when a sibling item is hovered outside the safe area', () => {
const level = mountLevel()
level.openItem('a')
registerSubmenuOnTheRight(level)
level.leaveItem('a', pointer(150, 40))
hover(level, 'b', { x: 150, y: 120 })
vi.advanceTimersByTime(300)
expect(level.openedItemId).toBe('b')
})
it('evaluates the hovered sibling item once the pointer rests in the safe area for 300 ms', () => {
const level = mountLevel()
level.openItem('a')
registerSubmenuOnTheRight(level)
level.leaveItem('a', pointer(150, 40))
hover(level, 'b', { x: 170, y: 60 })
vi.advanceTimersByTime(599)
expect(level.openedItemId).toBe('a')
vi.advanceTimersByTime(1)
expect(level.openedItemId).toBe('b')
})
it('drops the pending changes when it is unmounted', () => {
const { wrapper } = mountComposable(() => useMenuLevel({ isPopup: true, horizontal: false }))
wrapper.vm.openItem('a')
hover(wrapper.vm, 'c', { hasSubmenu: false })
wrapper.unmount()
vi.advanceTimersByTime(1000)
expect(wrapper.vm.openedItemId).toBe('a')
})
})

View File

@@ -0,0 +1,97 @@
import { useEventListener } from '@vueuse/core'
import { computed, type MaybeRefOrGetter, toValue } from 'vue'
const MENU_SELECTOR = '.menu-list'
const ITEM_SELECTOR = '.menu-trigger'
const INTERACTIVE_SELECTOR = 'a[href], button'
type ItemPosition = 'first' | 'last' | 'previous' | 'next'
export function useMenuListNavigation({
target,
isHorizontal,
canCloseWithArrowLeft,
onClose,
onLeave,
}: {
target: MaybeRefOrGetter<HTMLElement | null | undefined>
isHorizontal: MaybeRefOrGetter<boolean>
canCloseWithArrowLeft: MaybeRefOrGetter<boolean>
onClose: () => void
onLeave: () => void
}) {
const itemPositionByKey = computed<Partial<Record<string, ItemPosition>>>(() => ({
[toValue(isHorizontal) ? 'ArrowLeft' : 'ArrowUp']: 'previous',
[toValue(isHorizontal) ? 'ArrowRight' : 'ArrowDown']: 'next',
Home: 'first',
End: 'last',
}))
function getItems() {
const menu = toValue(target)
if (menu === null || menu === undefined) {
return []
}
return Array.from(menu.querySelectorAll<HTMLElement>(ITEM_SELECTOR)).filter(
item => item.closest(MENU_SELECTOR) === menu
)
}
function focusItem(position: ItemPosition) {
const items = getItems()
const currentIndex = items.findIndex(item => item.contains(document.activeElement))
const lastIndex = items.length - 1
const indexByPosition: Record<ItemPosition, number> = {
first: 0,
last: lastIndex,
previous: currentIndex > 0 ? currentIndex - 1 : lastIndex,
next: currentIndex < lastIndex ? currentIndex + 1 : 0,
}
items[indexByPosition[position]]?.focus()
}
function activateItem(item: HTMLElement) {
const control = item.querySelector<HTMLElement>(INTERACTIVE_SELECTOR) ?? item
control.click()
}
useEventListener(target, 'keydown', (event: KeyboardEvent) => {
if (event.defaultPrevented) {
return
}
const position = itemPositionByKey.value[event.key]
if (position !== undefined) {
event.preventDefault()
focusItem(position)
return
}
const item = getItems().find(item => item === event.target)
if ((event.key === 'Enter' || event.key === ' ') && item !== undefined) {
event.preventDefault()
activateItem(item)
return
}
if (event.key === 'Escape' || (event.key === 'ArrowLeft' && toValue(canCloseWithArrowLeft))) {
event.preventDefault()
onClose()
} else if (event.key === 'Tab') {
onLeave()
}
})
return {
focusFirstItem: () => focusItem('first'),
}
}

View File

@@ -0,0 +1,232 @@
import { useMenuListNavigation } from '@core/composables/menu-list-navigation.composable.ts'
import { mount } from '@vue/test-utils'
import { defineComponent, h, nextTick, ref } from 'vue'
async function mountMenuListNavigation({
isHorizontal = false,
canCloseWithArrowLeft = false,
hasTarget = true,
}: {
isHorizontal?: boolean
canCloseWithArrowLeft?: boolean
hasTarget?: boolean
} = {}) {
const onClose = vi.fn()
const onLeave = vi.fn()
const onItemClick = vi.fn()
const onButtonClick = vi.fn()
let focusFirstItem = () => {}
mount(
defineComponent({
setup() {
const menu = ref<HTMLElement>()
focusFirstItem = useMenuListNavigation({
target: () => (hasTarget ? menu.value : undefined),
isHorizontal,
canCloseWithArrowLeft,
onClose,
onLeave,
}).focusFirstItem
return () =>
h('ul', { ref: menu, class: 'menu-list' }, [
h('li', [h('div', { class: 'menu-trigger', tabindex: -1, onClick: onItemClick }, 'One')]),
h('li', [
h('div', { class: 'menu-trigger', tabindex: -1 }, [h('button', { onClick: onButtonClick }, 'Two')]),
]),
h('li', [
h('div', { class: 'menu-trigger', tabindex: -1 }, 'Three'),
h('ul', { class: 'menu-list' }, [h('li', [h('div', { class: 'menu-trigger', tabindex: -1 }, 'Nested')])]),
]),
])
},
}),
{ attachTo: document.body }
)
await nextTick()
return { focusFirstItem, onClose, onLeave, onItemClick, onButtonClick }
}
function getItem(label: string) {
const item = Array.from(document.querySelectorAll<HTMLElement>('.menu-trigger')).find(
element => element.textContent === label
)
if (item === undefined) {
throw new Error(`No menu item labeled "${label}"`)
}
return item
}
function getFocusedLabel() {
return document.activeElement?.textContent
}
function press(key: string) {
const event = new KeyboardEvent('keydown', { key, bubbles: true, cancelable: true })
document.activeElement?.dispatchEvent(event)
return event
}
describe('focusFirstItem', () => {
it('focuses the first item of the menu', async () => {
const { focusFirstItem } = await mountMenuListNavigation()
focusFirstItem()
expect(getFocusedLabel()).toBe('One')
})
})
describe('keyboard navigation', () => {
it('moves the focus to the next item with ArrowDown and wraps around after the last one', async () => {
await mountMenuListNavigation()
getItem('Two').focus()
expect(press('ArrowDown').defaultPrevented).toBe(true)
expect(getFocusedLabel()).toBe('Three')
press('ArrowDown')
expect(getFocusedLabel()).toBe('One')
})
it('moves the focus to the previous item with ArrowUp and wraps around before the first one', async () => {
await mountMenuListNavigation()
getItem('Two').focus()
press('ArrowUp')
expect(getFocusedLabel()).toBe('One')
press('ArrowUp')
expect(getFocusedLabel()).toBe('Three')
})
it('moves the focus to the first item with Home and to the last one with End', async () => {
await mountMenuListNavigation()
getItem('Two').focus()
press('End')
expect(getFocusedLabel()).toBe('Three')
press('Home')
expect(getFocusedLabel()).toBe('One')
})
it('skips the items of a nested menu', async () => {
await mountMenuListNavigation()
getItem('Three').focus()
press('ArrowDown')
expect(getFocusedLabel()).toBe('One')
})
it('moves the focus with ArrowLeft and ArrowRight in a horizontal menu', async () => {
await mountMenuListNavigation({ isHorizontal: true })
getItem('One').focus()
expect(press('ArrowDown').defaultPrevented).toBe(false)
expect(getFocusedLabel()).toBe('One')
press('ArrowRight')
expect(getFocusedLabel()).toBe('Two')
press('ArrowLeft')
expect(getFocusedLabel()).toBe('One')
})
it.each(['Enter', ' '])('clicks the focused item with "%s"', async key => {
const { onItemClick } = await mountMenuListNavigation()
getItem('One').focus()
expect(press(key).defaultPrevented).toBe(true)
expect(onItemClick).toHaveBeenCalledOnce()
})
it('clicks the button of the focused item rather than the item itself', async () => {
const { onButtonClick } = await mountMenuListNavigation()
getItem('Two').focus()
press('Enter')
expect(onButtonClick).toHaveBeenCalledOnce()
})
it('closes the menu with Escape', async () => {
const { onClose } = await mountMenuListNavigation()
getItem('Two').focus()
expect(press('Escape').defaultPrevented).toBe(true)
expect(onClose).toHaveBeenCalledOnce()
})
it('does not close the menu with ArrowLeft unless allowed', async () => {
const { onClose } = await mountMenuListNavigation()
getItem('Two').focus()
press('ArrowLeft')
expect(onClose).not.toHaveBeenCalled()
})
it('closes the menu with ArrowLeft when allowed', async () => {
const { onClose } = await mountMenuListNavigation({ canCloseWithArrowLeft: true })
getItem('Two').focus()
press('ArrowLeft')
expect(onClose).toHaveBeenCalledOnce()
})
it('leaves the menu with Tab without preventing the focus from moving', async () => {
const { onClose, onLeave } = await mountMenuListNavigation()
getItem('Two').focus()
expect(press('Tab').defaultPrevented).toBe(false)
expect(onLeave).toHaveBeenCalledOnce()
expect(onClose).not.toHaveBeenCalled()
})
it('ignores a key already handled by an outer listener', async () => {
const { onClose } = await mountMenuListNavigation()
getItem('Two').focus()
window.addEventListener('keydown', event => event.preventDefault(), { capture: true, once: true })
press('Escape')
expect(onClose).not.toHaveBeenCalled()
})
it('ignores the keys when there is no target', async () => {
const { onClose } = await mountMenuListNavigation({ hasTarget: false })
getItem('One').focus()
expect(press('ArrowDown').defaultPrevented).toBe(false)
expect(getFocusedLabel()).toBe('One')
press('Escape')
expect(onClose).not.toHaveBeenCalled()
})
})

View File

@@ -0,0 +1,110 @@
import { useOverlayStore } from '@core/packages/overlay/use-overlay-store.ts'
import { placeOverlay } from '@core/utils/placement.util.ts'
import { onClickOutside, useEventListener } from '@vueuse/core'
import type { Options } from 'placement.js'
import { type MaybeRefOrGetter, ref, type Ref, toValue, watch } from 'vue'
type MenuPopupOptions = {
isOpen: Ref<boolean>
anchor: MaybeRefOrGetter<HTMLElement | undefined>
placement: MaybeRefOrGetter<Options['placement']>
closesOnClickOutside: boolean
hasOpenSubmenu: MaybeRefOrGetter<boolean>
onClosed: () => void
}
export function useMenuPopup(
menu: MaybeRefOrGetter<HTMLElement | null | undefined>,
{ isOpen, anchor, placement, closesOnClickOutside, hasOpenSubmenu, onClosed }: MenuPopupOptions
) {
const placementSide = ref<string>()
const overlayStore = useOverlayStore()
let overlayCountOnOpen = 0
let stopClickOutside: (() => void) | undefined
function close(restoreFocus = false) {
isOpen.value = false
if (restoreFocus) {
toValue(anchor)?.focus()
}
}
function hasFocusInside() {
const list = document.activeElement?.closest('.menu-list')
if (list === null || list === undefined) {
return false
}
return list !== toValue(anchor)?.closest('.menu-list')
}
function place(menuElement: HTMLElement, reference: HTMLElement) {
placeOverlay(reference, menuElement, { placement: toValue(placement) })
placementSide.value = menuElement.dataset.placement?.split('-')[0]
if (closesOnClickOutside) {
stopClickOutside = onClickOutside(menuElement, () => close(), {
ignore: () => [reference, '.menu-list'],
controls: false,
})
}
}
watch(
isOpen,
opened => {
if (!opened) {
stopClickOutside?.()
stopClickOutside = undefined
onClosed()
return
}
overlayCountOnOpen = overlayStore.overlays.length
const menuElement = toValue(menu)
const reference = toValue(anchor)
if (menuElement !== null && menuElement !== undefined && reference !== undefined) {
place(menuElement, reference)
}
},
{ immediate: true, flush: 'post' }
)
watch(
isOpen,
opened => {
if (!opened && hasFocusInside()) {
toValue(anchor)?.focus()
}
},
{ flush: 'pre' }
)
useEventListener(
() => (isOpen.value ? window : undefined),
'keydown',
(event: KeyboardEvent) => {
if (event.key !== 'Escape' || event.defaultPrevented || toValue(hasOpenSubmenu)) {
return
}
if (overlayStore.overlays.length > overlayCountOnOpen) {
return
}
event.preventDefault()
close(true)
},
{ capture: true }
)
return { placementSide, close }
}

View File

@@ -0,0 +1,133 @@
import { useMenuPopup } from '@core/composables/menu-popup.composable.ts'
import { useOverlayStore } from '@core/packages/overlay/use-overlay-store.ts'
import { createGlobalTestConfig } from '@core-test/create-global-test-config.ts'
import { mount } from '@vue/test-utils'
import { defineComponent, h, nextTick, ref, useTemplateRef } from 'vue'
type PopupOptions = Partial<Pick<Parameters<typeof useMenuPopup>[1], 'closesOnClickOutside' | 'hasOpenSubmenu'>>
async function mountOpenPopup(options: PopupOptions = {}) {
const onClosed = vi.fn()
const wrapper = mount(
defineComponent({
setup: () => {
const isOpen = ref(false)
const anchor = useTemplateRef<HTMLElement>('anchor')
const popup = useMenuPopup(useTemplateRef<HTMLElement>('menu'), {
isOpen,
anchor: () => anchor.value ?? undefined,
placement: 'right-start',
closesOnClickOutside: true,
hasOpenSubmenu: false,
onClosed,
...options,
})
return { isOpen, ...popup }
},
render() {
return h('div', [
h('button', { ref: 'anchor', class: 'anchor' }, 'Actions'),
h('button', { class: 'outside' }, 'Outside'),
this.isOpen ? h('ul', { ref: 'menu', class: 'menu-list' }, [h('li', [h('button', 'Item')])]) : null,
])
},
}),
{ attachTo: document.body, global: createGlobalTestConfig() }
)
wrapper.vm.isOpen = true
await nextTick()
return { wrapper, onClosed }
}
function pressEscape() {
const event = new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true })
window.dispatchEvent(event)
return event
}
function registerModal() {
useOverlayStore().register({
key: Symbol('modal'),
component: { render: () => null },
props: {},
status: 'idle',
lastTrigger: undefined,
returnFocusTarget: null,
abort: () => {},
})
}
describe('useMenuPopup', () => {
it('places the menu against its anchor and exposes the side it ends up on', async () => {
const { wrapper } = await mountOpenPopup()
expect(wrapper.vm.placementSide).toBe('right')
})
it('closes on Escape and gives the focus back to its anchor', async () => {
const { wrapper, onClosed } = await mountOpenPopup()
const event = pressEscape()
await nextTick()
expect(wrapper.vm.isOpen).toBe(false)
expect(event.defaultPrevented).toBe(true)
expect(document.activeElement).toBe(wrapper.get('.anchor').element)
expect(onClosed).toHaveBeenCalled()
})
it('leaves Escape to its open submenu', async () => {
const { wrapper } = await mountOpenPopup({ hasOpenSubmenu: true })
pressEscape()
await nextTick()
expect(wrapper.vm.isOpen).toBe(true)
})
it('leaves Escape to a modal opened after it', async () => {
const { wrapper } = await mountOpenPopup()
registerModal()
const event = pressEscape()
await nextTick()
expect(wrapper.vm.isOpen).toBe(true)
expect(event.defaultPrevented).toBe(false)
})
it('gives the focus back to its anchor when it closes with the focus inside', async () => {
const { wrapper } = await mountOpenPopup()
wrapper.get<HTMLElement>('.menu-list button').element.focus()
wrapper.vm.close()
await nextTick()
expect(document.activeElement).toBe(wrapper.get('.anchor').element)
})
it.each([
{ closesOnClickOutside: true, expected: false },
{ closesOnClickOutside: false, expected: true },
])(
'stays open after a click outside: $expected, when closesOnClickOutside is $closesOnClickOutside',
async ({ closesOnClickOutside, expected }) => {
const { wrapper } = await mountOpenPopup({ closesOnClickOutside })
const outside = wrapper.get('.outside')
await outside.trigger('pointerdown')
await outside.trigger('click')
expect(wrapper.vm.isOpen).toBe(expected)
}
)
})

View File

@@ -12,11 +12,32 @@ The selection is stored by item ID, so it is kept when changing page or filter.
| `filteredItems` | `MaybeRefOrGetter<TItem[]>` | The items matching the current filter |
| `pageItems` | `MaybeRefOrGetter<TItem[]>` | The items displayed on the current page |
| `getItemId` | `(item: TItem) => TId` | Returns the ID of an item (`TId` extends `CollectionItemId`) |
| `selectedIds` | `Ref<TId[]>` | Optional ref holding the selected IDs (see below) |
`filteredItems` and `pageItems` must contain items of the same type as `items`. Only their IDs are used.
The returned IDs keep the type `getItemId` returns (a branded ID stays branded).
### `selectedIds`
Without it, the selection is kept by the composable and starts empty.
With it, the selection is read from and written to the given ref (a `defineModel` for example): its value when the composable is called is the initial selection, and it can be changed from outside.
```typescript
const selectedVmIds = defineModel<Vm['id'][]>('selectedVmIds', { required: true })
const { pageSelectionModel, isSelected, toggleSelection, selectionBindings } = useTableSelection({
items: () => vms.value,
filteredItems: filteredVms,
pageItems: paginatedVms,
getItemId: vm => vm.id,
selectedIds: selectedVmIds,
})
```
IDs that match no item of `items` are kept in the ref, so the selection can be set before the items are loaded. They are ignored by the returned values.
## Returned values
| Name | Description |

View File

@@ -1,6 +1,6 @@
import { type CollectionItemId, useCollection } from '@core/packages/collection'
import { useArrayMap } from '@vueuse/core'
import { computed, type MaybeRefOrGetter, toValue } from 'vue'
import { computed, type MaybeRefOrGetter, type Ref, toValue } from 'vue'
export type SelectionBindings = {
selectedCount: number
@@ -18,6 +18,7 @@ export function useTableSelection<TItem, TId extends CollectionItemId>(config: {
filteredItems: MaybeRefOrGetter<NoInfer<TItem>[]>
pageItems: MaybeRefOrGetter<NoInfer<TItem>[]>
getItemId: (item: TItem) => TId
selectedIds?: Ref<NoInfer<TId>[]>
}) {
const filteredIds = computed(
() => new Set<CollectionItemId>(toValue(config.filteredItems).map(item => config.getItemId(item)))
@@ -29,7 +30,7 @@ export function useTableSelection<TItem, TId extends CollectionItemId>(config: {
const { useFlag, useSubset, clearFlag } = useCollection(config.items, {
itemId: config.getItemId,
flags: { selected: true },
flags: { selected: { ids: config.selectedIds } },
})
const selectionFlag = useFlag('selected')

View File

@@ -0,0 +1,289 @@
import { useTableSelection } from '@core/composables/table-selection.composable.ts'
import { type MaybeRefOrGetter, ref, type Ref, toValue, watch } from 'vue'
type Vm = { id: string }
function createVms(...ids: string[]): Vm[] {
return ids.map(id => ({ id }))
}
function useVmSelection(config: {
items: MaybeRefOrGetter<Vm[]>
filteredItems?: MaybeRefOrGetter<Vm[]>
pageItems?: MaybeRefOrGetter<Vm[]>
selectedIds?: Ref<string[]>
}) {
const filteredItems = config.filteredItems ?? config.items
return useTableSelection({
items: config.items,
filteredItems,
pageItems: config.pageItems ?? filteredItems,
getItemId: vm => vm.id,
selectedIds: config.selectedIds,
})
}
describe('selectedIds', () => {
it('is empty by default', () => {
const { selectedIds } = useVmSelection({ items: createVms('vm-1', 'vm-2') })
expect(selectedIds.value).toEqual([])
})
it('includes the selected items hidden by the filter', () => {
const { selectedIds, toggleSelection } = useVmSelection({
items: createVms('vm-1', 'vm-2'),
filteredItems: createVms('vm-1'),
})
toggleSelection('vm-1')
toggleSelection('vm-2')
expect(selectedIds.value).toEqual(['vm-1', 'vm-2'])
})
it('leaves out the items that are no longer in `items`', () => {
const items = ref(createVms('vm-1', 'vm-2'))
const { selectedIds, toggleSelection } = useVmSelection({ items })
toggleSelection('vm-1')
toggleSelection('vm-2')
items.value = createVms('vm-2')
expect(selectedIds.value).toEqual(['vm-2'])
})
})
describe('selectedItems', () => {
it('holds the selected items', () => {
const [firstVm, secondVm] = createVms('vm-1', 'vm-2')
const { selectedItems, toggleSelection } = useVmSelection({ items: [firstVm, secondVm] })
toggleSelection('vm-2')
expect(selectedItems.value).toEqual([secondVm])
})
})
describe('isSelected', () => {
it('tells the selected items from the others', () => {
const { isSelected, toggleSelection } = useVmSelection({ items: createVms('vm-1', 'vm-2') })
toggleSelection('vm-1')
expect(isSelected('vm-1')).toBe(true)
expect(isSelected('vm-2')).toBe(false)
})
})
describe('toggleSelection', () => {
it('unselects a selected item', () => {
const { isSelected, toggleSelection } = useVmSelection({ items: createVms('vm-1') })
toggleSelection('vm-1')
toggleSelection('vm-1')
expect(isSelected('vm-1')).toBe(false)
})
})
describe('pageSelectionModel', () => {
it('is false when no item of the page is selected', () => {
const { pageSelectionModel, toggleSelection } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3'),
pageItems: createVms('vm-1', 'vm-2'),
})
toggleSelection('vm-3')
expect(pageSelectionModel.value).toBe(false)
})
it('is undefined when only some items of the page are selected', () => {
const { pageSelectionModel, toggleSelection } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3'),
pageItems: createVms('vm-1', 'vm-2'),
})
toggleSelection('vm-1')
expect(pageSelectionModel.value).toBeUndefined()
})
it('is true when every item of the page is selected', () => {
const { pageSelectionModel, toggleSelection } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3'),
pageItems: createVms('vm-1', 'vm-2'),
})
toggleSelection('vm-1')
toggleSelection('vm-2')
expect(pageSelectionModel.value).toBe(true)
})
it('selects the items of the page only when set to true', () => {
const { pageSelectionModel, selectedIds } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3'),
pageItems: createVms('vm-1', 'vm-2'),
})
pageSelectionModel.value = true
expect(selectedIds.value).toEqual(['vm-1', 'vm-2'])
})
it('unselects the items of the page only when set to false', () => {
const { pageSelectionModel, selectedIds, toggleSelection } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3'),
pageItems: createVms('vm-1', 'vm-2'),
})
toggleSelection('vm-1')
toggleSelection('vm-3')
pageSelectionModel.value = false
expect(selectedIds.value).toEqual(['vm-3'])
})
})
describe('selectionBindings', () => {
it('counts the selected items, the ones out of the page and the filtered items', () => {
const { selectionBindings, toggleSelection } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3', 'vm-4'),
filteredItems: createVms('vm-1', 'vm-2', 'vm-3'),
pageItems: createVms('vm-1', 'vm-2'),
})
toggleSelection('vm-1')
toggleSelection('vm-3')
toggleSelection('vm-4')
expect(selectionBindings.value).toMatchObject({ selectedCount: 3, hiddenSelectedCount: 2, filteredCount: 3 })
})
it('tells whether the whole page, the whole filter and every item are selected', () => {
const { selectionBindings, toggleSelection } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3'),
filteredItems: createVms('vm-1', 'vm-2'),
pageItems: createVms('vm-1'),
})
toggleSelection('vm-1')
expect(selectionBindings.value).toMatchObject({
areAllPageItemsSelected: true,
areAllFilteredItemsSelected: false,
areAllItemsSelected: false,
})
toggleSelection('vm-2')
expect(selectionBindings.value).toMatchObject({
areAllPageItemsSelected: true,
areAllFilteredItemsSelected: true,
areAllItemsSelected: false,
})
toggleSelection('vm-3')
expect(selectionBindings.value).toMatchObject({
areAllPageItemsSelected: true,
areAllFilteredItemsSelected: true,
areAllItemsSelected: true,
})
})
it('selects every item matching the filter on `onSelectAll`', () => {
const { selectionBindings, selectedIds } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3'),
filteredItems: createVms('vm-1', 'vm-2'),
pageItems: createVms('vm-1'),
})
selectionBindings.value.onSelectAll()
expect(selectedIds.value).toEqual(['vm-1', 'vm-2'])
})
it('unselects every item, hidden by the filter or not, on `onClearSelection`', () => {
const { selectionBindings, selectedIds, toggleSelection } = useVmSelection({
items: createVms('vm-1', 'vm-2'),
filteredItems: createVms('vm-1'),
})
toggleSelection('vm-1')
toggleSelection('vm-2')
selectionBindings.value.onClearSelection()
expect(selectedIds.value).toEqual([])
})
})
describe('`selectedIds` option', () => {
it('starts with the items of the ref selected', () => {
const { selectedIds } = useVmSelection({
items: createVms('vm-1', 'vm-2'),
selectedIds: ref(['vm-2']),
})
expect(selectedIds.value).toEqual(['vm-2'])
})
it('receives the selection', () => {
const selectedVmIds = ref<string[]>([])
const { toggleSelection } = useVmSelection({ items: createVms('vm-1', 'vm-2'), selectedIds: selectedVmIds })
toggleSelection('vm-2')
expect(toValue(selectedVmIds)).toEqual(['vm-2'])
})
it('changes the selection when set from outside', () => {
const selectedVmIds = ref(['vm-1'])
const { isSelected } = useVmSelection({ items: createVms('vm-1', 'vm-2'), selectedIds: selectedVmIds })
selectedVmIds.value = ['vm-2']
expect(isSelected('vm-1')).toBe(false)
expect(isSelected('vm-2')).toBe(true)
})
it('keeps the ids matching no item, which the returned values ignore', () => {
const selectedVmIds = ref(['vm-9'])
const { selectedIds, selectionBindings, toggleSelection } = useVmSelection({
items: createVms('vm-1'),
selectedIds: selectedVmIds,
})
toggleSelection('vm-1')
expect(toValue(selectedVmIds)).toEqual(['vm-9', 'vm-1'])
expect(selectedIds.value).toEqual(['vm-1'])
expect(selectionBindings.value.selectedCount).toBe(1)
})
it('selects an item loaded after its id was set', () => {
const items = ref<Vm[]>([])
const { selectedIds } = useVmSelection({ items, selectedIds: ref(['vm-1']) })
items.value = createVms('vm-1', 'vm-2')
expect(selectedIds.value).toEqual(['vm-1'])
})
it('is written once on `onSelectAll`', () => {
const selectedVmIds = ref<string[]>([])
const onWrite = vi.fn()
const { selectionBindings } = useVmSelection({
items: createVms('vm-1', 'vm-2', 'vm-3'),
selectedIds: selectedVmIds,
})
watch(selectedVmIds, onWrite, { flush: 'sync' })
selectionBindings.value.onSelectAll()
expect(onWrite).toHaveBeenCalledTimes(1)
})
})

View File

@@ -4,10 +4,12 @@ import { faCopy, faSquare as checkboxEmpty, type IconDefinition } from '@fortawe
import {
faAdd,
faArrowCircleRight,
faArrowDown,
faArrowDownLong,
faArrowRight,
faArrowRotateLeft,
faArrowRotateRight,
faArrowUp,
faArrowUpLong,
faArrowUpRightFromSquare,
faBan,
@@ -153,6 +155,8 @@ export const actionIcons = defineIconPack({
color: 'var(--color-neutral-txt-primary)',
rotate: 90,
},
'move-down': constructIcon(faArrowDown),
'move-up': constructIcon(faArrowUp),
'import-export': [
{
icon: faArrowUpLong,

View File

@@ -91,6 +91,7 @@
"action:edit-br": "@:action:edit BR",
"action:edit-config": "Edit config",
"action:edit-n-brs": "@:action:edit {n} BRs",
"action:edit-rules-order": "@:action:edit rules order within network",
"action:edit-settings": "@:action:edit @.lower:settings",
"action:edit-traffic-rule": "@:action:edit @.lower:traffic-rule",
"action:edit-vm-settings": "@:action:edit {name} @.lower:settings",
@@ -137,7 +138,9 @@
"action:migrate": "Migrate",
"action:migrate-n-vms": "Migrate 1 VM | Migrate {n} VMs",
"action:migrate-vdi-on-sr": "Migrate on SR",
"action:move-down": "Move down",
"action:move-filters-to-parent-group": "Move filters to parent group",
"action:move-up": "Move up",
"action:next-mapping": "Next: mapping",
"action:next-review": "Next: review",
"action:open": "Open",
@@ -524,6 +527,7 @@
"form:error:maximum": "Must be {max} or less",
"form:error:min-items": "Must contain at least {n} item | Must contain at least {n} items",
"form:error:minimum": "Must be {min} or more",
"form:error:must-match": "Must match “{text}”",
"form:error:required": "This field is required",
"form:n-errors-summary": "{n} field needs attention | {n} fields need attention",
"form:warning:out-of-range": "Should be between {min} and {max}",
@@ -631,6 +635,7 @@
"job:arg:missing-payload": "Payload is missing",
"job:arg:name-required": "@:name-required",
"job:arg:nbd-and-insecure-nbd-exclusive": "NBD and insecure NBD cannot be enabled together",
"job:arg:network-required": "@:network-required",
"job:arg:password-required": "Password is required",
"job:arg:pif-id-required": "PIF ID is required",
"job:arg:pif-ids-required": "At least one PIF ID is required",
@@ -761,6 +766,8 @@
"job:sr-delete:missing-sr": "No SRs to delete",
"job:sr-disconnect:missing-sr": "No SRs to disconnect",
"job:traffic-rule-delete:missing-rule": "No traffic rule selected",
"job:traffic-rule-edit-order:no-free-priority": "No free priority left on this network to apply this order",
"job:traffic-rule-edit-order:not-enough-rules": "Requires at least {n} rules",
"job:v2v-start:in-progress": "Migration launch in progress…",
"job:v2v-start:missing-vm": "No VMs to migrate",
"job:vbd-connect:missing-vbd": "No VBDs to connect",
@@ -1532,6 +1539,8 @@
"traffic-rule": "Traffic rule",
"traffic-rule-delete-warning": "This action is irreversible. The selected traffic rule will be permanently deleted.",
"traffic-rules": "Traffic rules",
"traffic-rules:edit-order-info": "Traffic rules are evaluated by priority, starting with rule 1, then rule 2, and so on. The first matching rule is applied, and subsequent rules are skipped. Priority only matters within the same network.",
"traffic-rules:edit-order-save-info": "Changes will only take effect when you save.",
"traffic-rules:error-plugin": "You are using the direct OpenFlow protocol (legacy mode), which does not support network traffic rules. To create them, switch to the XAPI plugin mode (beta) — see {check-doc}.",
"traffic-rules:error-plugin:check-doc": "the SDN controller documentation",
"traffic-rules:format-warning": "Configuration error: Traffic rules are not in the expected format. Please {check-doc} on how to migrate them.",
@@ -1541,7 +1550,8 @@
"traffic-rules:position-on-network": "{position} rule on this network.",
"traffic-rules:rule-ordinal-suffixes": "one:st, two:nd, few:rd, other:th",
"traffic-rules:target-on": "@.capitalize:direction-on",
"traffic-rules:xapi-plugin-required": "Requires XAPI plugin mode",
"traffic-rules:xapi-plugin-required": "Requires @:xapi-plugin mode",
"traffic-rules:xapi-plugin-required-with-link": "Requires {xapi-plugin} mode",
"transfer": "Transfer",
"transfer-size": "@:transfer @.lower:size",
"translation-tool": "Translation tool",
@@ -1767,6 +1777,7 @@
"with-memory": "With memory",
"write": "Write",
"writing-speed": "Writing speed",
"xapi-plugin": "XAPI plugin",
"xcp-ng": "XCP-ng",
"xen-orchestra": "Xen Orchestra",
"xo": "XO",

View File

@@ -91,6 +91,7 @@
"action:edit-br": "@:action:edit le BR",
"action:edit-config": "Modifier config",
"action:edit-n-brs": "@:action:edit {n} BRs",
"action:edit-rules-order": "@:action:edit l'ordre des règles dans le réseau",
"action:edit-settings": "@:action:edit les @.lower:settings",
"action:edit-traffic-rule": "@:action:edit la @.lower:traffic-rule",
"action:edit-vm-settings": "@:action:edit les @.lower:settings de {name}",
@@ -137,7 +138,9 @@
"action:migrate": "Migrer",
"action:migrate-n-vms": "Migrer 1 VM | Migrer {n} VMs",
"action:migrate-vdi-on-sr": "Migrer sur le SR",
"action:move-down": "Descendre",
"action:move-filters-to-parent-group": "Déplacer les filtres vers le groupe parent",
"action:move-up": "Monter",
"action:next-mapping": "Suivant : correspondance",
"action:next-review": "Suivant : récapitulatif",
"action:open": "Ouvrir",
@@ -524,6 +527,7 @@
"form:error:maximum": "Doit être inférieur ou égal à {max}",
"form:error:min-items": "Doit contenir au moins {n} élément | Doit contenir au moins {n} éléments",
"form:error:minimum": "Doit être supérieur ou égal à {min}",
"form:error:must-match": "Doit correspondre à « {text} »",
"form:error:required": "Ce champ est requis",
"form:n-errors-summary": "{n} champ est à corriger | {n} champs sont à corriger",
"form:warning:out-of-range": "Devrait être compris entre {min} et {max}",
@@ -631,6 +635,7 @@
"job:arg:missing-payload": "Aucune donnée fournie pour l'execution du job",
"job:arg:name-required": "@:name-required",
"job:arg:nbd-and-insecure-nbd-exclusive": "NBD et NBD non sécurisé ne peuvent pas être activés ensemble",
"job:arg:network-required": "@:network-required",
"job:arg:password-required": "Le mot de passe est obligatoire",
"job:arg:pif-id-required": "L'ID de PIF est obligatoire",
"job:arg:pif-ids-required": "Au moins un ID de PIF est obligatoire",
@@ -761,6 +766,8 @@
"job:sr-delete:missing-sr": "Aucun SR à supprimer",
"job:sr-disconnect:missing-sr": "Aucun SR à déconnecter",
"job:traffic-rule-delete:missing-rule": "Aucune règle de trafic sélectionnée",
"job:traffic-rule-edit-order:no-free-priority": "Plus aucune priorité libre sur ce réseau pour appliquer cet ordre",
"job:traffic-rule-edit-order:not-enough-rules": "Nécessite au moins {n} règles",
"job:v2v-start:in-progress": "Lancement de la migration en cours…",
"job:v2v-start:missing-vm": "Aucune VM à migrer",
"job:vbd-connect:missing-vbd": "Aucun VBD à connecter",
@@ -1532,6 +1539,8 @@
"traffic-rule": "Règle de trafic",
"traffic-rule-delete-warning": "Cette action est irréversible. La règle de trafic sélectionnée sera définitivement supprimée.",
"traffic-rules": "Règles de trafic",
"traffic-rules:edit-order-info": "Les règles de trafic sont évaluées par priorité, en commençant par la règle 1, puis la règle 2, et ainsi de suite. La première règle correspondante est appliquée et les suivantes sont ignorées. La priorité ne compte qu'au sein d'un même réseau.",
"traffic-rules:edit-order-save-info": "Les modifications ne prendront effet qu'à l'enregistrement.",
"traffic-rules:error-plugin": "Vous utilisez le protocole OpenFlow direct (mode historique), qui ne prend pas en charge les règles de trafic réseau. Pour en créer, passez en mode plugin XAPI (bêta) — voir {check-doc}.",
"traffic-rules:error-plugin:check-doc": "la documentation du contrôleur SDN",
"traffic-rules:format-warning": "Erreur de configuration : les règles de trafic ne sont pas au format attendu. Veuillez {check-doc} la plus récente pour savoir comment les migrer.",
@@ -1541,7 +1550,8 @@
"traffic-rules:position-on-network": "{position} règle sur ce réseau.",
"traffic-rules:rule-ordinal-suffixes": "one:re, other:e",
"traffic-rules:target-on": "@.capitalize:direction-on",
"traffic-rules:xapi-plugin-required": "Nécessite le mode plugin XAPI",
"traffic-rules:xapi-plugin-required": "Nécessite le mode @:xapi-plugin",
"traffic-rules:xapi-plugin-required-with-link": "Nécessite le mode {xapi-plugin}",
"transfer": "Transfert",
"transfer-size": "@:size du @.lower:transfer",
"translation-tool": "Outil de traduction",
@@ -1767,6 +1777,7 @@
"with-memory": "Avec mémoire",
"write": "Écriture",
"writing-speed": "Vitesse d'écriture",
"xapi-plugin": "plugin XAPI",
"xcp-ng": "XCP-ng",
"xen-orchestra": "Xen Orchestra",
"xo": "XO",

View File

@@ -45,9 +45,9 @@ If `TSource` doesn't provide an `id`, then `options.itemId` will be required.
### `CollectionConfigFlags` type
```typescript
type FlagConfig = { multiple?: MaybeRef<boolean> }
type FlagConfig<TId> = { multiple?: MaybeRef<boolean>; ids?: Ref<TId[]> }
type CollectionConfigFlags<TFlag extends string> = Record<TFlag, true | FlagConfig>
type CollectionConfigFlags<TFlag extends string, TId> = Record<TFlag, true | FlagConfig<TId>>
```
A flag that needs no configuration is declared with `true`.
@@ -57,6 +57,19 @@ Values for `multiple`:
- `true` (default): multiple items can share the same flag.
- `false`: only one item can have the flag at a time (exclusive selection). Setting the flag on one item will automatically unset it on all other items.
`ids` is the ref holding the IDs of the flagged items. Pass your own ref (a `defineModel` for example) to set the initially flagged items, and to read or change the flagged IDs from outside the collection:
```typescript
const selectedIds = defineModel<User['id'][]>('selectedIds', { required: true })
const { useFlag } = useCollection(users, {
flags: { selected: { ids: selectedIds } },
})
```
- The ref is written once per operation (`toggleAll` and `clearFlag` included), with a new array.
- IDs that match no item of the collection are kept in the ref: an item added later with one of these IDs is flagged.
## Return Value
| Name | Type | Description |

View File

@@ -43,9 +43,11 @@ export function createCollection<
}
function toggleAll(shouldBeFlagged = !areAllOn.value) {
for (const item of items.value) {
flagRegistry.toggleFlag(item.id, flag, shouldBeFlagged)
}
flagRegistry.toggleFlags(
items.value.map(item => item.id),
flag,
shouldBeFlagged
)
}
const useSubset = createUseSubset<TSource, TFlag, TProperties, TId>(flaggedItems, flagRegistry)

View File

@@ -1,5 +1,5 @@
import type { ArrayFilterPredicate, KeyOfByValue } from '@core/types/utility.type.ts'
import type { ComputedRef, MaybeRef, Reactive } from 'vue'
import type { ComputedRef, MaybeRef, Reactive, Ref } from 'vue'
export type CollectionItem<
TSource = unknown,
@@ -55,16 +55,21 @@ export type ExtractSourceId<TSource, TGetId extends GetItemId<TSource>> = TGetId
? TSource
: PickSourceId<TSource, 'id'>
export type FlagConfig = {
export type FlagConfig<TId extends CollectionItemId = CollectionItemId> = {
multiple?: MaybeRef<boolean>
ids?: Ref<TId[]>
}
export type CollectionConfigFlags<TFlag extends string> = Record<TFlag, true | FlagConfig>
export type CollectionConfigFlags<TFlag extends string, TId extends CollectionItemId = CollectionItemId> = Record<
TFlag,
true | FlagConfig<TId>
>
export type FlagRegistry<TId extends CollectionItemId, TFlag extends string> = {
isFlagged: (id: TId, flag: TFlag) => boolean
isFlagDefined: (flag: TFlag) => boolean
toggleFlag: (id: TId, flag: TFlag, shouldBeFlagged?: boolean) => void
toggleFlags: (ids: TId[], flag: TFlag, shouldBeFlagged: boolean) => void
clearFlag: (flag: TFlag) => void
isMultipleAllowed: (flag: TFlag) => boolean
assertFlag: (flag: TFlag) => void

View File

@@ -26,7 +26,7 @@ export function useCollection<
source: MaybeRefOrGetter<TSource[]>,
config?: {
itemId?: TGetId | ((source: TSource) => CollectionItemId)
flags?: CollectionConfigFlags<TFlag>
flags?: CollectionConfigFlags<TFlag, $TId>
properties?: (source: TSource, index: number) => TProperties
}
): RootCollection<TSource, TFlag, TProperties, $TId>
@@ -43,7 +43,7 @@ export function useCollection<
source: MaybeRefOrGetter<TSource[]>,
config?: {
itemId?: TGetId | ((source: TSource) => CollectionItemId)
flags?: CollectionConfigFlags<TFlag>
flags?: CollectionConfigFlags<TFlag, $TId>
properties?: (source: TSource, index: number) => TProperties
}
): RootCollection<TSource, TFlag, TProperties, $TId>
@@ -60,7 +60,7 @@ export function useCollection<
source: MaybeRefOrGetter<TSource[]>,
config: {
itemId: TGetId | ((source: TSource) => CollectionItemId)
flags?: CollectionConfigFlags<TFlag>
flags?: CollectionConfigFlags<TFlag, $TId>
properties?: (source: TSource, index: number) => TProperties
}
): RootCollection<TSource, TFlag, TProperties, $TId>
@@ -77,7 +77,7 @@ export function useCollection<
_sources: MaybeRefOrGetter<TSource[]>,
config?: {
itemId?: TGetId
flags?: CollectionConfigFlags<TFlag>
flags?: CollectionConfigFlags<TFlag, $TId>
properties?: (source: TSource, index: number) => TProperties
}
): RootCollection<TSource, TFlag, TProperties, $TId> {

View File

@@ -0,0 +1,414 @@
import { type MaybeRefOrGetter, ref, type Ref, toValue, watch } from 'vue'
import { useCollection } from './use-collection.ts'
type User = { id: string; group: 'admin' | 'user' }
function createUsers(): User[] {
return [
{ id: 'user-1', group: 'admin' },
{ id: 'user-2', group: 'admin' },
{ id: 'user-3', group: 'user' },
]
}
function useUserCollection(config: { users?: MaybeRefOrGetter<User[]>; selectedIds?: Ref<string[]> } = {}) {
return useCollection(config.users ?? createUsers(), {
flags: { selected: { ids: config.selectedIds }, active: { multiple: false } },
})
}
function getItem<TItem extends { id: string }>(items: Ref<TItem[]>, id: string) {
const item = toValue(items).find(candidate => candidate.id === id)
if (item === undefined) {
throw new Error(`Item "${id}" not found`)
}
return item
}
describe('items', () => {
it('holds an item per source, with its id and its source', () => {
const users = createUsers()
const { items } = useCollection(users)
expect(items.value.map(item => item.id)).toEqual(['user-1', 'user-2', 'user-3'])
expect(items.value.map(item => item.source)).toEqual(users)
})
it('follows the sources', () => {
const users = ref(createUsers())
const { items } = useCollection(users)
users.value = [{ id: 'user-4', group: 'user' }]
expect(items.value.map(item => item.id)).toEqual(['user-4'])
})
it('uses the source itself as id when it is a string or a number', () => {
const { items } = useCollection(['first', 2])
expect(items.value.map(item => item.id)).toEqual(['first', 2])
})
it('reads the id from the property named by `itemId`', () => {
const { items } = useCollection([{ uuid: 'user-1' }], { itemId: 'uuid' })
expect(items.value.map(item => item.id)).toEqual(['user-1'])
})
it('reads the id returned by the `itemId` function', () => {
const { items } = useCollection([{ name: 'alice' }], { itemId: user => `user-${user.name}` })
expect(items.value.map(item => item.id)).toEqual(['user-alice'])
})
it('attaches the properties computed from each source', () => {
const { items } = useCollection(createUsers(), {
properties: (user, index) => ({ isAdmin: user.group === 'admin', position: index + 1 }),
})
expect(items.value.map(item => item.properties)).toEqual([
{ isAdmin: true, position: 1 },
{ isAdmin: true, position: 2 },
{ isAdmin: false, position: 3 },
])
})
})
describe('count', () => {
it('is the number of items', () => {
const users = ref(createUsers())
const { count } = useCollection(users)
expect(count.value).toBe(3)
users.value = []
expect(count.value).toBe(0)
})
})
describe('useSubset', () => {
it('keeps the items matching the filter', () => {
const { useSubset } = useCollection(createUsers())
const admins = useSubset(item => item.source.group === 'admin')
expect(admins.items.value.map(item => item.id)).toEqual(['user-1', 'user-2'])
expect(admins.count.value).toBe(2)
})
it('can be narrowed by a subset of its own', () => {
const { useSubset } = useCollection(createUsers())
const admins = useSubset(item => item.source.group === 'admin')
const lastAdmins = admins.useSubset(item => item.id !== 'user-1')
expect(lastAdmins.items.value.map(item => item.id)).toEqual(['user-2'])
})
})
describe.each([
['kept by the collection', () => undefined],
['held by an `ids` ref', () => ref<string[]>([])],
])('flags %s', (_label, createSelectedIds) => {
function useSelectableUsers(users: MaybeRefOrGetter<User[]> = createUsers()) {
return useUserCollection({ users, selectedIds: createSelectedIds() })
}
describe('item.flags', () => {
it('is false for an item that was never flagged', () => {
const { items } = useSelectableUsers()
expect(getItem(items, 'user-1').flags.selected).toBe(false)
})
it('flags the item when set to true', () => {
const { items } = useSelectableUsers()
getItem(items, 'user-1').flags.selected = true
expect(getItem(items, 'user-1').flags.selected).toBe(true)
expect(getItem(items, 'user-2').flags.selected).toBe(false)
})
it('unflags the previous item of a flag whose `multiple` is false', () => {
const { items } = useSelectableUsers()
getItem(items, 'user-1').flags.active = true
getItem(items, 'user-2').flags.active = true
expect(getItem(items, 'user-1').flags.active).toBe(false)
expect(getItem(items, 'user-2').flags.active).toBe(true)
})
})
describe('item.toggleFlag', () => {
it('toggles the flag of the item', () => {
const { items } = useSelectableUsers()
getItem(items, 'user-1').toggleFlag('selected')
expect(getItem(items, 'user-1').flags.selected).toBe(true)
getItem(items, 'user-1').toggleFlag('selected')
expect(getItem(items, 'user-1').flags.selected).toBe(false)
})
it('forces the flag to the given state', () => {
const { items } = useSelectableUsers()
getItem(items, 'user-1').toggleFlag('selected', true)
getItem(items, 'user-1').toggleFlag('selected', true)
expect(getItem(items, 'user-1').flags.selected).toBe(true)
})
})
describe('toggleFlag', () => {
it('toggles the flag of the item with the given id', () => {
const { items, toggleFlag } = useSelectableUsers()
toggleFlag('user-2', 'selected')
expect(getItem(items, 'user-2').flags.selected).toBe(true)
})
})
describe('useFlag', () => {
it('lists the flagged items, their ids and their count, in the order of the collection', () => {
const { useFlag } = useSelectableUsers()
const selection = useFlag('selected')
selection.toggle('user-3')
selection.toggle('user-1')
expect(selection.items.value.map(item => item.source.id)).toEqual(['user-1', 'user-3'])
expect(selection.ids.value).toEqual(['user-1', 'user-3'])
expect(selection.count.value).toBe(2)
})
it('tells the flagged items from the others with `isOn`', () => {
const { useFlag } = useSelectableUsers()
const selection = useFlag('selected')
selection.toggle('user-1')
expect(selection.isOn('user-1')).toBe(true)
expect(selection.isOn('user-2')).toBe(false)
})
it('unflags a flagged item with `toggle`', () => {
const { useFlag } = useSelectableUsers()
const selection = useFlag('selected')
selection.toggle('user-1')
selection.toggle('user-1')
expect(selection.isOn('user-1')).toBe(false)
})
it('tells whether none, some or all the items are flagged', () => {
const { useFlag } = useSelectableUsers()
const selection = useFlag('selected')
expect([selection.areNoneOn.value, selection.areSomeOn.value, selection.areAllOn.value]).toEqual([
true,
false,
false,
])
selection.toggle('user-1')
expect([selection.areNoneOn.value, selection.areSomeOn.value, selection.areAllOn.value]).toEqual([
false,
true,
false,
])
selection.toggle('user-2')
selection.toggle('user-3')
expect([selection.areNoneOn.value, selection.areSomeOn.value, selection.areAllOn.value]).toEqual([
false,
true,
true,
])
})
it('never has `areAllOn` true on an empty collection', () => {
const { useFlag } = useSelectableUsers([])
expect(useFlag('selected').areAllOn.value).toBe(false)
})
it('flags every item with `toggleAll` unless they all are', () => {
const { useFlag } = useSelectableUsers()
const selection = useFlag('selected')
selection.toggle('user-1')
selection.toggleAll()
expect(selection.ids.value).toEqual(['user-1', 'user-2', 'user-3'])
})
it('unflags every item with `toggleAll` when they all are flagged', () => {
const { useFlag } = useSelectableUsers()
const selection = useFlag('selected')
selection.toggleAll()
selection.toggleAll()
expect(selection.ids.value).toEqual([])
})
it('forces every item to the state given to `toggleAll`', () => {
const { useFlag } = useSelectableUsers()
const selection = useFlag('selected')
selection.toggle('user-1')
selection.toggleAll(false)
expect(selection.ids.value).toEqual([])
selection.toggleAll(true)
selection.toggleAll(true)
expect(selection.ids.value).toEqual(['user-1', 'user-2', 'user-3'])
})
it('limits `toggleAll` to the items of the subset it comes from', () => {
const { useFlag, useSubset } = useSelectableUsers()
const selection = useFlag('selected')
const adminSelection = useSubset(item => item.source.group === 'admin').useFlag('selected')
adminSelection.toggleAll(true)
expect(selection.ids.value).toEqual(['user-1', 'user-2'])
selection.toggle('user-3')
adminSelection.toggleAll(false)
expect(selection.ids.value).toEqual(['user-3'])
})
it('narrows the flagged items with `useSubset`', () => {
const { useFlag } = useSelectableUsers()
const selection = useFlag('selected')
selection.toggleAll(true)
const selectedAdmins = selection.useSubset(item => item.source.group === 'admin')
expect(selectedAdmins.items.value.map(item => item.id)).toEqual(['user-1', 'user-2'])
})
})
describe('clearFlag', () => {
it('unflags every item', () => {
const { clearFlag, useFlag } = useSelectableUsers()
const selection = useFlag('selected')
selection.toggleAll(true)
clearFlag('selected')
expect(selection.ids.value).toEqual([])
})
it('unflags the items that are no longer in the collection', () => {
const users = ref(createUsers())
const { clearFlag, useFlag } = useSelectableUsers(users)
const selection = useFlag('selected')
selection.toggle('user-1')
users.value = []
clearFlag('selected')
users.value = createUsers()
expect(selection.ids.value).toEqual([])
})
})
})
describe('`ids` flag option', () => {
it('flags the items whose id the ref holds when the collection is created', () => {
const { useFlag } = useUserCollection({ selectedIds: ref(['user-2']) })
expect(useFlag('selected').ids.value).toEqual(['user-2'])
})
it('receives the ids of the flagged items', () => {
const selectedIds = ref<string[]>([])
const { items, useFlag } = useUserCollection({ selectedIds })
useFlag('selected').toggle('user-2')
getItem(items, 'user-1').flags.selected = true
expect(toValue(selectedIds)).toEqual(['user-2', 'user-1'])
})
it('changes the flagged items when set from outside', () => {
const selectedIds = ref(['user-1'])
const { useFlag } = useUserCollection({ selectedIds })
const selection = useFlag('selected')
selectedIds.value = ['user-2', 'user-3']
expect(selection.ids.value).toEqual(['user-2', 'user-3'])
})
it('keeps the ids matching no item, which the flag utilities ignore', () => {
const selectedIds = ref(['user-9'])
const { useFlag } = useUserCollection({ selectedIds })
const selection = useFlag('selected')
selection.toggle('user-1')
expect(toValue(selectedIds)).toEqual(['user-9', 'user-1'])
expect(selection.ids.value).toEqual(['user-1'])
expect(selection.count.value).toBe(1)
})
it('flags an item added after its id was set', () => {
const users = ref<User[]>([])
const { useFlag } = useUserCollection({ users, selectedIds: ref(['user-2']) })
const selection = useFlag('selected')
users.value = createUsers()
expect(selection.ids.value).toEqual(['user-2'])
})
it('keeps the ids out of the subset on a subset `toggleAll`', () => {
const selectedIds = ref(['user-1', 'user-3', 'user-9'])
const { useSubset } = useUserCollection({ selectedIds })
useSubset(item => item.source.group === 'admin')
.useFlag('selected')
.toggleAll(false)
expect(toValue(selectedIds)).toEqual(['user-3', 'user-9'])
})
it('is written once on `toggleAll`', () => {
const selectedIds = ref<string[]>([])
const onWrite = vi.fn()
const { useFlag } = useUserCollection({ selectedIds })
watch(selectedIds, onWrite, { flush: 'sync' })
useFlag('selected').toggleAll(true)
expect(onWrite).toHaveBeenCalledTimes(1)
})
it('is emptied by `clearFlag`, ids matching no item included', () => {
const selectedIds = ref(['user-1', 'user-9'])
const { clearFlag } = useUserCollection({ selectedIds })
clearFlag('selected')
expect(toValue(selectedIds)).toEqual([])
})
})

View File

@@ -1,19 +1,28 @@
import { objectFromEntries, objectEntries } from '@core/utils/object.util.ts'
import type { CollectionConfigFlags, CollectionItemId, FlagConfig, FlagRegistry } from './types.ts'
import { isRef, reactive, unref, watch } from 'vue'
import { computed, type ComputedRef, isRef, type Ref, shallowRef, unref, watch } from 'vue'
export function useFlagRegistry<TFlag extends string, TId extends CollectionItemId>(
config: CollectionConfigFlags<TFlag> = {} as CollectionConfigFlags<TFlag>
config: CollectionConfigFlags<TFlag, TId> = {} as CollectionConfigFlags<TFlag, TId>
): FlagRegistry<TId, TFlag> {
const registry = reactive(new Map()) as Map<TFlag, Set<TId>>
const flags = objectFromEntries(
objectEntries(config).map(([flag, flagConfig]): [TFlag, FlagConfig] => [
objectEntries(config).map(([flag, flagConfig]): [TFlag, FlagConfig<TId>] => [
flag,
flagConfig === true ? {} : flagConfig,
])
)
const flaggedIdsByFlag = objectFromEntries(
objectEntries(flags).map(([flag, { ids = shallowRef<TId[]>([]) }]): [TFlag, Ref<TId[]>] => [flag, ids])
)
const flaggedIdSetsByFlag = objectFromEntries(
objectEntries(flaggedIdsByFlag).map(([flag, flaggedIds]): [TFlag, ComputedRef<Set<TId>>] => [
flag,
computed(() => new Set(flaggedIds.value)),
])
)
for (const [flag, { multiple }] of objectEntries(flags)) {
if (isRef(multiple)) {
watch(multiple, () => clearFlag(flag))
@@ -33,42 +42,58 @@ export function useFlagRegistry<TFlag extends string, TId extends CollectionItem
function isFlagged(id: TId, flag: TFlag) {
assertFlag(flag)
return registry.get(flag)?.has(id) ?? false
return flaggedIdSetsByFlag[flag].value.has(id)
}
function setFlaggedIds(flag: TFlag, ids: TId[]) {
const flaggedIds = flaggedIdsByFlag[flag]
if (ids.length === flaggedIds.value.length && ids.every((id, index) => id === flaggedIds.value[index])) {
return
}
flaggedIds.value = ids
}
function toggleFlag(id: TId, flag: TFlag, shouldBeFlagged = !isFlagged(id, flag)) {
toggleFlags([id], flag, shouldBeFlagged)
}
function toggleFlags(ids: TId[], flag: TFlag, shouldBeFlagged: boolean) {
assertFlag(flag)
if (!registry.has(flag)) {
registry.set(flag, new Set())
}
const flagSet = registry.get(flag)!
if (shouldBeFlagged === flagSet.has(id)) {
if (ids.length === 0) {
return
}
const flaggedIds = flaggedIdsByFlag[flag].value
if (!shouldBeFlagged) {
flagSet.delete(id)
const idSet = new Set(ids)
setFlaggedIds(
flag,
flaggedIds.filter(id => !idSet.has(id))
)
return
}
if (!isMultipleAllowed(flag) && flagSet.size > 0) {
clearFlag(flag)
if (!isMultipleAllowed(flag)) {
setFlaggedIds(flag, ids.slice(-1))
return
}
flagSet.add(id)
const flaggedIdSet = flaggedIdSetsByFlag[flag].value
setFlaggedIds(flag, [...flaggedIds, ...ids.filter(id => !flaggedIdSet.has(id))])
}
function clearFlag(flag: TFlag) {
assertFlag(flag)
if (!registry.has(flag) || registry.get(flag)!.size === 0) {
return
}
registry.get(flag)!.clear()
setFlaggedIds(flag, [])
}
function isMultipleAllowed(flag: TFlag) {
@@ -81,6 +106,7 @@ export function useFlagRegistry<TFlag extends string, TId extends CollectionItem
isFlagged,
isFlagDefined,
toggleFlag,
toggleFlags,
clearFlag,
isMultipleAllowed,
assertFlag,

View File

@@ -0,0 +1,306 @@
import { nextTick, ref, type Ref, toValue, watch } from 'vue'
import { useFlagRegistry } from './use-flag-registry.ts'
function spyOnWrites(ids: Ref<string[]>) {
const onWrite = vi.fn()
watch(ids, onWrite, { flush: 'sync' })
return onWrite
}
describe('isFlagDefined', () => {
it('is true for a flag of the config', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(registry.isFlagDefined('selected')).toBe(true)
})
it('is false for any other flag', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(registry.isFlagDefined('active')).toBe(false)
})
})
describe('assertFlag', () => {
it('accepts a flag of the config', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(() => registry.assertFlag('selected')).not.toThrow()
})
it('throws for any other flag', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(() => registry.assertFlag('active')).toThrow('Flag "active" is not defined.')
})
})
describe('isFlagged', () => {
it('is false for an id that was never flagged', () => {
const registry = useFlagRegistry({ selected: true })
expect(registry.isFlagged('vm-1', 'selected')).toBe(false)
})
it('throws for a flag that is not in the config', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(() => registry.isFlagged('vm-1', 'active')).toThrow('Flag "active" is not defined.')
})
})
describe('toggleFlag', () => {
it('flags an unflagged id', () => {
const registry = useFlagRegistry({ selected: true })
registry.toggleFlag('vm-1', 'selected')
expect(registry.isFlagged('vm-1', 'selected')).toBe(true)
})
it('unflags a flagged id', () => {
const registry = useFlagRegistry({ selected: true })
registry.toggleFlag('vm-1', 'selected')
registry.toggleFlag('vm-1', 'selected')
expect(registry.isFlagged('vm-1', 'selected')).toBe(false)
})
it('keeps an id flagged when asked to flag it again', () => {
const registry = useFlagRegistry({ selected: true })
registry.toggleFlag('vm-1', 'selected', true)
registry.toggleFlag('vm-1', 'selected', true)
expect(registry.isFlagged('vm-1', 'selected')).toBe(true)
})
it('keeps an id unflagged when asked to unflag it', () => {
const registry = useFlagRegistry({ selected: true })
registry.toggleFlag('vm-1', 'selected', false)
expect(registry.isFlagged('vm-1', 'selected')).toBe(false)
})
it('keeps the other ids flagged', () => {
const registry = useFlagRegistry({ selected: true })
registry.toggleFlag('vm-1', 'selected')
registry.toggleFlag('vm-2', 'selected')
expect(registry.isFlagged('vm-1', 'selected')).toBe(true)
expect(registry.isFlagged('vm-2', 'selected')).toBe(true)
})
it('leaves the other flags of the id untouched', () => {
const registry = useFlagRegistry({ selected: true, active: true })
registry.toggleFlag('vm-1', 'selected')
expect(registry.isFlagged('vm-1', 'active')).toBe(false)
})
it('replaces the flagged id when `multiple` is false', () => {
const registry = useFlagRegistry({ active: { multiple: false } })
registry.toggleFlag('vm-1', 'active')
registry.toggleFlag('vm-2', 'active')
expect(registry.isFlagged('vm-1', 'active')).toBe(false)
expect(registry.isFlagged('vm-2', 'active')).toBe(true)
})
it('throws for a flag that is not in the config', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(() => registry.toggleFlag('vm-1', 'active')).toThrow('Flag "active" is not defined.')
})
})
describe('toggleFlags', () => {
it('flags every given id', () => {
const registry = useFlagRegistry({ selected: true })
registry.toggleFlags(['vm-1', 'vm-2'], 'selected', true)
expect(registry.isFlagged('vm-1', 'selected')).toBe(true)
expect(registry.isFlagged('vm-2', 'selected')).toBe(true)
})
it('unflags the given ids only', () => {
const registry = useFlagRegistry({ selected: true })
registry.toggleFlags(['vm-1', 'vm-2', 'vm-3'], 'selected', true)
registry.toggleFlags(['vm-1', 'vm-2'], 'selected', false)
expect(registry.isFlagged('vm-1', 'selected')).toBe(false)
expect(registry.isFlagged('vm-2', 'selected')).toBe(false)
expect(registry.isFlagged('vm-3', 'selected')).toBe(true)
})
it('keeps the last given id only when `multiple` is false', () => {
const registry = useFlagRegistry({ active: { multiple: false } })
registry.toggleFlag('vm-1', 'active')
registry.toggleFlags(['vm-2', 'vm-3'], 'active', true)
expect(registry.isFlagged('vm-1', 'active')).toBe(false)
expect(registry.isFlagged('vm-2', 'active')).toBe(false)
expect(registry.isFlagged('vm-3', 'active')).toBe(true)
})
it('throws for a flag that is not in the config', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(() => registry.toggleFlags(['vm-1'], 'active', true)).toThrow('Flag "active" is not defined.')
})
})
describe('clearFlag', () => {
it('unflags every id', () => {
const registry = useFlagRegistry({ selected: true })
registry.toggleFlags(['vm-1', 'vm-2'], 'selected', true)
registry.clearFlag('selected')
expect(registry.isFlagged('vm-1', 'selected')).toBe(false)
expect(registry.isFlagged('vm-2', 'selected')).toBe(false)
})
it('leaves the other flags untouched', () => {
const registry = useFlagRegistry({ selected: true, active: true })
registry.toggleFlag('vm-1', 'active')
registry.clearFlag('selected')
expect(registry.isFlagged('vm-1', 'active')).toBe(true)
})
it('throws for a flag that is not in the config', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(() => registry.clearFlag('active')).toThrow('Flag "active" is not defined.')
})
})
describe('isMultipleAllowed', () => {
it('is true by default', () => {
const registry = useFlagRegistry({ selected: true, active: {} })
expect(registry.isMultipleAllowed('selected')).toBe(true)
expect(registry.isMultipleAllowed('active')).toBe(true)
})
it('is false when `multiple` is false', () => {
const registry = useFlagRegistry({ active: { multiple: false } })
expect(registry.isMultipleAllowed('active')).toBe(false)
})
it('follows a `multiple` ref', () => {
const multiple = ref(true)
const registry = useFlagRegistry({ selected: { multiple } })
multiple.value = false
expect(registry.isMultipleAllowed('selected')).toBe(false)
})
it('throws for a flag that is not in the config', () => {
const registry = useFlagRegistry<string, string>({ selected: true })
expect(() => registry.isMultipleAllowed('active')).toThrow('Flag "active" is not defined.')
})
})
describe('`multiple` option', () => {
it('clears the flag when the ref changes', async () => {
const multiple = ref(true)
const registry = useFlagRegistry({ selected: { multiple } })
registry.toggleFlags(['vm-1', 'vm-2'], 'selected', true)
multiple.value = false
await nextTick()
expect(registry.isFlagged('vm-1', 'selected')).toBe(false)
expect(registry.isFlagged('vm-2', 'selected')).toBe(false)
})
})
describe('`ids` option', () => {
it('flags the ids the ref holds when the registry is created', () => {
const ids = ref(['vm-1'])
const registry = useFlagRegistry({ selected: { ids } })
expect(registry.isFlagged('vm-1', 'selected')).toBe(true)
expect(registry.isFlagged('vm-2', 'selected')).toBe(false)
})
it('follows the ids set on the ref from outside', () => {
const ids = ref(['vm-1'])
const registry = useFlagRegistry({ selected: { ids } })
ids.value = ['vm-2']
expect(registry.isFlagged('vm-1', 'selected')).toBe(false)
expect(registry.isFlagged('vm-2', 'selected')).toBe(true)
})
it('holds the flagged ids, in the order they were flagged', () => {
const ids = ref<string[]>([])
const registry = useFlagRegistry({ selected: { ids } })
registry.toggleFlag('vm-2', 'selected')
registry.toggleFlags(['vm-1', 'vm-2', 'vm-3'], 'selected', true)
registry.toggleFlag('vm-1', 'selected')
expect(toValue(ids)).toEqual(['vm-2', 'vm-3'])
})
it('is emptied by `clearFlag`', () => {
const ids = ref(['vm-1', 'vm-2'])
const registry = useFlagRegistry({ selected: { ids } })
registry.clearFlag('selected')
expect(toValue(ids)).toEqual([])
})
it('receives a new array instead of a mutation of the previous one', () => {
const initialIds = ['vm-1']
const ids = ref(initialIds)
const registry = useFlagRegistry({ selected: { ids } })
registry.toggleFlag('vm-2', 'selected')
expect(initialIds).toEqual(['vm-1'])
expect(toValue(ids)).toEqual(['vm-1', 'vm-2'])
})
it('is written once when several ids are toggled together', () => {
const ids = ref<string[]>([])
const registry = useFlagRegistry({ selected: { ids } })
const onWrite = spyOnWrites(ids)
registry.toggleFlags(['vm-1', 'vm-2', 'vm-3'], 'selected', true)
expect(onWrite).toHaveBeenCalledTimes(1)
})
it('is not written when an operation changes nothing', () => {
const ids = ref(['vm-1'])
const registry = useFlagRegistry({ selected: { ids }, active: { ids: ref<string[]>([]) } })
const onWrite = spyOnWrites(ids)
registry.toggleFlag('vm-1', 'selected', true)
registry.toggleFlag('vm-2', 'selected', false)
registry.toggleFlags([], 'selected', false)
registry.clearFlag('active')
expect(onWrite).not.toHaveBeenCalled()
})
})

View File

@@ -243,6 +243,20 @@ Like `useOverlayTrigger()`, it works from any component rendered inside an overl
An Escape whose default has been prevented is ignored: a nested component that handles Escape itself calls `event.preventDefault()` to keep the overlay open.
## Focus
`useOverlayFocus(target)` moves the focus to `target` (typically the `role="dialog"` element, with `tabindex="-1"`) when the overlay is mounted, unless a nested component already focused one of its own elements. When the overlay is unmounted, the focus goes back to the element that had it when `open()` was called, if it is still in the page:
```ts
useOverlayFocus(useTemplateRef('dialog'))
```
Like `useOverlayEscape()`, it does nothing when the component is not rendered in an overlay.
The promise returned by `open()` resolves once the overlay is unmounted, so the focus is already back when the caller resumes (e.g. a menu item that closes its menu after its action).
Keeping the keyboard focus inside the current overlay is up to the rendering: `VtsOverlayList` makes everything outside of it `inert` (the rest of the page, including teleported elements such as an open menu, and the overlays below the current one).
## Composition: building your own composable
`useOverlay` is designed to be wrapped in small, domain-specific composables:

View File

@@ -62,6 +62,7 @@ export interface Overlay {
props: Record<string, unknown>
status: OverlayStatus
lastTrigger: symbol | undefined
returnFocusTarget: Element | null
abort: () => void
}

View File

@@ -0,0 +1,32 @@
import { IK_OVERLAY_KEY } from '@core/packages/overlay/injection-keys.ts'
import { useOverlayStore } from '@core/packages/overlay/use-overlay-store.ts'
import { inject, onMounted, onUnmounted, toValue, type MaybeRefOrGetter } from 'vue'
/**
* Moves the focus to the target once the calling component is mounted, unless
* a nested component already took it, then gives it back to the element that
* had it when the overlay was opened once the component is unmounted.
*/
export function useOverlayFocus(target: MaybeRefOrGetter<HTMLElement | null | undefined>) {
const overlayKey = inject(IK_OVERLAY_KEY, undefined)
if (overlayKey === undefined) {
return
}
const returnFocusTarget = useOverlayStore().get(overlayKey.value)?.returnFocusTarget
onMounted(() => {
const element = toValue(target)
if (element && !element.contains(document.activeElement)) {
element.focus()
}
})
onUnmounted(() => {
if (returnFocusTarget instanceof HTMLElement && returnFocusTarget.isConnected) {
returnFocusTarget.focus()
}
})
}

View File

@@ -0,0 +1,112 @@
import VtsOverlayList from '@core/components/overlay/VtsOverlayList.vue'
import { useOverlayFocus } from '@core/packages/overlay/use-overlay-focus.ts'
import { useOverlay } from '@core/packages/overlay/use-overlay.ts'
import { createGlobalTestConfig } from '@core-test/create-global-test-config.ts'
import { flushPromises, mount } from '@vue/test-utils'
import { defineComponent, h, onMounted, ref, type VNodeChild } from 'vue'
const AutofocusInput = defineComponent({
setup() {
const input = ref<HTMLInputElement>()
onMounted(() => input.value?.focus())
return () => h('input', { ref: input, class: 'autofocus-input' })
},
})
function createTestModal(content: () => VNodeChild = () => null) {
return defineComponent({
emits: ['confirm'],
setup(props, { emit }) {
const dialog = ref<HTMLElement>()
useOverlayFocus(dialog)
return () =>
h('div', { ref: dialog, class: 'dialog', tabindex: -1 }, [
content(),
h('button', { class: 'confirm', onClick: () => emit('confirm') }, 'Confirm'),
])
},
})
}
function mountOverlayHost(modal = createTestModal()) {
const wrapper = mount(
defineComponent({
setup() {
return useOverlay({ component: () => Promise.resolve(modal), events: { onConfirm: true } })
},
render: () => [h('button', { class: 'opener' }, 'Open'), h(VtsOverlayList)],
}),
{ global: createGlobalTestConfig(), attachTo: document.body }
)
return { open: wrapper.vm.open, opener: getElement('.opener') }
}
function getElement(selector: string) {
const element = document.querySelector<HTMLElement>(selector)
if (element === null) {
throw new Error(`No element matches "${selector}"`)
}
return element
}
describe('useOverlayFocus', () => {
it('moves the focus into the overlay once it is open', async () => {
const { open, opener } = mountOverlayHost()
opener.focus()
open()
await flushPromises()
expect(document.activeElement).toBe(getElement('.dialog'))
})
it('keeps the focus on an element that the overlay content focused itself', async () => {
const { open, opener } = mountOverlayHost(createTestModal(() => h(AutofocusInput)))
opener.focus()
open()
await flushPromises()
expect(document.activeElement).toBe(getElement('.autofocus-input'))
})
it('gives the focus back to the opener before open() resolves', async () => {
const { open, opener } = mountOverlayHost()
opener.focus()
const response = open()
await flushPromises()
getElement('.confirm').click()
await response
expect(document.activeElement).toBe(opener)
})
it('does not give the focus back to an opener that left the page', async () => {
const { open, opener } = mountOverlayHost()
opener.focus()
const response = open()
await flushPromises()
opener.remove()
getElement('.confirm').click()
await response
expect(document.activeElement).not.toBe(opener)
})
it('does not move the focus outside of an overlay', () => {
mount(createTestModal(), { global: createGlobalTestConfig(), attachTo: document.body })
expect(document.activeElement).not.toBe(getElement('.dialog'))
})
})

View File

@@ -61,6 +61,7 @@ export function useOverlay<TComponent extends Component, const TEvents extends O
props: {},
status: 'idle',
lastTrigger: undefined,
returnFocusTarget: document.activeElement,
abort: () => settle({ event: OVERLAY_ABORT_EVENT, payload: undefined }),
})
@@ -77,13 +78,15 @@ export function useOverlay<TComponent extends Component, const TEvents extends O
// so paint a non-busy frame before removing the overlay
await nextTick()
resolve(response)
overlayStore.unregister(overlay)
if (currentOverlay === overlay) {
currentOverlay = undefined
}
await nextTick()
resolve(response)
}
const handleEvent = createEventHandler({

View File

@@ -0,0 +1,12 @@
import VtsButtonIconListCell, { type ButtonIconItem } from '@core/components/table/cells/VtsButtonIconListCell.vue'
import { defineColumn } from '@core/packages/table/define-column.ts'
import { renderHeadCell } from '@core/tables/helpers/render-head-cell.ts'
import type { HeaderConfig } from '@core/tables/types.ts'
import { h } from 'vue'
export type { ButtonIconItem }
export const useButtonIconListColumn = defineColumn((config?: HeaderConfig) => ({
renderHead: () => renderHeadCell(config?.headerLabel),
renderBody: (buttons: ButtonIconItem[]) => h(VtsButtonIconListCell, { buttons }),
}))

View File

@@ -0,0 +1,10 @@
import VtsRankCell from '@core/components/table/cells/VtsRankCell.vue'
import { defineColumn } from '@core/packages/table/define-column.ts'
import { renderHeadCell } from '@core/tables/helpers/render-head-cell.ts'
import type { HeaderConfig } from '@core/tables/types.ts'
import { h } from 'vue'
export const useRankColumn = defineColumn((config?: HeaderConfig) => ({
renderHead: () => renderHeadCell(config?.headerLabel),
renderBody: (rank: number, shift?: number) => h(VtsRankCell, { rank, shift }),
}))

View File

@@ -0,0 +1,23 @@
import { defineColumns } from '@core/packages/table/define-columns.ts'
import { useButtonIconListColumn } from '@core/tables/column-definitions/button-icon-list-column.ts'
import { useDoubleLinkColumn } from '@core/tables/column-definitions/double-link-column.ts'
import { useRankColumn } from '@core/tables/column-definitions/rank-column.ts'
import { useTagColumn } from '@core/tables/column-definitions/tag-column.ts'
import { useTextColumn } from '@core/tables/column-definitions/text-column.ts'
import { useTruncatedTextColumn } from '@core/tables/column-definitions/truncated-text-column.ts'
import { useI18n } from 'vue-i18n'
export const useTrafficRulesOrderColumns = defineColumns(() => {
const { t } = useI18n()
return {
rank: useRankColumn({ headerLabel: () => t('priority') }),
policy: useTagColumn({ headerLabel: () => t('policy') }),
protocol: useTextColumn({ headerLabel: () => t('protocol:port') }),
directionA: useTextColumn({ headerLabel: () => t('direction') }),
target: useTruncatedTextColumn({ headerLabel: () => t('target') }),
directionB: useTextColumn({ headerLabel: () => t('direction') }),
object: useDoubleLinkColumn({ headerLabel: () => t('object') }),
moveButtons: useButtonIconListColumn(),
}
})

View File

@@ -4,6 +4,7 @@ import type { PanelActionsGroup } from '@core/components/panel/PanelActions.vue'
import type { InfoSize } from '@core/components/ui/info/UiInfo.vue'
import type { ModalAccent } from '@core/components/ui/modal/UiModal.vue'
import type { TreeItemLabelSize } from '@core/components/ui/tree-item-label/UiTreeItemLabel.vue'
import type { MenuLevel } from '@core/composables/menu-level.composable.ts'
import type { ValueFormatter } from '@core/types/chart.ts'
import type { ComputedRef, InjectionKey, Ref } from 'vue'
@@ -21,7 +22,9 @@ export const IK_TREE_ITEM_LABEL_SIZE = Symbol('IK_TREE_ITEM_LABEL_SIZE') as Inje
export const IK_MENU_HORIZONTAL = Symbol('IK_MENU_HORIZONTAL') as InjectionKey<ComputedRef<boolean>>
export const IK_CLOSE_MENU = Symbol('IK_CLOSE_MENU') as InjectionKey<() => void>
export const IK_CLOSE_MENU = Symbol('IK_CLOSE_MENU') as InjectionKey<(restoreFocus?: boolean) => void>
export const IK_MENU_LEVEL = Symbol('IK_MENU_LEVEL') as InjectionKey<MenuLevel>
export const IK_IN_MENU = Symbol('IK_IN_MENU') as InjectionKey<boolean>

View File

@@ -0,0 +1,19 @@
import i18n from '@core/i18n.ts'
import { createPinia } from 'pinia'
import { createMemoryHistory, createRouter } from 'vue-router'
/**
* Shared `global` mounting options for component tests: the real `vue-i18n` instance, plus a Pinia and a router,
* both created per call to keep tests isolated.
*
* The router is there for `useUiStore`, which calls `useRouter()`/`useRoute()` in its setup: every component reaching
* that store (`VtsStateHero`, `VtsSuccessStateHero`…) needs one.
*/
export function createGlobalTestConfig() {
const router = createRouter({
history: createMemoryHistory(),
routes: [{ path: '/', component: { render: () => null } }],
})
return { plugins: [i18n, createPinia(), router] }
}

View File

@@ -0,0 +1,3 @@
import i18n from '@core/i18n.ts'
export const { t } = i18n.global

View File

@@ -0,0 +1,15 @@
import { createGlobalTestConfig } from '@core-test/create-global-test-config.ts'
import { mount, type VueWrapper } from '@vue/test-utils'
import { defineComponent, type ShallowUnwrapRef } from 'vue'
export function mountComposable<TResult extends Record<string, unknown>>(composable: () => TResult) {
const wrapper = mount(
defineComponent({
setup: () => composable(),
render: () => null,
}),
{ global: createGlobalTestConfig() }
) as unknown as VueWrapper<ShallowUnwrapRef<TResult>>
return { wrapper }
}

View File

@@ -3,6 +3,10 @@
"include": ["env.d.ts", "./lib/**/*", "./lib/**/*.vue", "./test/**/*"],
"exclude": [],
"compilerOptions": {
"types": ["vitest/globals"]
"types": ["vitest/globals"],
"paths": {
"@core/*": ["./lib/*"],
"@core-test/*": ["./test/*"]
}
}
}

View File

@@ -13,6 +13,7 @@ export default defineConfig({
resolve: {
alias: {
'@core': fileURLToPath(new URL('./lib', import.meta.url)),
'@core-test': fileURLToPath(new URL('./test', import.meta.url)),
},
},
test: {

View File

@@ -1,8 +1,9 @@
<template>
<VtsResponsiveMenu :title="t('account')" :section-title="t('menu')" :disabled placement="bottom-end">
<template #trigger="{ isOpen, open }">
<template #trigger="{ isOpen, open, bindings }">
<UiAccountMenuButton
v-tooltip="isOpen ? false : { content: t('account-organization-more'), placement: 'bottom-end' }"
v-bind="bindings"
:selected="isOpen"
size="medium"
@click="open($event)"

View File

@@ -1,8 +1,9 @@
<template>
<VtsMobileMenu :title="t('more-actions')">
<template #trigger="{ open }">
<template #trigger="{ open, bindings }">
<UiButtonIcon
v-tooltip="{ content: t('more-actions'), placement: 'bottom-end' }"
v-bind="bindings"
accent="brand"
icon="action:more-actions"
size="medium"

View File

@@ -0,0 +1,7 @@
import type { FrontXoNetwork } from '@/modules/network/remote-resources/use-xo-network-collection.ts'
import { defineJobArg } from '@core/packages/job'
export const xoNetworkArg = defineJobArg({
identify: (network: FrontXoNetwork | undefined) => network?.id,
toArray: false,
})

View File

@@ -1,25 +1,31 @@
<template>
<span class="json-schema-text">
<template v-for="(segment, index) of segments" :key="index">
<code v-if="segment.isCode" class="code">{{ segment.text }}</code>
<code v-if="segment.kind === 'code'" class="code">{{ segment.text }}</code>
<UiLink v-else-if="segment.kind === 'link'" :href="segment.href" size="medium" display-inline>
{{ segment.text }}
</UiLink>
<template v-else>{{ segment.text }}</template>
</template>
</span>
</template>
<script lang="ts" setup>
import { splitCodeSpans } from '@/modules/plugin/utils/json-schema-description.util.ts'
import { splitTextSegments } from '@/modules/plugin/utils/json-schema-description.util.ts'
import UiLink from '@core/components/ui/link/UiLink.vue'
import { computed } from 'vue'
const { text } = defineProps<{
text: string
}>()
const segments = computed(() => splitCodeSpans(text))
const segments = computed(() => splitTextSegments(text))
</script>
<style lang="postcss" scoped>
.json-schema-text {
white-space: pre-line;
.code {
color: var(--color-brand-txt-base);
background-color: var(--color-neutral-background-secondary);

View File

@@ -8,18 +8,36 @@ export type JsonSchemaDescription = {
exampleGroups: JsonSchemaExampleGroup[]
}
export type JsonSchemaTextSegment = {
text: string
isCode: boolean
}
export type JsonSchemaTextSegment =
| { kind: 'text' | 'code'; text: string }
| { kind: 'link'; text: string; href: string }
const CODE_SPAN_RE = /`([^`]+)`/
export function splitCodeSpans(text: string): JsonSchemaTextSegment[] {
return text
.split(new RegExp(CODE_SPAN_RE, 'g'))
.map((segment, index) => ({ text: segment, isCode: index % 2 === 1 }))
.filter(segment => segment.text !== '')
const LINE_BREAK_RE = /<br\s*\/?>/gi
const SEGMENT_RE = /`([^`]+)`|<a\s[^>]*?href=(["'])(https?:\/\/[^"']*)\2[^>]*>(.*?)<\/a>/gis
export function splitTextSegments(text: string): JsonSchemaTextSegment[] {
const segments: JsonSchemaTextSegment[] = []
let index = 0
for (const match of text.matchAll(SEGMENT_RE)) {
const [whole, code, , href, label] = match
if (match.index > index) {
segments.push({ kind: 'text', text: text.slice(index, match.index) })
}
segments.push(code !== undefined ? { kind: 'code', text: code } : { kind: 'link', text: label, href })
index = match.index + whole.length
}
if (index < text.length) {
segments.push({ kind: 'text', text: text.slice(index) })
}
return segments
}
function isList(lines: string[]): boolean {
@@ -31,7 +49,12 @@ export function parseSchemaDescription(description: string | undefined): JsonSch
const paragraphs: string[] = []
const exampleGroups: JsonSchemaExampleGroup[] = []
for (const block of (description ?? '').trim().split(/\n\s*\n/)) {
const blocks = (description ?? '')
.replace(LINE_BREAK_RE, '\n\n')
.trim()
.split(/\n\s*\n/)
for (const block of blocks) {
const lines = block
.split('\n')
.map(line => line.trim())
@@ -58,7 +81,7 @@ export function parseSchemaDescription(description: string | undefined): JsonSch
}
return {
text: paragraphs.length > 0 ? paragraphs.join(' ') : undefined,
text: paragraphs.length > 0 ? paragraphs.join('\n') : undefined,
exampleGroups,
}
}

View File

@@ -1,13 +1,24 @@
import { parseSchemaDescription, splitCodeSpans } from '@/modules/plugin/utils/json-schema-description.util.ts'
import { parseSchemaDescription, splitTextSegments } from '@/modules/plugin/utils/json-schema-description.util.ts'
describe('parseSchemaDescription', () => {
it.each([undefined, '', ' \n\n '])('returns no text for the description %j', description => {
expect(parseSchemaDescription(description)).toEqual({ text: undefined, exampleGroups: [] })
})
it('joins the paragraphs and keeps the code spans', () => {
it('puts each paragraph on its own line and keeps the code spans', () => {
expect(parseSchemaDescription('Paths to CA.\n\nFor AD, it can also be `<user>@<domain>`.')).toEqual({
text: 'Paths to CA. For AD, it can also be `<user>@<domain>`.',
text: 'Paths to CA.\nFor AD, it can also be `<user>@<domain>`.',
exampleGroups: [],
})
})
it.each(['<br>', '<br/>', '<br />', '<BR>'])('puts the text after a %s on its own line', lineBreak => {
expect(
parseSchemaDescription(
`Specify that the IdP should always sign the assertions${lineBreak}Note: either one must be signed.`
)
).toEqual({
text: 'Specify that the IdP should always sign the assertions\nNote: either one must be signed.',
exampleGroups: [],
})
})
@@ -52,23 +63,42 @@ For Microsoft Active Directory:
})
it('keeps a list without code spans as text', () => {
expect(parseSchemaDescription('Options:\n\n- first\n- second').text).toBe('Options: - first - second')
expect(parseSchemaDescription('Options:\n\n- first\n- second').text).toBe('Options:\n- first - second')
})
})
describe('splitCodeSpans', () => {
describe('splitTextSegments', () => {
it('splits the text around the code spans', () => {
expect(splitCodeSpans('Must be unique. e.g.: `dn` or `uid`')).toEqual([
{ text: 'Must be unique. e.g.: ', isCode: false },
{ text: 'dn', isCode: true },
{ text: ' or ', isCode: false },
{ text: 'uid', isCode: true },
expect(splitTextSegments('Must be unique. e.g.: `dn` or `uid`')).toEqual([
{ kind: 'text', text: 'Must be unique. e.g.: ' },
{ kind: 'code', text: 'dn' },
{ kind: 'text', text: ' or ' },
{ kind: 'code', text: 'uid' },
])
})
it('returns the whole text without code span', () => {
expect(splitCodeSpans('Where to look for the groups.')).toEqual([
{ text: 'Where to look for the groups.', isCode: false },
expect(splitTextSegments('Where to look for the groups.')).toEqual([
{ kind: 'text', text: 'Where to look for the groups.' },
])
})
it('turns the HTML links into links', () => {
expect(
splitTextSegments(
'See the <a href="https://docs.xen-orchestra.com/backups#backups-execution" rel="noopener noreferrer" target="_blank">job\'s runId</a> or `runId`'
)
).toEqual([
{ kind: 'text', text: 'See the ' },
{ kind: 'link', text: "job's runId", href: 'https://docs.xen-orchestra.com/backups#backups-execution' },
{ kind: 'text', text: ' or ' },
{ kind: 'code', text: 'runId' },
])
})
it('keeps the HTML links which do not point to a web page as text', () => {
expect(splitTextSegments('<a href="javascript:alert(1)">click</a>')).toEqual([
{ kind: 'text', text: '<a href="javascript:alert(1)">click</a>' },
])
})
})

View File

@@ -145,6 +145,7 @@ async function onSubmit() {
display: flex;
width: 100%;
justify-content: center;
align-items: center;
gap: 2.4rem;
}

View File

@@ -1,7 +1,9 @@
<template>
<MenuList placement="bottom-end">
<template #trigger="{ open }">
<UiDropdownButton size="small" variant="primary" @click="open($event)">{{ t('third-parties') }}</UiDropdownButton>
<template #trigger="{ open, bindings }">
<UiDropdownButton v-bind="bindings" size="small" variant="primary" @click="open($event)">
{{ t('third-parties') }}
</UiDropdownButton>
</template>
<ThirdPartiesMenuItems />
</MenuList>

View File

@@ -46,10 +46,10 @@
import { useXoNetworkCollection } from '@/modules/network/remote-resources/use-xo-network-collection.ts'
import { getPoolNetworkRoute } from '@/modules/network/utils/xo-network.util.ts'
import type { FrontXoPool } from '@/modules/pool/remote-resources/use-xo-pool-collection.ts'
import TrafficRuleTableActions from '@/modules/traffic-rules/components/actions/TrafficRuleTableActions.vue'
import { useDirectionLabels } from '@/modules/traffic-rules/composables/direction-labels.composable.ts'
import { useTrafficRulePolicy } from '@/modules/traffic-rules/composables/traffic-rule-policy.composable.ts'
import { useTrafficRuleTarget } from '@/modules/traffic-rules/composables/traffic-rule-target.composable.ts'
import { useTrafficRuleDelete } from '@/modules/traffic-rules/composables/use-traffic-rule-delete.composable.ts'
import { useTrafficRuleEdit } from '@/modules/traffic-rules/composables/use-traffic-rule-edit.composable.ts'
import type { EnrichedTrafficRule, RankedTrafficRule } from '@/modules/traffic-rules/types.ts'
import { getNetworkRules, getTrafficRuleProtocolLabel } from '@/modules/traffic-rules/utils/xo-traffic-rule.util.ts'
import { XO_LINKS } from '@/shared/constants.ts'
@@ -101,6 +101,8 @@ const getTarget = useTrafficRuleTarget()
const getDirectionLabels = useDirectionLabels()
const getPolicy = useTrafficRulePolicy()
const { getNetworkById, useGetNetworkById } = useXoNetworkCollection()
const showRulesFormatWarning = computed(() => {
@@ -166,11 +168,6 @@ const { HeadCells, BodyCells } = useTrafficRulesColumns({
network.value ? getPoolNetworkRoute(network.value.$pool, network.value.id) : undefined
)
const { deleteTrafficRules, canDeleteTrafficRules, isDeletingTrafficRules, deleteTrafficRulesErrorMessage } =
useTrafficRuleDelete(() => [rule])
const { editTrafficRule, canEditTrafficRule, isEditingTrafficRule } = useTrafficRuleEdit(() => rule)
return {
network: r =>
r({
@@ -179,7 +176,11 @@ const { HeadCells, BodyCells } = useTrafficRulesColumns({
to: networkTo.value,
}),
priority: r => r(`${rule.rank}/${rule.networkRuleCount}`),
policy: r => r(t(rule.allow ? 'allow' : 'drop'), rule.allow ? 'success' : 'danger'),
policy: r => {
const policy = getPolicy(rule)
return r(policy.label, policy.accent)
},
protocol: r => r(getTrafficRuleProtocolLabel(rule)),
directionA: r => r(rule.directionA),
target: r => r(rule.ipRange),
@@ -188,24 +189,8 @@ const { HeadCells, BodyCells } = useTrafficRulesColumns({
actions: r =>
r({
onClick: () => (selectedRuleId.value = rule.id),
actions: [
{
label: t('action:edit'),
icon: 'action:edit',
onClick: () => editTrafficRule(),
busy: isEditingTrafficRule.value,
disabled: !canEditTrafficRule.value,
},
{
label: t('action:delete'),
icon: 'action:delete',
onClick: () => deleteTrafficRules(),
disabled: !canDeleteTrafficRules.value,
busy: isDeletingTrafficRules.value,
hint: deleteTrafficRulesErrorMessage.value,
accent: 'danger',
},
],
component: TrafficRuleTableActions,
props: { rule, rules: rawRules, showEditOrder: showPriority },
}),
}
},

View File

@@ -0,0 +1,16 @@
<template>
<TrafficRuleEditButton :rule />
<TrafficRuleEditOrderButton v-if="showEditOrder" :rule :rules />
</template>
<script lang="ts" setup>
import TrafficRuleEditButton from '@/modules/traffic-rules/components/actions/edit/TrafficRuleEditButton.vue'
import TrafficRuleEditOrderButton from '@/modules/traffic-rules/components/actions/edit-order/TrafficRuleEditOrderButton.vue'
import type { RankedTrafficRule } from '@/modules/traffic-rules/types.ts'
defineProps<{
rule: RankedTrafficRule
rules: RankedTrafficRule[]
showEditOrder?: boolean
}>()
</script>

View File

@@ -0,0 +1,16 @@
<template>
<TrafficRuleMoreActions :rule :rules :show-edit-order />
<TrafficRuleDeleteButton :rule />
</template>
<script lang="ts" setup>
import TrafficRuleDeleteButton from '@/modules/traffic-rules/components/actions/delete/TrafficRuleDeleteButton.vue'
import TrafficRuleMoreActions from '@/modules/traffic-rules/components/actions/TrafficRuleMoreActions.vue'
import type { RankedTrafficRule } from '@/modules/traffic-rules/types.ts'
defineProps<{
rule: RankedTrafficRule
rules: RankedTrafficRule[]
showEditOrder?: boolean
}>()
</script>

View File

@@ -0,0 +1,21 @@
<template>
<VtsDeleteButton
:hint="deleteTrafficRulesErrorMessage"
:disabled="!canDeleteTrafficRules"
:busy="isDeletingTrafficRules"
@click="deleteTrafficRules()"
/>
</template>
<script lang="ts" setup>
import { useTrafficRuleDelete } from '@/modules/traffic-rules/composables/use-traffic-rule-delete.composable.ts'
import VtsDeleteButton from '@core/components/delete-button/VtsDeleteButton.vue'
import type { TrafficRule } from '@vates/types'
const { rule } = defineProps<{
rule: TrafficRule
}>()
const { deleteTrafficRules, canDeleteTrafficRules, isDeletingTrafficRules, deleteTrafficRulesErrorMessage } =
useTrafficRuleDelete(() => [rule])
</script>

View File

@@ -0,0 +1,48 @@
<template>
<MenuItem
:busy="isEditingTrafficRulesOrder"
:disabled="!canEditTrafficRulesOrder"
accent="neutral"
icon="action:edit"
@click="editTrafficRulesOrder()"
>
{{ t('action:edit-rules-order') }}
<i v-if="isXapiPluginRequired" class="em-dash-prefix">
<I18nT keypath="traffic-rules:xapi-plugin-required-with-link" scope="global">
<template #xapi-plugin>
<UiLink :href="XO_LINKS.DOC_SDN_CONTROLLER_XAPI_PLUGIN" size="small">
{{ t('xapi-plugin') }}
</UiLink>
</template>
</I18nT>
</i>
<i v-else-if="editTrafficRulesOrderErrorMessage" class="em-dash-prefix">{{ editTrafficRulesOrderErrorMessage }}</i>
</MenuItem>
</template>
<script lang="ts" setup>
import { useTrafficRuleEditOrder } from '@/modules/traffic-rules/composables/use-traffic-rule-edit-order.composable.ts'
import type { RankedTrafficRule } from '@/modules/traffic-rules/types.ts'
import { XO_LINKS } from '@/shared/constants.ts'
import MenuItem from '@core/components/menu/MenuItem.vue'
import UiLink from '@core/components/ui/link/UiLink.vue'
import { I18nT, useI18n } from 'vue-i18n'
const { rule, rules } = defineProps<{
rule: RankedTrafficRule
rules: RankedTrafficRule[]
}>()
const { t } = useI18n()
const {
editTrafficRulesOrder,
canEditTrafficRulesOrder,
isEditingTrafficRulesOrder,
editTrafficRulesOrderErrorMessage,
isXapiPluginRequired,
} = useTrafficRuleEditOrder(
() => rule.networkId,
() => rules
)
</script>

View File

@@ -1,5 +1,6 @@
<template>
<VtsActionButton
:hint="editTrafficRuleErrorMessage"
variant="tertiary"
accent="brand"
icon="action:edit"
@@ -9,14 +10,11 @@
>
{{ t('action:edit') }}
</VtsActionButton>
<VtsDeleteButton :disabled="!canDeleteTrafficRules" :busy="isDeletingTrafficRules" @click="deleteTrafficRules()" />
</template>
<script lang="ts" setup>
import { useTrafficRuleDelete } from '@/modules/traffic-rules/composables/use-traffic-rule-delete.composable.ts'
import { useTrafficRuleEdit } from '@/modules/traffic-rules/composables/use-traffic-rule-edit.composable.ts'
import VtsActionButton from '@core/components/action-button/VtsActionButton.vue'
import VtsDeleteButton from '@core/components/delete-button/VtsDeleteButton.vue'
import type { TrafficRule } from '@vates/types'
import { useI18n } from 'vue-i18n'
@@ -26,7 +24,7 @@ const { rule } = defineProps<{
const { t } = useI18n()
const { deleteTrafficRules, canDeleteTrafficRules, isDeletingTrafficRules } = useTrafficRuleDelete(() => [rule])
const { editTrafficRule, canEditTrafficRule, isEditingTrafficRule } = useTrafficRuleEdit(() => rule)
const { editTrafficRule, canEditTrafficRule, isEditingTrafficRule, editTrafficRuleErrorMessage } = useTrafficRuleEdit(
() => rule
)
</script>

Some files were not shown because too many files have changed in this diff Show More