@moneyforward/mfui-components 2.48.1

package/dist/cjs/src/DateTimeSelection/shared/YearSelector/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAXIMUM_VIEWABLE_YEAR = exports.MINIMUM_VIEWABLE_YEAR = void 0;
+/**
+ * The minimum viewable year in the year selector
+ */
+exports.MINIMUM_VIEWABLE_YEAR = 1800;
+/**
+ * The maximum viewable year in the year selector
+ */
+exports.MAXIMUM_VIEWABLE_YEAR = 2099;

package/dist/cjs/src/DateTimeSelection/shared/YearSelector/index.d.ts

@@ -0,0 +1 @@
+export * from './YearSelector';

package/dist/cjs/src/DateTimeSelection/shared/YearSelector/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./YearSelector"), exports);

package/dist/cjs/src/DateTimeSelection/shared/accessibility/constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Shared Japanese accessibility labels for date picker components
+ * These constants provide consistent Japanese text for screen readers.
+ */
+export declare const DATE_PICKER_A11Y_LABELS: {
+    /** Label for today's date */
+    readonly TODAY: "今日";
+    /** Label for selected dates */
+    readonly SELECTED: "選択済み";
+    /** Label for dates in the selected range */
+    readonly IN_RANGE: "選択範囲内";
+    /** Label for unavailable/disabled dates */
+    readonly UNAVAILABLE: "選択不可";
+    /** Label for range start dates */
+    readonly RANGE_START: "開始日";
+    /** Label for range end dates */
+    readonly RANGE_END: "終了日";
+};

package/dist/cjs/src/DateTimeSelection/shared/accessibility/constants.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DATE_PICKER_A11Y_LABELS = void 0;
+/**
+ * Shared Japanese accessibility labels for date picker components
+ * These constants provide consistent Japanese text for screen readers.
+ */
+exports.DATE_PICKER_A11Y_LABELS = {
+    /** Label for today's date */
+    TODAY: '今日',
+    /** Label for selected dates */
+    SELECTED: '選択済み',
+    /** Label for dates in the selected range */
+    IN_RANGE: '選択範囲内',
+    /** Label for unavailable/disabled dates */
+    UNAVAILABLE: '選択不可',
+    /** Label for range start dates */
+    RANGE_START: '開始日',
+    /** Label for range end dates */
+    RANGE_END: '終了日',
+};

package/dist/cjs/src/DateTimeSelection/shared/accessibility/generateDateLabel.d.ts

@@ -0,0 +1,22 @@
+export type DateLabelOptions = {
+    /** The date to generate a label for */
+    date: Date;
+    /** Whether the date is selected */
+    selected?: boolean;
+    /** Whether the date is in a selected range */
+    inRange?: boolean;
+    /** Whether the date is disabled */
+    disabled?: boolean;
+    /** Whether this date is the start of a range */
+    isRangeStart?: boolean;
+    /** Whether this date is the end of a range */
+    isRangeEnd?: boolean;
+};
+/**
+ * Generates an accessible label for a date cell with status information
+ *
+ * @param options - Configuration options for the label
+ *
+ * @returns Formatted accessible label string
+ */
+export declare function generateAccessibleDateLabel({ date, selected, inRange, disabled, isRangeStart, isRangeEnd, }: DateLabelOptions): string;

package/dist/cjs/src/DateTimeSelection/shared/accessibility/generateDateLabel.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAccessibleDateLabel = generateAccessibleDateLabel;
+const dayjs_1 = __importDefault(require("dayjs"));
+const constants_1 = require("./constants");
+/**
+ * Generates an accessible label for a date cell with status information
+ *
+ * @param options - Configuration options for the label
+ *
+ * @returns Formatted accessible label string
+ */
+function generateAccessibleDateLabel({ date, selected = false, inRange = false, disabled = false, isRangeStart = false, isRangeEnd = false, }) {
+    const today = new Date();
+    const isToday = date.getFullYear() === today.getFullYear() &&
+        date.getMonth() === today.getMonth() &&
+        date.getDate() === today.getDate();
+    // Create a comprehensive accessible label
+    const dateText = (0, dayjs_1.default)(date).format('D MMMM YYYY');
+    const statusParts = [];
+    if (isToday) {
+        statusParts.push(constants_1.DATE_PICKER_A11Y_LABELS.TODAY);
+    }
+    if (disabled) {
+        statusParts.push(constants_1.DATE_PICKER_A11Y_LABELS.UNAVAILABLE);
+    }
+    else if (selected) {
+        if (isRangeStart) {
+            statusParts.push(constants_1.DATE_PICKER_A11Y_LABELS.RANGE_START);
+        }
+        else if (isRangeEnd) {
+            statusParts.push(constants_1.DATE_PICKER_A11Y_LABELS.RANGE_END);
+        }
+        else {
+            statusParts.push(constants_1.DATE_PICKER_A11Y_LABELS.SELECTED);
+        }
+    }
+    else if (inRange) {
+        statusParts.push(constants_1.DATE_PICKER_A11Y_LABELS.IN_RANGE);
+    }
+    return statusParts.length > 0 ? `${dateText}, ${statusParts.join(', ')}` : dateText;
+}

