react-native-bikram-sambat 0.1.0

package/src/core/conversion.ts

@@ -0,0 +1,73 @@
+import type { ADDateValue, BSDateValue } from './types';
+import { adDateToEpochDay, epochDayToADDate } from './epochDay';
+import {
+  BS_CALENDAR_DATA,
+  BS_YEAR_OFFSETS,
+  getSupportedBSYearRange,
+} from './bsData';
+import { isValidADDate, isValidBSDate } from './validation';
+
+export function toBS(date: ADDateValue): BSDateValue {
+  if (!isValidADDate(date)) {
+    throw new RangeError(`Invalid AD date.`);
+  }
+
+  const epochDay = adDateToEpochDay(date);
+  const yearOffset = BS_YEAR_OFFSETS.find(
+    (offset) =>
+      epochDay >= offset.startEpochDay &&
+      epochDay < offset.startEpochDay + offset.totalDays
+  );
+
+  if (!yearOffset) {
+    throwUnsupportedRange();
+  }
+
+  const monthLengths = BS_CALENDAR_DATA.monthLengthsByYear[yearOffset.year];
+  let dayOfYear = epochDay - yearOffset.startEpochDay;
+
+  for (let monthIndex = 0; monthIndex < monthLengths.length; monthIndex += 1) {
+    const monthLength = monthLengths[monthIndex];
+
+    if (dayOfYear < monthLength) {
+      return {
+        calendar: 'BS',
+        year: yearOffset.year,
+        month: monthIndex + 1,
+        day: dayOfYear + 1,
+      };
+    }
+
+    dayOfYear -= monthLength;
+  }
+
+  throw new Error(`Failed to convert AD date to BS date.`);
+}
+
+export function toAD(date: BSDateValue): ADDateValue {
+  if (!isValidBSDate(date)) {
+    throw new RangeError(`Invalid BS date or unsupported BS year.`);
+  }
+
+  const yearOffset = BS_YEAR_OFFSETS.find((offset) => offset.year === date.year);
+
+  if (!yearOffset) {
+    throwUnsupportedRange();
+  }
+
+  const monthLengths = BS_CALENDAR_DATA.monthLengthsByYear[date.year];
+  const daysBeforeMonth = monthLengths
+    .slice(0, date.month - 1)
+    .reduce((sum, days) => sum + days, 0);
+  const epochDay = yearOffset.startEpochDay + daysBeforeMonth + date.day - 1;
+
+  return epochDayToADDate(epochDay);
+}
+
+function throwUnsupportedRange(): never {
+  const range = getSupportedBSYearRange();
+
+  throw new RangeError(
+    `Conversion is limited to BS years ${range.min}-${range.max} until verified month data is added.`
+  );
+}

package/src/core/dateKey.ts

@@ -0,0 +1,31 @@
+import type { BSDateKey, BSDateValue } from './types';
+import { isValidBSDate } from './validation';
+
+function pad2(value: number): string {
+  return String(value).padStart(2, '0');
+}
+
+export function createBSDateKey(date: BSDateValue): BSDateKey {
+  if (!isValidBSDate(date)) {
+    throw new RangeError(`Cannot create a BS date key from an invalid date.`);
+  }
+
+  return `${date.year}-${pad2(date.month)}-${pad2(date.day)}`;
+}
+
+export function parseBSDateKey(key: string): BSDateValue | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(key);
+
+  if (!match) {
+    return null;
+  }
+
+  const date: BSDateValue = {
+    calendar: 'BS',
+    year: Number(match[1]),
+    month: Number(match[2]),
+    day: Number(match[3]),
+  };
+
+  return isValidBSDate(date) ? date : null;
+}

package/src/core/epochDay.ts

