@vicacha-devs/strapi-plugin-calendar 0.0.0-stage → 1.0.0

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => Promise<void>;
+export default _default;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,7 @@
+import { CalendarPluginSettings } from '../../../shared/types';
+export declare const DEFAULT_CALENDAR_SETTINGS: CalendarPluginSettings;
+declare const _default: {
+    default: CalendarPluginSettings;
+    validator(config: Partial<CalendarPluginSettings>): void;
+};
+export default _default;

package/dist/server/src/controllers/admin.d.ts

@@ -0,0 +1,15 @@
+import { Core } from '@strapi/strapi';
+import { CalendarPluginSettings } from '../../../shared/types';
+import { StrapiRouteContext } from '../types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getCalendar(ctx: StrapiRouteContext): Promise<void>;
+    reschedule(ctx: StrapiRouteContext): Promise<void>;
+    quickCreate(ctx: StrapiRouteContext): Promise<void>;
+    getSettings(ctx: StrapiRouteContext): Promise<void>;
+    updateSettings(ctx: StrapiRouteContext<Partial<CalendarPluginSettings>>): Promise<void>;
+    clearSettings(ctx: StrapiRouteContext): Promise<void>;
+    getContentTypes(ctx: StrapiRouteContext): Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/content-api.d.ts

@@ -0,0 +1,10 @@
+import { Core } from '@strapi/strapi';
+import { StrapiRouteContext } from '../types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    getOccurrences(ctx: StrapiRouteContext): Promise<void>;
+    downloadFeedIcs(ctx: StrapiRouteContext): Promise<void>;
+    downloadEventIcs(ctx: StrapiRouteContext): Promise<void>;
+};
+export default _default;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,21 @@
+declare const _default: {
+    admin: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        getCalendar(ctx: import('../types').StrapiRouteContext): Promise<void>;
+        reschedule(ctx: import('../types').StrapiRouteContext): Promise<void>;
+        quickCreate(ctx: import('../types').StrapiRouteContext): Promise<void>;
+        getSettings(ctx: import('../types').StrapiRouteContext): Promise<void>;
+        updateSettings(ctx: import('../types').StrapiRouteContext<Partial<import('../../../shared/types').CalendarPluginSettings>>): Promise<void>;
+        clearSettings(ctx: import('../types').StrapiRouteContext): Promise<void>;
+        getContentTypes(ctx: import('../types').StrapiRouteContext): Promise<void>;
+    };
+    "content-api": ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        getOccurrences(ctx: import('../types').StrapiRouteContext): Promise<void>;
+        downloadFeedIcs(ctx: import('../types').StrapiRouteContext): Promise<void>;
+        downloadEventIcs(ctx: import('../types').StrapiRouteContext): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi: _strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default _default;

package/dist/server/src/index.d.ts

@@ -0,0 +1,85 @@
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => Promise<void>;
+    destroy: ({ strapi: _strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => void;
+    config: {
+        default: import('../../shared/types').CalendarPluginSettings;
+        validator(config: Partial<import('../../shared/types').CalendarPluginSettings>): void;
+    };
+    controllers: {
+        admin: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getCalendar(ctx: import('./types').StrapiRouteContext): Promise<void>;
+            reschedule(ctx: import('./types').StrapiRouteContext): Promise<void>;
+            quickCreate(ctx: import('./types').StrapiRouteContext): Promise<void>;
+            getSettings(ctx: import('./types').StrapiRouteContext): Promise<void>;
+            updateSettings(ctx: import('./types').StrapiRouteContext<Partial<import('../../shared/types').CalendarPluginSettings>>): Promise<void>;
+            clearSettings(ctx: import('./types').StrapiRouteContext): Promise<void>;
+            getContentTypes(ctx: import('./types').StrapiRouteContext): Promise<void>;
+        };
+        "content-api": ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            getOccurrences(ctx: import('./types').StrapiRouteContext): Promise<void>;
+            downloadFeedIcs(ctx: import('./types').StrapiRouteContext): Promise<void>;
+            downloadEventIcs(ctx: import('./types').StrapiRouteContext): Promise<void>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: (string | {
+                        name: string;
+                        config: {
+                            actions: string[];
+                        };
+                    })[];
+                };
+            }[];
+        };
+        "content-api": {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {};
+            }[];
+        };
+    };
+    services: {
+        settings: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => import('./types').SettingsService;
+        registry: ({ strapi: _strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => {
+            registerSource(source: import('../../shared/types').CalendarSourceMapping): void;
+            unregisterSource(sourceId: string): void;
+            getRegisteredSources(): import('../../shared/types').CalendarSourceMapping[];
+            registerSecondaryCalendar(calendar: import('../../shared/types').CalendarSystemConfig): void;
+            getRegisteredSecondaryCalendars(): import('../../shared/types').CalendarSystemConfig[];
+            registerCalendarFormatter(calendarId: string, formatter: import('../../shared/types').CalendarSystemFormatterFn): void;
+            unregisterCalendarFormatter(calendarId: string): void;
+        };
+        occurrence: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => import('./types').OccurrenceService;
+        ical: ({ strapi }: {
+            strapi: import("@strapi/strapi").Core.Strapi;
+        }) => import('./types').IcalService;
+    };
+};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import { Core } from '@strapi/strapi';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default _default;

package/dist/server/src/routes/admin.d.ts

@@ -0,0 +1,17 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {
+            policies: (string | {
+                name: string;
+                config: {
+                    actions: string[];
+                };
+            })[];
+        };
+    }[];
+};
+export default _default;

