chore: remove luckysheet integration

src/store/editor-bridge.ts

@@ -0,0 +1,25 @@
+"use client";
+
+import { create } from "zustand";
+import type { ReferenceTarget } from "@/types/search";
+import type { Json } from "@/types/supabase";
+
+export interface EditorReferenceBridgeResult {
+  blockId: string | null;
+}
+
+export interface EditorReferenceBridge {
+  insertInlineReference: (target: ReferenceTarget, alias?: string) => EditorReferenceBridgeResult;
+  insertEmbedReference: (target: ReferenceTarget) => EditorReferenceBridgeResult;
+  replaceWithSnapshot: (blocks: Json) => void;
+}
+
+interface EditorBridgeState {
+  bridge: EditorReferenceBridge | null;
+  registerBridge: (bridge: EditorReferenceBridge | null) => void;
+}
+
+export const useEditorBridgeStore = create<EditorBridgeState>((set) => ({
+  bridge: null,
+  registerBridge: (bridge) => set({ bridge }),
+}));

src/store/page-layout.ts

@@ -0,0 +1,18 @@
+"use client";
+
+import { create } from "zustand";
+
+interface PageLayoutState {
+  showInspector: boolean;
+  toggleInspector: () => void;
+  setInspector: (visible: boolean) => void;
+}
+
+export const usePageLayoutStore = create<PageLayoutState>((set) => ({
+  showInspector: true,
+  toggleInspector: () =>
+    set((state) => ({
+      showInspector: !state.showInspector,
+    })),
+  setInspector: (visible) => set({ showInspector: visible }),
+}));

src/store/search-palette.ts

@@ -0,0 +1,109 @@
+"use client";
+
+import { create } from "zustand";
+import type {
+  DocumentSearchFilters,
+  DocumentSearchResult,
+  DocumentSearchTimeField,
+  DocumentSearchTimeRange,
+} from "@/types/search";
+
+export type SearchPaletteMode = "search" | "reference";
+export type ReferenceInsertMode = "inline" | "embed";
+export type FilterKey = "titleOnly" | "exact" | "onlyCurrentPage" | "includeOcr";
+
+interface SearchPaletteState {
+  open: boolean;
+  mode: SearchPaletteMode;
+  query: string;
+  filters: Omit<DocumentSearchFilters, "timeRange">;
+  timeRange: DocumentSearchTimeRange;
+  referenceMode: ReferenceInsertMode;
+  alias: string;
+  recent: DocumentSearchResult[];
+  setRecent: (items: DocumentSearchResult[]) => void;
+  openSearch: () => void;
+  openReference: (options?: { referenceMode?: ReferenceInsertMode; aliasSeed?: string }) => void;
+  close: () => void;
+  setQuery: (value: string) => void;
+  toggleFilter: (key: FilterKey) => void;
+  setTimeRange: (range: DocumentSearchTimeRange) => void;
+  setTimeField: (field: DocumentSearchTimeField) => void;
+  setCustomRange: (range: { from?: string; to?: string } | null) => void;
+  setReferenceMode: (mode: ReferenceInsertMode) => void;
+  setAlias: (value: string) => void;
+  rememberResult: (result: DocumentSearchResult) => void;
+  resetFilters: () => void;
+}
+
+const defaultFilters: Omit<DocumentSearchFilters, "timeRange"> = {
+  titleOnly: false,
+  exact: false,
+  onlyCurrentPage: false,
+  includeOcr: false,
+  timeField: "updated",
+  customRange: undefined,
+};
+
+export const useSearchPaletteStore = create<SearchPaletteState>((set) => ({
+  open: false,
+  mode: "search",
+  query: "",
+  filters: { ...defaultFilters },
+  timeRange: "any",
+  referenceMode: "inline",
+  alias: "",
+  recent: [],
+  setRecent: (items) => set({ recent: items.slice(0, 10) }),
+  openSearch: () =>
+    set((state) => ({
+      open: true,
+      mode: "search",
+      query: state.query,
+    })),
+  openReference: (options) =>
+    set({
+      open: true,
+      mode: "reference",
+      referenceMode: options?.referenceMode ?? "inline",
+      alias: options?.aliasSeed ?? "",
+    }),
+  close: () => set({ open: false }),
+  setQuery: (value) => set({ query: value }),
+  toggleFilter: (key) =>
+    set((state) => ({
+      filters: {
+        ...state.filters,
+        [key]: !state.filters[key],
+      },
+    })),
+  setTimeRange: (range) => set({ timeRange: range }),
+  setTimeField: (field) =>
+    set((state) => ({
+      filters: {
+        ...state.filters,
+        timeField: field,
+      },
+    })),
+  setCustomRange: (range) =>
+    set((state) => ({
+      filters: {
+        ...state.filters,
+        customRange: range ?? undefined,
+      },
+    })),
+  setReferenceMode: (mode) => set({ referenceMode: mode }),
+  setAlias: (value) => set({ alias: value }),
+  rememberResult: (result) =>
+    set((state) => {
+      const existing = state.recent.filter((item) => item.id !== result.id);
+      return {
+        recent: [result, ...existing].slice(0, 10),
+      };
+    }),
+  resetFilters: () =>
+    set({
+      filters: { ...defaultFilters },
+      timeRange: "any",
+    }),
+}));

src/store/sidebar.ts

@@ -0,0 +1,59 @@
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import type { SidebarSectionId } from "@/components/sidebar/types";
+
+interface SidebarState {
+  open: boolean;
+  width: number;
+  collapsedSections: Record<SidebarSectionId, boolean>;
+  trashConfirm: boolean;
+  setOpen: (open: boolean) => void;
+  setWidth: (width: number) => void;
+  toggleSection: (section: SidebarSectionId) => void;
+  setSectionCollapsed: (section: SidebarSectionId, collapsed: boolean) => void;
+  setTrashConfirm: (value: boolean) => void;
+}
+
+const sectionDefaults: Record<SidebarSectionId, boolean> = {
+  starred: false,
+  public: false,
+  shared: false,
+  private: false,
+  templates: false,
+};
+
+export const useSidebarStore = create<SidebarState>()(
+  persist(
+    (set) => ({
+      open: false,
+      width: 280,
+      collapsedSections: { ...sectionDefaults },
+      trashConfirm: true,
+      setOpen: (open) => set({ open }),
+      setWidth: (width) => set({ width }),
+      toggleSection: (section) =>
+        set((state) => ({
+          collapsedSections: {
+            ...state.collapsedSections,
+            [section]: !state.collapsedSections[section],
+          },
+        })),
+      setSectionCollapsed: (section, collapsed) =>
+        set((state) => ({
+          collapsedSections: {
+            ...state.collapsedSections,
+            [section]: collapsed,
+          },
+        })),
+      setTrashConfirm: (value) => set({ trashConfirm: value }),
+    }),
+    {
+      name: "sidebar-ui",
+      partialize: (state) => ({
+        width: state.width,
+        collapsedSections: state.collapsedSections,
+        trashConfirm: state.trashConfirm,
+      }),
+    },
+  ),
+);