ical-generator 10.0.1-develop.9 → 10.1.1-develop.1

package/package.json

@@ -6,25 +6,26 @@
     "description": "ical-generator is a small piece of code which generates ical calendar files",
     "devDependencies": {
         "@date-fns/tz": "^1.4.1",
-        "@eslint/js": "^9.39.1",
+        "@eslint/js": "^10.0.1",
         "@istanbuljs/nyc-config-typescript": "^1.0.2",
         "@qiwi/semantic-release-gh-pages-plugin": "^5.4.3",
-        "@sebbo2002/semantic-release-jsr": "^3.1.0",
+        "@sebbo2002/semantic-release-jsr": "^3.2.1",
         "@semantic-release/changelog": "^6.0.3",
         "@semantic-release/exec": "^7.1.0",
         "@semantic-release/git": "^10.0.1",
-        "@semantic-release/npm": "^13.1.2",
+        "@semantic-release/npm": "^13.1.5",
         "@touch4it/ical-timezones": "^1.9.0",
         "@types/express": "^5.0.6",
         "@types/luxon": "^3.7.1",
         "@types/mocha": "^10.0.10",
-        "c8": "^10.1.3",
-        "dayjs": "^1.11.19",
-        "eslint": "^9.39.1",
+        "c8": "^11.0.0",
+        "dayjs": "^1.11.20",
+        "eslint": "^10.0.3",
         "eslint-config-prettier": "^10.1.8",
-        "eslint-plugin-jsonc": "^2.21.0",
-        "eslint-plugin-perfectionist": "^4.15.1",
+        "eslint-plugin-jsonc": "^3.1.2",
+        "eslint-plugin-perfectionist": "^5.6.0",
         "esm": "^3.2.25",
+        "globals": "^17.4.0",
         "husky": "^9.1.7",
         "license-checker": "^25.0.1",
         "luxon": "^3.7.2",
@@ -32,17 +33,18 @@
         "mochawesome": "^7.1.4",
         "moment": "^2.30.1",
         "moment-timezone": "^0.6.0",
-        "nyc": "^17.1.0",
-        "prettier": "^3.7.4",
+        "nyc": "^18.0.0",
+        "prettier": "^3.8.1",
         "rrule": "^2.8.1",
-        "semantic-release": "^25.0.2",
+        "semantic-release": "^25.0.3",
         "semantic-release-license": "^1.0.2",
         "source-map-support": "^0.5.21",
+        "temporal-polyfill": "^0.3.0",
         "tsup": "^8.5.1",
         "tsx": "^4.21.0",
-        "typedoc": "^0.28.15",
+        "typedoc": "^0.28.17",
         "typescript": "^5.9.3",
-        "typescript-eslint": "^8.48.0"
+        "typescript-eslint": "^8.57.0"
     },
     "engines": {
         "node": "20 || 22 || >=24"
@@ -131,5 +133,5 @@
         "test": "mocha"
     },
     "type": "module",
-    "version": "10.0.1-develop.9"
+    "version": "10.1.1-develop.1"
 }

package/src/alarm.ts

@@ -203,7 +203,7 @@ export default class ICalAlarm {
             return this;
         }
 
