bizdays-toolkit 0.1.2 → 0.2.0

package/CHANGELOG.md

@@ -4,6 +4,17 @@
 
 ## [Unreleased]
 
+## [0.2.0] - 2026-10-14
+
+### Added
+
+- `createSchedule()`: 曜日・祝日・毎年の月日・個別の日付の規則から、日ごとに任意の値（営業時間など）を返すスケジュール。祝日の値は `"weekday"`（曜日どおり）・`{ sameAs: 曜日 }`（その曜日の値）・`{ value }`（指定の値）から選べる。`valueOn`・`dayInfo`（値を決めた規則と祝日の情報付き）
+- `civilOf()`（営業日カレンダー・スケジュール）、`toDateTimeParts()`、`toJapanDateTime()`（`bizdays-toolkit/jp`）: 入力を、タイムゾーンでの暦日と時刻（`"HH:mm"`）に変換する
+
+### Changed
+
+- 営業日カレンダー（`createCalendar`）を、スケジュールの真偽値版として作り直した。判定の優先順位と結果は変わらない
+
 ## [0.1.2] - 2026-10-12
 
 ライブラリのコードと祝日データに変更はありません。
@@ -39,7 +50,8 @@
 
 - 日本: 2026 年 2 月の官報（2027 年の春分・秋分の日）まで反映（`dataVersion: "2026-02"`、`confirmedThrough: 2027`）
 
