@abraca/nuxt 0.1.0

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

@@ -0,0 +1,122 @@
+/**
+ * useWindowManager
+ *
+ * Floating window (PiP/panel) management for desktop-like UIs.
+ * Pure Vue reactive state — no CRDT required.
+ * Windows can be opened for any document or content.
+ *
+ * Usage:
+ *   const { windows, openWindow, closeWindow, focusWindow } = useWindowManager()
+ */
+export interface FloatingWindowState {
+    id: string;
+    title: string;
+    icon?: string;
+    docId: string;
+    docType?: string;
+    channelId?: string;
+    provider: any;
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    zIndex: number;
+    isMinimized: boolean;
+    isMaximized: boolean;
+    isFocused: boolean;
+    prevX: number;
+    prevY: number;
+    prevWidth: number;
+    prevHeight: number;
+    minimizeTarget?: {
+        x: number;
+        y: number;
+    };
+    initialTab?: 'editor' | 'chat';
+    meta?: Record<string, any>;
+}
+export declare function useWindowManager(): {
+    windows: import("vue").Reactive<Map<string, FloatingWindowState>>;
+    activeWindows: import("vue").ComputedRef<{
+        id: string;
+        title: string;
+        icon?: string | undefined;
+        docId: string;
+        docType?: string | undefined;
+        channelId?: string | undefined;
+        provider: any;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zIndex: number;
+        isMinimized: boolean;
+        isMaximized: boolean;
+        isFocused: boolean;
+        prevX: number;
+        prevY: number;
+        prevWidth: number;
+        prevHeight: number;
+        minimizeTarget?: {
+            x: number;
+            y: number;
+        } | undefined;
+        initialTab?: "editor" | "chat" | undefined;
+        meta?: Record<string, any> | undefined;
+    }[]>;
+    minimizedWindows: import("vue").ComputedRef<{
+        id: string;
+        title: string;
+        icon?: string | undefined;
+        docId: string;
+        docType?: string | undefined;
+        channelId?: string | undefined;
+        provider: any;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        zIndex: number;
+        isMinimized: boolean;
+        isMaximized: boolean;
+        isFocused: boolean;
+        prevX: number;
+        prevY: number;
+        prevWidth: number;
+        prevHeight: number;
+        minimizeTarget?: {
+            x: number;
+            y: number;
+        } | undefined;
+        initialTab?: "editor" | "chat" | undefined;
+        meta?: Record<string, any> | undefined;
+    }[]>;
+    openWindow: (opts: {
+        id: string;
+        title: string;
+        icon?: string;
+        docId: string;
+        docType?: string;
+        channelId?: string;
+        provider?: any;
+        width?: number;
+        height?: number;
+        spawnX?: number;
+        spawnY?: number;
+        initialX?: number;
+        initialY?: number;
+        initialTab?: "editor" | "chat";
+        meta?: Record<string, any>;
+    }) => void;
+    closeWindow: (id: string) => void;
+    closeAll: () => void;
+    focusWindow: (id: string) => void;
+    minimizeWindow: (id: string, target?: {
+        x: number;
+        y: number;
+    }) => void;
+    restoreWindow: (id: string) => void;
+    toggleMaximize: (id: string) => void;
+    moveWindow: (id: string, x: number, y: number) => void;
+    resizeWindow: (id: string, width: number, height: number, x?: number, y?: number) => void;
+};

package/dist/runtime/composables/useWindowManager.js

