thai_buddhist_date

Screenshots & Demo

Thai Buddhist Date Example 1 Thai Buddhist Date Example 2

🎎 Click to view video demo

â–ķïļ Watch full video (MP4)

pub package CI license: MIT

A tiny Dart library for working with Thai Buddhist Era dates (āļž.āļĻ.), with selectable output era (āļž.āļĻ./āļ„.āļĻ.), safe token‑aware formatting, flexible parsing, and optional Flutter widgets.

Looking for calendar and dialog pickers? See the companion UI package:

Highlights

  • Format with BE or CE: format(DateTime, era: ...) outputs the year in āļž.āļĻ. (BE) or āļ„.āļĻ. (CE).
  • Parse both BE and CE seamlessly: parse(String) detects BE years (>= 2400) and normalizes to a CE DateTime internally.
  • Token‑aware formatter: Only the year tokens are replaced when outputting BE, so patterns like yyyy-MM-dd or MMMM yyyy remain safe.
  • Clean Architecture service: High‑level ThaiDateService with caching and sync formatting for numeric patterns.
  • Flutter extras (optional): A lightweight month calendar and a set of date pickers (single, date‑time with preview, range, multi‑date, and fullscreen) with theming hooks.

Install

Add to your pubspec.yaml:

dependencies:
  thai_buddhist_date: ^0.2.7

Then run dart pub get or flutter pub get.

Quick start

import 'package:thai_buddhist_date/thai_buddhist_date.dart';

void main() {
  // Parse either BE or CE and get a DateTime (internally CE)
  final dt = parse('2568-08-22'); // BE input -> CE internally (2025-08-22)

  // Top-level format is synchronous
  print(format(dt, pattern: 'yyyy-MM-dd', era: Era.ce)); // 2025-08-22
}

Locale initialization for Flutter

If you need localized month/weekday names (e.g., MMMM yyyy), initialize the Thai locale before building the UI:

import 'package:flutter/material.dart';
import 'package:thai_buddhist_date/thai_buddhist_date.dart';

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  // Load date symbols for Thai before using patterns like 'MMMM' or 'EEE'
  await ThaiDateService().initializeLocale('th_TH');
  runApp(const MyApp());
}

Service cheatsheet (Clean Architecture)

final service = ThaiDateService();

// Format
final be = await service.format(ThaiDate.fromDateTime(DateTime(2025, 8, 22)), pattern: 'fullText');
final iso = service.formatSync(ThaiDate.fromDateTime(DateTime(2025, 8, 22)), pattern: 'iso');

// Parse (accepts BE or CE) – returns ThaiDate (BE year)
final t = service.parse('2568-08-22', pattern: 'yyyy-MM-dd');

// Now helper
final label = await service.formatNow(pattern: 'fullText');

// Global config
service.setEra(Era.be);
service.setLanguage(ThaiLanguage.thai); // sets locale to 'th_TH'
await service.initializeLocale('th_TH');

Multi-language date/time/date&time

  • Pick any locale via the locale: parameter or set language globally on the service.
  • Use the same API for date (yyyy-MM-dd), time (HH:mm), or combined (dd/MM/yyyy HH:mm).
final svc = ThaiDateService();
// Date only
final frDate = await svc.formatNow(pattern: 'yyyy-MM-dd', locale: 'fr');
// Time only
final frTime = await svc.formatNow(pattern: 'HH:mm', locale: 'fr');
// Date & Time
final frDateTime = await svc.formatNow(pattern: 'dd/MM/yyyy HH:mm', locale: 'fr');

// Override per call with another language
final esFull = await svc.formatNow(pattern: 'fullText', locale: 'es');

Thai full date format (āļ§āļąāļ™ āđ€āļ”āļ·āļ­āļ™ āļ›āļĩ)

Using a preset pattern, with BE or CE:

final d = DateTime(2025, 8, 25);
print(format(d, pattern: 'dmy', era: Era.be)); // 25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568
print(format(d, pattern: 'dmy', era: Era.ce)); // 25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2025

Custom patterns

Use any intl-style pattern: yyyy-MM-dd, dd/MM/yyyy, HH:mm, d MMMM yyyy, etc.

final d = DateTime(2025, 8, 25);
print(format(d, pattern: 'dd/MM/yyyy'));       // 25/08/2568 (BE)
print(format(d, pattern: 'MMMM yyyy'));        // āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568 (BE)
print(format(d, pattern: 'MMMM yyyy', era: Era.ce)); // āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2025 (CE)

