bizdays-toolkit 0.14.0 → 0.15.0

package/CHANGELOG.md

@@ -4,6 +4,38 @@
 
 ## [Unreleased]
 
+## [0.15.0] - 2026-10-21
+
+### 移行
+
+`businessDayOnOrAfter` に `cutoff` を指定するときは、時刻を持つ入力（`Date`・日時の文字列・時刻を持つ Temporal の値）を渡す。時刻のない入力（暦日の文字列・`PlainDate`）との組み合わせは、これまで暦日を 0 時として扱い締め時刻を黙って無視していたが、`invalid-argument` の Error になる。ほかは動作が変わらない（規則の絞り込み・カレンダーのメソッド・型の追加）。版ごとの作業は [docs/migration.md](./docs/migration.md) にまとめた。
+
+### Added
+
+- 祝日の規則（`{ holiday: true }`）と祝日の翌日の規則（`{ dayAfterHoliday: true }`）に、曜日の絞り込み `weekdays`（`months`・`kinds` と同じ絞り込みの配列）を追加した。「祝日の翌日は休館（土日に当たる場合は開館）」は `{ dayAfterHoliday: true, weekdays: [1, 2, 3, 4, 5] }`、「土曜の祝日は午前診療」は `{ holiday: true, weekdays: [6], value: … }`。曜日・日の規則に `weekdays` を付けると `invalid-option`。診断の `never-matches`・`shadowed` も曜日の絞り込みを扱う
+- 営業日カレンダーに、営業日を考慮した締め日 `closingMonth(input, closingDay, { convention })`・`closingPeriod(monthOrDate, closingDay, { convention })` を追加した。各月の締め日を `adjust` と同じ `convention`（必須）で営業日に調整し、日付は調整後の締め日がその日以降になる最初の月に属する。前月の締め日から当月の締め日までに営業日がない月（長期休業）は固有の期間を持たず、その日は次の月に属し、その月の `closingPeriod` は `no-business-day`。合成したカレンダー・スケジュールからのカレンダーにも付く。ルートの `closingMonth`・`closingPeriod` は暦日のまま
+- `HolidayPattern`・`RecurringPattern`・`RecurringRule`・`RecurringValue` に祝日の種別の型引数 `Kind`（既定 `string`）を追加し、`kinds` を `readonly Kind[]` にした。`holidays: jp` のカレンダー・スケジュールでは `kinds` に日本の祝日の種別の補完が効く（型は開いているので、ほかの文字列も通る）。型引数なしの利用はこれまでどおり
+
+### Changed
+
+- `businessDayOnOrAfter` の `cutoff` を、時刻を持たない入力と組み合わせると `invalid-argument` にした（上の「移行」）
+- README: `businessDaysBetween` が `addBusinessDays` の逆算になるのは起点が営業日のときで、休業日の起点では `addBusinessDays` が翌営業日を 1 と数える（`+0` と `+1` が同じ日）ことを明記した。`weekdays`、営業日を考慮した締め日、`cutoff` の入力の条件、バッジに npm のダウンロード数（直近 18 か月）を足した。サイズの値を測り直した（ルート約 9.7KB・日本の祝日込み約 11.5KB・英国の祝日込み約 11.4KB。0.15.0 で測定）
+- `docs/decisions.md`: 31 番に「起点が営業日のとき」の条件と休業日の起点の定義を、37 番に「別名」と「文脈を持つ経路」の線引きを、30 番に `reason`・`rulePath`・診断の違いを足した。41 番（`weekdays`・営業日を考慮した締め日と空の月の扱い）・42 番（`kinds` の型・`cutoff` の例外）を追加した
+
+### 開発
+
+- 性質のテストに、休業日を起点にした `addBusinessDays`（`addBusinessDays(a, n) = addBusinessDays(businessDayOnOrAfter(a), n − 1)`、n ≥ 1）と、営業日を考慮した締め日（複数のカレンダー × 4 つの方法 × 締め日 1〜31・−1 で、空でない期間が敷き詰められ `closingMonth` と往復する）を足した。規則の診断の性質のテストに `weekdays` を加えた
+- サイズの上限（`size-limits.json`）を上げた。ルート 22,000 → 23,000、`./jp` 25,000 → 26,000、`./diagnose` 28,500 → 29,500（gzip）。`weekdays` の検証・判定と営業日を考慮した締め日のため
+
+## [0.14.1] - 2026-10-20
+
+ライブラリの結果は 0.14.0 と同じ（内部の改善と文書だけ）。
+
+### 開発
+
+- `createCalendar`・`createSchedule` の作成が 0.13.0 で約 30% 遅くなっていた（CI の `bench` で 1.26 倍。手元では 14.0 → 18.5µs）のを直した。原因は、`createCalendarFromSchedule` のためにスケジュールの内部の判定を `WeakMap` に登録していたこと。`Object.freeze` 済みのオブジェクトに後から印（`WeakMap` のキーのハッシュや `defineProperty` の項目）を付けると、V8 がオブジェクトを遅い形に落とす。内部の判定を Symbol の項目としてオブジェクトリテラルに最初から含める形に変え、作成のコストは 0.12.0 の水準（手元で 14.9µs）に戻った。公開 API・結果は変わらない。Symbol の項目は `Object.keys`・`JSON.stringify` に出ない
+- `docs/decisions.md`: 38 番にこの原因と「作ったあとに印を付けず、リテラルに含める」知見を追記した
+
 ## [0.14.0] - 2026-10-20
 
 ### 移行
