@dxs-ts/eveli-ide 0.0.418 → 0.0.420

package/build/api-dialob-form/DialobFormsProvider.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+import { DasboardItem } from './types-dashboard';
+import { Visitor_DeleteForm, Visitor_CopyForm, Visitor_CreateNewForm } from './visitors';
+export interface DialobFormsOperationResult {
+    success: boolean;
+    message: string;
+}
+export interface DialobFormsContextType {
+    forms: DasboardItem[];
+    uploadJsonForm: (file: File) => Promise<DialobFormsOperationResult>;
+    uploadCsvForm: (file: File) => Promise<DialobFormsOperationResult>;
+    downloadAllForms: () => Promise<{
+        blob: Blob;
+        fileName: string;
+    }>;
+    createForm: (props: Visitor_CreateNewForm.Input) => Promise<Visitor_CreateNewForm.Result>;
+    copyForm: (props: Visitor_CopyForm.Input) => Promise<Visitor_CopyForm.Result>;
+    deleteForm: (props: Visitor_DeleteForm.Input) => Promise<Visitor_DeleteForm.Result>;
+}
+export declare const DialobFormsContext: React.Context<DialobFormsContextType>;
+export interface DialobFormsProviderProps {
+    tenantId?: string | undefined;
+    dialobApiUrl?: string | undefined;
+    fetch?: typeof window.fetch | undefined;
+    children: React.ReactNode;
+}
+export declare const DialobFormsProvider: React.FC<DialobFormsProviderProps>;
+export declare const useDialobForms: () => DialobFormsContextType;

package/build/api-dialob-form/index.d.ts

@@ -0,0 +1,4 @@
+export * from './DialobFormsProvider';
+export * from './visitors';
+export * from './types-rest-api';
+export * from './types-dashboard';

package/build/api-dialob-form/types-dashboard.d.ts

@@ -0,0 +1,13 @@
+import { DialobRestApi } from './types-rest-api';
+export interface DashboardState {
+    forms: DialobRestApi.FormListItem[];
+    tags: DialobRestApi.FormTag[];
+    items: DasboardItem[];
+    loadedAt: Date;
+}
+export interface DasboardItem {
+    id: string;
+    metadata: DialobRestApi.FormMetadata;
+    latestTagName?: string;
+    latestTagDate?: Date;
+}

package/build/api-dialob-form/types-rest-api.d.ts