@@ -0,0 +1,49 @@
+import type { ADDateValue } from './types';
+
+const MS_PER_DAY = 86_400_000;
+
+export function adDateToEpochDay(date: ADDateValue): number {
+  return Math.floor(utcMillisForADDate(date) / MS_PER_DAY);
+}
+
+export function epochDayToADDate(epochDay: number): ADDateValue {
+  if (!Number.isInteger(epochDay)) {
+    throw new RangeError(`Epoch day must be an integer.`);
+  }
+
+  const value = new Date(epochDay * MS_PER_DAY);
+
+  return {
+    calendar: 'AD',
+    year: value.getUTCFullYear(),
+    month: value.getUTCMonth() + 1,
+    day: value.getUTCDate(),
+  };
+}
+
+export function jsDateToEpochDay(date: Date): number {
+  return Math.floor(
+    utcMillisForADDate({
+      calendar: 'AD',
+      year: date.getUTCFullYear(),
+      month: date.getUTCMonth() + 1,
+      day: date.getUTCDate(),
+    }) / MS_PER_DAY
+  );
+}
+
+export function epochDayToJSDate(epochDay: number): Date {
+  if (!Number.isInteger(epochDay)) {
+    throw new RangeError(`Epoch day must be an integer.`);
+  }
+
+  return new Date(epochDay * MS_PER_DAY);
+}
+
+export function utcMillisForADDate(date: ADDateValue): number {
+  const value = new Date(0);
+  value.setUTCFullYear(date.year, date.month - 1, date.day);
+  value.setUTCHours(0, 0, 0, 0);
+
+  return value.getTime();
+}

package/src/core/format/format.ts

@@ -0,0 +1,108 @@
+import type { BSDateValue } from '../types';
+import type { CalendarLocale, LocaleCode, NumeralSystem } from '../locale';
+import { EN_LOCALE, NE_LOCALE } from '../locale';
+import { toNepaliNumerals } from '../numerals';
+import { toAD } from '../conversion';
+import { isValidBSDate } from '../validation';
+import { getSupportedBSYearRange } from '../bsData';
+import { FORMAT_TOKENS, NUMERIC_TOKENS, FormatToken } from './tokens';
+
+export type FormatBSOptions = {
+  locale?: LocaleCode | CalendarLocale;
+  numerals?: NumeralSystem;
+};
+
+function resolveLocale(locale: LocaleCode | CalendarLocale | undefined): CalendarLocale {
+  if (!locale) return EN_LOCALE;
+  if (typeof locale === 'string') {
+    return locale === 'ne' ? NE_LOCALE : EN_LOCALE;
+  }
+  return locale;
+}
+
+function pad2(value: number): string {
+  return String(value).padStart(2, '0');
+}
+
+function formatToken(
+  date: BSDateValue,
+  token: FormatToken,
+  locale: CalendarLocale
+): string {
+  switch (token) {
+    case 'yyyy':
+      return String(date.year);
+    case 'yy':
+      return String(date.year).slice(-2);
+    case 'MMMM':
+      return locale.months[date.month - 1];
+    case 'MMM':
+      return locale.monthsShort[date.month - 1];
+    case 'MM':
+      return pad2(date.month);
+    case 'M':
+      return String(date.month);
+    case 'EEEE':
+      return locale.weekdays[getUTCDay(date)];
+    case 'EEE':
+    case 'E':
+      return locale.weekdaysShort[getUTCDay(date)];
+    case 'dd':
+      return pad2(date.day);
+    case 'd':
+      return String(date.day);
+    default:
+      return token;
+  }
+}
+
+function getUTCDay(date: BSDateValue): number {
+  const ad = toAD(date);
+  const utcDate = new Date(Date.UTC(ad.year, ad.month - 1, ad.day));
+  return utcDate.getUTCDay();
+}
+
+export function formatBS(
+  date: BSDateValue,
+  pattern: string,
+  options?: FormatBSOptions
+): string {
+  if (!isValidBSDate(date)) {
+    const range = getSupportedBSYearRange();
+    const dateStr = `${date.year}-${String(date.month).padStart(2, '0')}-${String(date.day).padStart(2, '0')}`;
+    throw new RangeError(
+      `Cannot format invalid BS date ${dateStr}. Supported BS range is ${range.min}–${range.max}.`
+    );
+  }
+
+  const locale = resolveLocale(options?.locale);
+  const numerals = options?.numerals;
+  let result = '';
+  let i = 0;
+
+  while (i < pattern.length) {
+    let matched = false;
+
+    for (const token of FORMAT_TOKENS) {
+      if (pattern.slice(i, i + token.length) === token) {
+        let value = formatToken(date, token, locale);
+
+        if (numerals === 'devanagari' && NUMERIC_TOKENS.has(token)) {
+          value = toNepaliNumerals(value);
+        }
+
+        result += value;
+        i += token.length;
+        matched = true;
+        break;
+      }
+    }
+
+    if (!matched) {
+      result += pattern[i];
+      i += 1;
+    }
+  }
+
+  return result;
+}

