Compare commits

..

2 Commits

Author SHA1 Message Date
Simon Pacotte
f2e5384667 update changelog 2026-11-18 17:18:10 +01:00
Simon Pacotte
7a9eb86b87 fix(xo-server): keep server statuses in sync with the live connections 2026-11-18 16:59:14 +01:00
140 changed files with 672 additions and 7359 deletions

View File

@@ -78,7 +78,6 @@ module.exports = {
typescript: true,
'eslint-import-resolver-custom-alias': {
alias: {
'@core-test': '../web-core/test',
'@core': '../web-core/lib',
'@': './src',
},
@@ -103,7 +102,6 @@ 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' },
],
},
@@ -125,10 +123,6 @@ module.exports = {
pattern: '@core/**',
group: 'internal',
},
{
pattern: '@core-test/**',
group: 'internal',
},
],
},
],

View File

@@ -190,7 +190,7 @@ export interface Xapi {
deleteNetwork(id: XoNetwork['id']): Promise<void>
deleteVif(vifId: XoVif['id']): Promise<void>
disconnectVif(vifId: XoVif['id']): Promise<void>
exportVmOva(vmRef: XenApiVm['$ref'], opts?: { signal?: AbortSignal }): Promise<PassThrough>
exportVmOva(vmRef: XenApiVm['$ref']): 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?: { signal?: AbortSignal; compress?: boolean | 'zstd' | 'gzip'; useSnapshot?: boolean }
opts?: { cancelToken?: unknown; 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; signal?: AbortSignal; format: SUPPORTED_VDI_FORMAT }
opts: { baseRef?: string; cancelToken?: unknown; format: SUPPORTED_VDI_FORMAT }
): Promise<Readable & { length?: number }>
VDI_importContent(
vdiRef: XenApiVdi['$ref'],
stream: Readable | Buffer,
opts: { signal?: AbortSignal; format: SUPPORTED_VDI_FORMAT }
opts: { cancelToken?: unknown; format: SUPPORTED_VDI_FORMAT }
): Promise<void>
VIF_create(
options: {

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -14,14 +14,8 @@
<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, bindings }">
<UiTabItem
v-bind="bindings"
:active="isOpen"
:disabled="presets === undefined"
class="preset-tab"
@click="open"
>
<template #trigger="{ open, isOpen }">
<UiTabItem :active="isOpen" :disabled="presets === undefined" class="preset-tab" @click="open">
<VtsIcon name="fa:sliders" size="medium" />
Presets
</UiTabItem>

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -7,16 +7,13 @@
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')
.prop('bindings', 'MenuTriggerBindings'),
slot('trigger').prop('open', '(event: MouseEvent) => void').prop('isOpen', 'boolean'),
slot().help('Menu items'),
]"
>
<VtsResponsiveMenu v-bind="properties">
<template #trigger="{ open, isOpen, bindings }">
<UiDropdownButton v-bind="bindings" variant="primary" size="medium" :selected="isOpen" @click="open($event)">
<template #trigger="{ open, isOpen }">
<UiDropdownButton variant="primary" size="medium" :selected="isOpen" @click="open($event)">
New
</UiDropdownButton>
</template>

View File

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

View File

