@glatam/calendar-core 1.0.1 → 1.0.3

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@glatam/calendar-core",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "description": "Lógica pura del calendario @glatam/calendar",
   "type": "module",
   "author": "Santiago Hernández Saldarriaga",
   "license": "MIT",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "git+https://github.com/santiagoshs/glatam-calendar.git"
@@ -24,6 +27,7 @@
   ],
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "test": "vitest run"
   },
   "devDependencies": {

package/src/index.ts

@@ -1,116 +0,0 @@
-import { BlockingRule, CalendarDay, TimeSlot, EvaluatedTimeSlot } from './types.js';
-import { BlockingStrategyFactory } from './strategies/factory.js';
-import { formatISODate, getStartOfWeek } from './utils/date-utils.js';
-
-export * from './types.js';
-export * from './utils/date-utils.js';
-export * from './strategies/strategy.interface.js';
-export * from './strategies/weekly.strategy.js';
-export * from './strategies/date-range.strategy.js';
-export * from './strategies/factory.js';
-
-/**
- * Checks if a specific date or time slot is blocked and returns the matching rule.
- */
-export function getBlockingRule(date: Date, slot: TimeSlot | undefined, rules: BlockingRule[]): BlockingRule | undefined {
-  for (const rule of rules) {
-    const strategy = BlockingStrategyFactory.getStrategy(rule.type);
-    if (slot) {
-      if (strategy.isSlotBlocked(date, slot, rule)) return rule;
-    } else {
-      if (strategy.isDateBlocked(date, rule)) return rule;
-    }
-  }
-  return undefined;
-}
-
-export function isTimeBlocked(date: Date, slot: TimeSlot | undefined, rules: BlockingRule[]): boolean {
-  return !!getBlockingRule(date, slot, rules);
-}
-
-/**
- * Generates an array of CalendarDay items representing a monthly calendar grid.
- */
-export function generateMonthDays(
-  year: number,
-  month: number,
-  rules: BlockingRule[],
-  slotsPerDay: TimeSlot[] = [],
-  startOfWeekDay = 0
-): CalendarDay[] {
-  const firstDayOfMonth = new Date(year, month, 1);
-  const startGridDate = getStartOfWeek(firstDayOfMonth, startOfWeekDay);
-
-  const days: CalendarDay[] = [];
-  const currentDate = new Date(startGridDate);
-
-  for (let i = 0; i < 42; i++) {
-    const dateCopy = new Date(currentDate);
-    const dateString = formatISODate(dateCopy);
-
-    const evaluatedSlots: EvaluatedTimeSlot[] = slotsPerDay.map((slot) => {
-      const match = getBlockingRule(dateCopy, slot, rules);
-      return { ...slot, isBlocked: !!match, rule: match };
-    });
-
-    const dayRule = getBlockingRule(dateCopy, undefined, rules);
-    const isDayFullyBlocked = !!dayRule || (evaluatedSlots.length > 0 && evaluatedSlots.every((s) => s.isBlocked));
-
-    days.push({
-      dateString,
-      date: dateCopy,
-      isBlocked: isDayFullyBlocked,
-      rule: dayRule || (evaluatedSlots.length > 0 && evaluatedSlots.every((s) => s.isBlocked) ? evaluatedSlots[0].rule : undefined),
-      dayOfWeek: dateCopy.getDay(),
-      dayNumber: dateCopy.getDate(),
-      isCurrentMonth: dateCopy.getMonth() === month,
-      slots: evaluatedSlots,
-    });
-
-    currentDate.setDate(currentDate.getDate() + 1);
-  }
-
-  return days;
-}
-
-/**
- * Generates an array of 7 CalendarDay items representing a single week view.
- */
-export function generateWeekDays(
-  referenceDate: Date,
-  rules: BlockingRule[],
-  slotsPerDay: TimeSlot[] = [],
-  startOfWeekDay = 0
-): CalendarDay[] {
-  const startOfWeek = getStartOfWeek(referenceDate, startOfWeekDay);
-  const days: CalendarDay[] = [];
-  const currentDate = new Date(startOfWeek);
-
-  for (let i = 0; i < 7; i++) {
-    const dateCopy = new Date(currentDate);
-    const dateString = formatISODate(dateCopy);
-
-    const evaluatedSlots: EvaluatedTimeSlot[] = slotsPerDay.map((slot) => {
-      const match = getBlockingRule(dateCopy, slot, rules);
-      return { ...slot, isBlocked: !!match, rule: match };
-    });
-
-    const dayRule = getBlockingRule(dateCopy, undefined, rules);
-    const isDayFullyBlocked = !!dayRule || (evaluatedSlots.length > 0 && evaluatedSlots.every((s) => s.isBlocked));
-
-    days.push({
-      dateString,
-      date: dateCopy,
-      isBlocked: isDayFullyBlocked,
-      rule: dayRule || (evaluatedSlots.length > 0 && evaluatedSlots.every((s) => s.isBlocked) ? evaluatedSlots[0].rule : undefined),
-      dayOfWeek: dateCopy.getDay(),
-      dayNumber: dateCopy.getDate(),
-      isCurrentMonth: true,
-      slots: evaluatedSlots,
-    });
-
-    currentDate.setDate(currentDate.getDate() + 1);
-  }
-
-  return days;
-}

package/src/strategies/date-range.strategy.ts

@@ -1,41 +0,0 @@
-import { BlockingRule, TimeSlot } from '../types.js';
-import { BlockingStrategy } from './strategy.interface.js';
-import { formatISODate, isTimeOverlapping } from '../utils/date-utils.js';
-
-export class DateRangeStrategy implements BlockingStrategy {
-  isDateBlocked(date: Date, rule: BlockingRule): boolean {
-    if (!this.matchesDateRange(date, rule)) {
-      return false;
-    }
-    // If no slots are defined, the entire day is blocked.
-    return !rule.slots || rule.slots.length === 0;
-  }
-
-  isSlotBlocked(date: Date, slot: TimeSlot, rule: BlockingRule): boolean {
-    if (!this.matchesDateRange(date, rule)) {
-      return false;
-    }
-
-    // If no slots are defined, the entire day is blocked, so the slot is blocked.
-    if (!rule.slots || rule.slots.length === 0) {
-      return true;
-    }
-
-    // Check if the slot overlaps with any blocked slots in the rule
-    return rule.slots.some((blockedSlot) => isTimeOverlapping(slot, blockedSlot));
-  }
-
-  private matchesDateRange(date: Date, rule: BlockingRule): boolean {
-    const dateStr = formatISODate(date);
-
-    if (rule.startDate && dateStr < rule.startDate) {
-      return false;
-    }
-
-    if (rule.endDate && dateStr > rule.endDate) {
-      return false;
-    }
-
-    return true;
-  }
-}

package/src/strategies/factory.ts

@@ -1,22 +0,0 @@
-import { BlockingRuleType } from '../types.js';
-import { BlockingStrategy } from './strategy.interface.js';
-import { WeeklyStrategy } from './weekly.strategy.js';
-import { DateRangeStrategy } from './date-range.strategy.js';
-
-export class BlockingStrategyFactory {
-  private static strategies: Record<BlockingRuleType, BlockingStrategy> = {
-    weekly: new WeeklyStrategy(),
-    'date-range': new DateRangeStrategy(),
-  };
-
-  /**
-   * Retrieves the strategy for a given rule type.
-   */
-  static getStrategy(type: BlockingRuleType): BlockingStrategy {
-    const strategy = this.strategies[type];
-    if (!strategy) {
-      throw new Error(`Estrategia de bloqueo no soportada: ${type}`);
-    }
-    return strategy;
-  }
-}

package/src/strategies/strategy.interface.ts

@@ -1,16 +0,0 @@
-import { BlockingRule, TimeSlot } from '../types.js';
-
-export interface BlockingStrategy {
-  /**
-   * Evaluates if a given date is blocked by the rule.
-   * If the rule defines specific slots, a date is considered fully blocked
-   * only if the whole day is covered, or we check slot-by-slot.
-   * Here, isDateBlocked returns true if there is a day-wide block.
-   */
-  isDateBlocked(date: Date, rule: BlockingRule): boolean;
-
-  /**
-   * Evaluates if a specific time slot on a given date is blocked by this rule.
-   */
-  isSlotBlocked(date: Date, slot: TimeSlot, rule: BlockingRule): boolean;
-}

package/src/strategies/weekly.strategy.ts

@@ -1,46 +0,0 @@
-import { BlockingRule, TimeSlot } from '../types.js';
-import { BlockingStrategy } from './strategy.interface.js';
-import { formatISODate, isTimeOverlapping } from '../utils/date-utils.js';
-
-export class WeeklyStrategy implements BlockingStrategy {
-  isDateBlocked(date: Date, rule: BlockingRule): boolean {
-    if (!this.matchesDateAndDay(date, rule)) {
-      return false;
-    }
-    // If no slots are defined, the entire day is blocked.
-    return !rule.slots || rule.slots.length === 0;
-  }
-
-  isSlotBlocked(date: Date, slot: TimeSlot, rule: BlockingRule): boolean {
-    if (!this.matchesDateAndDay(date, rule)) {
-      return false;
-    }
-
-    // If no slots are defined, the entire day is blocked, so the slot is blocked.
-    if (!rule.slots || rule.slots.length === 0) {
-      return true;
-    }
-
-    // Check if the slot overlaps with any blocked slots in the rule
-    return rule.slots.some((blockedSlot) => isTimeOverlapping(slot, blockedSlot));
-  }
-
-  private matchesDateAndDay(date: Date, rule: BlockingRule): boolean {
-    const dayOfWeek = date.getDay();
-    if (!rule.daysOfWeek || !rule.daysOfWeek.includes(dayOfWeek)) {
-      return false;
-    }
-
-    const dateStr = formatISODate(date);
-
-    if (rule.startDate && dateStr < rule.startDate) {
-      return false;
-    }
-
-    if (rule.endDate && dateStr > rule.endDate) {
-      return false;
-    }
-
-    return true;
-  }
-}

package/src/types.ts

@@ -1,35 +0,0 @@
-export interface TimeSlot {
-  start: string;
-  end: string;
-}
-
-export type BlockingRuleType = 'weekly' | 'date-range';
-
-export interface BlockingRule {
-  id: string;
-  type: BlockingRuleType;
-  startDate?: string;
-  endDate?: string;
-  daysOfWeek?: number[];
-  slots?: TimeSlot[];
-  description?: string; // Descriptive title/notes for the task/block
-  [key: string]: any; // Allow custom metadata (assignees, status, priority)
-}
-
-export interface CalendarDay {
-  dateString: string;
-  date: Date;
-  isBlocked: boolean;
-  rule?: BlockingRule; // The rule blocking the whole day
-  dayOfWeek: number;
-  dayNumber: number;
-  isCurrentMonth: boolean;
-  slots: EvaluatedTimeSlot[];
-}
-
-export interface EvaluatedTimeSlot {
-  start: string;
-  end: string;
-  isBlocked: boolean;
-  rule?: BlockingRule; // The rule that caused the block
-}

package/src/utils/date-utils.ts

@@ -1,59 +0,0 @@
-import { TimeSlot } from '../types.js';
-
-/**
- * Parses an ISO date string (YYYY-MM-DD) into a local Date object.
- * Prevents timezone shifting issues.
- */
-export function parseISODate(dateStr: string): Date {
-  const parts = dateStr.split('T')[0].split('-');
-  if (parts.length !== 3) {
-    return new Date(dateStr);
-  }
-  const year = parseInt(parts[0], 10);
-  const month = parseInt(parts[1], 10) - 1; // 0-indexed
-  const day = parseInt(parts[2], 10);
-  return new Date(year, month, day);
-}
-
-/**
- * Formats a Date object to YYYY-MM-DD in the local timezone.
- */
-export function formatISODate(date: Date): string {
-  const year = date.getFullYear();
-  const month = String(date.getMonth() + 1).padStart(2, '0');
-  const day = String(date.getDate()).padStart(2, '0');
-  return `${year}-${month}-${day}`;
-}
-
-/**
- * Converts a time string "HH:MM" to minutes from midnight.
- */
-export function timeToMinutes(timeStr: string): number {
-  const [hours, minutes] = timeStr.split(':').map(Number);
-  return (hours || 0) * 60 + (minutes || 0);
-}
-
-/**
- * Checks if two time slots overlap.
- */
-export function isTimeOverlapping(slot1: TimeSlot, slot2: TimeSlot): boolean {
-  const start1 = timeToMinutes(slot1.start);
-  const end1 = timeToMinutes(slot1.end);
-  const start2 = timeToMinutes(slot2.start);
-  const end2 = timeToMinutes(slot2.end);
-
-  return start1 < end2 && start2 < end1;
-}
-
-/**
- * Gets the start of the week for a given date.
- * @param date The date reference.
- * @param startOfWeekDay The day the week starts (0 = Sunday, 1 = Monday). Default is 0.
- */
-export function getStartOfWeek(date: Date, startOfWeekDay = 0): Date {
-  const result = new Date(date.getFullYear(), date.getMonth(), date.getDate());
-  const day = result.getDay();
-  const diff = (day < startOfWeekDay ? 7 : 0) + day - startOfWeekDay;
-  result.setDate(result.getDate() - diff);
-  return result;
-}

package/tests/calendar.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  isTimeBlocked,
-  generateMonthDays,
-  generateWeekDays,
-  parseISODate,
-  formatISODate,
-  BlockingRule,
-  TimeSlot,
-} from '../src/index.js';
-
-describe('Calendar Core tests', () => {
-  describe('Date Utilities', () => {
-    it('should parse YYYY-MM-DD to local Date object timezone-neutrally', () => {
-      const parsed = parseISODate('2026-07-18');
-      expect(parsed.getFullYear()).toBe(2026);
-      expect(parsed.getMonth()).toBe(6); // July is 6
-      expect(parsed.getDate()).toBe(18);
-    });
-
-    it('should format Date object to YYYY-MM-DD string', () => {
-      const date = new Date(2026, 6, 18);
-      expect(formatISODate(date)).toBe('2026-07-18');
-    });
-  });
-
-  describe('isTimeBlocked with WeeklyStrategy', () => {
-    const rules: BlockingRule[] = [
-      {
-        id: '1',
-        type: 'weekly',
-        daysOfWeek: [1, 3], // Monday and Wednesday
-        slots: [
-          { start: '09:00', end: '11:00' },
-          { start: '14:00', end: '16:00' },
-        ],
-      },
-    ];
-
-    it('should block matching slots on Monday', () => {
-      const monday = new Date(2026, 6, 13); // Monday
-      const slot: TimeSlot = { start: '09:30', end: '10:30' };
-      expect(isTimeBlocked(monday, slot, rules)).toBe(true);
-    });
-
-    it('should NOT block non-matching slots on Monday', () => {
-      const monday = new Date(2026, 6, 13); // Monday
-      const slot: TimeSlot = { start: '11:30', end: '13:00' };
-      expect(isTimeBlocked(monday, slot, rules)).toBe(false);
-    });
-
-    it('should NOT block any slots on Tuesday', () => {
-      const tuesday = new Date(2026, 6, 14); // Tuesday
-      const slot: TimeSlot = { start: '09:30', end: '10:30' };
-      expect(isTimeBlocked(tuesday, slot, rules)).toBe(false);
-    });
-  });
-
-  describe('isTimeBlocked with DateRangeStrategy', () => {
-    const rules: BlockingRule[] = [
-      {
-        id: '2',
-        type: 'date-range',
-        startDate: '2026-07-20',
-        endDate: '2026-07-25',
-        // No slots means block the entire day
-      },
-    ];
-
-    it('should block any time on dates within range', () => {
-      const testDate = new Date(2026, 6, 22); // July 22, 2026
-      expect(isTimeBlocked(testDate, undefined, rules)).toBe(true);
-    });
-
-    it('should NOT block dates outside range', () => {
-      const testDate = new Date(2026, 6, 26); // July 26, 2026
-      expect(isTimeBlocked(testDate, undefined, rules)).toBe(false);
-    });
-  });
-
-  describe('Grid Generation', () => {
-    it('should generate 42 days for month view grid', () => {
-      const rules: BlockingRule[] = [];
-      const days = generateMonthDays(2026, 6, rules); // July 2026
-      expect(days.length).toBe(42);
-      // July 1st, 2026 is a Wednesday.
-      // If startOfWeekDay is 0 (Sunday), the first day of grid should be June 28th.
-      expect(days[0].dateString).toBe('2026-06-28');
-    });
-
-    it('should generate 7 days for week view grid', () => {
-      const rules: BlockingRule[] = [];
-      const days = generateWeekDays(new Date(2026, 6, 18), rules, [], 1); // July 18, 2026 (Saturday), start Monday
-      expect(days.length).toBe(7);
-      // Mon of that week is July 13th
-      expect(days[0].dateString).toBe('2026-07-13');
-      expect(days[6].dateString).toBe('2026-07-19');
-    });
-  });
-});

package/tsconfig.json

@@ -1,8 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "./dist",
-    "rootDir": "./src"
-  },
-  "include": ["src/**/*"]
-}