@yassidev/nuxt-directus 0.0.14 → 0.0.16

package/dist/module.d.mts

@@ -559,6 +559,10 @@ interface ModuleOptions {
     };
     types?: false | {
         enabled?: boolean;
+        transform?: Array<{
+            from: string | RegExp;
+            to: string;
+        }>;
     };
     proxy?: false | {
         enabled?: boolean;

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "directus",
   "configKey": "directus",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,16 +1,14 @@
 import { defineNuxtModule, useLogger, updateRuntimeConfig, hasNuxtModule, createResolver, addImportsDir, addImports, addServerImportsDir, addServerImports, addTemplate, addTypeTemplate } from 'nuxt/kit';
 import { generateDirectusTypes } from 'directus-sdk-typegen';
 import { fetchTranslations, syncTranslations } from '../dist/runtime/server.js';
-import { readFileSync, existsSync } from 'node:fs';
+import { unwatchFile, watchFile, watch as watch$1, stat as stat$1, readFileSync, existsSync } from 'node:fs';
 import { NAME } from '../dist/runtime/constants.js';
+import * as sp from 'node:path';
 import { resolve, join, relative, sep } from 'node:path';
-import { unwatchFile, watchFile, watch as watch$1, stat as stat$2 } from 'fs';
-import { realpath as realpath$1, stat as stat$1, lstat as lstat$1, open, readdir as readdir$1 } from 'fs/promises';
-import { EventEmitter } from 'events';
-import * as sysPath from 'path';
-import { lstat, stat, readdir, realpath } from 'node:fs/promises';
+import { EventEmitter } from 'node:events';
+import { lstat, stat, readdir, realpath, open } from 'node:fs/promises';
 import { Readable } from 'node:stream';
-import { type } from 'os';
+import { type } from 'node:os';
 
 const JOIN_LEADING_SLASH_RE = /^\.?\//;
 function hasTrailingSlash(input = "", respectQueryAndFragment) {
@@ -155,6 +153,20 @@ const normalizeFilter = (filter) => {
 };
 /** Readable readdir stream, emitting new files as they're being listed. */
 class ReaddirpStream extends Readable {
+    parents;
+    reading;
+    parent;
+    _stat;
+    _maxDepth;
+    _wantsDir;
+    _wantsFile;
+    _wantsEverything;
+    _root;
+    _isDirent;
+    _statsProp;
+    _rdOptions;
+    _fileFilter;
+    _directoryFilter;
     constructor(options = {}) {
         super({
             objectMode: true,
@@ -173,7 +185,8 @@ class ReaddirpStream extends Readable {
         else {
             this._stat = statMethod;
         }
-        this._maxDepth = opts.depth ?? defaultOptions.depth;
+        this._maxDepth =
+            opts.depth != null && Number.isSafeInteger(opts.depth) ? opts.depth : defaultOptions.depth;
         this._wantsDir = type ? DIR_TYPES.has(type) : false;
         this._wantsFile = type ? FILE_TYPES.has(type) : false;
         this._wantsEverything = type === EntryTypes.EVERYTHING_TYPE;
@@ -363,7 +376,7 @@ const EVENTS = {
 };
 const EV = EVENTS;
 const THROTTLE_MODE_WATCH = 'watch';
-const statMethods = { lstat: lstat$1, stat: stat$1 };
+const statMethods = { lstat, stat };
 const KEY_LISTENERS = 'listeners';
 const KEY_ERR = 'errHandlers';
 const KEY_RAW = 'rawEmitters';
@@ -403,7 +416,7 @@ const binaryExtensions = new Set([
     'xmind', 'xpi', 'xpm', 'xwd', 'xz',
     'z', 'zip', 'zipx',
 ]);
-const isBinaryPath = (filePath) => binaryExtensions.has(sysPath.extname(filePath).slice(1).toLowerCase());
+const isBinaryPath = (filePath) => binaryExtensions.has(sp.extname(filePath).slice(1).toLowerCase());
 // TODO: emit errors properly. Example: EMFILE on Macos.
 const foreach = (val, fn) => {
     if (val instanceof Set) {
@@ -456,7 +469,7 @@ function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
         // emit based on events occurring for files from a directory's watcher in
         // case the file's watcher misses it (and rely on throttling to de-dupe)
         if (evPath && path !== evPath) {
-            fsWatchBroadcast(sysPath.resolve(path, evPath), KEY_LISTENERS, sysPath.join(path, evPath));
+            fsWatchBroadcast(sp.resolve(path, evPath), KEY_LISTENERS, sp.join(path, evPath));
         }
     };
     try {
@@ -627,6 +640,8 @@ const setFsWatchFileListener = (path, fullPath, options, handlers) => {
  * @mixin
  */
 class NodeFsHandler {
+    fsw;
+    _boundHandleError;
     constructor(fsW) {
         this.fsw = fsW;
         this._boundHandleError = (error) => fsW._handleError(error);
@@ -639,11 +654,11 @@ class NodeFsHandler {
      */
     _watchWithNodeFs(path, listener) {
         const opts = this.fsw.options;
-        const directory = sysPath.dirname(path);
-        const basename = sysPath.basename(path);
+        const directory = sp.dirname(path);
+        const basename = sp.basename(path);
         const parent = this.fsw._getWatchedDir(directory);
         parent.add(basename);
-        const absolutePath = sysPath.resolve(path);
+        const absolutePath = sp.resolve(path);
         const options = {
             persistent: opts.persistent,
         };
@@ -675,8 +690,8 @@ class NodeFsHandler {
         if (this.fsw.closed) {
             return;
         }
-        const dirname = sysPath.dirname(file);
-        const basename = sysPath.basename(file);
+        const dirname = sp.dirname(file);
+        const basename = sp.basename(file);
         const parent = this.fsw._getWatchedDir(dirname);
         // stats is always present
         let prevStats = stats;
@@ -688,7 +703,7 @@ class NodeFsHandler {
                 return;
             if (!newStats || newStats.mtimeMs === 0) {
                 try {
-                    const newStats = await stat$1(file);
+                    const newStats = await stat(file);
                     if (this.fsw.closed)
                         return;
                     // Check that change event was not fired because of changed only accessTime.
@@ -753,7 +768,7 @@ class NodeFsHandler {
             this.fsw._incrReadyCount();
             let linkPath;
             try {
-                linkPath = await realpath$1(path);
+                linkPath = await realpath(path);
             }
             catch (e) {
                 this.fsw._emitReady();
@@ -783,8 +798,9 @@ class NodeFsHandler {
     }
     _handleRead(directory, initialAdd, wh, target, dir, depth, throttler) {
         // Normalize the directory name on Windows
-        directory = sysPath.join(directory, '');
-        throttler = this.fsw._throttle('readdir', directory, 1000);
+        directory = sp.join(directory, '');
+        const throttleKey = target ? `${directory}:${target}` : directory;
+        throttler = this.fsw._throttle('readdir', throttleKey, 1000);
         if (!throttler)
             return;
         const previous = this.fsw._getWatchedDir(wh.path);
@@ -802,7 +818,7 @@ class NodeFsHandler {
                 return;
             }
             const item = entry.path;
-            let path = sysPath.join(directory, item);
+            let path = sp.join(directory, item);
             current.add(item);
             if (entry.stats.isSymbolicLink() &&
                 (await this._handleSymlink(entry, directory, path, item))) {
@@ -818,7 +834,7 @@ class NodeFsHandler {
             if (item === target || (!target && !previous.has(item))) {
                 this.fsw._incrReadyCount();
                 // ensure relativeness of path is preserved in case of watcher reuse
-                path = sysPath.join(dir, sysPath.relative(dir, path));
+                path = sp.join(dir, sp.relative(dir, path));
                 this._addToNodeFs(path, initialAdd, wh, depth + 1);
             }
         })
@@ -863,13 +879,13 @@ class NodeFsHandler {
      * @returns closer for the watcher instance.
      */
     async _handleDir(dir, stats, initialAdd, depth, target, wh, realpath) {
-        const parentDir = this.fsw._getWatchedDir(sysPath.dirname(dir));
-        const tracked = parentDir.has(sysPath.basename(dir));
+        const parentDir = this.fsw._getWatchedDir(sp.dirname(dir));
+        const tracked = parentDir.has(sp.basename(dir));
         if (!(initialAdd && this.fsw.options.ignoreInitial) && !target && !tracked) {
             this.fsw._emit(EV.ADD_DIR, dir, stats);
         }
         // ensure dir is tracked (harmless if redundant)
-        parentDir.add(sysPath.basename(dir));
+        parentDir.add(sp.basename(dir));
         this.fsw._getWatchedDir(dir);
         let throttler;
         let closer;
@@ -921,8 +937,8 @@ class NodeFsHandler {
             const follow = this.fsw.options.followSymlinks;
             let closer;
             if (stats.isDirectory()) {
-                const absPath = sysPath.resolve(path);
-                const targetPath = follow ? await realpath$1(path) : path;
+                const absPath = sp.resolve(path);
+                const targetPath = follow ? await realpath(path) : path;
                 if (this.fsw.closed)
                     return;
                 closer = await this._handleDir(wh.watchPath, stats, initialAdd, depth, target, wh, targetPath);
@@ -934,10 +950,10 @@ class NodeFsHandler {
                 }
             }
             else if (stats.isSymbolicLink()) {
-                const targetPath = follow ? await realpath$1(path) : path;
+                const targetPath = follow ? await realpath(path) : path;
                 if (this.fsw.closed)
                     return;
-                const parent = sysPath.dirname(wh.watchPath);
+                const parent = sp.dirname(wh.watchPath);
                 this.fsw._getWatchedDir(parent).add(wh.watchPath);
                 this.fsw._emit(EV.ADD, wh.watchPath, stats);
                 closer = await this._handleDir(parent, stats, initialAdd, depth, path, wh, targetPath);
@@ -945,7 +961,7 @@ class NodeFsHandler {
                     return;
                 // preserve this symlink's target path
                 if (targetPath !== undefined) {
-                    this.fsw._symlinkPaths.set(sysPath.resolve(path), targetPath);
+                    this.fsw._symlinkPaths.set(sp.resolve(path), targetPath);
                 }
             }
             else {
@@ -972,7 +988,7 @@ const ONE_DOT = '.';
 const TWO_DOTS = '..';
 const STRING_TYPE = 'string';
 const BACK_SLASH_RE = /\\/g;
-const DOUBLE_SLASH_RE = /\/\//;
+const DOUBLE_SLASH_RE = /\/\//g;
 const DOT_RE = /\..*\.(sw[px])$|~$|\.subl.*\.tmp/;
 const REPLACER_RE = /^\.[/\\]/;
 function arrify(item) {
@@ -991,11 +1007,11 @@ function createPattern(matcher) {
             if (matcher.path === string)
                 return true;
             if (matcher.recursive) {
-                const relative = sysPath.relative(matcher.path, string);
+                const relative = sp.relative(matcher.path, string);
                 if (!relative) {
                     return false;
                 }
-                return !relative.startsWith('..') && !sysPath.isAbsolute(relative);
+                return !relative.startsWith('..') && !sp.isAbsolute(relative);
             }
             return false;
         };
@@ -1005,14 +1021,12 @@ function createPattern(matcher) {
 function normalizePath(path) {
     if (typeof path !== 'string')
         throw new Error('string expected');
-    path = sysPath.normalize(path);
+    path = sp.normalize(path);
     path = path.replace(/\\/g, '/');
     let prepend = false;
     if (path.startsWith('//'))
         prepend = true;
-    const DOUBLE_SLASH_RE = /\/\//;
-    while (path.match(DOUBLE_SLASH_RE))
-        path = path.replace(DOUBLE_SLASH_RE, '/');
+    path = path.replace(DOUBLE_SLASH_RE, '/');
     if (prepend)
         path = '/' + path;
     return path;
@@ -1055,9 +1069,7 @@ const toUnix = (string) => {
     if (str.startsWith(SLASH_SLASH)) {
         prepend = true;
     }
-    while (str.match(DOUBLE_SLASH_RE)) {
-        str = str.replace(DOUBLE_SLASH_RE, SLASH);
-    }
+    str = str.replace(DOUBLE_SLASH_RE, SLASH);
     if (prepend) {
         str = SLASH + str;
     }
@@ -1065,27 +1077,30 @@ const toUnix = (string) => {
 };
 // Our version of upath.normalize
 // TODO: this is not equal to path-normalize module - investigate why
-const normalizePathToUnix = (path) => toUnix(sysPath.normalize(toUnix(path)));
+const normalizePathToUnix = (path) => toUnix(sp.normalize(toUnix(path)));
 // TODO: refactor
 const normalizeIgnored = (cwd = '') => (path) => {
     if (typeof path === 'string') {
-        return normalizePathToUnix(sysPath.isAbsolute(path) ? path : sysPath.join(cwd, path));
+        return normalizePathToUnix(sp.isAbsolute(path) ? path : sp.join(cwd, path));
     }
     else {
         return path;
     }
 };
 const getAbsolutePath = (path, cwd) => {
-    if (sysPath.isAbsolute(path)) {
+    if (sp.isAbsolute(path)) {
         return path;
     }
-    return sysPath.join(cwd, path);
+    return sp.join(cwd, path);
 };
 const EMPTY_SET = Object.freeze(new Set());
 /**
  * Directory entry.
  */
 class DirEntry {
+    path;
+    _removeWatcher;
+    items;
     constructor(dir, removeWatcher) {
         this.path = dir;
         this._removeWatcher = removeWatcher;
@@ -1107,11 +1122,11 @@ class DirEntry {
             return;
         const dir = this.path;
         try {
-            await readdir$1(dir);
+            await readdir(dir);
         }
         catch (err) {
             if (this._removeWatcher) {
-                this._removeWatcher(sysPath.dirname(dir), sysPath.basename(dir));
+                this._removeWatcher(sp.dirname(dir), sp.basename(dir));
             }
         }
     }
@@ -1138,12 +1153,19 @@ class DirEntry {
 const STAT_METHOD_F = 'stat';
 const STAT_METHOD_L = 'lstat';
 class WatchHelper {
+    fsw;
+    path;
+    watchPath;
+    fullWatchPath;
+    dirParts;
+    followSymlinks;
+    statMethod;
     constructor(path, follow, fsw) {
         this.fsw = fsw;
         const watchPath = path;
         this.path = path = path.replace(REPLACER_RE, '');
         this.watchPath = watchPath;
-        this.fullWatchPath = sysPath.resolve(watchPath);
+        this.fullWatchPath = sp.resolve(watchPath);
         this.dirParts = [];
         this.dirParts.forEach((parts) => {
             if (parts.length > 1)
@@ -1153,7 +1175,7 @@ class WatchHelper {
         this.statMethod = follow ? STAT_METHOD_F : STAT_METHOD_L;
     }
     entryPath(entry) {
-        return sysPath.join(this.watchPath, sysPath.relative(this.watchPath, entry.fullPath));
+        return sp.join(this.watchPath, sp.relative(this.watchPath, entry.fullPath));
     }
     filterPath(entry) {
         const { stats } = entry;
@@ -1176,6 +1198,24 @@ class WatchHelper {
  *       .on('add', path => log('File', path, 'was added'))
  */
 class FSWatcher extends EventEmitter {
+    closed;
+    options;
+    _closers;
+    _ignoredPaths;
+    _throttled;
+    _streams;
+    _symlinkPaths;
+    _watched;
+    _pendingWrites;
+    _pendingUnlinks;
+    _readyCount;
+    _emitReady;
+    _closePromise;
+    _userIgnored;
+    _readyEmitted;
+    _emitRaw;
+    _boundRemove;
+    _nodeFsHandler;
     // Not indenting methods for history sake; for now.
     constructor(_opts = {}) {
         super();
@@ -1309,7 +1349,7 @@ class FSWatcher extends EventEmitter {
                 return;
             results.forEach((item) => {
                 if (item)
-                    this.add(sysPath.dirname(item), sysPath.basename(_origAdd || item));
+                    this.add(sp.dirname(item), sp.basename(_origAdd || item));
             });
         });
         return this;
@@ -1324,10 +1364,10 @@ class FSWatcher extends EventEmitter {
         const { cwd } = this.options;
         paths.forEach((path) => {
             // convert to absolute path unless relative path already matches
-            if (!sysPath.isAbsolute(path) && !this._closers.has(path)) {
+            if (!sp.isAbsolute(path) && !this._closers.has(path)) {
                 if (cwd)
-                    path = sysPath.join(cwd, path);
-                path = sysPath.resolve(path);
+                    path = sp.join(cwd, path);
+                path = sp.resolve(path);
             }
             this._closePath(path);
             this._addIgnoredPath(path);
@@ -1381,7 +1421,7 @@ class FSWatcher extends EventEmitter {
     getWatched() {
         const watchList = {};
         this._watched.forEach((entry, dir) => {
-            const key = this.options.cwd ? sysPath.relative(this.options.cwd, dir) : dir;
+            const key = this.options.cwd ? sp.relative(this.options.cwd, dir) : dir;
             const index = key || ONE_DOT;
             watchList[index] = entry.getChildren().sort();
         });
@@ -1407,9 +1447,9 @@ class FSWatcher extends EventEmitter {
             return;
         const opts = this.options;
         if (isWindows)
-            path = sysPath.normalize(path);
+            path = sp.normalize(path);
         if (opts.cwd)
-            path = sysPath.relative(opts.cwd, path);
+            path = sp.relative(opts.cwd, path);
         const args = [path];
         if (stats != null)
             args.push(stats);
@@ -1465,10 +1505,10 @@ class FSWatcher extends EventEmitter {
         if (opts.alwaysStat &&
             stats === undefined &&
             (event === EVENTS.ADD || event === EVENTS.ADD_DIR || event === EVENTS.CHANGE)) {
-            const fullPath = opts.cwd ? sysPath.join(opts.cwd, path) : path;
+            const fullPath = opts.cwd ? sp.join(opts.cwd, path) : path;
             let stats;
             try {
-                stats = await stat$1(fullPath);
+                stats = await stat(fullPath);
             }
             catch (err) {
                 // do nothing
@@ -1548,13 +1588,13 @@ class FSWatcher extends EventEmitter {
         const pollInterval = awf.pollInterval;
         let timeoutHandler;
         let fullPath = path;
-        if (this.options.cwd && !sysPath.isAbsolute(path)) {
-            fullPath = sysPath.join(this.options.cwd, path);
+        if (this.options.cwd && !sp.isAbsolute(path)) {
+            fullPath = sp.join(this.options.cwd, path);
         }
         const now = new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
-            stat$2(fullPath, (err, curStat) => {
+            stat$1(fullPath, (err, curStat) => {
                 if (err || !writes.has(path)) {
                     if (err && err.code !== 'ENOENT')
                         awfEmit(err);
@@ -1620,7 +1660,7 @@ class FSWatcher extends EventEmitter {
      * @param directory path of the directory
      */
     _getWatchedDir(directory) {
-        const dir = sysPath.resolve(directory);
+        const dir = sp.resolve(directory);
         if (!this._watched.has(dir))
             this._watched.set(dir, new DirEntry(dir, this._boundRemove));
         return this._watched.get(dir);
@@ -1646,8 +1686,8 @@ class FSWatcher extends EventEmitter {
         // if what is being deleted is a directory, get that directory's paths
         // for recursive deleting and cleaning of watched object
         // if it is not a directory, nestedDirectoryChildren will be empty array
-        const path = sysPath.join(directory, item);
-        const fullPath = sysPath.resolve(path);
+        const path = sp.join(directory, item);
+        const fullPath = sp.resolve(path);
         isDirectory =
             isDirectory != null ? isDirectory : this._watched.has(path) || this._watched.has(fullPath);
         // prevent duplicate handling in case of arriving here nearly simultaneously
@@ -1679,7 +1719,7 @@ class FSWatcher extends EventEmitter {
         // If we wait for this file to be fully written, cancel the wait.
         let relPath = path;
         if (this.options.cwd)
-            relPath = sysPath.relative(this.options.cwd, path);
+            relPath = sp.relative(this.options.cwd, path);
         if (this.options.awaitWriteFinish && this._pendingWrites.has(relPath)) {
             const event = this._pendingWrites.get(relPath).cancelWait();
             if (event === EVENTS.ADD)
@@ -1700,8 +1740,8 @@ class FSWatcher extends EventEmitter {
      */
     _closePath(path) {
         this._closeFile(path);
-        const dir = sysPath.dirname(path);
-        this._getWatchedDir(dir).remove(sysPath.basename(path));
+        const dir = sp.dirname(path);
+        this._getWatchedDir(dir).remove(sp.basename(path));
     }
     /**
      * Closes only file-specific watchers
@@ -1755,9 +1795,9 @@ function watch(paths, options = {}) {
     watcher.add(paths);
     return watcher;
 }
-const chokidar = { watch, FSWatcher };
+const chokidar = { watch: watch, FSWatcher: FSWatcher };
 
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule({
   meta: { name: NAME },
   setup(options, nuxt) {
     const logger = useLogger(NAME);
@@ -1812,8 +1852,8 @@ function normalizeConfig(options) {
     url: process.env.DIRECTUS_URL ?? "http://localhost:8055",
     accessToken: process.env.DIRECTUS_ACCESS_TOKEN || process.env.DIRECTUS_ADMIN_TOKEN || "",
     i18n: { enabled: hasNuxtModule("@nuxtjs/i18n"), sync: true, prefix: void 0 },
-    types: { enabled: true },
-    proxy: { enabled: true, path: "/api", options: {} },
+    types: { enabled: true, transform: [] },
+    proxy: { enabled: true, path: "/directus", options: {} },
     image: { enabled: hasNuxtModule("@nuxt/image"), alias: "directus" },
     composables: { enabled: true, mode: "rest", client: true, server: true }
   });
@@ -1883,11 +1923,20 @@ function setupI18n(config, nuxt, logger) {
 async function setupTypes(config, nuxt, logger) {
   addTypeTemplate({
     filename: "directus/types.d.ts",
-    getContents: () => generateDirectusTypes({
-      directusUrl: withoutTrailingSlash(config.url),
-      outputPath: "",
-      directusToken: config.accessToken
-    })
+    getContents: async () => {
+      let types = await generateDirectusTypes({
+        directusUrl: withoutTrailingSlash(config.url),
+        outputPath: "",
+        directusToken: config.accessToken
+      });
+      if (config.types.transform && config.types.transform.length > 0) {
+        for (const { from, to } of config.types.transform) {
+          const regex = typeof from === "string" ? new RegExp(from, "g") : from;
+          types = types.replace(regex, to);
+        }
+      }
+      return types;
+    }
   });
   nuxt.options.alias = defu(nuxt.options.alias, {
     "#directus/types": "./directus/types.d.ts"
@@ -1913,4 +1962,4 @@ function setupImage(config, nuxt, logger) {
   logger.info(`Image alias has been registered: ${config.image.alias} -> ${config.url}`);
 }
 
-export { module as default };
+export { module$1 as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yassidev/nuxt-directus",
-  "version": "0.0.14",
+  "version": "0.0.16",
   "description": "A Nuxt module for better integration with Directus CMS.",
   "repository": "yassilah/nuxt-directus",
   "license": "MIT",
@@ -35,31 +35,31 @@
     "test:types": "vue-tsc --noEmit && cd playground && vue-tsc --noEmit"
   },
   "dependencies": {
-    "@directus/sdk": "^20.1.0",
-    "@nuxt/kit": "^4.1.3",
+    "@directus/sdk": "^21.0.0",
+    "@nuxt/kit": "^4.3.0",
     "directus-sdk-typegen": "^0.2.1"
   },
   "build": {
     "failOnWarn": false
   },
   "devDependencies": {
-    "@nuxt/devtools": "^2.6.5",
-    "@nuxt/eslint": "1.9.0",
-    "@nuxt/eslint-config": "^1.9.0",
-    "@nuxt/image": "^1.11.0",
+    "@nuxt/devtools": "^3.1.1",
+    "@nuxt/eslint": "1.13.0",
+    "@nuxt/eslint-config": "^1.13.0",
+    "@nuxt/image": "^2.0.0",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "^4.1.3",
-    "@nuxt/test-utils": "^3.19.2",
-    "@nuxtjs/i18n": "^10.1.0",
-    "@playwright/test": "^1.56.0",
+    "@nuxt/schema": "^4.3.0",
+    "@nuxt/test-utils": "^3.23.0",
+    "@nuxtjs/i18n": "^10.2.1",
+    "@playwright/test": "^1.58.0",
     "@types/node": "latest",
     "changelogen": "^0.6.2",
-    "directus": "^11.12.0",
-    "eslint": "^9.37.0",
-    "nuxt": "^4.1.3",
-    "playwright-core": "^1.56.0",
+    "directus": "^11.14.1",
+    "eslint": "^9.39.2",
+    "nuxt": "^4.3.0",
+    "playwright-core": "^1.58.0",
     "typescript": "~5.9.3",
-    "vitest": "^3.2.4",
-    "vue-tsc": "^3.1.0"
+    "vitest": "^4.0.18",
+    "vue-tsc": "^3.2.4"
   }
 }