@zealicsolutions/web-ui 1.0.133 → 1.0.135

package/dist/cjs/organisms/Calendar/config/toolDescriptor/resourceBindings.d.ts

@@ -0,0 +1,29 @@
+export declare const resourceBindingsGroup: {
+    readonly id: "resourceBindings";
+    readonly tool: "calendarDataRetrieval";
+    readonly titleKey: "config.calendar.group.resourceBindings";
+    readonly collapsible: true;
+    readonly initiallyExpanded: false;
+    readonly pathBase: "dataRetrievalConfig.bindings.resource";
+    readonly toolConfig: {
+        readonly targets: readonly [{
+            readonly captureName: "id";
+            readonly labelKey: "config.calendar.bindings.resource.id";
+        }, {
+            readonly captureName: "name";
+            readonly labelKey: "config.calendar.bindings.resource.name";
+        }, {
+            readonly captureName: "accentClass";
+            readonly labelKey: "config.calendar.bindings.resource.accentClass";
+        }, {
+            readonly captureName: "color";
+            readonly labelKey: "config.calendar.bindings.resource.color";
+        }, {
+            readonly captureName: "meta[$index].token";
+            readonly labelKey: "config.calendar.bindings.resource.meta.token";
+        }, {
+            readonly captureName: "meta[$index].dataFieldId";
+            readonly labelKey: "config.calendar.bindings.resource.meta.fieldId";
+        }];
+    };
+};

package/dist/cjs/organisms/Calendar/index.d.ts

@@ -0,0 +1,3 @@
+export { CalendarOrganism } from './CalendarOrganism';
+export * from './types';
+export * from './queries';

package/dist/cjs/organisms/Calendar/queries/index.d.ts

@@ -0,0 +1,5 @@
+export { useCalendarData as useCalendarEvents } from './useCalendarData';
+export { useCreateCalendarEvent } from './useCreateCalendarEvent';
+export { useDeleteCalendarEvent } from './useDeleteCalendarEvent';
+export { useUpdateCalendarEvent } from './useUpdateCalendarEvent';
+export type * from './types';

package/dist/cjs/organisms/Calendar/queries/types.d.ts