package/dist/cjs/src/DateTimeSelection/shared/accessibility/getDateAriaAttributes.d.ts

@@ -0,0 +1,14 @@
+import { type DateLabelOptions } from './generateDateLabel';
+export type DateAriaAttributes = {
+    'aria-label': string;
+    'aria-pressed': 'true' | undefined;
+    'aria-selected': 'true' | 'false';
+};
+/**
+ * Generates consistent ARIA attributes for date cells
+ *
+ * @param options - Configuration options for the ARIA attributes
+ *
+ * @returns Object with ARIA attributes
+ */
+export declare function getDateAriaAttributes(options: DateLabelOptions): DateAriaAttributes;

package/dist/cjs/src/DateTimeSelection/shared/accessibility/getDateAriaAttributes.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDateAriaAttributes = getDateAriaAttributes;
+const generateDateLabel_1 = require("./generateDateLabel");
+/**
+ * Generates consistent ARIA attributes for date cells
+ *
+ * @param options - Configuration options for the ARIA attributes
+ *
+ * @returns Object with ARIA attributes
+ */
+function getDateAriaAttributes(options) {
+    const { selected = false } = options;
+    return {
+        'aria-label': (0, generateDateLabel_1.generateAccessibleDateLabel)(options),
+        'aria-pressed': selected ? 'true' : undefined,
+        'aria-selected': selected ? 'true' : 'false',
+    };
+}

package/dist/cjs/src/DateTimeSelection/shared/accessibility/index.d.ts

@@ -0,0 +1,3 @@
+export { DATE_PICKER_A11Y_LABELS } from './constants';
+export { generateAccessibleDateLabel, type DateLabelOptions } from './generateDateLabel';
+export { getDateAriaAttributes, type DateAriaAttributes } from './getDateAriaAttributes';

package/dist/cjs/src/DateTimeSelection/shared/accessibility/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDateAriaAttributes = exports.generateAccessibleDateLabel = exports.DATE_PICKER_A11Y_LABELS = void 0;
+var constants_1 = require("./constants");
+Object.defineProperty(exports, "DATE_PICKER_A11Y_LABELS", { enumerable: true, get: function () { return constants_1.DATE_PICKER_A11Y_LABELS; } });
+var generateDateLabel_1 = require("./generateDateLabel");
+Object.defineProperty(exports, "generateAccessibleDateLabel", { enumerable: true, get: function () { return generateDateLabel_1.generateAccessibleDateLabel; } });
+var getDateAriaAttributes_1 = require("./getDateAriaAttributes");
+Object.defineProperty(exports, "getDateAriaAttributes", { enumerable: true, get: function () { return getDateAriaAttributes_1.getDateAriaAttributes; } });

package/dist/cjs/src/DateTimeSelection/shared/index.d.ts

@@ -0,0 +1,6 @@
+export * from './DateCell';
+export * from './DayCell';
+export * from './MonthCell';
+export * from './MonthGrid';
+export * from './YearSelector';
+export * from './CalendarGrid';

package/dist/cjs/src/DateTimeSelection/shared/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./DateCell"), exports);
+__exportStar(require("./DayCell"), exports);
+__exportStar(require("./MonthCell"), exports);
+__exportStar(require("./MonthGrid"), exports);
+__exportStar(require("./YearSelector"), exports);
+__exportStar(require("./CalendarGrid"), exports);

package/dist/cjs/src/DateTimeSelection/shared/utilities/dateParsing.d.ts

