@symbiote-native/calendar 0.1.0

package/build/legacy/reminders.js

@@ -0,0 +1,56 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoCalendar } from './native-module.js';
+import { stringifyDateValues, stringifyIfDate } from '../core/utils.js';
+export async function getRemindersAsync(calendarIds, status, startDate, endDate) {
+    if (!expoCalendar.getRemindersAsync) {
+        throw new UnavailabilityError('Calendar', 'getRemindersAsync');
+    }
+    if (status && !startDate) {
+        throw new Error('getRemindersAsync must be called with a startDate (date) to search for reminders');
+    }
+    if (status && !endDate) {
+        throw new Error('getRemindersAsync must be called with an endDate (date) to search for reminders');
+    }
+    if (!calendarIds || !calendarIds.length) {
+        throw new Error('getRemindersAsync must be called with a non-empty array of calendarIds to search');
+    }
+    return expoCalendar.getRemindersAsync(startDate ? stringifyIfDate(startDate) : null, endDate ? stringifyIfDate(endDate) : null, calendarIds, status);
+}
+export async function getReminderAsync(id) {
+    if (!expoCalendar.getReminderByIdAsync) {
+        throw new UnavailabilityError('Calendar', 'getReminderAsync');
+    }
+    if (!id) {
+        throw new Error('getReminderAsync must be called with an id (string) of the target reminder');
+    }
+    return expoCalendar.getReminderByIdAsync(id);
+}
+export async function createReminderAsync(calendarId, reminder = {}) {
+    if (!expoCalendar.saveReminderAsync) {
+        throw new UnavailabilityError('Calendar', 'createReminderAsync');
+    }
+    const { id: _id, ...details } = reminder;
+    return expoCalendar.saveReminderAsync(stringifyDateValues({ ...details, calendarId: calendarId ?? undefined }));
+}
+export async function updateReminderAsync(id, details = {}) {
+    if (!expoCalendar.saveReminderAsync) {
+        throw new UnavailabilityError('Calendar', 'updateReminderAsync');
+    }
+    if (!id) {
+        throw new Error('updateReminderAsync must be called with an id (string) of the target reminder');
+    }
+    if (Object.hasOwn(details, 'creationDate') ||
+        Object.hasOwn(details, 'lastModifiedDate')) {
+        console.warn('updateReminderAsync was called with one or more read-only properties, which will not be updated');
+    }
+    return expoCalendar.saveReminderAsync(stringifyDateValues({ ...details, id }));
+}
+export async function deleteReminderAsync(id) {
+    if (!expoCalendar.deleteReminderAsync) {
+        throw new UnavailabilityError('Calendar', 'deleteReminderAsync');
+    }
+    if (!id) {
+        throw new Error('deleteReminderAsync must be called with an id (string) of the target reminder');
+    }
+    return expoCalendar.deleteReminderAsync(id);
+}

package/build/legacy/types.d.ts

