mirror of
https://github.com/vatesfr/xen-orchestra.git
synced 2026-11-18 13:00:52 -06:00
Compare commits
21 Commits
server_sta
...
master
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
f3b14e6431 | ||
|
|
2f2ff49857 | ||
|
|
3b16209f8b | ||
|
|
b3ac4b97d7 | ||
|
|
d30de831c3 | ||
|
|
a5975cfb1e | ||
|
|
6df327e702 | ||
|
|
8075e28118 | ||
|
|
959587f004 | ||
|
|
409005ece0 | ||
|
|
98aaaeba40 | ||
|
|
381dacfa9a | ||
|
|
845e73b610 | ||
|
|
f647fe0fc6 | ||
|
|
3ad84220a3 | ||
|
|
b5ec15c0c3 | ||
|
|
6e5e5e95eb | ||
|
|
92cb48378b | ||
|
|
7d1e113d32 | ||
|
|
d93fa3d4de | ||
|
|
dd2b8f227c |
@@ -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',
|
||||
},
|
||||
],
|
||||
},
|
||||
],
|
||||
|
||||
@@ -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: {
|
||||
|
||||
@@ -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
|
||||
|
||||
21
@xen-orchestra/backups/_abortableMap.mjs
Normal file
21
@xen-orchestra/backups/_abortableMap.mjs
Normal 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
|
||||
}
|
||||
}
|
||||
93
@xen-orchestra/backups/_abortableMap.test.mjs
Normal file
93
@xen-orchestra/backups/_abortableMap.test.mjs
Normal 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)
|
||||
})
|
||||
})
|
||||
@@ -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
|
||||
}
|
||||
})
|
||||
@@ -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)
|
||||
}
|
||||
|
||||
@@ -10,7 +10,7 @@
|
||||
},
|
||||
"version": "0.78.0",
|
||||
"engines": {
|
||||
"node": ">=14.18"
|
||||
"node": ">=22.19"
|
||||
},
|
||||
"scripts": {
|
||||
"postversion": "npm publish --access public",
|
||||
|
||||
@@ -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)"
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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">
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -14,6 +14,7 @@
|
||||
prop('disabled').bool().widget().ctx(),
|
||||
prop('lockIcon').bool().widget(),
|
||||
iconProp('leftIcon'),
|
||||
iconProp('rightIcon'),
|
||||
setting('label').preset('Click me').widget(),
|
||||
]"
|
||||
:presets="{
|
||||
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
|
||||
1538
@xen-orchestra/mixins/Tasks.test.mjs
Normal file
1538
@xen-orchestra/mixins/Tasks.test.mjs
Normal file
File diff suppressed because it is too large
Load Diff
@@ -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"
|
||||
|
||||
@@ -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.
|
||||
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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(' '))
|
||||
})
|
||||
})
|
||||
@@ -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)
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
<template>
|
||||
<li>
|
||||
<li role="none">
|
||||
<VtsDropdownTitle>
|
||||
<slot />
|
||||
</VtsDropdownTitle>
|
||||
|
||||
@@ -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')))
|
||||
|
||||
@@ -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()
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -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>
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -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>
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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')">
|
||||
|
||||
@@ -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)">
|
||||
|
||||
@@ -48,6 +48,12 @@ const uiStore = useUiStore()
|
||||
}
|
||||
}
|
||||
|
||||
@media (--medium-or-large) {
|
||||
&:deep(.modal) {
|
||||
max-width: min(95vw, 120rem);
|
||||
}
|
||||
}
|
||||
|
||||
&:deep(.modal) {
|
||||
padding: 0;
|
||||
gap: 0;
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -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 {
|
||||
|
||||
@@ -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)"
|
||||
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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()
|
||||
})
|
||||
})
|
||||
@@ -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>
|
||||
|
||||
@@ -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>()
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -4,6 +4,7 @@
|
||||
<button
|
||||
:id="wrapperController?.id"
|
||||
ref="dropZoneRef"
|
||||
:aria-describedby="wrapperController?.describedBy"
|
||||
type="button"
|
||||
class="dropzone"
|
||||
:class="{ 'is-over-dropzone': isOverDropZone }"
|
||||
|
||||
@@ -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)"
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
199
@xen-orchestra/web-core/lib/composables/menu-level.composable.ts
Normal file
199
@xen-orchestra/web-core/lib/composables/menu-level.composable.ts
Normal 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,
|
||||
}
|
||||
}
|
||||
@@ -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')
|
||||
})
|
||||
})
|
||||
@@ -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'),
|
||||
}
|
||||
}
|
||||
@@ -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()
|
||||
})
|
||||
})
|
||||
110
@xen-orchestra/web-core/lib/composables/menu-popup.composable.ts
Normal file
110
@xen-orchestra/web-core/lib/composables/menu-popup.composable.ts
Normal 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 }
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
)
|
||||
})
|
||||
@@ -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 |
|
||||
|
||||
@@ -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')
|
||||
|
||||
@@ -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)
|
||||
})
|
||||
})
|
||||
@@ -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,
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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",
|
||||
|
||||
@@ -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 |
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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> {
|
||||
|
||||
@@ -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([])
|
||||
})
|
||||
})
|
||||
@@ -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,
|
||||
|
||||
@@ -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()
|
||||
})
|
||||
})
|
||||
@@ -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:
|
||||
|
||||
@@ -62,6 +62,7 @@ export interface Overlay {
|
||||
props: Record<string, unknown>
|
||||
status: OverlayStatus
|
||||
lastTrigger: symbol | undefined
|
||||
returnFocusTarget: Element | null
|
||||
abort: () => void
|
||||
}
|
||||
|
||||
|
||||
@@ -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()
|
||||
}
|
||||
})
|
||||
}
|
||||
@@ -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'))
|
||||
})
|
||||
})
|
||||
@@ -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({
|
||||
|
||||
@@ -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 }),
|
||||
}))
|
||||
@@ -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 }),
|
||||
}))
|
||||
@@ -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(),
|
||||
}
|
||||
})
|
||||
@@ -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>
|
||||
|
||||
|
||||
19
@xen-orchestra/web-core/test/create-global-test-config.ts
Normal file
19
@xen-orchestra/web-core/test/create-global-test-config.ts
Normal 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] }
|
||||
}
|
||||
3
@xen-orchestra/web-core/test/i18n.ts
Normal file
3
@xen-orchestra/web-core/test/i18n.ts
Normal file
@@ -0,0 +1,3 @@
|
||||
import i18n from '@core/i18n.ts'
|
||||
|
||||
export const { t } = i18n.global
|
||||
15
@xen-orchestra/web-core/test/mount-composable.ts
Normal file
15
@xen-orchestra/web-core/test/mount-composable.ts
Normal 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 }
|
||||
}
|
||||
@@ -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/*"]
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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: {
|
||||
|
||||
@@ -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)"
|
||||
|
||||
@@ -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"
|
||||
|
||||
@@ -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,
|
||||
})
|
||||
@@ -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);
|
||||
|
||||
@@ -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,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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>' },
|
||||
])
|
||||
})
|
||||
})
|
||||
|
||||
@@ -145,6 +145,7 @@ async function onSubmit() {
|
||||
display: flex;
|
||||
width: 100%;
|
||||
justify-content: center;
|
||||
align-items: center;
|
||||
gap: 2.4rem;
|
||||
}
|
||||
|
||||
|
||||
@@ -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>
|
||||
|
||||
@@ -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 },
|
||||
}),
|
||||
}
|
||||
},
|
||||
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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>
|
||||
@@ -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
Reference in New Issue
Block a user