@nepdatejs/core 0.0.0-bootstrap → 0.1.0

package/src/errors.ts

@@ -0,0 +1,43 @@
+export type NepDateRangeErrorCode =
+  /** The year, month or day does not exist in that calendar. */
+  | 'INVALID_DATE'
+  /** The date is outside the BS table, so it cannot be a BS date or be converted. */
+  | 'OUT_OF_TABLE'
+  /** A value of the wrong kind: not an integer, unknown time zone, bad text, … */
+  | 'INVALID_ARGUMENT';
+
+/** Thrown for any invalid date or argument. Check `code`, not the message. */
+export class NepDateRangeError extends RangeError {
+  readonly code: NepDateRangeErrorCode;
+
+  constructor(code: NepDateRangeErrorCode, message: string) {
+    super(message);
+    this.name = 'NepDateRangeError';
+    this.code = code;
+  }
+}
+
+export type NepDateDataErrorCode =
+  'EMPTY' | 'BAD_MONTH_COUNT' | 'BAD_MONTH' | 'BAD_YEAR_TOTAL' | 'BAD_ANCHOR';
+
+/** Thrown when a BS table passed to `setBsData` or `patchBsYear` is not valid. */
+export class NepDateDataError extends Error {
+  readonly code: NepDateDataErrorCode;
+  /** The BS year at fault, when there is one. */
+  readonly year: number | undefined;
+  /** The month (1–12) at fault, when there is one. */
+  readonly month: number | undefined;
+
+  constructor(
+    code: NepDateDataErrorCode,
+    message: string,
+    year?: number,
+    month?: number,
+  ) {
+    super(message);
+    this.name = 'NepDateDataError';
+    this.code = code;
+    this.year = year;
+    this.month = month;
+  }
+}

package/src/fiscal.ts

@@ -0,0 +1,50 @@
+import { BS_FISCAL_YEAR_START_MONTH } from './bs/data-api';
+import { compareDates } from './compare';
+import { toCalendar } from './convert';
+import { bsDate, daysInMonth } from './create';
+import { formatNumber } from './locale/index';
+import type { CalendarDate, FiscalYear, LocaleCode } from './types';
+
+/** The fiscal year a date falls in: 1 Shrawan to the end of Asar. */
+export function fiscalYear(date: CalendarDate): FiscalYear {
+  const bs = toCalendar(date, 'BS');
+
+  return fiscalYearRange(bs.month >= BS_FISCAL_YEAR_START_MONTH ? bs.year : bs.year - 1);
+}
+
+/** The fiscal year that starts in BS `startYear` (2083 → FY 2083/84). */
+export function fiscalYearRange(startYear: number): FiscalYear {
+  const endYear = startYear + 1;
+  const lastMonth = BS_FISCAL_YEAR_START_MONTH - 1;
+
+  return Object.freeze({
+    startYear,
+    label: `${startYear}/${String(endYear % 100).padStart(2, '0')}`,
+    firstDay: bsDate(startYear, BS_FISCAL_YEAR_START_MONTH, 1),
+    lastDay: bsDate(endYear, lastMonth, daysInMonth('BS', endYear, lastMonth)),
+  });
+}
+
+/**
+ * label "2083/84" · full "2083/2084" · cbms "2083.084" (the form Nepal's tax
+ * system uses). Digits follow the locale.
+ */
+export function formatFiscalYear(
+  fy: FiscalYear,
+  style: 'label' | 'full' | 'cbms' = 'label',
+  locale?: LocaleCode,
+): string {
+  const end = fy.startYear + 1;
+  const text =
+    style === 'full'
+      ? `${fy.startYear}/${end}`
+      : style === 'cbms'
+        ? `${fy.startYear}.${String(end % 1000).padStart(3, '0')}`
+        : fy.label;
+
+  return formatNumber(text, locale);
+}
+
+export function isInFiscalYear(date: CalendarDate, fy: FiscalYear): boolean {
+  return compareDates(date, fy.firstDay) >= 0 && compareDates(date, fy.lastDay) <= 0;
+}

