@abraca/nuxt 2.0.0 → 2.0.3

package/dist/runtime/components/renderers/calendar/ACalendarToolbar.vue.d.ts

@@ -20,16 +20,16 @@ type __VLS_Props = {
     };
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    next: () => any;
-    prev: () => any;
     "update:viewMode": (mode: CalendarViewMode) => any;
+    prev: () => any;
+    next: () => any;
     today: () => any;
     "add-event": () => any;
     "navigate-to-month": (year: number, month: number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onNext?: (() => any) | undefined;
-    onPrev?: (() => any) | undefined;
     "onUpdate:viewMode"?: ((mode: CalendarViewMode) => any) | undefined;
+    onPrev?: (() => any) | undefined;
+    onNext?: (() => any) | undefined;
     onToday?: (() => any) | undefined;
     "onAdd-event"?: (() => any) | undefined;
     "onNavigate-to-month"?: ((year: number, month: number) => any) | undefined;

package/dist/runtime/components/renderers/media/MediaTransportBar.d.vue.ts

@@ -8,13 +8,13 @@ type __VLS_Props = {
     isLoading: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    next: () => any;
     prev: () => any;
+    next: () => any;
     togglePlay: () => any;
     seek: (position: number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onNext?: (() => any) | undefined;
     onPrev?: (() => any) | undefined;
+    onNext?: (() => any) | undefined;
     onTogglePlay?: (() => any) | undefined;
     onSeek?: ((position: number) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/renderers/media/MediaTransportBar.vue.d.ts

@@ -8,13 +8,13 @@ type __VLS_Props = {
     isLoading: boolean;
 };
 declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
-    next: () => any;
     prev: () => any;
+    next: () => any;
     togglePlay: () => any;
     seek: (position: number) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
-    onNext?: (() => any) | undefined;
     onPrev?: (() => any) | undefined;
+    onNext?: (() => any) | undefined;
     onTogglePlay?: (() => any) | undefined;
     onSeek?: ((position: number) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/shell/AUserProfilePopover.d.vue.ts

@@ -39,8 +39,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     currentDocId: string | null;
     avatarStyle: string;
     isSelf: boolean;
-    showFollow: boolean;
     isFollowing: boolean;
+    showFollow: boolean;
     currentDocLabel: string | null;
     currentDocIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/components/shell/AUserProfilePopover.vue.d.ts

@@ -39,8 +39,8 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_Props, {}, {}, {},
     currentDocId: string | null;
     avatarStyle: string;
     isSelf: boolean;
-    showFollow: boolean;
     isFollowing: boolean;
+    showFollow: boolean;
     currentDocLabel: string | null;
     currentDocIcon: string;
 }, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;

package/dist/runtime/composables/useAAField.js

@@ -2,7 +2,7 @@ import { computed, isRef, onScopeDispose, ref } from "vue";
 import { useAwareness } from "./useAwareness.js";
 import { useAwarenessPeers } from "./useAwarenessPeers.js";
 export function useAAField(key) {
-  const { setField } = useAwareness();
+  const { setField, localState } = useAwareness();
   const { peers } = useAwarenessPeers();
   const fieldKey = computed(
     () => typeof key === "function" ? key() : isRef(key) ? key.value : key
@@ -38,7 +38,8 @@ export function useAAField(key) {
     setField("hover", fieldKey.value);
   }
   function onMouseleave() {
-    setField("hover", null);
+    const current = localState.value?.hover;
+    if (current === fieldKey.value) setField("hover", null);
   }
   function onMousedown() {
     localPress.value = true;
@@ -46,13 +47,15 @@ export function useAAField(key) {
   }
   function onMouseup() {
     localPress.value = false;
-    setField("press", null);
+    const current = localState.value?.press;
+    if (current === fieldKey.value) setField("press", null);
   }
   function onFocus() {
     setField("focus", fieldKey.value);
   }
   function onBlur() {
-    setField("focus", null);
+    const current = localState.value?.focus;
+    if (current === fieldKey.value) setField("focus", null);
   }
   const isPressed = computed(() => localPress.value || pressers.value.length > 0);
   const handlers = {

package/dist/runtime/composables/useAAFocus.js

@@ -97,12 +97,17 @@ export function useAAFocus() {
     const candidates = document.elementsFromPoint(clientX, clientY);
     for (const el of candidates) {
       if (!isAnchorable(el)) continue;
-      const path = pathFromElement(el);
-      if (!path) continue;
-      const r = el.getBoundingClientRect();
-      return { elementPath: path, dx: clientX - r.left, dy: clientY - r.top };
+      const path2 = pathFromElement(el);
+      if (!path2) continue;
+      const r2 = el.getBoundingClientRect();
+      return { elementPath: path2, dx: clientX - r2.left, dy: clientY - r2.top };
     }
-    return null;
+    const picked = pickAnchorElement();
+    if (!picked) return null;
+    const path = pathFromElement(picked.el);
+    if (!path) return null;
+    const r = picked.el.getBoundingClientRect();
+    return { elementPath: path, dx: clientX - r.left, dy: clientY - r.top };
   }
   function snapshot() {
     cancelAnimationFrame(raf);

package/dist/runtime/composables/useAAFollowAnchor.js

@@ -1,4 +1,4 @@
-import { computed, watch } from "vue";
+import { computed, onScopeDispose, watch } from "vue";
 import { useRoute, useRouter } from "#imports";
 import { useAAEphemeral } from "./useAAEphemeral.js";
 import { useAwarenessPeers } from "./useAwarenessPeers.js";
@@ -8,8 +8,11 @@ export function useAAFollowAnchor(leaderId) {
   const { peers: allPeers } = useAwarenessPeers();
   const route = useRoute();
   const router = useRouter();
+  const scrollState = /* @__PURE__ */ new Map();
   let scrollRaf = 0;
-  let lastTargetKey = "";
+  const LERP = 0.18;
+  const SETTLE_PX = 0.5;
+  const MIN_DELTA_PX = 4;
   const leaderPayload = computed(() => {
     const id = leaderId.value;
     if (id == null) return null;
@@ -23,43 +26,74 @@ export function useAAFollowAnchor(leaderId) {
       });
     }
   }, { immediate: true });
-  function scrollToLeader() {
-    cancelAnimationFrame(scrollRaf);
-    scrollRaf = requestAnimationFrame(() => {
-      const payload = leaderPayload.value;
-      if (!payload) return;
-      if (payload.route !== route.path) return;
-      const instructions = [];
-      if (payload.scrollers && payload.scrollers.length) {
-        for (const s of payload.scrollers) {
-          instructions.push({ container: s.containerPath, element: s.elementPath, ratio: s.ratio });
+  function ensureRaf() {
+    if (scrollRaf) return;
+    const tick = () => {
+      let stillMoving = false;
+      for (const [scroller, s] of scrollState) {
+        const delta = s.target - s.current;
+        if (Math.abs(delta) < SETTLE_PX) {
+          if (scroller === window) window.scrollTo({ top: s.target, behavior: "auto" });
+          else scroller.scrollTo({ top: s.target, behavior: "auto" });
+          scrollState.delete(scroller);
+          continue;
         }
-      } else if (payload.kind === "anchor" && payload.anchor) {
-        instructions.push({ element: payload.anchor.elementPath, ratio: payload.anchorRatio ?? 0.05 });
-      } else if (payload.kind === "selection" && payload.start) {
-        instructions.push({ element: payload.start.elementPath, ratio: 0.2 });
+        stillMoving = true;
+        s.current += delta * LERP;
+        if (scroller === window) window.scrollTo({ top: s.current, behavior: "auto" });
+        else scroller.scrollTo({ top: s.current, behavior: "auto" });
       }
-      const fingerprint = [];
-      for (const ins of instructions) {
-        const target = elementFromPath(ins.element);
-        if (!target || !target.isConnected) continue;
-        const scroller = ins.container ? elementFromPath(ins.container) ?? window : window;
-        const isWindow = scroller === window;
-        const scrollerRect = isWindow ? { top: 0, height: window.innerHeight || document.documentElement.clientHeight } : scroller.getBoundingClientRect();
-        const desiredTop = scrollerRect.top + scrollerRect.height * Math.max(0, Math.min(0.9, ins.ratio));
-        const rect = target.getBoundingClientRect();
-        const delta = rect.top - desiredTop;
-        fingerprint.push(`${isWindow ? "w" : ins.container?.join(",")}-${Math.round(rect.top)}-${ins.ratio.toFixed(3)}`);
-        if (Math.abs(delta) < 8) continue;
-        if (isWindow) window.scrollBy({ top: delta, behavior: "smooth" });
-        else scroller.scrollBy({ top: delta, behavior: "smooth" });
+      scrollRaf = stillMoving ? requestAnimationFrame(tick) : 0;
+    };
+    scrollRaf = requestAnimationFrame(tick);
+  }
+  function scrollToLeader() {
+    const payload = leaderPayload.value;
+    if (!payload) return;
+    if (payload.route !== route.path) return;
+    const instructions = [];
+    if (payload.scrollers && payload.scrollers.length) {
+      for (const s of payload.scrollers) {
+        instructions.push({ container: s.containerPath, element: s.elementPath, ratio: s.ratio });
       }
-      const key = fingerprint.join("|");
-      if (key === lastTargetKey) return;
-      lastTargetKey = key;
-    });
+    } else if (payload.kind === "anchor" && payload.anchor) {
+      instructions.push({ element: payload.anchor.elementPath, ratio: payload.anchorRatio ?? 0.05 });
+    } else if (payload.kind === "selection" && payload.start) {
+      instructions.push({ element: payload.start.elementPath, ratio: 0.2 });
+    }
+    let targetsChanged = false;
+    for (const ins of instructions) {
+      const target = elementFromPath(ins.element);
+      if (!target || !target.isConnected) continue;
+      const scroller = ins.container ? elementFromPath(ins.container) ?? window : window;
+      const isWindow = scroller === window;
+      const scrollerRect = isWindow ? { top: 0, height: window.innerHeight || document.documentElement.clientHeight } : scroller.getBoundingClientRect();
+      const desiredTop = scrollerRect.top + scrollerRect.height * Math.max(0, Math.min(0.9, ins.ratio));
+      const rect = target.getBoundingClientRect();
+      const delta = rect.top - desiredTop;
+      if (Math.abs(delta) < MIN_DELTA_PX) continue;
+      const currentScroll = isWindow ? window.scrollY : scroller.scrollTop;
+      const targetScroll = currentScroll + delta;
+      const existing = scrollState.get(scroller);
+      if (existing) {
+        existing.current = currentScroll;
+        if (Math.abs(existing.target - targetScroll) >= 0.5) {
+          existing.target = targetScroll;
+          targetsChanged = true;
+        }
+      } else {
+        scrollState.set(scroller, { current: currentScroll, target: targetScroll });
+        targetsChanged = true;
+      }
+    }
+    if (targetsChanged) ensureRaf();
   }
   watch(leaderPayload, scrollToLeader, { deep: true, flush: "post" });
+  onScopeDispose(() => {
+    if (scrollRaf) cancelAnimationFrame(scrollRaf);
+    scrollRaf = 0;
+    scrollState.clear();
+  });
   const leader = computed(() => {
     const id = leaderId.value;
     if (id == null) return null;

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

@@ -19,11 +19,14 @@ export interface UseAAFollowPeerOptions {
     onBreak?: () => void;
 }
 export declare function useAAFollowPeer(options?: UseAAFollowPeerOptions): {
-    follow: (clientId: number) => void;
+    follow: (clientIdOrPublicKey: number | string) => void;
     unfollow: () => void;
-    followingClientId: import("vue").Ref<number | null, number | null>;
+    followingClientId: import("vue").ComputedRef<number | null>;
+    followingPublicKey: import("vue").ComputedRef<string | null>;
     followingUser: import("vue").ComputedRef<{
-        name?: string;
-        color?: string;
+        name?: string | undefined;
+        color?: string | undefined;
+        publicKey?: string | undefined;
     } | null>;
+    isFollowing: import("vue").ComputedRef<boolean>;
 };

package/dist/runtime/composables/useAAFollowPeer.js

@@ -2,17 +2,42 @@ import { computed, onScopeDispose, ref, watch } from "vue";
 import { useAbracadabra } from "./useAbracadabra.js";
 import { useSyncedMap } from "./useYDoc.js";
 import { useAwareness } from "./useAwareness.js";
-const _followingClientId = ref(null);
+const _followingPublicKey = ref(null);
+const _followingClientIdFallback = ref(null);
 export function useAAFollowPeer(options = {}) {
   const { doc, provider } = useAbracadabra();
   const { data, set } = useSyncedMap(doc, "aware-ui");
   const { states } = useAwareness();
-  const followingClientId = _followingClientId;
   let unsubInteraction = null;
+  const followingClientId = computed(() => {
+    const pk = _followingPublicKey.value;
+    if (pk) {
+      for (const [cid, st] of states.value.entries()) {
+        const peerPk = st?.user?.publicKey;
+        if (peerPk === pk) return cid;
+      }
+      return null;
+    }
+    return _followingClientIdFallback.value;
+  });
+  const isFollowing = computed(
+    () => _followingPublicKey.value != null || _followingClientIdFallback.value != null
+  );
+  const followingPublicKey = computed(() => _followingPublicKey.value);
+  const followingUserCache = ref(null);
   const followingUser = computed(() => {
-    if (followingClientId.value == null) return null;
-    const state = states.value.get(followingClientId.value);
-    return state?.user ?? null;
+    const cid = followingClientId.value;
+    if (cid != null) {
+      const state = states.value.get(cid);
+      if (state?.user) return state.user;
+    }
+    return followingUserCache.value;
+  });
+  watch(followingUser, (user) => {
+    if (user) followingUserCache.value = { ...user };
+  }, { flush: "post" });
+  watch(isFollowing, (active) => {
+    if (!active) followingUserCache.value = null;
   });
   function detachInteraction() {
     unsubInteraction?.();
@@ -31,14 +56,31 @@ export function useAAFollowPeer(options = {}) {
       window.removeEventListener("wheel", onBreak);
     };
   }
-  function follow(clientId) {
-    if (followingClientId.value === clientId) return;
-    followingClientId.value = clientId;
+  function follow(clientIdOrPublicKey) {
+    if (typeof clientIdOrPublicKey === "string") {
+      if (_followingPublicKey.value === clientIdOrPublicKey) return;
+      _followingPublicKey.value = clientIdOrPublicKey;
+      _followingClientIdFallback.value = null;
+    } else {
+      const cid = clientIdOrPublicKey;
+      const state = states.value.get(cid);
+      const pk = state?.user?.publicKey;
+      if (pk) {
+        if (_followingPublicKey.value === pk) return;
+        _followingPublicKey.value = pk;
+        _followingClientIdFallback.value = null;
+      } else {
+        if (_followingClientIdFallback.value === cid) return;
+        _followingPublicKey.value = null;
+        _followingClientIdFallback.value = cid;
+      }
+    }
     attachInteractionBreaker();
   }
   function unfollow() {
-    if (followingClientId.value == null) return;
-    followingClientId.value = null;
+    if (_followingPublicKey.value == null && _followingClientIdFallback.value == null) return;
+    _followingPublicKey.value = null;
+    _followingClientIdFallback.value = null;
     detachInteraction();
     options.onBreak?.();
   }
@@ -71,5 +113,12 @@ export function useAAFollowPeer(options = {}) {
     }
   });
   onScopeDispose(detachInteraction);
-  return { follow, unfollow, followingClientId, followingUser };
+  return {
+    follow,
+    unfollow,
+    followingClientId,
+    followingPublicKey,
+    followingUser,
+    isFollowing
+  };
 }

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

@@ -6,7 +6,7 @@ import type { MaybeRefOrGetter } from 'vue';
  * scoped container as `peer:viewport:<scope>` ephemeral state.
  *
  * Use case: render "Janis is reading the API section" overlays in long docs.
- * Pair with `<APresenceCursors>` for a complete spatial-presence layer.
+ * Pair with `<APresenceCursors>` for a complete presence layer.
  */
 export interface PeerViewport {
     clientId: number;

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

@@ -21,6 +21,8 @@ export declare function useAbracadabraAuth(): {
     confirmPasswordReset: any;
     changePassword: any;
     setPassword: any;
+    hasPassword: any;
+    refreshHasPassword: any;
     recoverIdentity: any;
     unblockConnection: any;
     setUserName: any;

package/dist/runtime/composables/useAbracadabraAuth.js

@@ -24,6 +24,8 @@ export function useAbracadabraAuth() {
     confirmPasswordReset: abra.confirmPasswordReset,
     changePassword: abra.changePassword,
     setPassword: abra.setPassword,
+    hasPassword: abra.hasPassword,
+    refreshHasPassword: abra.refreshHasPassword,
     recoverIdentity: abra.recoverIdentity,
     unblockConnection: abra.unblockConnection,
     setUserName: abra.setUserName,

package/dist/runtime/composables/useEditorSuggestions.js

@@ -72,7 +72,8 @@ export function useEditorSuggestions(options = {}) {
         ...extEnabled("colorSwatch") ? [{ kind: "colorSwatch", label: "Color Swatch", icon: "i-lucide-palette", description: "Inline color chip with picker", keywords: ["color", "swatch", "token", "palette"] }] : [],
         ...extEnabled("mathBlock") ? [{ kind: "mathBlock", label: "Math (block)", icon: "i-lucide-square-sigma", description: "Display-mode LaTeX equation", keywords: ["katex", "latex", "equation", "formula", "math"] }] : [],
         ...extEnabled("mathInline") ? [{ kind: "mathInline", label: "Math (inline)", icon: "i-lucide-sigma", description: "Inline LaTeX expression", keywords: ["katex", "latex", "inline math"] }] : [],
-        ...extEnabled("diff") ? [{ kind: "diff", label: "Diff", icon: "i-lucide-git-compare", description: "Side-by-side text diff", keywords: ["compare", "changes", "git"] }] : []
+        ...extEnabled("diff") ? [{ kind: "diff", label: "Diff", icon: "i-lucide-git-compare", description: "Side-by-side text diff", keywords: ["compare", "changes", "git"] }] : [],
+        ...extEnabled("svgEmbed") ? [{ kind: "svgEmbed", label: "SVG embed", icon: "i-lucide-image", description: "Inline SVG (sanitized)", keywords: ["svg", "vector", "icon", "diagram"] }] : []
       ]
     ];
     try {

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

@@ -1,33 +1,47 @@
-/**
- * useEmailVerification
- *
- * Wraps the email-verification half of the auth lifecycle.
- * - `request()` triggers a verification email (rate-limited 1/min, 10/day).
- * - `confirm(token)` consumes the token from the email link; no auth needed.
- *
- * `verified` mirrors the most recent local result of `confirm()` — the
- * server doesn't currently expose `email_verified_at` on `getMe()`, so
- * the canonical signal is "did `confirm()` succeed in this session".
- *
- * Usage:
- *   const { verified, isRequesting, isConfirming, error, request, confirm } = useEmailVerification()
- */
-declare function request(): Promise<void>;
-declare function confirm(token: string): Promise<void>;
+/** Known error codes raised by `useEmailVerification()` actions. */
+export type EmailVerificationErrorCode = 'rate_limited' | 'token_expired' | 'token_invalid' | 'verification_disabled' | 'already_verified' | 'email_not_set' | 'unauthorized' | 'forbidden' | 'network_error' | 'server_error' | 'unknown';
+export interface EmailVerificationError {
+    code: EmailVerificationErrorCode;
+    message: string;
+    status?: number;
+    retryAfterSeconds?: number;
+}
+export type EmailVerificationAction = 'request' | 'confirm';
+export interface EmailVerificationResult {
+    ok: boolean;
+    error?: EmailVerificationError;
+}
+declare function classifyError(err: unknown): EmailVerificationError;
 export declare function useEmailVerification(): {
-    /** True after a successful `confirm()` in the current session. */
+    /** True after a successful `confirm()` in this session. */
     verified: import("vue").Ref<boolean, boolean>;
-    /** Whether a `request()` is in flight. */
-    isRequesting: import("vue").Ref<boolean, boolean>;
-    /** Whether a `confirm()` is in flight. */
-    isConfirming: import("vue").Ref<boolean, boolean>;
-    /** Last error message, or null. */
-    error: import("vue").Ref<string | null, string | null>;
     /** Epoch ms of the last successful `request()`, or null. */
     lastSentAt: import("vue").Ref<number | null, number | null>;
-    /** Send a verification email to the current user. Requires auth. */
-    request: typeof request;
+    /** Currently-running action, or null. */
+    busy: import("vue").Ref<EmailVerificationAction | null, EmailVerificationAction | null>;
+    /** Most recent typed error, or null. Cleared at the start of every action. */
+    error: import("vue").Ref<{
+        code: EmailVerificationErrorCode;
+        message: string;
+        status?: number | undefined;
+        retryAfterSeconds?: number | undefined;
+    } | null, EmailVerificationError | {
+        code: EmailVerificationErrorCode;
+        message: string;
+        status?: number | undefined;
+        retryAfterSeconds?: number | undefined;
+    } | null>;
+    /** Most recent successful action, or null. */
+    lastSuccess: import("vue").Ref<EmailVerificationAction | null, EmailVerificationAction | null>;
+    /** Wipe `error` without re-running anything. */
+    clearError: () => void;
+    /** Send a verification email to the current user. Auth required. */
+    request: () => Promise<EmailVerificationResult>;
     /** Confirm a verification token from the email link. No auth required. */
-    confirm: typeof confirm;
+    confirm: (opts: {
+        token: string;
+    }) => Promise<EmailVerificationResult>;
+    /** Internal helper exposed for testing. */
+    _classifyError: typeof classifyError;
 };
 export {};