react-native-bikram-sambat 0.1.0

package/src/range-helpers.test.ts

@@ -0,0 +1,153 @@
+import {
+  isBSDateInSupportedRange,
+  clampBSDateToSupportedRange,
+  getDefaultSupportedBSDate,
+  getSafeCalendarMonth,
+  SUPPORTED_BS_START_YEAR,
+  SUPPORTED_BS_END_YEAR,
+  getSupportedBSRange,
+} from './core';
+
+describe('supported range helpers', () => {
+  it('exports start and end year constants', () => {
+    expect(SUPPORTED_BS_START_YEAR).toBe(2081);
+    expect(SUPPORTED_BS_END_YEAR).toBe(2081);
+  });
+
+  it('getSupportedBSRange returns correct range', () => {
+    const range = getSupportedBSRange();
+    expect(range).toEqual({ start: 2081, end: 2081 });
+  });
+});
+
+describe('isBSDateInSupportedRange', () => {
+  it('returns true for dates inside supported range', () => {
+    expect(
+      isBSDateInSupportedRange({ calendar: 'BS', year: 2081, month: 1, day: 1 })
+    ).toBe(true);
+    expect(
+      isBSDateInSupportedRange({ calendar: 'BS', year: 2081, month: 12, day: 30 })
+    ).toBe(true);
+  });
+
+  it('returns false for dates outside supported range', () => {
+    expect(
+      isBSDateInSupportedRange({ calendar: 'BS', year: 2080, month: 1, day: 1 })
+    ).toBe(false);
+    expect(
+      isBSDateInSupportedRange({ calendar: 'BS', year: 2082, month: 1, day: 1 })
+    ).toBe(false);
+  });
+
+  it('returns false for invalid calendar', () => {
+    expect(
+      isBSDateInSupportedRange({ calendar: 'AD' as any, year: 2081, month: 1, day: 1 })
+    ).toBe(false);
+  });
+});
+
+describe('clampBSDateToSupportedRange', () => {
+  it('returns same date when already in range', () => {
+    const date = { calendar: 'BS' as const, year: 2081, month: 6, day: 15 };
+    expect(clampBSDateToSupportedRange(date)).toEqual(date);
+  });
+
+  it('clamps year below range to start year month 1 day 1', () => {
+    const result = clampBSDateToSupportedRange({
+      calendar: 'BS',
+      year: 2080,
+      month: 6,
+      day: 15,
+    });
+    expect(result.year).toBe(2081);
+    expect(result.month).toBe(1);
+    expect(result.day).toBe(1);
+  });
+
+  it('clamps year above range to end year month 12 day 30', () => {
+    const result = clampBSDateToSupportedRange({
+      calendar: 'BS',
+      year: 2082,
+      month: 6,
+      day: 15,
+    });
+    expect(result.year).toBe(2081);
+    expect(result.month).toBe(12);
+    expect(result.day).toBe(30);
+  });
+
+  it('clamps month to valid range', () => {
+    const result = clampBSDateToSupportedRange({
+      calendar: 'BS',
+      year: 2081,
+      month: 13,
+      day: 1,
+    });
+    expect(result.month).toBe(12);
+  });
+
+  it('clamps day to valid month length', () => {
+    const result = clampBSDateToSupportedRange({
+      calendar: 'BS',
+      year: 2081,
+      month: 8,
+      day: 30,
+    });
+    expect(result.day).toBe(29);
+  });
+});
+
+describe('getDefaultSupportedBSDate', () => {
+  it('returns first day of first supported year', () => {
+    const date = getDefaultSupportedBSDate();
+    expect(date).toEqual({
+      calendar: 'BS',
+      year: 2081,
+      month: 1,
+      day: 1,
+    });
+  });
+});
+
+describe('getSafeCalendarMonth', () => {
+  it('uses value when in supported range', () => {
+    const result = getSafeCalendarMonth({
+      value: { calendar: 'BS', year: 2081, month: 5, day: 10 },
+    });
+    expect(result).toEqual({ year: 2081, month: 5 });
+  });
+
+  it('uses defaultValue when value is null', () => {
+    const result = getSafeCalendarMonth({
+      value: null,
+      defaultValue: { calendar: 'BS', year: 2081, month: 3, day: 1 },
+    });
+    expect(result).toEqual({ year: 2081, month: 3 });
+  });
+
+  it('uses year/month when in supported range', () => {
+    const result = getSafeCalendarMonth({
+      year: 2081,
+      month: 7,
+    });
+    expect(result).toEqual({ year: 2081, month: 7 });
+  });
+
+  it('falls back to supported range when year is out of range', () => {
+    const result = getSafeCalendarMonth({
+      year: 2082,
+      month: 1,
+    });
+    expect(result).toEqual({ year: 2081, month: 1 });
+  });
+
+  it('falls back to supported range when no valid input', () => {
+    const result = getSafeCalendarMonth({});
+    expect(result).toEqual({ year: 2081, month: 1 });
+  });
+
+  it('falls back to supported range when input is undefined', () => {
+    const result = getSafeCalendarMonth();
+    expect(result).toEqual({ year: 2081, month: 1 });
+  });
+});