@@ -0,0 +1,141 @@
+import { reactive, ref, computed } from "vue";
+const windows = reactive(/* @__PURE__ */ new Map());
+const topZIndex = ref(30);
+let cascadeOffset = 0;
+export function useWindowManager() {
+  function bringToFront(id) {
+    const win = windows.get(id);
+    if (!win) return;
+    topZIndex.value++;
+    win.zIndex = topZIndex.value;
+  }
+  function focusWindow(id) {
+    for (const [wid, win] of windows) {
+      win.isFocused = wid === id;
+    }
+    bringToFront(id);
+  }
+  function openWindow(opts) {
+    if (windows.has(opts.id)) {
+      const win = windows.get(opts.id);
+      if (win.isMinimized) win.isMinimized = false;
+      focusWindow(opts.id);
+      return;
+    }
+    const width = opts.width ?? 700;
+    const height = opts.height ?? 500;
+    let x, y;
+    if (opts.initialX !== void 0 && opts.initialY !== void 0) {
+      x = opts.initialX;
+      y = opts.initialY;
+    } else if (opts.spawnX !== void 0 && opts.spawnY !== void 0) {
+      x = Math.min(opts.spawnX + 16, window.innerWidth - width - 20);
+      y = Math.min(Math.max(opts.spawnY - height / 2, 20), window.innerHeight - height - 20);
+    } else {
+      const offset = cascadeOffset * 30;
+      cascadeOffset = (cascadeOffset + 1) % 10;
+      x = Math.min(100 + offset, window.innerWidth - width - 20);
+      y = Math.min(80 + offset, window.innerHeight - height - 20);
+    }
+    topZIndex.value++;
+    for (const win of windows.values()) win.isFocused = false;
+    windows.set(opts.id, {
+      id: opts.id,
+      title: opts.title,
+      icon: opts.icon,
+      docId: opts.docId,
+      docType: opts.docType,
+      channelId: opts.channelId,
+      provider: opts.provider ?? null,
+      x,
+      y,
+      width,
+      height,
+      zIndex: topZIndex.value,
+      isMinimized: false,
+      isMaximized: false,
+      isFocused: true,
+      prevX: x,
+      prevY: y,
+      prevWidth: width,
+      prevHeight: height,
+      initialTab: opts.initialTab,
+      meta: opts.meta
+    });
+  }
+  function closeWindow(id) {
+    windows.delete(id);
+  }
+  function closeAll() {
+    windows.clear();
+  }
+  function minimizeWindow(id, target) {
+    const win = windows.get(id);
+    if (!win) return;
+    win.isMinimized = true;
+    win.isFocused = false;
+    if (target) win.minimizeTarget = target;
+  }
+  function restoreWindow(id) {
+    const win = windows.get(id);
+    if (!win) return;
+    win.isMinimized = false;
+    focusWindow(id);
+  }
+  function toggleMaximize(id) {
+    const win = windows.get(id);
+    if (!win) return;
+    if (win.isMaximized) {
+      win.x = win.prevX;
+      win.y = win.prevY;
+      win.width = win.prevWidth;
+      win.height = win.prevHeight;
+      win.isMaximized = false;
+    } else {
+      win.prevX = win.x;
+      win.prevY = win.y;
+      win.prevWidth = win.width;
+      win.prevHeight = win.height;
+      win.x = 0;
+      win.y = 0;
+      win.width = window.innerWidth;
+      win.height = window.innerHeight;
+      win.isMaximized = true;
+    }
+    focusWindow(id);
+  }
+  function moveWindow(id, x, y) {
+    const win = windows.get(id);
+    if (!win || win.isMaximized) return;
+    win.x = x;
+    win.y = y;
+  }
+  function resizeWindow(id, width, height, x, y) {
+    const win = windows.get(id);
+    if (!win || win.isMaximized) return;
+    win.width = Math.max(width, 300);
+    win.height = Math.max(height, 200);
+    if (x !== void 0) win.x = x;
+    if (y !== void 0) win.y = y;
+  }
+  const activeWindows = computed(
+    () => [...windows.values()].filter((w) => !w.isMinimized).sort((a, b) => a.zIndex - b.zIndex)
+  );
+  const minimizedWindows = computed(
+    () => [...windows.values()].filter((w) => w.isMinimized)
+  );
+  return {
+    windows,
+    activeWindows,
+    minimizedWindows,
+    openWindow,
+    closeWindow,
+    closeAll,
+    focusWindow,
+    minimizeWindow,
+    restoreWindow,
+    toggleMaximize,
+    moveWindow,
+    resizeWindow
+  };
+}

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