Creative parse/format helpers (BE/CE, all common formats)

You can use parseThaiDate and formatThaiDate for flexible, ergonomic conversion between String and DateTime, supporting BE/CE and many formats:

// Parsing (String to DateTime)
parseThaiDate('03092568');         // BE, compact
parseThaiDate('03-09-2568');       // BE, dash
parseThaiDate('03/09/2568');       // BE, slash
parseThaiDate('03.09.2568');       // BE, dot
parseThaiDate('2568-09-03');       // BE, ISO
parseThaiDate('2568.09.03');       // BE, ISO dot
parseThaiDate('2568/09/03');       // BE, ISO slash
parseThaiDate('3/9/2568');         // BE, single-digit
parseThaiDate('3-9-2568');         // BE, single-digit dash
parseThaiDate('3.9.2568');         // BE, single-digit dot

// Parsing CE
parseThaiDate('03092025', era: Era.ce); // CE, compact
parseThaiDate('03-09-2025', era: Era.ce); // CE, dash
parseThaiDate('03/09/2025', era: Era.ce); // CE, slash
parseThaiDate('03.09.2025', era: Era.ce); // CE, dot
parseThaiDate('2025-09-03', era: Era.ce); // CE, ISO
parseThaiDate('2025.09.03', era: Era.ce); // CE, ISO dot
parseThaiDate('2025/09/03', era: Era.ce); // CE, ISO slash
parseThaiDate('3/9/2025', era: Era.ce);   // CE, single-digit
parseThaiDate('3-9-2025', era: Era.ce);   // CE, single-digit dash
parseThaiDate('3.9.2025', era: Era.ce);   // CE, single-digit dot

// Formatting (DateTime to String)
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'dd/MM/yyyy'); // '03/09/2568'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'dd/MM/yyyy'); // '03/09/2025'
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'dd-MM-yyyy'); // '03-09-2568'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'dd-MM-yyyy'); // '03-09-2025'
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'dd.MM.yyyy'); // '03.09.2568'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'dd.MM.yyyy'); // '03.09.2025'
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'yyyy-MM-dd'); // '2568-09-03'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'yyyy-MM-dd'); // '2025-09-03'
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'yyyy.MM.dd'); // '2568.09.03'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'yyyy.MM.dd'); // '2025.09.03'
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'yyyy/MM/dd'); // '2568/09/03'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'yyyy/MM/dd'); // '2025/09/03'
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'd/M/yyyy');   // '3/9/2568'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'd/M/yyyy');   // '3/9/2025'
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'd-M-yyyy');   // '3-9-2568'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'd-M-yyyy');   // '3-9-2025'
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'd.M.yyyy');   // '3.9.2568'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'd.M.yyyy');   // '3.9.2025'

// Custom formats
formatThaiDate(DateTime(2568,9,3), era: Era.be, format: 'ddMMyyyy'); // '03092568'
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'ddMMyyyy'); // '03092025'

// Extensible: add your own formats
final customFormats = {'myCustom': 'yyyyMMdd'};
parseThaiDate('20250903', format: 'yyyyMMdd', era: Era.ce, customFormats: customFormats);
formatThaiDate(DateTime(2025,9,3), era: Era.ce, format: 'yyyyMMdd'); // '20250903'

Explicit-era parsing for BE inputs

When your input is known to be āļž.āļĻ., parse with an explicit era:

final parsed = ThaiDateService().parseWithEra(
  '25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568',
  era: Era.be,
  pattern: 'd MMMM yyyy',
);
print(parsed?.toDateTime()); // 2025-08-25 00:00:00.000

Common recipes

// 1) Today in BE and CE (compat functions)
print(formatNow(pattern: 'dd/MM/yyyy', era: Era.be));
print(formatNow(pattern: 'dd/MM/yyyy', era: Era.ce));

// 2) Localized full text (ensure locale first)
await ThaiDateService().initializeLocale('th_TH');
print(formatNow(pattern: 'fullText'));
print(formatNow(pattern: 'fullText', locale: 'en_US'));

// 3) Extensions
print(DateTime(2025, 8, 22).toThaiStringSync(pattern: 'yyyy-MM-dd'));

// 4) Parsing
print(parse('22/08/2568', format: 'dd/MM/yyyy'));
print(parse('2025-08-22', format: 'yyyy-MM-dd'));