package/src/theme/create-theme.ts

@@ -0,0 +1,29 @@
+import { useColorScheme } from 'react-native';
+import type { CalendarTheme, ColorScheme } from './types';
+import { LIGHT_THEME, DARK_THEME } from './default-theme';
+
+export function useCalendarTheme(options?: {
+  colorScheme?: ColorScheme;
+  theme?: Partial<CalendarTheme>;
+}): CalendarTheme {
+  const deviceScheme = useColorScheme();
+  const colorScheme = options?.colorScheme ?? 'system';
+  const resolved = colorScheme === 'system' ? deviceScheme : colorScheme;
+  const base = resolved === 'dark' ? DARK_THEME : LIGHT_THEME;
+
+  if (!options?.theme) return base;
+
+  return deepMergeThemes(base, options.theme);
+}
+
+function deepMergeThemes(
+  base: CalendarTheme,
+  override: Partial<CalendarTheme>
+): CalendarTheme {
+  return {
+    colors: { ...base.colors, ...(override.colors ?? {}) },
+    radius: { ...base.radius, ...(override.radius ?? {}) },
+    spacing: { ...base.spacing, ...(override.spacing ?? {}) },
+    typography: { ...base.typography, ...(override.typography ?? {}) },
+  };
+}

package/src/theme/default-theme.ts