@@ -0,0 +1,159 @@
+export declare namespace DialobRestApi {
+    type ValidationLevel = 'INFO' | 'WARNING' | 'ERROR' | 'FATAL';
+    type ValidationType = 'VISIBILITY' | 'VALIDATION' | 'REQUIREMENT' | 'VARIABLE' | 'GENERAL' | 'CLASSNAME' | 'VALUE_ENTRY' | 'VALUESET' | 'VALUESET_ENTRY' | 'CANADDROW' | 'CANREMOVEROW';
+    type FormTagType = 'NORMAL' | 'MUTABLE';
+    interface FormValidationError {
+        itemId?: string;
+        message?: string;
+        level?: ValidationLevel;
+        type?: ValidationType;
+        expression?: string;
+        startIndex?: number;
+        endIndex?: number;
+        index?: number;
+    }
+    interface RestApiErrorResponse {
+        timestamp?: Date;
+        status?: number;
+        error?: string;
+        message?: string;
+        trace?: string;
+        path?: string;
+        errors?: Array<{
+            code?: string;
+            context?: string;
+            rejectedValue?: any;
+            error?: string;
+        }>;
+    }
+    interface ApiResponse {
+        ok?: boolean;
+        error?: string;
+        reason?: string;
+        id?: string;
+        rev?: string;
+        errors?: FormValidationError[];
+        form?: Form;
+    }
+    interface FormMetadata {
+        label: string;
+        created?: Date;
+        lastSaved?: Date;
+        valid?: boolean;
+        creator?: string;
+        tenantId?: string;
+        savedBy?: string;
+        labels: string[];
+        defaultSubmitUrl?: string;
+        languages: string[];
+        additionalProperties: Record<string, any>;
+    }
+    interface Validation {
+        message: Record<string, string>;
+        rule?: string;
+    }
+    interface FormValueSetEntry {
+        id: string;
+        label?: Record<string, string>;
+        when?: string;
+        additionalProperties: Record<string, any>;
+    }
+    interface FormValueSet {
+        id: string;
+        entries?: FormValueSetEntry[];
+        additionalProperties: Record<string, any>;
+    }
+    interface Variable {
+        name: string;
+        expression?: string;
+        defaultValue?: any;
+        context?: boolean;
+        published?: boolean;
+        contextType?: string;
+        description?: string;
+    }
+    interface FormItem {
+        id: string;
+        type: string;
+        view?: string;
+        label: Record<string, string>;
+        description: Record<string, string>;
+        required?: string;
+        requiredErrorText: Record<string, string>;
+        readOnly?: boolean;
+        items: string[];
+        className: string[];
+        activeWhen?: string;
+        canAddRowWhen?: string;
+        canRemoveRowWhen?: string;
+        validations: Validation[];
+        valueSetId?: string;
+        defaultValue?: any;
+        props?: Record<string, any>;
+        additionalProperties: Record<string, any>;
+    }
+    interface Form {
+        _id?: string;
+        _rev?: string;
+        name?: string;
+        data: Record<string, FormItem>;
+        metadata: FormMetadata;
+        variables: Variable[];
+        namespaces: Record<string, Form>;
+        valueSets: FormValueSet[];
+        requiredErrorText: Record<string, string>;
+    }
+    interface FormListItem {
+        id: string;
+        metadata: FormMetadata;
+    }
+    interface FormTag {
+        formName: string;
+        name: string;
+        refName?: string;
+        created?: Date;
+        formId?: string;
+        description?: string;
+        creator?: string;
+        type?: FormTagType;
+    }
+    interface DialobAdminConfig {
+        dialobApiUrl: string;
+        tenantId?: string;
+    }
+    interface TagFilters {
+        formName?: string;
+        formId?: string;
+        name?: string;
+    }
+    interface UpdateFormOptions {
+        oldId?: string;
+        newId?: string;
+        force?: boolean;
+        dryRun?: boolean;
+    }
+    interface CreateFormRequest {
+        name: string;
+        data: {
+            questionnaire: {
+                id: 'questionnaire';
+                type: 'questionnaire';
+                items: string[];
+            };
+        };
+        metadata: {
+            label: string;
+            languages: string[];
+        };
+    }
+    interface Backend {
+        findAllForms: () => Promise<FormListItem[]>;
+        findAllTags: (filters?: TagFilters) => Promise<FormTag[]>;
+        getForm: (formId: string, rev?: string) => Promise<Form>;
+        getFormTags: (formId: string) => Promise<FormTag[]>;
+        createForm: (form: CreateFormRequest | Form) => Promise<Form>;
+        updateForm: (formId: string, form: Form, options?: UpdateFormOptions) => Promise<ApiResponse>;
+        deleteForm: (formId: string) => Promise<ApiResponse>;
+        createFormFromCsv: (csvData: string) => Promise<ApiResponse>;
+    }
+}

package/build/api-dialob-form/visitors/Visitor_CopyForm.d.ts

@@ -0,0 +1,29 @@
+import { DialobRestApi } from '../types-rest-api';
+export declare namespace Visitor_CopyForm {
+    interface Input {
+        sourceFormId: string;
+        newName: string;
+        newLabel: string;
+    }
+    interface Result {
+        success: boolean;
+        originalForm?: DialobRestApi.Form;
+        copiedForm?: DialobRestApi.Form;
+        copiedFormId?: string;
+        message: string;
+        error?: string;
+        validationErrors?: ValidationErrors;
+    }
+    interface ValidationErrors {
+        name?: string;
+        label?: string;
+    }
+}
+export declare class Visitor_CopyForm {
+    accept(backend: DialobRestApi.Backend, context: Visitor_CopyForm.Input): Promise<Visitor_CopyForm.Result>;
+    private hasValidationErrors;
+    private prepareCopiedForm;
+    private buildSuccessResult;
+    private buildValidationFailureResult;
+    private buildErrorResult;
+}