@@ -0,0 +1,142 @@
+/**
+ * Y.js reactive primitives for Vue 3.
+ *
+ * IMPORTANT: All `doc` and `provider` parameters must be ShallowRef.
+ * Never pass plain refs or reactive() wrappers — Vue's deep proxy breaks Yjs internals.
+ *
+ * Ported from cou-sh/app/composables/useYDoc.ts with minor cleanup.
+ * Three.js multiplayer utilities (useMultiplayerObject, useSmoothedCursors) are
+ * included for parity but require Three.js in the consuming app.
+ */
+import { type Ref, type ShallowRef } from 'vue';
+import type * as Y from 'yjs';
+export interface AwarenessUser {
+    clientId: number;
+    user?: {
+        name?: string;
+        color?: string;
+        avatar?: string;
+    };
+    [key: string]: any;
+}
+export declare function useSyncedMap<T = any>(doc: ShallowRef<Y.Doc | null>, mapName: string): {
+    data: Record<string, T>;
+    lastUpdateLocal: ShallowRef<boolean, boolean>;
+    set: (key: string, value: T) => T | undefined;
+    remove: (key: string) => void | undefined;
+    clear: () => void | undefined;
+    get: (key: string) => T | undefined;
+    yMap: import("vue").ComputedRef<Y.Map<T> | null>;
+};
+export declare function useSyncedArray<T = any>(doc: ShallowRef<Y.Doc | null>, arrayName: string): {
+    list: Ref<T[], T[]>;
+    push: (item: T) => void | undefined;
+    unshift: (item: T) => void | undefined;
+    insert: (index: number, items: T[]) => void | undefined;
+    deleteAt: (index: number, length?: number) => void | undefined;
+    replace: (index: number, item: T) => void;
+    yArray: import("vue").ComputedRef<Y.Array<T> | null>;
+};
+export declare function useSyncedText(doc: ShallowRef<Y.Doc | null>, textName: string): {
+    text: Ref<string, string>;
+    insert: (index: number, content: string, attrs?: Record<string, any>) => void | undefined;
+    delete: (index: number, length: number) => void | undefined;
+    format: (index: number, length: number, attrs: Record<string, any>) => void | undefined;
+    yText: import("vue").ComputedRef<Y.Text | null>;
+};
+export declare function useSyncedXml(doc: ShallowRef<Y.Doc | null>, xmlName: string): {
+    yXml: ShallowRef<Y.XmlFragment | null, Y.XmlFragment | null>;
+};
+export declare function useAwarenessOf(provider: ShallowRef<{
+    awareness: any;
+} | null>): {
+    states: Ref<{
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    }[], AwarenessUser[] | {
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    }[]>;
+    currentUser: Ref<{
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    } | null, AwarenessUser | {
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    } | null>;
+    setLocalState: (state: any) => void;
+};
+export declare function useSmoothedCursors(provider: ShallowRef<{
+    awareness: any;
+} | null>, posKey?: string, lerpFactor?: number): {
+    cursors: Ref<{
+        clientId: number;
+        x: number;
+        y: number;
+        state: {
+            [x: string]: any;
+            clientId: number;
+            user?: {
+                name?: string | undefined;
+                color?: string | undefined;
+                avatar?: string | undefined;
+            } | undefined;
+        };
+    }[], {
+        clientId: number;
+        x: number;
+        y: number;
+        state: AwarenessUser;
+    }[] | {
+        clientId: number;
+        x: number;
+        y: number;
+        state: {
+            [x: string]: any;
+            clientId: number;
+            user?: {
+                name?: string | undefined;
+                color?: string | undefined;
+                avatar?: string | undefined;
+            } | undefined;
+        };
+    }[]>;
+    states: Ref<{
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    }[], AwarenessUser[] | {
+        [x: string]: any;
+        clientId: number;
+        user?: {
+            name?: string | undefined;
+            color?: string | undefined;
+            avatar?: string | undefined;
+        } | undefined;
+    }[]>;
+    setLocalState: (state: any) => void;
+};

package/dist/runtime/composables/useYDoc.js