@@ -0,0 +1,147 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import type { AlarmMethod, AttendeeRole, AttendeeStatus, AttendeeType, CalendarAccessLevel, CalendarDialogResultActions, CalendarType, DayOfTheWeek, EntityTypes, EventAccessLevel, EventStatus, Frequency, MonthOfTheYear, SourceType, Availability } from './enums';
+export type { PermissionResponse };
+export type IRecurringEventOptions = {
+    futureEvents?: boolean;
+    instanceStartDate?: string | Date;
+};
+export type IOrganizer = {
+    isCurrentUser: boolean;
+    name?: string;
+    role: string;
+    status: string;
+    type: string;
+    url?: string;
+};
+export type ISource = {
+    id?: string;
+    type: string | SourceType;
+    name: string;
+    isLocalAccount?: boolean;
+};
+export type ICalendar = {
+    id: string;
+    title: string;
+    sourceId?: string;
+    source: ISource;
+    type?: CalendarType;
+    color: string;
+    entityType?: EntityTypes;
+    allowsModifications: boolean;
+    allowedAvailabilities: Availability[];
+    isPrimary?: boolean;
+    name?: string | null;
+    ownerAccount?: string;
+    timeZone?: string;
+    allowedReminders?: AlarmMethod[];
+    allowedAttendeeTypes?: AttendeeType[];
+    isVisible?: boolean;
+    isSynced?: boolean;
+    accessLevel?: CalendarAccessLevel;
+};
+export type IEvent = {
+    id: string;
+    calendarId: string;
+    title: string;
+    location: string | null;
+    creationDate?: string | Date;
+    lastModifiedDate?: string | Date;
+    timeZone: string;
+    endTimeZone?: string;
+    url?: string;
+    notes: string;
+    alarms: IAlarm[];
+    recurrenceRule: IRecurrenceRule | null;
+    startDate: string | Date;
+    endDate: string | Date;
+    originalStartDate?: string | Date;
+    isDetached?: boolean;
+    allDay: boolean;
+    availability: Availability;
+    status: EventStatus;
+    organizer?: IOrganizer;
+    organizerEmail?: string;
+    accessLevel?: EventAccessLevel;
+    guestsCanModify?: boolean;
+    guestsCanInviteOthers?: boolean;
+    guestsCanSeeGuests?: boolean;
+    originalId?: string;
+    instanceId?: string;
+};
+export type IReminder = {
+    id?: string;
+    calendarId?: string;
+    title?: string;
+    location?: string;
+    creationDate?: string | Date;
+    lastModifiedDate?: string | Date;
+    timeZone?: string;
+    url?: string;
+    notes?: string;
+    alarms?: IAlarm[];
+    recurrenceRule?: IRecurrenceRule | null;
+    startDate?: string | Date;
+    dueDate?: string | Date;
+    allDay?: boolean;
+    completed?: boolean;
+    completionDate?: string | Date;
+};
+export type IAttendee = {
+    id?: string;
+    isCurrentUser?: boolean;
+    name: string;
+    role: AttendeeRole;
+    status: AttendeeStatus;
+    type: AttendeeType;
+    url?: string;
+    email?: string;
+};
+export type IAlarmLocation = {
+    title?: string;
+    proximity?: string;
+    radius?: number;
+    coords?: {
+        latitude?: number;
+        longitude?: number;
+    };
+};
+export type IAlarm = {
+    absoluteDate?: string;
+    relativeOffset?: number;
+    structuredLocation?: IAlarmLocation;
+    method?: AlarmMethod;
+};
+export type IDaysOfTheWeek = {
+    dayOfTheWeek: DayOfTheWeek;
+    weekNumber?: number;
+};
+export type IRecurrenceRule = {
+    frequency: Frequency;
+    interval?: number;
+    endDate?: string | Date;
+    occurrence?: number;
+    daysOfTheWeek?: IDaysOfTheWeek[];
+    daysOfTheMonth?: number[];
+    monthsOfTheYear?: MonthOfTheYear[];
+    weeksOfTheYear?: number[];
+    daysOfTheYear?: number[];
+    setPositions?: number[];
+};
+export type IOpenEventDialogResult = {
+    action: Extract<CalendarDialogResultActions, 'done' | 'canceled' | 'deleted' | 'responded'>;
+};
+export type IDialogEventResult = {
+    action: Extract<CalendarDialogResultActions, 'done' | 'saved' | 'canceled' | 'deleted'>;
+    id: string | null;
+};
+export type IPresentationOptions = {
+    startNewActivityTask?: boolean;
+};
+export type IOpenEventPresentationOptions = IPresentationOptions & {
+    allowsEditing?: boolean;
+    allowsCalendarPreview?: boolean;
+};
+export type ICalendarDialogParams = {
+    id: string;
+    instanceStartDate?: string | Date;
+};

package/build/legacy/types.js

@@ -0,0 +1 @@
+export {};