-[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.1.2...HEAD
+[Unreleased]: https://github.com/inohan77/bizdays-toolkit/compare/v0.2.0...HEAD
+[0.2.0]: https://github.com/inohan77/bizdays-toolkit/compare/v0.1.2...v0.2.0
 [0.1.2]: https://github.com/inohan77/bizdays-toolkit/compare/v0.1.1...v0.1.2
 [0.1.1]: https://github.com/inohan77/bizdays-toolkit/compare/v0.1.0...v0.1.1
 [0.1.0]: https://github.com/inohan77/bizdays-toolkit/releases/tag/v0.1.0

package/README.md

@@ -17,9 +17,10 @@
 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダーです。
 
 - **日本の祝日を内閣府のデータで全日照合**: 1955 年〜官報公表済みの年まで、内閣府「国民の祝日」CSV のすべての日付と一致することをテストで確かめています（振替休日・国民の休日・皇室行事による休日・五輪特措法による移動を含む）
+- **日ごとの値（営業時間など）**: 「火曜定休、祝日は日曜の営業時間、元日は休業、大晦日は短縮営業」のように、曜日・祝日・特定日で変わる値を同じ規則で引けます
 - **営業日の計算**: 定休日の曜日・毎年の休業日（年末年始のような年をまたぐ期間も可）・臨時休業日・臨時営業日と祝日を組み合わせ、「N 営業日後」「締め時刻を過ぎたら翌営業日」などを計算します
 - **タイムゾーンを間違えない**: `Date` などの瞬間は、カレンダーのタイムゾーン（日本は `Asia/Tokyo`）で暦日に変換してから判定します。UTC で動くサーバーでも、日本時間 0〜9 時が前日扱いになりません
-- **軽量・依存ゼロ**: minify + gzip で約 3KB（日本の祝日込みで約 5KB）。ESM・型定義同梱・`sideEffects: false` で、Node.js・ブラウザー・Edge ランタイムで動作します
+- **軽量・依存ゼロ**: minify + gzip で約 4KB（日本の祝日込みで約 5.5KB）。ESM・型定義同梱・`sideEffects: false` で、Node.js・ブラウザー・Edge ランタイムで動作します
 - **他の国・地域に拡張できる**: 祝日の提供元はインターフェース（`HolidayProvider`）で差し替えられます。現在は日本のみ同梱しています
 
 [English](#english)
@@ -87,6 +88,43 @@ shipping.dayInfo("2027-01-01");
 5. `closedWeekdays`（定休日の曜日）
 6. それ以外は営業日
 
+### 日ごとの値（営業時間など）
+
+`createSchedule` は、曜日・祝日・特定日の規則から、日ごとに任意の値を返します。値の型は自由なので、営業時間のほか、受付枠や配送料の区分などにも使えます。
+
+```ts
+import { createSchedule } from "bizdays-toolkit";
+import { jp } from "bizdays-toolkit/jp";
+
+type Hours = { open: string; close: string } | null; // null は休業
+const weekday = { open: "10:00", close: "21:00" };
+const sunday = { open: "10:00", close: "19:00" };
+
+const storeHours = createSchedule<Hours>({
+  holidays: jp,
+  weekly: [sunday, weekday, null, weekday, weekday, weekday, weekday], // [日, 月, …, 土]。火曜定休
+  holiday: { sameAs: 0 }, // 祝日は日曜の値（"weekday": 曜日どおり / { value: … }: 指定の値）
+  annual: [{ date: "01-01", value: null, name: "元日休業" }], // 毎年の月日（期間も可）
+  dates: [{ date: "2026-12-31", value: { open: "10:00", close: "17:00" }, name: "大晦日" }],
+});
+
+storeHours.valueOn("2026-11-03"); // { open: "10:00", close: "19:00" }（文化の日は日曜の営業時間）
+storeHours.dayInfo("2027-01-01");
+// { date: "2027-01-01", weekday: 5, value: null, reason: "annual", name: "元日休業", holiday: {…} }
+```
+
+値は `dates`（個別の日付・期間）→ `annual`（毎年の月日・期間）→ 祝日 → `weekly`（曜日）の順に決まります。同じ種類の規則が重なる場合は、配列で先に書いたものが優先です。
+
+「今、営業時間内か」のような時刻の範囲の判定は、業種ごとの決まり（深夜をまたぐ営業、休憩時間など）があるためライブラリでは行いません。`civilOf` でタイムゾーンでの暦日と時刻を取り出せば、アプリ側で簡単に書けます。
+
+```ts
+const { date, time } = storeHours.civilOf(new Date()); // { date: "2026-10-14", time: "16:30" }（日本時間）
+const hours = storeHours.valueOn(date);
+const isOpen = hours !== null && time !== null && hours.open <= time && time < hours.close;
+```
+
+`civilOf` は営業日カレンダーにもあり、`bizdays-toolkit/jp` の `toJapanDateTime`、ルートの `toDateTimeParts(input, timeZone)` でも同じ変換ができます。
+
 ### 日付・日時の入力
 
 すべてのメソッドは次の入力を受け付けます。戻り値の日付は常に `"YYYY-MM-DD"` 文字列です。
@@ -155,9 +193,10 @@ MIT
 A business-day calendar that combines public holidays with company or store closures.
 
 - **Japanese holidays verified day by day** against the Cabinet Office CSV, from 1955 through the latest year officially announced (substitute holidays, citizens' holidays, imperial ceremonies, and the Olympic moves included)
+- **Day-by-day schedules**: `createSchedule` returns any value per day (e.g. store hours) from weekly values, a holiday rule (`"weekday"`, `{ sameAs: 0 }`, or `{ value }`), annual dates and specific dates
 - **Business-day arithmetic**: closed weekdays, annual closures (including ranges across the new year), specific closed/open dates, holiday policy, `addBusinessDays`, cut-off times, and more
 - **Time-zone safe**: instants (`Date`, ISO strings with offsets, Temporal) are converted to a civil date in the calendar's time zone before evaluation
-- **Lightweight, zero dependencies**: about 3 KB min+gzip (about 5 KB with Japanese holidays), ESM, bundled types, `sideEffects: false`
+- **Lightweight, zero dependencies**: about 4 KB min+gzip (about 5.5 KB with Japanese holidays), ESM, bundled types, `sideEffects: false`
 - **Extensible** through the `HolidayProvider` interface (only Japan is bundled for now)
 
 ```ts

package/dist/core/calendar.d.ts

@@ -8,10 +8,13 @@
  *   4. 祝日            … holidayPolicy に従う（closed: 休業 / open: 営業 / ignore: 判定に使わない）
  *   5. closedWeekdays … 定休日の曜日
  *   6. それ以外は営業日
+ *
+ * 内部では、営業日かどうか（真偽値）を返すスケジュール（createSchedule）として作っている。
  */
 import { type DateString, type Weekday } from "./date.ts";
 import { type DateInput } from "./input.ts";
-import type { Holiday, HolidayProvider } from "./types.ts";
+import { type HolidayLookup, type HolidaySourceOptions } from "./schedule.ts";
+import type { Holiday } from "./types.ts";
 /** 祝日の扱い */
 export type HolidayPolicy = "closed" | "open" | "ignore";
 /** 毎年の月日 "MM-DD"（名前付きも可） */
@@ -36,14 +39,7 @@ export interface DateRange {
     readonly to: DateString;
     readonly name?: string;
 }
-export interface CalendarOptions<Kind extends string = string> {
-    /** 祝日の提供元（例: jp）。複数渡すと和集合になる */
-    readonly holidays?: HolidayProvider<Kind> | readonly HolidayProvider<Kind>[];
-    /**
-     * 日時の入力（Date・オフセット付き文字列など）を暦日に変換するタイムゾーン。
-     * 省略時は祝日の提供元のタイムゾーン、提供元もなければ "UTC"
-     */
-    readonly timeZone?: string;
+export interface CalendarOptions<Kind extends string = string> extends HolidaySourceOptions<Kind> {
     /** 定休日の曜日（0 = 日曜日） */
     readonly closedWeekdays?: readonly Weekday[];
     /** 毎年の休業日 */
@@ -54,8 +50,6 @@ export interface CalendarOptions<Kind extends string = string> {
     readonly openDates?: readonly (SpecificDate | DateRange)[];
     /** 祝日の扱い（既定: "closed"） */
     readonly holidayPolicy?: HolidayPolicy;
-    /** 祝日の提供元の対応年を外れた日付の扱い（既定: "throw"） */
-    readonly outOfRange?: "throw" | "ignore";
     /** 営業日を探すときに調べる最大日数（既定: 3660）。超えたら Error */
     readonly maxSearchDays?: number;
 }
@@ -80,23 +74,7 @@ export interface BusinessDayOptions {
      */
     readonly cutoff?: string;
 }
-export interface Calendar<Kind extends string = string> {
-    /** 日時の入力を暦日に変換するタイムゾーン */
-    readonly timeZone: string;
-    /** 祝日の提供元 */
-    readonly providers: readonly HolidayProvider<Kind>[];
-    /** 入力をカレンダーのタイムゾーンでの暦日に変換する */
-    dateOf(input: DateInput): DateString;
-    /** 今日の日付（カレンダーのタイムゾーン） */
-    today(now?: Date): DateString;
-    /** 祝日か */
-    isHoliday(input: DateInput): boolean;
-    /** 祝日なら祝日を返す */
-    getHoliday(input: DateInput): Holiday<Kind> | undefined;
-    /** その年の祝日 */
-    holidaysInYear(year: number): readonly Holiday<Kind>[];
-    /** 期間内の祝日（両端を含む） */
-    holidaysBetween(from: DateInput, to: DateInput): readonly Holiday<Kind>[];
+export interface Calendar<Kind extends string = string> extends HolidayLookup<Kind> {
     /** 1 日分の判定結果（営業日か・理由・祝日） */
     dayInfo(input: DateInput): DayInfo<Kind>;
     /** 営業日か */

package/dist/core/calendar.js

@@ -8,160 +8,91 @@
  *   4. 祝日            … holidayPolicy に従う（closed: 休業 / open: 営業 / ignore: 判定に使わない）
  *   5. closedWeekdays … 定休日の曜日
  *   6. それ以外は営業日
+ *
+ * 内部では、営業日かどうか（真偽値）を返すスケジュール（createSchedule）として作っている。
  */
-import { addDays, fromDayNumber, parseDate, toDayNumber, weekdayOf, } from "./date.js";
-import { instantToCivil, parseTimeOfDay, toCivil, validateTimeZone, } from "./input.js";
-const MONTH_DAY_RE = /^(\d{2})-(\d{2})$/;
-const MAX_DAYS_IN_MONTH = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
-function parseMonthDay(value) {
-    const m = MONTH_DAY_RE.exec(value);
-    const month = Number(m?.[1]);
-    const day = Number(m?.[2]);
-    if (!m || month < 1 || month > 12 || day < 1 || day > MAX_DAYS_IN_MONTH[month - 1]) {
-        throw new RangeError(`Invalid month-day: ${JSON.stringify(value)} (expected MM-DD)`);
-    }
-    return value;
-}
-function compileDates(entries, label) {
-    return (entries ?? []).map((e) => {
-        if (typeof e === "string") {
-            const n = toDayNumber(e);
-            return { from: n, to: n, name: undefined };
-        }
-        if ("date" in e) {
-            const n = toDayNumber(e.date);
-            return { from: n, to: n, name: e.name };
-        }
-        const from = toDayNumber(e.from);
-        const to = toDayNumber(e.to);
-        if (from > to)
-            throw new RangeError(`${label}: "from" must not be after "to" (${e.from} > ${e.to})`);
-        return { from, to, name: e.name };
-    });
-}
-function compileAnnual(entries) {
+import { addDays, fromDayNumber, toDayNumber } from "./date.js";
+import { parseTimeOfDay, toCivil } from "./input.js";
+import { createSchedule, parseMonthDay, } from "./schedule.js";
+function toDateValues(entries, value) {
     return (entries ?? []).map((e) => {
-        if (typeof e === "string") {
-            const md = parseMonthDay(e);
-            return { from: md, to: md, name: undefined };
-        }
-        if ("date" in e) {
-            const md = parseMonthDay(e.date);
-            return { from: md, to: md, name: e.name };
-        }
-        return { from: parseMonthDay(e.from), to: parseMonthDay(e.to), name: e.name };
+        if (typeof e === "string")
+            return { date: e, value };
+        if ("date" in e)
+            return e.name === undefined ? { date: e.date, value } : { ...e, value };
+        return e.name === undefined ? { from: e.from, to: e.to, value } : { ...e, value };
     });
 }
-function matchAnnual(rule, monthDay) {
-    return rule.from <= rule.to
-        ? monthDay >= rule.from && monthDay <= rule.to
-        : monthDay >= rule.from || monthDay <= rule.to;
-}
 /** 祝日と休業日の規則から営業日カレンダーを作る */
 export function createCalendar(options = {}) {
-    const providers = Object.freeze(options.holidays === undefined
-        ? []
-        : Array.isArray(options.holidays)
-            ? [...options.holidays]
-            : [options.holidays]);
-    let timeZone;
-    if (options.timeZone !== undefined) {
-        timeZone = validateTimeZone(options.timeZone);
-    }
-    else {
-        const zones = [...new Set(providers.map((p) => validateTimeZone(p.timeZone)))];
-        if (zones.length > 1) {
-            throw new RangeError(`Holiday providers use different time zones (${zones.join(", ")}); specify options.timeZone`);
-        }
-        timeZone = zones[0] ?? "UTC";
-    }
     const closedWeekdays = new Set();
     for (const w of options.closedWeekdays ?? []) {
         if (!Number.isInteger(w) || w < 0 || w > 6)
             throw new RangeError(`Invalid weekday: ${w}`);
         closedWeekdays.add(w);
     }
-    const closedAnnual = compileAnnual(options.closedAnnual);
-    const closedDates = compileDates(options.closedDates, "closedDates");
-    const openDates = compileDates(options.openDates, "openDates");
     const holidayPolicy = options.holidayPolicy ?? "closed";
     if (!["closed", "open", "ignore"].includes(holidayPolicy)) {
         throw new RangeError(`Invalid holidayPolicy: ${String(holidayPolicy)}`);
     }
-    const outOfRange = options.outOfRange ?? "throw";
     const maxSearchDays = options.maxSearchDays ?? 3660;
     if (!Number.isInteger(maxSearchDays) || maxSearchDays < 1) {
         throw new RangeError(`Invalid maxSearchDays: ${maxSearchDays}`);
     }
-    const yearCache = new Map();
-    function providerYears(provider, year) {
-        const { from, to } = provider.supportedYears;
-        if (year < from || year > to) {
-            if (outOfRange === "ignore")
-                return [];
-            throw new RangeError(`Holidays for ${provider.id} are supported for ${from}-${to}; requested ${year}`);
-        }
-        return provider.holidaysInYear(year);
-    }
-    function holidayMap(year) {
-        let map = yearCache.get(year);
-        if (!map) {
-            map = new Map();
-            for (const provider of providers) {
-                for (const h of providerYears(provider, year)) {
-                    // 同じ日に複数の提供元の祝日がある場合は、先に渡した提供元を優先する
-                    if (!map.has(h.date))
-                        map.set(h.date, h);
-                }
-            }
-            yearCache.set(year, map);
-        }
-        return map;
-    }
-    const dateOf = (input) => toCivil(input, timeZone).date;
-    function holidayOn(date) {
-        if (providers.length === 0)
-            return undefined;
-        return holidayMap(parseDate(date).year).get(date);
-    }
-    function findRule(rules, dayNumber) {
-        return rules.find((r) => dayNumber >= r.from && dayNumber <= r.to);
-    }
+    const weekly = [0, 1, 2, 3, 4, 5, 6].map((w) => !closedWeekdays.has(w));
+    const sourceOptions = {
+        ...(options.holidays !== undefined && { holidays: options.holidays }),
+        ...(options.timeZone !== undefined && { timeZone: options.timeZone }),
+        ...(options.outOfRange !== undefined && { outOfRange: options.outOfRange }),
+    };
+    const schedule = createSchedule({
+        ...sourceOptions,
+        weekly,
+        holiday: holidayPolicy === "ignore" ? "weekday" : { value: holidayPolicy === "open" },
+        annual: (options.closedAnnual ?? []).map((e) => {
+            if (typeof e === "string")
+                return { date: parseMonthDay(e), value: false };
+            if ("date" in e)
+                return e.name === undefined ? { date: e.date, value: false } : { ...e, value: false };
+            return e.name === undefined
+                ? { from: e.from, to: e.to, value: false }
+                : { ...e, value: false };
+        }),
+        // 臨時営業日を先に並べて、臨時休業日より優先する
+        dates: [...toDateValues(options.openDates, true), ...toDateValues(options.closedDates, false)],
+    });
     function info(date) {
-        const dayNumber = toDayNumber(date);
-        const weekday = weekdayOf(date);
-        const holiday = holidayOn(date);
-        const make = (businessDay, reason, name) => {
-            const result = {
-                date,
-                weekday,
-                businessDay,
-                reason,
-            };
-            if (name !== undefined)
-                result.name = name;
-            if (holiday !== undefined)
-                result.holiday = holiday;
-            return Object.freeze(result);
-        };
-        const open = findRule(openDates, dayNumber);
-        if (open)
-            return make(true, "open-date", open.name);
-        const closed = findRule(closedDates, dayNumber);
-        if (closed)
-            return make(false, "closed-date", closed.name);
-        const monthDay = date.slice(5);
-        const annual = closedAnnual.find((r) => matchAnnual(r, monthDay));
-        if (annual)
-            return make(false, "closed-annual", annual.name);
-        if (holiday && holidayPolicy !== "ignore") {
-            return make(holidayPolicy === "open", "holiday", holiday.name);
+        const day = schedule.dayInfo(date);
+        let reason;
+        switch (day.reason) {
+            case "date":
+                reason = day.value ? "open-date" : "closed-date";
+                break;
+            case "annual":
+                reason = "closed-annual";
+                break;
+            case "holiday":
+                reason = "holiday";
+                break;
+            case "weekday":
+                reason = day.value ? "regular" : "closed-weekday";
+                break;
         }
-        if (closedWeekdays.has(weekday))
-            return make(false, "closed-weekday", undefined);
-        return make(true, "regular", undefined);
+        const result = {
+            date: day.date,
+            weekday: day.weekday,
+            businessDay: day.value,
+            reason,
+        };
+        // 曜日で決まった日には名前を付けない（祝日名は holiday で分かる）
+        if (day.name !== undefined && day.reason !== "weekday")
+            result.name = day.name;
+        if (day.holiday !== undefined)
+            result.holiday = day.holiday;
+        return Object.freeze(result);
     }
-    const isOpen = (date) => info(date).businessDay;
+    const isOpen = (date) => schedule.valueOn(date);
+    const dateOf = schedule.dateOf;
     function search(start, step) {
         let n = toDayNumber(start);
         for (let i = 0; i < maxSearchDays; i++, n += step) {
@@ -171,13 +102,6 @@ export function createCalendar(options = {}) {
         }
         throw new Error(`No business day found within ${maxSearchDays} days from ${start}`);
     }
-    function ordered(from, to) {
-        const a = dateOf(from);
-        const b = dateOf(to);
-        if (a > b)
-            throw new RangeError(`"from" must not be after "to" (${a} > ${b})`);
-        return [a, b];
-    }
     function countOpen(from, toExclusive) {
         let count = 0;
         for (let n = from; n < toExclusive; n++)
@@ -186,33 +110,21 @@ export function createCalendar(options = {}) {
         return count;
     }
     const calendar = {
-        timeZone,
-        providers,
+        timeZone: schedule.timeZone,
+        providers: schedule.providers,
         dateOf,
-        today: (now = new Date()) => instantToCivil(now.getTime(), timeZone).date,
-        isHoliday: (input) => holidayOn(dateOf(input)) !== undefined,
-        getHoliday: (input) => holidayOn(dateOf(input)),
-        holidaysInYear(year) {
-            if (!Number.isInteger(year))
-                throw new RangeError(`Invalid year: ${year}`);
-            return Object.freeze([...holidayMap(year).values()].sort((a, b) => a.date < b.date ? -1 : a.date > b.date ? 1 : 0));
-        },
-        holidaysBetween(from, to) {
-            const [a, b] = ordered(from, to);
-            const result = [];
-            for (let y = parseDate(a).year; y <= parseDate(b).year; y++) {
-                for (const h of calendar.holidaysInYear(y))
-                    if (h.date >= a && h.date <= b)
-                        result.push(h);
-            }
-            return Object.freeze(result);
-        },
+        civilOf: schedule.civilOf,
+        today: schedule.today,
+        isHoliday: schedule.isHoliday,
+        getHoliday: schedule.getHoliday,
+        holidaysInYear: schedule.holidaysInYear,
+        holidaysBetween: schedule.holidaysBetween,
         dayInfo: (input) => info(dateOf(input)),
         isBusinessDay: (input) => isOpen(dateOf(input)),
         nextBusinessDay: (input) => search(addDays(dateOf(input), 1), 1),
         previousBusinessDay: (input) => search(addDays(dateOf(input), -1), -1),
         businessDayOnOrAfter(input, opts = {}) {
-            const civil = toCivil(input, timeZone);
+            const civil = toCivil(input, schedule.timeZone);
             let start = civil.date;
             if (opts.cutoff !== undefined) {
                 const cutoff = parseTimeOfDay(opts.cutoff);
@@ -240,7 +152,10 @@ export function createCalendar(options = {}) {
             return a <= b ? countOpen(a, b) : -countOpen(b, a);
         },
         listBusinessDays(from, to) {
-            const [a, b] = ordered(from, to);
+            const a = dateOf(from);
+            const b = dateOf(to);
+            if (a > b)
+                throw new RangeError(`"from" must not be after "to" (${a} > ${b})`);
             const result = [];
             for (let n = toDayNumber(a); n <= toDayNumber(b); n++) {
                 const date = fromDayNumber(n);

package/dist/core/input.d.ts

@@ -38,5 +38,10 @@ export declare function instantToCivil(epochMilliseconds: number, timeZone: stri
 export declare function toCivil(input: DateInput, timeZone: string): CivilDateTime;
 /** 入力を、タイムゾーンでの暦日 "YYYY-MM-DD" に変換する */
 export declare function toDateString(input: DateInput, timeZone: string): DateString;
+/** 入力を、タイムゾーンでの暦日と時刻（"HH:mm"。暦日だけの入力では null）に変換する */
+export declare function toDateTimeParts(input: DateInput, timeZone: string): {
+    readonly date: DateString;
+    readonly time: string | null;
+};
 /** "HH:mm" を 0 時からの経過分に変換する（00:00〜23:59） */
 export declare function parseTimeOfDay(value: string): number;

package/dist/core/input.js

@@ -120,6 +120,14 @@ export function toCivil(input, timeZone) {
 export function toDateString(input, timeZone) {
     return toCivil(input, validateTimeZone(timeZone)).date;
 }
+/** 入力を、タイムゾーンでの暦日と時刻（"HH:mm"。暦日だけの入力では null）に変換する */
+export function toDateTimeParts(input, timeZone) {
+    const civil = toCivil(input, validateTimeZone(timeZone));
+    const time = civil.minutes === null
+        ? null
+        : `${String(Math.floor(civil.minutes / 60)).padStart(2, "0")}:${String(civil.minutes % 60).padStart(2, "0")}`;
+    return Object.freeze({ date: civil.date, time });
+}
 /** "HH:mm" を 0 時からの経過分に変換する（00:00〜23:59） */
 export function parseTimeOfDay(value) {
     const m = /^(\d{2}):(\d{2})$/.exec(value);

package/dist/core/schedule.d.ts

@@ -0,0 +1,130 @@
+/**
+ * 日ごとに値を返すスケジュール（営業時間・受付枠など、曜日・祝日・特定日で変わるもの）。
+ *
+ * 1 日の値は次の優先順位で決まる（上が優先）:
+ *   1. dates   … 個別の日付・期間（配列で先に書いたものが優先）
+ *   2. annual  … 毎年の月日・月日の期間（年をまたぐ期間も可。配列で先に書いたものが優先）
+ *   3. 祝日     … holiday の規則（"weekday": 曜日どおり / { sameAs: 曜日 }: その曜日の値 / { value }: 指定の値）
+ *   4. weekly  … 曜日ごとの値
+ *
+ * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
+ */
+import { type DateString, type Weekday } from "./date.ts";
+import { type DateInput } from "./input.ts";
+import type { Holiday, HolidayProvider } from "./types.ts";
+/** 祝日の値の決め方 */
+export type HolidayRule<T> = 
+/** 祝日を考えず、曜日の値を使う */
+"weekday"
+/** 指定した曜日の値を使う（例: 祝日は日曜日の営業時間） */
+ | {
+    readonly sameAs: Weekday;
+}
+/** 指定した値を使う */
+ | {
+    readonly value: T;
+};
+/** 毎年の月日 "MM-DD" の値 */
+export interface AnnualValue<T> {
+    readonly date: string;
+    readonly value: T;
+    readonly name?: string;
+}
+/** 毎年の月日の期間の値（from > to なら年をまたぐ。例: 12-31 〜 01-03） */
+export interface AnnualRangeValue<T> {
+    readonly from: string;
+    readonly to: string;
+    readonly value: T;
+    readonly name?: string;
+}
+/** 個別の日付 "YYYY-MM-DD" の値 */
+export interface DateValue<T> {
+    readonly date: DateString;
+    readonly value: T;
+    readonly name?: string;
+}
+/** 個別の日付の期間（両端を含む）の値 */
+export interface DateRangeValue<T> {
+    readonly from: DateString;
+    readonly to: DateString;
+    readonly value: T;
+    readonly name?: string;
+}
+/** 祝日の提供元とタイムゾーンの設定（スケジュールと営業日カレンダーで共通） */
+export interface HolidaySourceOptions<Kind extends string = string> {
+    /** 祝日の提供元（例: jp）。複数渡すと和集合になる */
+    readonly holidays?: HolidayProvider<Kind> | readonly HolidayProvider<Kind>[];
+    /**
+     * 日時の入力（Date・オフセット付き文字列など）を暦日に変換するタイムゾーン。
+     * 省略時は祝日の提供元のタイムゾーン、提供元もなければ "UTC"
+     */
+    readonly timeZone?: string;
+    /** 祝日の提供元の対応年を外れた日付の扱い（既定: "throw"） */
+    readonly outOfRange?: "throw" | "ignore";
+}
+export interface ScheduleOptions<T, Kind extends string = string> extends HolidaySourceOptions<Kind> {
+    /** 曜日ごとの値（[日, 月, 火, 水, 木, 金, 土]） */
+    readonly weekly: readonly [T, T, T, T, T, T, T];
+    /** 祝日の値の決め方（既定: "weekday"） */
+    readonly holiday?: HolidayRule<T>;
+    /** 毎年の月日の値 */
+    readonly annual?: readonly (AnnualValue<T> | AnnualRangeValue<T>)[];
+    /** 個別の日付の値 */
+    readonly dates?: readonly (DateValue<T> | DateRangeValue<T>)[];
+}
+/** 値を決めた規則 */
+export type ScheduleReason = "date" | "annual" | "holiday" | "weekday";
+/** 1 日分の値と、その値を決めた規則 */
+export interface ScheduleDay<T, Kind extends string = string> {
+    readonly date: DateString;
+    readonly weekday: Weekday;
+    readonly value: T;
+    /** 値を決めた規則 */
+    readonly reason: ScheduleReason;
+    /** 値を決めた規則の名前（dates・annual の name、祝日なら祝日名） */
+    readonly name?: string;
+    /** その日が祝日なら祝日（holiday の規則に関係なく付く） */
+    readonly holiday?: Holiday<Kind>;
+}
+/** 暦日と時刻（カレンダーのタイムゾーン） */
+export interface CivilDateTimeParts {
+    /** 暦日 "YYYY-MM-DD" */
+    readonly date: DateString;
+    /** 時刻 "HH:mm"。暦日だけの入力では null */
+    readonly time: string | null;
+}
+/** 祝日を調べる機能（スケジュールと営業日カレンダーで共通） */
+export interface HolidayLookup<Kind extends string = string> {
+    /** 日時の入力を暦日に変換するタイムゾーン */
+    readonly timeZone: string;
+    /** 祝日の提供元 */
+    readonly providers: readonly HolidayProvider<Kind>[];
+    /** 入力をタイムゾーンでの暦日に変換する */
+    dateOf(input: DateInput): DateString;
+    /** 入力をタイムゾーンでの暦日と時刻に変換する */
+    civilOf(input: DateInput): CivilDateTimeParts;
+    /** 今日の日付（タイムゾーン） */
+    today(now?: Date): DateString;
+    /** 祝日か */
+    isHoliday(input: DateInput): boolean;
+    /** 祝日なら祝日を返す */
+    getHoliday(input: DateInput): Holiday<Kind> | undefined;
+    /** その年の祝日 */
+    holidaysInYear(year: number): readonly Holiday<Kind>[];
+    /** 期間内の祝日（両端を含む） */
+    holidaysBetween(from: DateInput, to: DateInput): readonly Holiday<Kind>[];
+}
+export interface Schedule<T, Kind extends string = string> extends HolidayLookup<Kind> {
+    /** その日の値 */
+    valueOn(input: DateInput): T;
+    /** その日の値と、値を決めた規則 */
+    dayInfo(input: DateInput): ScheduleDay<T, Kind>;
+}
+/** "MM-DD" を検証する（2 月 29 日は可） */
+export declare function parseMonthDay(value: string): string;
+/** 祝日を調べる機能を作る（スケジュールと営業日カレンダーで共通） */
+export declare function createHolidayLookup<Kind extends string>(options: HolidaySourceOptions<Kind>): HolidayLookup<Kind> & {
+    holidayOn(date: DateString): Holiday<Kind> | undefined;
+};
+/** 曜日・祝日・特定日の規則から、日ごとに値を返すスケジュールを作る */
+export declare function createSchedule<T, Kind extends string = string>(options: ScheduleOptions<T, Kind>): Schedule<T, Kind>;

package/dist/core/schedule.js

@@ -0,0 +1,203 @@
+/**
+ * 日ごとに値を返すスケジュール（営業時間・受付枠など、曜日・祝日・特定日で変わるもの）。
+ *
+ * 1 日の値は次の優先順位で決まる（上が優先）:
+ *   1. dates   … 個別の日付・期間（配列で先に書いたものが優先）
+ *   2. annual  … 毎年の月日・月日の期間（年をまたぐ期間も可。配列で先に書いたものが優先）
+ *   3. 祝日     … holiday の規則（"weekday": 曜日どおり / { sameAs: 曜日 }: その曜日の値 / { value }: 指定の値）
+ *   4. weekly  … 曜日ごとの値
+ *
+ * 営業日カレンダー（createCalendar）は、このスケジュールの真偽値版として作られている。
+ */
+import { parseDate, toDayNumber, weekdayOf } from "./date.js";
+import { instantToCivil, toCivil, toDateTimeParts, validateTimeZone, } from "./input.js";
+// ------------------------------------------------------------
+// 内部の共通処理
+// ------------------------------------------------------------
+const MONTH_DAY_RE = /^(\d{2})-(\d{2})$/;
+const MAX_DAYS_IN_MONTH = [31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+/** "MM-DD" を検証する（2 月 29 日は可） */
+export function parseMonthDay(value) {
+    const m = MONTH_DAY_RE.exec(value);
+    const month = Number(m?.[1]);
+    const day = Number(m?.[2]);
+    if (!m || month < 1 || month > 12 || day < 1 || day > MAX_DAYS_IN_MONTH[month - 1]) {
+        throw new RangeError(`Invalid month-day: ${JSON.stringify(value)} (expected MM-DD)`);
+    }
+    return value;
+}
+function compileDates(entries, label) {
+    return (entries ?? []).map((e) => {
+        if ("date" in e) {
+            const n = toDayNumber(e.date);
+            return { from: n, to: n, value: e.value, name: e.name };
+        }
+        const from = toDayNumber(e.from);
+        const to = toDayNumber(e.to);
+        if (from > to) {
+            throw new RangeError(`${label}: "from" must not be after "to" (${e.from} > ${e.to})`);
+        }
+        return { from, to, value: e.value, name: e.name };
+    });
+}
+function compileAnnual(entries) {
+    return (entries ?? []).map((e) => {
+        if ("date" in e) {
+            const md = parseMonthDay(e.date);
+            return { from: md, to: md, value: e.value, name: e.name };
+        }
+        return { from: parseMonthDay(e.from), to: parseMonthDay(e.to), value: e.value, name: e.name };
+    });
+}
+function matchAnnual(rule, monthDay) {
+    return rule.from <= rule.to
+        ? monthDay >= rule.from && monthDay <= rule.to
+        : monthDay >= rule.from || monthDay <= rule.to;
+}
+/** 祝日を調べる機能を作る（スケジュールと営業日カレンダーで共通） */
+export function createHolidayLookup(options) {
+    const providers = Object.freeze(options.holidays === undefined
+        ? []
+        : Array.isArray(options.holidays)
+            ? [...options.holidays]
+            : [options.holidays]);
+    let timeZone;
+    if (options.timeZone !== undefined) {
+        timeZone = validateTimeZone(options.timeZone);
+    }
+    else {
+        const zones = [...new Set(providers.map((p) => validateTimeZone(p.timeZone)))];
+        if (zones.length > 1) {
+            throw new RangeError(`Holiday providers use different time zones (${zones.join(", ")}); specify options.timeZone`);
+        }
+        timeZone = zones[0] ?? "UTC";
+    }
+    const outOfRange = options.outOfRange ?? "throw";
+    const yearCache = new Map();
+    function providerYears(provider, year) {
+        const { from, to } = provider.supportedYears;
+        if (year < from || year > to) {
+            if (outOfRange === "ignore")
+                return [];
+            throw new RangeError(`Holidays for ${provider.id} are supported for ${from}-${to}; requested ${year}`);
+        }
+        return provider.holidaysInYear(year);
+    }
+    function holidayMap(year) {
+        let map = yearCache.get(year);
+        if (!map) {
+            map = new Map();
+            for (const provider of providers) {
+                for (const h of providerYears(provider, year)) {
+                    // 同じ日に複数の提供元の祝日がある場合は、先に渡した提供元を優先する
+                    if (!map.has(h.date))
+                        map.set(h.date, h);
+                }
+            }
+            yearCache.set(year, map);
+        }
+        return map;
+    }
+    function holidayOn(date) {
+        if (providers.length === 0)
+            return undefined;
+        return holidayMap(parseDate(date).year).get(date);
+    }
+    const dateOf = (input) => toCivil(input, timeZone).date;
+    function holidaysInYear(year) {
+        if (!Number.isInteger(year))
+            throw new RangeError(`Invalid year: ${year}`);
+        return Object.freeze([...holidayMap(year).values()].sort((a, b) => a.date < b.date ? -1 : a.date > b.date ? 1 : 0));
+    }
+    return {
+        timeZone,
+        providers,
+        holidayOn,
+        dateOf,
+        civilOf: (input) => toDateTimeParts(input, timeZone),
+        today: (now = new Date()) => instantToCivil(now.getTime(), timeZone).date,
+        isHoliday: (input) => holidayOn(dateOf(input)) !== undefined,
+        getHoliday: (input) => holidayOn(dateOf(input)),
+        holidaysInYear,
+        holidaysBetween(from, to) {
+            const a = dateOf(from);
+            const b = dateOf(to);
+            if (a > b)
+                throw new RangeError(`"from" must not be after "to" (${a} > ${b})`);
+            const result = [];
+            for (let y = parseDate(a).year; y <= parseDate(b).year; y++) {
+                for (const h of holidaysInYear(y))
+                    if (h.date >= a && h.date <= b)
+                        result.push(h);
+            }
+            return Object.freeze(result);
+        },
+    };
+}
+// ------------------------------------------------------------
+// createSchedule
+// ------------------------------------------------------------
+/** 曜日・祝日・特定日の規則から、日ごとに値を返すスケジュールを作る */
+export function createSchedule(options) {
+    const weekly = options.weekly;
+    if (!Array.isArray(weekly) || weekly.length !== 7) {
+        throw new RangeError("weekly must have 7 values ([Sunday, Monday, ..., Saturday])");
+    }
+    const holidayRule = options.holiday ?? "weekday";
+    if (typeof holidayRule === "object" && "sameAs" in holidayRule) {
+        const w = holidayRule.sameAs;
+        if (!Number.isInteger(w) || w < 0 || w > 6)
+            throw new RangeError(`Invalid weekday: ${w}`);
+    }
+    else if (holidayRule !== "weekday" &&
+        !(typeof holidayRule === "object" && "value" in holidayRule)) {
+        throw new RangeError(`Invalid holiday rule: ${JSON.stringify(holidayRule)}`);
+    }
+    const dates = compileDates(options.dates, "dates");
+    const annual = compileAnnual(options.annual);
+    const lookup = createHolidayLookup(options);
+    function info(date) {
+        const dayNumber = toDayNumber(date);
+        const weekday = weekdayOf(date);
+        const holiday = lookup.holidayOn(date);
+        const make = (value, reason, name) => {
+            const result = {
+                date,
+                weekday,
+                value,
+                reason,
+            };
+            if (name !== undefined)
+                result.name = name;
+            if (holiday !== undefined)
+                result.holiday = holiday;
+            return Object.freeze(result);
+        };
+        const byDate = dates.find((r) => dayNumber >= r.from && dayNumber <= r.to);
+        if (byDate)
+            return make(byDate.value, "date", byDate.name);
+        const monthDay = date.slice(5);
+        const byAnnual = annual.find((r) => matchAnnual(r, monthDay));
+        if (byAnnual)
+            return make(byAnnual.value, "annual", byAnnual.name);
+        if (holiday && holidayRule !== "weekday") {
+            const value = "sameAs" in holidayRule ? weekly[holidayRule.sameAs] : holidayRule.value;
+            return make(value, "holiday", holiday.name);
+        }
+        return make(weekly[weekday], "weekday", undefined);
+    }
+    const schedule = {
+        timeZone: lookup.timeZone,
+        providers: lookup.providers,
+        dateOf: lookup.dateOf,
+        civilOf: lookup.civilOf,
+        today: lookup.today,
+        isHoliday: lookup.isHoliday,
+        getHoliday: lookup.getHoliday,
+        holidaysInYear: lookup.holidaysInYear,
+        holidaysBetween: lookup.holidaysBetween,
+        valueOn: (input) => info(lookup.dateOf(input)).value,
+        dayInfo: (input) => info(lookup.dateOf(input)),
+    };
+    return Object.freeze(schedule);
+}

package/dist/index.d.ts

@@ -1,9 +1,11 @@
 /**
- * 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダー。
+ * 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダー（createCalendar）と、
+ * 曜日・祝日・特定日で変わる値（営業時間など）のスケジュール（createSchedule）。
  *
  * 国ごとの祝日はサブパスから読み込む（例: "bizdays-toolkit/jp"）。
  */
 export { createCalendar, type AnnualDate, type AnnualRange, type BusinessDayOptions, type Calendar, type CalendarOptions, type DateRange, type DayInfo, type DayReason, type HolidayPolicy, type SpecificDate, } from "./core/calendar.ts";
+export { createSchedule, type AnnualRangeValue, type AnnualValue, type CivilDateTimeParts, type DateRangeValue, type DateValue, type HolidayLookup, type HolidayRule, type HolidaySourceOptions, type Schedule, type ScheduleDay, type ScheduleOptions, type ScheduleReason, } from "./core/schedule.ts";
 export { addDays, diffDays, isValidDate, nthWeekdayOfMonth, weekdayOf, type DateString, type Weekday, } from "./core/date.ts";
-export { toDateString, type DateInput, type TemporalDateLike, type TemporalInstantLike, } from "./core/input.ts";
+export { toDateString, toDateTimeParts, type DateInput, type TemporalDateLike, type TemporalInstantLike, } from "./core/input.ts";
 export type { Holiday, HolidayProvider } from "./core/types.ts";

package/dist/index.js

@@ -1,8 +1,10 @@
 /**
- * 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダー。
+ * 祝日と、会社・店舗の休業日を組み合わせた営業日カレンダー（createCalendar）と、
+ * 曜日・祝日・特定日で変わる値（営業時間など）のスケジュール（createSchedule）。
  *
  * 国ごとの祝日はサブパスから読み込む（例: "bizdays-toolkit/jp"）。
  */
 export { createCalendar, } from "./core/calendar.js";
+export { createSchedule, } from "./core/schedule.js";
 export { addDays, diffDays, isValidDate, nthWeekdayOfMonth, weekdayOf, } from "./core/date.js";
-export { toDateString, } from "./core/input.js";
+export { toDateString, toDateTimeParts, } from "./core/input.js";

package/dist/jp/index.d.ts

@@ -30,6 +30,11 @@ export declare function holidaysInYear(year: number): readonly JapaneseHoliday[]
 export declare function holidaysBetween(from: DateInput, to: DateInput): readonly JapaneseHoliday[];
 /** 日本時間での暦日 */
 export declare function toJapanDate(input: DateInput): DateString;
+/** 日本時間での暦日と時刻（"HH:mm"。暦日だけの入力では null） */
+export declare function toJapanDateTime(input: DateInput): {
+    readonly date: DateString;
+    readonly time: string | null;
+};
 /** 反映済みの官報の年月 */
 export declare const dataVersion: string;
 /** 春分・秋分の日が官報で確定している最後の年 */

package/dist/jp/index.js

@@ -52,6 +52,10 @@ export function holidaysBetween(from, to) {
 export function toJapanDate(input) {
     return calendar().dateOf(input);
 }
+/** 日本時間での暦日と時刻（"HH:mm"。暦日だけの入力では null） */
+export function toJapanDateTime(input) {
+    return calendar().civilOf(input);
+}
 /** 反映済みの官報の年月 */
 export const dataVersion = DATA_VERSION;
 /** 春分・秋分の日が官報で確定している最後の年 */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bizdays-toolkit",
-  "version": "0.1.2",
-  "description": "Holidays and business-day calendar with time zone support. Japanese holidays verified against the Cabinet Office data. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府データで全日照合）",
+  "version": "0.2.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. / 祝日と営業日のカレンダー（タイムゾーン対応・日本の祝日は内閣府データで全日照合）",
   "keywords": [
     "bizdays",
     "business-day",