Example: Thai date picker (output āļž.āļĻ. āļ āļēāļĐāļēāđ„āļ—āļĒ)

import 'package:flutter/material.dart';
import 'package:thai_buddhist_date_pickers/thai_buddhist_date_pickers.dart';
import 'package:thai_buddhist_date/thai_buddhist_date.dart' as tbd;

// ... inside a widget method
final picked = await showThaiDatePicker(
  context,
  locale: 'th_TH',
);
if (picked != null) {
  final label = tbd.format(picked, pattern: 'dmy', era: tbd.Era.be);
  print(label); // āđ€āļŠāđˆāļ™ 27 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568
}

Ergonomics

  • Global settings:
final svc = ThaiDateService();
svc.setEra(Era.be);
svc.setLanguage(ThaiLanguage.thai);
  • Quick language switch:
// Use `setLanguage` or pass `locale:` per call
  • Reusable formatter:
// Reusable: hold a service instance and reuse it
  • Extensions:
// DateTime -> String
final s = await DateTime(2025, 8, 22).toThaiString(pattern: 'yyyy-MM-dd', era: Era.ce);

Backward compatibility and sync vs async

  • Top-level helpers format(...) and formatNow(...) are synchronous (String). They’re drop-in replacements for legacy usage and safe to call without await.
  • The high-level ThaiDateService exposes both format(...) (async) and formatSync(...) (sync for numeric-only patterns). Use the service if you need explicit control, caching, and advanced parse/convert helpers.
  • Legacy shims like ThaiCalendar, ThaiDateSettings, ThaiFormatter, and TbdLocales remain available for existing code; they map to the new internals.
  • If you output localized month/weekday names (e.g., MMMM, EEE), call await ThaiDateService().initializeLocale('th_TH') once at startup.

Flutter widgets (optional)

This package ships a simple calendar and multiple pickers. They’re intentionally lightweight so you can customize them freely.

Month calendar

BuddhistGregorianCalendar renders a single‑month grid that formats the header with BE or CE.

BuddhistGregorianCalendar(
  era: Era.be,                 // or Era.ce
  dayBuilder: customDay?,       // optional: build your own day cells
)

Pickers

  • Single date dialog: showThaiDatePicker(...)
  • Date‑time dialog with live preview and formatString: showThaiDateTimePicker(...)
  • Convenience wrappers that return formatted strings: showThaiDatePickerFormatted(...), showThaiDateTimePickerFormatted(...)
  • Range selection dialog: showThaiDateRangePicker(...)
  • Multi‑date selection dialog: showThaiMultiDatePicker(...)
  • Fullscreen variant (single): showThaiDatePickerFullscreen(...)

All dialogs support theming/spacing parameters: shape, titlePadding, contentPadding, actionsPadding, insetPadding.

Basic usage:

// Single date
final picked = await showThaiDatePicker(
  context,
  locale: 'th_TH',
);

// Date-time with preview (custom preview format)
final dt = await showThaiDateTimePicker(
  context,
  formatString: 'dd/MM/yyyy HH:mm',
);

// Range (dialog)
final range = await showThaiDateRangePicker(context, era: Era.be, locale: 'th_TH');

// Multi-date
final multiple = await showThaiMultiDatePicker(context, era: Era.be, locale: 'th_TH');

API cheatsheet:

Future<DateTime?> showThaiDatePicker(...)
Future<DateTime?> showThaiDateTimePicker(..., { String formatString = 'dd/MM/yyyy HH:mm' })
Future<String?>  showThaiDatePickerFormatted(..., { String formatString = 'dd/MM/yyyy' })
Future<String?>  showThaiDateTimePickerFormatted(..., { String formatString = 'dd/MM/yyyy HH:mm' })
Future<DateTimeRange?> showThaiDateRangePicker(...)
Future<Set<DateTime>?> showThaiMultiDatePicker(...)
Future<DateTime?> showThaiDatePickerFullscreen(...)

Customization and theming

All dialogs accept common parameters to match your app’s style:

  • shape, titlePadding, contentPadding, actionsPadding, insetPadding
  • width, height (where applicable)
  • headerBuilder and dayBuilder for custom header/day cell UIs
  • firstDate and lastDate to constrain selectable dates

The date‑time dialog also exposes formatString to control the live preview text (the returned value is still a DateTime).

