@abraca/nuxt 2.9.0 → 2.11.0

package/dist/runtime/extensions/document-meta.js

@@ -1,11 +1,15 @@
 import { Node } from "@tiptap/core";
-import { Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
 import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import { Plugin, PluginKey, TextSelection } from "@tiptap/pm/state";
+import { Fragment } from "@tiptap/pm/model";
+import { DecorationSet, Decoration } from "@tiptap/pm/view";
+import { isChangeOrigin } from "@tiptap/extension-collaboration";
 import DocumentMetaView from "./views/DocumentMetaView.vue";
 export const DocumentMeta = Node.create({
   name: "documentMeta",
   content: "inline*",
   defining: true,
+  draggable: false,
   parseHTML() {
     return [{ tag: 'div[data-type="document-meta"]' }];
   },
@@ -56,6 +60,263 @@ export const DocumentMeta = Node.create({
   },
   addProseMirrorPlugins() {
     return [
+      // ── L2: comprehensive structure guard ────────────────────────────────
+      // Rejects local transactions that would violate the
+      //   documentHeader@0  documentMeta@1  block+
+      // invariant, and reshapes any post-state (including y-sync deltas
+      // that slipped past the Y-level enforcer) so we never render a
+      // damaged structure. Also enforces L6: documentMeta content is
+      // limited to metaField inline atoms.
+      new Plugin({
+        key: new PluginKey("documentStructureGuard"),
+        filterTransaction(tr) {
+          if (!tr.docChanged) return true;
+          if (isChangeOrigin(tr)) return true;
+          if (tr.getMeta("shape-repair")) return true;
+          const doc = tr.doc;
+          let headerCount = 0;
+          let headerIdx = -1;
+          let metaCount = 0;
+          let metaIdx = -1;
+          doc.forEach((node, _offset, index) => {
+            if (node.type.name === "documentHeader") {
+              headerCount++;
+              if (headerIdx === -1) headerIdx = index;
+            } else if (node.type.name === "documentMeta") {
+              metaCount++;
+              if (metaIdx === -1) metaIdx = index;
+            }
+          });
+          if (headerCount !== 1 || headerIdx !== 0) return false;
+          if (metaCount !== 1 || metaIdx !== 1) return false;
+          let strayMetaField = false;
+          doc.descendants((node, _pos, parent) => {
+            if (node.type.name === "metaField" && parent?.type.name !== "documentMeta") {
+              strayMetaField = true;
+              return false;
+            }
+            return true;
+          });
+          if (strayMetaField) return false;
+          return true;
+        },
+        // Repair damage that arrived via y-sync (or any tr the filter
+        // couldn't reject). Runs on every doc-changing tr so peers always
+        // see a healthy structure. We collapse duplicates by content, merge
+        // metaField children from extras into the canonical meta, and
+        // restore correct ordering.
+        appendTransaction(transactions, _oldState, newState) {
+          if (!transactions.some((t) => t.docChanged)) return null;
+          const doc = newState.doc;
+          const schema = newState.schema;
+          const headerType = schema.nodes.documentHeader;
+          const metaType = schema.nodes.documentMeta;
+          const paragraphType = schema.nodes.paragraph;
+          if (!headerType || !metaType || !paragraphType) return null;
+          const headers = [];
+          const metas = [];
+          const bodyContent = [];
+          const strayMetaFields = [];
+          doc.forEach((node, _offset, index) => {
+            if (node.type.name === "documentHeader")
+              headers.push({ node, idx: index, weight: node.textContent.length });
+            else if (node.type.name === "documentMeta")
+              metas.push({ node, idx: index, weight: node.childCount });
+            else bodyContent.push(node);
+          });
+          doc.descendants((node, _pos, parent) => {
+            if (node.type.name === "metaField" && parent?.type.name !== "documentMeta") {
+              strayMetaFields.push(node);
+              return false;
+            }
+            return true;
+          });
+          const pick = (arr) => {
+            if (arr.length === 0) return null;
+            let best = arr[0];
+            for (let i = 1; i < arr.length; i++) {
+              const c = arr[i];
+              if (c.weight > best.weight || c.weight === best.weight && c.idx < best.idx)
+                best = c;
+            }
+            return best;
+          };
+          const canonicalHeader = pick(headers);
+          const canonicalMeta = pick(metas);
+          const headerExtras = canonicalHeader ? headers.filter((h) => h !== canonicalHeader) : [];
+          const metaExtras = canonicalMeta ? metas.filter((m) => m !== canonicalMeta) : [];
+          const headerMissing = headers.length === 0;
+          const metaMissing = metas.length === 0;
+          const headerMisplaced = !headerMissing && (canonicalHeader?.idx ?? 0) !== 0;
+          const metaMisplaced = !metaMissing && (canonicalMeta?.idx ?? 0) !== 1;
+          const hasDuplicates = headerExtras.length > 0 || metaExtras.length > 0;
+          const hasStrayFields = strayMetaFields.length > 0;
+          if (!headerMissing && !metaMissing && !headerMisplaced && !metaMisplaced && !hasDuplicates && !hasStrayFields)
+            return null;
+          const repairedHeader = canonicalHeader?.node ?? headerType.create();
+          const identityOf = (mf) => {
+            const a = mf.attrs ?? {};
+            if (a.metaKey) return `mk:${a.metaKey}`;
+            const composite = `${a.startKey ?? ""}:${a.endKey ?? ""}:${a.latKey ?? ""}:${a.lngKey ?? ""}:${a.allDayKey ?? ""}`;
+            return composite === "::::" ? "" : `c:${composite}`;
+          };
+          const seen = /* @__PURE__ */ new Set();
+          const mergedFields = [];
+          const collectFields = (source) => {
+            source.forEach?.((child) => {
+              if (child.type.name !== "metaField") return;
+              const id = identityOf(child);
+              if (!id || seen.has(id)) return;
+              seen.add(id);
+              mergedFields.push(child);
+            });
+          };
+          if (canonicalMeta?.node) collectFields(canonicalMeta.node);
+          for (const m of metaExtras) collectFields(m.node);
+          for (const sf of strayMetaFields) {
+            const id = identityOf(sf);
+            if (!id || seen.has(id)) continue;
+            seen.add(id);
+            mergedFields.push(sf);
+          }
+          const metaNeedsRebuild = metaExtras.length > 0 || strayMetaFields.length > 0;
+          const repairedMeta = !metaNeedsRebuild && canonicalMeta?.node ? canonicalMeta.node : metaType.create(
+            null,
+            mergedFields.length > 0 ? Fragment.fromArray(mergedFields) : Fragment.empty
+          );
+          const finalBody = bodyContent.length > 0 ? bodyContent : [paragraphType.create()];
+          const newContent = Fragment.fromArray([
+            repairedHeader,
+            repairedMeta,
+            ...finalBody
+          ]);
+          const tr = newState.tr;
+          tr.replaceWith(0, doc.content.size, newContent);
+          tr.setMeta("shape-repair", true);
+          try {
+            const mappedAnchor = tr.mapping.map(newState.selection.anchor);
+            const mappedHead = tr.mapping.map(newState.selection.head);
+            tr.setSelection(
+              TextSelection.create(
+                tr.doc,
+                Math.min(mappedAnchor, tr.doc.content.size),
+                Math.min(mappedHead, tr.doc.content.size)
+              )
+            );
+          } catch {
+            const firstBodyPos = repairedHeader.nodeSize + repairedMeta.nodeSize + 1;
+            tr.setSelection(
+              TextSelection.create(
+                tr.doc,
+                Math.min(firstBodyPos, tr.doc.content.size)
+              )
+            );
+          }
+          return tr;
+        }
+      }),
+      // ── L5: selection-aware placeholder + cursor-in-meta DOM signal ──────
+      // Marks the documentMeta DOM node with:
+      //   data-cursor-in-meta="true"  when the selection is inside it
+      //   data-empty="true"           when its content is empty
+      // CSS uses the combination to render the placeholder hint only when
+      // BOTH are true — so an empty meta with the cursor elsewhere stays
+      // visually empty (but still clickable, per Layer 4), and a populated
+      // meta with cursor inside doesn't get a stray hint behind the chips.
+      new Plugin({
+        key: new PluginKey("documentMetaCursorSignal"),
+        props: {
+          decorations(state) {
+            let metaPos = -1;
+            let metaNode = null;
+            state.doc.forEach((node, offset) => {
+              if (metaPos === -1 && node.type.name === "documentMeta") {
+                metaPos = offset;
+                metaNode = node;
+              }
+            });
+            if (metaPos === -1 || !metaNode) return DecorationSet.empty;
+            const { $head } = state.selection;
+            let inMeta = false;
+            for (let d = $head.depth; d >= 0; d--) {
+              if ($head.node(d).type.name === "documentMeta") {
+                inMeta = true;
+                break;
+              }
+            }
+            const isEmpty = metaNode.content.size === 0;
+            if (!inMeta && !isEmpty) return DecorationSet.empty;
+            const attrs = {};
+            if (inMeta) attrs["data-cursor-in-meta"] = "true";
+            if (isEmpty) attrs["data-empty"] = "true";
+            return DecorationSet.create(state.doc, [
+              Decoration.node(metaPos, metaPos + metaNode.nodeSize, attrs)
+            ]);
+          }
+        }
+      }),
+      // ── L6: meta text-input lockout ──────────────────────────────────────
+      // Swallow all keystrokes inside documentMeta except '/' (which
+      // triggers the slash menu). Property chips remain insertable via
+      // the menu / programmatic commands. Combined with filterTransaction
+      // above, this guarantees nothing but metaField atoms can ever live
+      // in the meta header.
+      new Plugin({
+        key: new PluginKey("documentMetaInputLock"),
+        props: {
+          handleTextInput(view, _from, _to, text) {
+            const { $head } = view.state.selection;
+            let inMeta = false;
+            for (let d = $head.depth; d >= 0; d--) {
+              if ($head.node(d).type.name === "documentMeta") {
+                inMeta = true;
+                break;
+              }
+            }
+            if (!inMeta) return false;
+            return text !== "/";
+          }
+        }
+      }),
+      // ── L4 helper: explicit empty-meta click fallback ───────────────────
+      // With NodeViewContent using display:contents (required so chips
+      // align as direct flex children of the wrapper), PM's posAtCoords
+      // can't always find an inline position in an empty meta row.
+      // Catch any click that lands inside the meta wrapper but not on a
+      // chip / button / dropdown and place the cursor at the end of meta
+      // ourselves.
+      new Plugin({
+        key: new PluginKey("documentMetaClickFallback"),
+        props: {
+          handleClick(view, _pos, event) {
+            const target = event.target;
+            if (!target) return false;
+            const metaEl = target.closest('[data-type="document-meta"]');
+            if (!metaEl) return false;
+            if (target.closest('[data-type="meta-field"]')) return false;
+            if (target.closest("button")) return false;
+            if (target.closest('[role="menu"]')) return false;
+            if (target.closest("[data-popper-content]")) return false;
+            let metaPos = -1;
+            let metaContentSize = 0;
+            view.state.doc.forEach((node, offset) => {
+              if (metaPos === -1 && node.type.name === "documentMeta") {
+                metaPos = offset;
+                metaContentSize = node.content.size;
+              }
+            });
+            if (metaPos === -1) return false;
+            const targetPos = metaPos + 1 + metaContentSize;
+            view.dispatch(
+              view.state.tr.setSelection(
+                TextSelection.create(view.state.doc, targetPos)
+              )
+            );
+            view.focus();
+            return true;
+          }
+        }
+      }),
       new Plugin({
         key: new PluginKey("documentMetaGuard"),
         props: {
@@ -89,26 +350,90 @@ export const DocumentMeta = Node.create({
               return true;
             }
             return false;
+          },
+          // Block drops that target inside documentMeta or carry documentMeta content
+          handleDrop(view, event, slice, moved) {
+            if (event) {
+              const coords = { left: event.clientX, top: event.clientY };
+              const pos = view.posAtCoords(coords);
+              if (pos) {
+                const $pos = view.state.doc.resolve(pos.pos);
+                for (let d = $pos.depth; d >= 0; d--) {
+                  if ($pos.node(d).type.name === "documentMeta") return true;
+                }
+              }
+            }
+            if (moved && slice) {
+              let hasMeta = false;
+              slice.content.forEach((node) => {
+                if (node.type.name === "documentMeta") hasMeta = true;
+              });
+              if (hasMeta) return true;
+            }
+            return false;
+          },
+          // Extract metaField nodes from pasted content and merge into documentMeta
+          handlePaste(view, _event, slice) {
+            const metaFieldNodes = [];
+            slice.content.forEach((node) => {
+              if (node.type.name === "metaField") {
+                metaFieldNodes.push(node);
+              } else if (node.type.name === "documentMeta") {
+                node.forEach((child) => {
+                  if (child.type.name === "metaField") metaFieldNodes.push(child);
+                });
+              } else {
+                node.forEach((child) => {
+                  if (child.type.name === "metaField") metaFieldNodes.push(child);
+                });
+              }
+            });
+            if (metaFieldNodes.length === 0) return false;
+            let metaPos = -1;
+            let metaNode = null;
+            view.state.doc.forEach((node, offset) => {
+              if (node.type.name === "documentMeta") {
+                metaPos = offset;
+                metaNode = node;
+              }
+            });
+            if (metaPos === -1 || !metaNode) return false;
+            const existingKeys = /* @__PURE__ */ new Set();
+            metaNode.forEach((child) => {
+              if (child.type.name === "metaField" && child.attrs.metaKey) {
+                existingKeys.add(`${child.attrs.fieldType}:${child.attrs.metaKey}`);
+              }
+            });
+            const newFields = metaFieldNodes.filter((n) => {
+              if (!n.attrs.metaKey) return true;
+              const key = `${n.attrs.fieldType}:${n.attrs.metaKey}`;
+              if (existingKeys.has(key)) return false;
+              existingKeys.add(key);
+              return true;
+            });
+            if (newFields.length > 0) {
+              const insertPos = metaPos + 1 + metaNode.content.size;
+              const tr = view.state.tr;
+              tr.insert(insertPos, Fragment.from(newFields));
+              view.dispatch(tr);
+            }
+            let hasNonMetaContent = false;
+            slice.content.forEach((node) => {
+              if (node.type.name !== "metaField" && node.type.name !== "documentMeta") {
+                if (node.type.name === "paragraph" || node.type.name === "heading") {
+                  let hasNonFieldChild = false;
+                  node.forEach((child) => {
+                    if (child.type.name !== "metaField") hasNonFieldChild = true;
+                  });
+                  if (hasNonFieldChild || node.content.size === 0) hasNonMetaContent = true;
+                } else {
+                  hasNonMetaContent = true;
+                }
+              }
+            });
+            return !hasNonMetaContent;
           }
         }
-      }),
-      new Plugin({
-        key: new PluginKey("documentMetaDedupe"),
-        appendTransaction(transactions, _old, newState) {
-          if (!transactions.some((tr2) => tr2.docChanged)) return null;
-          const metaPositions = [];
-          newState.doc.forEach((node, offset) => {
-            if (node.type.name === "documentMeta") metaPositions.push(offset);
-          });
-          if (metaPositions.length <= 1) return null;
-          const tr = newState.tr;
-          for (let i = metaPositions.length - 1; i >= 1; i--) {
-            const pos = metaPositions[i];
-            const node = newState.doc.nodeAt(pos);
-            if (node) tr.delete(pos, pos + node.nodeSize);
-          }
-          return tr;
-        }
       })
     ];
   }

package/dist/runtime/extensions/meta-field.js

@@ -66,6 +66,48 @@ export const MetaField = Node.create({
         const newNode = metaFieldType.create(attrs);
         if (dispatch) dispatch(tr.insert(insertPos, newNode));
         return true;
+      },
+      /**
+       * Move the metaField at `fromPos` to the index of the metaField currently
+       * at `toPos` (both are positions *inside* documentMeta — i.e. any position
+       * of the chip as reported by its NodeView's getPos()). No-op if the move
+       * would result in no change.
+       *
+       * MetaFieldView's drag-grip pointer handler calls this; without it the
+       * drag-reorder UI is rendered but inert.
+       */
+      moveMetaField: (fromPos, toPos) => ({ state, dispatch }) => {
+        const { doc, tr } = state;
+        let metaStart = -1;
+        let metaEnd = -1;
+        doc.forEach((node, offset) => {
+          if (node.type.name === "documentMeta") {
+            metaStart = offset + 1;
+            metaEnd = offset + 1 + node.content.size;
+          }
+        });
+        if (metaStart === -1) return false;
+        const fromNode = doc.nodeAt(fromPos);
+        if (!fromNode || fromNode.type.name !== "metaField") return false;
+        const fromFrom = fromPos;
+        const fromTo = fromPos + fromNode.nodeSize;
+        const target = Math.min(Math.max(toPos, metaStart), metaEnd);
+        let insertPos;
+        const toNode = doc.nodeAt(target);
+        if (toNode && toNode.type.name === "metaField") {
+          const targetStart = target;
+          const targetEnd = target + toNode.nodeSize;
+          const mid = (targetStart + targetEnd) / 2;
+          insertPos = toPos < mid ? targetStart : targetEnd;
+        } else {
+          insertPos = target;
+        }
+        if (insertPos === fromFrom || insertPos === fromTo) return false;
+        const newTr = tr.delete(fromFrom, fromTo);
+        const adjusted = insertPos > fromTo ? insertPos - fromNode.nodeSize : insertPos;
+        newTr.insert(adjusted, fromNode);
+        if (dispatch) dispatch(newTr);
+        return true;
       }
     };
   }

package/dist/runtime/extensions/views/DocumentMetaView.vue

@@ -19,19 +19,51 @@ const items = computed(() => {
   void props.node.content.size;
   return buildMetaMenuItems(props.editor);
 });
+function placeCursorInMeta(event) {
+  const target = event.target;
+  if (!target) return;
+  if (target.closest('[data-type="meta-field"]')) return;
+  if (target.closest("button")) return;
+  if (target.closest('[role="menu"]')) return;
+  if (target.closest("[data-popper-content]")) return;
+  const pos = props.getPos();
+  if (typeof pos !== "number") return;
+  const node = props.node;
+  const endPos = pos + 1 + node.content.size;
+  requestAnimationFrame(() => {
+    props.editor.chain().focus(endPos).run();
+  });
+}
 </script>
 
 <template>
+  <!--
+    L4: clicks anywhere on the row that aren't on a chip / + button /
+    menu are routed to placeCursorInMeta so the cursor lands inside an
+    empty meta even when PM's posAtCoords would have missed it. The
+    row's CSS min-height in editor.css guarantees the row stays tall
+    enough to receive clicks.
+
+    L5: placeholder text is rendered by a CSS ::after pseudo on the
+    wrapper, gated on the `data-cursor-in-meta="true"` +
+    `data-empty="true"` attributes set by the documentMetaCursorSignal
+    decoration plugin (see extensions/document-meta.ts). It flows
+    inline after the + button so the two never overlap.
+  -->
   <NodeViewWrapper
     as="div"
     data-type="document-meta"
     class="group/meta"
-    :class="{ 'meta-empty': node.content.size === 0 && !props.editor.isEditable }"
     draggable="false"
+    @mousedown="placeCursorInMeta"
     @dragstart.prevent.stop
   >
+    <!-- display: contents keeps chips as direct flex children of the
+         wrapper so they align with `align-items: center` / `gap` and
+         the cursor caret sits on the same baseline. -->
     <NodeViewContent
       as="span"
+      class="meta-content"
       style="display: contents"
     />
     <span
@@ -53,11 +85,5 @@ const items = computed(() => {
         />
       </UDropdownMenu>
     </span>
-    <span
-      v-if="node.content.size === 0 && props.editor.isEditable"
-      class="text-sm text-(--ui-text-muted) pointer-events-none opacity-60"
-    >
-      Type '/' to add a property…
-    </span>
   </NodeViewWrapper>
 </template>

package/dist/runtime/extensions/views/FieldView.vue

@@ -1,6 +1,7 @@
 <script setup>
-import { NodeViewWrapper, NodeViewContent } from "@tiptap/vue-3";
 import { computed } from "vue";
+import { NodeViewWrapper, NodeViewContent } from "@tiptap/vue-3";
+import ANodeInlineLabel from "../../components/editor/ANodeInlineLabel.vue";
 const props = defineProps({
   decorations: { type: Array, required: true },
   selected: { type: Boolean, required: true },
@@ -14,9 +15,26 @@ const props = defineProps({
   extension: { type: Object, required: true },
   HTMLAttributes: { type: Object, required: true }
 });
-const name = computed(() => props.node.attrs.name || "field");
+const FIELD_TYPES = ["string", "number", "boolean", "object", "array", "any"];
+const name = computed(() => props.node.attrs.name || "");
 const fieldType = computed(() => props.node.attrs.type || "string");
-const required = computed(() => props.node.attrs.required);
+const required = computed(() => !!props.node.attrs.required);
+function setName(v) {
+  props.updateAttributes({ name: v });
+}
+function setType(v) {
+  props.updateAttributes({ type: v });
+}
+function toggleRequired() {
+  props.updateAttributes({ required: !required.value });
+}
+const typeItems = computed(
+  () => FIELD_TYPES.map((t) => ({
+    label: t,
+    onSelect: () => setType(t),
+    ...fieldType.value === t ? { icon: "i-lucide-check" } : {}
+  }))
+);
 </script>
 
 <template>
@@ -28,22 +46,36 @@ const required = computed(() => props.node.attrs.required);
       class="flex items-center gap-3 font-mono text-sm"
       contenteditable="false"
     >
-      <span
-        v-if="name"
-        class="font-semibold text-(--ui-primary)"
-      >{{ name }}</span>
-      <div
-        v-if="fieldType || required"
-        class="flex-1 flex items-center gap-1.5 text-xs"
-      >
-        <span
-          v-if="fieldType"
-          class="rounded-sm bg-(--ui-bg-elevated) text-(--ui-text-toned) px-1.5 py-0.5"
-        >{{ fieldType }}</span>
-        <span
-          v-if="required"
-          class="rounded-sm bg-red-500/10 text-(--ui-error) px-1.5 py-0.5"
-        >required</span>
+      <ANodeInlineLabel
+        :model-value="name"
+        placeholder="fieldName"
+        variant="name"
+        @update:model-value="setName"
+      />
+      <div class="flex-1 flex items-center gap-1.5 text-xs">
+        <UDropdownMenu
+          :items="typeItems"
+          :content="{ align: 'start' }"
+        >
+          <button
+            class="rounded-sm bg-(--ui-bg-elevated) text-(--ui-text-toned) px-1.5 py-0.5 hover:bg-(--ui-bg-accented) inline-flex items-center gap-1"
+            title="Change type"
+          >
+            {{ fieldType }}
+            <UIcon
+              name="i-lucide-chevron-down"
+              class="size-3 opacity-60"
+            />
+          </button>
+        </UDropdownMenu>
+        <button
+          class="rounded-sm px-1.5 py-0.5 transition-colors"
+          :class="required ? 'bg-red-500/10 text-(--ui-error) hover:bg-red-500/20' : 'text-(--ui-text-muted) border border-dashed border-(--ui-border) hover:border-(--ui-border-accented) hover:text-(--ui-text)'"
+          :title="required ? 'Mark optional' : 'Mark required'"
+          @click="toggleRequired"
+        >
+          {{ required ? "required" : "optional" }}
+        </button>
       </div>
     </div>
     <div class="mt-3 text-(--ui-text-muted) text-sm [&_code]:text-xs/4">

package/dist/runtime/extensions/views/MetaFieldView.vue

@@ -75,6 +75,32 @@ function getObjArr(key) {
   if (!v || !Array.isArray(v)) return [];
   return v;
 }
+function resolveOptionLabel(raw, opts) {
+  if (raw == null || raw === "") return "";
+  if (typeof raw === "string") {
+    if (!opts.length) return raw;
+    if (opts.includes(raw)) return raw;
+    if (/^-?\d+$/.test(raw)) {
+      const idx = Number(raw);
+      if (idx >= 0 && idx < opts.length) return opts[idx];
+    }
+    return raw;
+  }
+  if (typeof raw === "number" && Number.isFinite(raw)) {
+    if (raw >= 0 && raw < opts.length) return opts[raw];
+    return String(raw);
+  }
+  return String(raw);
+}
+const selectChipLabel = computed(
+  () => resolveOptionLabel(storage()?.pageMeta?.[metaKey.value], options.value)
+);
+const multiSelectChipValues = computed(() => {
+  const raw = storage()?.pageMeta?.[metaKey.value];
+  if (!Array.isArray(raw) || raw.length === 0) return [];
+  return raw.map((v) => resolveOptionLabel(v, options.value)).filter((s) => s.length > 0);
+});
+const multiSelectChipLabel = computed(() => multiSelectChipValues.value.join(", "));
 function getNum(key, fallback = 0) {
   return storage()?.pageMeta?.[key] ?? fallback;
 }
@@ -837,8 +863,8 @@ function removeOption(opt) {
           trailing
           class="h-7 px-2.5 border border-(--ui-border) rounded-md hover:bg-(--ui-bg-elevated) data-[state=open]:bg-(--ui-bg-elevated) min-w-28"
         >
-          <span :class="getStr(metaKey) ? '' : 'text-(--ui-text-dimmed)'">
-            {{ getStr(metaKey) || fieldLabel || t.select }}
+          <span :class="selectChipLabel ? '' : 'text-(--ui-text-dimmed)'">
+            {{ selectChipLabel || fieldLabel || t.select }}
           </span>
         </UButton>
         <template #content>
@@ -913,8 +939,8 @@ function removeOption(opt) {
           trailing
           class="h-7 px-2.5 border border-(--ui-border) rounded-md hover:bg-(--ui-bg-elevated) data-[state=open]:bg-(--ui-bg-elevated) min-w-28"
         >
-          <span :class="getStrArr(metaKey).length ? '' : 'text-(--ui-text-dimmed)'">
-            {{ getStrArr(metaKey).length ? getStrArr(metaKey).join(", ") : fieldLabel || t.select }}
+          <span :class="multiSelectChipValues.length ? '' : 'text-(--ui-text-dimmed)'">
+            {{ multiSelectChipValues.length ? multiSelectChipLabel : fieldLabel || t.select }}
           </span>
         </UButton>
         <template #content>

package/dist/runtime/middleware/abracadabra-auth.d.ts

@@ -1,2 +1,2 @@
-declare const _default: any;
+declare const _default: import("#app").RouteMiddleware;
 export default _default;

package/dist/runtime/plugin-abracadabra.client.d.ts

@@ -1,4 +1,4 @@
-declare const _default: any;
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
 export default _default;
 declare module '#app' {
     interface NuxtApp {