package/src/format.ts

@@ -0,0 +1,88 @@
+import { dayOfWeek } from './compare';
+import { formatNumber, getLocale } from './locale/index';
+import type { CalendarDate, LocaleCode } from './types';
+
+/** Named formats. `cbms` is the dotted form Nepal's tax system uses. */
+export const DATE_FORMATS: {
+  readonly iso: 'Y-m-d';
+  readonly cbms: 'Y.m.d';
+  readonly short: 'j M Y';
+  readonly long: 'j F Y';
+  readonly full: 'l, j F Y';
+} = Object.freeze({
+  iso: 'Y-m-d',
+  cbms: 'Y.m.d',
+  short: 'j M Y',
+  long: 'j F Y',
+  full: 'l, j F Y',
+});
+
+export type NamedFormat = keyof typeof DATE_FORMATS;
+/** A named format, or a pattern of tokens (see formatDate). */
+export type DateFormatPattern = NamedFormat | (string & Record<never, never>);
+
+/**
+ * Format a date in its own calendar. Tokens: Y 2083, y 83, m 06, n 6, d 09,
+ * j 9, F month name, M short month name, l weekday, D short weekday. Put a
+ * backslash before a letter to print it as is. Digits follow the locale.
+ *
+ *   formatDate(bsDate(2082, 4, 1), 'full')        → "Thursday, 1 Shrawan 2082"
+ *   formatDate(bsDate(2082, 4, 1), 'long', 'ne')  → "१ साउन २०८२"
+ */
+export function formatDate(
+  date: CalendarDate,
+  pattern: DateFormatPattern = 'iso',
+  locale?: LocaleCode,
+): string {
+  const tokens: string =
+    pattern in DATE_FORMATS ? DATE_FORMATS[pattern as NamedFormat] : pattern;
+  const data = getLocale(locale);
+  const months = data.months[date.calendar];
+  const digits = (value: string | number): string => formatNumber(value, locale);
+  const pad = (value: number): string => String(value).padStart(2, '0');
+  let output = '';
+
+  for (let index = 0; index < tokens.length; index++) {
+    const token = tokens.charAt(index);
+    switch (token) {
+      case '\\':
+        index++;
+        output += tokens.charAt(index);
+        break;
+      case 'Y':
+        output += digits(date.year);
+        break;
+      case 'y':
+        output += digits(pad(((date.year % 100) + 100) % 100));
+        break;
+      case 'm':
+        output += digits(pad(date.month));
+        break;
+      case 'n':
+        output += digits(date.month);
+        break;
+      case 'd':
+        output += digits(pad(date.day));
+        break;
+      case 'j':
+        output += digits(date.day);
+        break;
+      case 'F':
+        output += months.long[date.month - 1] ?? '';
+        break;
+      case 'M':
+        output += months.short[date.month - 1] ?? '';
+        break;
+      case 'l':
+        output += data.weekdays.long[dayOfWeek(date)] ?? '';
+        break;
+      case 'D':
+        output += data.weekdays.short[dayOfWeek(date)] ?? '';
+        break;
+      default:
+        output += token;
+    }
+  }
+
+  return output;
+}

package/src/index.ts