@@ -373,7 +405,9 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.0...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.15.0...HEAD
+[0.15.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.1...v0.15.0
+[0.14.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.14.0...v0.14.1
 [0.14.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.13.0...v0.14.0
 [0.13.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.12.0...v0.13.0
 [0.12.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.11.1...v0.12.0

package/README.md

@@ -7,6 +7,7 @@
 
 <p align="center">
   <a href="https://www.npmjs.com/package/bizdays-toolkit"><img src="https://img.shields.io/npm/v/bizdays-toolkit" alt="npm version"></a>
+  <a href="https://www.npmjs.com/package/bizdays-toolkit"><img src="https://img.shields.io/npm/d18m/bizdays-toolkit" alt="npm downloads"></a>
   <a href="https://github.com/inohan77/bizdays-toolkit/actions/workflows/ci.yml"><img src="https://img.shields.io/github/actions/workflow/status/inohan77/bizdays-toolkit/ci.yml?branch=main&amp;label=CI" alt="CI status"></a>
   <a href="https://github.com/inohan77/bizdays-toolkit/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/bizdays-toolkit" alt="license"></a>
   <img src="https://img.shields.io/node/v/bizdays-toolkit" alt="Node.js version">
@@ -28,7 +29,7 @@ A business-day calendar that combines public holidays with company or store clos
 - **A calendar from a schedule**: `createCalendarFromSchedule` turns a schedule such as store hours into a business-day calendar, so the hours are the only configuration and business-day arithmetic works on them
 - **Combining calendars**: `combineCalendars` builds a calendar of the days on which all of several calendars are open (your company and the bank, for a remittance date) or any of them is open (any of several stores), and business-day arithmetic works on the result
 - **Time-zone safe**: instants such as `Date` are converted to a civil date in the calendar's time zone (`Asia/Tokyo` for Japan, `Europe/London` for the UK) before evaluation. A server running in UTC does not treat 00:00–09:00 in Japan as the previous day
-- **Lightweight, zero dependencies**: about 9.3 KB min+gzip (about 11.1 KB with Japanese holidays, about 11.1 KB with UK bank holidays; measured for 0.14.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
+- **Lightweight, zero dependencies**: about 9.7 KB min+gzip (about 11.5 KB with Japanese holidays, about 11.4 KB with UK bank holidays; measured for 0.15.0). ESM, bundled types and `sideEffects: false`. Written in standard JavaScript and `Intl` only (no Node.js APIs); CI tests it on Node.js, Chrome, Firefox, Edge, Safari and Cloudflare Workers
 - **Extensible to other countries and regions**: holiday providers are pluggable through the `HolidayProvider` interface. Japan and the UK are bundled
 
 ## Installation
@@ -112,14 +113,14 @@ shipping.addBusinessDays("2026-12-30", 1); // "2027-01-04"
 shipping.businessDaysBetween("2026-09-01", "2026-10-01"); // business days from (inclusive) to (exclusive)
 
 // Orders before 14:00 ship today, later orders on the next business day
-shipping.businessDayOnOrAfter(new Date(), { cutoff: "14:00" });
+shipping.businessDayOnOrAfter(new Date(), { cutoff: "14:00" }); // the input must carry a time of day
 
 shipping.dayInfo("2027-01-01");
 // { date: "2027-01-01", weekday: 5, businessDay: false, reason: "closed-annual", name: "New Year closure", holiday: {…}, rulePath: "closedAnnual[0]" }
 shipping.daysBetween("2026-12-30", "2027-01-04").map((d) => d.businessDay); // [true, false, false, false, false, true]
 ```
 
-`daysBetween(from, to)` returns `dayInfo` for every day in the period (both ends included). `listBusinessDays` and `holidaysBetween` include both ends too; only `businessDaysBetween(from, to)` counts from `from` (inclusive) to `to` (exclusive), so that `businessDaysBetween(a, b) + businessDaysBetween(b, c)` equals `businessDaysBetween(a, c)` and it is the inverse of `addBusinessDays`.
+`daysBetween(from, to)` returns `dayInfo` for every day in the period (both ends included). `listBusinessDays` and `holidaysBetween` include both ends too; only `businessDaysBetween(from, to)` counts from `from` (inclusive) to `to` (exclusive), so that `businessDaysBetween(a, b) + businessDaysBetween(b, c)` equals `businessDaysBetween(a, c)` and, when `a` is a business day, `businessDaysBetween(a, addBusinessDays(a, n))` is `n` (the inverse of `addBusinessDays`). From a closed day, `addBusinessDays` counts the next business day as 1 (so `+0` and `+1` give the same day, as `n = 0` is `businessDayOnOrAfter`), while `businessDaysBetween` does not count the closed start, so the two differ by one there.
 
 `createCalendar` and `createSchedule` validate the options when they are created, so the usual pattern is to create them once and reuse them. Creating is also cheap (about 0.02 ms for a calendar and 0.04 ms for a schedule with Japanese holidays on a development machine), so creating one per request is not a problem in practice.
 
@@ -179,8 +180,8 @@ museum.isBusinessDay("2026-05-07"); // false (the day after the May 3–6 run of
 - **The nth weekday** is the nth occurrence of that weekday in the month (days 1–7 hold the 1st). It is not the weekday in the nth row of a printed calendar
 - **Days that do not exist in a month** (`nth: 5` or `day: 31` in a month without one) do not match. Use `day: -1` for the last day
 - **Every other week** (`interval: 2`) is not the same as the 1st and 3rd weekdays (`nth: [1, 3]`): a month with five Wednesdays shifts the latter by a week. `interval` is the number of weeks (an integer of 2 or more) and `anchor` is a date on the same weekday that the cycle passes through; the rule matches that date and every `interval` weeks before and after it. Stores announce "every other Wednesday from January 7", so copy that date. To start at the anchor rather than also matching earlier dates, add `effectiveFrom`. `interval` cannot be combined with `nth`
-- **Holiday rules** (`{ holiday: true }`) write exceptions to the default holiday handling: "open on holidays from April 2027" is `openRecurring: [{ holiday: true, effectiveFrom: "2027-04-01" }]` with `holidayPolicy: "closed"` kept for the past, "open on substitute holidays and citizens' holidays" is `openRecurring: [{ holiday: true, kinds: ["substitute", "citizens"] }]`, and "special hours on the May holidays" in a schedule is `recurring: [{ holiday: true, months: [5], value: … }]`. `kinds` narrows to those `Holiday.kind` values (see the provider's list), `months` to those months; omit both for all holidays. The rule is judged at the "over the holiday" step, before `holidayPolicy` or a schedule's `holiday`, and also with `holidayPolicy: "ignore"`. Its days are holidays, so `onHolidayRule` cannot be set on it (`invalid-option`); `holiday` still shows the holiday
-- **The day after a holiday** is never itself a holiday, so `onHolidayRule` cannot be set on such a rule (it is an `invalid-option`). "Holidays" are those of the holiday provider, not annual closures. A rule of this kind matches no day without a holiday provider
+- **Holiday rules** (`{ holiday: true }`) write exceptions to the default holiday handling: "open on holidays from April 2027" is `openRecurring: [{ holiday: true, effectiveFrom: "2027-04-01" }]` with `holidayPolicy: "closed"` kept for the past, "open on substitute holidays and citizens' holidays" is `openRecurring: [{ holiday: true, kinds: ["substitute", "citizens"] }]`, and "special hours on the May holidays" in a schedule is `recurring: [{ holiday: true, months: [5], value: … }]`. `kinds` narrows to those `Holiday.kind` values (see the provider's list; with `holidays: jp` the editor completes them), `weekdays` to those weekdays ("morning hours on a Saturday holiday" is `{ holiday: true, weekdays: [6], value: … }`), `months` to those months; omit them for all holidays. The rule is judged at the "over the holiday" step, before `holidayPolicy` or a schedule's `holiday`, and also with `holidayPolicy: "ignore"`. Its days are holidays, so `onHolidayRule` cannot be set on it (`invalid-option`); `holiday` still shows the holiday
+- **The day after a holiday** is never itself a holiday, so `onHolidayRule` cannot be set on such a rule (it is an `invalid-option`). "Holidays" are those of the holiday provider, not annual closures. A rule of this kind matches no day without a holiday provider. `weekdays` narrows it to those weekdays: a museum "closed on the day after a holiday, except when that day is a Saturday or Sunday" is `{ dayAfterHoliday: true, weekdays: [1, 2, 3, 4, 5] }` (opening the weekend with `openRecurring` instead would override every other weekend closure)
 - Among recurring rules, the one written first in the array wins, and `openRecurring` wins over `closedRecurring`. The day after Labor Thanksgiving Day on a Monday (2026-11-23) is both the day the Monday rule moves to and the day after a holiday; the rule written first decides, and `dayInfo` shows which
 
 **Effective periods** (`effectiveFrom`, `effectiveTo`) let one calendar represent a change of rules and still reproduce past dates. They go on recurring rules and on annual closures (`closedAnnual` in object form).
@@ -407,6 +408,18 @@ const office = createCalendar({ holidays: jp, closedWeekdays: [0, 6] });
 office.listBusinessDays(from, to).length; // 22 (business days in the November period)
 ```
 
+**Closing days that move to a business day**: when the contract says "closed on the 20th, or the previous business day if the 20th is not one", use the calendar's `closingMonth(date, closingDay, { convention })` and `closingPeriod(monthOrDate, closingDay, { convention })`. Each month's closing day (the last day when it does not exist) is adjusted with the `convention` of `adjust` (required, no default), and a date belongs to the first month whose adjusted closing day is on or after it. The root functions keep closing on calendar days.
+
+```ts
+const office = createCalendar({ holidays: jp, closedWeekdays: [0, 6] });
+// September 20, 2026 is a Sunday: with "preceding" the September closing day is Friday the 18th
+office.closingMonth("2026-09-19", 20, { convention: "preceding" }); // "2026-10" (the 19th is after the September closing)
+closingMonth("2026-09-19", 20); // "2026-09" (closing on calendar days)
+office.closingPeriod("2026-10", 20, { convention: "preceding" }); // { from: "2026-09-19", to: "2026-10-20" }
+```
+
+A month whose closing day is not preceded by any business day since the previous closing day (a long closure for renovation, say) has no period of its own: its days belong to the next month, `closingMonth` never returns that month, and `closingPeriod` for that month throws `no-business-day`. With `"following"` a closing day can move past a long closure into a later month; the period is then longer, not empty.
+
 The `day` of `dueDate` also maps days that do not exist in a month (such as February 30) to the last day. Recurring rules (`{ day: 31 }`) do not match such days, so the two behave differently: a due date must always fall somewhere in its month.
 
 ### Day-by-day values (e.g. store hours)

package/dist/core/calendar.d.ts

@@ -81,9 +81,9 @@ export interface CalendarOptions<Kind extends string = string> extends HolidaySo
      * 祝日に当たったときの扱いは規則ごとに onHolidayRule で指定する（既定: "under-holiday"）。
      * 有効期間（effectiveFrom・effectiveTo）を付けると、期間の外では書かれていないのと同じに扱う
      */
-    readonly closedRecurring?: readonly RecurringRule[];
+    readonly closedRecurring?: readonly RecurringRule<Kind>[];
     /** 繰り返しの営業日。closedRecurring と同じ日に当たる場合はこちらが優先 */
-    readonly openRecurring?: readonly RecurringRule[];
+    readonly openRecurring?: readonly RecurringRule<Kind>[];
     /** 祝日の扱い（既定: "closed"） */
     readonly holidayPolicy?: HolidayPolicy;
     /** 営業日を探すときに調べる最大日数（既定: 3660）。超えたら Error */
@@ -147,7 +147,8 @@ export interface CombineOptions {
 export interface BusinessDayOptions {
     /**
      * 締め時刻 "HH:mm"（カレンダーのタイムゾーン）。
-     * 入力の時刻がこの時刻以降なら、その日は対象にしない。暦日だけの入力は 0 時として扱う
+     * 入力の時刻がこの時刻以降なら、その日は対象にしない。時刻を持たない入力（暦日の文字列・Temporal の PlainDate など）
+     * と組み合わせると code: "invalid-argument" の Error（締め時刻が黙って無視されるのを防ぐ。0.15.0 から）
      */
     readonly cutoff?: string;
 }
@@ -195,7 +196,10 @@ export interface Calendar<Kind extends string = string> extends HolidayLookup<Ki
     nextBusinessDay(input: DateInput): DateString;
     /** 前営業日（入力日の前日以前） */
     previousBusinessDay(input: DateInput): DateString;
-    /** 入力日が営業日ならその日、そうでなければ翌営業日。cutoff で締め時刻を指定できる */
+    /**
+     * 入力日が営業日ならその日、そうでなければ翌営業日。cutoff で締め時刻を指定できる
+     * （cutoff を指定するときの入力は、時刻を持つもの。時刻のない入力と組み合わせると invalid-argument）
+     */
     businessDayOnOrAfter(input: DateInput, options?: BusinessDayOptions): DateString;
     /** 入力日が営業日ならその日、そうでなければ前営業日 */
     businessDayOnOrBefore(input: DateInput): DateString;
@@ -227,6 +231,23 @@ export interface Calendar<Kind extends string = string> extends HolidayLookup<Ki
      * その月にない日は末日に読み替えてから調整する（例: 2 月の 30 日払いは 2 月末日）
      */
     dueDate(month: MonthString, options: DueDateOptions): DateString;
+    /**
+     * 営業日を考慮した締め日で区切ったときに、日付が属する月。
+     * 各月の締め日（締め日がその月にない場合は末日）を convention で営業日に調整した日を D(m) とし、
+     * 日付が D(m) 以下となる最小の m を返す。前月の締め日から当月の締め日までに営業日がない月（長期休業）は
+     * 固有の期間を持たず、その日は次の月に属する
+     */
+    closingMonth(input: DateInput, closingDay: number, options: AdjustOptions): MonthString;
+    /**
+     * 営業日を考慮した締め日で区切ったときの、その月分の期間（両端を含む暦日。前月の調整後の締め日の翌日から
+     * 当月の調整後の締め日まで）。暦日を渡すと、その日が属する期間（closingMonth で求めた月の期間）。
+     * 月を渡して、その月に固有の期間がない（前月の締め日から当月の締め日までに営業日がない）ときは
+     * code: "no-business-day" の Error。返す値は変更できず、name は付かない
+     */
+    closingPeriod(input: DateInput | MonthString, closingDay: number, options: AdjustOptions): {
+        readonly from: DateString;
+        readonly to: DateString;
+    };
 }
 interface CompiledCalendar<Kind extends string> {
     readonly schedule: CompiledSchedule<boolean, Kind>;

package/dist/core/calendar.js

@@ -21,7 +21,7 @@
 import { addDays, daysInMonth, formatDate, fromDayNumber, toDayNumber, } from "./date.js";
 import { checkUnknownKeys, IssueCollector, plainError, rangeError } from "./errors.js";
 import { parseTimeOfDay, toCivil } from "./input.js";
-import { dayOfMonth, isDayOfMonthValue, parseMonth } from "./month.js";
+import { checkClosingDay, closingDayIn, closingMonth as calendarClosingMonth, dayOfMonth, formatMonth, isDayOfMonthValue, parseMonth, shiftMonth, } from "./month.js";
 import { buildSchedule, compileAnnualRules, compileDateRules, compileHolidaySource, compileRecurringRules, createHolidayLookup, infoOfSchedule, isWeekday, mapDays, RECURRING_RULE_KEYS, } from "./schedule.js";
 const CALENDAR_OPTION_KEYS = [
     "holidays",
@@ -181,6 +181,23 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
         "modified-following",
         "modified-preceding",
     ];
+    /** 月 m の、営業日に調整した締め日 D(m)（decisions.md の 41 番） */
+    function closingDate(month, closingDay, options) {
+        return adjustDate(dayOfMonth(month, closingDayIn(month, closingDay)), options);
+    }
+    /** 営業日を考慮した締め日で日付が属する月（date ≤ D(m) となる最小の m）。暦日の締めの月の前月から順に調べる */
+    function closingMonthOf(date, closingDay, options) {
+        checkClosingDay(closingDay);
+        let month = parseMonth(calendarClosingMonth(date, closingDay));
+        // D は月とともに単調に増える（減らない）ので、暦日の締めの月から、後ろへ（following で前月の締め日が
+        // 長期休業を越えて当月以降に来た場合）、前へ（preceding で当月の締め日が date より前に来た場合）順に探す
+        while (date <= closingDate(shiftMonth(month, -1), closingDay, options)) {
+            month = shiftMonth(month, -1);
+        }
+        while (date > closingDate(month, closingDay, options))
+            month = shiftMonth(month, 1);
+        return month;
+    }
     function adjustDate(date, options) {
         const convention = options?.convention;
         if (!CONVENTIONS.includes(convention)) {
@@ -265,7 +282,10 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
             let start = civil.date;
             if (opts.cutoff !== undefined) {
                 const cutoff = parseTimeOfDay(opts.cutoff);
-                if (civil.minutes !== null && civil.minutes >= cutoff)
+                if (civil.minutes === null) {
+                    throw rangeError("invalid-argument", "cutoff requires an input with a time of day (a Date, a date-time string or a Temporal value with a time); a date-only input would silently ignore the cutoff");
+                }
+                if (civil.minutes >= cutoff)
                     start = addDays(start, 1);
             }
             return search(start, 1);
@@ -305,6 +325,21 @@ function buildCalendar(lookup, isOpen, info, maxSearchDays) {
         nthBusinessDayOfMonth: nthOfMonth,
         firstBusinessDayOfMonth: (month) => nthOfMonth(month, 1),
         lastBusinessDayOfMonth: (month) => nthOfMonth(month, -1),
+        closingMonth: (input, closingDay, options) => formatMonth(closingMonthOf(dateOf(input), closingDay, options)),
+        closingPeriod(input, closingDay, options) {
+            checkClosingDay(closingDay);
+            // "YYYY-MM" だけを月として扱い、それ以外（暦日・日時の文字列・Date・Temporal の値）は dateOf で暦日にする
+            const isMonth = typeof input === "string" && /^\d{4}-\d{2}$/.test(input);
+            const month = isMonth
+                ? parseMonth(input)
+                : closingMonthOf(dateOf(input), closingDay, options);
+            const to = closingDate(month, closingDay, options);
+            const from = addDays(closingDate(shiftMonth(month, -1), closingDay, options), 1);
+            if (from > to) {
+                throw rangeError("no-business-day", `${formatMonth(month)} has no closing period of its own: there is no business day between the previous closing day and ${to} (its days belong to the next month)`);
+            }
+            return Object.freeze({ from, to });
+        },
         dueDate(month, options) {
             const day = options?.day;
             if (!isDayOfMonthValue(day)) {

package/dist/core/diagnose.js

@@ -389,21 +389,26 @@ function analyze(c, compiled, isCalendar) {
                 ? source.providers.length === 0
                     ? "This rule matches no day: there are no holidays without a holiday provider"
                     : rule.holiday
-                        ? "This rule matches no day: no holiday of the selected kinds within the selected months and effective period"
-                        : "This rule matches no day: no day after a holiday within its effective period"
+                        ? "This rule matches no day: no holiday of the selected kinds, weekdays and months within its effective period"
+                        : "This rule matches no day: no day after a holiday on the selected weekdays and months within its effective period"
                 : rule.effectiveFrom === null && rule.effectiveTo === null
                     ? "This rule matches no day (for example, a day that does not exist in the selected months)"
                     : "This rule matches no day within its effective period");
             return;
         }
-        // 祝日・祝日の翌日の規則は祝日次第で年ごとに変わるので、形の包含は同じ形の規則どうし（種別・月の絞り込み）だけで調べる
+        // 祝日・祝日の翌日の規則は祝日次第で年ごとに変わるので、形の包含は同じ形の規則どうし（種別・曜日・月の絞り込み）だけで調べる
         const k = recurring.findIndex((r, i) => i < j &&
             canCover(r, rule) &&
             periodCovers(r, rule) &&
             (rule.holiday
-                ? r.holiday && setCovers(r.kinds, rule.kinds) && setCovers(r.months, rule.months)
+                ? r.holiday &&
+                    setCovers(r.kinds, rule.kinds) &&
+                    setCovers(r.weekdays, rule.weekdays) &&
+                    setCovers(r.months, rule.months)
                 : rule.dayAfterHoliday
-                    ? r.dayAfterHoliday && setCovers(r.months, rule.months)
+                    ? r.dayAfterHoliday &&
+                        setCovers(r.weekdays, rule.weekdays) &&
+                        setCovers(r.months, rule.months)
                     : !r.holiday &&
                         !r.dayAfterHoliday &&
                         intervalCovers(r, rule) &&

package/dist/core/month.d.ts

@@ -48,6 +48,10 @@ export declare function monthOf(input: DateString | MonthString, offset?: number
  * @public
  */
 export declare function closingMonth(date: DateString, closingDay: number): MonthString;
+/** @internal 締め日の検証（closingMonth・closingPeriod・営業日カレンダーの締め日で共用） */
+export declare function checkClosingDay(closingDay: number): void;
+/** @internal その月の締め日（日）。-1 またはその月の日数以上なら末日（decisions.md の 16 番の読み替えはここだけで行う） */
+export declare function closingDayIn({ year, month }: YearMonth, closingDay: number): number;
 /**
  * 締め日で区切ったときの、その月分の期間（両端を含む暦日）。closingMonth の逆算。
  *

package/dist/core/month.js

@@ -71,13 +71,14 @@ export function closingMonth(date, closingDay) {
     const { year, month, day } = parseDate(date);
     return formatMonth(shiftMonth({ year, month }, day <= closingDayIn({ year, month }, closingDay) ? 0 : 1));
 }
-function checkClosingDay(closingDay) {
+/** @internal 締め日の検証（closingMonth・closingPeriod・営業日カレンダーの締め日で共用） */
+export function checkClosingDay(closingDay) {
     if (!isDayOfMonthValue(closingDay)) {
         throw rangeError("invalid-argument", `closingDay must be an integer from 1 to 31, or -1 (last day): ${closingDay}`);
     }
 }
-/** その月の締め日（日）。-1 またはその月の日数以上なら末日（decisions.md の 16 番の読み替えはここだけで行う） */
-function closingDayIn({ year, month }, closingDay) {
+/** @internal その月の締め日（日）。-1 またはその月の日数以上なら末日（decisions.md の 16 番の読み替えはここだけで行う） */
+export function closingDayIn({ year, month }, closingDay) {
     const last = daysInMonth(year, month);
     return closingDay === -1 || closingDay > last ? last : closingDay;
 }

package/dist/core/schedule.d.ts

@@ -91,6 +91,8 @@ export interface WeekdayPattern {
     readonly day?: never;
     readonly dayAfterHoliday?: never;
     readonly holiday?: never;
+    readonly weekdays?: never;
+    readonly kinds?: never;
 }
 /**
  * 毎月の日の繰り返し（例: 毎月 20 日、毎月末日）。その月にない日（2 月 30 日など）は当てはまらない。
@@ -107,6 +109,8 @@ export interface DayOfMonthPattern {
     readonly anchor?: never;
     readonly dayAfterHoliday?: never;
     readonly holiday?: never;
+    readonly weekdays?: never;
+    readonly kinds?: never;
 }
 /**
  * 祝日の翌日（祝日が続く場合は連休が明けた日。その日自身は祝日でない）。「祝日」は提供元の祝日だけ。
@@ -115,6 +119,8 @@ export interface DayOfMonthPattern {
  */
 export interface DayAfterHolidayPattern {
     readonly dayAfterHoliday: true;
+    /** 当てはめる曜日（翌日の曜日。省略時はすべての曜日。例: [1, 2, 3, 4, 5] で土日に当たる翌日は除く） */
+    readonly weekdays?: readonly Weekday[];
     /** 当てはめる月（翌日の月。省略時はすべての月） */
     readonly months?: readonly Month[];
     readonly weekday?: never;
@@ -123,6 +129,7 @@ export interface DayAfterHolidayPattern {
     readonly anchor?: never;
     readonly day?: never;
     readonly holiday?: never;
+    readonly kinds?: never;
 }
 /**
  * 祝日（提供元の祝日である日）。kinds で祝日の種別を絞れる（省略時はすべての祝日）。
@@ -131,10 +138,12 @@ export interface DayAfterHolidayPattern {
  * 当てはまる日は祝日なので、onHolidayRule は指定できない（指定すると invalid-option）。
  * @public
  */
-export interface HolidayPattern {
+export interface HolidayPattern<Kind extends string = string> {
     readonly holiday: true;
-    /** 当てはめる祝日の種別（Holiday.kind。省略時はすべて） */
-    readonly kinds?: readonly string[];
+    /** 当てはめる祝日の種別（Holiday.kind。省略時はすべて）。提供元の種別の型で補完が効く（型は開いているので他の文字列も通る） */
+    readonly kinds?: readonly Kind[];
+    /** 当てはめる曜日（省略時はすべての曜日。例: [6] で土曜の祝日だけ） */
+    readonly weekdays?: readonly Weekday[];
     /** 当てはめる月（省略時はすべての月） */
     readonly months?: readonly Month[];
     readonly weekday?: never;
@@ -148,12 +157,12 @@ export interface HolidayPattern {
  * 繰り返しのパターン。
  * @public
  */
-export type RecurringPattern = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | HolidayPattern;
+export type RecurringPattern<Kind extends string = string> = WeekdayPattern | DayOfMonthPattern | DayAfterHolidayPattern | HolidayPattern<Kind>;
 /**
  * 繰り返しの規則（営業日カレンダーの closedRecurring・openRecurring）。
  * @public
  */
-export type RecurringRule = RecurringPattern & EffectivePeriod & {
+export type RecurringRule<Kind extends string = string> = RecurringPattern<Kind> & EffectivePeriod & {
     readonly name?: string;
     /** 祝日に当たったときの扱い（既定: "under-holiday"） */
     readonly onHolidayRule?: OnHolidayRule;
@@ -162,7 +171,7 @@ export type RecurringRule = RecurringPattern & EffectivePeriod & {
  * 繰り返しの規則の値（スケジュールの recurring）。
  * @public
  */
-export type RecurringValue<T> = RecurringRule & {
+export type RecurringValue<T, Kind extends string = string> = RecurringRule<Kind> & {
     readonly value: T;
 };
 /**
@@ -228,7 +237,7 @@ export interface ScheduleOptions<T, Kind extends string = string> extends Holida
     /** 祝日の値の決め方（既定: "weekday"） */
     readonly holiday?: HolidayValueRule<T>;
     /** 繰り返しの規則（毎週・毎月の第 n 曜日・毎月の日）の値 */
-    readonly recurring?: readonly RecurringValue<T>[];
+    readonly recurring?: readonly RecurringValue<T, Kind>[];
     /** 毎年の月日の値 */
     readonly annual?: readonly (AnnualValue<T> | AnnualRangeValue<T>)[];
     /** 個別の日付の値 */
@@ -370,6 +379,8 @@ export interface RecurringRuleCompiled<T> extends CompiledPeriod {
     readonly holiday: boolean;
     /** 祝日の規則で絞る種別（null はすべての祝日） */
     readonly kinds: ReadonlySet<string> | null;
+    /** 祝日・祝日の翌日の規則で絞る曜日（null はすべての曜日） */
+    readonly weekdays: ReadonlySet<number> | null;
     /** 月の集合（null はすべての月） */
     readonly months: ReadonlySet<number> | null;
     readonly onHolidayRule: OnHolidayRule;

package/dist/core/schedule.js

@@ -309,6 +309,24 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
             c.error("invalid-option", `${p}.kinds`, '"kinds" can be used only with "holiday"');
             ok = false;
         }
+        let weekdays = null;
+        if ("weekdays" in entry) {
+            if (!hasHoliday && !hasAfter) {
+                c.error("invalid-option", `${p}.weekdays`, '"weekdays" can be used only with "holiday" or "dayAfterHoliday"');
+                ok = false;
+            }
+            else if (!Array.isArray(entry["weekdays"])) {
+                c.error("invalid-option", `${p}.weekdays`, "must be a non-empty array of weekdays (0 = Sunday to 6 = Saturday)");
+                ok = false;
+            }
+            else {
+                const set = checkSet(c, `${p}.weekdays`, entry["weekdays"], isWeekday, "a weekday (0 = Sunday to 6 = Saturday)");
+                if (set)
+                    weekdays = set;
+                else
+                    ok = false;
+            }
+        }
         let months = null;
         if (entry["months"] !== undefined) {
             if (!Array.isArray(entry["months"])) {
@@ -341,6 +359,7 @@ export function compileRecurringRules(c, path, entries, valueOf, keys) {
                 dayAfterHoliday: hasAfter,
                 holiday: hasHoliday,
                 kinds,
+                weekdays,
                 months,
                 onHolidayRule: onHoliday,
                 value,
@@ -360,14 +379,16 @@ export function matchPattern(rule, date, holidayOf) {
     const { year, month, day } = parseDate(date);
     if (rule.months && !rule.months.has(month))
         return false;
-    if (rule.holiday) {
-        const h = holidayOf?.(date);
-        return h !== undefined && (rule.kinds === null || rule.kinds.has(h.kind));
-    }
-    if (rule.dayAfterHoliday) {
-        return (holidayOf !== undefined &&
-            holidayOf(date) === undefined &&
-            holidayOf(addDays(date, -1)) !== undefined);
+    if (rule.holiday || rule.dayAfterHoliday) {
+        if (holidayOf === undefined)
+            return false;
+        if (rule.weekdays && !rule.weekdays.has(weekdayOf(date)))
+            return false;
+        if (rule.holiday) {
+            const h = holidayOf(date);
+            return h !== undefined && (rule.kinds === null || rule.kinds.has(h.kind));
+        }
+        return holidayOf(date) === undefined && holidayOf(addDays(date, -1)) !== undefined;
     }
     const dim = daysInMonth(year, month);
     if (rule.weekday !== null) {
@@ -619,6 +640,7 @@ export const RECURRING_RULE_KEYS = [
     "dayAfterHoliday",
     "holiday",
     "kinds",
+    "weekdays",
     "months",
     "name",
     "onHolidayRule",
@@ -778,10 +800,10 @@ export function mapDays(from, to, fn) {
  * @internal スケジュールの内部の判定（暦日の文字列を直接受け取る）。createCalendarFromSchedule が、公開メソッド
  * （入力の解析を通る）を経由せずに 1 日分の結果を得るために使う。スケジュールごとに作成時に登録する
  */
-const internalInfo = new WeakMap();
+const INTERNAL_INFO = Symbol("bizdays-toolkit.scheduleInfo");
 /** @internal スケジュールの内部の判定を取り出す（createSchedule が作ったものでなければ undefined） */
 export function infoOfSchedule(schedule) {
-    return internalInfo.get(schedule);
+    return schedule[INTERNAL_INFO];
 }
 /** @internal 検証済みの規則からスケジュールを作る */
 export function buildSchedule(compiled) {
@@ -789,6 +811,9 @@ export function buildSchedule(compiled) {
     const resolve = createResolver(compiled, lookup);
     const info = (date) => resolve(date).day;
     const schedule = {
+        // 内部の判定（createCalendarFromSchedule が使う）。Symbol の項目なので列挙されず、JSON にも出ない。
+        // オブジェクトリテラルに含めるのは、あとから defineProperty や WeakMap で付けると作成が数 µs 遅くなるため
+        [INTERNAL_INFO]: info,
         timeZone: lookup.timeZone,
         providers: lookup.providers,
         outOfRange: lookup.outOfRange,
@@ -804,9 +829,7 @@ export function buildSchedule(compiled) {
         dayInfo: (input) => info(lookup.dateOf(input)),
         daysBetween: (from, to) => mapDays(lookup.dateOf(from), lookup.dateOf(to), info),
     };
-    Object.freeze(schedule);
-    internalInfo.set(schedule, info);
-    return schedule;
+    return Object.freeze(schedule);
 }
 /**
  * 曜日・祝日・特定日の規則から、日ごとに値を返すスケジュールを作る。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "description": "Holidays, business-day calendar and day-by-day schedules (e.g. store hours) with time zone support. Japanese holidays verified against the Cabinet Office data; UK bank holidays (England, Wales, Scotland, Northern Ireland) verified against GOV.UK. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府、英国の bank holidays は GOV.UK のデータで全日照合）",
   "keywords": [
     "bank-holidays",