@cou.sh/nuxt 1.0.1

package/dist/runtime/components/widgets/index.js

@@ -0,0 +1,278 @@
+import { Node, mergeAttributes } from "@tiptap/core";
+import { VueNodeViewRenderer } from "@tiptap/vue-3";
+import SwitchWidgetComponent from "./SwitchWidget.vue";
+import CheckboxWidgetComponent from "./CheckboxWidget.vue";
+import ButtonWidgetComponent from "./ButtonWidget.vue";
+import SliderWidgetComponent from "./SliderWidget.vue";
+import ColorPickerWidgetComponent from "./ColorPickerWidget.vue";
+import CalendarWidgetComponent from "./CalendarWidget.vue";
+import InputDateWidgetComponent from "./InputDateWidget.vue";
+import ScrollAreaWidgetComponent from "./ScrollAreaWidget.vue";
+import TabsWidgetComponent from "./TabsWidget.vue";
+import TabPanelWidgetComponent from "./TabPanelWidget.vue";
+import IconWidgetComponent from "./IconWidget.vue";
+export const SwitchWidget = Node.create({
+  name: "switchWidget",
+  group: "inline",
+  inline: true,
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      checked: { default: false },
+      label: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-type="switch-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes(HTMLAttributes, { "data-type": "switch-widget" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(SwitchWidgetComponent);
+  }
+});
+export const CheckboxWidget = Node.create({
+  name: "checkboxWidget",
+  group: "inline",
+  inline: true,
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      checked: { default: false },
+      label: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-type="checkbox-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes(HTMLAttributes, { "data-type": "checkbox-widget" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CheckboxWidgetComponent);
+  }
+});
+export const ButtonWidget = Node.create({
+  name: "buttonWidget",
+  group: "inline",
+  inline: true,
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      label: { default: "Button" },
+      variant: { default: "solid" },
+      color: { default: "primary" },
+      icon: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-type="button-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes(HTMLAttributes, { "data-type": "button-widget" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(ButtonWidgetComponent);
+  }
+});
+export const SliderWidget = Node.create({
+  name: "sliderWidget",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      value: { default: 50 },
+      min: { default: 0 },
+      max: { default: 100 },
+      step: { default: 1 },
+      label: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="slider-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes, { "data-type": "slider-widget" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(SliderWidgetComponent);
+  }
+});
+export const ColorPickerWidget = Node.create({
+  name: "colorPickerWidget",
+  group: "inline",
+  inline: true,
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      color: { default: "#00C16A" },
+      label: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-type="color-picker-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes(HTMLAttributes, { "data-type": "color-picker-widget" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(ColorPickerWidgetComponent);
+  }
+});
+export const CalendarWidget = Node.create({
+  name: "calendarWidget",
+  group: "block",
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      date: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="calendar-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes, { "data-type": "calendar-widget" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(CalendarWidgetComponent);
+  }
+});
+export const InputDateWidget = Node.create({
+  name: "inputDateWidget",
+  group: "inline",
+  inline: true,
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      date: { default: null },
+      label: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-type="input-date-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes(HTMLAttributes, { "data-type": "input-date-widget" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(InputDateWidgetComponent);
+  }
+});
+export const ScrollAreaWidget = Node.create({
+  name: "scrollAreaWidget",
+  group: "block",
+  content: "block+",
+  defining: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      orientation: { default: "vertical" },
+      height: { default: 384 }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="scroll-area-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes, { "data-type": "scroll-area-widget" }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(ScrollAreaWidgetComponent);
+  }
+});
+export const TabPanel = Node.create({
+  name: "tabPanel",
+  group: "tabPanel",
+  content: "block+",
+  defining: true,
+  isolating: true,
+  addAttributes() {
+    return {
+      label: { default: "Tab" },
+      icon: { default: null }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="tab-panel"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes, { "data-type": "tab-panel" }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(TabPanelWidgetComponent);
+  }
+});
+export const TabsWidget = Node.create({
+  name: "tabsWidget",
+  group: "block",
+  content: "tabPanel+",
+  defining: true,
+  draggable: true,
+  addAttributes() {
+    return {};
+  },
+  parseHTML() {
+    return [{ tag: 'div[data-type="tabs-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["div", mergeAttributes(HTMLAttributes, { "data-type": "tabs-widget" }), 0];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(TabsWidgetComponent);
+  }
+});
+export const IconWidget = Node.create({
+  name: "iconWidget",
+  group: "inline",
+  inline: true,
+  atom: true,
+  draggable: true,
+  addAttributes() {
+    return {
+      name: { default: "" }
+    };
+  },
+  parseHTML() {
+    return [{ tag: 'span[data-type="icon-widget"]' }];
+  },
+  renderHTML({ HTMLAttributes }) {
+    return ["span", mergeAttributes(HTMLAttributes, { "data-type": "icon-widget" })];
+  },
+  addNodeView() {
+    return VueNodeViewRenderer(IconWidgetComponent);
+  },
+  addInputRules() {
+    return [
+      {
+        find: /:(i-lucide-[\w-]+):$/,
+        handler: ({ state, range, match }) => {
+          const attrs = { name: match[1] };
+          const { tr } = state;
+          tr.replaceWith(range.from, range.to, this.type.create(attrs));
+        }
+      }
+    ];
+  }
+});
+export const AllWidgets = [
+  SwitchWidget,
+  CheckboxWidget,
+  ButtonWidget,
+  SliderWidget,
+  ColorPickerWidget,
+  CalendarWidget,
+  InputDateWidget,
+  ScrollAreaWidget,
+  TabPanel,
+  TabsWidget,
+  IconWidget
+];

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

@@ -0,0 +1,14 @@
+export { useCollabStatus } from "./useCollabStatus.js";
+export { useEditorCollaboration } from "./useEditorCollaboration.js";
+export type { CollaborationUser, CollaborationOptions } from "./useEditorCollaboration.js";
+export { COLORS, getRandomColor, getRandomName } from "./useEditorCollaboration.js";
+export { useEditorCompletion } from "./useEditorCompletion.js";
+export { useEditorDragHandle } from "./useEditorDragHandle.js";
+export { useEditorEmojis } from "./useEditorEmojis.js";
+export { useEditorMentions } from "./useEditorMentions.js";
+export { useEditorSuggestions } from "./useEditorSuggestions.js";
+export { useEditorToolbar } from "./useEditorToolbar.js";
+export { useLucideIcons } from "./useLucideIcons.js";
+export { useDocumentPermissions } from "./useDocumentPermissions.js";
+export { useSpaces } from "./useSpaces.js";
+export { useOnlineStatus } from "./useOnlineStatus.js";

package/dist/runtime/composables/index.js

@@ -0,0 +1,13 @@
+export { useCollabStatus } from "./useCollabStatus.js";
+export { useEditorCollaboration } from "./useEditorCollaboration.js";
+export { COLORS, getRandomColor, getRandomName } from "./useEditorCollaboration.js";
+export { useEditorCompletion } from "./useEditorCompletion.js";
+export { useEditorDragHandle } from "./useEditorDragHandle.js";
+export { useEditorEmojis } from "./useEditorEmojis.js";
+export { useEditorMentions } from "./useEditorMentions.js";
+export { useEditorSuggestions } from "./useEditorSuggestions.js";
+export { useEditorToolbar } from "./useEditorToolbar.js";
+export { useLucideIcons } from "./useLucideIcons.js";
+export { useDocumentPermissions } from "./useDocumentPermissions.js";
+export { useSpaces } from "./useSpaces.js";
+export { useOnlineStatus } from "./useOnlineStatus.js";

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

@@ -0,0 +1,10 @@
+import { type Ref } from "vue";
+/**
+ * Derives a human-readable status label and color from connection state.
+ * Useful for displaying connection indicators in Nuxt UI components.
+ */
+export declare function useCollabStatus(status: Ref<"disconnected" | "connecting" | "connected">, synced: Ref<boolean>): {
+    label: import("vue").ComputedRef<"Saved" | "Syncing" | "Connecting" | "Offline">;
+    color: import("vue").ComputedRef<"success" | "info" | "warning" | "error">;
+    icon: import("vue").ComputedRef<"i-lucide-cloud-check" | "i-lucide-cloud-upload" | "i-lucide-cloud" | "i-lucide-cloud-off">;
+};

package/dist/runtime/composables/useCollabStatus.js

@@ -0,0 +1,23 @@
+import { computed } from "vue";
+export function useCollabStatus(status, synced) {
+  const label = computed(() => {
+    if (status.value === "connected" && synced.value) return "Saved";
+    if (status.value === "connected") return "Syncing";
+    if (status.value === "connecting") return "Connecting";
+    return "Offline";
+  });
+  const color = computed(() => {
+    if (status.value === "connected" && synced.value) return "success";
+    if (status.value === "connected") return "info";
+    if (status.value === "connecting") return "warning";
+    return "error";
+  });
+  const icon = computed(() => {
+    if (status.value === "connected" && synced.value)
+      return "i-lucide-cloud-check";
+    if (status.value === "connected") return "i-lucide-cloud-upload";
+    if (status.value === "connecting") return "i-lucide-cloud";
+    return "i-lucide-cloud-off";
+  });
+  return { label, color, icon };
+}

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

@@ -0,0 +1,11 @@
+import { type MaybeRef } from "vue";
+export declare function useDocumentPermissions(role: MaybeRef<string | undefined | null>): {
+    role: import("vue").ComputedRef<string>;
+    canRead: import("vue").ComputedRef<boolean>;
+    canWrite: import("vue").ComputedRef<boolean>;
+    canCreate: import("vue").ComputedRef<boolean>;
+    canDelete: import("vue").ComputedRef<boolean>;
+    canUpload: import("vue").ComputedRef<boolean>;
+    canManage: import("vue").ComputedRef<boolean>;
+    meetsRole: (required: string | string[]) => boolean;
+};

package/dist/runtime/composables/useDocumentPermissions.js

@@ -0,0 +1,44 @@
+import { computed, toValue } from "vue";
+const ROLE_HIERARCHY = {
+  owner: 5,
+  admin: 4,
+  member: 3,
+  editor: 2,
+  viewer: 1
+};
+const PERMISSION_MATRIX = {
+  owner: { document: ["create", "read", "update", "delete"], file: ["upload", "read", "delete"] },
+  admin: { document: ["create", "read", "update", "delete"], file: ["upload", "read", "delete"] },
+  member: { document: ["create", "read", "update"], file: ["upload", "read"] },
+  editor: { document: ["read", "update"], file: ["upload", "read"] },
+  viewer: { document: ["read"], file: ["read"] }
+};
+export function useDocumentPermissions(role) {
+  const currentRole = computed(() => toValue(role) || "viewer");
+  const canRead = computed(() => hasPermission(currentRole.value, "document", "read"));
+  const canWrite = computed(() => hasPermission(currentRole.value, "document", "update"));
+  const canCreate = computed(() => hasPermission(currentRole.value, "document", "create"));
+  const canDelete = computed(() => hasPermission(currentRole.value, "document", "delete"));
+  const canUpload = computed(() => hasPermission(currentRole.value, "file", "upload"));
+  const canManage = computed(() => (ROLE_HIERARCHY[currentRole.value] ?? 0) >= (ROLE_HIERARCHY["admin"] ?? Infinity));
+  function hasPermission(roleName, resource, action) {
+    const perms = PERMISSION_MATRIX[roleName];
+    if (!perms) return false;
+    return perms[resource].includes(action);
+  }
+  function meetsRole(required) {
+    const roles = Array.isArray(required) ? required : [required];
+    const userLevel = ROLE_HIERARCHY[currentRole.value] ?? 0;
+    return roles.some((r) => userLevel >= (ROLE_HIERARCHY[r] ?? Infinity));
+  }
+  return {
+    role: currentRole,
+    canRead,
+    canWrite,
+    canCreate,
+    canDelete,
+    canUpload,
+    canManage,
+    meetsRole
+  };
+}

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

@@ -0,0 +1,25 @@
+export interface CollaborationUser {
+    name: string;
+    color: string;
+    avatar?: string;
+}
+export interface CollaborationOptions {
+    spaceId: string;
+    documentId: string;
+    user: CollaborationUser;
+}
+export declare const COLORS: Record<string, string>;
+export declare const getRandomColor: () => string;
+export declare const getRandomName: () => string;
+export declare function useEditorCollaboration(options: CollaborationOptions): {
+    enabled: true;
+    ready: any;
+    status: any;
+    isConnected: any;
+    connectedUsers: any;
+    extensions: any;
+    updateUser: (updates: Partial<CollaborationUser>) => void;
+    doc: any;
+    provider: any;
+    synced: any;
+};

package/dist/runtime/composables/useEditorCollaboration.js

@@ -0,0 +1,141 @@
+import { Collaboration, CollaborationCursor } from "@rgby/collab-core";
+export const COLORS = {
+  red: "#f87171",
+  orange: "#fb923c",
+  amber: "#fbbf24",
+  yellow: "#facc15",
+  lime: "#a3e635",
+  green: "#4ade80",
+  emerald: "#34d399",
+  teal: "#2dd4bf",
+  cyan: "#22d3ee",
+  sky: "#38bdf8",
+  blue: "#60a5fa",
+  indigo: "#818cf8",
+  violet: "#a78bfa",
+  purple: "#c084fc",
+  fuchsia: "#e879f9",
+  pink: "#f472b6",
+  rose: "#fb7185"
+};
+const ADJECTIVES = [
+  "Swift",
+  "Clever",
+  "Bright",
+  "Quick",
+  "Sharp",
+  "Bold",
+  "Calm",
+  "Kind",
+  "Brave",
+  "Wise",
+  "Noble",
+  "Mighty",
+  "Gentle",
+  "Fierce",
+  "Silent",
+  "Wild",
+  "Golden",
+  "Silver",
+  "Cosmic",
+  "Lucky",
+  "Mystic",
+  "Stellar",
+  "Radiant",
+  "Daring"
+];
+const ANIMALS = [
+  "Fox",
+  "Owl",
+  "Bear",
+  "Wolf",
+  "Eagle",
+  "Hawk",
+  "Lion",
+  "Tiger",
+  "Falcon",
+  "Panther",
+  "Dolphin",
+  "Phoenix",
+  "Dragon",
+  "Raven",
+  "Lynx",
+  "Otter",
+  "Stag",
+  "Cobra",
+  "Jaguar",
+  "Crane",
+  "Badger",
+  "Viper",
+  "Condor",
+  "Gazelle"
+];
+export const getRandomColor = () => {
+  const keys = Object.keys(COLORS);
+  return keys[Math.floor(Math.random() * keys.length)];
+};
+export const getRandomName = () => `${ADJECTIVES[Math.floor(Math.random() * ADJECTIVES.length)]} ${ANIMALS[Math.floor(Math.random() * ANIMALS.length)]}`;
+export function useEditorCollaboration(options) {
+  const { spaceId, documentId, user } = options;
+  const {
+    doc,
+    provider,
+    status,
+    synced,
+    users: rawUsers,
+    updatePresence,
+    me
+  } = useCollaborativeDocument(spaceId, documentId);
+  const isConnected = computed(() => status.value === "connected");
+  const ready = computed(() => !!doc.value && !!provider.value);
+  watch(() => isConnected.value, (connected) => {
+    if (connected) {
+      updatePresence({
+        user: {
+          name: user.name,
+          color: user.color,
+          avatar: user.avatar
+        }
+      });
+    }
+  }, { immediate: true });
+  const connectedUsers = computed(() => {
+    return rawUsers.value.filter((u) => u.user).map((u) => ({
+      ...u.user,
+      // Ensure name and color exist, fallback if needed
+      name: u.user.name || "Anonymous",
+      color: u.user.color || "#ccc"
+    }));
+  });
+  const extensions = computed(() => {
+    if (!doc.value || !provider.value) return [];
+    return [
+      Collaboration.configure({
+        document: doc.value
+      }),
+      CollaborationCursor.configure({
+        provider: provider.value,
+        user: {
+          name: user.name,
+          color: user.color
+        }
+      })
+    ];
+  });
+  return {
+    enabled: true,
+    ready,
+    status,
+    isConnected,
+    connectedUsers,
+    extensions,
+    // Helper to update local user if needed
+    updateUser: (updates) => {
+      updatePresence({ user: { ...user, ...updates } });
+    },
+    // Expose raw values if needed by other components
+    doc,
+    provider,
+    synced
+  };
+}

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

@@ -0,0 +1,60 @@
+import type { Editor } from '@tiptap/vue-3';
+interface UseEditorCompletionOptions {
+    api?: string;
+}
+export declare function useEditorCompletion(_editorRef: Ref<{
+    editor: Editor | undefined;
+} | null | undefined>, _options?: UseEditorCompletionOptions): {
+    extension: import("@tiptap/core").Extension<import("../components/editor/CompletionExtension.js").CompletionOptions, import("../components/editor/CompletionExtension.js").CompletionStorage>;
+    handlers: {
+        aiContinue: {
+            canExecute: () => boolean;
+            execute: () => undefined;
+            isActive: () => boolean;
+            isDisabled: () => boolean;
+        };
+        aiFix: {
+            canExecute: () => boolean;
+            execute: () => undefined;
+            isActive: () => boolean;
+            isDisabled: () => boolean;
+        };
+        aiExtend: {
+            canExecute: () => boolean;
+            execute: () => undefined;
+            isActive: () => boolean;
+            isDisabled: () => boolean;
+        };
+        aiReduce: {
+            canExecute: () => boolean;
+            execute: () => undefined;
+            isActive: () => boolean;
+            isDisabled: () => boolean;
+        };
+        aiSimplify: {
+            canExecute: () => boolean;
+            execute: () => undefined;
+            isActive: () => boolean;
+            isDisabled: () => boolean;
+        };
+        aiSummarize: {
+            canExecute: () => boolean;
+            execute: () => undefined;
+            isActive: () => boolean;
+            isDisabled: () => boolean;
+        };
+        aiTranslate: {
+            canExecute: () => boolean;
+            execute: () => undefined;
+            isActive: () => boolean;
+            isDisabled: () => boolean;
+        };
+    };
+    isLoading: any;
+    mode: any;
+    completion: any;
+    complete: () => void;
+    stop: () => void;
+    setCompletion: () => void;
+};
+export {};

package/dist/runtime/composables/useEditorCompletion.js

@@ -0,0 +1,42 @@
+import { Completion } from "../components/editor/CompletionExtension.js";
+export function useEditorCompletion(_editorRef, _options = {}) {
+  const isLoading = ref(false);
+  const mode = ref("continue");
+  const completion = ref("");
+  const extension = Completion.configure({
+    onTrigger: () => {
+    },
+    onAccept: () => {
+    },
+    onDismiss: () => {
+    }
+  });
+  const handlers = {
+    aiContinue: {
+      canExecute: () => false,
+      execute: () => void 0,
+      isActive: () => false,
+      isDisabled: () => true
+    },
+    aiFix: { canExecute: () => false, execute: () => void 0, isActive: () => false, isDisabled: () => true },
+    aiExtend: { canExecute: () => false, execute: () => void 0, isActive: () => false, isDisabled: () => true },
+    aiReduce: { canExecute: () => false, execute: () => void 0, isActive: () => false, isDisabled: () => true },
+    aiSimplify: { canExecute: () => false, execute: () => void 0, isActive: () => false, isDisabled: () => true },
+    aiSummarize: { canExecute: () => false, execute: () => void 0, isActive: () => false, isDisabled: () => true },
+    aiTranslate: { canExecute: () => false, execute: () => void 0, isActive: () => false, isDisabled: () => true }
+  };
+  return {
+    extension,
+    handlers,
+    isLoading,
+    mode,
+    completion,
+    // Add missing exports that might be expected by the component
+    complete: () => {
+    },
+    stop: () => {
+    },
+    setCompletion: () => {
+    }
+  };
+}

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

@@ -0,0 +1,10 @@
+import type { DropdownMenuItem, EditorCustomHandlers } from '@nuxt/ui';
+import type { Editor, JSONContent } from '@tiptap/vue-3';
+export declare function useEditorDragHandle<T extends EditorCustomHandlers>(customHandlers?: T): {
+    selectedNode: any;
+    getItems: (editor: Editor) => DropdownMenuItem[][];
+    onNodeChange: (event: {
+        node: JSONContent | null;
+        pos: number;
+    }) => void;
+};