@symbiote-native/calendar 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,189 @@
+# @symbiote-native/calendar
+
+Add a meeting to the user's calendar, list what is on this week, set a reminder, or hand the user
+the system's own event dialog. One API for every [SymbioteNative](../../README.md) adapter (React,
+Vue, Svelte, Solid and Angular).
+
+It wraps [`expo-calendar`](https://github.com/expo/expo/tree/main/packages/expo-calendar)
+(calendar, event, reminder and attendee CRUD, plus the OS event dialogs) the same way
+[`@symbiote-native/print`](../print) wraps its upstream: `expo-modules-core` is a direct
+dependency and the upstream JS is hand-ported into `core/`. See the `symbiote-expo-native-module`
+project skill for the full mechanism.
+
+**Both of upstream's API surfaces are ported, matching Expo's own layout exactly**: the modern
+`SharedObject`-class `ExpoCalendar`/`ExpoCalendarEvent`/`ExpoCalendarReminder`/
+`ExpoCalendarAttendee` API (default entry, mirroring upstream's own default `Calendar.ts`) and
+the legacy function-based API (`/legacy` subpath, mirroring upstream's `legacy/Calendar.ts`).
+Method names, the static-vs-module-level-function split, and per-field platform availability all
+match upstream's real source (`src/Calendar.ts` and `src/legacy/Calendar.ts` at sdk-57) directly.
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --calendar
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --calendar
+```
+
+Either way: installs `@symbiote-native/calendar` and wires the native autolinking
+automatically, see [`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/calendar
+```
+
+`expo-calendar` and `expo-modules-core` come along as regular, pinned dependencies, never
+install either yourself, and never add the `expo` meta-package to this project.
+
+### Required one-time step: native autolinking wiring
+
+Same one-time app wiring every `expo-modules-core` package shares, see
+[`@symbiote-native/print`'s README](../print/README.md#required-one-time-step-native-autolinking-wiring)
+for the full table; nothing package-specific here.
+
+### Permissions and config plugin
+
+`native-link.json` declares:
+
+- **Android**: `READ_CALENDAR`/`WRITE_CALENDAR` permissions. Both native modules are registered
+  and genuinely called by our JS: `ExpoCalendar` (legacy surface, `/legacy` subpath) and
+  `CalendarNext` (modern surface, default entry).
+- **iOS**: `NSCalendarsUsageDescription`, `NSRemindersUsageDescription`,
+  `NSRemindersFullAccessUsageDescription`, `NSCalendarsFullAccessUsageDescription` (custom
+  wording; reword to fit the app).
+
+**Not modeled** (upstream's config plugin's `writeOnlyAccess` opt-in, which swaps
+`NSCalendarsFullAccessUsageDescription` for `NSCalendarsWriteOnlyAccessUsageDescription`): this
+manifest format has no iOS equivalent of Android's `optionalManifestBundles` for a plist-key swap.
+If write-only calendar access (iOS 17+) is needed, add
+`NSCalendarsWriteOnlyAccessUsageDescription` to the app's own Info.plist by hand and drop
+`NSCalendarsFullAccessUsageDescription`.
+
+</details>
+
+## Platform availability (modern API)
+
+| Member | iOS | Android |
+|---|---|---|
+| `ExpoCalendar` CRUD (`createEvent`/`update`/`addEventWithForm`/`delete`), `listEvents` | yes | yes |
+| `getDefaultCalendarSync`/`presentPicker`/`getSourcesSync` (module-level) | yes | no |
+| `calendar.createReminder`/`listReminders` | yes | no |
+| `event.createAttendee` | no | yes |
+| `event.getOccurrenceSync`/`getAttendees`/`update`/`delete` | yes | yes |
+| `ExpoCalendarReminder` (whole class) | yes | no - no-op class, no properties/methods |
+| `ExpoCalendarAttendee` (whole class) | no - no-op class | yes |
+| `getCalendarPermissions`/`requestCalendarPermissions` (module-level) | yes | yes |
+| `getRemindersPermissions`/`requestRemindersPermissions` (module-level) | yes | no |
+
+An iOS-only or Android-only member throws `UnavailabilityError` on the other platform, or is
+absent from the native ambient - check for presence before calling if the call site must run on
+both.
+
+## What's not ported
+
+Nothing from `expo-calendar`'s public surface. The legacy `requestPermissionsAsync` is kept as the
+deprecated alias upstream ships: it warns and calls `requestCalendarPermissionsAsync`.
+
+## Permission hooks
+
+`useCalendarPermissions`/`useRemindersPermissions` are ported to every adapter (originally
+dropped as React-only, since reversed):
+
+- React/Vue/Solid: `createPermissionHook` from `@symbiote-native/{react,vue,solid}`, a tuple
+  `[status, request, get]`.
+- Svelte: `createPermissionHook` from `@symbiote-native/svelte/runes/create-permission-hook`, a
+  boxed getter `{status, requestPermission, getPermission}`.
+- Angular: `CalendarPermissionsService`/`RemindersPermissionsService`, `connect(): Signal<...>`.
+
+## Shape
+
+```
+src/core/                 modern SharedObject API (default entry)
+  enums.ts                 every enum (EntityTypes, Frequency, Availability, ...)
+  types.ts                 ICalendarInput/Patch, IEventInput/Patch, IAttendeeInput/Patch, ...
+  utils.ts                  stringifyDateValues, getNullableDetailsFields
+  native-module.ts          declare class ambients for the 4 SharedObject classes + module fns
+  calendar.ts               ExpoCalendar class + module-level functions (getCalendars, ...)
+  event.ts                  ExpoCalendarEvent - instance CRUD/attendee methods, static get()
+  attendee.ts                ExpoCalendarAttendee (android-only surface)
+  reminder.ts                ExpoCalendarReminder (ios-only surface)
+src/legacy/                legacy function-based API (/legacy subpath)
+  enums.ts                  re-exports src/core/enums.ts - upstream shares one enum source too
+  types.ts                  ICalendar, IEvent, IReminder, IAttendee, IRecurrenceRule, ...
+  native-module.ts          requireNativeModule('ExpoCalendar')
+  calendar.ts                every *Async free function (getCalendarsAsync, createEventAsync, ...)
+src/angular/               @symbiote-native/calendar/angular
+```
+
+`./react`, `./vue`, `./svelte`, and `./solid` are `exports`-map aliases straight onto
+`src/core/`. `./legacy` aliases onto `src/legacy/`; there is no separate Angular build for it,
+matching `@symbiote-native/file-system`'s and `@symbiote-native/media-library`'s dual-surface
+precedent.
+
+Every wrapper class extends its native `SharedObject` base directly
+(`class ExpoCalendarEvent extends expoCalendarNext.ExpoCalendarEvent`), overriding only the
+methods upstream itself overrides (Date stringification, `getNullableDetailsFields`, prototype
+upgrade of a returned native instance, or a platform guard) - everything else (like
+`openInCalendar`/`editInCalendar`) is inherited from the native ambient untouched, exactly as
+upstream leaves it. A module-level `upgradeToX(native)` helper reassigns a returned native
+instance's prototype in place (`Object.setPrototypeOf`) rather than calling `new` on the native
+class, since Android's Kotlin throws on direct construction of `ExpoCalendar`/`ExpoCalendarEvent`.
+
+## Use it
+
+```ts
+// modern surface (default)
+import { ExpoCalendar, requestCalendarPermissions } from '@symbiote-native/calendar';
+
+await requestCalendarPermissions();
+const calendar = await ExpoCalendar.get(calendarId);
+const event = await calendar.createEvent({
+  title: 'Standup',
+  startDate: new Date(),
+  endDate: new Date(Date.now() + 30 * 60_000),
+});
+await event.update({ notes: 'Daily sync' });
+```
+
+```ts
+// legacy surface
+import { createEventAsync, requestCalendarPermissionsAsync } from '@symbiote-native/calendar/legacy';
+
+await requestCalendarPermissionsAsync();
+const eventId = await createEventAsync(calendarId, {
+  title: 'Standup',
+  startDate: new Date(),
+  endDate: new Date(Date.now() + 30 * 60_000),
+});
+```
+
+## Common questions
+
+- **`getCalendars()` or `createEvent` fails or returns nothing.** Call `requestCalendarPermissions()`
+  first and check `granted` (Android: `READ_CALENDAR` and `WRITE_CALENDAR`, added for you).
+- **The system event dialog does not appear on iOS, no error.** iOS checks permission before showing
+  it: ask first, then call `addEventWithForm`.
+- **Default calendar.** `getDefaultCalendarSync()` is iOS only; on Android list calendars and pick.
+- **Reminders on Android.** iOS only.
+- **Write-only access.** `requestCalendarPermissions(true)` on iOS 17+; swap the Info.plist string by
+  hand (see Permissions above).
+
+Sources: [Expo docs: Calendar](https://docs.expo.dev/versions/v56.0.0/sdk/calendar-legacy/),
+[expo/expo#36001](https://github.com/expo/expo/issues/36001),
+[expo/expo#4991](https://github.com/expo/expo/issues/4991),
+[expo/expo#48186](https://github.com/expo/expo/pull/48186).
+
+## Test it
+
+```bash
+pnpm vitest run packages/calendar
+```

package/build/angular/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../core';
+export { CalendarPermissionsService } from './services/calendar-permissions.service';
+export { RemindersPermissionsService } from './services/reminders-permissions.service';

package/build/angular/index.js

@@ -0,0 +1,3 @@
+export * from '../core/index.js';
+export { CalendarPermissionsService } from './services/calendar-permissions.service/index.js';
+export { RemindersPermissionsService } from './services/reminders-permissions.service/index.js';

package/build/angular/services/calendar-permissions.service/index.d.ts

@@ -0,0 +1,5 @@
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import type { PermissionResponse } from 'expo-modules-core';
+export declare class CalendarPermissionsService extends PermissionsServiceBase<PermissionResponse, boolean> {
+    constructor();
+}

package/build/angular/services/calendar-permissions.service/index.js

@@ -0,0 +1,60 @@
+// Angular twin of `../../react`'s `useCalendarPermissions`, `get`/`request` take `writeOnly`
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import { getCalendarPermissions, requestCalendarPermissions, } from '../../../core/calendar.js';
+let CalendarPermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = PermissionsServiceBase;
+    var CalendarPermissionsService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            CalendarPermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super(getCalendarPermissions, requestCalendarPermissions);
+        }
+    };
+    return CalendarPermissionsService = _classThis;
+})();
+export { CalendarPermissionsService };

package/build/angular/services/reminders-permissions.service/index.d.ts

@@ -0,0 +1,5 @@
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import type { PermissionResponse } from 'expo-modules-core';
+export declare class RemindersPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+    constructor();
+}

package/build/angular/services/reminders-permissions.service/index.js

@@ -0,0 +1,60 @@
+// Angular twin of `../../react`'s `useRemindersPermissions`
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import { getRemindersPermissions, requestRemindersPermissions, } from '../../../core/calendar.js';
+let RemindersPermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = PermissionsServiceBase;
+    var RemindersPermissionsService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            RemindersPermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super(getRemindersPermissions, requestRemindersPermissions);
+        }
+    };
+    return RemindersPermissionsService = _classThis;
+})();
+export { RemindersPermissionsService };

package/build/core/attendee.d.ts

@@ -0,0 +1,9 @@
+import { expoCalendarNext } from './native-module';
+import type { NativeExpoCalendarAttendee } from './native-module';
+import type { IAttendeePatch } from './types';
+/** @platform android - iOS registers this class with no properties or methods. */
+export declare class ExpoCalendarAttendee extends expoCalendarNext.ExpoCalendarAttendee {
+    update(details: IAttendeePatch): Promise<void>;
+    delete(): Promise<void>;
+}
+export declare function upgradeToExpoCalendarAttendee(native: NativeExpoCalendarAttendee): ExpoCalendarAttendee;

package/build/core/attendee.js

@@ -0,0 +1,28 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoCalendarNext } from './native-module.js';
+import { getNullableDetailsFields, stringifyDateValues } from './utils.js';
+/** @platform android - iOS registers this class with no properties or methods. */
+export class ExpoCalendarAttendee extends expoCalendarNext.ExpoCalendarAttendee {
+    async update(details) {
+        if (!super.update) {
+            throw new UnavailabilityError('ExpoCalendarAttendee', 'update');
+        }
+        return super.update(stringifyDateValues(details), getNullableDetailsFields(details));
+    }
+    async delete() {
+        if (!super.delete) {
+            throw new UnavailabilityError('ExpoCalendarAttendee', 'delete');
+        }
+        return super.delete();
+    }
+}
+function isExpoCalendarAttendee(value) {
+    return value instanceof ExpoCalendarAttendee;
+}
+export function upgradeToExpoCalendarAttendee(native) {
+    Object.setPrototypeOf(native, ExpoCalendarAttendee.prototype);
+    if (!isExpoCalendarAttendee(native)) {
+        throw new Error('unreachable - just reassigned the prototype to ExpoCalendarAttendee');
+    }
+    return native;
+}

package/build/core/calendar-permission-api.d.ts

@@ -0,0 +1,9 @@
+import { splitWriteOnlyPermissionOptions } from '@symbiote-native/engine';
+export type ICalendarPermissionMethodOptions = {
+    writeOnly?: boolean;
+};
+export declare const calendarPermissionMethods: {
+    getMethod: (options?: ICalendarPermissionMethodOptions) => Promise<import("expo-modules-core").PermissionResponse>;
+    requestMethod: (options?: ICalendarPermissionMethodOptions) => Promise<import("expo-modules-core").PermissionResponse>;
+};
+export declare const splitCalendarPermissionOptions: typeof splitWriteOnlyPermissionOptions;

package/build/core/calendar-permission-api.js

@@ -0,0 +1,9 @@
+// `methods` every adapter's `useCalendarPermissions` binds to the shared
+// `@symbiote-native/{react,vue,solid,svelte}` `createPermissionHook` factory
+import { getCalendarPermissions, requestCalendarPermissions } from './calendar.js';
+import { splitWriteOnlyPermissionOptions } from '@symbiote-native/engine';
+export const calendarPermissionMethods = {
+    getMethod: (options) => getCalendarPermissions(options?.writeOnly),
+    requestMethod: (options) => requestCalendarPermissions(options?.writeOnly),
+};
+export const splitCalendarPermissionOptions = splitWriteOnlyPermissionOptions;

package/build/core/calendar.d.ts

@@ -0,0 +1,34 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import { expoCalendarNext } from './native-module';
+import type { IAddEventWithFormOptions, ICalendarInput, ICalendarPatch, IDialogEventResult, IEventInput, IReminderInput, ISource } from './types';
+import type { EntityTypes } from './enums';
+import { ExpoCalendarEvent } from './event';
+import { ExpoCalendarReminder } from './reminder';
+export declare class ExpoCalendar extends expoCalendarNext.ExpoCalendar {
+    createEvent(details: IEventInput): Promise<ExpoCalendarEvent>;
+    /** @platform ios */
+    createReminder(details: IReminderInput): Promise<ExpoCalendarReminder>;
+    listEvents(startDate: Date, endDate: Date): Promise<ExpoCalendarEvent[]>;
+    /** @platform ios */
+    listReminders(startDate?: string | Date | null, endDate?: string | Date | null, status?: string | null): Promise<ExpoCalendarReminder[]>;
+    update(details: ICalendarPatch): Promise<void>;
+    addEventWithForm(options?: IAddEventWithFormOptions): Promise<IDialogEventResult>;
+    delete(): Promise<void>;
+    static get(calendarId: string): Promise<ExpoCalendar>;
+}
+/** @platform ios - Android has no single system-managed default calendar. */
+export declare function getDefaultCalendarSync(): ExpoCalendar;
+export declare function getCalendars(entityType?: EntityTypes): Promise<ExpoCalendar[]>;
+export declare function createCalendar(details?: ICalendarInput): Promise<ExpoCalendar>;
+/** @platform ios */
+export declare function presentPicker(): Promise<ExpoCalendar | null>;
+/** Searches events across several calendars at once - use `calendar.listEvents()` for one. */
+export declare function listEvents(calendars: (string | ExpoCalendar)[], startDate: Date, endDate: Date): Promise<ExpoCalendarEvent[]>;
+export declare function requestCalendarPermissions(writeOnly?: boolean): Promise<PermissionResponse>;
+export declare function getCalendarPermissions(writeOnly?: boolean): Promise<PermissionResponse>;
+/** @platform ios */
+export declare function requestRemindersPermissions(): Promise<PermissionResponse>;
+/** @platform ios */
+export declare function getRemindersPermissions(): Promise<PermissionResponse>;
+/** @platform ios - Android has no first-class calendar-sources API. */
+export declare function getSourcesSync(): ISource[];

package/build/core/calendar.js

@@ -0,0 +1,118 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoCalendarNext } from './native-module.js';
+import { stringifyDateValues, stringifyIfDate } from './utils.js';
+import { ExpoCalendarEvent, upgradeToExpoCalendarEvent } from './event.js';
+import { ExpoCalendarReminder, upgradeToExpoCalendarReminder, } from './reminder.js';
+export class ExpoCalendar extends expoCalendarNext.ExpoCalendar {
+    async createEvent(details) {
+        return upgradeToExpoCalendarEvent(await super.createEvent(stringifyDateValues(details)));
+    }
+    /** @platform ios */
+    async createReminder(details) {
+        if (!super.createReminder) {
+            throw new UnavailabilityError('ExpoCalendar', 'createReminder');
+        }
+        return upgradeToExpoCalendarReminder(await super.createReminder(stringifyDateValues(details)));
+    }
+    async listEvents(startDate, endDate) {
+        if (!startDate) {
+            throw new Error('listEvents must be called with a startDate (date) to search for events');
+        }
+        if (!endDate) {
+            throw new Error('listEvents must be called with an endDate (date) to search for events');
+        }
+        const events = await super.listEvents(stringifyIfDate(startDate), stringifyIfDate(endDate));
+        return events.map(upgradeToExpoCalendarEvent);
+    }
+    /** @platform ios */
+    async listReminders(startDate = null, endDate = null, status = null) {
+        if (!super.listReminders) {
+            throw new UnavailabilityError('ExpoCalendar', 'listReminders');
+        }
+        const reminders = await super.listReminders(startDate, endDate, status);
+        return reminders.map(upgradeToExpoCalendarReminder);
+    }
+    async update(details) {
+        return super.update(stringifyDateValues(details));
+    }
+    async addEventWithForm(options) {
+        if (!super.addEventWithForm) {
+            throw new UnavailabilityError('ExpoCalendar', 'addEventWithForm');
+        }
+        return super.addEventWithForm(options && stringifyDateValues(options));
+    }
+    async delete() {
+        return super.delete();
+    }
+    static async get(calendarId) {
+        return upgradeToExpoCalendar(await expoCalendarNext.getCalendarById(calendarId));
+    }
+}
+function isExpoCalendar(value) {
+    return value instanceof ExpoCalendar;
+}
+function upgradeToExpoCalendar(native) {
+    Object.setPrototypeOf(native, ExpoCalendar.prototype);
+    if (!isExpoCalendar(native)) {
+        throw new Error('unreachable - just reassigned the prototype to ExpoCalendar');
+    }
+    return native;
+}
+/** @platform ios - Android has no single system-managed default calendar. */
+export function getDefaultCalendarSync() {
+    if (!expoCalendarNext.getDefaultCalendarSync) {
+        throw new UnavailabilityError('Calendar', 'getDefaultCalendarSync');
+    }
+    return upgradeToExpoCalendar(expoCalendarNext.getDefaultCalendarSync());
+}
+export async function getCalendars(entityType) {
+    if (!expoCalendarNext.getCalendars) {
+        throw new UnavailabilityError('Calendar', 'getCalendars');
+    }
+    const calendars = await expoCalendarNext.getCalendars(entityType ?? null);
+    return calendars.map(upgradeToExpoCalendar);
+}
+export async function createCalendar(details = {}) {
+    return upgradeToExpoCalendar(await expoCalendarNext.createCalendar(details));
+}
+/** @platform ios */
+export async function presentPicker() {
+    if (!expoCalendarNext.presentPicker) {
+        throw new UnavailabilityError('Calendar', 'presentPicker');
+    }
+    const calendar = await expoCalendarNext.presentPicker();
+    return calendar ? upgradeToExpoCalendar(calendar) : null;
+}
+/** Searches events across several calendars at once - use `calendar.listEvents()` for one. */
+export async function listEvents(calendars, startDate, endDate) {
+    const calendarIds = calendars.map(calendar => typeof calendar === 'string' ? calendar : calendar.id);
+    const events = await expoCalendarNext.listEvents(calendarIds, stringifyIfDate(startDate), stringifyIfDate(endDate));
+    return events.map(upgradeToExpoCalendarEvent);
+}
+export async function requestCalendarPermissions(writeOnly) {
+    return expoCalendarNext.requestCalendarPermissions(writeOnly);
+}
+export async function getCalendarPermissions(writeOnly) {
+    return expoCalendarNext.getCalendarPermissions(writeOnly);
+}
+/** @platform ios */
+export async function requestRemindersPermissions() {
+    if (!expoCalendarNext.requestRemindersPermissions) {
+        throw new UnavailabilityError('Calendar', 'requestRemindersPermissions');
+    }
+    return expoCalendarNext.requestRemindersPermissions();
+}
+/** @platform ios */
+export async function getRemindersPermissions() {
+    if (!expoCalendarNext.getRemindersPermissions) {
+        throw new UnavailabilityError('Calendar', 'getRemindersPermissions');
+    }
+    return expoCalendarNext.getRemindersPermissions();
+}
+/** @platform ios - Android has no first-class calendar-sources API. */
+export function getSourcesSync() {
+    if (!expoCalendarNext.getSourcesSync) {
+        throw new UnavailabilityError('Calendar', 'getSourcesSync');
+    }
+    return expoCalendarNext.getSourcesSync();
+}