package/build/api-dialob-form/visitors/Visitor_CreateNewForm.d.ts

@@ -0,0 +1,32 @@
+import { DialobRestApi } from '../types-rest-api';
+export declare namespace Visitor_CreateNewForm {
+    interface Input {
+        name: string;
+        label: string;
+        template: DialobRestApi.CreateFormRequest;
+    }
+    interface Result {
+        success: boolean;
+        form?: DialobRestApi.Form;
+        formId?: string;
+        message: string;
+        error?: string;
+        validationErrors?: ValidationErrors;
+    }
+    interface ValidationErrors {
+        name?: string;
+        label?: string;
+    }
+}
+export declare class Visitor_CreateNewForm {
+    accept(backend: DialobRestApi.Backend, context: Visitor_CreateNewForm.Input): Promise<Visitor_CreateNewForm.Result>;
+    static validateInput(context: {
+        name?: string;
+        label?: string;
+    }): Visitor_CreateNewForm.ValidationErrors;
+    private hasValidationErrors;
+    private prepareNewForm;
+    private buildSuccessResult;
+    private buildValidationFailureResult;
+    private buildErrorResult;
+}

package/build/api-dialob-form/visitors/Visitor_DashboardState.d.ts

@@ -0,0 +1,8 @@
+import { DashboardState } from '../types-dashboard';
+import { DialobRestApi } from '../types-rest-api';
+export declare namespace Visitor_DashboardState {
+}
+export declare class Visitor_DashboardState {
+    accept(backend: DialobRestApi.Backend): Promise<DashboardState>;
+    private findLatestTag;
+}

package/build/api-dialob-form/visitors/Visitor_DeleteForm.d.ts

@@ -0,0 +1,19 @@
+import { DialobRestApi } from '../types-rest-api';
+export declare namespace Visitor_DeleteForm {
+    interface Input {
+        form: DialobRestApi.FormListItem;
+    }
+    interface Result {
+        success: boolean;
+        formId: string;
+        message: string;
+        error?: string;
+        response?: DialobRestApi.ApiResponse;
+    }
+}
+export declare class Visitor_DeleteForm {
+    accept(backend: DialobRestApi.Backend, context: Visitor_DeleteForm.Input): Promise<Visitor_DeleteForm.Result>;
+    private validateInput;
+    private buildSuccessResult;
+    private buildErrorResult;
+}

package/build/api-dialob-form/visitors/Visitor_DownloadAllForms.d.ts

@@ -0,0 +1,24 @@
+import { DialobRestApi } from '../types-rest-api';
+export declare namespace Visitor_DownloadAllForms {
+    interface Input {
+        forms: DialobRestApi.FormListItem[];
+    }
+    interface Result {
+        totalCount: number;
+        successfulForms: DialobRestApi.Form[];
+        failedForms: Array<{
+            formId: string;
+            error: string;
+        }>;
+    }
+}
+export declare class Visitor_DownloadAllForms {
+    accept(backend: DialobRestApi.Backend, context: Visitor_DownloadAllForms.Input): Promise<{
+        fileName: string;
+        blob: Blob;
+    }>;
+    private fetchAllForms;
+    private buildDownloadResult;
+    private generateFileName;
+    private sanitizeFileName;
+}

package/build/api-dialob-form/visitors/Visitor_RestApi.d.ts

@@ -0,0 +1,10 @@
+import { DialobRestApi } from '../types-rest-api';
+export declare namespace Visitor_RestApi {
+    interface Input {
+        config: DialobRestApi.DialobAdminConfig;
+        fetch: typeof window.fetch;
+    }
+}
+export declare class Visitor_RestApi {
+    accept(context: Visitor_RestApi.Input): DialobRestApi.Backend;
+}