@@ -0,0 +1,34 @@
+type ParseDateResult = {
+    isValid: boolean;
+    result: Date | undefined;
+};
+/**
+ * Shared date parsing utility that supports both Japanese era formats and Western calendar formats
+ *
+ * Note: Uses non-strict parsing for Western calendar formats, allowing flexible delimiters.
+ * For example, both "2025-12-24" and "2025/12/24" are valid for format "YYYY-MM-DD".
+ *
+ * Also supports formats without delimiters as fallbacks because dayjs does not support them natively:
+ * - YYYYMMDD format (8-digit number): "20251215" can be parsed even when format is "YYYY-MM-DD"
+ * - YYYYMM format (6-digit number): "202512" can be parsed even when format is "YYYY-MM"
+ *
+ * @param inputString - The input string to parse
+ *
+ * @param format - The dayjs format to use for Western calendar parsing
+ *
+ * @returns Object with isValid flag and parsed Date result
+ */
+export declare function parseInputDate(inputString: string, format: string): ParseDateResult;
+/**
+ * Convenience function that returns the parsed Date directly or null
+ *
+ * This is useful for cases where you only need the Date result
+ *
+ * @param inputString - The input string to parse
+ *
+ * @param format - The dayjs format to use for Western calendar parsing
+ *
+ * @returns Parsed Date or null if invalid
+ */
+export declare function parseInputDateSimple(inputString: string, format: string): Date | null;
+export {};

package/dist/cjs/src/DateTimeSelection/shared/utilities/dateParsing.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInputDate = parseInputDate;
+exports.parseInputDateSimple = parseInputDateSimple;
+const dayjs_1 = require("../../../utilities/date/dayjs");
+const japaneseCalendar_1 = require("./japaneseCalendar");
+/**
+ * Shared date parsing utility that supports both Japanese era formats and Western calendar formats
+ *
+ * Note: Uses non-strict parsing for Western calendar formats, allowing flexible delimiters.
+ * For example, both "2025-12-24" and "2025/12/24" are valid for format "YYYY-MM-DD".
+ *
+ * Also supports formats without delimiters as fallbacks because dayjs does not support them natively:
+ * - YYYYMMDD format (8-digit number): "20251215" can be parsed even when format is "YYYY-MM-DD"
+ * - YYYYMM format (6-digit number): "202512" can be parsed even when format is "YYYY-MM"
+ *
+ * @param inputString - The input string to parse
+ *
+ * @param format - The dayjs format to use for Western calendar parsing
+ *
+ * @returns Object with isValid flag and parsed Date result
+ */
+function parseInputDate(inputString, format) {
+    // Use the refined Japanese era detection from japaneseCalendar utility
+    const hasJapaneseEra = (0, japaneseCalendar_1.isJapaneseEraFormat)(inputString);
+    if (hasJapaneseEra) {
+        // Try Japanese calendar parsing for era formats
+        try {
+            const jpResult = (0, japaneseCalendar_1.warekiToDate)(inputString);
+            if (jpResult.isValid) {
+                return { isValid: true, result: jpResult.result };
+            }
+        }
+        catch (error) {
+            // If Japanese calendar parsing fails, fall back to dayjs
+            console.warn('Japanese calendar parsing failed:', error);
+        }
+    }
+    // Try dayjs parsing for Western calendar format first
+    const dayjsResult = (0, dayjs_1.dayjs)(inputString, format, false);
+    if (dayjsResult.isValid()) {
+        return { isValid: true, result: dayjsResult.toDate() };
+    }
+    // Fall back to YYYYMMDD format (8-digit number without delimiters) if the specified format fails
+    // This allows inputs like "20251215" to be parsed even when format is "YYYY-MM-DD"
+    if (/^\d{8}$/.test(inputString)) {
+        const yyyymmddResult = (0, dayjs_1.dayjs)(inputString, 'YYYYMMDD', false);
+        if (yyyymmddResult.isValid()) {
+            return { isValid: true, result: yyyymmddResult.toDate() };
+        }
+    }
+    // Fall back to YYYYMM format (6-digit number without delimiters) if the specified format fails
+    // This allows inputs like "202512" to be parsed even when format is "YYYY-MM"
+    if (/^\d{6}$/.test(inputString)) {
+        const yyyymmResult = (0, dayjs_1.dayjs)(inputString, 'YYYYMM', false);
+        if (yyyymmResult.isValid()) {
+            return { isValid: true, result: yyyymmResult.toDate() };
+        }
+    }
+    return { isValid: false, result: undefined };
+}
+/**
+ * Convenience function that returns the parsed Date directly or null
+ *
+ * This is useful for cases where you only need the Date result
+ *
+ * @param inputString - The input string to parse
+ *
+ * @param format - The dayjs format to use for Western calendar parsing
+ *
+ * @returns Parsed Date or null if invalid
+ */
+function parseInputDateSimple(inputString, format) {
+    const result = parseInputDate(inputString, format);
+    return result.isValid && result.result ? result.result : null;
+}

