@sneat/extensions-schedulus-shared 0.3.0

package/lib/services/calendar-data-provider.d.ts

@@ -0,0 +1,33 @@
+import { Signal, Injector } from '@angular/core';
+import { CalendariumSpaceService } from '../services/calendarium-space.service';
+import { CalendarHappeningBriefsBySpaceID } from '@sneat/mod-schedulus-core';
+import { IErrorLogger } from '@sneat/core';
+import { Observable } from 'rxjs';
+import { CalendarDay } from './calendar-day';
+import { RecurringsByWeekday } from './calendar-types';
+import { HappeningService } from './happening.service';
+import { CalendarDayService } from './calendar-day.service';
+export declare class CalendarDataProvider {
+    private readonly injector;
+    private readonly $primarySpaceID;
+    private readonly errorLogger;
+    private readonly happeningService;
+    private readonly calendarDayService;
+    private readonly calendariumSpaceService;
+    private readonly destroyed;
+    private readonly $space;
+    private readonly days;
+    constructor(injector: Injector, $primarySpaceID: Signal<string | undefined>, errorLogger: IErrorLogger, happeningService: HappeningService, calendarDayService: CalendarDayService, calendariumSpaceService: CalendariumSpaceService);
+    private primarySpace?;
+    private $primarySpace;
+    private $spaces;
+    readonly $recurringByWd: Signal<Readonly<RecurringsByWeekday>>;
+    readonly $recurringsBySpaceID: Signal<Readonly<CalendarHappeningBriefsBySpaceID>>;
+    destroy(): void;
+    private readonly $inputs;
+    getCalendarDay(date: Date): CalendarDay;
+    preloadEvents(...dates: Date[]): Observable<CalendarDay>;
+    getDays(): Observable<CalendarDay>;
+    loadForWeek(): void;
+    private loadEvents;
+}

package/lib/services/calendar-day.d.ts

@@ -0,0 +1,45 @@
+import { Signal } from '@angular/core';
+import { IErrorLogger } from '@sneat/core';
+import { ISpaceContext } from '@sneat/space-models';
+import { Observable } from 'rxjs';
+import { ISlotUIContext, RecurringSlots, WeekdayCode2 } from '@sneat/mod-schedulus-core';
+import { HappeningService } from './happening.service';
+import { CalendarDayService } from './calendar-day.service';
+import { Injector } from '@angular/core';
+export interface ICalendarDayInput {
+    readonly spaceID: string;
+    readonly $recurringSlots: Signal<RecurringSlots | undefined>;
+    readonly recurringSlots$: Observable<RecurringSlots>;
+}
+export declare class CalendarDay {
+    readonly date: Date;
+    private readonly $inputs;
+    private readonly errorLogger;
+    private readonly happeningService;
+    private readonly calendarDayService;
+    private readonly destroyed$;
+    private $recurringSlots;
+    private singles?;
+    private _spaces;
+    get spaces(): readonly ISpaceContext[];
+    readonly dateID: string;
+    readonly wd: WeekdayCode2;
+    readonly wdLongTitle: string;
+    private readonly _isLoading;
+    readonly $isLoading: Signal<boolean>;
+    private readonly _slots;
+    readonly slots$: Observable<ISlotUIContext[] | undefined>;
+    private calendarDayDbo?;
+    get slots(): ISlotUIContext[] | undefined;
+    private readonly subscriptions;
+    private effectRef?;
+    constructor(date: Date, injector: Injector, $inputs: Signal<readonly ICalendarDayInput[]>, errorLogger: IErrorLogger, happeningService: HappeningService, calendarDayService: CalendarDayService);
+    destroy(): void;
+    private readonly processSpaceID;
+    private readonly subscribeForCalendarDay;
+    private readonly subscribeForSingles;
+    private readonly processSingles;
+    private subscribeForRecurrings;
+    private readonly processRecurrings;
+    private joinRecurringsWithSinglesAndEmit;
+}

package/lib/services/calendar-day.service.d.ts

@@ -0,0 +1,18 @@
+import { Firestore as AngularFirestore } from '@angular/fire/firestore';
+import { ICalendarDayBrief } from '@sneat/mod-schedulus-core';
+import { ISpaceContext } from '@sneat/space-models';
+import * as i0 from "@angular/core";
+export declare class CalendarDayService {
+    private readonly errorLogger;
+    readonly afs: AngularFirestore;
+    private readonly spaceItemService;
+    constructor();
+    watchSpaceDay(space: ISpaceContext, dateID: string): import("rxjs").Observable<import("@sneat/space-models").ISpaceItemNavContext<ICalendarDayBrief, ICalendarDayBrief>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarDayService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarDayService>;
+}
+export declare class CalendarDayServiceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarDayServiceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CalendarDayServiceModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CalendarDayServiceModule>;
+}