@@ -1,9 +1,8 @@
import { createLogger } from '@xen-orchestra/log'
import { EventEmitter } from 'node:events'
import { makeOnProgress } from '@vates/task/combineEvents'
import { forbiddenOperation, noSuchObject } from 'xo-common/api-errors.js'
import { 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'
@@ -11,30 +10,7 @@ export { Task }
const { warn } = createLogger('xo:mixins:Tasks')
// 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 noop = Function.prototype
const DEFAULT_BACKUP_LOG_KEEP_DURATION = 31 * 24 * 60 * 60 * 1000
@@ -62,73 +38,33 @@ 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
try {
do {
for (const [id, taskLog] of buf) {
buf.delete(id)
// 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 })
}
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)
// 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)
try {
await store.put(id, taskLog)
} catch (error) {
warn('failure on saving task log in store', { error, taskLog })
}
}
} 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
}
}
} while (buf.size !== 0) // new events may have been added during iteration
this.#handleOnProgressScheduled = false
}
#bufferTaskUpdate = taskLog => {
@@ -149,8 +85,16 @@ export default class Tasks extends EventEmitter {
}
const { $root } = taskLog
const { id } = $root
this.#liveLogs.set(id, $root)
const { status, id } = $root
if (status !== 'pending') {
if (this.#logsToClearOnSuccess.has(id)) {
this.#logsToClearOnSuccess.delete(id)
if (status === 'success') {
return buf.set(id, null)
}
}
}
$root.updatedAt = Date.now()
buf.set(id, $root)
@@ -184,13 +128,10 @@ export default class Tasks extends EventEmitter {
.on('start', async () => {
this.#store = await app.getStore('tasks')
// 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)
}
for await (const taskLog of this.list({ filter: _ => _.status === 'pending' })) {
taskLog.status = 'interrupted'
taskLog.updatedAt = Date.now()
await this.#store.put(taskLog.id, taskLog)
}
return () => this.#store.close()
@@ -217,18 +158,7 @@ export default class Tasks extends EventEmitter {
const deleteEntry = data => {
++count
// 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()
})
this.deleteLog(data.key, cb)
}
const stream = db.createReadStream({
@@ -263,156 +193,26 @@ 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.
*
* 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.
* Abort support for external tasks is not implemented — the external process
* controls its own lifecycle.
*/
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)
},
createExternalProgressHandler({ onRootTaskEnd, onRootTaskStart, onTaskUpdate } = {}) {
return makeOnProgress({
onRootTaskEnd,
onRootTaskStart,
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) {
return task.abort(reason)
if (task === undefined) {
throw noSuchObject(id, 'task')
}
// 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')
return task.abort(reason)
}
async clearLogs() {
@@ -445,64 +245,16 @@ 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 storedLog = await this.#deleteStored(id, cb)
const log = await this.get(id).catch(noop)
const liveLog = this.#liveLogs.get(id)
this.#liveLogs.delete(id)
const log = liveLog ?? storedLog
if (log !== undefined) {
this.#emitSafely('remove', log)
await this.#store.del(id, cb)
this.emit('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) {
@@ -513,107 +265,37 @@ 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
// 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
}
}
for await (const [, taskLog] of this.#store.iterator()) {
if (predicate(taskLog)) {
yield taskLog
if (--limit < 1) {
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
}
break
}
}
}
}
async watch(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 })
}
})
// live task
if (this.#tasks.has(id)) {
this.on(id, cb)
// 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
let stopWatch = () => {
this.off(id, cb)
stopWatch = noop
}
// 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
return () => stopWatch()
}
// unknown task will throw noSuchObject
const taskLog = await this.get(id)
// the first event of the task may have arrived while the store was read: watch it until it ends
return watchLive() ?? (callLater(taskLog), stop)
// finished task
setImmediate(cb, taskLog)
return noop
}
}

File diff suppressed because it is too large Load Diff

View File

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

View File

@@ -2,15 +2,12 @@
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` / `@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 |
| 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 |
Test files sit next to the code they test, as `lib/**/*.unit.test.ts`. Shared test infrastructure lives in `test/`, outside `lib/`. The shared `scripts/npmignore` keeps all of it out of the published package.

View File

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

View File

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

View File

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

View File

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

View File

@@ -1,17 +1,13 @@
<!-- v1.0 -->
<template>
<slot :bindings="triggerBindings" :is-open="isOpen" :open="open" name="trigger" />
<slot :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>
@@ -20,68 +16,45 @@
<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, shallowRef, useId, useTemplateRef, watch } from 'vue'
export type MenuTriggerBindings = {
'aria-haspopup': 'menu' | 'dialog'
'aria-expanded': boolean
'aria-controls'?: string
}
import { computed, inject, nextTick, provide, ref, useSlots } from 'vue'
defineOptions({
inheritAttrs: false,
})
const { horizontal, noBorder, disabled, placement, anchor } = defineProps<{
const props = defineProps<{
horizontal?: boolean
noBorder?: boolean
disabled?: boolean
placement?: Options['placement']
anchor?: HTMLElement
}>()
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 slots = useSlots()
const isOpen = ref(false)
const menu = ref()
const isParentHorizontal = inject(
IK_MENU_HORIZONTAL,
computed(() => false)
)
provide(
IK_MENU_HORIZONTAL,
computed(() => horizontal)
computed(() => props.horizontal ?? false)
)
useDisabled(() => disabled)
useDisabled(() => props.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) {
@@ -91,58 +64,44 @@ const defaultPlacement = computed<Options['placement']>(() => {
return parentPlacementSide?.value === 'left' ? 'left-start' : 'right-start'
})
const parentLevel = inject(IK_MENU_LEVEL, undefined)
const isSubmenu = hasTrigger && parentLevel !== undefined
const level = useMenuLevel({ isPopup: hasTrigger, horizontal: () => horizontal })
provide(IK_MENU_LEVEL, level)
let clearClickOutsideEvent: (() => void) | undefined
const hasTrigger = useSlots().trigger !== undefined
provide(IK_IN_MENU, true)
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)
whenever(
() => !isOpen.value,
() => clearClickOutsideEvent?.()
)
if (slots.trigger && inject(IK_CLOSE_MENU, undefined) === undefined) {
provide(IK_CLOSE_MENU, () => (isOpen.value = false))
}
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) {
const open = (event: MouseEvent) => {
if (isOpen.value) {
isOpen.value = false
return
return (isOpen.value = false)
}
triggerElement.value = event.currentTarget as HTMLElement
isOpen.value = true
await nextTick()
focusFirstItem()
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]
})
}
watch(menu, (menuElement, _, onCleanup) => {
if (menuElement !== null && isSubmenu) {
onCleanup(parentLevel.registerSubmenu(menuElement))
}
})
defineExpose({ focusFirstItem })
</script>
<style lang="postcss" scoped>