package/dist/cjs/src/DateTimeSelection/shared/utilities/japaneseCalendar.d.ts

@@ -0,0 +1,48 @@
+declare const REIWA: "\u4EE4\u548C";
+declare const HEISEI: "\u5E73\u6210";
+declare const SHOWA: "\u662D\u548C";
+declare const TAISHO: "\u5927\u6B63";
+declare const MEIJI: "\u660E\u6CBB";
+type Geongo = typeof REIWA | typeof HEISEI | typeof SHOWA | typeof TAISHO | typeof MEIJI;
+declare const WAREKI_START_YEARS: {
+    readonly r: 2019;
+    readonly R: 2019;
+    readonly 令和: 2019;
+    readonly h: 1989;
+    readonly H: 1989;
+    readonly 平成: 1989;
+    readonly s: 1926;
+    readonly S: 1926;
+    readonly 昭和: 1926;
+    readonly t: 1912;
+    readonly T: 1912;
+    readonly 大正: 1912;
+    readonly m: 1868;
+    readonly M: 1868;
+    readonly 明治: 1868;
+};
+declare const warekiReg: {
+    dateString: RegExp;
+    wareki: RegExp;
+    eraDetection: RegExp;
+};
+type WarekiResult<T> = {
+    isValid: boolean;
+    result: T;
+    formatted: string;
+};
+declare function selectGengo(year: number, month: number, date: number): Geongo;
+declare function fullWidthToHalfWidth(dateString: string): string;
+declare function dateToWareki(d: string | Date): WarekiResult<string>;
+export declare function warekiToDate(wareki: string): WarekiResult<Date>;
+/**
+ * Check if the input string appears to be a Japanese era format
+ * This is used for initial screening before attempting to parse
+ *
+ * @param inputString - The input string to check
+ *
+ * @returns true if the string appears to be a Japanese era format
+ */
+export declare function isJapaneseEraFormat(inputString: string): boolean;
+export { warekiReg, dateToWareki, fullWidthToHalfWidth, selectGengo, WAREKI_START_YEARS };
+export type { WarekiResult };

package/dist/cjs/src/DateTimeSelection/shared/utilities/japaneseCalendar.js