Behavior and notes

  • All pickers support output in āļž.āļĻ. or āļ„.āļĻ. via the era parameter.
  • The calendar respects firstDate and lastDate and disables days outside this window.
  • For localized month/weekday names, initialize locale once on startup via ThaiDateService().initializeLocale('th_TH').

Error handling and edge cases

  • Parsing uses a simple heuristic for BE years (>= 2400). If your input is ambiguous or uses a custom pattern, prefer ThaiDateService().parseWithEra(input, pattern: '...', era: Era.be|Era.ce) or pass an explicit format: to parse.
  • All UI pickers are timezone-agnostic and operate on DateTime values you provide; be mindful of UTC vs local when storing or comparing.
  • The token‑aware formatter replaces only year tokens; other tokens are left to intl for correct localization.

Notes

  • Token‑aware: only year tokens (y, yy, yyyy) are swapped to BE; other tokens are left to intl for correct localization.
  • Parsing heuristics treat years >= 2400 as BE. If inputs are ambiguous, use ThaiDateService().parseWithEra(..., era: ...) with an explicit pattern.
  • For Thai month/day names in Flutter, initialize locale via ThaiDateService().initializeLocale('th_TH') before rendering widgets.

License

MIT

āļ§āļīāļ˜āļĩāđƒāļŠāđ‰āļ‡āļēāļ™ (āļ āļēāļĐāļēāđ„āļ—āļĒ)

āļ”āđ‰āļēāļ™āļĨāđˆāļēāļ‡āļ™āļĩāđ‰āļ„āļ·āļ­āļ„āļđāđˆāļĄāļ·āļ­āļāļēāļĢāđƒāļŠāđ‰āļ‡āļēāļ™āđāļšāļšāļĒāđˆāļ­āļžāļĢāđ‰āļ­āļĄāļ•āļąāļ§āļ­āļĒāđˆāļēāļ‡āđ‚āļ„āđ‰āļ”āļ„āļĢāļ­āļšāļ„āļĨāļļāļĄāļāļĢāļ“āļĩāļ—āļąāđˆāļ§āđ„āļ› āđāļĨāļ°āļāļēāļĢāļ•āļąāđ‰āļ‡āļ„āđˆāļēāđ€āļžāļīāđˆāļĄāđ€āļ•āļīāļĄ

1) āļāļēāļĢāđ€āļĢāļĩāļĒāļāđƒāļŠāđ‰āļ‡āļēāļ™āļ›āļāļ•āļī (Standard)

āđƒāļŠāđ‰ parse āļ­āđˆāļēāļ™āļŠāļ•āļĢāļīāļ‡āļ§āļąāļ™āļ—āļĩāđˆāđ€āļ›āđ‡āļ™ BE/CE āđ„āļ”āđ‰āļ­āļąāļ•āđ‚āļ™āļĄāļąāļ•āļī āđāļĨāļ° format āđ€āļžāļ·āđˆāļ­āļžāļīāļĄāļžāđŒāļœāļĨ āđ‚āļ”āļĒāđ€āļĨāļ·āļ­āļāļĒāļļāļ„āļ›āļĩāļ”āđ‰āļ§āļĒ era: Era.be|Era.ce

import 'package:thai_buddhist_date/thai_buddhist_date.dart';

final dt1 = parse('2568-08-25');             // āļ­āļīāļ™āļžāļļāļ• āļž.āļĻ. -> āļ āļēāļĒāđƒāļ™āđ€āļ›āđ‡āļ™ āļ„.āļĻ. (2025-08-25)
final dt2 = parse('2025-08-25');             // āļ­āļīāļ™āļžāļļāļ• āļ„.āļĻ.

final sBE = format(dt1);                      // āļ„āđˆāļēāđ€āļĢāļīāđˆāļĄāļ•āđ‰āļ™ Era.be -> 2568-08-25
final sCE = format(dt1, era: Era.ce);         // 2025-08-25

āđƒāļŠāđ‰āđāļžāļ•āđ€āļ—āļīāļĢāđŒāļ™āđ€āļ­āļ‡āđ„āļ”āđ‰ āđ€āļŠāđˆāļ™ MMMM yyyy, dd/MM/yyyy, HH:mm āđ€āļ›āđ‡āļ™āļ•āđ‰āļ™