package/lib/services/calendar-nav.service.d.ts

@@ -0,0 +1,14 @@
+import { ISlotUIEvent } from '@sneat/mod-schedulus-core';
+import * as i0 from "@angular/core";
+export declare class CalendarNavService {
+    private readonly errorLogger;
+    private readonly spaceNavService;
+    navigateToHappeningPage(args: ISlotUIEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarNavService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendarNavService>;
+}
+export declare class CalendarNavServicesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendarNavServicesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CalendarNavServicesModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CalendarNavServicesModule>;
+}

package/lib/services/calendar-space.d.ts

@@ -0,0 +1,23 @@
+import { CalendariumSpaceService } from '../services/calendarium-space.service';
+import { ICalendariumSpaceDbo, RecurringSlots } from '@sneat/mod-schedulus-core';
+import { ISpaceItemWithOptionalDbo } from '@sneat/space-models';
+import { Observable } from 'rxjs';
+import { ISpaceRecurrings, RecurringsByWeekday } from './calendar-types';
+export declare class CalendarSpace {
+    readonly spaceID: string;
+    private readonly calendariumSpaceService;
+    private readonly contactID?;
+    private readonly destroyed;
+    destroy(): void;
+    readonly $recurrings: import("@angular/core").WritableSignal<ISpaceRecurrings | undefined>;
+    readonly $recurringByWd: import("@angular/core").WritableSignal<Readonly<RecurringsByWeekday>>;
+    private readonly $calendariumSpace;
+    readonly $recurringSlots: import("@angular/core").WritableSignal<RecurringSlots | undefined>;
+    private readonly calendariumSpace$;
+    readonly recurringSlots$: Observable<RecurringSlots>;
+    constructor(spaceID: string, calendariumSpaceService: CalendariumSpaceService, contactID?: string | undefined);
+    setCalendariumSpace(calendariumSpace: ISpaceItemWithOptionalDbo<ICalendariumSpaceDbo>): void;
+    private processRecurringBriefs;
+    private processRecurring;
+    private addRecurringsToSlotsGroup;
+}

package/lib/services/calendar-types.d.ts

@@ -0,0 +1,10 @@
+import { ICalendariumSpaceContext, ISlotUIContext, RecurringSlots, WeekdayCode2, IHappeningBrief } from '@sneat/mod-schedulus-core';
+export type ISpaceRecurrings = {
+    readonly spaceID: string;
+    readonly recurringHappenings: Readonly<Record<string, IHappeningBrief>>;
+};
+export type RecurringsByWeekday = {
+    [wd in WeekdayCode2]: ISlotUIContext[];
+};
+export declare const emptyRecurringsByWeekday: () => RecurringsByWeekday;
+export declare const groupRecurringSlotsByWeekday: (calendariumSpace?: ICalendariumSpaceContext) => RecurringSlots;

package/lib/services/calendarium-services.module.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class CalendariumServicesModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendariumServicesModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CalendariumServicesModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CalendariumServicesModule>;
+}

package/lib/services/calendarium-space.service.d.ts

@@ -0,0 +1,8 @@
+import { ICalendariumSpaceDbo } from '@sneat/mod-schedulus-core';
+import { SpaceModuleService } from '@sneat/space-services';
+import * as i0 from "@angular/core";
+export declare class CalendariumSpaceService extends SpaceModuleService<ICalendariumSpaceDbo> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<CalendariumSpaceService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CalendariumSpaceService>;
+}

package/lib/services/happening.service.d.ts