package/build/api-dialob-form/visitors/Visitor_UploadFormCsv.d.ts

@@ -0,0 +1,25 @@
+import { DialobRestApi } from '../types-rest-api';
+export declare namespace Visitor_UploadCsvForm {
+    interface Input {
+        file: File;
+    }
+    interface Result {
+        success: boolean;
+        formId?: string;
+        message: string;
+        error?: string;
+        metadata?: {
+            fileName: string;
+            fileSize: number;
+            uploadTime: Date;
+        };
+    }
+}
+export declare class Visitor_UploadCsvForm {
+    accept(backend: DialobRestApi.Backend, context: Visitor_UploadCsvForm.Input): Promise<Visitor_UploadCsvForm.Result>;
+    private validateCsvFile;
+    private readCsvFile;
+    private uploadCsvToBackend;
+    private buildSuccessResult;
+    private buildFailureResult;
+}

package/build/api-dialob-form/visitors/Visitor_UploadFormJson.d.ts

@@ -0,0 +1,30 @@
+import { DialobRestApi } from '../types-rest-api';
+export declare namespace Visitor_UploadFormJson {
+    interface Input {
+        file: File;
+        allForms: DialobRestApi.FormListItem[];
+    }
+    interface Result {
+        success: boolean;
+        message: string;
+        isExisting?: boolean;
+        error?: string;
+        metadata?: {
+            fileName: string;
+            fileSize: number;
+            uploadTime: Date;
+            formName?: string;
+        };
+    }
+}
+export declare class Visitor_UploadFormJson {
+    private startTime;
+    accept(backend: DialobRestApi.Backend, context: Visitor_UploadFormJson.Input): Promise<Visitor_UploadFormJson.Result>;
+    private validateFile;
+    private readFileSync;
+    private parseJson;
+    private prepareData;
+    private uploadForm;
+    private buildSuccessResult;
+    private handleFailure;
+}

package/build/api-dialob-form/visitors/index.d.ts

@@ -0,0 +1,8 @@
+export * from './Visitor_CopyForm';
+export * from './Visitor_CreateNewForm';
+export * from './Visitor_DashboardState';
+export * from './Visitor_DownloadAllForms';
+export * from './Visitor_RestApi';
+export * from './Visitor_UploadFormCsv';
+export * from './Visitor_UploadFormJson';
+export * from './Visitor_DeleteForm';

package/build/date-picker/DateInput.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+export interface DateInputProps {
+    value: Date | null;
+    inline: boolean;
+    onChange: (newDate: Date | null) => void;
+}
+export declare const DateInput: React.FC<DateInputProps>;

package/build/date-picker/calendar-input/CalendarInput.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+export declare const CalendarInput: React.ForwardRefExoticComponent<{
+    className: string;
+} & React.RefAttributes<HTMLInputElement>>;

package/build/date-picker/calendar-input/CalendarInputProvider.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+import { DateInputStateMachine, DateField } from './DateInputStateMachine';
+export interface CalendarInputProps {
+    value?: Date | null;
+    onChange: (date: Date | null) => void;
+    onCalendarOpen?: () => void;
+    placeholder?: string;
+    disabled?: boolean;
+    className: string;
+}
+export interface CalendarInputContextType {
+    machine: DateInputStateMachine;
+    dayRef: React.RefObject<HTMLInputElement>;
+    monthRef: React.RefObject<HTMLInputElement>;
+    yearRef: React.RefObject<HTMLInputElement>;
+    typeDayDigit: (value: string) => void;
+    typeMonthDigit: (value: string) => void;
+    typeYearDigit: (value: string) => void;
+    focusField: (field: DateField) => void;
+    blurField: (field: DateField) => void;
+    clear: () => void;
+    handleKeyDown: (e: React.KeyboardEvent<HTMLInputElement>, field: DateField) => void;
+    handleContainerClick: (e: React.MouseEvent) => void;
+    handleCalendarOpen: () => void;
+}
+export declare const useCalendarInput: () => CalendarInputContextType;
+export declare const CalendarInputProvider: React.FC<{
+    children: React.ReactNode;
+    value?: Date | null;
+    onChange: (date: Date | null) => void;
+    onCalendarOpen?: () => void;
+}>;