package/src/core/format/index.ts

@@ -0,0 +1,4 @@
+export type { FormatBSOptions } from './format';
+export type { ParseBSOptions } from './parse';
+export { formatBS } from './format';
+export { parseBS } from './parse';

package/src/core/format/parse.ts

@@ -0,0 +1,68 @@
+import type { BSDateValue } from '../types';
+import type { NumeralSystem } from '../locale';
+import { toLatinNumerals } from '../numerals';
+import { isValidBSDate } from '../validation';
+
+export type ParseBSOptions = {
+  numerals?: NumeralSystem;
+};
+
+const SUPPORTED_PATTERNS = ['yyyy-MM-dd'] as const;
+
+type SupportedPattern = (typeof SUPPORTED_PATTERNS)[number];
+
+function isSupportedPattern(pattern: string): pattern is SupportedPattern {
+  return SUPPORTED_PATTERNS.includes(pattern as SupportedPattern);
+}
+
+function parseWithPattern(
+  value: string,
+  pattern: SupportedPattern,
+  numerals: NumeralSystem | undefined
+): BSDateValue | null {
+  const normalized = numerals === 'devanagari' ? toLatinNumerals(value) : value;
+
+  if (pattern === 'yyyy-MM-dd') {
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(normalized);
+
+    if (!match) return null;
+
+    return {
+      calendar: 'BS',
+      year: Number(match[1]),
+      month: Number(match[2]),
+      day: Number(match[3]),
+    };
+  }
+
+  return null;
+}
+
+export function parseBS(
+  value: string,
+  pattern: string,
+  options?: ParseBSOptions
+): BSDateValue {
+  if (!isSupportedPattern(pattern)) {
+    throw new Error(
+      `Unsupported parse pattern "${pattern}". Phase 2 only supports "yyyy-MM-dd".`
+    );
+  }
+
+  const numerals = options?.numerals;
+  const result = parseWithPattern(value, pattern, numerals);
+
+  if (!result) {
+    throw new Error(
+      `Failed to parse "${value}" with pattern "${pattern}". Expected 4-digit year, 2-digit month, and 2-digit day separated by hyphens.`
+    );
+  }
+
+  if (!isValidBSDate(result)) {
+    throw new RangeError(
+      `Parsed date ${result.year}-${String(result.month).padStart(2, '0')}-${String(result.day).padStart(2, '0')} is not a valid BS date or falls outside the supported data range.`
+    );
+  }
+
+  return result;
+}

package/src/core/format/tokens.ts

@@ -0,0 +1,35 @@
+export type FormatToken =
+  | 'yyyy'
+  | 'yy'
+  | 'MMMM'
+  | 'MMM'
+  | 'MM'
+  | 'M'
+  | 'EEEE'
+  | 'EEE'
+  | 'E'
+  | 'dd'
+  | 'd';
+
+export const FORMAT_TOKENS: readonly FormatToken[] = [
+  'yyyy',
+  'yy',
+  'MMMM',
+  'MMM',
+  'MM',
+  'M',
+  'EEEE',
+  'EEE',
+  'E',
+  'dd',
+  'd',
+];
+
+export const NUMERIC_TOKENS: ReadonlySet<FormatToken> = new Set([
+  'yyyy',
+  'yy',
+  'MM',
+  'M',
+  'dd',
+  'd',
+]);

package/src/core/index.ts

@@ -0,0 +1,10 @@
+export * from './types';
+export * from './epochDay';
+export * from './bsData';
+export * from './conversion';
+export * from './dateKey';
+export * from './validation';
+export * from './arithmetic';
+export * from './numerals';
+export * from './locale';
+export * from './format';

