@umituz/web-dashboard 2.5.2 → 3.1.0

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

@@ -0,0 +1,140 @@
+/**
+ * @umituz/web-dashboard
+ *
+ * Dashboard Layout System - Customizable, themeable dashboard layouts
+ * with comprehensive analytics services and config-based architecture.
+ *
+ * @version 3.0.0
+ */
+
+// Export all domains
+export * from './domains/layouts';
+export * from './domains/settings';
+export * from './domains/billing';
+
+// 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,
+  useOnboardingStep,
+} from './domains/onboarding';
+
+export type {
+  OnboardingStep,
+  OnboardingState,
+  OnboardingConfig,
+} from './domains/onboarding';
+
+export {
+  AuthLayout,
+  LoginForm,
+  RegisterForm,
+  useAuth,
+  type LoginCredentials,
+  type RegisterData,
+  type User,
+} from './domains/auth';
+
+// Analytics with conflict resolution
+export {
+  useAnalytics,
+  MetricCard,
+  AnalyticsChart,
+  AnalyticsCard,
+  AnalyticsLayout,
+  formatNumber,
+  formatPercentage,
+  formatCurrency,
+  calculateGrowth,
+  getTrend,
+  createKPI,
+  createMetric,
+  formatMetricValue,
+  calculateConversionRate,
+  calculateDropOffRate,
+  createDateRangePreset,
+  getDateRangePresets,
+  aggregateByPeriod,
+  calculateMovingAverage,
+  detectOutliers,
+  roundTo,
+  generateColor,
+  generateChartColors,
+  // Services
+  AnalyticsEngineService,
+  analyticsEngineService,
+  PerformanceService,
+  performanceService,
+  // Types
+  type Metric,
+  type TimeSeriesData,
+  type ChartData,
+  type FunnelStep,
+  type FunnelData,
+  type CohortAnalysis,
+  type UserSegment,
+  type KPIData,
+  type KPIs,
+  type ChartType,
+  type ChartConfig,
+  type MetricCardProps,
+  type AnalyticsCardProps,
+  type AnalyticsLayoutProps,
+  type DateRangePreset,
+  type DateRangeValue,
+  type AnalyticsExportOptions,
+  type ConversionPath,
+  type HeatmapData,
+  type UserBehaviorPrediction,
+  type UserData,
+  type ConversionData,
+  type FunnelItem,
+  type ActivityItem,
+  type PerformanceMetric,
+  type DashboardMetrics,
+  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,
+  type DataConfig,
+  type ChartsConfig,
+  type PerformanceConfig as DashboardPerformanceConfig,
+  type DashboardConfig as DashboardConfigType,
+} from './domain/config';