final d = DateTime(2025, 8, 25);
print(format(d, format: 'dd/MM/yyyy'));       // 25/08/2568 (BE)
print(format(d, format: 'MMMM yyyy'));        // āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568 (BE)
print(format(d, format: 'MMMM yyyy', era: Era.ce)); // āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2025 (CE)
// āļ§āļąāļ™āļ™āļĩāđ‰āđāļšāļš formatNow (āđ„āļĄāđˆāļ•āđ‰āļ­āļ‡ await)
print(formatNow(pattern: 'MMMM yyyy'));

2) āļāļēāļĢāđ€āļĢāļĩāļĒāļāđƒāļŠāđ‰āļ‡āļēāļ™āļ­āļĒāđˆāļēāļ‡āļ‡āđˆāļēāļĒ (Quick)

  • āđ„āļĄāđˆāļ­āļĒāļēāļāļŠāļĢāđ‰āļēāļ‡ DateTime.now() āđ€āļ­āļ‡ āđƒāļŠāđ‰ formatNow(...)
  • āļ•āđ‰āļ­āļ‡āļāļēāļĢāļŠāļ·āđˆāļ­āđ€āļ”āļ·āļ­āļ™/āļ§āļąāļ™āđāļšāļš localized āđƒāļŦāđ‰āđ€āļĢāļĩāļĒāļ ThaiDateService().initializeLocale('th_TH') āļŦāļ™āļķāđˆāļ‡āļ„āļĢāļąāđ‰āļ‡āļāđˆāļ­āļ™āđƒāļŠāđ‰āļ‡āļēāļ™
  • āđƒāļŠāđ‰ extension āļŠāļģāļŦāļĢāļąāļš DateTime
// āļ›āđ‰āļēāļĒāļ‚āđ‰āļ­āļ„āļ§āļēāļĄāļ•āļ­āļ™āļ™āļĩāđ‰ (āđ„āļĄāđˆāļ•āđ‰āļ­āļ‡ await)
final label = formatNow(pattern: 'fullText');

// āđ‚āļŦāļĨāļ” locale āļāđˆāļ­āļ™āđāļĨāđ‰āļ§āļ„āđˆāļ­āļĒāđƒāļŠāđ‰āļ‡āļēāļ™
await ThaiDateService().initializeLocale('th_TH');
final labelAfterInit = formatNow(pattern: 'fullText');

// Extension āļšāļ™ DateTime
final pretty = DateTime(2025, 8, 25).toThaiStringSync(pattern: 'yyyy-MM-dd');
// āļ§āļąāļ™āļ™āļĩāđ‰āđāļšāļšāđ€āļĢāđ‡āļ§
final todayQuick = formatNow(pattern: 'yyyy-MM-dd');

3) āļāļēāļĢāđ€āļĢāļĩāļĒāļāđƒāļŠāđ‰āļ‡āļēāļ™āđāļšāļš Custom (āļŠāļĨāļąāļš/āļ•āļąāļ”āļŠāđˆāļ§āļ™, āđ€āļ”āļ·āļ­āļ™āļĒāđˆāļ­, āļ•āļąāļ§āļ„āļąāđˆāļ™)

āļ•āđ‰āļ­āļ‡āļāļēāļĢāļĢāļđāļ›āđāļšāļš “āļ§āļąāļ™ āđ€āļ”āļ·āļ­āļ™ āļ›āļĩ” āđ€āļŠāđˆāļ™ 25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568 āđƒāļŠāđ‰āļžāļĢāļĩāđ€āļ‹āđ‡āļ• pattern: 'dmy'

final d = DateTime(2025, 8, 25);
print(format(d, pattern: 'dmy'));           // 25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568
print(format(d, pattern: 'dmy', era: Era.ce)); // 25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2025
// āļ§āļąāļ™āļ™āļĩāđ‰āļ”āđ‰āļ§āļĒāļžāļĢāļĩāđ€āļ‹āđ‡āļ•āđ€āļ”āļĩāļĒāļ§āļāļąāļ™
print(formatNow(pattern: 'dmy'));

āļŦāļĢāļ·āļ­āļāļģāļŦāļ™āļ”āđāļžāļ•āđ€āļ—āļīāļĢāđŒāļ™āđ€āļ­āļ‡ āđ€āļŠāđˆāļ™ MMMM d, d MMMM, d MMM yyyy

// āđ€āļĢāļĩāļĒāļ‡ āļ§āļąāļ™ āđ€āļ”āļ·āļ­āļ™ āļ›āļĩ (āļ”āļĩāļŸāļ­āļĨāļ•āđŒ)
final def = format(d, pattern: 'd MMMM yyyy', era: Era.be); // 25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568

