@hebcal/icalendar 6.3.7 → 7.0.0

package/README.md

@@ -1,12 +1,15 @@
 # @hebcal/icalendar
+
 Jewish holidays and Hebrew calendar as iCalendar RFC 2445
 
 ## Installation
+
 ```bash
 $ npm install @hebcal/icalendar
 ```
 
 ## Synopsis
+
 ```javascript
 import {HebrewCalendar, Location} from '@hebcal/core';
 import {eventsToIcalendar} from '@hebcal/icalendar';
@@ -24,7 +27,7 @@ const events = HebrewCalendar.calendar(options);
 const str = await eventsToIcalendar(events, {
   locale: 'he',
   ...options,
-})
+});
 
 const icalStream = fs.createWriteStream('feed.ics');
 icalStream.write(str);

package/dist/foldLine.d.ts

@@ -0,0 +1 @@
+export declare function foldLine(line: string): string;

package/dist/foldLine.js

@@ -0,0 +1,47 @@
+import { Buffer } from 'node:buffer';
+let foldSegmenter;
+const char74re = /.{1,74}/g;
+export function foldLine(line) {
+    const lineBytes = Buffer.byteLength(line);
+    if (lineBytes <= 74) {
+        return line;
+    }
+    if (lineBytes === line.length) {
+        // All-ASCII fast path: every UTF-16 unit encodes to one UTF-8 byte
+        // iff the string is pure ASCII, so we can split by JS chars.
+        return line.match(char74re).join('\r\n ');
+    }
+    // Walk grapheme clusters so we never split a multi-octet UTF-8
+    // sequence (or a combining/ZWJ/regional-indicator cluster) across
+    // a fold boundary. Reuse a single Segmenter to avoid per-call
+    // construction cost.
+    if (!foldSegmenter) {
+        foldSegmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
+    }
+    const parts = [];
+    let chunkStart = 0;
+    let len = 0;
+    for (const { segment, index } of foldSegmenter.segment(line)) {
+        const cp = segment.codePointAt(0);
+        // Most segments are a single code point; compute UTF-8 length
+        // arithmetically and skip the Buffer.byteLength call.
+        const cpUnits = cp >= 0x10000 ? 2 : 1;
+        let octets;
+        if (segment.length === cpUnits) {
+            octets = cp < 0x80 ? 1 : cp < 0x800 ? 2 : cp < 0x10000 ? 3 : 4;
+        }
+        else {
+            octets = Buffer.byteLength(segment);
+        }
+        if (len + octets >= 75) {
+            parts.push(line.slice(chunkStart, index));
+            chunkStart = index;
+            len = octets;
+        }
+        else {
+            len += octets;
+        }
+    }
+    parts.push(line.slice(chunkStart));
+    return parts.join('\r\n ');
+}

package/dist/icalendar.d.ts

@@ -3,6 +3,13 @@ import { CalOptions } from '@hebcal/core/dist/esm/CalOptions';
 export type ICalEventOptions = {
     dtstamp?: string;
     sequence?: number;
+    /**
+     * Text for the `DESCRIPTION` property, overriding `ev.memo`. This is
+     * per-event, so pass a fresh options object to each `IcalEvent` (for
+     * example `new IcalEvent(ev, {...opts, memo})`) rather than setting it on
+     * an options object shared by a whole calendar.
+     */
+    memo?: string;
     emoji?: boolean;
     utmSource?: string;
     utmMedium?: string;
@@ -22,20 +29,20 @@ export type ICalOptions = CalOptions & ICalEventOptions;
  * Represents an RFC 2445 iCalendar VEVENT
  */
 export declare class IcalEvent {
-    ev: Event;
-    options: ICalOptions;
-    dtstamp: string;
-    sequence?: number;
-    timed: boolean;
-    locationName: string | null | undefined;
-    startDate: string;
-    isoDateOnly: string;
-    dtargs: string;
-    transp: string;
-    busyStatus: string;
-    endDate: string;
-    subj: string;
-    category: string | null;
+    readonly ev: Event;
+    readonly options: ICalOptions;
+    readonly dtstamp: string;
+    readonly sequence?: number;
+    readonly timed: boolean;
+    readonly locationName: string | null | undefined;
+    readonly startDate: string;
+    readonly isoDateOnly: string;
+    readonly dtargs: string;
+    readonly transp: string;
+    readonly busyStatus: string;
+    readonly endDate: string;
+    readonly subj: string;
+    readonly category: string | null;
     lines?: string[];
     /**
      * Builds an IcalEvent object from a Hebcal Event

package/dist/icalendar.js

@@ -1,17 +1,14 @@
-/*! @hebcal/icalendar v6.3.7 */
-import { Buffer } from 'node:buffer';
 import { flags } from '@hebcal/core/dist/esm/event';
 import { Locale } from '@hebcal/core/dist/esm/locale';
 import { murmur32HexSync } from 'murmurhash3';
-import { pad2, isDate, pad4 } from '@hebcal/hdate';
-import { shouldRenderBrief, getEventCategories, getCalendarTitle } from '@hebcal/rest-api/dist/esm/common';
-import { getHolidayDescription } from '@hebcal/rest-api/dist/esm/holiday';
-import { makeTorahMemoText } from '@hebcal/rest-api/dist/esm/memo';
+import { pad2, pad4, isDate } from '@hebcal/hdate';
+import { getCalendarTitle, getEventCategories, shouldRenderBrief, } from '@hebcal/rest-api/dist/esm/common';
 import { appendIsraelAndTracking } from '@hebcal/rest-api/dist/esm/url';
 import { makeAnchor } from '@hebcal/rest-api/dist/esm/makeAnchor';
-import { promises } from 'node:fs';
+import { promises as fs } from 'node:fs';
 import { version } from './pkgVersion.js';
-
+import { foldLine } from './foldLine.js';
+const ESC_NEWLINE = String.raw `\n`;
 const vtimezoneCache = new Map();
 const CATEGORY = {
     candles: 'Holiday',
@@ -57,7 +54,6 @@ function appendTrackingToUrl(url, options) {
     const utmCampaign = options.utmCampaign;
     return appendIsraelAndTracking(url, options.il, utmSource, utmMedium, utmCampaign);
 }
-const char74re = /(.{1,74})/g;
 const DAILY_LEARNING = flags.DAILY_LEARNING |
     flags.DAF_YOMI |
     flags.MISHNA_YOMI |
@@ -66,7 +62,7 @@ const DAILY_LEARNING = flags.DAILY_LEARNING |
 /**
  * Represents an RFC 2445 iCalendar VEVENT
  */
-class IcalEvent {
+export class IcalEvent {
     ev;
     options;
     dtstamp;
@@ -161,7 +157,9 @@ class IcalEvent {
             }
         }
         this.subj = subj;
-        this.category = ev0.category || CATEGORY[getEventCategories(ev)?.[0]];
+        this.category =
+            ev0.category ||
+                (CATEGORY[getEventCategories(ev)?.[0]] ?? null);
     }
     getAlarm() {
         const ev = this.ev;
@@ -236,9 +234,13 @@ class IcalEvent {
             arr.push('CLASS:PUBLIC');
         }
         const options = this.options;
-        // create memo (holiday descr, Torah, etc)
-        const memo = createMemo(ev, options);
-        addOptional(arr, 'DESCRIPTION', memo);
+        // The caller is responsible for building the memo (holiday description,
+        // Torah reading, URL, etc), either as `options.memo` or on the event
+        // itself; we only escape newlines for RFC 5545
+        const memo = options.memo ?? ev.memo;
+        if (memo) {
+            addOptional(arr, 'DESCRIPTION', memo.replaceAll('\n', ESC_NEWLINE));
+        }
         addOptional(arr, 'LOCATION', this.locationName);
         const loc = options.location;
         if (this.timed && loc) {
@@ -266,50 +268,13 @@ class IcalEvent {
      * fold lines to 75 characters
      */
     getLines() {
-        return this.getLongLines().map(IcalEvent.fold);
+        return this.getLongLines().map(foldLine);
     }
     /**
      * fold line to 75 characters
      */
     static fold(line) {
-        if (Buffer.byteLength(line) <= 74) {
-            return line;
-        }
-        let isASCII = true;
-        for (let i = 0; i < line.length; i++) {
-            if (line.codePointAt(i) > 255) {
-                isASCII = false;
-                break;
-            }
-        }
-        if (isASCII) {
-            // It's longer than 74 octets, and all characters are ASCII, so we
-            // use a simple regex to split it into chunks of 74 characters
-            const matches = line.match(char74re);
-            return matches.join('\r\n ');
-        }
-        // iterate unicode character by character, making sure
-        // that adding a new character would keep the line <= 75 octets
-        const segmenter = new Intl.Segmenter('en', { granularity: 'grapheme' });
-        const segments = segmenter.segment(line);
-        const chars = Array.from(segments, s => s.segment);
-        let result = '';
-        let current = '';
-        let len = 0;
-        for (const ch of chars) {
-            const octets = ch.codePointAt(0) < 256 ? 1 : Buffer.byteLength(ch);
-            const newlen = len + octets;
-            if (newlen < 75) {
-                current += ch;
-                len = newlen;
-            }
-            else {
-                result += current + '\r\n ';
-                current = ch;
-                len = octets;
-            }
-        }
-        return result + current;
+        return foldLine(line);
     }
     static escape(str) {
         if (str.includes(',')) {
@@ -343,96 +308,14 @@ class IcalEvent {
  * Transforms a single Event into a VEVENT string
  * @returns multi-line result, delimited by \r\n
  */
-function eventToIcal(ev, options) {
+export function eventToIcal(ev, options) {
     const ical = new IcalEvent(ev, options);
     return ical.toString();
 }
-const torahMemoCache = new Map();
-const HOLIDAY_IGNORE_MASK = DAILY_LEARNING |
-    flags.OMER_COUNT |
-    flags.SHABBAT_MEVARCHIM |
-    flags.MOLAD |
-    flags.USER_EVENT |
-    flags.HEBREW_DATE;
-const ESC_NEWLINE = String.raw `\n`;
-const DBL_NEWLINE = ESC_NEWLINE + ESC_NEWLINE;
-/**
- * @private
- */
-function makeTorahMemo(ev, il) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    if (ev.getFlags() & HOLIDAY_IGNORE_MASK || ev.eventTime) {
-        return '';
-    }
-    const hd = ev.getDate();
-    const yy = hd.getFullYear();
-    const mm = hd.getMonth();
-    const dd = hd.getDate();
-    const key = [yy, mm, dd, il ? '1' : '0', ev.getDesc()].join('-');
-    let memo = torahMemoCache.get(key);
-    if (typeof memo === 'string') {
-        return memo;
-    }
-    memo = makeTorahMemoText(ev, il).replaceAll('\n', ESC_NEWLINE);
-    torahMemoCache.set(key, memo);
-    return memo;
-}
-/**
- * @private
- */
-function createMemo(ev, options) {
-    let memo = ev.memo || '';
-    if (memo.length && memo.includes('\n')) {
-        memo = memo.replaceAll('\n', ESC_NEWLINE);
-    }
-    const desc = ev.getDesc();
-    if (desc === 'Havdalah' || desc === 'Candle lighting') {
-        return memo;
-    }
-    const mask = ev.getFlags();
-    if (mask & flags.OMER_COUNT) {
-        const omerEv = ev;
-        const sefira = [
-            omerEv.sefira('en'),
-            omerEv.sefira('he'),
-            omerEv.sefira('translit'),
-        ].join(ESC_NEWLINE);
-        return (omerEv.getTodayIs('en') +
-            DBL_NEWLINE +
-            omerEv.getTodayIs('he') +
-            DBL_NEWLINE +
-            sefira);
-    }
-    if (!memo) {
-        memo = getHolidayDescription(ev);
-    }
-    if (!memo) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const linkEv = ev.linkedEvent;
-        if (linkEv && linkEv.getDesc() !== ev.getDesc()) {
-            memo = linkEv.render(options.locale);
-        }
-    }
-    const torahMemo = makeTorahMemo(ev, options.il);
-    if (torahMemo) {
-        if (memo.length) {
-            memo += DBL_NEWLINE;
-        }
-        memo += torahMemo;
-    }
-    const url = appendTrackingToUrl(ev.url(), options);
-    if (url) {
-        if (memo.length) {
-            memo += DBL_NEWLINE;
-        }
-        memo += url;
-    }
-    return memo;
-}
 /**
  * Generates an RFC 2445 iCalendar string from an array of events
  */
-async function eventsToIcalendar(events, options) {
+export async function eventsToIcalendar(events, options) {
     if (!events.length)
         throw new RangeError('Events can not be empty');
     if (!options)
@@ -461,7 +344,7 @@ async function getVtimezone(tzid) {
     }
     const filename = `./zoneinfo/${tzid}.ics`;
     try {
-        const contents = await promises.readFile(filename, 'utf-8');
+        const contents = await fs.readFile(filename, 'utf-8');
         const lines = contents.split('\r\n');
         // ignore first 3 and last 1 lines
         const str = lines.slice(3, lines.length - 2).join('\r\n');
@@ -510,14 +393,14 @@ function makeIcalPreamble(opts) {
 /**
  * Generates an RFC 2445 iCalendar string from an array of IcalEvents
  */
-async function icalEventsToString(icals, options) {
+export async function icalEventsToString(icals, options) {
     if (!icals.length)
         throw new RangeError('Events can not be empty');
     if (!options)
         throw new TypeError('Invalid options object');
     const stream = [];
     const preamble = makeIcalPreamble(options);
-    for (const line of preamble.map(IcalEvent.fold)) {
+    for (const line of preamble.map(foldLine)) {
         stream.push(line);
         stream.push('\r\n');
     }
@@ -541,5 +424,3 @@ async function icalEventsToString(icals, options) {
     stream.push('END:VCALENDAR\r\n');
     return stream.join('');
 }
-
-export { IcalEvent, eventToIcal, eventsToIcalendar, icalEventsToString };

package/dist/pkgVersion.d.ts

@@ -1 +1 @@
-export declare const version = "6.3.7";
+export declare const version = "7.0.0";

package/dist/pkgVersion.js

@@ -1,5 +1,2 @@
-/*! @hebcal/icalendar v6.3.7 */
 // DO NOT EDIT THIS AUTO-GENERATED FILE!
-const version = '6.3.7';
-
-export { version };
+export const version = '7.0.0';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebcal/icalendar",
-  "version": "6.3.7",
+  "version": "7.0.0",
   "author": "Michael J. Radwin (https://github.com/mjradwin)",
   "keywords": [
     "ical",
@@ -30,33 +30,32 @@
   },
   "homepage": "https://hebcal.github.io/api/icalendar/",
   "dependencies": {
-    "@hebcal/core": "^6.1.0",
-    "@hebcal/hdate": "^0.22.0",
-    "@hebcal/rest-api": "^6.4.3",
-    "murmurhash3": "^0.5.0",
-    "tslib": "^2.8.1"
+    "@hebcal/core": "^6.8.2",
+    "@hebcal/hdate": "^0.22.5",
+    "@hebcal/rest-api": "^7.0.0",
+    "murmurhash3": "^0.5.0"
   },
   "scripts": {
-    "build:rollup": "rollup -c",
-    "build:version": "node ./version.cjs package.json src/pkgVersion.ts",
-    "build": "npm run build:version && npm run build:rollup",
+    "build:version": "node ./version.js package.json src/pkgVersion.ts",
+    "build": "npm run build:version && tsc",
     "pretest": "npm run build",
-    "docs": "typedoc",
+    "docs": "npx -y typedoc",
     "test": "vitest",
-    "lint": "gts lint",
-    "clean": "gts clean",
+    "lint": "oxlint && prettier --check .",
+    "clean": "rm -rf dist",
     "compile": "tsc",
-    "fix": "gts fix"
+    "fix": "oxlint --fix && prettier --write ."
   },
   "license": "BSD-2-Clause",
   "devDependencies": {
-    "@hebcal/learning": "^6.7.2",
-    "@rollup/plugin-typescript": "^12.3.0",
-    "@types/node": "25.6.0",
-    "gts": "^7.0.0",
-    "rollup": "^4.60.1",
-    "typedoc": "^0.28.18",
-    "typescript": "^6.0.2",
-    "vitest": "^4.1.4"
+    "@hebcal/learning": "^6.9.5",
+    "@types/node": "26.1.1",
+    "oxlint": "^1.76.0",
+    "prettier": "^3.9.6",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "allowScripts": {
+    "murmurhash3": true
   }
 }