@umituz/web-dashboard 3.0.0 → 3.1.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/web-dashboard",
-  "version": "3.0.0",
-  "description": "Dashboard Layout System - Comprehensive analytics services, customizable layouts, and config-based architecture",
+  "version": "3.1.0",
+  "description": "Dashboard Layout System - Comprehensive analytics, calendar, customizable layouts, and config-based architecture",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "sideEffects": false,
@@ -34,6 +34,11 @@
     "./analytics/utils": "./src/domains/analytics/utils/index.ts",
     "./analytics/types": "./src/domains/analytics/types/index.ts",
     "./analytics/services": "./src/domains/analytics/services/index.ts",
+    "./calendar": "./src/domains/calendar/index.ts",
+    "./calendar/types": "./src/domains/calendar/types/calendar.types",
+    "./calendar/services": "./src/domains/calendar/services/index.ts",
+    "./calendar/hooks": "./src/domains/calendar/hooks/index.ts",
+    "./calendar/utils": "./src/domains/calendar/utils/index.ts",
     "./config": "./src/domain/config/index.ts",
     "./billing": "./src/domains/billing/index.ts",
     "./billing/components": "./src/domains/billing/components/index.ts",
@@ -94,6 +99,11 @@
     "behavior-prediction",
     "performance-monitoring",
     "realtime-metrics",
+    "calendar",
+    "content-calendar",
+    "scheduler",
+    "content-planning",
+    "drag-drop",
     "charts",
     "metrics",
     "kpi",

package/src/domain/config/CalendarConfig.ts

@@ -0,0 +1,22 @@
+/**
+ * Calendar Configuration
+ */
+
+import type { CalendarConfig } from '../../domains/calendar/types/calendar.types';
+
+/**
+ * Default calendar configuration
+ */
+export const DEFAULT_CALENDAR_CONFIG: CalendarConfig = {
+  defaultView: 'month',
+  showWeekends: true,
+  startOfWeek: 0,
+  hourRange: {
+    start: 0,
+    end: 23,
+  },
+  enableDragDrop: true,
+  showPlatformFilters: true,
+  platforms: ['instagram', 'facebook', 'twitter', 'linkedin', 'tiktok', 'youtube'],
+  slotDuration: 30,
+};

package/src/domain/config/index.ts

@@ -3,3 +3,4 @@
  */
 
 export * from './DashboardConfig';
+export * from './CalendarConfig';

package/src/domains/calendar/components/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Calendar Components Index
+ */
+
+// Placeholder - components will be added in next iteration
+// For now, types, services, hooks, and utils are sufficient
+export {} from './index';

package/src/domains/calendar/hooks/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Calendar Hooks Index
+ */
+
+export * from './useCalendar';

package/src/domains/calendar/hooks/useCalendar.ts