package/build/react/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../core';
+export { useCalendarPermissions } from './use-calendar-permissions';
+export { useRemindersPermissions } from './use-reminders-permissions';

package/build/react/index.js

@@ -0,0 +1,3 @@
+export * from '../core/index.js';
+export { useCalendarPermissions } from './use-calendar-permissions.js';
+export { useRemindersPermissions } from './use-reminders-permissions.js';

package/build/react/use-calendar-permissions.d.ts

@@ -0,0 +1,10 @@
+import { type ICalendarPermissionMethodOptions } from '../core/calendar-permission-api';
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IPermissionHookOptions } from '@symbiote-native/engine';
+export type IUseCalendarPermissionsOptions = ICalendarPermissionMethodOptions;
+export type IUseCalendarPermissionsResult = [
+    PermissionResponse | null,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare function useCalendarPermissions(options?: IPermissionHookOptions<IUseCalendarPermissionsOptions>): IUseCalendarPermissionsResult;

package/build/react/use-calendar-permissions.js

@@ -0,0 +1,7 @@
+import { createPermissionHook } from '@symbiote-native/react';
+import { calendarPermissionMethods, splitCalendarPermissionOptions, } from '../core/calendar-permission-api.js';
+const usePermission = createPermissionHook(calendarPermissionMethods);
+// React twin of `expo-calendar`'s `useCalendarPermissions`
+export function useCalendarPermissions(options) {
+    return usePermission(...splitCalendarPermissionOptions(options));
+}

package/build/react/use-reminders-permissions.d.ts

@@ -0,0 +1,8 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+export type IUseRemindersPermissionsResult = [
+    PermissionResponse | null,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare function useRemindersPermissions(options?: IPermissionHookBehavior): IUseRemindersPermissionsResult;

package/build/react/use-reminders-permissions.js

@@ -0,0 +1,10 @@
+import { createPermissionHook } from '@symbiote-native/react';
+import { getRemindersPermissions, requestRemindersPermissions, } from '../core/calendar.js';
+const usePermission = createPermissionHook({
+    getMethod: getRemindersPermissions,
+    requestMethod: requestRemindersPermissions,
+});
+// React twin of `expo-calendar`'s `useRemindersPermissions`
+export function useRemindersPermissions(options) {
+    return usePermission(options);
+}

package/build/solid/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../core';
+export { useCalendarPermissions } from './use-calendar-permissions';
+export { useRemindersPermissions } from './use-reminders-permissions';

package/build/solid/index.js

@@ -0,0 +1,3 @@
+export * from '../core/index.js';
+export { useCalendarPermissions } from './use-calendar-permissions.js';
+export { useRemindersPermissions } from './use-reminders-permissions.js';

package/build/solid/use-calendar-permissions.d.ts

@@ -0,0 +1,11 @@
+import { type ICalendarPermissionMethodOptions } from '../core/calendar-permission-api';
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IPermissionHookOptions } from '@symbiote-native/engine';
+import type { Accessor } from 'solid-js';
+export type IUseCalendarPermissionsOptions = ICalendarPermissionMethodOptions;
+export type IUseCalendarPermissionsResult = [
+    Accessor<PermissionResponse | null>,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare function useCalendarPermissions(options?: IPermissionHookOptions<IUseCalendarPermissionsOptions>): IUseCalendarPermissionsResult;

package/build/solid/use-calendar-permissions.js

@@ -0,0 +1,7 @@
+import { createPermissionHook } from '@symbiote-native/solid';
+import { calendarPermissionMethods, splitCalendarPermissionOptions, } from '../core/calendar-permission-api.js';
+const usePermission = createPermissionHook(calendarPermissionMethods);
+// Solid twin of `../react`'s `useCalendarPermissions`
+export function useCalendarPermissions(options) {
+    return usePermission(...splitCalendarPermissionOptions(options));
+}

package/build/solid/use-reminders-permissions.d.ts

@@ -0,0 +1,9 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { Accessor } from 'solid-js';
+export type IUseRemindersPermissionsResult = [
+    Accessor<PermissionResponse | null>,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare function useRemindersPermissions(options?: IPermissionHookBehavior): IUseRemindersPermissionsResult;

package/build/solid/use-reminders-permissions.js

@@ -0,0 +1,10 @@
+import { createPermissionHook } from '@symbiote-native/solid';
+import { getRemindersPermissions, requestRemindersPermissions, } from '../core/calendar.js';
+const usePermission = createPermissionHook({
+    getMethod: getRemindersPermissions,
+    requestMethod: requestRemindersPermissions,
+});
+// Solid twin of `../react`'s `useRemindersPermissions`
+export function useRemindersPermissions(options) {
+    return usePermission(options);
+}

package/build/svelte/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../core';
+export { useCalendarPermissions } from './use-calendar-permissions.svelte';
+export { useRemindersPermissions } from './use-reminders-permissions.svelte';

package/build/svelte/index.js

@@ -0,0 +1,3 @@
+export * from '../core/index.js';
+export { useCalendarPermissions } from './use-calendar-permissions.svelte';
+export { useRemindersPermissions } from './use-reminders-permissions.svelte';

package/build/svelte/use-calendar-permissions.svelte.d.ts

@@ -0,0 +1,10 @@
+import { type ICalendarPermissionMethodOptions } from '../core/calendar-permission-api';
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IPermissionHookOptions } from '@symbiote-native/engine';
+export type IUseCalendarPermissionsOptions = ICalendarPermissionMethodOptions;
+export type IUseCalendarPermissionsResult = {
+    readonly status: PermissionResponse | null;
+    requestPermission: () => Promise<PermissionResponse>;
+    getPermission: () => Promise<PermissionResponse>;
+};
+export declare function useCalendarPermissions(options?: IPermissionHookOptions<IUseCalendarPermissionsOptions>): IUseCalendarPermissionsResult;

package/build/svelte/use-calendar-permissions.svelte.js

@@ -0,0 +1,7 @@
+import { createPermissionHook } from '@symbiote-native/svelte/runes/create-permission-hook';
+import { calendarPermissionMethods, splitCalendarPermissionOptions, } from '../core/calendar-permission-api.js';
+const usePermission = createPermissionHook(calendarPermissionMethods);
+// Svelte twin of `../react`'s `useCalendarPermissions`
+export function useCalendarPermissions(options) {
+    return usePermission(...splitCalendarPermissionOptions(options));
+}

package/build/svelte/use-reminders-permissions.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+export type IUseRemindersPermissionsResult = {
+    readonly status: PermissionResponse | null;
+    requestPermission: () => Promise<PermissionResponse>;
+    getPermission: () => Promise<PermissionResponse>;
+};
+export declare function useRemindersPermissions(behavior?: IPermissionHookBehavior): IUseRemindersPermissionsResult;

package/build/svelte/use-reminders-permissions.svelte.js

@@ -0,0 +1,10 @@
+import { createPermissionHook } from '@symbiote-native/svelte/runes/create-permission-hook';
+import { getRemindersPermissions, requestRemindersPermissions, } from '../core/calendar.js';
+const usePermission = createPermissionHook({
+    getMethod: getRemindersPermissions,
+    requestMethod: requestRemindersPermissions,
+});
+// Svelte twin of `../react`'s `useRemindersPermissions`
+export function useRemindersPermissions(behavior) {
+    return usePermission(behavior);
+}

package/build/vue/index.d.ts

@@ -0,0 +1,3 @@
+export * from '../core';
+export { useCalendarPermissions } from './use-calendar-permissions';
+export { useRemindersPermissions } from './use-reminders-permissions';

package/build/vue/index.js

@@ -0,0 +1,3 @@
+export * from '../core/index.js';
+export { useCalendarPermissions } from './use-calendar-permissions.js';
+export { useRemindersPermissions } from './use-reminders-permissions.js';

package/build/vue/use-calendar-permissions.d.ts

@@ -0,0 +1,11 @@
+import { type ICalendarPermissionMethodOptions } from '../core/calendar-permission-api';
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IPermissionHookOptions } from '@symbiote-native/engine';
+import type { Ref } from '@vue/runtime-core';
+export type IUseCalendarPermissionsOptions = ICalendarPermissionMethodOptions;
+export type IUseCalendarPermissionsResult = [
+    Ref<PermissionResponse | null>,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare function useCalendarPermissions(options?: IPermissionHookOptions<IUseCalendarPermissionsOptions>): IUseCalendarPermissionsResult;

package/build/vue/use-calendar-permissions.js

@@ -0,0 +1,7 @@
+import { createPermissionHook } from '@symbiote-native/vue';
+import { calendarPermissionMethods, splitCalendarPermissionOptions, } from '../core/calendar-permission-api.js';
+const usePermission = createPermissionHook(calendarPermissionMethods);
+// Vue twin of `../react`'s `useCalendarPermissions`
+export function useCalendarPermissions(options) {
+    return usePermission(...splitCalendarPermissionOptions(options));
+}

package/build/vue/use-reminders-permissions.d.ts

@@ -0,0 +1,9 @@
+import type { PermissionResponse } from 'expo-modules-core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { Ref } from '@vue/runtime-core';
+export type IUseRemindersPermissionsResult = [
+    Ref<PermissionResponse | null>,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare function useRemindersPermissions(options?: IPermissionHookBehavior): IUseRemindersPermissionsResult;

package/build/vue/use-reminders-permissions.js

@@ -0,0 +1,10 @@
+import { createPermissionHook } from '@symbiote-native/vue';
+import { getRemindersPermissions, requestRemindersPermissions, } from '../core/calendar.js';
+const usePermission = createPermissionHook({
+    getMethod: getRemindersPermissions,
+    requestMethod: requestRemindersPermissions,
+});
+// Vue twin of `../react`'s `useRemindersPermissions`
+export function useRemindersPermissions(options) {
+    return usePermission(options);
+}

package/build-ngc/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-ngc/angular/index.js

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

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,2BAA2B,EAAE,MAAM,0CAA0C,CAAC"}

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

@@ -0,0 +1,8 @@
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import type { PermissionResponse } from 'expo-modules-core';
+import * as i0 from "@angular/core";
+export declare class CalendarPermissionsService extends PermissionsServiceBase<PermissionResponse, boolean> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarPermissionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarPermissionsService>;
+}

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

@@ -0,0 +1,17 @@
+// Angular twin of `../../react`'s `useCalendarPermissions`, `get`/`request` take `writeOnly`
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import { getCalendarPermissions, requestCalendarPermissions, } from '../../../core/calendar';
+import * as i0 from "@angular/core";
+export class CalendarPermissionsService extends PermissionsServiceBase {
+    constructor() {
+        super(getCalendarPermissions, requestCalendarPermissions);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CalendarPermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CalendarPermissionsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: CalendarPermissionsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/calendar-permissions.service/index.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAE7F,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EACL,sBAAsB,EACtB,0BAA0B,GAC3B,MAAM,wBAAwB,CAAC;;AAIhC,MAAM,OAAO,0BAA2B,SAAQ,sBAG/C;IACC;QACE,KAAK,CAAC,sBAAsB,EAAE,0BAA0B,CAAC,CAAC;IAC5D,CAAC;uGANU,0BAA0B;2GAA1B,0BAA0B,cADb,MAAM;;2FACnB,0BAA0B;kBADtC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

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

@@ -0,0 +1,8 @@
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import type { PermissionResponse } from 'expo-modules-core';
+import * as i0 from "@angular/core";
+export declare class RemindersPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<RemindersPermissionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RemindersPermissionsService>;
+}

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

@@ -0,0 +1,17 @@
+// Angular twin of `../../react`'s `useRemindersPermissions`
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import { getRemindersPermissions, requestRemindersPermissions, } from '../../../core/calendar';
+import * as i0 from "@angular/core";
+export class RemindersPermissionsService extends PermissionsServiceBase {
+    constructor() {
+        super(getRemindersPermissions, requestRemindersPermissions);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: RemindersPermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: RemindersPermissionsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: RemindersPermissionsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/reminders-permissions.service/index.ts"],"names":[],"mappings":"AAAA,4DAA4D;AAE5D,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EACL,uBAAuB,EACvB,2BAA2B,GAC5B,MAAM,wBAAwB,CAAC;;AAIhC,MAAM,OAAO,2BAA4B,SAAQ,sBAA0C;IACzF;QACE,KAAK,CAAC,uBAAuB,EAAE,2BAA2B,CAAC,CAAC;IAC9D,CAAC;uGAHU,2BAA2B;2GAA3B,2BAA2B,cADd,MAAM;;2FACnB,2BAA2B;kBADvC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/build-ngc/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-ngc/core/attendee.js

@@ -0,0 +1,29 @@
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoCalendarNext } from './native-module';
+import { getNullableDetailsFields, stringifyDateValues } from './utils';
+/** @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;
+}
+//# sourceMappingURL=attendee.js.map

package/build-ngc/core/attendee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attendee.js","sourceRoot":"","sources":["../../src/core/attendee.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AAGnD,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAExE,kFAAkF;AAClF,MAAM,OAAO,oBACX,SAAQ,gBAAgB,CAAC,oBAAoB;IAEpC,KAAK,CAAC,MAAM,CAAC,OAAuB;QAC3C,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAClB,MAAM,IAAI,mBAAmB,CAAC,sBAAsB,EAAE,QAAQ,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,KAAK,CAAC,MAAM,CACjB,mBAAmB,CAAC,OAAO,CAAC,EAC5B,wBAAwB,CAAC,OAAO,CAAC,CAClC,CAAC;IACJ,CAAC;IAEQ,KAAK,CAAC,MAAM;QACnB,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;YAClB,MAAM,IAAI,mBAAmB,CAAC,sBAAsB,EAAE,QAAQ,CAAC,CAAC;QAClE,CAAC;QACD,OAAO,KAAK,CAAC,MAAM,EAAE,CAAC;IACxB,CAAC;CACF;AAED,SAAS,sBAAsB,CAAC,KAAc;IAC5C,OAAO,KAAK,YAAY,oBAAoB,CAAC;AAC/C,CAAC;AAED,MAAM,UAAU,6BAA6B,CAC3C,MAAkC;IAElC,MAAM,CAAC,cAAc,CAAC,MAAM,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC;IAC9D,IAAI,CAAC,sBAAsB,CAAC,MAAM,CAAC,EAAE,CAAC;QACpC,MAAM,IAAI,KAAK,CACb,qEAAqE,CACtE,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/build-ngc/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-ngc/core/calendar-permission-api.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"calendar-permission-api.js","sourceRoot":"","sources":["../../src/core/calendar-permission-api.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,6EAA6E;AAE7E,OAAO,EAAE,sBAAsB,EAAE,0BAA0B,EAAE,MAAM,YAAY,CAAC;AAChF,OAAO,EAAE,+BAA+B,EAAE,MAAM,yBAAyB,CAAC;AAI1E,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,SAAS,EAAE,CAAC,OAA0C,EAAE,EAAE,CACxD,sBAAsB,CAAC,OAAO,EAAE,SAAS,CAAC;IAC5C,aAAa,EAAE,CAAC,OAA0C,EAAE,EAAE,CAC5D,0BAA0B,CAAC,OAAO,EAAE,SAAS,CAAC;CACjD,CAAC;AAEF,MAAM,CAAC,MAAM,8BAA8B,GAAG,+BAA+B,CAAC"}

package/build-ngc/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[];