package/src/core/locale/en.ts

@@ -0,0 +1,23 @@
+import type { CalendarLocale } from './types';
+
+export const EN_LOCALE: CalendarLocale = {
+  code: 'en',
+  months: [
+    'Baisakh',
+    'Jestha',
+    'Ashadh',
+    'Shrawan',
+    'Bhadra',
+    'Ashwin',
+    'Kartik',
+    'Mangsir',
+    'Poush',
+    'Magh',
+    'Falgun',
+    'Chaitra',
+  ],
+  monthsShort: ['Bai', 'Jes', 'Ash', 'Shr', 'Bha', 'Asw', 'Kar', 'Man', 'Pou', 'Mag', 'Fal', 'Cha'],
+  weekdays: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+  weekdaysShort: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+  today: 'Today',
+};

package/src/core/locale/index.ts

@@ -0,0 +1,3 @@
+export type { LocaleCode, NumeralSystem, CalendarLocale } from './types';
+export { EN_LOCALE } from './en';
+export { NE_LOCALE } from './ne';

package/src/core/locale/ne.ts

@@ -0,0 +1,31 @@
+import type { CalendarLocale } from './types';
+
+export const NE_LOCALE: CalendarLocale = {
+  code: 'ne',
+  months: [
+    'बैशाख',
+    'जेठ',
+    'असार',
+    'श्रावण',
+    'भाद्र',
+    'आश्विन',
+    'कार्तिक',
+    'मंसिर',
+    'पौष',
+    'माघ',
+    'फाल्गुन',
+    'चैत्र',
+  ],
+  monthsShort: ['बै', 'जे', 'अ', 'श्रा', 'भा', 'आ', 'का', 'मं', 'पौ', 'मा', 'फा', 'चै'],
+  weekdays: [
+    'आइतबार',
+    'सोमबार',
+    'मंगलबार',
+    'बुधबार',
+    'बिहीबार',
+    'शुक्रबार',
+    'शनिबार',
+  ],
+  weekdaysShort: ['आइत', 'सोम', 'मंगल', 'बुध', 'बिही', 'शुक्र', 'शनि'],
+  today: 'आज',
+};

package/src/core/locale/types.ts

@@ -0,0 +1,12 @@
+export type LocaleCode = 'en' | 'ne';
+
+export type NumeralSystem = 'latin' | 'devanagari';
+
+export type CalendarLocale = {
+  code: LocaleCode;
+  months: string[];
+  monthsShort: string[];
+  weekdays: string[];
+  weekdaysShort: string[];
+  today: string;
+};

package/src/core/numerals/index.ts

@@ -0,0 +1 @@
+export { toNepaliNumerals, toLatinNumerals } from './nepali-numerals';

package/src/core/numerals/nepali-numerals.ts

@@ -0,0 +1,27 @@
+const DEVANAGARI_DIGITS = ['०', '१', '२', '३', '४', '५', '६', '७', '८', '९'];
+const LATIN_DIGITS = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'];
+
+export function toNepaliNumerals(value: string | number): string {
+  const str = typeof value === 'number' ? String(value) : value;
+
+  return str.replace(/[0-9]/g, (digit) => DEVANAGARI_DIGITS[Number(digit)]);
+}
+
+export function toLatinNumerals(value: string | number): string {
+  const str = typeof value === 'number' ? String(value) : value;
+
+  let result = '';
+
+  for (let i = 0; i < str.length; i++) {
+    const char = str[i];
+    const index = DEVANAGARI_DIGITS.indexOf(char);
+
+    if (index !== -1) {
+      result += LATIN_DIGITS[index];
+    } else {
+      result += char;
+    }
+  }
+
+  return result;
+}

package/src/core/types.ts

@@ -0,0 +1,15 @@
+export type BSDateValue = {
+  calendar: 'BS';
+  year: number;
+  month: number;
+  day: number;
+};
+
+export type ADDateValue = {
+  calendar: 'AD';
+  year: number;
+  month: number;
+  day: number;
+};
+
+export type BSDateKey = `${number}-${string}-${string}`;