View File

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

View File

@@ -1,12 +1,6 @@
<!-- v1.0 -->
<template>
<div
:aria-disabled="disabled || undefined"
:class="[{ active, selected, disabled }, className]"
class="menu-trigger"
role="menuitem"
tabindex="-1"
>
<div :class="[{ active, disabled }, className]" class="menu-trigger">
<VtsIcon :name="icon" size="medium" :busy />
<slot />
</div>
@@ -22,7 +16,6 @@ import { computed } from 'vue'
const { accent } = defineProps<{
accent: MenuItemAccent
active?: boolean
selected?: boolean
busy?: boolean
disabled?: boolean
icon?: IconName
@@ -33,25 +26,12 @@ 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);
@@ -60,10 +40,6 @@ 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);
}
@@ -93,10 +69,6 @@ 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);
@@ -112,10 +84,6 @@ const className = computed(() => toVariants({ accent }))
&.accent--warning {
color: var(--color-warning-txt-base);
&.selected {
background-color: var(--color-warning-background-selected);
}
&:hover {
color: var(--color-warning-txt-hover);
background-color: var(--color-warning-background-hover);

View File

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

View File

@@ -1,26 +1,17 @@
<template>
<MenuList :placement>
<template #trigger="{ open, bindings }">
<template #trigger="{ open }">
<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
v-bind="bindings"
variant="secondary"
size="medium"
icon="action:change-state"
@click="open($event)"
>
<UiDropdownButton v-else variant="secondary" size="medium" icon="action:change-state" @click="open($event)">
{{ t('action:change-state') }}
</UiDropdownButton>
</template>

View File

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

View File

@@ -1,10 +1,9 @@
<template>
<slot :bindings="triggerBindings" :is-open :open name="trigger" />
<slot :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"
@@ -37,7 +36,7 @@
<script lang="ts" setup>
import VtsDropdownTitle from '@core/components/dropdown/VtsDropdownTitle.vue'
import MenuList, { type MenuTriggerBindings } from '@core/components/menu/MenuList.vue'
import MenuList 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'
@@ -67,7 +66,7 @@ const emit = defineEmits<{
defineSlots<{
default(): any
trigger(props: { open: () => void; isOpen: boolean; bindings: MenuTriggerBindings }): any
trigger(props: { open: () => void; isOpen: boolean }): any
}>()
const { t } = useI18n()
@@ -76,17 +75,9 @@ const overlayStore = useOverlayStore()
const titleId = useId()
const dialogId = useId()
const isOpen = ref(false)
const submenus = shallowRef<MobileSubmenu[]>([])
const triggerBindings = computed<MenuTriggerBindings>(() => ({
'aria-haspopup': 'dialog',
'aria-expanded': isOpen.value,
'aria-controls': isOpen.value ? dialogId : undefined,
}))
const currentSubmenu = computed(() => submenus.value.at(-1))
const backLabel = computed(() => (currentSubmenu.value ? t('action:go-back') : t('action:close')))

View File

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

View File

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

View File

@@ -1,17 +1,21 @@
<template>
<UiModal :accent :icon @confirm="handleConfirm()" @dismiss="emit('cancel')">
<UiModal :accent :icon @confirm="isConfirmed && emit('confirm')" @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" ref="typeToConfirmInput" :confirmation-text />
<VtsTypeToConfirmInput
v-if="confirmationText !== undefined"
v-model="isTypedTextConfirmed"
:confirmation-text
/>
</div>
</template>
<template #buttons>
<VtsOverlayCancelButton @click="emit('cancel')">{{ t('action:go-back') }}</VtsOverlayCancelButton>
<VtsOverlayConfirmButton>
<VtsOverlayConfirmButton :disabled="!isConfirmed">
{{ modalTexts.action }}
</VtsOverlayConfirmButton>
</template>
@@ -27,7 +31,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 { useTemplateRef } from 'vue'
import { computed, ref } from 'vue'
import { useI18n } from 'vue-i18n'
type ActionTexts = {
@@ -172,15 +176,9 @@ const modalTexts = useMapper(
() => defaultActionByObject[object]
)
const typeToConfirmInput = useTemplateRef('typeToConfirmInput')
const isTypedTextConfirmed = ref(false)
function handleConfirm() {
if (confirmationText !== undefined && !typeToConfirmInput.value?.validate()) {
return
}
emit('confirm')
}
const isConfirmed = computed(() => confirmationText === undefined || isTypedTextConfirmed.value)
</script>
<style lang="postcss" scoped>

View File

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

View File

@@ -1,5 +1,5 @@
<template>
<UiModal :accent :icon @confirm="handleConfirm()" @dismiss="emit('cancel')">
<UiModal :accent :icon @confirm="isConfirmed && emit('confirm')" @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 ref="typeToConfirmInput" :confirmation-text />
<VtsTypeToConfirmInput v-model="isConfirmed" :confirmation-text />
</div>
</template>
<template #buttons>
<VtsOverlayCancelButton @click="emit('cancel')">{{ t('action:go-back') }}</VtsOverlayCancelButton>
<VtsOverlayConfirmButton>
<VtsOverlayConfirmButton :disabled="!isConfirmed">
{{ 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 { useTemplateRef } from 'vue'
import { ref } from 'vue'
import { useI18n } from 'vue-i18n'
defineProps<{
@@ -46,15 +46,7 @@ const emit = defineEmits<{
const { t } = useI18n()
const typeToConfirmInput = useTemplateRef('typeToConfirmInput')
function handleConfirm() {
if (!typeToConfirmInput.value?.validate()) {
return
}
emit('confirm')
}
const isConfirmed = ref(false)
</script>
<style lang="postcss" scoped>

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -2,15 +2,13 @@
<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, bindings }">
<template #trigger="{ open }">
<UiButton
v-tooltip="action.hint"
v-bind="bindings"
variant="tertiary"
:accent="action.buttonAccent"
size="medium"
:left-icon="action.icon"
right-icon="fa:angle-down"
:disabled="action.disabled"
:busy="action.busy"
@click="open($event)"

View File

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

View File

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

View File

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

View File

@@ -1,54 +1,35 @@
<template>
<div class="vts-type-to-confirm-input">
<VtsRequiredHint />
<VtsInputWrapper :label="t('type-x-to-confirm', { text: confirmationText })" :message="errorMessage">
<UiInput ref="input" v-model="typedText" accent="brand" required />
<VtsInputWrapper :label="t('type-x-to-confirm', { text: confirmationText })">
<UiInput v-model="typedText" accent="brand" required />
</VtsInputWrapper>
</div>
</template>
<script lang="ts" setup>
import VtsInputWrapper, { type InputWrapperMessage } from '@core/components/input-wrapper/VtsInputWrapper.vue'
import VtsInputWrapper 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 { computed, ref, useTemplateRef, watch } from 'vue'
import { ref, watch } from 'vue'
import { useI18n } from 'vue-i18n'
const { confirmationText } = defineProps<{
confirmationText: string
}>()
const { t } = useI18n()
const isConfirmed = defineModel<boolean>({ required: true })
const input = useTemplateRef('input')
const { t } = useI18n()
const typedText = ref('')
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()
watch(
() => typedText.value === confirmationText,
isMatching => {
isConfirmed.value = isMatching
}
return isMatching
}
defineExpose({ validate })
)
</script>
<style lang="postcss" scoped>

View File

@@ -3,7 +3,6 @@
<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>
@@ -29,7 +28,6 @@ export type ButtonProps = {
disabled?: boolean
lockIcon?: boolean
leftIcon?: IconName
rightIcon?: IconName
}
const { accent, variant, size, disabled, busy, lockIcon } = defineProps<ButtonProps>()

View File

@@ -1,12 +1,10 @@
<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">
@@ -37,8 +35,7 @@
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 { useOverlayFocus } from '@core/packages/overlay/use-overlay-focus.ts'
import { useId, useTemplateRef } from 'vue'
import { useId } from 'vue'
defineProps<{
title?: string
@@ -58,8 +55,6 @@ const slots = defineSlots<{
useOverlayEscape(() => emit('dismiss'))
useOverlayFocus(useTemplateRef('dialog'))
const titleId = useId()
</script>
@@ -78,7 +73,6 @@ const titleId = useId()
max-width: 100%;
min-height: 100dvh;
background-color: var(--color-neutral-background-secondary);
outline: none;
.header {
display: flex;

View File

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

View File

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

View File

@@ -1,14 +1,7 @@
<!-- v4 -->
<template>
<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"
>
<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">
<UiButtonIcon
v-if="onDismiss"
:accent
@@ -40,10 +33,9 @@ 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, useTemplateRef } from 'vue'
import { computed, provide, useId } from 'vue'
export type ModalAccent = 'info' | 'warning' | 'danger'
@@ -66,8 +58,6 @@ const slots = defineSlots<{
useOverlayEscape(() => emit('dismiss'))
useOverlayFocus(useTemplateRef('dialog'))
const titleId = useId()
const className = computed(() => toVariants({ accent }))
@@ -98,7 +88,6 @@ provide(
border-radius: 1rem;
border-width: 0.1rem;
border-style: solid;
outline: none;
&:not(:has(.buttons)) {
padding-bottom: 3.2rem;
@@ -131,7 +120,6 @@ provide(
.content {
width: 100%;
text-align: start;
}
}
}

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -1,6 +1,6 @@
import { type CollectionItemId, useCollection } from '@core/packages/collection'
import { useArrayMap } from '@vueuse/core'
import { computed, type MaybeRefOrGetter, type Ref, toValue } from 'vue'
import { computed, type MaybeRefOrGetter, toValue } from 'vue'
export type SelectionBindings = {
selectedCount: number
@@ -18,7 +18,6 @@ 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)))
@@ -30,7 +29,7 @@ export function useTableSelection<TItem, TId extends CollectionItemId>(config: {
const { useFlag, useSubset, clearFlag } = useCollection(config.items, {
itemId: config.getItemId,
flags: { selected: { ids: config.selectedIds } },
flags: { selected: true },
})
const selectionFlag = useFlag('selected')

View File

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

View File

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

View File

@@ -91,7 +91,6 @@
"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",
@@ -138,9 +137,7 @@
"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",
@@ -527,7 +524,6 @@
"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}",
@@ -635,7 +631,6 @@
"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",
@@ -766,8 +761,6 @@
"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",
@@ -1539,8 +1532,6 @@
"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.",
@@ -1550,8 +1541,7 @@
"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-with-link": "Requires {xapi-plugin} mode",
"traffic-rules:xapi-plugin-required": "Requires XAPI plugin mode",
"transfer": "Transfer",
"transfer-size": "@:transfer @.lower:size",
"translation-tool": "Translation tool",
@@ -1777,7 +1767,6 @@
"with-memory": "With memory",
"write": "Write",
"writing-speed": "Writing speed",
"xapi-plugin": "XAPI plugin",
"xcp-ng": "XCP-ng",
"xen-orchestra": "Xen Orchestra",
"xo": "XO",

View File

@@ -91,7 +91,6 @@
"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}",
@@ -138,9 +137,7 @@
"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",
@@ -527,7 +524,6 @@
"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}",
@@ -635,7 +631,6 @@
"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",
@@ -766,8 +761,6 @@
"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",
@@ -1539,8 +1532,6 @@
"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.",
@@ -1550,8 +1541,7 @@
"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 @:xapi-plugin",
"traffic-rules:xapi-plugin-required-with-link": "Nécessite le mode {xapi-plugin}",
"traffic-rules:xapi-plugin-required": "Nécessite le mode plugin XAPI",
"transfer": "Transfert",
"transfer-size": "@:size du @.lower:transfer",
"translation-tool": "Outil de traduction",
@@ -1777,7 +1767,6 @@
"with-memory": "Avec mémoire",
"write": "Écriture",
"writing-speed": "Vitesse d'écriture",
"xapi-plugin": "plugin XAPI",
"xcp-ng": "XCP-ng",
"xen-orchestra": "Xen Orchestra",
"xo": "XO",

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -61,7 +61,6 @@ 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 }),
})
@@ -78,15 +77,13 @@ export function useOverlay<TComponent extends Component, const TEvents extends O
// so paint a non-busy frame before removing the overlay
await nextTick()
resolve(response)
overlayStore.unregister(overlay)
if (currentOverlay === overlay) {
currentOverlay = undefined
}
await nextTick()
resolve(response)
}
const handleEvent = createEventHandler({

View File

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

View File

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

View File

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

View File

@@ -4,7 +4,6 @@ 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'
@@ -22,9 +21,7 @@ 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<(restoreFocus?: boolean) => void>
export const IK_MENU_LEVEL = Symbol('IK_MENU_LEVEL') as InjectionKey<MenuLevel>
export const IK_CLOSE_MENU = Symbol('IK_CLOSE_MENU') as InjectionKey<() => void>
export const IK_IN_MENU = Symbol('IK_IN_MENU') as InjectionKey<boolean>

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@@ -8,36 +8,18 @@ export type JsonSchemaDescription = {
exampleGroups: JsonSchemaExampleGroup[]
}
export type JsonSchemaTextSegment =
| { kind: 'text' | 'code'; text: string }
| { kind: 'link'; text: string; href: string }
export type JsonSchemaTextSegment = {
text: string
isCode: boolean
}
const CODE_SPAN_RE = /`([^`]+)`/
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
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 !== '')
}
function isList(lines: string[]): boolean {
@@ -49,12 +31,7 @@ export function parseSchemaDescription(description: string | undefined): JsonSch
const paragraphs: string[] = []
const exampleGroups: JsonSchemaExampleGroup[] = []
const blocks = (description ?? '')
.replace(LINE_BREAK_RE, '\n\n')
.trim()
.split(/\n\s*\n/)
for (const block of blocks) {
for (const block of (description ?? '').trim().split(/\n\s*\n/)) {
const lines = block
.split('\n')
.map(line => line.trim())
@@ -81,7 +58,7 @@ export function parseSchemaDescription(description: string | undefined): JsonSch
}
return {
text: paragraphs.length > 0 ? paragraphs.join('\n') : undefined,
text: paragraphs.length > 0 ? paragraphs.join(' ') : undefined,
exampleGroups,
}
}

View File

@@ -1,24 +1,13 @@
import { parseSchemaDescription, splitTextSegments } from '@/modules/plugin/utils/json-schema-description.util.ts'
import { parseSchemaDescription, splitCodeSpans } 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('puts each paragraph on its own line and keeps the code spans', () => {
it('joins the paragraphs and keeps the code spans', () => {
expect(parseSchemaDescription('Paths to CA.\n\nFor AD, it can also be `<user>@<domain>`.')).toEqual({
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.',
text: 'Paths to CA. For AD, it can also be `<user>@<domain>`.',
exampleGroups: [],
})
})
@@ -63,42 +52,23 @@ For Microsoft Active Directory:
})
it('keeps a list without code spans as text', () => {
expect(parseSchemaDescription('Options:\n\n- first\n- second').text).toBe('Options:\n- first - second')
expect(parseSchemaDescription('Options:\n\n- first\n- second').text).toBe('Options: - first - second')
})
})
describe('splitTextSegments', () => {
describe('splitCodeSpans', () => {
it('splits the text around the code spans', () => {
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' },
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 },
])
})
it('returns the whole text without code span', () => {
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>' },
expect(splitCodeSpans('Where to look for the groups.')).toEqual([
{ text: 'Where to look for the groups.', isCode: false },
])
})
})

View File

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

View File

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

View File

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

View File

@@ -1,6 +1,5 @@
<template>
<VtsActionButton
:hint="editTrafficRuleErrorMessage"
variant="tertiary"
accent="brand"
icon="action:edit"
@@ -10,11 +9,14 @@
>
{{ 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'
@@ -24,7 +26,7 @@ const { rule } = defineProps<{
const { t } = useI18n()
const { editTrafficRule, canEditTrafficRule, isEditingTrafficRule, editTrafficRuleErrorMessage } = useTrafficRuleEdit(
() => rule
)
const { deleteTrafficRules, canDeleteTrafficRules, isDeletingTrafficRules } = useTrafficRuleDelete(() => [rule])
const { editTrafficRule, canEditTrafficRule, isEditingTrafficRule } = useTrafficRuleEdit(() => rule)
</script>

View File

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

View File

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

View File

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

View File

@@ -1,48 +0,0 @@
<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>

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