@@ -0,0 +1,232 @@
+/**
+ * useCalendar Hook
+ *
+ * React hook for calendar functionality with config support
+ */
+
+import { useState, useCallback, useEffect, useMemo } from 'react';
+import type { CalendarConfig, ContentItem, CalendarFilter } from '../types/calendar.types';
+import { calendarService } from '../services';
+import { DEFAULT_CALENDAR_CONFIG } from '../utils';
+
+interface UseCalendarOptions {
+  /** Calendar configuration */
+  config?: Partial<CalendarConfig>;
+  /** User ID */
+  userId: string;
+  /** Error callback */
+  onError?: (error: Error) => void;
+}
+
+interface UseCalendarReturn {
+  // Data
+  items: ContentItem[];
+  loading: boolean;
+  error: string | null;
+  currentView: CalendarView;
+  currentDate: Date;
+  selectedDate: Date;
+  filter: CalendarFilter;
+
+  // Actions
+  setCurrentView: (view: CalendarView) => void;
+  setCurrentDate: (date: Date) => void;
+  setSelectedDate: (date: Date) => void;
+  setFilter: (filter: Partial<CalendarFilter>) => void;
+  refresh: () => Promise<void>;
+
+  // CRUD
+  createItem: (item: Omit<ContentItem, 'id' | 'created_at' | 'updated_at'>) => Promise<ContentItem>;
+  updateItem: (id: string, updates: Partial<ContentItem>) => Promise<void>;
+  deleteItem: (id: string) => Promise<void>;
+  moveItem: (id: string, newDate: Date) => Promise<void>;
+
+  // Computed
+  filteredItems: ContentItem[];
+  itemsForDate: (date: Date) => ContentItem[];
+}
+
+type CalendarView = 'month' | 'week' | 'day' | 'timeline';
+
+/**
+ * useCalendar hook
+ *
+ * Manages calendar state and operations with config support
+ */
+export function useCalendar(options: UseCalendarOptions): UseCalendarReturn {
+  const { config: userConfig, userId, onError } = options;
+
+  // Merge config with defaults
+  const config = useMemo(() => ({
+    ...DEFAULT_CALENDAR_CONFIG,
+    ...userConfig,
+  }), [userConfig]);
+
+  // State
+  const [items, setItems] = useState<ContentItem[]>([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [currentView, setCurrentView] = useState<CalendarView>(config.defaultView || 'month');
+  const [currentDate, setCurrentDate] = useState(new Date());
+  const [selectedDate, setSelectedDate] = useState(new Date());
+  const [filter, setFilter] = useState<CalendarFilter>({});
+
+  // Fetch items
+  const refresh = useCallback(async () => {
+    if (!userId) return;
+
+    setLoading(true);
+    setError(null);
+
+    try {
+      const data = await calendarService.getContentItems(userId, filter);
+      setItems(data);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to fetch calendar items';
+      setError(errorMessage);
+      onError?.(err as Error);
+    } finally {
+      setLoading(false);
+    }
+  }, [userId, filter, onError]);
+
+  // Create item
+  const createItem = useCallback(async (item: Omit<ContentItem, 'id' | 'created_at' | 'updated_at'>): Promise<ContentItem> => {
+    if (!userId) {
+      throw new Error('User ID is required');
+    }
+
+    try {
+      const created = await calendarService.createContentItem(userId, item);
+      await refresh();
+      return created;
+    } catch (err) {
+      onError?.(err as Error);
+      throw err;
+    }
+  }, [userId, refresh, onError]);
+
+  // Update item
+  const updateItem = useCallback(async (id: string, updates: Partial<ContentItem>): Promise<void> => {
+    try {
+      await calendarService.updateContentItem(id, updates);
+      await refresh();
+    } catch (err) {
+      onError?.(err as Error);
+      throw err;
+    }
+  }, [refresh, onError]);
+
+  // Delete item
+  const deleteItem = useCallback(async (id: string): Promise<void> => {
+    try {
+      await calendarService.deleteContentItem(id);
+      await refresh();
+    } catch (err) {
+      onError?.(err as Error);
+      throw err;
+    }
+  }, [refresh, onError]);
+
+  // Move item
+  const moveItem = useCallback(async (id: string, newDate: Date): Promise<void> => {
+    try {
+      await calendarService.moveContentItem(id, newDate);
+      await refresh();
+    } catch (err) {
+      onError?.(err as Error);
+      throw err;
+    }
+  }, [refresh, onError]);
+
+  // Filter update
+  const updateFilter = useCallback((updates: Partial<CalendarFilter>) => {
+    setFilter(prev => ({ ...prev, ...updates }));
+  }, []);
+
+  // Get filtered items
+  const filteredItems = useMemo(() => {
+    return items.filter(item => {
+      // Search filter
+      if (filter.search && !item.title.toLowerCase().includes(filter.search.toLowerCase())) {
+        return false;
+      }
+
+      // Platform filter
+      if (filter.platforms && filter.platforms.length > 0) {
+        if (!item.platforms.some(p => filter.platforms?.includes(p))) {
+          return false;
+        }
+      }
+
+      // Type filter
+      if (filter.types && filter.types.length > 0) {
+        if (!item.type || !filter.types.includes(item.type)) {
+          return false;
+        }
+      }
+
+      // Status filter
+      if (filter.status && item.status !== filter.status) {
+        return false;
+      }
+
+      // Date range filter
+      if (filter.dateRange) {
+        const itemDate = new Date(item.scheduled_at);
+        if (itemDate < filter.dateRange.start || itemDate > filter.dateRange.end) {
+          return false;
+        }
+      }
+
+      return true;
+    });
+  }, [items, filter]);
+
+  // Get items for specific date
+  const itemsForDate = useCallback((date: Date): ContentItem[] => {
+    const dateStart = new Date(date);
+    dateStart.setHours(0, 0, 0, 0);
+
+    const dateEnd = new Date(date);
+    dateEnd.setHours(23, 59, 59, 999);
+
+    return filteredItems.filter(item => {
+      const itemDate = new Date(item.scheduled_at);
+      return itemDate >= dateStart && itemDate <= dateEnd;
+    });
+  }, [filteredItems]);
+
+  // Initial fetch
+  useEffect(() => {
+    refresh();
+  }, [refresh]);
+
+  return {
+    // Data
+    items,
+    loading,
+    error,
+    currentView,
+    currentDate,
+    selectedDate,
+    filter,
+
+    // Actions
+    setCurrentView,
+    setCurrentDate,
+    setSelectedDate,
+    setFilter: updateFilter,
+    refresh,
+
+    // CRUD
+    createItem,
+    updateItem,
+    deleteItem,
+    moveItem,
+
+    // Computed
+    filteredItems,
+    itemsForDate,
+  };
+}

package/src/domains/calendar/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Calendar Domain Index
+ */
+
+export * from './types/calendar.types';
+export * from './services';
+export * from './hooks';
+export * from './utils';
+export * from './components';

package/src/domains/calendar/services/CalendarService.ts

@@ -0,0 +1,259 @@
+/**
+ * Calendar Service
+ *
+ * Firebase-based calendar service for managing content items
+ */
+
+import type {
+  ContentItem,
+  CalendarFilter,
+  CreateContentItemParams,
+  UpdateContentItemParams,
+  ICalendarService,
+} from '../types/calendar.types';
+
+/**
+ * Database interface for calendar operations
+ * Implementations can provide different backends
+ */
+interface ICalendarDatabase {
+  getItems(userId: string): Promise<ContentItem[]>;
+  getItemById(id: string): Promise<ContentItem | null>;
+  createItem(userId: string, item: CreateContentItemParams): Promise<ContentItem>;
+  updateItem(id: string, updates: UpdateContentItemParams): Promise<void>;
+  deleteItem(id: string): Promise<void>;
+}
+
+/**
+ * Firebase implementation of calendar database
+ */
+class FirebaseCalendarDatabase implements ICalendarDatabase {
+  async getItems(userId: string): Promise<ContentItem[]> {
+    // Lazy load Firebase
+    const { collection, query, where, getDocs } = await import('firebase/firestore');
+    const { db } = await import('@umituz/web-firebase');
+
+    const calendarQuery = query(
+      collection(db as any, 'calendar_items'),
+      where("user_id", "==", userId)
+    );
+
+    const postsQuery = query(
+      collection(db as any, "posts"),
+      where("userId", "==", userId)
+    );
+
+    const [calendarSnap, postsSnap] = await Promise.all([
+      getDocs(calendarQuery),
+      getDocs(postsQuery)
+    ]);
+
+    const calendarItems = calendarSnap.docs.map((doc: any) => ({
+      id: doc.id,
+      ...doc.data()
+    } as ContentItem));
+
+    const postItems = postsSnap.docs.map((doc: any) => {
+      const data = doc.data();
+      return {
+        id: doc.id,
+        title: data.title || 'Untitled Post',
+        description: data.content || '',
+        scheduled_at: data.scheduledAt
+          ? (typeof data.scheduledAt === 'string' ? data.scheduledAt : (data.scheduledAt as any)?.toDate?.().toISOString())
+          : new Date().toISOString(),
+        platforms: data.platform ? [data.platform] : [],
+        app_name: data.appName || 'My App',
+        status: data.status || 'draft',
+        type: 'post'
+      } as ContentItem;
+    });
+
+    return [...calendarItems, ...postItems].sort((a, b) =>
+      new Date(b.scheduled_at).getTime() - new Date(a.scheduled_at).getTime()
+    );
+  }
+
+  async getItemById(id: string): Promise<ContentItem | null> {
+    const { doc, getDoc } = await import('firebase/firestore');
+    const { db } = await import('@umituz/web-firebase');
+
+    const docRef = doc(db as any, 'calendar_items', id);
+    const snap = await getDoc(docRef);
+
+    if (!snap.exists()) {
+      return null;
+    }
+
+    return {
+      id: snap.id,
+      ...snap.data()
+    } as ContentItem;
+  }
+
+  async createItem(userId: string, item: CreateContentItemParams): Promise<ContentItem> {
+    const { collection, addDoc, serverTimestamp } = await import('firebase/firestore');
+    const { db } = await import('@umituz/web-firebase');
+
+    const docRef = await addDoc(collection(db as any, 'calendar_items'), {
+      ...item,
+      scheduled_at: typeof item.scheduled_at === 'string' ? item.scheduled_at : item.scheduled_at.toISOString(),
+      user_id: userId,
+      created_at: serverTimestamp(),
+      updated_at: serverTimestamp()
+    });
+
+    return {
+      id: docRef.id,
+      ...item,
+      scheduled_at: typeof item.scheduled_at === 'string' ? item.scheduled_at : item.scheduled_at.toISOString(),
+      user_id: userId,
+      created_at: new Date().toISOString()
+    } as ContentItem;
+  }
+
+  async updateItem(id: string, updates: UpdateContentItemParams): Promise<void> {
+    const { doc, updateDoc, serverTimestamp } = await import('firebase/firestore');
+    const { db } = await import('@umituz/web-firebase');
+
+    const docRef = doc(db as any, 'calendar_items', id);
+
+    const updateData: any = { ...updates };
+    if (updates.scheduled_at) {
+      updateData.scheduled_at = typeof updates.scheduled_at === 'string'
+        ? updates.scheduled_at
+        : updates.scheduled_at.toISOString();
+    }
+
+    await updateDoc(docRef, {
+      ...updateData,
+      updated_at: serverTimestamp()
+    });
+  }
+
+  async deleteItem(id: string): Promise<void> {
+    const { doc, deleteDoc } = await import('firebase/firestore');
+    const { db } = await import('@umituz/web-firebase');
+
+    const docRef = doc(db as any, 'calendar_items', id);
+    await deleteDoc(docRef);
+  }
+}
+
+/**
+ * Calendar Service Implementation
+ *
+ * Provides CRUD operations for calendar content items
+ * Uses database interface for backend abstraction
+ */
+export class CalendarService implements ICalendarService {
+  private static instance: CalendarService;
+  private database: ICalendarDatabase;
+
+  private constructor() {
+    // Use Firebase implementation by default
+    this.database = new FirebaseCalendarDatabase();
+  }
+
+  public static getInstance(): CalendarService {
+    if (!CalendarService.instance) {
+      CalendarService.instance = new CalendarService();
+    }
+    return CalendarService.instance;
+  }
+
+  /**
+   * Set database implementation (for testing or custom backends)
+   */
+  setDatabase(database: ICalendarDatabase): void {
+    this.database = database;
+  }
+
+  /**
+   * Get all content items for a user
+   */
+  async getContentItems(userId: string, filter?: CalendarFilter): Promise<ContentItem[]> {
+    const items = await this.database.getItems(userId);
+
+    if (!filter) return items;
+
+    // Apply filters
+    return items.filter(item => {
+      // Search filter
+      if (filter.search && !item.title.toLowerCase().includes(filter.search.toLowerCase())) {
+        return false;
+      }
+
+      // Platform filter
+      if (filter.platforms && filter.platforms.length > 0) {
+        if (!item.platforms.some(p => filter.platforms?.includes(p))) {
+          return false;
+        }
+      }
+
+      // Type filter
+      if (filter.types && filter.types.length > 0) {
+        if (!item.type || !filter.types.includes(item.type)) {
+          return false;
+        }
+      }
+
+      // Status filter
+      if (filter.status && item.status !== filter.status) {
+        return false;
+      }
+
+      // Date range filter
+      if (filter.dateRange) {
+        const itemDate = new Date(item.scheduled_at);
+        if (itemDate < filter.dateRange.start || itemDate > filter.dateRange.end) {
+          return false;
+        }
+      }
+
+      return true;
+    });
+  }
+
+  /**
+   * Get a single content item by ID
+   */
+  async getContentItemById(id: string): Promise<ContentItem | null> {
+    return this.database.getItemById(id);
+  }
+
+  /**
+   * Create a new content item
+   */
+  async createContentItem(userId: string, item: CreateContentItemParams): Promise<ContentItem> {
+    return this.database.createItem(userId, item);
+  }
+
+  /**
+   * Update an existing content item
+   */
+  async updateContentItem(id: string, updates: UpdateContentItemParams): Promise<void> {
+    await this.database.updateItem(id, updates);
+  }
+
+  /**
+   * Delete a content item
+   */
+  async deleteContentItem(id: string): Promise<void> {
+    await this.database.deleteItem(id);
+  }
+
+  /**
+   * Move content item to a new date
+   */
+  async moveContentItem(id: string, newDate: Date): Promise<void> {
+    await this.updateContentItem(id, {
+      scheduled_at: newDate
+    });
+  }
+}
+
+/**
+ * Singleton instance
+ */
+export const calendarService = CalendarService.getInstance();

package/src/domains/calendar/services/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Calendar Services Index
+ */
+
+export * from './CalendarService';

package/src/domains/calendar/types/calendar.types.ts

@@ -0,0 +1,129 @@
+/**
+ * Calendar Domain Types
+ */
+
+/**
+ * Content item status
+ */
+export type ContentStatus = 'draft' | 'scheduled' | 'published' | 'failed';
+
+/**
+ * Content item type
+ */
+export type ContentType = 'post' | 'story' | 'reel' | 'tweet' | 'article';
+
+/**
+ * Calendar view type
+ */
+export type CalendarView = 'month' | 'week' | 'day' | 'timeline';
+
+/**
+ * Content item
+ */
+export interface ContentItem {
+  id: string;
+  title: string;
+  description: string;
+  type?: ContentType;
+  status: ContentStatus;
+  scheduled_at: string;
+  platforms: string[];
+  app_name: string;
+  user_id?: string;
+  media_url?: string;
+  tags?: string[];
+  created_at?: string;
+  updated_at?: string;
+}
+
+/**
+ * Calendar event
+ */
+export interface CalendarEvent {
+  id: string;
+  title: string;
+  date: Date;
+  type: 'content' | 'campaign' | 'reminder';
+  status: string;
+  color?: string;
+}
+
+/**
+ * Calendar filter
+ */
+export interface CalendarFilter {
+  search?: string;
+  platforms?: string[];
+  types?: ContentType[];
+  status?: ContentStatus;
+  dateRange?: {
+    start: Date;
+    end: Date;
+  };
+}
+
+/**
+ * Calendar configuration
+ */
+export interface CalendarConfig {
+  /** Default view */
+  defaultView?: CalendarView;
+  /** Show weekends */
+  showWeekends?: boolean;
+  /** Start of week (0-6, 0 = Sunday) */
+  startOfWeek?: number;
+  /** Hour range for day/week view */
+  hourRange?: {
+    start: number; // 0-23
+    end: number; // 0-23
+  };
+  /** Enable drag and drop */
+  enableDragDrop?: boolean;
+  /** Show platform filters */
+  showPlatformFilters?: boolean;
+  /** Available platforms */
+  platforms?: string[];
+  /** Time slot duration in minutes */
+  slotDuration?: number;
+}
+
+/**
+ * Content item creation params
+ */
+export interface CreateContentItemParams {
+  title: string;
+  description: string;
+  scheduled_at: string | Date;
+  platforms: string[];
+  app_name: string;
+  type?: ContentType;
+  status?: ContentStatus;
+  media_url?: string;
+  tags?: string[];
+}
+
+/**
+ * Content item update params
+ */
+export interface UpdateContentItemParams {
+  title?: string;
+  description?: string;
+  scheduled_at?: string | Date;
+  platforms?: string[];
+  type?: ContentType;
+  status?: ContentStatus;
+  media_url?: string;
+  tags?: string[];
+}
+
+/**
+ * Calendar service interface
+ */
+export interface ICalendarService {
+  getContentItems(userId: string, filter?: CalendarFilter): Promise<ContentItem[]>;
+  getContentItemById(id: string): Promise<ContentItem | null>;
+  createContentItem(userId: string, item: CreateContentItemParams): Promise<ContentItem>;
+  updateContentItem(id: string, updates: UpdateContentItemParams): Promise<void>;
+  deleteContentItem(id: string): Promise<void>;
+  moveContentItem(id: string, newDate: Date): Promise<void>;
+}

package/src/domains/calendar/utils/index.ts

@@ -0,0 +1,131 @@
+/**
+ * Calendar Domain Utilities
+ */
+
+import type { CalendarConfig } from '../types/calendar.types';
+
+/**
+ * Default calendar configuration
+ */
+export const DEFAULT_CALENDAR_CONFIG: CalendarConfig = {
+  defaultView: 'month',
+  showWeekends: true,
+  startOfWeek: 0, // Sunday
+  hourRange: {
+    start: 0,
+    end: 23,
+  },
+  enableDragDrop: true,
+  showPlatformFilters: true,
+  platforms: ['instagram', 'facebook', 'twitter', 'linkedin', 'tiktok'],
+  slotDuration: 30, // 30 minutes
+};
+
+/**
+ * Get week dates for a given date
+ */
+export function getWeekDates(date: Date, startOfWeek: number = 0): Date[] {
+  const week = [];
+  const current = new Date(date);
+
+  // Find the first day of the week
+  const day = current.getDay();
+  const diff = (day < startOfWeek ? 7 : 0) + day - startOfWeek;
+  current.setDate(current.getDate() - diff);
+
+  // Get 7 days
+  for (let i = 0; i < 7; i++) {
+    week.push(new Date(current));
+    current.setDate(current.getDate() + 1);
+  }
+
+  return week;
+}
+
+/**
+ * Get month days
+ */
+export function getMonthDays(date: Date): Date[] {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const days: Date[] = [];
+
+  const firstDay = new Date(year, month, 1);
+  const lastDay = new Date(year, month + 1, 0);
+
+  for (let d = new Date(firstDay); d <= lastDay; d.setDate(d.getDate() + 1)) {
+    days.push(new Date(d));
+  }
+
+  return days;
+}
+
+/**
+ * Check if date is in range
+ */
+export function isDateInRange(date: Date, range: { start: Date; end: Date }): boolean {
+  return date >= range.start && date <= range.end;
+}
+
+/**
+ * Format date for display
+ */
+export function formatDate(date: Date, format: 'short' | 'long' | 'time' = 'short'): string {
+  if (format === 'time') {
+    return date.toLocaleTimeString('en-US', {
+      hour: '2-digit',
+      minute: '2-digit',
+    });
+  }
+
+  return date.toLocaleDateString('en-US', {
+    month: format === 'long' ? 'long' : 'short',
+    day: 'numeric',
+    year: 'numeric',
+  });
+}
+
+/**
+ * Check if dates are same day
+ */
+export function isSameDay(date1: Date, date2: Date): boolean {
+  return (
+    date1.getFullYear() === date2.getFullYear() &&
+    date1.getMonth() === date2.getMonth() &&
+    date1.getDate() === date2.getDate()
+  );
+}
+
+/**
+ * Get date range for a view
+ */
+export function getViewRange(view: 'month' | 'week', date: Date): { start: Date; end: Date } {
+  if (view === 'month') {
+    const start = new Date(date.getFullYear(), date.getMonth(), 1);
+    const end = new Date(date.getFullYear(), date.getMonth() + 1, 0);
+    return { start, end };
+  }
+
+  // Week view
+  const week = getWeekDates(date);
+  return {
+    start: new Date(week[0].setHours(0, 0, 0, 0)),
+    end: new Date(week[6].setHours(23, 59, 59, 999)),
+  };
+}
+
+/**
+ * Generate time slots
+ */
+export function generateTimeSlots(startHour: number, endHour: number, slotDuration: number): string[] {
+  const slots: string[] = [];
+
+  for (let hour = startHour; hour < endHour; hour++) {
+    for (let minute = 0; minute < 60; minute += slotDuration) {
+      const time = `${hour.toString().padStart(2, '0')}:${minute.toString().padStart(2, '0')}`;
+      slots.push(time);
+    }
+  }
+
+  return slots;
+}

package/src/index.ts

@@ -12,7 +12,11 @@ export * from './domains/layouts';
 export * from './domains/settings';
 export * from './domains/billing';
 
-// Auth and Onboarding with conflict resolution
+// Domains - using selective exports to avoid conflicts
+export * from './domains/layouts';
+export * from './domains/settings';
+export * from './domains/billing';
+export * from './domains/calendar';
 export {
   OnboardingWizard,
   useOnboarding,
@@ -95,9 +99,37 @@ export {
   type RealtimeMetrics,
 } from './domains/analytics';
 
+// Calendar
+export {
+  useCalendar,
+  calendarService,
+  // Services
+  CalendarService,
+  // Utils
+  getWeekDates,
+  getMonthDays,
+  isDateInRange,
+  formatDate,
+  isSameDay,
+  getViewRange,
+  generateTimeSlots,
+  // Types
+  type ContentItem,
+  type CalendarEvent,
+  type CalendarFilter,
+  type CalendarConfig,
+  type ContentStatus,
+  type ContentType,
+  type CalendarView,
+  type CreateContentItemParams,
+  type UpdateContentItemParams,
+  type ICalendarService,
+} from './domains/calendar';
+
 // Config with renamed exports to avoid conflicts
 export {
   DEFAULT_DASHBOARD_CONFIG,
+  DEFAULT_CALENDAR_CONFIG,
   type AnalyticsServiceType,
   type ExportFormat as DashboardExportFormat,
   type AnalyticsConfig as DashboardAnalyticsConfig,