package/dist/server/src/routes/content-api.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    type: string;
+    routes: {
+        method: string;
+        path: string;
+        handler: string;
+        config: {};
+    }[];
+};
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,28 @@
+declare const _default: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: (string | {
+                    name: string;
+                    config: {
+                        actions: string[];
+                    };
+                })[];
+            };
+        }[];
+    };
+    "content-api": {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {};
+        }[];
+    };
+};
+export default _default;

package/dist/server/src/services/builtinSources.d.ts

@@ -0,0 +1,3 @@
+import { CalendarSourceMapping } from '../../../shared/types';
+export declare const BUILTIN_EVENTS_SOURCE: CalendarSourceMapping;
+export declare const BUILTIN_BOOKINGS_SOURCE: CalendarSourceMapping;

package/dist/server/src/services/ical.d.ts

@@ -0,0 +1,6 @@
+import { Core } from '@strapi/strapi';
+import { IcalService } from '../types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => IcalService;
+export default _default;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,23 @@
+declare const _default: {
+    settings: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => import('../types').SettingsService;
+    registry: ({ strapi: _strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => {
+        registerSource(source: import('../../../shared/types').CalendarSourceMapping): void;
+        unregisterSource(sourceId: string): void;
+        getRegisteredSources(): import('../../../shared/types').CalendarSourceMapping[];
+        registerSecondaryCalendar(calendar: import('../../../shared/types').CalendarSystemConfig): void;
+        getRegisteredSecondaryCalendars(): import('../../../shared/types').CalendarSystemConfig[];
+        registerCalendarFormatter(calendarId: string, formatter: import('../../../shared/types').CalendarSystemFormatterFn): void;
+        unregisterCalendarFormatter(calendarId: string): void;
+    };
+    occurrence: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => import('../types').OccurrenceService;
+    ical: ({ strapi }: {
+        strapi: import("@strapi/strapi").Core.Strapi;
+    }) => import('../types').IcalService;
+};
+export default _default;

package/dist/server/src/services/occurrence.d.ts

@@ -0,0 +1,6 @@
+import { Core } from '@strapi/strapi';
+import { OccurrenceService } from '../types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => OccurrenceService;
+export default _default;

package/dist/server/src/services/occurrenceDates.d.ts

@@ -0,0 +1,7 @@
+import { CalendarItemStatus, CalendarSourceMapping } from '../../../shared/types';
+export declare function resolveStartEndFromDocument(doc: Record<string, unknown>, source: CalendarSourceMapping): {
+    startDate: string;
+    endDate: string | null;
+    allDay: boolean;
+} | null;
+export declare function mapStatus(rawStatus: unknown): CalendarItemStatus;

package/dist/server/src/services/quickCreateHelpers.d.ts

@@ -0,0 +1,20 @@
+import { CalendarSourceMapping, RRuleFieldValue } from '../../../shared/types';
+import { QuickCreateEntryParams, RescheduleOccurrenceParams } from '../types';
+export interface ContentTypeSchemaShape {
+    options?: {
+        draftAndPublish?: boolean;
+    };
+    attributes?: Record<string, {
+        type?: string;
+        required?: boolean;
+    }>;
+}
+export declare function matchesSourceFilter(source: CalendarSourceMapping, filter?: string): boolean;
+export declare function resolveTargetSource(sources: CalendarSourceMapping[], sourceId?: string): CalendarSourceMapping | undefined;
+export declare function isBookingCollectionSource(source: CalendarSourceMapping, schema?: ContentTypeSchemaShape): boolean;
+export declare function buildQuickCreatePayload(params: QuickCreateEntryParams, source: CalendarSourceMapping, defaultTimezone: string, schema?: ContentTypeSchemaShape): {
+    data: Record<string, unknown>;
+    shouldPublish: boolean;
+};
+export declare function buildDirectUpdatePayload(params: RescheduleOccurrenceParams, source: CalendarSourceMapping, existingDoc?: Record<string, unknown>): Record<string, unknown>;
+export declare function buildRecurrenceOverridePayload(recurrence: RRuleFieldValue, rruleField: string, params: RescheduleOccurrenceParams): Record<string, unknown>;

package/dist/server/src/services/registry.d.ts

@@ -0,0 +1,19 @@
+import { Core } from '@strapi/strapi';
+import { CalendarSourceMapping, CalendarSystemConfig, CalendarSystemFormatterFn } from '../../../shared/types';
+/**
+ * Runtime registry allowing companion plugins (e.g. `@vicacha-devs/strapi-plugin-events`
+ * or `@vicacha-devs/strapi-plugin-bookings`) or host applications to programmatically
+ * register collection sources and secondary calendar systems.
+ */
+declare const _default: ({ strapi: _strapi }: {
+    strapi: Core.Strapi;
+}) => {
+    registerSource(source: CalendarSourceMapping): void;
+    unregisterSource(sourceId: string): void;
+    getRegisteredSources(): CalendarSourceMapping[];
+    registerSecondaryCalendar(calendar: CalendarSystemConfig): void;
+    getRegisteredSecondaryCalendars(): CalendarSystemConfig[];
+    registerCalendarFormatter(calendarId: string, formatter: CalendarSystemFormatterFn): void;
+    unregisterCalendarFormatter(calendarId: string): void;
+};
+export default _default;

package/dist/server/src/services/settings.d.ts

@@ -0,0 +1,6 @@
+import { Core } from '@strapi/strapi';
+import { SettingsService } from '../types';
+declare const _default: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => SettingsService;
+export default _default;

package/dist/server/src/types.d.ts

@@ -0,0 +1,98 @@
+import { Core } from '@strapi/strapi';
+import { CalendarPluginSettings, CalendarSourceMapping, CalendarSystemConfig, CalendarSystemFormatterFn, DiscoveredContentType, ExpandedCalendarOccurrence } from '../../shared/types';
+export interface StrapiRouteContext<TBody = Record<string, unknown>, TQuery = Record<string, string | undefined>, TParams = Record<string, string | undefined>> {
+    query?: TQuery;
+    params?: TParams;
+    request?: {
+        body?: TBody;
+    };
+    status?: number;
+    body?: unknown;
+    set?: (header: string, value: string) => void;
+}
+export interface RegistryService {
+    registerSource(source: CalendarSourceMapping): void;
+    unregisterSource(sourceId: string): void;
+    getRegisteredSources(): CalendarSourceMapping[];
+    registerSecondaryCalendar(calendar: CalendarSystemConfig): void;
+    getRegisteredSecondaryCalendars(): CalendarSystemConfig[];
+    registerCalendarFormatter(calendarId: string, formatter: CalendarSystemFormatterFn): void;
+    unregisterCalendarFormatter(calendarId: string): void;
+}
+export interface SettingsService {
+    ensureInitialized(): Promise<CalendarPluginSettings>;
+    getSettings(): Promise<CalendarPluginSettings>;
+    updateSettings(patch: Partial<CalendarPluginSettings>): Promise<CalendarPluginSettings>;
+    clearSettings(): Promise<CalendarPluginSettings>;
+    discoverContentTypes(): DiscoveredContentType[];
+}
+export interface OccurrenceQueryParams {
+    from?: string;
+    to?: string;
+    locale?: string;
+    category?: string;
+    sourceId?: string;
+    documentId?: string;
+    includeDrafts?: boolean;
+    publicOnly?: boolean;
+}
+export interface RescheduleOccurrenceParams {
+    sourceId?: string;
+    uid?: string;
+    documentId: string;
+    locale?: string;
+    occurrenceDate: string;
+    newStartDate: string;
+    newEndDate?: string;
+    applyToSeries?: boolean;
+    cancelOccurrence?: boolean;
+}
+export interface QuickCreateEntryParams {
+    sourceId?: string;
+    title: string;
+    startDate: string;
+    endDate?: string;
+    location?: string;
+    category?: string;
+    summary?: string;
+    rrule?: string;
+    customerName?: string;
+    customerEmail?: string;
+    customerPhone?: string;
+    partySize?: number;
+    bookingStatus?: "confirmed" | "pending";
+}
+export interface OccurrenceService {
+    registerCalendarFormatter(calendarId: string, formatter: CalendarSystemFormatterFn): void;
+    unregisterCalendarFormatter(calendarId: string): void;
+    formatDateInCalendarSystem(isoOrDateKey: string, system: CalendarSystemConfig, locale?: string, options?: {
+        compact?: boolean;
+    }): string;
+    getOccurrences(params: OccurrenceQueryParams): Promise<ExpandedCalendarOccurrence[]>;
+    rescheduleOccurrence(params: RescheduleOccurrenceParams): Promise<Record<string, unknown>>;
+    quickCreateEntry(params: QuickCreateEntryParams): Promise<Record<string, unknown>>;
+}
+export interface IcalService {
+    buildFeedIcs(params: {
+        from?: string;
+        to?: string;
+        locale?: string;
+        category?: string;
+        sourceId?: string;
+        publicOnly?: boolean;
+    }): Promise<string>;
+    buildSingleInviteIcs(params: {
+        documentId: string;
+        occurrenceDate?: string;
+        locale?: string;
+        publicOnly?: boolean;
+    }): Promise<string>;
+}
+export interface CalendarPluginServiceMap {
+    registry: RegistryService;
+    settings: SettingsService;
+    occurrence: OccurrenceService;
+    ical: IcalService;
+}
+export declare function getCalendarService<K extends keyof CalendarPluginServiceMap>(strapi: Core.Strapi, pluginId: string, serviceName: K): CalendarPluginServiceMap[K];
+export declare function formatErrorMessage(err: unknown, fallback: string): string;

package/dist/shared/calendarSystems.d.ts

@@ -0,0 +1,41 @@
+import { AlternateDateValue, CalendarSourceMapping, CalendarSystemConfig, CalendarSystemFormatterFn } from './types';
+/**
+ * Standard Unicode CLDR / @internationalized/date calendar identifiers.
+ * Covers global solar, lunar, and lunisolar calendar systems.
+ */
+export declare const SUPPORTED_INTL_CALENDARS: ReadonlyArray<{
+    id: string;
+    intlCalendar: string;
+    defaultLabel: string;
+}>;
+export declare function registerCalendarSystemFormatter(calendarId: string, formatter: CalendarSystemFormatterFn): void;
+export declare function unregisterCalendarSystemFormatter(calendarId: string): void;
+export declare function getRegisteredCalendarFormatters(): ReadonlyMap<string, CalendarSystemFormatterFn>;
+export declare function applyDayOffset(date: Date, dayOffset?: number): Date;
+/**
+ * Extracts numeric { year, month, day } parts for any Date in any Unicode CLDR calendar
+ * (e.g. "islamic-umalqura", "hebrew", "persian", "gregory").
+ */
+export declare function extractCalendarParts(date: Date, intlCalendar: string, dayOffset?: number): {
+    year: number;
+    month: number;
+    day: number;
+} | null;
+/**
+ * Formats an ISO date or YYYY-MM-DD string into a target CalendarSystemConfig.
+ */
+export declare function formatDateInCalendarSystem(isoOrDateKey: string, system: CalendarSystemConfig, locale?: string, options?: {
+    compact?: boolean;
+}): string;
+/**
+ * Computes all alternate calendar representations for a calendar occurrence.
+ */
+export declare function resolveOccurrenceAlternateDates(params: {
+    occurrenceDate: string;
+    baseDateKey: string;
+    isRecurring: boolean;
+    doc: Record<string, unknown>;
+    source: CalendarSourceMapping;
+    secondaryCalendars?: CalendarSystemConfig[];
+    locale?: string;
+}): Record<string, AlternateDateValue>;

package/dist/shared/icalGenerator.d.ts

@@ -0,0 +1,18 @@
+import { CalendarLinkSet, ExpandedCalendarOccurrence } from './types';
+export declare function foldIcsLine(line: string): string;
+export declare function toIcsTimestamp(iso: string, allDay?: boolean): string;
+export declare function buildCalendarLinks(params: {
+    documentId: string;
+    title: string;
+    startDate: string;
+    endDate: string;
+    allDay?: boolean;
+    summary?: string;
+    location?: string;
+    occurrenceDate?: string;
+}): CalendarLinkSet;
+export declare function generateIcsCalendar(params: {
+    calendarTitle: string;
+    timezone: string;
+    occurrences: ExpandedCalendarOccurrence[];
+}): string;