-        let _attach = null;
+        let _attach: ICalAttachment | undefined;
         if (typeof attachment === 'string') {
             _attach = {
                 mime: null,

package/src/index.ts

@@ -113,6 +113,10 @@ export {
     type ICalOrganizer,
     type ICalRepeatingOptions,
     type ICalRRuleStub,
+    type ICalTemporalInstantStub,
+    type ICalTemporalPlainDateStub,
+    type ICalTemporalPlainDateTimeStub,
+    type ICalTemporalZonedDateTimeStub,
     type ICalTimezone,
     type ICalTZDateStub,
     ICalWeekday,

package/src/tools.ts

@@ -9,6 +9,10 @@ import {
     type ICalMomentTimezoneStub,
     type ICalOrganizer,
     type ICalRRuleStub,
+    type ICalTemporalInstantStub,
+    type ICalTemporalPlainDateStub,
+    type ICalTemporalPlainDateTimeStub,
+    type ICalTemporalZonedDateTimeStub,
     type ICalTZDateStub,
 } from './types.ts';
 
@@ -19,17 +23,14 @@ export function addOrGetCustomAttributes(
         | Record<string, string>
         | { key: string; value: string }[],
 ): void;
-
 export function addOrGetCustomAttributes(
     data: { x: [string, string][] },
     keyOrArray: string,
     value: string,
 ): void;
-
 export function addOrGetCustomAttributes(data: {
     x: [string, string][];
 }): { key: string; value: string }[];
-
 export function addOrGetCustomAttributes(
     data: { x: [string, string][] },
     keyOrArray?:
@@ -100,6 +101,19 @@ export function checkDate(
         return value;
     }
 
+    // Temporal types - these are always valid if they exist
+    // Check this first to avoid false positives with other date libraries
+    if (
+        typeof value === 'object' &&
+        value !== null &&
+        (isTemporalZonedDateTime(value) ||
+            isTemporalPlainDateTime(value) ||
+            isTemporalPlainDate(value) ||
+            isTemporalInstant(value))
+    ) {
+        return value;
+    }
+
     // Luxon
     if (isLuxonDate(value) && value.isValid === true) {
         return value;
@@ -254,14 +268,14 @@ export function formatDate(
 
         // (!dateonly && !floating) || !timezone => utc
         let s =
-            m.getUTCFullYear() +
+            m.getUTCFullYear().toString().padStart(4, '0') +
             String(m.getUTCMonth() + 1).padStart(2, '0') +
             m.getUTCDate().toString().padStart(2, '0');
 
         // (dateonly || floating) && timezone => tz
         if (timezone) {
             s =
-                m.getFullYear() +
+                m.getFullYear().toString().padStart(2, '0') +
                 String(m.getMonth() + 1).padStart(2, '0') +
                 m.getDate().toString().padStart(2, '0');
         }
@@ -317,6 +331,66 @@ export function formatDate(
                 ? 'T' + m.toFormat('HHmmss') + (floating || timezone ? '' : 'Z')
                 : '')
         );
+    } else if (isTemporalZonedDateTime(d)) {
+        let t = d;
+
+        // try to convert to the specified timezone
+        if (timezone) {
+            t = d.withTimeZone(d.timeZoneId);
+        }
+        if (!timezone && d.timeZoneId !== 'UTC') {
+            t = d.withTimeZone('UTC');
+        }
+
+        return formatDate(
+            null,
+            t.toPlainDateTime(),
+            dateonly,
+
+            // keep floating if specified or if a timezone is set
+            // to remove the 'Z' UTC specifier from the output
+            floating || !!timezone,
+        );
+    } else if (isTemporalPlainDateTime(d)) {
+        // Temporal.PlainDateTime - floating time or convert to timezone
+        if (dateonly) {
+            return (
+                d.year.toString().padStart(4, '0') +
+                d.month.toString().padStart(2, '0') +
+                d.day.toString().padStart(2, '0')
+            );
+        }
+
+        if (timezone) {
+            // Convert to ZonedDateTime in the specified timezone
+            const zoned = d.toZonedDateTime(timezone);
+            return formatDate(timezone, zoned, dateonly, floating);
+        }
+
+        // Floating time - no timezone, no Z
+        return (
+            d.year.toString().padStart(4, '0') +
+            d.month.toString().padStart(2, '0') +
+            d.day.toString().padStart(2, '0') +
+            'T' +
+            d.hour.toString().padStart(2, '0') +
+            d.minute.toString().padStart(2, '0') +
+            d.second.toString().padStart(2, '0') +
+            (floating || timezone ? '' : 'Z')
+        );
+    } else if (isTemporalPlainDate(d)) {
+        // Temporal.PlainDate - date only
+        return (
+            d.year.toString().padStart(4, '0') +
+            d.month.toString().padStart(2, '0') +
+            d.day.toString().padStart(2, '0') +
+            (!dateonly ? 'T000000' + (floating || timezone ? '' : 'Z') : '')
+        );
+    } else if (isTemporalInstant(d)) {
+        // Temporal.Instant - convert to ZonedDateTime first
+        const targetTz = timezone || 'UTC';
+        const zoned = d.toZonedDateTimeISO(targetTz);
+        return formatDate(timezone, zoned, dateonly, floating);
     } else {
         // @see https://day.js.org/docs/en/plugin/utc
 
@@ -384,7 +458,8 @@ export function isDayjs(value: ICalDateTimeValue): value is ICalDayJsStub {
         value !== null &&
         !(value instanceof Date) &&
         !isMoment(value) &&
-        !isLuxonDate(value)
+        !isLuxonDate(value) &&
+        !isTemporal(value)
     );
 }
 
@@ -395,12 +470,17 @@ export function isLuxonDate(
         typeof value === 'object' &&
         value !== null &&
         'toJSDate' in value &&
-        typeof value.toJSDate === 'function'
+        typeof value.toJSDate === 'function' &&
+        !isTemporal(value)
     );
 }
 export function isMoment(value: ICalDateTimeValue): value is ICalMomentStub {
-    // @ts-expect-error _isAMomentObject is a private property
-    return value != null && value._isAMomentObject != null;
+    return (
+        value != null &&
+        // @ts-expect-error _isAMomentObject is a private property
+        value._isAMomentObject != null &&
+        !isTemporal(value)
+    );
 }
 export function isMomentDuration(
     value: unknown,
@@ -428,6 +508,111 @@ export function isRRule(value: unknown): value is ICalRRuleStub {
     );
 }
 
+export function isTemporal(
+    value: ICalDateTimeValue,
+): value is
+    | ICalTemporalInstantStub
+    | ICalTemporalPlainDateStub
+    | ICalTemporalPlainDateTimeStub
+    | ICalTemporalZonedDateTimeStub {
+    return (
+        isTemporalZonedDateTime(value) ||
+        isTemporalPlainDateTime(value) ||
+        isTemporalPlainDate(value) ||
+        isTemporalInstant(value)
+    );
+}
+
+export function isTemporalInstant(
+    value: ICalDateTimeValue,
+): value is ICalTemporalInstantStub {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        !isTemporalZonedDateTime(value) &&
+        !isTemporalPlainDateTime(value) &&
+        !isTemporalPlainDate(value) &&
+        'toZonedDateTimeISO' in value &&
+        typeof value.toZonedDateTimeISO === 'function' &&
+        !('year' in value) &&
+        !('timeZoneId' in value)
+    );
+}
+
+export function isTemporalPlainDate(
+    value: ICalDateTimeValue,
+): value is ICalTemporalPlainDateStub {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        !isTemporalZonedDateTime(value) &&
+        !isTemporalPlainDateTime(value) &&
+        'toPlainDateTime' in value &&
+        typeof value.toPlainDateTime === 'function' &&
+        'year' in value &&
+        typeof value.year === 'number' &&
+        'month' in value &&
+        typeof value.month === 'number' &&
+        'day' in value &&
+        typeof value.day === 'number' &&
+        !('hour' in value) &&
+        !('timeZoneId' in value) &&
+        !('epochSeconds' in value)
+    );
+}
+
+export function isTemporalPlainDateTime(
+    value: ICalDateTimeValue,
+): value is ICalTemporalPlainDateTimeStub {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        !isTemporalZonedDateTime(value) &&
+        'toZonedDateTime' in value &&
+        typeof value.toZonedDateTime === 'function' &&
+        'toPlainDate' in value &&
+        typeof value.toPlainDate === 'function' &&
+        'year' in value &&
+        typeof value.year === 'number' &&
+        'month' in value &&
+        typeof value.month === 'number' &&
+        'day' in value &&
+        typeof value.day === 'number' &&
+        'hour' in value &&
+        typeof value.hour === 'number' &&
+        'minute' in value &&
+        typeof value.minute === 'number' &&
+        'second' in value &&
+        typeof value.second === 'number' &&
+        !('timeZone' in value)
+    );
+}
+
+export function isTemporalZonedDateTime(
+    value: ICalDateTimeValue,
+): value is ICalTemporalZonedDateTimeStub {
+    return (
+        typeof value === 'object' &&
+        value !== null &&
+        'timeZoneId' in value &&
+        typeof value.timeZoneId === 'string' &&
+        'toPlainDateTime' in value &&
+        typeof value.toPlainDateTime === 'function' &&
+        'year' in value &&
+        typeof value.year === 'number' &&
+        'month' in value &&
+        typeof value.month === 'number' &&
+        'day' in value &&
+        typeof value.day === 'number' &&
+        'hour' in value &&
+        typeof value.hour === 'number' &&
+        'minute' in value &&
+        typeof value.minute === 'number' &&
+        'second' in value &&
+        typeof value.second === 'number'
+    );
+}
+
 export function isTZDate(value: ICalDateTimeValue): value is ICalTZDateStub {
     return (
         value instanceof Date &&
@@ -445,6 +630,36 @@ export function toDate(value: ICalDateTimeValue): Date {
         return new Date(value);
     }
 
+    if (isTemporalZonedDateTime(value)) {
+        // Convert ZonedDateTime to Instant, then to Date
+        const instant = value.toInstant();
+        return new Date(instant.epochMilliseconds);
+    }
+
+    if (isTemporalPlainDateTime(value)) {
+        // PlainDateTime has no timezone, treat as UTC
+        return new Date(
+            Date.UTC(
+                value.year,
+                value.month - 1,
+                value.day,
+                value.hour,
+                value.minute,
+                value.second,
+            ),
+        );
+    }
+
+    if (isTemporalPlainDate(value)) {
+        // PlainDate has no time, treat as midnight UTC
+        return new Date(Date.UTC(value.year, value.month - 1, value.day));
+    }
+
+    if (isTemporalInstant(value)) {
+        // Instant has epochMilliseconds
+        return new Date(value.epochMilliseconds);
+    }
+
     if (isLuxonDate(value)) {
         return value.toJSDate();
     }
@@ -506,5 +721,16 @@ export function toJSON(
         return value;
     }
 
+    // Temporal.ZonedDateTime needs special handling to convert to UTC first
+    // as [Timezone] info is not supported as a string input format
+    if (isTemporalZonedDateTime(value)) {
+        return toJSON(value.withTimeZone('UTC').toPlainDateTime());
+    }
+
+    // Temporal types have toJSON() method that returns ISO strings
+    if (isTemporal(value)) {
+        return value.toJSON();
+    }
+
     return value.toJSON();
 }

package/src/types.ts

@@ -20,9 +20,9 @@ export enum ICalWeekday {
 
 /**
  * ical-generator supports [native Date](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date),
- * [moment.js](https://momentjs.com/) (and [moment-timezone](https://momentjs.com/timezone/), [Day.js](https://day.js.org/en/) and
+ * [moment.js](https://momentjs.com/) (and [moment-timezone](https://momentjs.com/timezone/), [Day.js](https://day.js.org/en/),
  * [Luxon](https://moment.github.io/luxon/)'s [DateTime](https://moment.github.io/luxon/docs/class/src/datetime.js~DateTime.html)
- * objects. You can also pass a string which is then passed to javascript's Date internally.
+ * and [Temporal](https://tc39.es/proposal-temporal/docs/) objects. You can also pass a string which is then passed to javascript's Date internally.
  */
 export type ICalDateTimeValue =
     | Date
@@ -30,6 +30,10 @@ export type ICalDateTimeValue =
     | ICalLuxonDateTimeStub
     | ICalMomentStub
     | ICalMomentTimezoneStub
+    | ICalTemporalInstantStub
+    | ICalTemporalPlainDateStub
+    | ICalTemporalPlainDateTimeStub
+    | ICalTemporalZonedDateTimeStub
     | string;
 
 export interface ICalDayJsStub {
@@ -37,8 +41,8 @@ export interface ICalDayJsStub {
     isValid(): boolean;
     toDate(): Date;
     toJSON(): string;
-    tz(zone?: string): ICalDayJsStub;
-    utc(): ICalDayJsStub;
+    tz?(zone?: string): ICalDayJsStub;
+    utc?(): ICalDayJsStub;
 }
 
 export interface ICalDescription {
@@ -123,6 +127,50 @@ export interface ICalRRuleStub {
     toString(): string;
 }
 
+export interface ICalTemporalInstantStub {
+    epochMilliseconds: number;
+    epochSeconds?: number;
+    toJSON(): string;
+    toString(): string;
+    toZonedDateTimeISO(timeZone: string): ICalTemporalZonedDateTimeStub;
+}
+
+export interface ICalTemporalPlainDateStub {
+    day: number;
+    month: number;
+    toJSON(): string;
+    toString(): string;
+    year: number;
+}
+
+export interface ICalTemporalPlainDateTimeStub {
+    day: number;
+    hour: number;
+    minute: number;
+    month: number;
+    second: number;
+    toJSON(): string;
+    toPlainDate(): ICalTemporalPlainDateStub;
+    toString(): string;
+    toZonedDateTime(timeZone: string): ICalTemporalZonedDateTimeStub;
+    year: number;
+}
+
+export interface ICalTemporalZonedDateTimeStub {
+    day: number;
+    hour: number;
+    minute: number;
+    month: number;
+    second: number;
+    timeZoneId: string;
+    toInstant(): ICalTemporalInstantStub;
+    toJSON(): string;
+    toPlainDateTime(): ICalTemporalPlainDateTimeStub;
+    toString(): string;
+    withTimeZone(timeZone: string): ICalTemporalZonedDateTimeStub;
+    year: number;
+}
+
 export interface ICalTimezone {
     generator?: (timezone: string) => null | string;
     name: null | string;