@@ -0,0 +1,99 @@
+import type { TextStyle } from 'react-native';
+import type { CalendarTheme } from './types';
+
+const headerStyle: TextStyle = {
+  fontSize: 18,
+  fontWeight: '600',
+};
+
+const weekdayStyle: TextStyle = {
+  fontSize: 12,
+  fontWeight: '500',
+};
+
+const dayStyle: TextStyle = {
+  fontSize: 15,
+  fontWeight: '400',
+};
+
+export const LIGHT_THEME: CalendarTheme = {
+  colors: {
+    background: '#ffffff',
+    surface: '#ffffff',
+    text: '#111827',
+    mutedText: '#6b7280',
+    primary: '#2563eb',
+    primaryText: '#ffffff',
+    todayBorder: '#2563eb',
+    disabledText: '#d1d5db',
+    outsideMonthText: '#d1d5db',
+    border: '#e5e7eb',
+    marker: '#2563eb',
+    overlay: 'rgba(0, 0, 0, 0.5)',
+    modalBackground: '#ffffff',
+    fieldBackground: '#ffffff',
+    fieldBorder: '#e5e7eb',
+    placeholderText: '#9ca3af',
+    rangeBackground: '#dbeafe',
+    rangeText: '#1e40af',
+    rangeStartBackground: '#2563eb',
+    rangeEndBackground: '#2563eb',
+    danger: '#ef4444',
+  },
+  radius: {
+    day: 20,
+    calendar: 12,
+  },
+  spacing: {
+    xs: 4,
+    sm: 8,
+    md: 12,
+    lg: 16,
+  },
+  typography: {
+    header: headerStyle,
+    weekday: weekdayStyle,
+    day: dayStyle,
+  },
+};
+
+export const DARK_THEME: CalendarTheme = {
+  colors: {
+    background: '#111827',
+    surface: '#1f2937',
+    text: '#f9fafb',
+    mutedText: '#9ca3af',
+    primary: '#3b82f6',
+    primaryText: '#ffffff',
+    todayBorder: '#3b82f6',
+    disabledText: '#4b5563',
+    outsideMonthText: '#4b5563',
+    border: '#374151',
+    marker: '#3b82f6',
+    overlay: 'rgba(0, 0, 0, 0.6)',
+    modalBackground: '#1f2937',
+    fieldBackground: '#1f2937',
+    fieldBorder: '#374151',
+    placeholderText: '#6b7280',
+    rangeBackground: '#1e3a5f',
+    rangeText: '#93c5fd',
+    rangeStartBackground: '#3b82f6',
+    rangeEndBackground: '#3b82f6',
+    danger: '#f87171',
+  },
+  radius: {
+    day: 20,
+    calendar: 12,
+  },
+  spacing: {
+    xs: 4,
+    sm: 8,
+    md: 12,
+    lg: 16,
+  },
+  typography: {
+    header: headerStyle,
+    weekday: weekdayStyle,
+    day: dayStyle,
+  },
+};

package/src/theme/index.ts

@@ -0,0 +1,3 @@
+export type { CalendarTheme, ColorScheme } from './types';
+export { LIGHT_THEME, DARK_THEME } from './default-theme';
+export { useCalendarTheme } from './create-theme';

package/src/theme/types.ts

@@ -0,0 +1,44 @@
+import type { TextStyle } from 'react-native';
+
+export type CalendarTheme = {
+  colors: {
+    background: string;
+    surface: string;
+    text: string;
+    mutedText: string;
+    primary: string;
+    primaryText: string;
+    todayBorder: string;
+    disabledText: string;
+    outsideMonthText: string;
+    border: string;
+    marker: string;
+    overlay: string;
+    modalBackground: string;
+    fieldBackground: string;
+    fieldBorder: string;
+    placeholderText: string;
+    rangeBackground: string;
+    rangeText: string;
+    rangeStartBackground: string;
+    rangeEndBackground: string;
+    danger: string;
+  };
+  radius: {
+    day: number;
+    calendar: number;
+  };
+  spacing: {
+    xs: number;
+    sm: number;
+    md: number;
+    lg: number;
+  };
+  typography: {
+    header: TextStyle;
+    weekday: TextStyle;
+    day: TextStyle;
+  };
+};
+
+export type ColorScheme = 'light' | 'dark' | 'system';

package/src/utils/date-helpers.ts

