react-native-bikram-sambat 0.1.0

package/src/core/validation.test.ts

@@ -0,0 +1,207 @@
+import {
+  adDateToEpochDay,
+  createBSDateKey,
+  createBSYearOffsets,
+  epochDayToADDate,
+  epochDayToJSDate,
+  getBSMonthLength,
+  getSupportedBSRange,
+  isValidADDate,
+  isValidBSDate,
+  jsDateToEpochDay,
+  parseBSDateKey,
+  toAD,
+  toBS,
+  SUPPORTED_BS_START_YEAR,
+  SUPPORTED_BS_END_YEAR,
+} from './index';
+
+describe('BS date validation', () => {
+  it('accepts dates inside the available placeholder data range', () => {
+    expect(
+      isValidBSDate({ calendar: 'BS', year: 2081, month: 1, day: 1 })
+    ).toBe(true);
+    expect(
+      isValidBSDate({ calendar: 'BS', year: 2081, month: 4, day: 31 })
+    ).toBe(true);
+  });
+
+  it('rejects dates outside month lengths or available data', () => {
+    expect(
+      isValidBSDate({ calendar: 'BS', year: 2081, month: 8, day: 30 })
+    ).toBe(false);
+    expect(
+      isValidBSDate({ calendar: 'BS', year: 2082, month: 1, day: 1 })
+    ).toBe(false);
+  });
+
+  it('rejects dates outside the supported year range', () => {
+    expect(
+      isValidBSDate({ calendar: 'BS', year: 2080, month: 1, day: 1 })
+    ).toBe(false);
+    expect(
+      isValidBSDate({ calendar: 'BS', year: 2082, month: 1, day: 1 })
+    ).toBe(false);
+    expect(
+      isValidBSDate({ calendar: 'BS', year: 2000, month: 1, day: 1 })
+    ).toBe(false);
+  });
+
+  it('returns month lengths for supported BS years', () => {
+    expect(getBSMonthLength(2081, 1)).toBe(31);
+    expect(getBSMonthLength(2081, 8)).toBe(29);
+  });
+
+  it('throws for unsupported years with range in message', () => {
+    expect(() => getBSMonthLength(2082, 1)).toThrow(/2081–2081/);
+    expect(() => getBSMonthLength(2080, 1)).toThrow(/2081–2081/);
+    expect(() => getBSMonthLength(2081, 0)).toThrow(RangeError);
+    expect(() => getBSMonthLength(2081, 13)).toThrow(RangeError);
+  });
+});
+
+describe('supported BS range', () => {
+  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('AD date validation', () => {
+  it('accepts real AD dates and rejects calendar overflows', () => {
+    expect(
+      isValidADDate({ calendar: 'AD', year: 2024, month: 2, day: 29 })
+    ).toBe(true);
+    expect(
+      isValidADDate({ calendar: 'AD', year: 2023, month: 2, day: 29 })
+    ).toBe(false);
+  });
+
+  it('handles AD years 0 through 99 without Date.UTC remapping', () => {
+    expect(isValidADDate({ calendar: 'AD', year: 1, month: 1, day: 1 })).toBe(
+      true
+    );
+    expect(isValidADDate({ calendar: 'AD', year: 1, month: 2, day: 29 })).toBe(
+      false
+    );
+  });
+});
+
+describe('BS date keys', () => {
+  it('creates stable YYYY-MM-DD keys', () => {
+    expect(
+      createBSDateKey({ calendar: 'BS', year: 2081, month: 1, day: 3 })
+    ).toBe('2081-01-03');
+  });
+
+  it('parses valid keys', () => {
+    expect(parseBSDateKey('2081-01-03')).toEqual({
+      calendar: 'BS',
+      year: 2081,
+      month: 1,
+      day: 3,
+    });
+  });
+
+  it('rejects malformed or invalid keys', () => {
+    expect(parseBSDateKey('2081-1-03')).toBeNull();
+    expect(parseBSDateKey('2081-08-30')).toBeNull();
+  });
+});
+
+describe('Stage 1 conversion architecture', () => {
+  it('round-trips the placeholder anchor date', () => {
+    const bs = { calendar: 'BS' as const, year: 2081, month: 1, day: 1 };
+    const ad = { calendar: 'AD' as const, year: 2024, month: 4, day: 13 };
+
+    expect(toAD(bs)).toEqual(ad);
+    expect(toBS(ad)).toEqual(bs);
+  });
+
+  it('converts dates at the end of the available placeholder range', () => {
+    const bs = { calendar: 'BS' as const, year: 2081, month: 12, day: 30 };
+    const ad = toAD(bs);
+
+    expect(toBS(ad)).toEqual(bs);
+  });
+
+  it('throws instead of guessing outside the available placeholder range', () => {
+    expect(() =>
+      toBS({ calendar: 'AD', year: 2024, month: 4, day: 12 })
+    ).toThrow(RangeError);
+    expect(() =>
+      toAD({ calendar: 'BS', year: 2082, month: 1, day: 1 })
+    ).toThrow(RangeError);
+  });
+
+  it('requires year data to start at the BS anchor year', () => {
+    expect(() =>
+      createBSYearOffsets({
+        anchorBS: { calendar: 'BS', year: 2081, month: 1, day: 1 },
+        anchorAD: { calendar: 'AD', year: 2024, month: 4, day: 13 },
+        monthLengthsByYear: {
+          2082: [31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+        },
+      })
+    ).toThrow(/contiguous/);
+  });
+
+  it('requires the BS anchor to be the first day of a BS year', () => {
+    expect(() =>
+      createBSYearOffsets({
+        anchorBS: { calendar: 'BS', year: 2081, month: 1, day: 2 },
+        anchorAD: { calendar: 'AD', year: 2024, month: 4, day: 14 },
+        monthLengthsByYear: {
+          2081: [31, 31, 32, 31, 31, 31, 30, 29, 30, 29, 30, 30],
+        },
+      })
+    ).toThrow(/first day/);
+  });
+});
+
+describe('UTC epoch-day utilities', () => {
+  it('round-trips AD dates through integer epoch days', () => {
+    const ad = { calendar: 'AD' as const, year: 2024, month: 4, day: 13 };
+
+    expect(
+      epochDayToADDate(jsDateToEpochDay(new Date(Date.UTC(2024, 3, 13))))
+    ).toEqual(ad);
+  });
+
+  it('round-trips AD years 0 through 99 through epoch days', () => {
+    const ad = { calendar: 'AD' as const, year: 1, month: 1, day: 1 };
+
+    expect(epochDayToADDate(adDateToEpochDay(ad))).toEqual(ad);
+  });
+
+  it('reads JS Date UTC parts without remapping years 0 through 99', () => {
+    const value = new Date(0);
+    value.setUTCFullYear(1, 0, 1);
+    value.setUTCHours(0, 0, 0, 0);
+
+    expect(epochDayToADDate(jsDateToEpochDay(value))).toEqual({
+      calendar: 'AD',
+      year: 1,
+      month: 1,
+      day: 1,
+    });
+  });
+
+  it('returns UTC-midnight Date objects from epoch days', () => {
+    const jsDate = epochDayToJSDate(
+      jsDateToEpochDay(new Date(Date.UTC(2024, 3, 13, 23, 59, 59)))
+    );
+
+    expect(jsDate.toISOString()).toBe('2024-04-13T00:00:00.000Z');
+  });
+
+  it('rejects fractional epoch days', () => {
+    expect(() => epochDayToADDate(1.5)).toThrow(RangeError);
+    expect(() => epochDayToJSDate(1.5)).toThrow(RangeError);
+  });
+});

package/src/core/validation.ts

@@ -0,0 +1,141 @@
+import type { ADDateValue, BSDateValue } from './types';
+import { BS_CALENDAR_DATA, getSupportedBSYearRange } from './bsData';
+import { utcMillisForADDate } from './epochDay';
+
+export function getBSMonthLength(year: number, month: number): number {
+  const monthLengths = BS_CALENDAR_DATA.monthLengthsByYear[year];
+
+  if (!monthLengths) {
+    const range = getSupportedBSYearRange();
+    throw new RangeError(
+      `BS year ${year} is outside the supported data range (${range.min}–${range.max}).`
+    );
+  }
+
+  if (!Number.isInteger(month) || month < 1 || month > 12) {
+    throw new RangeError(`BS month must be an integer from 1 to 12.`);
+  }
+
+  return monthLengths[month - 1];
+}
+
+export function isValidBSDate(date: BSDateValue): boolean {
+  if (
+    date.calendar !== 'BS' ||
+    !Number.isInteger(date.year) ||
+    !Number.isInteger(date.month) ||
+    !Number.isInteger(date.day) ||
+    date.month < 1 ||
+    date.month > 12
+  ) {
+    return false;
+  }
+
+  const range = getSupportedBSYearRange();
+
+  if (date.year < range.min || date.year > range.max) {
+    return false;
+  }
+
+  const monthLengths = BS_CALENDAR_DATA.monthLengthsByYear[date.year];
+
+  if (!monthLengths) {
+    return false;
+  }
+
+  return date.day >= 1 && date.day <= monthLengths[date.month - 1];
+}
+
+export function isBSDateInSupportedRange(date: BSDateValue): boolean {
+  if (
+    date.calendar !== 'BS' ||
+    !Number.isInteger(date.year) ||
+    !Number.isInteger(date.month) ||
+    !Number.isInteger(date.day)
+  ) {
+    return false;
+  }
+
+  const range = getSupportedBSYearRange();
+  return date.year >= range.min && date.year <= range.max;
+}
+
+export function clampBSDateToSupportedRange(date: BSDateValue): BSDateValue {
+  const range = getSupportedBSYearRange();
+
+  if (date.year < range.min) {
+    return { calendar: 'BS', year: range.min, month: 1, day: 1 };
+  }
+
+  if (date.year > range.max) {
+    return { calendar: 'BS', year: range.max, month: 12, day: 30 };
+  }
+
+  const monthLengths = BS_CALENDAR_DATA.monthLengthsByYear[date.year];
+  if (!monthLengths) {
+    return { calendar: 'BS', year: range.min, month: 1, day: 1 };
+  }
+
+  const clampedMonth = Math.max(1, Math.min(12, date.month));
+  const maxDay = monthLengths[clampedMonth - 1];
+  const clampedDay = Math.max(1, Math.min(maxDay, date.day));
+
+  return { calendar: 'BS', year: date.year, month: clampedMonth, day: clampedDay };
+}
+
+export function getDefaultSupportedBSDate(): BSDateValue {
+  const range = getSupportedBSYearRange();
+  return { calendar: 'BS', year: range.min, month: 1, day: 1 };
+}
+
+export function getSafeCalendarMonth(input?: {
+  year?: number;
+  month?: number;
+  value?: BSDateValue | null;
+  defaultValue?: BSDateValue;
+}): { year: number; month: number } {
+  const range = getSupportedBSYearRange();
+
+  if (input?.value && isBSDateInSupportedRange(input.value)) {
+    return { year: input.value.year, month: input.value.month };
+  }
+
+  if (input?.defaultValue && isBSDateInSupportedRange(input.defaultValue)) {
+    return { year: input.defaultValue.year, month: input.defaultValue.month };
+  }
+
+  if (
+    input?.year != null &&
+    input?.month != null &&
+    input.year >= range.min &&
+    input.year <= range.max &&
+    input.month >= 1 &&
+    input.month <= 12
+  ) {
+    return { year: input.year, month: input.month };
+  }
+
+  return { year: range.min, month: 1 };
+}
+
+export function isValidADDate(date: ADDateValue): boolean {
+  if (
+    date.calendar !== 'AD' ||
+    !Number.isInteger(date.year) ||
+    !Number.isInteger(date.month) ||
+    !Number.isInteger(date.day) ||
+    date.month < 1 ||
+    date.month > 12 ||
+    date.day < 1
+  ) {
+    return false;
+  }
+
+  const value = new Date(utcMillisForADDate(date));
+
+  return (
+    value.getUTCFullYear() === date.year &&
+    value.getUTCMonth() + 1 === date.month &&
+    value.getUTCDate() === date.day
+  );
+}

package/src/exports.test.ts

@@ -0,0 +1,135 @@
+import {
+  NepaliCalendar,
+  type NepaliCalendarProps,
+  type CalendarTheme,
+  type CalendarMarkedDate,
+  type BSDateValue,
+  NepaliDatePicker,
+  DatePickerModal,
+  type NepaliDatePickerProps,
+  type DatePickerModalProps,
+  NepaliRangePicker,
+  RangePickerModal,
+  type NepaliRangePickerProps,
+  type RangePickerModalProps,
+  type DateRangeValue,
+} from './index';
+
+describe('root package exports', () => {
+  it('exports NepaliCalendar component', () => {
+    expect(typeof NepaliCalendar).toBe('function');
+  });
+
+  it('exports NepaliCalendarProps type (compile-time check)', () => {
+    const _props: NepaliCalendarProps = {};
+    expect(_props).toBeDefined();
+  });
+
+  it('exports CalendarTheme type (compile-time check)', () => {
+    const _theme: CalendarTheme = {
+      colors: {
+        background: '#fff',
+        surface: '#fff',
+        text: '#000',
+        mutedText: '#666',
+        primary: '#2563eb',
+        primaryText: '#fff',
+        todayBorder: '#2563eb',
+        disabledText: '#ccc',
+        outsideMonthText: '#ccc',
+        border: '#eee',
+        marker: '#2563eb',
+        overlay: 'rgba(0, 0, 0, 0.5)',
+        modalBackground: '#fff',
+        fieldBackground: '#fff',
+        fieldBorder: '#eee',
+        placeholderText: '#999',
+        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: { fontSize: 18 },
+        weekday: { fontSize: 12 },
+        day: { fontSize: 15 },
+      },
+    };
+    expect(_theme.colors.primary).toBe('#2563eb');
+  });
+
+  it('exports CalendarMarkedDate type (compile-time check)', () => {
+    const _marked: CalendarMarkedDate = {
+      type: 'holiday',
+      label: 'Test',
+      color: '#ef4444',
+    };
+    expect(_marked.type).toBe('holiday');
+  });
+
+  it('exports BSDateValue type (compile-time check)', () => {
+    const _date: BSDateValue = {
+      calendar: 'BS',
+      year: 2081,
+      month: 1,
+      day: 1,
+    };
+    expect(_date.calendar).toBe('BS');
+  });
+
+  it('exports NepaliDatePicker component', () => {
+    expect(typeof NepaliDatePicker).toBe('function');
+  });
+
+  it('exports DatePickerModal component', () => {
+    expect(typeof DatePickerModal).toBe('function');
+  });
+
+  it('exports NepaliDatePickerProps type (compile-time check)', () => {
+    const _props: NepaliDatePickerProps = {
+      placeholder: 'Select date',
+    };
+    expect(_props.placeholder).toBe('Select date');
+  });
+
+  it('exports DatePickerModalProps type (compile-time check)', () => {
+    const _props: DatePickerModalProps = {
+      visible: false,
+    };
+    expect(_props.visible).toBe(false);
+  });
+
+  it('exports NepaliRangePicker component', () => {
+    expect(typeof NepaliRangePicker).toBe('function');
+  });
+
+  it('exports RangePickerModal component', () => {
+    expect(typeof RangePickerModal).toBe('function');
+  });
+
+  it('exports NepaliRangePickerProps type (compile-time check)', () => {
+    const _props: NepaliRangePickerProps = {
+      placeholder: 'Select range',
+    };
+    expect(_props.placeholder).toBe('Select range');
+  });
+
+  it('exports RangePickerModalProps type (compile-time check)', () => {
+    const _props: RangePickerModalProps = {
+      visible: false,
+    };
+    expect(_props.visible).toBe(false);
+  });
+
+  it('exports DateRangeValue type (compile-time check)', () => {
+    const _range: DateRangeValue = {
+      start: { calendar: 'BS', year: 2081, month: 1, day: 1 },
+      end: { calendar: 'BS', year: 2081, month: 1, day: 15 },
+    };
+    expect(_range.start?.year).toBe(2081);
+    expect(_range.end?.year).toBe(2081);
+  });
+});

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './core';
+export * from './calendar';
+export * from './components/NepaliCalendar';
+export * from './components/NepaliDatePicker';
+export * from './components/NepaliRangePicker';
+export * from './theme';
+export * from './accessibility';
+export * from './utils';