@@ -0,0 +1,99 @@
+import { IFilter } from '@sneat/api';
+import { HappeningStatus, IHappeningDbo, WeekdayCode2, IHappeningContext, IHappeningPrice, IHappeningSlotWithID } from '@sneat/mod-schedulus-core';
+import { ISpaceContext, ISpaceRequest } from '@sneat/space-models';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface ICreateHappeningRequest {
+    readonly spaceID: string;
+    readonly happening: IHappeningDbo;
+}
+export interface IHappeningRequest extends ISpaceRequest {
+    readonly happeningID: string;
+    readonly happeningType?: string;
+}
+export interface IUpdateHappeningTextsRequest extends IHappeningRequest {
+    readonly title: string;
+    readonly summary?: string;
+    readonly description?: string;
+}
+export interface ISpaceModuleDocShortRef {
+    readonly id: string;
+    readonly spaceID?: string;
+}
+export interface IHappeningContactRequest extends ISpaceRequest {
+    readonly happeningID: string;
+    readonly contact: ISpaceModuleDocShortRef;
+}
+export interface IHappeningContactsRequest extends ISpaceRequest {
+    readonly happeningID: string;
+    readonly contacts: readonly ISpaceModuleDocShortRef[];
+}
+export interface IHappeningSlotRequest extends IHappeningRequest {
+    readonly slot: IHappeningSlotWithID;
+}
+export interface IHappeningPricesRequest extends IHappeningRequest {
+    readonly prices: readonly IHappeningPrice[];
+}
+export interface IDeleteHappeningPricesRequest extends IHappeningRequest {
+    readonly priceIDs: readonly string[];
+}
+export interface IHappeningSlotDateRequest extends IHappeningSlotRequest {
+    readonly date?: string;
+}
+export interface IHappeningDateSlotIDRequest extends IHappeningRequest {
+    readonly slotID: string;
+    readonly date: string;
+}
+export interface ISlotsRefRequest extends IHappeningRequest {
+    readonly slotIDs?: readonly string[];
+    readonly date?: string;
+}
+export interface ISlotRefRequest extends IHappeningRequest {
+    readonly slotID: string;
+}
+export interface ISlotRequest extends IHappeningRequest {
+    readonly date?: string;
+    readonly slotID?: string;
+    readonly weekday?: WeekdayCode2;
+    readonly reason?: string;
+}
+export interface IDeleteSlotRequest extends ISlotRefRequest {
+    readonly reason?: string;
+}
+export type ICancelHappeningRequest = ISlotRequest;
+export declare class HappeningService {
+    private readonly errorLogger;
+    private readonly sneatApiService;
+    private readonly spaceItemService;
+    static statusFilter(statuses: HappeningStatus[]): IFilter;
+    constructor();
+    createHappening(request: ICreateHappeningRequest): Observable<unknown>;
+    cancelHappening(request: ICancelHappeningRequest): Observable<void>;
+    revokeHappeningCancellation(request: ICancelHappeningRequest): Observable<void>;
+    deleteHappening(happening: IHappeningContext): Observable<void>;
+    deleteSlot(request: IDeleteSlotRequest): Observable<void>;
+    updateHappeningTexts(request: IUpdateHappeningTextsRequest): Observable<void>;
+    readonly removeParticipant: (request: IHappeningContactRequest) => Observable<void>;
+    readonly removeParticipants: (request: IHappeningContactsRequest) => Observable<void>;
+    readonly addParticipant: (request: IHappeningContactRequest) => Observable<void>;
+    readonly addParticipants: (request: IHappeningContactsRequest) => Observable<void>;
+    readonly addSlot: (spaceID: string, happeningID: string, slot: IHappeningSlotWithID) => Observable<void>;
+    readonly updateSlot: (spaceID: string, happeningID: string, slot: IHappeningSlotWithID) => Observable<void>;
+    deleteHappeningPrices(request: IDeleteHappeningPricesRequest): Observable<void>;
+    setHappeningPrices(request: IHappeningPricesRequest): Observable<void>;
+    adjustSlot(spaceID: string, happeningID: string, slot: IHappeningSlotWithID, date: string): Observable<void>;
+    cancelAdjustment(spaceID: string, happeningID: string, slotID: string, date: string): Observable<void>;
+    watchHappeningByID(space: ISpaceContext, id: string): Observable<IHappeningContext>;
+    watchUpcomingSingles(space: ISpaceContext, statuses?: HappeningStatus[]): Observable<IHappeningContext[]>;
+    watchPastSingles(space: ISpaceContext, statuses?: HappeningStatus[]): Observable<IHappeningContext[]>;
+    watchRecentlyCreatedSingles(space: ISpaceContext, statuses?: HappeningStatus[]): Observable<IHappeningContext[]>;
+    private watchSingles;
+    watchSinglesOnSpecificDay(space: ISpaceContext, date: string, status?: HappeningStatus): Observable<IHappeningContext[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HappeningService>;
+}
+export declare class HappeningServiceModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HappeningServiceModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HappeningServiceModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HappeningServiceModule>;
+}

package/lib/services/index.d.ts

@@ -0,0 +1,5 @@
+export * from './calendarium-services.module';
+export * from './calendarium-space.service';
+export * from './happening.service';
+export * from './calendar-day.service';
+export * from './calendar-nav.service';

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@sneat/extensions-schedulus-shared",
+  "version": "0.3.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": ">=21.0.0",
+    "@angular/core": ">=21.0.0"
+  },
+  "dependencies": {
+    "tslib": "2.8.1"
+  },
+  "module": "esm2022/sneat-extensions-schedulus-shared.js",
+  "typings": "sneat-extensions-schedulus-shared.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./sneat-extensions-schedulus-shared.d.ts",
+      "default": "./esm2022/sneat-extensions-schedulus-shared.js"
+    }
+  },
+  "sideEffects": false
+}

package/sneat-extensions-schedulus-shared.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@sneat/extensions-schedulus-shared" />
+export * from './index';