@@ -0,0 +1,172 @@
+import {
+  reactive,
+  ref,
+  shallowRef,
+  computed,
+  watch,
+  onMounted,
+  onBeforeUnmount
+} from "vue";
+export function useSyncedMap(doc, mapName) {
+  const state = reactive({});
+  const ymap = shallowRef(null);
+  const lastUpdateLocal = shallowRef(true);
+  const observer = (event) => {
+    lastUpdateLocal.value = event.transaction.local;
+    event.keysChanged.forEach((key) => {
+      if (ymap.value.has(key)) state[key] = ymap.value.get(key);
+      else delete state[key];
+    });
+  };
+  const init = (newDoc) => {
+    if (ymap.value) ymap.value.unobserve(observer);
+    ymap.value = newDoc.getMap(mapName);
+    for (const key in state) delete state[key];
+    ymap.value.forEach((value, key) => {
+      state[key] = value;
+    });
+    ymap.value.observe(observer);
+  };
+  watch(doc, (d) => d && init(d), { immediate: true });
+  onBeforeUnmount(() => {
+    if (ymap.value) ymap.value.unobserve(observer);
+  });
+  return {
+    data: state,
+    lastUpdateLocal,
+    set: (key, value) => ymap.value?.set(key, value),
+    remove: (key) => ymap.value?.delete(key),
+    clear: () => ymap.value?.clear(),
+    get: (key) => ymap.value?.get(key),
+    yMap: computed(() => ymap.value)
+  };
+}
+export function useSyncedArray(doc, arrayName) {
+  const list = ref([]);
+  const yarray = shallowRef(null);
+  const observer = (event) => {
+    let index = 0;
+    event.delta.forEach((op) => {
+      if (op.retain) {
+        index += op.retain;
+      } else if (op.insert) {
+        const items = op.insert;
+        list.value.splice(index, 0, ...items);
+        index += items.length;
+      } else if (op.delete) {
+        list.value.splice(index, op.delete);
+      }
+    });
+  };
+  const init = (newDoc) => {
+    if (yarray.value) yarray.value.unobserve(observer);
+    yarray.value = newDoc.getArray(arrayName);
+    list.value = yarray.value.toArray();
+    yarray.value.observe(observer);
+  };
+  watch(doc, (d) => d && init(d), { immediate: true });
+  onBeforeUnmount(() => {
+    if (yarray.value) yarray.value.unobserve(observer);
+  });
+  return {
+    list,
+    push: (item) => yarray.value?.push([item]),
+    unshift: (item) => yarray.value?.insert(0, [item]),
+    insert: (index, items) => yarray.value?.insert(index, items),
+    deleteAt: (index, length = 1) => yarray.value?.delete(index, length),
+    replace: (index, item) => {
+      if (!yarray.value || !doc.value) return;
+      doc.value.transact(() => {
+        yarray.value.delete(index, 1);
+        yarray.value.insert(index, [item]);
+      });
+    },
+    yArray: computed(() => yarray.value)
+  };
+}
+export function useSyncedText(doc, textName) {
+  const text = ref("");
+  const ytext = shallowRef(null);
+  const observer = () => {
+    text.value = ytext.value.toString();
+  };
+  const init = (newDoc) => {
+    if (ytext.value) ytext.value.unobserve(observer);
+    ytext.value = newDoc.getText(textName);
+    text.value = ytext.value.toString();
+    ytext.value.observe(observer);
+  };
+  watch(doc, (d) => d && init(d), { immediate: true });
+  onBeforeUnmount(() => {
+    if (ytext.value) ytext.value.unobserve(observer);
+  });
+  return {
+    text,
+    insert: (index, content, attrs) => ytext.value?.insert(index, content, attrs),
+    delete: (index, length) => ytext.value?.delete(index, length),
+    format: (index, length, attrs) => ytext.value?.format(index, length, attrs),
+    yText: computed(() => ytext.value)
+  };
+}
+export function useSyncedXml(doc, xmlName) {
+  const yXml = shallowRef(null);
+  watch(doc, (d) => {
+    if (d) yXml.value = d.getXmlFragment(xmlName);
+  }, { immediate: true });
+  return { yXml };
+}
+export function useAwarenessOf(provider) {
+  const states = ref([]);
+  const currentUser = ref(null);
+  const update = () => {
+    if (!provider.value) return;
+    const awareness = provider.value.awareness;
+    states.value = Array.from(awareness.getStates().entries()).map(([id, state]) => ({ clientId: id, ...state }));
+    const local = awareness.getLocalState();
+    if (local) currentUser.value = { clientId: awareness.clientID, ...local };
+  };
+  watch(provider, (p, oldP) => {
+    if (oldP) oldP.awareness.off("change", update);
+    if (p) {
+      p.awareness.on("change", update);
+      update();
+    }
+  }, { immediate: true });
+  const setLocalState = (state) => {
+    if (!provider.value) return;
+    const awareness = provider.value.awareness;
+    const current = awareness.getLocalState() || {};
+    awareness.setLocalState({ ...current, ...state });
+  };
+  return { states, currentUser, setLocalState };
+}
+export function useSmoothedCursors(provider, posKey = "pos", lerpFactor = 0.3) {
+  const { states, setLocalState } = useAwarenessOf(provider);
+  const localId = computed(() => provider.value?.awareness?.clientID ?? 0);
+  const cursors = ref([]);
+  let frame;
+  const tick = () => {
+    const activeIds = /* @__PURE__ */ new Set();
+    for (const s of states.value) {
+      if (s.clientId === localId.value) continue;
+      const pos = s[posKey];
+      if (pos == null) continue;
+      activeIds.add(s.clientId);
+      const entry = cursors.value.find((c) => c.clientId === s.clientId);
+      if (!entry) {
+        cursors.value.push({ clientId: s.clientId, x: pos.x, y: pos.y, state: s });
+      } else {
+        entry.x += (pos.x - entry.x) * lerpFactor;
+        entry.y += (pos.y - entry.y) * lerpFactor;
+        entry.state = s;
+      }
+    }
+    for (let i = cursors.value.length - 1; i >= 0; i--) {
+      if (!activeIds.has(cursors.value[i].clientId)) cursors.value.splice(i, 1);
+    }
+    frame = requestAnimationFrame(tick);
+  };
+  onMounted(() => tick());
+  onBeforeUnmount(() => cancelAnimationFrame(frame));
+  return { cursors, states, setLocalState };
+}