// āļŠāļĨāļąāļšāđ€āļ›āđ‡āļ™ āđ€āļ”āļ·āļ­āļ™ āļ§āļąāļ™
final monthDay = format(d, pattern: 'MMMM d', era: Era.be); // āļŠāļīāļ‡āļŦāļēāļ„āļĄ 25

// āļ•āļąāļ”āļ›āļĩāļ­āļ­āļ (āļ§āļąāļ™ āđ€āļ”āļ·āļ­āļ™)
final dayMonth = format(d, pattern: 'd MMMM', era: Era.be); // 25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ

// āđƒāļŠāđ‰āđ€āļ”āļ·āļ­āļ™āļĒāđˆāļ­
final shortDash = format(d, pattern: 'd MMM yyyy', era: Era.be); // 25 āļŠ.āļ„. 2568

4) āđƒāļŠāđ‰āļ‡āļēāļ™āļ”āđ‰āļ§āļĒ āļž.āļĻ. āļŦāļĢāļ·āļ­ āļ„.āļĻ. (Formatting & Parsing with Era)

  • Formatting: āļāļģāļŦāļ™āļ”āļĒāļļāļ„āļ›āļĩāļ”āđ‰āļ§āļĒ era: Era.be|Era.ce āđƒāļ™ format(...) āļŦāļĢāļ·āļ­ extension toThaiString(...)
  • Parsing (āļ­āļīāļ™āļžāļļāļ•āđāļ™āđˆāļŠāļąāļ”āļ§āđˆāļēāđ€āļ›āđ‡āļ™ āļž.āļĻ.): āđƒāļŠāđ‰ ThaiDateService().parseWithEra(..., era: Era.be) āđ€āļžāļ·āđˆāļ­āļšāļąāļ‡āļ„āļąāļšāđāļ›āļĨāļ‡āļ›āļĩ āļž.āļĻ. -> āļ„.āļĻ.
// Formatting āđ€āļ›āđ‡āļ™ āļž.āļĻ. āļŦāļĢāļ·āļ­ āļ„.āļĻ.
final be = format(d);                    // 2568-08-25
final ce = format(d, era: Era.ce);       // 2025-08-25
// āļ§āļąāļ™āļ™āļĩāđ‰ (BE/CE)
print(formatNow(pattern: 'yyyy-MM-dd', era: Era.be));
print(formatNow(pattern: 'yyyy-MM-dd', era: Era.ce));

// Parsing āđ€āļĄāļ·āđˆāļ­āļ­āļīāļ™āļžāļļāļ•āđ€āļ›āđ‡āļ™ āļž.āļĻ. āđāļ™āđˆāļ™āļ­āļ™
final parsedBE = ThaiDateService().parseWithEra(
  '25 āļŠāļīāļ‡āļŦāļēāļ„āļĄ 2568',
  pattern: 'd MMMM yyyy',
  era: Era.be,
); // -> DateTime(2025, 8, 25)

5) āļŦāļĨāļēāļĒāļ āļēāļĐāļē (Multi‑language)

  • āļāļģāļŦāļ™āļ” locale āđ€āļ›āđ‡āļ™āļĢāļēāļĒāļ„āļĢāļąāđ‰āļ‡āļœāđˆāļēāļ™ locale: 'th_TH' | 'en_US' | 'ja' | ...
  • āļ•āļąāđ‰āļ‡āļ„āđˆāļēāļ āļēāļĐāļē/locale āļ—āļąāđ‰āļ‡āļĢāļ°āļšāļšāļ”āđ‰āļ§āļĒ ThaiDateService().setLanguage(...) āļŦāļĢāļ·āļ­ initializeLocale(...)
await ThaiDateService().initializeLocale('ja');
final jaNow = await ThaiDateService().formatNow(pattern: 'fullText', locale: 'ja');

6) āļ—āļīāļ›āļŠāđŒ (Tips)

  • ThaiDateService().formatSync(...) āđ€āļĢāđ‡āļ§āļŠāļģāļŦāļĢāļąāļšāđāļžāļ•āđ€āļ—āļīāļĢāđŒāļ™āđ€āļŠāļīāļ‡āļ•āļąāļ§āđ€āļĨāļ‚āļĨāđ‰āļ§āļ™
  • Extensions: DateTime.toThaiString(), String.toThaiDate()

Libraries

thai_buddhist_date