@@ -0,0 +1,216 @@
+"use strict";
+// inspired by https://github.com/kufu/tamatebako/blob/master/packages/wareki/src/index.ts
+/* eslint-disable unicorn/numeric-separators-style */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAREKI_START_YEARS = exports.warekiReg = void 0;
+exports.warekiToDate = warekiToDate;
+exports.isJapaneseEraFormat = isJapaneseEraFormat;
+exports.dateToWareki = dateToWareki;
+exports.fullWidthToHalfWidth = fullWidthToHalfWidth;
+exports.selectGengo = selectGengo;
+const REIWA = '令和';
+const HEISEI = '平成';
+const SHOWA = '昭和';
+const TAISHO = '大正';
+const MEIJI = '明治';
+const REIWA_START_YEAR = 2019;
+const HEISEI_START_YEAR = 1989;
+const SHOWA_START_YEAR = 1926;
+const TAISHO_START_YEAR = 1912;
+const MEIJI_START_YEAR = 1868;
+// More specific separators for different contexts
+const WESTERN_SEPARATOR = String.raw `[:\/\-\.\s．]`;
+const WAREKI_BOUNDARYS = [
+    [REIWA, REIWA_START_YEAR, 4, 30, HEISEI],
+    [HEISEI, HEISEI_START_YEAR, 1, 7, SHOWA],
+    [SHOWA, SHOWA_START_YEAR, 12, 24, TAISHO],
+    [TAISHO, TAISHO_START_YEAR, 7, 29, MEIJI],
+];
+const WAREKI_START_YEARS = {
+    r: REIWA_START_YEAR,
+    R: REIWA_START_YEAR,
+    [REIWA]: REIWA_START_YEAR,
+    h: HEISEI_START_YEAR,
+    H: HEISEI_START_YEAR,
+    [HEISEI]: HEISEI_START_YEAR,
+    s: SHOWA_START_YEAR,
+    S: SHOWA_START_YEAR,
+    [SHOWA]: SHOWA_START_YEAR,
+    t: TAISHO_START_YEAR,
+    T: TAISHO_START_YEAR,
+    [TAISHO]: TAISHO_START_YEAR,
+    m: MEIJI_START_YEAR,
+    M: MEIJI_START_YEAR,
+    [MEIJI]: MEIJI_START_YEAR,
+};
+exports.WAREKI_START_YEARS = WAREKI_START_YEARS;
+const warekiReg = {
+    // Western calendar: supports full-width numbers and flexible separators
+    dateString: new RegExp(String.raw `^([0-9０-９]{4})${WESTERN_SEPARATOR}([0-9０-９]{1,2})${WESTERN_SEPARATOR}([0-9０-９]{1,2})(?:[\s．]([0-9０-９]{2}):([0-9０-９]{2}))?$`),
+    // Japanese era: supports both traditional (H12年2月12日) and Western-style (H12.2.12) formats
+    wareki: new RegExp(String.raw `^(${Object.keys(WAREKI_START_YEARS).join('|')})(元|[0-9０-９]{1,2})(?:年([0-9０-９]{1,2})月([0-9０-９]{1,2})日|[./-]([0-9０-９]{1,2})[./-]([0-9０-９]{1,2}))$`),
+    // Era detection for both traditional and Western-style formats
+    eraDetection: /^(?:令和|平成|昭和|大正|明治|[rhstmRHSTM])(?:元|[0-9０-９]{1,2})(?:年|[./-])/,
+};
+exports.warekiReg = warekiReg;
+function selectGengo(year, month, date) {
+    for (const [modern, boundaryYear, boundaryMonth, boundaryDay, ancient] of WAREKI_BOUNDARYS) {
+        if (year > boundaryYear) {
+            return modern;
+        }
+        if (year === boundaryYear) {
+            if (month > boundaryMonth || (month === boundaryMonth && date > boundaryDay)) {
+                return modern;
+            }
+            return ancient;
+        }
+    }
+    return MEIJI;
+}
+/**
+ * Validate if the given month and day are valid for a specific year
+ *
+ * @param year - The year to validate against
+ *
+ * @param month - The month (1-12)
+ *
+ * @param day - The day (1-31)
+ *
+ * @returns true if the date is valid
+ */
+function isValidDate(year, month, day) {
+    // Basic NaN check
+    if (Number.isNaN(year) || Number.isNaN(month) || Number.isNaN(day)) {
+        return false;
+    }
+    // Month validation (1-12)
+    if (month < 1 || month > 12) {
+        return false;
+    }
+    // Day validation (1-31)
+    if (day < 1 || day > 31) {
+        return false;
+    }
+    // Days in each month (considering leap years)
+    const daysInMonth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    // Check for leap year
+    const isLeapYear = (year % 4 === 0 && year % 100 !== 0) || year % 400 === 0;
+    if (isLeapYear && month === 2) {
+        daysInMonth[1] = 29;
+    }
+    // Check if day is valid for the given month
+    return day <= (daysInMonth[month - 1] ?? 31);
+}
+function fullWidthToHalfWidth(dateString) {
+    let result = '';
+    for (let i = 0; i < dateString.length; i++) {
+        const code = dateString.codePointAt(i) ?? 0;
+        let isFullWidth = false;
+        if ((code >= 0xff10 && code <= 0xff19) ||
+            (code >= 0xff21 && code <= 0xff3a) ||
+            (code >= 0xff41 && code <= 0xff5a) ||
+            code === 0xff0e) {
+            isFullWidth = true;
+        }
+        result += isFullWidth ? String.fromCodePoint(code - 0xfee0) : dateString.charAt(i);
+    }
+    return result;
+}
+function dateToWareki(d) {
+    const dateString = d instanceof Date ? `${String(d.getFullYear())}/${String(d.getMonth() + 1)}/${String(d.getDate())}` : d;
+    const formatted = fullWidthToHalfWidth(dateString);
+    const matcher = warekiReg.dateString.exec(formatted);
+    if (!matcher) {
+        return {
+            isValid: false,
+            result: dateString,
+            formatted,
+        };
+    }
+    const year = Number(matcher[1]);
+    const month = Number(matcher[2]);
+    const date = Number(matcher[3]);
+    const gengo = selectGengo(year, month, date);
+    // wareki (Japanese calendar) starts from 1
+    const warekiYear = year - WAREKI_START_YEARS[gengo] + 1;
+    return {
+        isValid: true,
+        result: `${gengo}${warekiYear === 1 ? '元' : String(warekiYear)}年${String(month)}月${String(date)}日`,
+        formatted,
+    };
+}
+function warekiToDate(wareki) {
+    const formatted = fullWidthToHalfWidth(wareki);
+    // parse as japanese era
+    const matchedWareki = warekiReg.wareki.exec(formatted);
+    if (matchedWareki) {
+        const baseYear = WAREKI_START_YEARS[matchedWareki[1]];
+        // Handle "元" (first year) and regular years
+        const eraYear = matchedWareki[2] === '元' ? 1 : Number(matchedWareki[2]);
+        // Handle both traditional (年月日) and Western-style (./- separators) formats
+        // Traditional format: groups 3,4 (month, day)
+        // Western format: groups 5,6 (month, day)
+        const month = Number(matchedWareki[3] || matchedWareki[5]);
+        const day = Number(matchedWareki[4] || matchedWareki[6]);
+        // Validation: ensure era year is reasonable (1-200 years per era)
+        if (eraYear < 1 || eraYear > 200) {
+            return {
+                isValid: false,
+                result: new Date(formatted),
+                formatted,
+            };
+        }
+        // Calculate the actual Western calendar year
+        const actualYear = baseYear + eraYear - 1;
+        // Validate month and day ranges
+        if (!isValidDate(actualYear, month, day)) {
+            return {
+                isValid: false,
+                result: new Date(formatted),
+                formatted,
+            };
+        }
+        return {
+            isValid: true,
+            // wareki (Japanese calendar) starts from 1
+            result: new Date(actualYear, month - 1, day),
+            formatted,
+        };
+    }
+    // parse as A.D.
+    const matchedDate = warekiReg.dateString.exec(formatted);
+    if (matchedDate) {
+        const year = Number(matchedDate[1]);
+        const month = Number(matchedDate[2]);
+        const day = Number(matchedDate[3]);
+        // Validate month and day ranges for Western calendar
+        if (!isValidDate(year, month, day)) {
+            return {
+                isValid: false,
+                result: new Date(formatted),
+                formatted,
+            };
+        }
+        return {
+            isValid: true,
+            result: new Date(year, month - 1, day),
+            formatted,
+        };
+    }
+    return {
+        isValid: false,
+        result: new Date(formatted),
+        formatted,
+    };
+}
+/**
+ * Check if the input string appears to be a Japanese era format
+ * This is used for initial screening before attempting to parse
+ *
+ * @param inputString - The input string to check
+ *
+ * @returns true if the string appears to be a Japanese era format
+ */
+function isJapaneseEraFormat(inputString) {
+    return warekiReg.eraDetection.test(inputString);
+}

package/dist/cjs/src/Dialog/Dialog.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The general purpose Dialog component.
+ * This component extends the props of `<div>` element with `role="dialog"`.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/HTML/Element/dialog
+ */
+export declare const Dialog: import("react").ForwardRefExoticComponent<{
+    children?: import("react").ReactNode;
+    title: string;
+    open?: boolean;
+    onClose?: () => void;
+    actionSlot?: import("react").ReactNode;
+    size?: import("../../styled-system/recipes").DialogSlotRecipeVariant["size"];
+    hideCloseButton?: boolean;
+    closeButtonProps?: Pick<import("react").ComponentPropsWithoutRef<"button">, "aria-label">;
+    targetDOMNode?: HTMLElement | null;
+    enableAutoUnmount?: boolean;
+    disableBackdropClose?: boolean;
+    customFocusElement?: import("react").RefObject<HTMLElement | null> | HTMLElement | null;
+} & Omit<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "open" | "onClose"> & {
+    ref?: (import("react").RefObject<HTMLDivElement | null> | import("react").RefCallback<HTMLDivElement> | null) | undefined;
+} & import("react").Attributes>;