@@ -0,0 +1,146 @@
+import type { BSDateValue } from '../core/types';
+import { formatBS } from '../core/format';
+import { isValidBSDate, isBSDateInSupportedRange, getDefaultSupportedBSDate } from '../core/validation';
+import type { LocaleCode, NumeralSystem, CalendarLocale } from '../core/locale';
+
+export function safeFormatBSDate(
+  date: BSDateValue | null | undefined,
+  pattern: string,
+  locale?: LocaleCode | CalendarLocale,
+  numerals?: NumeralSystem
+): string | null {
+  if (!date) return null;
+  if (!isValidBSDate(date)) return null;
+  if (!isBSDateInSupportedRange(date)) return null;
+
+  try {
+    return formatBS(date, pattern, { locale, numerals });
+  } catch {
+    return null;
+  }
+}
+
+export function getSafeInitialBSDate(
+  value: BSDateValue | null | undefined,
+  defaultValue: BSDateValue | undefined
+): BSDateValue {
+  if (value && isValidBSDate(value) && isBSDateInSupportedRange(value)) {
+    return value;
+  }
+
+  if (defaultValue && isValidBSDate(defaultValue) && isBSDateInSupportedRange(defaultValue)) {
+    return defaultValue;
+  }
+
+  return getDefaultSupportedBSDate();
+}
+
+export function isDateDisabled(
+  date: BSDateValue,
+  options: {
+    minDate?: BSDateValue;
+    maxDate?: BSDateValue;
+    disabledDates?: string[] | ((date: BSDateValue) => boolean);
+    dateKey: string;
+  }
+): boolean {
+  const { minDate, maxDate, disabledDates, dateKey } = options;
+
+  if (minDate && compareBSDate(date, minDate) < 0) return true;
+  if (maxDate && compareBSDate(date, maxDate) > 0) return true;
+
+  if (Array.isArray(disabledDates)) {
+    return disabledDates.includes(dateKey);
+  }
+
+  if (typeof disabledDates === 'function') {
+    return disabledDates(date);
+  }
+
+  return false;
+}
+
+function compareBSDate(a: BSDateValue, b: BSDateValue): number {
+  if (a.year !== b.year) return a.year - b.year;
+  if (a.month !== b.month) return a.month - b.month;
+  return a.day - b.day;
+}
+
+export function createDateAccessibilityLabel(
+  date: BSDateValue,
+  locale: CalendarLocale,
+  options: {
+    selected?: boolean;
+    today?: boolean;
+    disabled?: boolean;
+    outsideMonth?: boolean;
+    rangeStart?: boolean;
+    rangeEnd?: boolean;
+    inRange?: boolean;
+    markedLabel?: string;
+  }
+): string {
+  const {
+    selected,
+    today,
+    disabled,
+    outsideMonth,
+    rangeStart,
+    rangeEnd,
+    inRange,
+    markedLabel,
+  } = options;
+
+  const parts: string[] = [];
+
+  try {
+    parts.push(formatBS(date, 'yyyy MMMM d', { locale }));
+  } catch {
+    parts.push(`${date.year}/${date.month}/${date.day}`);
+  }
+
+  if (rangeStart) parts.push('range start');
+  if (rangeEnd) parts.push('range end');
+  if (inRange && !rangeStart && !rangeEnd) parts.push('in selected range');
+  if (selected && !inRange) parts.push('selected');
+  if (today) parts.push('today');
+  if (disabled) parts.push('disabled');
+  if (outsideMonth) parts.push('outside month');
+  if (markedLabel) parts.push(markedLabel);
+
+  return parts.join(', ');
+}
+
+export function warnInvalidDateInDev(
+  message: string,
+  value: unknown
+): void {
+  if (__DEV__) {
+    console.warn(`react-native-bikram-sambat: ${message}`, value);
+  }
+}
+
+export function warnOutOfRangeInDev(
+  value: BSDateValue,
+  range: { min: number; max: number }
+): void {
+  if (__DEV__) {
+    const dateStr = `${value.year}-${String(value.month).padStart(2, '0')}-${String(value.day).padStart(2, '0')}`;
+    console.warn(
+      `react-native-bikram-sambat: value ${dateStr} is outside supported BS range ${range.min}–${range.max}. Falling back to ${range.min}-01-01.`
+    );
+  }
+}
+
+export function warnMinMaxInDev(
+  minDate: BSDateValue | undefined,
+  maxDate: BSDateValue | undefined
+): void {
+  if (__DEV__ && minDate && maxDate) {
+    if (compareBSDate(minDate, maxDate) > 0) {
+      console.warn(
+        'react-native-bikram-sambat: minDate is after maxDate. This may cause unexpected behavior.'
+      );
+    }
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export {
+  safeFormatBSDate,
+  getSafeInitialBSDate,
+  isDateDisabled,
+  createDateAccessibilityLabel,
+  warnInvalidDateInDev,
+  warnOutOfRangeInDev,
+  warnMinMaxInDev,
+} from './date-helpers';