package/build/date-picker/calendar-input/DateInputStateMachine.d.ts

@@ -0,0 +1,37 @@
+export type DateInputState = 'empty' | 'typing' | 'validating' | 'valid' | 'error';
+export type DateField = 'day' | 'month' | 'year';
+export interface DateInputData {
+    day: string;
+    month: string;
+    year: string;
+    state: DateInputState;
+    focusedField: DateField | null;
+    error?: string;
+    shouldAutoAdvance?: boolean;
+    resultDate?: Date;
+    isUserChange: boolean;
+}
+export declare class DateInputStateMachine {
+    private data;
+    constructor(initialData?: Partial<DateInputData>);
+    get day(): string;
+    get month(): string;
+    get year(): string;
+    get state(): DateInputState;
+    get focusedField(): DateField | null;
+    get error(): string | undefined;
+    get shouldAutoAdvance(): boolean | undefined;
+    get resultDate(): Date | undefined;
+    get isUserChange(): boolean;
+    get isValid(): boolean;
+    typeDayDigit(value: string): DateInputStateMachine;
+    typeMonthDigit(value: string): DateInputStateMachine;
+    typeYearDigit(value: string): DateInputStateMachine;
+    focusField(field: DateField): DateInputStateMachine;
+    blurField(field: DateField): DateInputStateMachine;
+    clear(): DateInputStateMachine;
+    setFromDate(date: Date | null): DateInputStateMachine;
+    private isComplete;
+    private tryValidateComplete;
+    debug(): string;
+}

package/build/date-picker/calendar-input/Input.d.ts

@@ -0,0 +1 @@
+export declare const Input: import('@emotion/styled').StyledComponent<import('@mui/system').MUIStyledCommonProps<import('@mui/material').Theme>, import('react').DetailedHTMLProps<import('react').InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, {}>;

package/build/date-picker/calendar-input/index.d.ts

@@ -0,0 +1,2 @@
+export * from './CalendarInputProvider';
+export * from './CalendarInput';

package/build/date-picker/calendar-interactive/Calendar.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+export interface CalendarProps {
+    initialDate: Date;
+    selectedDate?: Date | null;
+    minDate?: Date;
+    maxDate?: Date;
+    inline?: boolean | undefined;
+    onDateSelect: (date: Date) => void;
+    onClose?: () => void;
+}
+export declare const Calendar: React.FC<CalendarProps>;

package/build/date-picker/calendar-interactive/CalendarHeader.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export declare const CalendarHeader: React.FC<{
+    currentDate: Date;
+    onPreviousMonth: () => void;
+    onNextMonth: () => void;
+    onPreviousYear: () => void;
+    onNextYear: () => void;
+    onYearClick: () => void;
+}>;

package/build/date-picker/calendar-interactive/CalendarProvider.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export declare const CalendarProvider: React.FC<{
+    inline?: boolean | undefined;
+    value: Date | null;
+    locale: string;
+    open: boolean;
+    onClose: () => void;
+    onChange: (value: Date | null) => void;
+}>;

package/build/date-picker/calendar-interactive/CardWrapper.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export declare const CardWrapper: React.FC<{
+    inline: boolean;
+    children: React.ReactNode;
+}>;

package/build/date-picker/calendar-interactive/DayGrid.d.ts

@@ -0,0 +1,7 @@
+export declare const DayGrid: React.FC<{
+    currentDate: Date;
+    selectedDate?: Date | null;
+    onDateSelect: (date: Date) => void;
+    minDate?: Date;
+    maxDate?: Date;
+}>;

package/build/date-picker/calendar-interactive/YearPicker.d.ts

