@autumnsgrove/groveengine 0.3.2 → 0.4.0

package/dist/components/admin/MarkdownEditor.svelte.d.ts

@@ -6,10 +6,7 @@ type MarkdownEditor = {
     getAvailableAnchors: () => string[];
     insertAnchor: (name: any) => void;
     clearDraft: () => void;
-    getDraftStatus: () => {
-        hasDraft: boolean;
-        storedDraft: null;
-    };
+    getDraftStatus: () => any;
 };
 declare const MarkdownEditor: import("svelte").Component<{
     content?: string;
@@ -25,10 +22,7 @@ declare const MarkdownEditor: import("svelte").Component<{
     getAvailableAnchors: () => string[];
     insertAnchor: (name: any) => void;
     clearDraft: () => void;
-    getDraftStatus: () => {
-        hasDraft: boolean;
-        storedDraft: null;
-    };
+    getDraftStatus: () => any;
 }, "content">;
 type $$ComponentProps = {
     content?: string;

package/dist/components/admin/composables/index.d.ts

@@ -0,0 +1,7 @@
+export { useSnippets } from "./useSnippets.svelte.js";
+export { useDraftManager } from "./useDraftManager.svelte.js";
+export { useWritingSession } from "./useWritingSession.svelte.js";
+export { useCommandPalette } from "./useCommandPalette.svelte.js";
+export { useAmbientSounds, soundLibrary } from "./useAmbientSounds.svelte.js";
+export { useEditorTheme, themes } from "./useEditorTheme.svelte.js";
+export { useSlashCommands, baseSlashCommands } from "./useSlashCommands.svelte.js";

package/dist/components/admin/composables/index.js

@@ -0,0 +1,12 @@
+/**
+ * MarkdownEditor Composables
+ * Extracted from MarkdownEditor.svelte for better maintainability
+ */
+
+export { useAmbientSounds, soundLibrary } from "./useAmbientSounds.svelte.js";
+export { useEditorTheme, themes } from "./useEditorTheme.svelte.js";
+export { useSnippets } from "./useSnippets.svelte.js";
+export { useDraftManager } from "./useDraftManager.svelte.js";
+export { useWritingSession } from "./useWritingSession.svelte.js";
+export { useSlashCommands, baseSlashCommands } from "./useSlashCommands.svelte.js";
+export { useCommandPalette } from "./useCommandPalette.svelte.js";

package/dist/components/admin/composables/useAmbientSounds.svelte.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Creates an ambient sounds manager with Svelte 5 runes
+ * @returns {object} Ambient sounds state and controls
+ */
+export function useAmbientSounds(): object;
+export namespace soundLibrary {
+    namespace forest {
+        let name: string;
+        let key: string;
+        let url: string;
+        let description: string;
+    }
+    namespace rain {
+        let name_1: string;
+        export { name_1 as name };
+        let key_1: string;
+        export { key_1 as key };
+        let url_1: string;
+        export { url_1 as url };
+        let description_1: string;
+        export { description_1 as description };
+    }
+    namespace campfire {
+        let name_2: string;
+        export { name_2 as name };
+        let key_2: string;
+        export { key_2 as key };
+        let url_2: string;
+        export { url_2 as url };
+        let description_2: string;
+        export { description_2 as description };
+    }
+    namespace night {
+        let name_3: string;
+        export { name_3 as name };
+        let key_3: string;
+        export { key_3 as key };
+        let url_3: string;
+        export { url_3 as url };
+        let description_3: string;
+        export { description_3 as description };
+    }
+    namespace cafe {
+        let name_4: string;
+        export { name_4 as name };
+        let key_4: string;
+        export { key_4 as key };
+        let url_4: string;
+        export { url_4 as url };
+        let description_4: string;
+        export { description_4 as description };
+    }
+}

package/dist/components/admin/composables/useAmbientSounds.svelte.js

@@ -0,0 +1,192 @@
+/**
+ * Ambient Sounds Composable
+ * Manages background audio for the editor (forest, rain, fire, etc.)
+ */
+
+const SOUNDS_STORAGE_KEY = "grove-editor-sounds";
+
+// Sound definitions with ambient loops
+export const soundLibrary = {
+  forest: {
+    name: "forest",
+    key: "f",
+    url: "/sounds/forest-ambience.mp3",
+    description: "birds, wind",
+  },
+  rain: {
+    name: "rain",
+    key: "r",
+    url: "/sounds/rain-ambience.mp3",
+    description: "gentle rainfall",
+  },
+  campfire: {
+    name: "fire",
+    key: "i",
+    url: "/sounds/campfire-ambience.mp3",
+    description: "crackling embers",
+  },
+  night: {
+    name: "night",
+    key: "n",
+    url: "/sounds/night-ambience.mp3",
+    description: "crickets, breeze",
+  },
+  cafe: {
+    name: "cafe",
+    key: "a",
+    url: "/sounds/cafe-ambience.mp3",
+    description: "soft murmurs",
+  },
+};
+
+/**
+ * Creates an ambient sounds manager with Svelte 5 runes
+ * @returns {object} Ambient sounds state and controls
+ */
+export function useAmbientSounds() {
+  let state = $state({
+    enabled: false,
+    currentSound: "forest",
+    volume: 0.3,
+    showPanel: false,
+  });
+
+  let audioElement = $state(null);
+
+  function loadSettings() {
+    try {
+      const stored = localStorage.getItem(SOUNDS_STORAGE_KEY);
+      if (stored) {
+        const settings = JSON.parse(stored);
+        state.currentSound = settings.currentSound || "forest";
+        state.volume = settings.volume ?? 0.3;
+        // Don't auto-enable on load - user must click to start
+      }
+    } catch (e) {
+      console.warn("Failed to load sound settings:", e);
+    }
+  }
+
+  function saveSettings() {
+    try {
+      localStorage.setItem(
+        SOUNDS_STORAGE_KEY,
+        JSON.stringify({
+          currentSound: state.currentSound,
+          volume: state.volume,
+        })
+      );
+    } catch (e) {
+      console.warn("Failed to save sound settings:", e);
+    }
+  }
+
+  function toggle() {
+    if (state.enabled) {
+      stop();
+    } else {
+      play(state.currentSound);
+    }
+  }
+
+  function play(soundKey) {
+    const sound = soundLibrary[soundKey];
+    if (!sound) return;
+
+    // Stop current sound if playing
+    if (audioElement) {
+      audioElement.pause();
+      audioElement = null;
+    }
+
+    // Create new audio element
+    audioElement = new Audio(sound.url);
+    audioElement.loop = true;
+    audioElement.volume = state.volume;
+
+    // Handle playback errors gracefully
+    audioElement.onerror = () => {
+      console.warn(`Sound file not found: ${sound.url}`);
+      state.enabled = false;
+    };
+
+    audioElement
+      .play()
+      .then(() => {
+        state.enabled = true;
+        state.currentSound = soundKey;
+        saveSettings();
+      })
+      .catch((e) => {
+        console.warn("Failed to play sound:", e);
+        state.enabled = false;
+      });
+  }
+
+  function stop() {
+    if (audioElement) {
+      audioElement.pause();
+      audioElement = null;
+    }
+    state.enabled = false;
+  }
+
+  function setVolume(newVolume) {
+    state.volume = newVolume;
+    if (audioElement) {
+      audioElement.volume = newVolume;
+    }
+    saveSettings();
+  }
+
+  function selectSound(soundKey) {
+    if (state.enabled) {
+      play(soundKey);
+    } else {
+      state.currentSound = soundKey;
+      saveSettings();
+    }
+  }
+
+  function togglePanel() {
+    state.showPanel = !state.showPanel;
+  }
+
+  function closePanel() {
+    state.showPanel = false;
+  }
+
+  function cleanup() {
+    if (audioElement) {
+      audioElement.pause();
+      audioElement = null;
+    }
+  }
+
+  return {
+    get state() {
+      return state;
+    },
+    get enabled() {
+      return state.enabled;
+    },
+    get currentSound() {
+      return state.currentSound;
+    },
+    get volume() {
+      return state.volume;
+    },
+    get showPanel() {
+      return state.showPanel;
+    },
+    loadSettings,
+    toggle,
+    play,
+    stop,
+    setVolume,
+    selectSound,
+    togglePanel,
+    closePanel,
+    cleanup,
+  };
+}

package/dist/components/admin/composables/useCommandPalette.svelte.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Command Palette Composable
+ * Manages the command palette (Cmd+K) functionality
+ */
+/**
+ * Creates a command palette manager with Svelte 5 runes
+ * @param {object} options - Configuration options
+ * @param {Function} options.getActions - Function to get available actions
+ * @param {Function} options.getThemes - Function to get available themes
+ * @param {Function} options.getCurrentTheme - Function to get current theme
+ * @returns {object} Command palette state and controls
+ */
+export function useCommandPalette(options?: {
+    getActions: Function;
+    getThemes: Function;
+    getCurrentTheme: Function;
+}): object;

package/dist/components/admin/composables/useCommandPalette.svelte.js

@@ -0,0 +1,118 @@
+/**
+ * Command Palette Composable
+ * Manages the command palette (Cmd+K) functionality
+ */
+
+/**
+ * Creates a command palette manager with Svelte 5 runes
+ * @param {object} options - Configuration options
+ * @param {Function} options.getActions - Function to get available actions
+ * @param {Function} options.getThemes - Function to get available themes
+ * @param {Function} options.getCurrentTheme - Function to get current theme
+ * @returns {object} Command palette state and controls
+ */
+export function useCommandPalette(options = {}) {
+  const { getActions, getThemes, getCurrentTheme } = options;
+
+  let state = $state({
+    open: false,
+    query: "",
+    selectedIndex: 0,
+  });
+
+  // Get all commands including theme commands
+  function getAllCommands() {
+    const actions = getActions ? getActions() : [];
+    const themes = getThemes ? getThemes() : {};
+    const currentTheme = getCurrentTheme ? getCurrentTheme() : "";
+
+    const themeCommands = Object.entries(themes).map(([key, theme]) => ({
+      id: `theme-${key}`,
+      label: `Theme: ${theme.label} (${theme.desc})`,
+      shortcut: currentTheme === key ? "●" : "",
+      action: () => {
+        // Theme action is handled by the caller
+      },
+      themeKey: key,
+      isTheme: true,
+    }));
+
+    return [...actions, ...themeCommands];
+  }
+
+  // Get filtered commands based on query
+  function getFilteredCommands() {
+    const allCommands = getAllCommands();
+    return allCommands.filter((cmd) =>
+      cmd.label.toLowerCase().includes(state.query.toLowerCase())
+    );
+  }
+
+  function open() {
+    state.open = true;
+    state.query = "";
+    state.selectedIndex = 0;
+  }
+
+  function close() {
+    state.open = false;
+  }
+
+  function toggle() {
+    if (state.open) {
+      close();
+    } else {
+      open();
+    }
+  }
+
+  function navigate(direction) {
+    const filtered = getFilteredCommands();
+    const count = filtered.length;
+    if (count === 0) return;
+
+    if (direction === "down") {
+      state.selectedIndex = (state.selectedIndex + 1) % count;
+    } else if (direction === "up") {
+      state.selectedIndex = (state.selectedIndex - 1 + count) % count;
+    }
+  }
+
+  function execute(index) {
+    const filtered = getFilteredCommands();
+    const cmd = filtered[index];
+    if (cmd && cmd.action) {
+      cmd.action();
+      close();
+    }
+    return cmd;
+  }
+
+  function setQuery(query) {
+    state.query = query;
+    state.selectedIndex = 0;
+  }
+
+  return {
+    get state() {
+      return state;
+    },
+    get isOpen() {
+      return state.open;
+    },
+    get query() {
+      return state.query;
+    },
+    get selectedIndex() {
+      return state.selectedIndex;
+    },
+    getAllCommands,
+    getFilteredCommands,
+    open,
+    close,
+    toggle,
+    navigate,
+    execute,
+    setQuery,
+  };
+}

package/dist/components/admin/composables/useDraftManager.svelte.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Creates a draft manager with Svelte 5 runes
+ * @param {object} options - Configuration options
+ * @param {string} options.draftKey - Unique key for localStorage
+ * @param {Function} options.getContent - Function to get current content
+ * @param {Function} options.setContent - Function to set content
+ * @param {Function} options.onDraftRestored - Callback when draft is restored
+ * @param {boolean} options.readonly - Whether editor is readonly
+ * @returns {object} Draft state and controls
+ */
+export function useDraftManager(options?: {
+    draftKey: string;
+    getContent: Function;
+    setContent: Function;
+    onDraftRestored: Function;
+    readonly: boolean;
+}): object;

package/dist/components/admin/composables/useDraftManager.svelte.js

@@ -0,0 +1,154 @@
+/**
+ * Draft Manager Composable
+ * Handles auto-saving drafts to localStorage
+ */
+
+const AUTO_SAVE_DELAY = 2000; // 2 seconds
+
+/**
+ * Creates a draft manager with Svelte 5 runes
+ * @param {object} options - Configuration options
+ * @param {string} options.draftKey - Unique key for localStorage
+ * @param {Function} options.getContent - Function to get current content
+ * @param {Function} options.setContent - Function to set content
+ * @param {Function} options.onDraftRestored - Callback when draft is restored
+ * @param {boolean} options.readonly - Whether editor is readonly
+ * @returns {object} Draft state and controls
+ */
+export function useDraftManager(options = {}) {
+  const { draftKey, getContent, setContent, onDraftRestored, readonly } = options;
+
+  let lastSavedContent = $state("");
+  let draftSaveTimer = $state(null);
+  let hasDraft = $state(false);
+  let draftRestorePrompt = $state(false);
+  let storedDraft = $state(null);
+
+  function saveDraft() {
+    if (!draftKey || readonly) return;
+
+    const content = getContent();
+    try {
+      const draft = {
+        content,
+        savedAt: new Date().toISOString(),
+      };
+      localStorage.setItem(`draft:${draftKey}`, JSON.stringify(draft));
+      lastSavedContent = content;
+      hasDraft = true;
+    } catch (e) {
+      console.warn("Failed to save draft:", e);
+    }
+  }
+
+  function loadDraft() {
+    if (!draftKey) return null;
+
+    try {
+      const stored = localStorage.getItem(`draft:${draftKey}`);
+      if (stored) {
+        return JSON.parse(stored);
+      }
+    } catch (e) {
+      console.warn("Failed to load draft:", e);
+    }
+    return null;
+  }
+
+  function clearDraft() {
+    if (!draftKey) return;
+
+    try {
+      localStorage.removeItem(`draft:${draftKey}`);
+      hasDraft = false;
+      storedDraft = null;
+      draftRestorePrompt = false;
+    } catch (e) {
+      console.warn("Failed to clear draft:", e);
+    }
+  }
+
+  function restoreDraft() {
+    if (storedDraft && setContent) {
+      setContent(storedDraft.content);
+      lastSavedContent = storedDraft.content;
+      if (onDraftRestored) {
+        onDraftRestored(storedDraft);
+      }
+    }
+    draftRestorePrompt = false;
+  }
+
+  function discardDraft() {
+    clearDraft();
+    lastSavedContent = getContent();
+  }
+
+  function scheduleSave(content) {
+    if (!draftKey || readonly) return;
+
+    // Clear previous timer
+    if (draftSaveTimer) {
+      clearTimeout(draftSaveTimer);
+    }
+
+    // Don't save if content hasn't changed from last saved version
+    if (content === lastSavedContent) return;
+
+    // Schedule a draft save
+    draftSaveTimer = setTimeout(() => {
+      saveDraft();
+    }, AUTO_SAVE_DELAY);
+  }
+
+  function init(initialContent) {
+    // Check for existing draft on mount
+    if (draftKey) {
+      const draft = loadDraft();
+      if (draft && draft.content !== initialContent) {
+        storedDraft = draft;
+        draftRestorePrompt = true;
+      } else {
+        lastSavedContent = initialContent;
+      }
+    }
+  }
+
+  function cleanup() {
+    if (draftSaveTimer) {
+      clearTimeout(draftSaveTimer);
+    }
+  }
+
+  function getStatus() {
+    return { hasDraft, storedDraft };
+  }
+
+  function hasUnsavedChanges(content) {
+    return content !== lastSavedContent;
+  }
+
+  return {
+    get hasDraft() {
+      return hasDraft;
+    },
+    get draftRestorePrompt() {
+      return draftRestorePrompt;
+    },
+    get storedDraft() {
+      return storedDraft;
+    },
+    get lastSavedContent() {
+      return lastSavedContent;
+    },
+    init,
+    scheduleSave,
+    saveDraft,
+    clearDraft,
+    restoreDraft,
+    discardDraft,
+    getStatus,
+    hasUnsavedChanges,
+    cleanup,
+  };
+}