@@ -0,0 +1,126 @@
+/**
+ * @nepdatejs/core: the source of truth for Bikram Sambat (BS) and AD dates.
+ * No package dependencies; built-ins only (docs/plan D-004).
+ */
+export type {
+  AdDate,
+  BsData,
+  BsDate,
+  CalendarDate,
+  CalendarSystem,
+  DateOf,
+  EpochDay,
+  FiscalYear,
+  LocaleCode,
+  MonthNumber,
+  Weekday,
+} from './types';
+
+export {
+  NepDateDataError,
+  NepDateRangeError,
+  type NepDateDataErrorCode,
+  type NepDateRangeErrorCode,
+} from './errors';
+
+export { toEpochDay, weekdayOf } from './epoch';
+export { configure, getConfig, resetConfig, type NepDateConfig } from './config';
+
+export { isAdLeapYear, MAX_AD_YEAR } from './ad/calendar';
+export { bsFirstYear, bsLastYear } from './bs/table';
+export {
+  BS_FISCAL_YEAR_START_MONTH,
+  getBsData,
+  patchBsYear,
+  resetBsData,
+  setBsData,
+  validateBsData,
+} from './bs/data-api';
+
+export {
+  adDate,
+  bsDate,
+  createDate,
+  daysInMonth,
+  isAdDate,
+  isBsDate,
+  isCalendarDate,
+  isValidDate,
+} from './create';
+
+export {
+  adToBs,
+  bsToAd,
+  fromEpoch,
+  fromIsoDate,
+  fromIsoTimestamp,
+  fromJsDate,
+  isConvertible,
+  maxDate,
+  minDate,
+  toCalendar,
+  toEpoch,
+  toIsoDate,
+} from './convert';
+export { isProjected } from './projected';
+export { now, today } from './clock';
+
+export {
+  addDays,
+  addMonths,
+  addYears,
+  differenceInDays,
+  eachDayOfInterval,
+  eachDayOfMonth,
+  endOfMonth,
+  endOfWeek,
+  endOfYear,
+  startOfMonth,
+  startOfWeek,
+  startOfYear,
+} from './arithmetic';
+
+export {
+  clampDate,
+  compareDates,
+  dayOfWeek,
+  isAfter,
+  isBefore,
+  isSameDay,
+  isSameMonth,
+  isSameYear,
+  isWeekend,
+  isWithin,
+} from './compare';
+
+export {
+  formatMessage,
+  formatNumber,
+  getLocale,
+  hasLocale,
+  monthNames,
+  registerLocale,
+  toAsciiDigits,
+  toDevanagariDigits,
+  weekdayNames,
+  type LocaleData,
+} from './locale/index';
+
+export {
+  DATE_FORMATS,
+  formatDate,
+  type DateFormatPattern,
+  type NamedFormat,
+} from './format';
+export { parseDate, parseDateStrict, parseFiscalYear } from './parse';
+export { fiscalYear, fiscalYearRange, formatFiscalYear, isInFiscalYear } from './fiscal';
+export {
+  compareTimes,
+  formatTime,
+  fromIsoDateTime,
+  isValidTime,
+  parseTime,
+  timeOfDay,
+  toIsoDateTime,
+  type TimeOfDay,
+} from './time';

package/src/locale/en.ts