@@ -0,0 +1,7 @@
+export declare const YearPicker: React.FC<{
+    currentYear: number;
+    onYearSelect: (year: number) => void;
+    onClose: () => void;
+    minDate?: Date;
+    maxDate?: Date;
+}>;

package/build/date-picker/calendar-interactive/index.d.ts

@@ -0,0 +1 @@
+export * from './CalendarProvider';

package/build/date-picker/calendar-interactive/intl.d.ts

@@ -0,0 +1 @@
+export declare function getMessages(locale: string): Record<string, string>;

package/build/date-picker/index.d.ts

@@ -0,0 +1 @@
+export * from './DateInput';

package/build/dialob-dashboard-smart/DialobDashboardSmart.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const DialobDashboardSmart: React.FC<{}>;

package/build/dialob-dashboard-smart/dialog-copy/DialogCopy.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { DialobRestApi } from '../../api-dialob-form';
+export interface DialogCopyProps {
+    onClose: () => void;
+    source: DialobRestApi.FormListItem;
+}
+export declare const DialogCopy: React.FC<DialogCopyProps>;

package/build/dialob-dashboard-smart/dialog-copy/index.d.ts

@@ -0,0 +1 @@
+export * from './DialogCopy';

package/build/dialob-dashboard-smart/dialog-create/DialogCreate.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+export interface DialogCreateProps {
+    onClose: () => void;
+}
+export declare const DialogCreate: React.FC<DialogCreateProps>;

package/build/dialob-dashboard-smart/dialog-create/index.d.ts

@@ -0,0 +1 @@
+export * from './DialogCreate';

package/build/dialob-dashboard-smart/dialog-delete/DialogDelete.d.ts

@@ -0,0 +1,7 @@
+import { DialobRestApi } from '../../api-dialob-form';
+import { default as React } from 'react';
+export interface DialobActionCreateProps {
+    onClose: () => void;
+    source: DialobRestApi.FormListItem;
+}
+export declare const DialobActionDelete: React.FC<DialobActionCreateProps>;

package/build/dialob-dashboard-smart/dialog-delete/index.d.ts

@@ -0,0 +1 @@
+export * from './DialogDelete';

package/build/dialob-dashboard-smart/form-table/FormTable.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const FormTable: React.FC<{}>;

package/build/dialob-dashboard-smart/form-table/index.d.ts

@@ -0,0 +1 @@
+export * from './FormTable';

package/build/dialob-dashboard-smart/form-table-date-time/FormTableDateTime.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+export declare const FormTableDateTime: React.FC<{
+    value: string;
+}>;

package/build/dialob-dashboard-smart/form-table-date-time/index.d.ts

@@ -0,0 +1 @@
+export * from './FormTableDateTime';

package/build/dialob-dashboard-smart/form-table-filters/index.d.ts

@@ -0,0 +1,4 @@
+import { DasboardItem } from '../../api-dialob-form';
+import { FilterFnOption } from '@tanstack/react-table';
+export declare const filterDateGte_latestTagDate: FilterFnOption<DasboardItem>;
+export declare const filterDateGte_lastSaved: FilterFnOption<DasboardItem>;

package/build/dialob-dashboard-smart/form-table-toolbar/FileUploadButton.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+export declare const FileUploadButton: React.FC<{
+    accept: string;
+    onChange: (file: File) => Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    uploadRef: React.MutableRefObject<HTMLInputElement | null>;
+}>;

package/build/dialob-dashboard-smart/form-table-toolbar/FormTableToolbar.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const FormTableToolbar: React.FC<{}>;

package/build/dialob-dashboard-smart/form-table-toolbar/index.d.ts

@@ -0,0 +1 @@
+export * from './FormTableToolbar';

package/build/dialob-dashboard-smart/index.d.ts

@@ -0,0 +1 @@
+export * from './DialobDashboardSmart';

package/build/dialob-dashboard-smart/intl/index.d.ts

@@ -0,0 +1,3 @@
+export declare const messages: {
+    [key: string]: any;
+};