@@ -0,0 +1,44 @@
+export interface CalendarEventType {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    resourceId?: string;
+    resourceName?: string;
+}
+export interface CalendarResource {
+    id: string;
+    name: string;
+    accentClass?: string;
+    meta?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface CalendarOverlay {
+    id: string;
+    type: string;
+    data: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export interface CalendarData {
+    events: CalendarEventType[];
+    resources: CalendarResource[];
+    overlays: CalendarOverlay[];
+}
+export interface UseCalendarEventsParams {
+    organismId: string;
+    start?: Date;
+    end?: Date;
+    rwoRecordId?: string;
+}
+export interface UseCalendarEventsReturn {
+    events: CalendarEventType[];
+    resources: CalendarResource[];
+    overlays: CalendarOverlay[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => void;
+    refreshSignal: number;
+}
+export { CreateCalendarEventParams } from './useCreateCalendarEvent';
+export { DeleteCalendarEventParams } from './useDeleteCalendarEvent';
+export { UpdateCalendarEventParams } from './useUpdateCalendarEvent';

package/dist/cjs/organisms/Calendar/queries/useCalendarData.d.ts

@@ -0,0 +1,11 @@
+import type { UseCalendarEventsParams, UseCalendarEventsReturn } from './types';
+/**
+ * Hook for fetching calendar events, resources, and overlays for a specific organism.
+ * Follows the same pattern as useCalendarData but includes data fetching.
+ *
+ * @param organismId - The ID of the calendar organism
+ * @param start - Optional start date for filtering events
+ * @param end - Optional end date for filtering events
+ * @returns Calendar data with events, resources, overlays and loading state
+ */
+export declare const useCalendarData: ({ organismId, start, end, rwoRecordId: providedRwoRecordId, }: UseCalendarEventsParams) => UseCalendarEventsReturn;

package/dist/cjs/organisms/Calendar/queries/useCreateCalendarEvent.d.ts

@@ -0,0 +1,33 @@
+export interface CalendarEventType {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    resourceId?: string;
+    resourceName?: string;
+}
+export interface MutationCallbacks<TData = unknown> {
+    onSuccess?: (data: TData, variables: unknown) => void;
+    onError?: (error: Error, variables: unknown) => void;
+}
+export interface UseCreateCalendarEventParams {
+    onSuccess?: (data: CalendarEventType, variables: CreateCalendarEventParams) => void;
+    onError?: (error: Error, variables: CreateCalendarEventParams) => void;
+}
+export interface CreateCalendarEventParams {
+    event: Omit<CalendarEventType, 'id'>;
+}
+/**
+ * Hook for creating new calendar events.
+ *
+ * @param options - Configuration object with optional callbacks
+ * @returns { create, isLoading, isError, error, isSuccess, data }
+ */
+export declare const useCreateCalendarEvent: (options?: UseCreateCalendarEventParams) => {
+    create: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<void | import("contexts").CalendarEventType, Error, CreateCalendarEventParams, unknown>;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    data: void | import("contexts").CalendarEventType | undefined;
+};

package/dist/cjs/organisms/Calendar/queries/useDeleteCalendarEvent.d.ts

@@ -0,0 +1,27 @@
+export interface UseDeleteCalendarEventParams {
+    onSuccess?: (data: {
+        eventId: string;
+    }, variables: DeleteCalendarEventParams) => void;
+    onError?: (error: Error, variables: DeleteCalendarEventParams) => void;
+}
+export interface DeleteCalendarEventParams {
+    eventId: string;
+}
+/**
+ * Hook for deleting calendar events.
+ *
+ * @param options - Configuration object with optional callbacks
+ * @returns { delete, isLoading, isError, error, isSuccess, data }
+ */
+export declare const useDeleteCalendarEvent: (options?: UseDeleteCalendarEventParams) => {
+    delete: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<{
+        eventId: string;
+    }, Error, DeleteCalendarEventParams, unknown>;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    data: {
+        eventId: string;
+    } | undefined;
+};

package/dist/cjs/organisms/Calendar/queries/useUpdateCalendarEvent.d.ts

@@ -0,0 +1,29 @@
+export interface CalendarEventType {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    resourceId?: string;
+    resourceName?: string;
+}
+export interface UseUpdateCalendarEventParams {
+    onSuccess?: (data: CalendarEventType, variables: UpdateCalendarEventParams) => void;
+    onError?: (error: Error, variables: UpdateCalendarEventParams) => void;
+}
+export interface UpdateCalendarEventParams {
+    event: CalendarEventType;
+}
+/**
+ * Hook for updating existing calendar events.
+ *
+ * @param options - Configuration object with optional callbacks
+ * @returns { update, isLoading, isError, error, isSuccess, data }
+ */
+export declare const useUpdateCalendarEvent: (options?: UseUpdateCalendarEventParams) => {
+    update: import("@tanstack/react-query/build/legacy/types").UseMutateAsyncFunction<void | import("contexts").CalendarEventType, Error, UpdateCalendarEventParams, unknown>;
+    isLoading: boolean;
+    isError: boolean;
+    error: Error | null;
+    isSuccess: boolean;
+    data: void | import("contexts").CalendarEventType | undefined;
+};

package/dist/cjs/organisms/Calendar/types.d.ts

@@ -0,0 +1,148 @@
+import type { OrganismDTO } from '../types';
+export interface CalendarOrganismEventType {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    status?: string;
+    eventType?: string;
+    resourceId?: string;
+    resourceName?: string;
+    associatedEntityType?: any;
+    associatedEntityId?: string;
+}
+export interface CalendarEventType {
+    id: string;
+    title: string;
+    start: Date;
+    end: Date;
+    resourceId?: string;
+    resourceName?: string;
+    meta?: Record<string, any>;
+}
+export type ColorToken = 'blue' | 'green' | 'yellow' | 'purple' | 'red';
+export type StatusToken = 'tentative' | 'confirmed' | 'completed' | 'cancelled';
+export type DesignerOverlayIndicatorConfig = {
+    maxPerCell?: number;
+    icons?: Record<string, {
+        iconName?: string;
+        className?: string;
+        priority?: number;
+        showCountBadge?: boolean;
+    }>;
+    statusClasses?: {
+        ok?: string;
+        info?: string;
+        warning?: string;
+        danger?: string;
+    };
+    showLegend?: boolean;
+};
+export type CalendarOrganismConfiguration = {
+    display: {
+        defaultView: 'day' | 'week' | 'month' | 'year';
+        use24HourFormatByDefault?: boolean;
+        colorMap: Array<{
+            status: StatusToken;
+            color: ColorToken;
+        }>;
+        overlayIndicators?: DesignerOverlayIndicatorConfig;
+    };
+};
+export type CalendarQuery = {
+    rangeStart: string;
+    rangeEnd: string;
+    timezone?: string;
+    filters?: Record<string, unknown>;
+};
+export type CalendarPage = {
+    events: CalendarEventType[];
+    resources?: Array<Record<string, unknown>>;
+    overlays?: Array<Record<string, unknown>>;
+};
+export type FieldMappingValue = string | {
+    template: string;
+    tokens: Record<string, string>;
+} | {
+    const: any;
+};
+export interface EventBindings {
+    id?: FieldMappingValue;
+    title?: FieldMappingValue;
+    startDate?: FieldMappingValue;
+    endDate?: FieldMappingValue;
+    startTime?: FieldMappingValue;
+    endTime?: FieldMappingValue;
+    description?: FieldMappingValue;
+    color?: FieldMappingValue;
+    isRepeating?: FieldMappingValue;
+    isRepeatingInterval?: FieldMappingValue;
+    isRepeatingExcludedDates?: FieldMappingValue;
+    status?: FieldMappingValue;
+    eventType?: FieldMappingValue;
+    resourceId?: FieldMappingValue;
+    resourceName?: FieldMappingValue;
+    associatedEntityType?: FieldMappingValue;
+    associatedEntityId?: FieldMappingValue;
+    meta?: Record<string, FieldMappingValue>;
+}
+export interface ResourceBindings {
+    id?: FieldMappingValue;
+    name?: FieldMappingValue;
+    accentClass?: FieldMappingValue;
+    color?: FieldMappingValue;
+    meta?: Record<string, FieldMappingValue>;
+}
+export interface Bindings {
+    event?: EventBindings;
+    resource?: ResourceBindings;
+}
+export interface ModalField {
+    id: string;
+    label: string;
+    type: 'text' | 'datetime' | 'select' | 'textarea' | 'number';
+    required?: boolean;
+    dataFieldId?: string;
+    remoteOptions?: {
+        queryKey: string;
+        valueField: string;
+        labelField: string;
+    };
+    options?: Array<{
+        value: any;
+        label: string;
+    }>;
+    placeholder?: string;
+    validation?: Record<string, any>;
+}
+export interface ModalConfig {
+    i18n: {
+        title: string;
+        submitLabel: string;
+        cancelLabel?: string;
+    };
+    fields: ModalField[];
+    layout: {
+        columns: number;
+        order: string[];
+    };
+}
+export interface FormConfig {
+    modal: ModalConfig;
+}
+export interface DataRetrievalConfig {
+    bindings: Bindings;
+    form: FormConfig;
+    loadEvents?: (organismId: string, query: CalendarQuery) => Promise<CalendarPage>;
+    onEventCreate?: (event: Omit<CalendarEventType, 'id'>) => Promise<any>;
+    onEventUpdate?: (event: CalendarEventType) => Promise<any>;
+    onEventDelete?: (eventId: string) => Promise<void>;
+}
+export interface CalendarOrganismProps {
+    organism: OrganismDTO & {
+        config: {
+            dataRetrievalConfig: DataRetrievalConfig;
+            display?: CalendarOrganismConfiguration['display'];
+        };
+    };
+}

package/dist/cjs/organisms/Calendar/useCalendarOrganism.d.ts

@@ -0,0 +1,66 @@
+import type { CalendarOrganismProps } from './types';
+export declare const useCalendarOrganism: (props: CalendarOrganismProps) => {
+    events: {
+        title: string;
+        color: string;
+        startDate: Date;
+        endDate: Date;
+        startTime: string;
+        endTime: string;
+        isRepeating: boolean;
+        id?: string | undefined;
+        visibility?: "public" | "private" | undefined;
+        description?: string | undefined;
+        isRepeatingInterval?: "daily" | "weekly" | "monthly" | undefined;
+        isRepeatingExcludedDates?: Date[] | undefined;
+        resourceId?: string | undefined;
+        eventType?: string | undefined;
+    }[];
+    resources: import("./queries").CalendarResource[] | {
+        id: string;
+        name: string;
+        accentClass: any;
+        color: any;
+        meta: any;
+    }[];
+    overlays: import("./queries").CalendarOverlay[];
+    isLoading: boolean;
+    error: Error | null;
+    refreshSignal: number;
+    calendarConfig: EventCalendarConfigType;
+    onEventAdd: (newEvent: Omit<{
+        title: string;
+        color: string;
+        startDate: Date;
+        endDate: Date;
+        startTime: string;
+        endTime: string;
+        isRepeating: boolean;
+        id?: string | undefined;
+        visibility?: "public" | "private" | undefined;
+        description?: string | undefined;
+        isRepeatingInterval?: "daily" | "weekly" | "monthly" | undefined;
+        isRepeatingExcludedDates?: Date[] | undefined;
+        resourceId?: string | undefined;
+        eventType?: string | undefined;
+    }, "id">, isUndo?: boolean | undefined) => Promise<void>;
+    onEventUpdate: (event: {
+        title: string;
+        color: string;
+        startDate: Date;
+        endDate: Date;
+        startTime: string;
+        endTime: string;
+        isRepeating: boolean;
+        id?: string | undefined;
+        visibility?: "public" | "private" | undefined;
+        description?: string | undefined;
+        isRepeatingInterval?: "daily" | "weekly" | "monthly" | undefined;
+        isRepeatingExcludedDates?: Date[] | undefined;
+        resourceId?: string | undefined;
+        eventType?: string | undefined;
+    }, isUndo?: boolean | undefined) => Promise<void>;
+    onEventDelete: (eventId: string, isUndo?: boolean | undefined) => Promise<void>;
+    onDateRangeChange: (startDate: Date, endDate: Date) => Promise<void>;
+    refetch: () => void;
+};

package/dist/cjs/organisms/Calendar/utils/statusColorMapping.d.ts

@@ -0,0 +1,7 @@
+import type { ColorToken, StatusToken } from '../types';
+export type StatusColorMap = Array<{
+    status: StatusToken;
+    color: ColorToken;
+}>;
+export declare const mapStatusToColor: (status: StatusToken, map: StatusColorMap, fallback?: ColorToken) => ColorToken;
+export declare const normalizeEvents: (raw: any[], map: StatusColorMap) => any[];

package/dist/cjs/organisms/Calendar/utils/toPackageOverlayConfig.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import type { DesignerOverlayIndicatorConfig } from '../types';
+export type OverlayIconEntry = {
+    className?: string;
+    priority?: number;
+    showCountBadge?: boolean;
+    icon?: React.ReactNode;
+};
+export type OverlayIndicatorConfig = {
+    maxPerCell?: number;
+    icons?: Record<string, OverlayIconEntry>;
+    statusClasses?: {
+        ok?: string;
+        info?: string;
+        warning?: string;
+        danger?: string;
+    };
+    showLegend?: boolean;
+};
+export declare const DynamicIcon: React.FC<{
+    name: string;
+    className?: string;
+}>;
+export declare const toPackageOverlayConfig: (cfg?: DesignerOverlayIndicatorConfig) => OverlayIndicatorConfig | undefined;

package/dist/cjs/organisms/CalendarDataGrid/CalendarDataGrid.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import '../../setup/muiXLicense';
+import type { CalendarDataGridProps } from './types';
+export declare const CalendarDataGrid: React.NamedExoticComponent<CalendarDataGridProps>;

package/dist/cjs/organisms/CalendarDataGrid/CalendarDataGrid.examples.stories.d.ts

@@ -0,0 +1,7 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { CalendarDataGrid } from '../../index';
+type Story = StoryObj<typeof CalendarDataGrid>;
+declare const meta: Meta<typeof CalendarDataGrid>;
+export default meta;
+export declare const CalendarDataGridExamples: Story;
+export declare const ResourceSchedulingDashboard: Story;

package/dist/cjs/organisms/CalendarDataGrid/CalendarDataGrid.stories.d.ts

@@ -0,0 +1,5 @@
+import type { Meta, StoryObj } from '@storybook/react';
+import { CalendarDataGrid } from './CalendarDataGrid';
+declare const meta: Meta<typeof CalendarDataGrid>;
+export default meta;
+export declare const Basic: StoryObj<typeof CalendarDataGrid>;