@@ -0,0 +1,93 @@
+import type { LocaleData } from './registry';
+
+const bsMonths = [
+  'Baisakh',
+  'Jestha',
+  'Asar',
+  'Shrawan',
+  'Bhadra',
+  'Ashwin',
+  'Kartik',
+  'Mangsir',
+  'Poush',
+  'Magh',
+  'Falgun',
+  'Chaitra',
+];
+const adMonths = [
+  'January',
+  'February',
+  'March',
+  'April',
+  'May',
+  'June',
+  'July',
+  'August',
+  'September',
+  'October',
+  'November',
+  'December',
+];
+
+export const en: LocaleData = {
+  digits: ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'],
+  weekdays: {
+    long: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
+    short: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'],
+    narrow: ['Su', 'Mo', 'Tu', 'We', 'Th', 'Fr', 'Sa'],
+  },
+  months: {
+    AD: { long: adMonths, short: adMonths.map((name) => name.slice(0, 3)) },
+    BS: { long: bsMonths, short: bsMonths.map((name) => name.slice(0, 3)) },
+  },
+  calendarNames: { AD: 'AD', BS: 'BS' },
+  labels: {
+    today: 'Today',
+    clear: 'Clear date',
+    previousMonth: 'Previous month',
+    nextMonth: 'Next month',
+    previousYear: 'Previous year',
+    nextYear: 'Next year',
+    month: 'Month',
+    year: 'Year',
+    openCalendar: 'Open calendar',
+    chooseDate: 'Choose a date',
+    calendar: 'Calendar',
+    presets: 'Shortcuts',
+    fiscalYear: 'Fiscal year',
+    time: 'Time',
+    hour: 'Hour',
+    minute: 'Minute',
+    now: 'Now',
+    done: 'Done',
+  },
+  time: { am: 'AM', pm: 'PM' },
+  presets: {
+    today: 'Today',
+    yesterday: 'Yesterday',
+    tomorrow: 'Tomorrow',
+    thisWeek: 'This week',
+    lastWeek: 'Last week',
+    last7Days: 'Last 7 days',
+    last30Days: 'Last 30 days',
+    thisMonth: 'This month',
+    lastMonth: 'Last month',
+    thisYear: 'This year',
+    thisFiscalYear: 'This fiscal year',
+    lastFiscalYear: 'Last fiscal year',
+  },
+  messages: {
+    invalidFormat: {
+      AD: 'Enter an AD date as YYYY-MM-DD.',
+      BS: 'Enter a BS date as YYYY-MM-DD.',
+    },
+    outOfRange: 'Choose a date from {min} to {max}.',
+    onOrAfter: 'Choose {min} or later.',
+    onOrBefore: 'Choose {max} or earlier.',
+    unavailable: 'This date is not available.',
+    rangeTooShort: 'Choose at least {min} days.',
+    rangeTooLong: 'Choose at most {max} days.',
+    tooManyDates: 'Choose at most {max} dates.',
+    invalidTime: 'Enter a time as HH:MM.',
+  },
+};

package/src/locale/index.ts

@@ -0,0 +1,49 @@
+import { getConfig } from '../config';
+import type { CalendarSystem, LocaleCode } from '../types';
+import { localeData, type LocaleData } from './registry';
+
+export { hasLocale, registerLocale, type LocaleData } from './registry';
+
+const DEVANAGARI = ['०', '१', '२', '३', '४', '५', '६', '७', '८', '९'];
+
+/** The data for a locale (the configured default when omitted; English when unknown). */
+export function getLocale(locale: LocaleCode = getConfig().defaultLocale): LocaleData {
+  return localeData(locale);
+}
+
+export function monthNames(
+  calendar: CalendarSystem,
+  locale?: LocaleCode,
+  width: 'long' | 'short' = 'long',
+): readonly string[] {
+  return getLocale(locale).months[calendar][width];
+}
+
+export function weekdayNames(
+  locale?: LocaleCode,
+  width: 'long' | 'short' | 'narrow' = 'long',
+): readonly string[] {
+  return getLocale(locale).weekdays[width];
+}
+
+/** Replace Devanagari digits with ASCII digits. */
+export function toAsciiDigits(value: string): string {
+  return value.replace(/[०-९]/g, (digit) => String(DEVANAGARI.indexOf(digit)));
+}
+
+/** Replace ASCII digits with Devanagari digits. */
+export function toDevanagariDigits(value: string | number): string {
+  return String(value).replace(/[0-9]/g, (digit) => DEVANAGARI[Number(digit)] ?? digit);
+}
+
+/** Write a number (or digit string) with the locale's digits. */
+export function formatNumber(value: string | number, locale?: LocaleCode): string {
+  const { digits } = getLocale(locale);
+
+  return String(value).replace(/[0-9]/g, (digit) => digits[Number(digit)] ?? digit);
+}
+
+/** Fill {name} placeholders in a locale message. */
+export function formatMessage(template: string, values: Record<string, string>): string {
+  return template.replace(/\{(\w+)\}/g, (whole, name: string) => values[name] ?? whole);
+}

package/src/locale/ne.ts

