@sfxcode/nuxt-ui-formkit 1.2.11 → 1.3.0

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=4.0.0"
   },
-  "version": "1.2.11",
+  "version": "1.3.0",
   "builder": {
     "@nuxt/module-builder": "1.0.3",
     "unbuild": "3.6.1"

package/dist/runtime/components/inputs/FUSelect.vue

@@ -10,12 +10,17 @@ const { handleInput, handleChange, isInvalid, color, styleClass, modelValue, ite
 </script>
 
 <template>
+  <!-- Nuxt UI's own USelect shrinks its trigger to whatever's currently
+  selected (or just the chevron, unselected) - `w-fit min-w-48` keeps it from
+  collapsing that small while still growing for longer option labels, rather
+  than forcing every instance to one fixed width. Only applies when the
+  consumer hasn't already set their own `class`. -->
   <USelect
     :id="context.id"
     v-model="modelValue"
     :name="context.node.name"
     v-bind="{ ...context?.attrs }"
-    :class="styleClass"
+    :class="[styleClass, !context?.attrs?.class && 'w-fit min-w-48']"
     :disabled="!!context?.disabled"
     :style="context?.attrs.style"
     :color="color"

package/dist/runtime/components/inputs/FUSelectMenu.vue

@@ -10,12 +10,17 @@ const { handleInput, handleChange, isInvalid, styleClass, color, modelValue, ite
 </script>
 
 <template>
+  <!-- Nuxt UI's own USelectMenu shrinks its trigger to whatever's currently
+  selected (or just the chevron, unselected) - `w-fit min-w-48` keeps it from
+  collapsing that small while still growing for longer option labels, rather
+  than forcing every instance to one fixed width. Only applies when the
+  consumer hasn't already set their own `class`. -->
   <USelectMenu
     :id="context.id"
     v-model="modelValue"
     :name="context.node.name"
     v-bind="{ ...context?.attrs }"
-    :class="styleClass"
+    :class="[styleClass, !context?.attrs?.class && 'w-fit min-w-48']"
     :disabled="!!context?.disabled"
     :style="context?.attrs.style"
     :color="color"

package/dist/runtime/composables/useFormKitEditor.d.ts

@@ -0,0 +1,36 @@
+type EditorData = Record<string, unknown> & {
+    _dollar_formkit?: string;
+    $formkit?: string;
+    attrs?: {
+        attrKey?: string;
+        attrValue?: unknown;
+    }[];
+    options?: unknown[];
+    label?: unknown;
+    legend?: unknown;
+    outerClass?: unknown;
+    wrapperClass?: unknown;
+    innerClass?: unknown;
+    readonly?: unknown;
+    disabled?: unknown;
+    preserve?: unknown;
+};
+/**
+ * Converts between a single FormKit schema node (`{ $formkit: 'nuxtUIInput', ... }`)
+ * and the "editor data" shape used by the property-editor form built in
+ * `useFormKitEditorSchema`. The editor form is itself a FormKit form, so its
+ * field names can't collide with FormKit's own `$`-prefixed schema syntax -
+ * `_dollar_formkit` stands in for `$formkit` while editing and gets mapped
+ * back on the way out.
+ */
+export declare function useFormKitEditor(): {
+    inputNames: string[];
+    outputNames: string[];
+    inputNamesWithOptions: string[];
+    inputNamesWithLegend: string[];
+    editorDataToSchema: (data: EditorData) => Record<string, unknown>;
+    editorDataToJson: (data: EditorData) => string;
+    editorDataToCode: (data: EditorData) => string;
+    schemaToEditorData: (schema: Record<string, unknown>) => EditorData;
+};
+export {};

package/dist/runtime/composables/useFormKitEditor.js

@@ -0,0 +1,120 @@
+export function useFormKitEditor() {
+  const inputNamesWithOptions = ["nuxtUICheckboxGroup", "nuxtUIInputMenu", "nuxtUIListbox", "nuxtUIRadioGroup", "nuxtUISelect", "nuxtUISelectMenu", "nuxtUITree"];
+  const inputNamesWithLegend = ["nuxtUICheckboxGroup", "nuxtUIRadioGroup"];
+  const inputNames = ["nuxtUICalendar", "nuxtUICheckbox", "nuxtUICheckboxGroup", "nuxtUIColorPicker", "nuxtUIEditor", "nuxtUIFileUpload", "nuxtUIInput", "nuxtUIInputDate", "nuxtUIInputMenu", "nuxtUIInputNumber", "nuxtUIInputRating", "nuxtUIInputTags", "nuxtUIInputTime", "nuxtUIListbox", "nuxtUIPinInput", "nuxtUIRadioGroup", "nuxtUISelect", "nuxtUISelectMenu", "nuxtUISlider", "nuxtUISwitch", "nuxtUITextarea", "nuxtUITree"].sort();
+  const outputNames = ["nuxtUIOutputBadge", "nuxtUIOutputBoolean", "nuxtUIOutputDate", "nuxtUIOutputLink", "nuxtUIOutputList", "nuxtUIOutputNumber", "nuxtUIOutputProgress", "nuxtUIOutputRating", "nuxtUIOutputText", "nuxtUIOutputUser"].sort();
+  function parseAttrValue(value) {
+    if (typeof value !== "string")
+      return value;
+    const trimmed = value.trim();
+    if (trimmed.length === 0)
+      return value;
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return value;
+    }
+  }
+  function sanitizeOptions(options) {
+    if (!Array.isArray(options))
+      return void 0;
+    return options.filter((option) => Boolean(option) && typeof option === "object").filter((option) => option.label !== "" || option.value !== "").map((option) => ({ ...option }));
+  }
+  function editorDataToSchema(data) {
+    if (!data)
+      return {};
+    const formkitInput = data._dollar_formkit;
+    let extraAttrs = {};
+    if (data.attrs && Array.isArray(data.attrs) && data.attrs.length > 0) {
+      const mapped = data.attrs.filter((entry) => entry && typeof entry === "object" && entry.attrKey).map((entry) => [entry.attrKey, parseAttrValue(entry.attrValue)]);
+      extraAttrs = Object.fromEntries(mapped);
+    }
+    const defaultObject = {
+      readonly: data.readonly === true ? true : void 0,
+      disabled: data.disabled === true ? true : void 0,
+      preserve: data.preserve === true ? true : void 0
+    };
+    const outerClass = data.outerClass ? String(data.outerClass).trim() : void 0;
+    const wrapperClass = data.wrapperClass ? String(data.wrapperClass).trim() : void 0;
+    const innerClass = data.innerClass ? String(data.innerClass).trim() : void 0;
+    const undefinedObject = {
+      attrs: void 0,
+      schemaResultFormKey: void 0,
+      _dollar_formkit: void 0,
+      section: void 0,
+      slots: void 0
+    };
+    const useOptions = formkitInput ? inputNamesWithOptions.includes(formkitInput) : false;
+    const useLegend = formkitInput ? inputNamesWithLegend.includes(formkitInput) : false;
+    const result = {
+      ...data,
+      $formkit: formkitInput,
+      ...extraAttrs,
+      ...undefinedObject,
+      ...defaultObject,
+      outerClass,
+      wrapperClass,
+      innerClass,
+      // Cloned (not the same array/objects as `data.options`) so nothing
+      // downstream - the live preview's own rendered Select, `JSON.stringify`
+      // for the debug/copy views - can ever mutate the editor form's own
+      // repeater value by touching a shared reference. Also drops rows the
+      // user hasn't finished filling in yet, which Nuxt UI's Select/SelectMenu
+      // otherwise reject for having an empty `value`.
+      options: useOptions ? sanitizeOptions(data.options) : void 0,
+      label: useLegend ? void 0 : data.label,
+      legend: useLegend ? data.legend : void 0
+    };
+    for (const key in result) {
+      const value = result[key];
+      if (typeof value === "string" && value.trim().length === 0)
+        result[key] = void 0;
+    }
+    return result;
+  }
+  function editorDataToJson(data) {
+    if (!data)
+      return "{}";
+    return JSON.stringify(editorDataToSchema(data));
+  }
+  function objectToString(data) {
+    if (!data)
+      return "{}";
+    return `{ ${Object.entries(data).filter(([, value]) => value !== void 0).map(([key, value]) => {
+      if (key === "options" && Array.isArray(value) && value.length > 0) {
+        const options = value.map((option) => option && typeof option === "object" ? objectToString(option) : JSON.stringify(option));
+        return `${key}: [${options.join(", ")}]`;
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return `${key}: ${value}`;
+      }
+      return `${key}: '${value}'`;
+    }).join(", ")} }`;
+  }
+  function editorDataToCode(data) {
+    if (!data)
+      return "{}";
+    try {
+      const jsonData = editorDataToJson(data);
+      return objectToString(JSON.parse(jsonData));
+    } catch (error) {
+      console.error("Error in editorDataToCode:", error);
+      return "{}";
+    }
+  }
+  function schemaToEditorData(schema) {
+    if (!schema)
+      return {};
+    return { ...schema, _dollar_formkit: schema.$formkit };
+  }
+  return {
+    inputNames,
+    outputNames,
+    inputNamesWithOptions,
+    inputNamesWithLegend,
+    editorDataToSchema,
+    editorDataToJson,
+    editorDataToCode,
+    schemaToEditorData
+  };
+}

package/dist/runtime/composables/useFormKitEditorSchema.d.ts

@@ -0,0 +1,74 @@
+export declare function useFormKitEditorSchema(isChangeTypePossible?: boolean): {
+    editorSchema: (typeOptionsOverride?: {
+        label: string;
+        value: string;
+    }[]) => (string | import("@formkit/core").FormKitSchemaDOMNode | import("@formkit/core").FormKitSchemaComponent | import("@formkit/core").FormKitSchemaCondition | import("@formkit/core").FormKitSchemaFormKit | {
+        $formkit: string;
+        if: string;
+        name: string;
+        label: string;
+        help: string;
+        listClass: string;
+        listItemClass: string;
+        insertButtonLabel: string;
+        alwaysDisplayInsertButton: boolean;
+        displayDeleteButton: boolean;
+        draggable: boolean;
+        displayDragHandle: boolean;
+        dragHandleClass: string;
+        buttonGroupClass: string;
+        hideMoveButtons: boolean;
+        newItem: {
+            label: string;
+            value: string;
+            attrKey?: undefined;
+            attrValue?: undefined;
+        };
+        key: string;
+        preserve: boolean;
+        children: {
+            $formkit: string;
+            label: string;
+            name: string;
+            outerClass: string;
+        }[];
+    } | {
+        $formkit: string;
+        if: string;
+        name: string;
+        label: string;
+        help: string;
+        listClass: string;
+        listItemClass: string;
+        insertButtonLabel: string;
+        alwaysDisplayInsertButton: boolean;
+        displayDeleteButton: boolean;
+        draggable: boolean;
+        displayDragHandle: boolean;
+        dragHandleClass: string;
+        buttonGroupClass: string;
+        hideMoveButtons: boolean;
+        newItem: {
+            attrKey: string;
+            attrValue: string;
+            label?: undefined;
+            value?: undefined;
+        };
+        key: string;
+        preserve: boolean;
+        children: {
+            $formkit: string;
+            label: string;
+            name: string;
+            outerClass: string;
+        }[];
+    })[];
+    fieldTypeOptions: {
+        label: string;
+        value: string;
+    }[];
+    typeOptions: (names: string[], kind?: string) => {
+        label: string;
+        value: string;
+    }[];
+};

package/dist/runtime/composables/useFormKitEditorSchema.js

@@ -0,0 +1,337 @@
+import { useFormKitSchema } from "./useFormKitSchema.js";
+import { useFormKitEditor } from "./useFormKitEditor.ts";
+let instanceCounter = 0;
+export function useFormKitEditorSchema(isChangeTypePossible = true) {
+  const { addElement } = useFormKitSchema();
+  const { inputNames, outputNames, inputNamesWithOptions, inputNamesWithLegend } = useFormKitEditor();
+  instanceCounter += 1;
+  const dollarFormkitId = `_dollar_formkit_${instanceCounter}`;
+  const sectionId = `section_${instanceCounter}`;
+  function ifGet(id, value) {
+    return `$get(${id}).value === '${value}'`;
+  }
+  function ifSection(section) {
+    return ifGet(sectionId, section);
+  }
+  function ifAnyType(names) {
+    return names.map((name) => ifGet(dollarFormkitId, name)).join(" || ");
+  }
+  function ifNoneType(names) {
+    return names.map((name) => `$get(${dollarFormkitId}).value !== '${name}'`).join(" && ");
+  }
+  const optionsCapableIf = `(${ifAnyType(inputNamesWithOptions)})`;
+  const notOptionsCapableIf = `(${ifNoneType(inputNamesWithOptions)})`;
+  const legendTypeIf = `(${ifAnyType(inputNamesWithLegend)})`;
+  const notLegendTypeIf = `(${ifNoneType(inputNamesWithLegend)})`;
+  function typeOptions(names, kind) {
+    return names.map((name) => ({ label: kind ? `${name} (${kind})` : name, value: name }));
+  }
+  const fieldTypeOptions = [...typeOptions(inputNames), ...typeOptions(outputNames, "output")];
+  const sectionOptions = [
+    { label: "Base", value: "base" },
+    { label: "Display", value: "display" },
+    { label: "Style", value: "style" },
+    { label: "Validation", value: "validation" },
+    { label: "Options", value: "options" },
+    { label: "Attributes", value: "attrs" }
+  ];
+  const validationVisibilityOptions = [
+    { label: "Blur", value: "blur" },
+    { label: "Live", value: "live" },
+    { label: "Dirty", value: "dirty" },
+    { label: "Submit", value: "submit" }
+  ];
+  function editorSchema(typeOptionsOverride = fieldTypeOptions) {
+    return [
+      {
+        $formkit: "nuxtUISelectMenu",
+        // `$get()` addresses nodes by `id`, not `name` - this has to match
+        // `dollarFormkitId`, the identifier `ifGet`/`ifAnyType`/`ifNoneType`
+        // use below. `name` stays the fixed `'_dollar_formkit'` string -
+        // that's the form-data key consumers (`useFormKitEditor`, the
+        // Form Builder/Input Editor pages) read, and unlike `id` it isn't
+        // addressed through FormKit's cross-instance global registry, so it
+        // doesn't need to be unique.
+        // Disabled rather than hidden (`if: false`) when type-switching is
+        // turned off - hiding would unmount this node entirely, and every
+        // other `$get(dollarFormkitId)` comparison below (legend vs label,
+        // the Options tab's capability check) would then find nothing and
+        // always evaluate false.
+        id: dollarFormkitId,
+        name: "_dollar_formkit",
+        disabled: !isChangeTypePossible,
+        label: "Field Type",
+        value: "nuxtUIInput",
+        // Without `valueKey`, nuxtUISelectMenu's model value is the whole
+        // `{ label, value }` option object rather than just its `value` -
+        // every `$get(_dollar_formkit).value === '...'` comparison below
+        // would silently compare an object to a string and always be false.
+        valueKey: "value",
+        options: typeOptionsOverride,
+        key: "schema_inputSelection",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        name: "name",
+        label: "Field Name",
+        validation: "required",
+        validationVisibility: "live",
+        key: "schema_name",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIRadioGroup",
+        // See the `dollarFormkitId` comment above - same reasoning, `id`
+        // needs to be globally unique per mount, `name` doesn't.
+        id: sectionId,
+        name: "section",
+        legend: "Properties",
+        options: sectionOptions,
+        orientation: "horizontal",
+        // Nuxt UI's horizontal RadioGroup fieldset is `flex flex-row` with no
+        // wrap by default - in the narrow Properties panel that overflows
+        // instead of dropping "Attributes" etc. to a second line.
+        ui: { fieldset: "flex-wrap" },
+        value: "base",
+        key: "schema_section",
+        preserve: true
+      },
+      // --- Base -----------------------------------------------------------
+      {
+        $formkit: "nuxtUIInput",
+        if: `${ifSection("base")} && ${notLegendTypeIf}`,
+        name: "label",
+        label: "Field Label",
+        key: "schema_label",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: `${ifSection("base")} && ${legendTypeIf}`,
+        name: "legend",
+        label: "Field Legend",
+        key: "schema_legend",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("base"),
+        name: "help",
+        label: "Help Text",
+        key: "schema_help",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("base"),
+        name: "value",
+        label: "Default Value",
+        key: "schema_value",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("base"),
+        name: "id",
+        label: "Field ID",
+        key: "schema_id",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("base"),
+        name: "key",
+        label: "Schema Key",
+        help: "Forces FormKit to re-render this node when the key changes.",
+        key: "schema_key",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUICheckbox",
+        if: ifSection("base"),
+        name: "preserve",
+        label: "Preserve value when hidden",
+        key: "schema_preserve",
+        value: false,
+        preserve: true
+      },
+      // --- Display ----------------------------------------------------------
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("display"),
+        name: "class",
+        label: "CSS Class",
+        key: "schema_class",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("display"),
+        name: "if",
+        label: "Render Condition (if-expression)",
+        help: "e.g. $get(otherField).value === true",
+        key: "schema_if",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUICheckbox",
+        if: ifSection("display"),
+        name: "disabled",
+        label: "Disabled",
+        key: "schema_disabled",
+        value: false,
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUICheckbox",
+        if: ifSection("display"),
+        name: "readonly",
+        label: "Read Only",
+        key: "schema_readonly",
+        value: false,
+        preserve: true
+      },
+      // --- Style ------------------------------------------------------------
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("style"),
+        name: "outerClass",
+        label: "Outer Class",
+        key: "schema_outerClass",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("style"),
+        name: "wrapperClass",
+        label: "Wrapper Class",
+        key: "schema_wrapperClass",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("style"),
+        name: "innerClass",
+        label: "Inner Class",
+        key: "schema_innerClass",
+        preserve: true
+      },
+      // --- Validation ---------------------------------------------------------
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("validation"),
+        name: "validation",
+        label: "Validation Rules",
+        help: "e.g. required|email",
+        key: "schema_validation",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUISelect",
+        if: ifSection("validation"),
+        name: "validationVisibility",
+        label: "Validation Visibility",
+        options: validationVisibilityOptions,
+        key: "schema_validationVisibility",
+        preserve: true
+      },
+      {
+        $formkit: "nuxtUIInput",
+        if: ifSection("validation"),
+        name: "validationLabel",
+        label: "Validation Label",
+        key: "schema_validationLabel",
+        preserve: true
+      },
+      // --- Options (only for field types with an options/items list) --------
+      // `listClass`/`listItemClass` match the flex row layout from the
+      // Repeater sample (pages/form/repeater-sample.vue); `draggable` +
+      // `displayDragHandle` add drag-and-drop reordering the way the
+      // Drag-and-Drop Repeater sample (pages/form/repeater-drag.vue) does -
+      // `hideMoveButtons` follows that same sample's convention of hiding the
+      // up/down buttons once dragging covers reordering.
+      addElement("p", "The selected field type does not use an options list.", { class: "text-muted text-sm" }, `${ifSection("options")} && ${notOptionsCapableIf}`),
+      {
+        $formkit: "nuxtUIRepeater",
+        if: `${ifSection("options")} && ${optionsCapableIf}`,
+        name: "options",
+        label: "Options",
+        help: "Shown to the user as label, submitted as value.",
+        listClass: "grid gap-2",
+        listItemClass: "flex items-start gap-2",
+        insertButtonLabel: "Add Option",
+        alwaysDisplayInsertButton: true,
+        displayDeleteButton: true,
+        draggable: true,
+        displayDragHandle: true,
+        // Each row's children render with their own label above their input
+        // (like every other field), but the drag handle and delete button
+        // don't have one - `items-start` alone lines them up with the
+        // *labels*, not the inputs below. `mt-6` nudges both down to roughly
+        // where the inputs start instead.
+        dragHandleClass: "mt-6 cursor-grab active:cursor-grabbing text-muted",
+        buttonGroupClass: "mt-6 shrink-0",
+        hideMoveButtons: true,
+        newItem: { label: "", value: "" },
+        key: "schema_options",
+        preserve: true,
+        children: [
+          {
+            $formkit: "nuxtUIInput",
+            label: "Label",
+            name: "label",
+            outerClass: "w-48"
+          },
+          {
+            $formkit: "nuxtUIInput",
+            label: "Value",
+            name: "value",
+            outerClass: "w-48"
+          }
+        ]
+      },
+      // --- Attributes (escape hatch for anything not covered above) ---------
+      {
+        $formkit: "nuxtUIRepeater",
+        if: ifSection("attrs"),
+        name: "attrs",
+        label: "Extra Properties",
+        help: "Any additional schema property this field type supports (e.g. rows, min, max, icon).",
+        listClass: "grid gap-2",
+        listItemClass: "flex items-start gap-2",
+        insertButtonLabel: "Add Property",
+        alwaysDisplayInsertButton: true,
+        displayDeleteButton: true,
+        draggable: true,
+        displayDragHandle: true,
+        // Each row's children render with their own label above their input
+        // (like every other field), but the drag handle and delete button
+        // don't have one - `items-start` alone lines them up with the
+        // *labels*, not the inputs below. `mt-6` nudges both down to roughly
+        // where the inputs start instead.
+        dragHandleClass: "mt-6 cursor-grab active:cursor-grabbing text-muted",
+        buttonGroupClass: "mt-6 shrink-0",
+        hideMoveButtons: true,
+        newItem: { attrKey: "", attrValue: "" },
+        key: "schema_attrs",
+        preserve: true,
+        children: [
+          {
+            $formkit: "nuxtUIInput",
+            label: "Property",
+            name: "attrKey",
+            outerClass: "w-48"
+          },
+          {
+            $formkit: "nuxtUIInput",
+            label: "Value",
+            name: "attrValue",
+            outerClass: "w-48"
+          }
+        ]
+      }
+    ];
+  }
+  return { editorSchema, fieldTypeOptions, typeOptions };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sfxcode/nuxt-ui-formkit",
-  "version": "1.2.11",
+  "version": "1.3.0",
   "description": "FormKit integration for Nuxt UI - Seamlessly connect FormKit form handling with Nuxt UI components",
   "author": {
     "name": "Tom",
@@ -78,7 +78,7 @@
     "dev": "npm run dev:prepare && nuxi dev playground",
     "dev:build": "nuxi build playground",
     "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare && nuxi prepare playground",
-    "release": "npm run lint && npm run test && npm run prepack && changelogen --patch --release && npm publish --access=public && git push --follow-tags",
+    "release": "npm run lint && npm run test && npm run prepack && changelogen --minor --release && npm publish --access=public && git push --follow-tags",
     "lint": "eslint .",
     "test": "vitest run",
     "test:watch": "vitest watch",
@@ -92,38 +92,38 @@
     "@formkit/nuxt": "^2.1.2",
     "@nuxt/ui": "^4.10.0",
     "@standard-schema/spec": "^1.1.0",
-    "@vue/compiler-dom": "^3.5.40"
+    "@vue/compiler-dom": "^3.5.41"
   },
   "devDependencies": {
     "@codemirror/lang-json": "^6.0.2",
     "@codemirror/state": "^6.7.1",
     "@codemirror/theme-one-dark": "^6.1.3",
-    "@codemirror/view": "^6.43.7",
+    "@codemirror/view": "^6.43.8",
     "@iconify-json/heroicons": "^1.2.3",
-    "@iconify-json/lucide": "^1.2.121",
+    "@iconify-json/lucide": "^1.2.123",
     "@iconify-json/simple-icons": "^1.2.93",
     "@nuxt/devtools": "4.0.0-alpha.9",
-    "@nuxt/eslint-config": "^1.16.0",
-    "@nuxt/kit": "^4.5.1",
+    "@nuxt/eslint-config": "^1.17.0",
+    "@nuxt/kit": "^4.5.2",
     "@nuxt/module-builder": "^1.0.3",
-    "@nuxt/schema": "^4.5.1",
+    "@nuxt/schema": "^4.5.2",
     "@nuxt/test-utils": "^4.1.0",
     "@types/node": "latest",
     "@vitejs/plugin-vue": "^6.0.8",
     "@vue/test-utils": "^2.4.11",
     "changelogen": "^0.6.2",
     "codemirror": "^6.0.2",
-    "eslint": "^10.8.0",
+    "eslint": "^10.8.1",
     "jsdom": "^30.0.1",
     "mkdist": "^2.4.1",
-    "nuxt": "^4.5.1",
-    "sass-embedded": "^1.100.0",
+    "nuxt": "^4.5.2",
+    "sass-embedded": "^1.102.0",
     "typescript": "~6.0.3",
     "unbuild": "^3.6.1",
     "valibot": "^1.4.2",
     "vitepress": "2.0.0-alpha.17",
     "vitest": "^4.1.10",
-    "vue": "^3.5.40",
+    "vue": "^3.5.41",
     "vue-i18n": "^11.4.8",
     "vue-tsc": "^3.3.9",
     "zod": "^4.4.3"