package/dist/runtime/extensions/accordion.d.ts

@@ -0,0 +1,3 @@
+import { Node } from '@tiptap/core';
+export declare const AccordionItem: Node<any, any>;
+export declare const Accordion: Node<any, any>;

package/dist/runtime/extensions/accordion.js

@@ -0,0 +1,49 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import AccordionView from "./views/AccordionView.vue";
+import AccordionItemView from "./views/AccordionItemView.vue";
+export const AccordionItem = Node.create({
+  name: "accordionItem",
+  content: "block+",
+  addAttributes() {
+    return {
+      label: { default: "Item" },
+      icon: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "div[data-accordion-item]",
+        getAttrs: (el) => ({
+          label: el.getAttribute("data-label"),
+          icon: el.getAttribute("data-icon")
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes({
+      "data-accordion-item": "",
+      "data-label": HTMLAttributes.label,
+      "data-icon": HTMLAttributes.icon
+    }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(AccordionItemView);
+  }
+});
+export const Accordion = Node.create({
+  name: "accordion",
+  group: "block",
+  content: "accordionItem+",
+  parseHTML() {
+    return [{ tag: "div[data-accordion]" }];
+  },
+  renderHTML() {
+    return ["div", { "data-accordion": "" }, 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(AccordionView);
+  }
+});

package/dist/runtime/extensions/badge.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const Badge: Node<any, any>;

package/dist/runtime/extensions/badge.js

@@ -0,0 +1,39 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import BadgeView from "./views/BadgeView.vue";
+export const Badge = Node.create({
+  name: "badge",
+  group: "inline",
+  inline: true,
+  atom: true,
+  addAttributes() {
+    return {
+      label: { default: "Badge" },
+      color: { default: "neutral" },
+      variant: { default: "subtle" }
+    };
+  },
+  parseHTML() {
+    return [
+      {
+        tag: "span[data-badge]",
+        getAttrs: (el) => ({
+          label: el.getAttribute("data-label"),
+          color: el.getAttribute("data-color"),
+          variant: el.getAttribute("data-variant")
+        })
+      }
+    ];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes({
+      "data-badge": "",
+      "data-label": HTMLAttributes.label,
+      "data-color": HTMLAttributes.color,
+      "data-variant": HTMLAttributes.variant
+    })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(BadgeView);
+  }
+});

package/dist/runtime/extensions/callout.d.ts

@@ -0,0 +1,2 @@
+import { Node } from '@tiptap/core';
+export declare const Callout: Node<any, any>;