@@ -0,0 +1,93 @@
+import type { LocaleData } from './registry';
+
+const bsMonths = [
+  'बैशाख',
+  'जेठ',
+  'असार',
+  'साउन',
+  'भदौ',
+  'असोज',
+  'कार्तिक',
+  'मङ्सिर',
+  'पुस',
+  'माघ',
+  'फाल्गुण',
+  'चैत',
+];
+const adMonths = [
+  'जनवरी',
+  'फेब्रुअरी',
+  'मार्च',
+  'अप्रिल',
+  'मे',
+  'जुन',
+  'जुलाई',
+  'अगस्ट',
+  'सेप्टेम्बर',
+  'अक्टोबर',
+  'नोभेम्बर',
+  'डिसेम्बर',
+];
+
+export const ne: LocaleData = {
+  digits: ['०', '१', '२', '३', '४', '५', '६', '७', '८', '९'],
+  weekdays: {
+    long: ['आइतबार', 'सोमबार', 'मङ्गलबार', 'बुधबार', 'बिहिबार', 'शुक्रबार', 'शनिबार'],
+    short: ['आइत', 'सोम', 'मङ्गल', 'बुध', 'बिही', 'शुक्र', 'शनि'],
+    narrow: ['आ', 'सो', 'मं', 'बु', 'बि', 'शु', 'श'],
+  },
+  months: {
+    AD: { long: adMonths, short: adMonths },
+    BS: { long: bsMonths, short: bsMonths },
+  },
+  calendarNames: { AD: 'ई.सं.', BS: 'वि.सं.' },
+  labels: {
+    today: 'आज',
+    clear: 'मिति हटाउनुहोस्',
+    previousMonth: 'अघिल्लो महिना',
+    nextMonth: 'अर्को महिना',
+    previousYear: 'अघिल्लो वर्ष',
+    nextYear: 'अर्को वर्ष',
+    month: 'महिना',
+    year: 'वर्ष',
+    openCalendar: 'पात्रो खोल्नुहोस्',
+    chooseDate: 'मिति छान्नुहोस्',
+    calendar: 'पात्रो',
+    presets: 'छिटो छनोट',
+    fiscalYear: 'आर्थिक वर्ष',
+    time: 'समय',
+    hour: 'घण्टा',
+    minute: 'मिनेट',
+    now: 'अहिले',
+    done: 'भयो',
+  },
+  time: { am: 'पूर्वाह्न', pm: 'अपराह्न' },
+  presets: {
+    today: 'आज',
+    yesterday: 'हिजो',
+    tomorrow: 'भोलि',
+    thisWeek: 'यो हप्ता',
+    lastWeek: 'गत हप्ता',
+    last7Days: 'पछिल्लो ७ दिन',
+    last30Days: 'पछिल्लो ३० दिन',
+    thisMonth: 'यो महिना',
+    lastMonth: 'गत महिना',
+    thisYear: 'यो वर्ष',
+    thisFiscalYear: 'यो आर्थिक वर्ष',
+    lastFiscalYear: 'गत आर्थिक वर्ष',
+  },
+  messages: {
+    invalidFormat: {
+      AD: 'ई.सं. मिति YYYY-MM-DD ढाँचामा लेख्नुहोस्।',
+      BS: 'वि.सं. मिति YYYY-MM-DD ढाँचामा लेख्नुहोस्।',
+    },
+    outOfRange: '{min} देखि {max} सम्मको मिति छान्नुहोस्।',
+    onOrAfter: '{min} वा त्यसपछिको मिति छान्नुहोस्।',
+    onOrBefore: '{max} वा त्यसअघिको मिति छान्नुहोस्।',
+    unavailable: 'यो मिति उपलब्ध छैन।',
+    rangeTooShort: 'कम्तीमा {min} दिन छान्नुहोस्।',
+    rangeTooLong: 'बढीमा {max} दिन छान्नुहोस्।',
+    tooManyDates: 'बढीमा {max} मिति छान्नुहोस्।',
+    invalidTime: 'समय HH:MM ढाँचामा लेख्नुहोस्।',
+  },
+};

package/src/locale/registry.ts

@@ -0,0 +1,114 @@
+import { NepDateRangeError } from '../errors';
+import type { LocaleCode } from '../types';
+import { en } from './en';
+import { ne } from './ne';
+
+type Names12 = readonly string[];
+
+/** Everything a language needs: digits, names, UI labels and validation messages. */
+export interface LocaleData {
+  /** Ten digit characters, 0–9. */
+  readonly digits: readonly string[];
+  /** Seven names each, Sunday first. */
+  readonly weekdays: {
+    readonly long: readonly string[];
+    readonly short: readonly string[];
+    readonly narrow: readonly string[];
+  };
+  /** Twelve names each, first month first. */
+  readonly months: {
+    readonly AD: { readonly long: Names12; readonly short: Names12 };
+    readonly BS: { readonly long: Names12; readonly short: Names12 };
+  };
+  /** How each calendar is named in this language: "BS" / "वि.सं.". */
+  readonly calendarNames: { readonly AD: string; readonly BS: string };
+  readonly labels: {
+    readonly today: string;
+    readonly clear: string;
+    readonly previousMonth: string;
+    readonly nextMonth: string;
+    readonly previousYear: string;
+    readonly nextYear: string;
+    readonly month: string;
+    readonly year: string;
+    readonly openCalendar: string;
+    readonly chooseDate: string;
+    readonly calendar: string;
+    /** Picker shortcuts (presets) and the name of their list. */
+    readonly presets: string;
+    readonly fiscalYear: string;
+    readonly time: string;
+    readonly hour: string;
+    readonly minute: string;
+    readonly now: string;
+    readonly done: string;
+  };
+  /** Words for 12-hour times. */
+  readonly time: { readonly am: string; readonly pm: string };
+  /** Names of the built-in picker presets. */
+  readonly presets: {
+    readonly today: string;
+    readonly yesterday: string;
+    readonly tomorrow: string;
+    readonly thisWeek: string;
+    readonly lastWeek: string;
+    readonly last7Days: string;
+    readonly last30Days: string;
+    readonly thisMonth: string;
+    readonly lastMonth: string;
+    readonly thisYear: string;
+    readonly thisFiscalYear: string;
+    readonly lastFiscalYear: string;
+  };
+  /** Messages may use {min} and {max} placeholders. */
+  readonly messages: {
+    readonly invalidFormat: { readonly AD: string; readonly BS: string };
+    readonly outOfRange: string;
+    readonly onOrAfter: string;
+    readonly onOrBefore: string;
+    readonly unavailable: string;
+    /** Range pickers: {min} / {max} are day counts. */
+    readonly rangeTooShort: string;
+    readonly rangeTooLong: string;
+    /** Multiple-date pickers: {max} is a count of dates. */
+    readonly tooManyDates: string;
+    readonly invalidTime: string;
+  };
+}
+
+const locales = new Map<string, LocaleData>([
+  ['en', en],
+  ['ne', ne],
+]);
+
+/** Add or replace a language. Lists must have the right lengths (10 digits, 7 weekdays, 12 months). */
+export function registerLocale(code: LocaleCode, data: LocaleData): void {
+  const checks: [string, readonly string[], number][] = [
+    ['digits', data.digits, 10],
+    ['weekdays.long', data.weekdays.long, 7],
+    ['weekdays.short', data.weekdays.short, 7],
+    ['weekdays.narrow', data.weekdays.narrow, 7],
+    ['months.AD.long', data.months.AD.long, 12],
+    ['months.AD.short', data.months.AD.short, 12],
+    ['months.BS.long', data.months.BS.long, 12],
+    ['months.BS.short', data.months.BS.short, 12],
+  ];
+  for (const [name, list, length] of checks) {
+    if (list.length !== length) {
+      throw new NepDateRangeError(
+        'INVALID_ARGUMENT',
+        `Locale "${code}": ${name} must have ${length} entries, not ${list.length}.`,
+      );
+    }
+  }
+  locales.set(code, data);
+}
+
+export function hasLocale(code: LocaleCode): boolean {
+  return locales.has(code);
+}
+
+/** The data for a locale, or English when the locale is not registered. */
+export function localeData(code: LocaleCode): LocaleData {
+  return locales.get(code) ?? en;
+}