@ws-ui/store 0.1.0 → 0.1.2

package/dist/modules/explorer/thunks.d.ts

@@ -0,0 +1,263 @@
+/// <reference types="@ws-ui/shared/dist/declarations/datasources/interfaces/catalog" />
+/// <reference types="@ws-ui/shared/dist/declarations/datasources/interfaces/dataclass-attribute" />
+import { Action, ThunkDispatch } from '@reduxjs/toolkit';
+import { FileFolderType, IFileInfo, ISaveFileResponse, ISetFileContentResponse, ITextEditorSelection } from '@ws-ui/shared';
+import { ITab } from '@ws-ui/shared';
+import { ClassFileTypes } from '../../modules/root/types';
+import { AppState } from '..';
+import { ISettingsState } from '../settings';
+import { ITreeItem } from './types';
+interface ICreateNewFilePayload {
+    fileName: string;
+    type: FileFolderType;
+    path: string;
+    parentNode: ITreeItem;
+    content?: string;
+    qodly: boolean;
+}
+export declare function getDefaultContent(root: FileFolderType, projectSettings: ISettingsState['project']): "" | {
+    metadata: {
+        v: string;
+        datasources: never[];
+        styles: never[];
+    };
+    components: {
+        ROOT: {
+            parent: string;
+            type: {
+                resolvedName: string;
+            };
+            isCanvas: boolean;
+            props: {
+                airyMode: boolean;
+                className: string;
+                classNames: never[];
+                events: never[];
+            };
+            displayName: string;
+            custom: {};
+            hidden: boolean;
+            nodes: never[];
+            linkedNodes: {};
+        };
+    };
+} | "//%attributes = {}\n";
+export declare function getFilenameFromType(fileName: string, type: FileFolderType, qodly?: boolean): string;
+export declare function castToFileFolder(type: string): FileFolderType;
+export declare function getFileType(root: FileFolderType): FileFolderType;
+export declare const tryEditMethod: import("@reduxjs/toolkit").AsyncThunk<ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>>, {
+    method: catalog.IMethod;
+}, {
+    state: AppState;
+}>;
+export declare const createModelFiles: import("@reduxjs/toolkit").AsyncThunk<void, {
+    type: 'dataclass';
+    className: string;
+    collectionName: string;
+    toCreate?: ClassFileTypes | undefined;
+} | {
+    type: 'model';
+}, {
+    state: AppState;
+}>;
+export declare const fetchFolderContent: import("@reduxjs/toolkit").AsyncThunk<ITreeItem[], string, {}>;
+export declare const fetchFolderContentWithoutExpanding: import("@reduxjs/toolkit").AsyncThunk<ITreeItem[], string, {}>;
+export declare const uploadFileAndGetResponse: import("@reduxjs/toolkit").AsyncThunk<{
+    status: number;
+    data: any;
+}, File, {}>;
+export declare const uploadFile: import("@reduxjs/toolkit").AsyncThunk<{
+    status: number;
+    fileName: string;
+}, {
+    file: File;
+    path: string;
+    parentNode: ITreeItem;
+}, {}>;
+export declare const createNewFile: import("@reduxjs/toolkit").AsyncThunk<{
+    qodly: boolean;
+    file: ISetFileContentResponse;
+    parentNode: ITreeItem;
+}, ICreateNewFilePayload, {
+    state: AppState;
+    rejectValue: string;
+}>;
+/**
+ * Returns the file path of the given file object based on its type.
+ *
+ * @param {ISaveFileResponse} file - The file object to get the path for.
+ * @param {Partial<{ withExtension: boolean; qodly: boolean }>} [options] - Optional parameters object.
+ * @param {boolean} [options.withExtension=true] - Whether to include the file extension in the path.
+ * @param {boolean} [options.qodly=true] - Whether to use the qodly file extension instead of the standard one.
+ * @return {string} The file path with or without extension, based on the options.
+ */
+export declare function getFilePath(file: ISaveFileResponse, options?: Partial<{
+    withExtension: boolean;
+    qodly: boolean;
+}>): string;
+export declare const createNewFileAndOpen: import("@reduxjs/toolkit").AsyncThunk<void, ICreateNewFilePayload, {
+    dispatch: ThunkDispatch<any, void, Action>;
+}>;
+export declare const createNewNode: import("@reduxjs/toolkit").AsyncThunk<{
+    file: import("@ws-ui/shared").IAddFolderResponse;
+    parentNode: ITreeItem;
+}, {
+    fileName: string;
+    type: FileFolderType;
+    path: string;
+    parentNode: ITreeItem;
+}, {}>;
+export declare const openFile: import("@reduxjs/toolkit").AsyncThunk<ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>> | null, {
+    file: IFileInfo;
+    inactive?: boolean | undefined;
+    isNew?: boolean | undefined;
+    flags?: Pick<Partial<{
+        touched: boolean;
+        removed: boolean;
+        pinned: boolean;
+        loading: boolean;
+        old: boolean;
+        enabled: boolean;
+        confirmed: boolean;
+    }>, "pinned" | "loading" | "enabled" | "confirmed"> | undefined;
+}, {
+    state: AppState;
+}>;
+export declare const openFileAtLine: import("@reduxjs/toolkit").AsyncThunk<ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>>, {
+    file: IFileInfo;
+    line: number;
+    offset?: number | undefined;
+}, {
+    state: AppState;
+}>;
+export declare const injectContentAtLine: import("@reduxjs/toolkit").AsyncThunk<{
+    path: string;
+    content: string;
+    line: number;
+}, {
+    path: string;
+    content: string;
+    line: number;
+}, {}>;
+export interface IOpenFileAtSelectionPayload {
+    file: IFileInfo;
+    selection: ITextEditorSelection;
+}
+export declare const openFileAtSelection: import("@reduxjs/toolkit").AsyncThunk<ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>>, IOpenFileAtSelectionPayload, {
+    state: AppState;
+}>;
+export declare const deleteFile: import("@reduxjs/toolkit").AsyncThunk<{
+    deleted: boolean;
+    node: ITreeItem;
+}, ITreeItem, {
+    state: AppState;
+}>;
+export declare const deleteFolder: import("@reduxjs/toolkit").AsyncThunk<{
+    deleted: boolean;
+    node: ITreeItem;
+}, ITreeItem, {
+    state: AppState;
+}>;
+export declare const removeFileNode: import("@reduxjs/toolkit").AsyncThunk<{
+    deleted: boolean;
+    node: ITreeItem;
+}, ITreeItem, {
+    state: AppState;
+}>;
+export declare const renameFile: import("@reduxjs/toolkit").AsyncThunk<{
+    old: ITreeItem;
+    new: ITreeItem;
+}, {
+    file: ITreeItem;
+    newname: string;
+}, {
+    state: AppState;
+}>;
+export declare const relocateNode: import("@reduxjs/toolkit").AsyncThunk<void, {
+    draggedNode: ITreeItem;
+    newLocation: ITreeItem;
+}, {
+    state: AppState;
+}>;
+export declare const duplicateNode: import("@reduxjs/toolkit").AsyncThunk<any, any, {
+    state: AppState;
+}>;
+export declare const executeMethod: import("@reduxjs/toolkit").AsyncThunk<void | {
+    [refName: string]: datasources.IComponentAction;
+}, {
+    methodName: string;
+    namespace?: string | undefined;
+    params?: {
+        name: string;
+        namespace?: string | undefined;
+        isHardCoded?: boolean | undefined;
+        type?: 'string' | 'number' | 'object' | 'date' | 'array' | 'bool' | undefined;
+    }[] | undefined;
+    resultingDataSource?: {
+        id?: string | undefined;
+        namespace?: string | undefined;
+    } | undefined;
+}, {
+    state: AppState;
+}>;
+export {};

package/dist/modules/explorer/types.d.ts

@@ -0,0 +1,56 @@
+import { FileFolderType, IEditor } from '@ws-ui/shared';
+export interface ITreeItem {
+    name: string;
+    path: string;
+    children?: ITreeItem[];
+    type: FileFolderType;
+    date?: string;
+    size?: number;
+    ext?: string;
+    error: null | {
+        message: string;
+    };
+    flags: {
+        [key: string]: boolean;
+    };
+    tipKey?: string;
+    config: {
+        editor?: IEditor;
+        supportedEditors?: IEditor[];
+    };
+    isRoot?: boolean;
+}
+export interface INodePermissions {
+    canRemove: boolean;
+    canAdd: boolean;
+    canMove: boolean;
+    canRename: boolean;
+    canDownload: boolean;
+    canUpload: boolean;
+    canReload: boolean;
+    canAddFolder: boolean;
+    canDuplicate: boolean;
+    canDrag: boolean;
+    canDragIn: boolean;
+    canTerminate: boolean;
+    canRender: boolean;
+    canExecute: boolean;
+}
+export interface INodeFlags {
+    hidden: boolean;
+    disabled: boolean;
+}
+export interface INodeAttributes {
+    flags: Partial<INodeFlags>;
+    permissions: Partial<INodePermissions>;
+}
+export interface IEditors {
+    pattern: string;
+    editor: IEditor;
+    supportedEditors?: IEditor[];
+}
+export declare const editors: IEditors[];
+export declare const extensions: {
+    pattern: string;
+    type: 'json' | 'text';
+}[];

package/dist/modules/explorer/utils.d.ts

@@ -0,0 +1,4 @@
+import { IEditors } from './types';
+export declare function getNodeRelativePath(nodePath: string): string;
+export declare function getEditors(path: string): IEditors;
+export declare function getExtension(path: string): "json" | "text";

package/dist/modules/index.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="@ws-ui/shared/dist/declarations/datasources/datasource" />
+import rootReducer from './root';
+export declare const stateReducer: import("redux").Reducer<import("redux").CombinedState<{
+    root: import("immer/dist/internal.js").WritableDraft<import("./root").IRootState>;
+    explorer: import("immer/dist/internal.js").WritableDraft<import("./explorer").ITreeItem>[];
+    debugger: import("./debugger").IDebuggerState;
+    settings: import("./settings").ISettingsState;
+    catalog: {
+        state: "loading";
+    } | {
+        state: "loaded";
+        model: datasources.IEnhancedCatalog;
+    } | {
+        state: "error";
+        error: string;
+    };
+    roles: {
+        flags: {
+            touched?: boolean | undefined;
+            removed?: boolean | undefined;
+            pinned?: boolean | undefined;
+            loading?: boolean | undefined;
+            old?: boolean | undefined;
+            enabled?: boolean | undefined;
+            confirmed?: boolean | undefined;
+        };
+        date?: string | undefined;
+        privileges: import("./roles").TById;
+        roles: import("./roles").TRolesDict;
+        forceLogin?: boolean | undefined;
+        selectedTab: "roles" | "privileges";
+    };
+    sharedDatasources: import("./shared-datasources").ISharedDatasourcesState;
+    webforms: import("./webforms").IWebformEditorState;
+    modals: import("./modals").IModalsState;
+    sharedCSS: import("immer/dist/internal.js").WritableDraft<import("./shared-css").ISharedCSSState>;
+    model: import("./model").IModelState;
+}>, import("redux").AnyAction>;
+export { rootReducer };
+export type AppState = ReturnType<typeof stateReducer>;
+export * from './catalog';
+export * from './debugger';
+export * from './explorer';
+export * from './modals';
+export * from './model';
+export * from './roles';
+export * from './root';
+export * from './settings';
+export * from './shared-css';
+export * from './shared-datasources';
+export * from './tabs';
+export * from './webforms';

package/dist/modules/modals/index.d.ts

@@ -0,0 +1,5 @@
+declare const _default: import("redux").Reducer<import("./reducer").IModalsState>;
+export default _default;
+export * from './reducer';
+export * from './thunks';
+export * from './types';

package/dist/modules/modals/reducer.d.ts

@@ -0,0 +1,17 @@
+import { ICloseModalAction, ICreateModalAction, IEditModalAction, IModal, IRemoveModalAction } from './types';
+export interface IModalsState {
+    list: IModal[];
+}
+declare const stateSlice: import("@reduxjs/toolkit").Slice<IModalsState, {
+    createModal: (state: import("immer/dist/internal.js").WritableDraft<IModalsState>, action: ICreateModalAction) => void;
+    editModal: (state: import("immer/dist/internal.js").WritableDraft<IModalsState>, action: IEditModalAction) => void;
+    removeModal: (state: import("immer/dist/internal.js").WritableDraft<IModalsState>, action: IRemoveModalAction) => void;
+    closeModal: (state: import("immer/dist/internal.js").WritableDraft<IModalsState>, action: ICloseModalAction) => void;
+}, "modals">;
+export declare const createModal: import("@reduxjs/toolkit").ActionCreatorWithPayload<IModal, string>, removeModal: import("@reduxjs/toolkit").ActionCreatorWithPayload<string, string>, closeModal: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    id: string;
+    reason?: import("./types").ModalCloseReason | undefined;
+}, string>, editModal: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    id: string;
+} & Partial<Pick<IModal, "views" | "title">>, string>;
+export default stateSlice;

package/dist/modules/modals/thunks.d.ts

@@ -0,0 +1,12 @@
+import { Store } from '../../store';
+import { IModal, ModalType } from './types';
+interface IOpenModalPayload extends Omit<IModal, 'id' | 'isOpen' | 'type'> {
+    type?: ModalType;
+    store?: Store;
+}
+interface IOpenModalReturnValue {
+    confirmed?: boolean;
+    options?: Record<string, boolean>;
+}
+export declare const openModal: import("@reduxjs/toolkit").AsyncThunk<IOpenModalReturnValue, IOpenModalPayload, {}>;
+export {};

package/dist/modules/modals/types.d.ts

@@ -0,0 +1,69 @@
+/// <reference types="react" />
+import { PayloadAction } from '@reduxjs/toolkit';
+export declare const ModalIcons: {
+    FdSave: (props: import("react").SVGProps<SVGSVGElement>) => JSX.Element;
+    FdWarningDanger: (props: import("react").SVGProps<SVGSVGElement>) => JSX.Element;
+    FdInfoCircle: (props: import("react").SVGProps<SVGSVGElement>) => JSX.Element;
+    FdInfoBold: (props: import("react").SVGProps<SVGSVGElement>) => JSX.Element;
+};
+export type ModalIcon = keyof typeof ModalIcons;
+export declare enum ModalType {
+    ALERT = "alert",
+    CONFIRM = "confirm"
+}
+export declare enum ModalColor {
+    PRIMARY = "primary",
+    WARNING = "warning",
+    DANGER = "danger"
+}
+export declare enum ModalCloseReason {
+    CONFIRMED = "confirmed",
+    CANCELED = "canceled"
+}
+export interface IModal {
+    /**
+     * Id of the modal
+     */
+    id: string;
+    type: ModalType;
+    color?: ModalColor;
+    /**
+     * title displayed at the header of the modal
+     */
+    title?: string;
+    /**
+     * The message to be displayed at the center of the modal.
+     */
+    message: string;
+    views?: {
+        /**
+         * additional warnings to be displayed in a list view under the message.
+         */
+        tips?: {
+            type: 'warning' | 'error' | 'info';
+            message: string;
+        }[];
+        toggles?: Record<string, {
+            key: string;
+            value: boolean;
+            title: string;
+            warnings?: {
+                type: 'warning' | 'error' | 'info';
+                message: string;
+            }[];
+        }>;
+    };
+    icon?: ModalIcon;
+    zIndex?: number;
+    isOpen: boolean;
+    closeReason?: ModalCloseReason;
+}
+export type ICreateModalAction = PayloadAction<IModal>;
+export type IEditModalAction = PayloadAction<{
+    id: string;
+} & Partial<Pick<IModal, 'views' | 'title'>>>;
+export type IRemoveModalAction = PayloadAction<string>;
+export type ICloseModalAction = PayloadAction<{
+    id: string;
+    reason?: ModalCloseReason;
+}>;

package/dist/modules/model/helpers.d.ts

@@ -0,0 +1,12 @@
+import { ServerModel, ModelNode } from '../../modules/model/types';
+export declare const serializeModel: (nodes: ModelNode[], modelProps: Partial<{
+    version: string;
+    backgroundColor: string;
+    backgroundImage: string;
+    backgroundVariant: 'dotted' | 'grid' | 'none';
+    zoom: number;
+}>) => ServerModel;
+export declare function getDefaultName(prefix: string, _propertyKey: string, items: Record<string, any>): string;
+export declare const isRelatedEntityAttr: (attribute: catalog.IAttribute) => boolean;
+export declare const isRelatedEntitiesAttr: (attribute: catalog.IAttribute) => boolean;
+export declare const isRelatedAttr: (attribute: catalog.IAttribute) => boolean;

package/dist/modules/model/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("redux").Reducer<import("./reducer").IModelState>;
+export default _default;
+export * from './reducer';
+export * from './thunks';
+export * from './types';
+export * from './subjects';
+export * from './helpers';
+export * from './selectors';

package/dist/modules/model/reducer.d.ts

@@ -0,0 +1,33 @@
+/// <reference types="@ws-ui/shared/dist/declarations/datasources/interfaces/catalog" />
+import { PayloadAction } from '@reduxjs/toolkit';
+export type IModelState = {
+    model: {
+        dataClasses: Record<string, catalog.IDataClass>;
+        collections: Record<string, catalog.IDataClass>;
+        extraProperties: Record<string, any>;
+    };
+    draft: {
+        dataClasses: Record<string, catalog.IDataClass>;
+        collections: Record<string, catalog.IDataClass>;
+        extraProperties: Record<string, any>;
+    };
+    flags: {
+        [key: string]: any;
+    };
+};
+export declare const FLAGS_KEYS: {
+    DATACLASS_DELETE: string;
+    DATACLASS_DRAGGABLE: string;
+};
+declare const stateSlice: import("@reduxjs/toolkit").Slice<IModelState, {
+    setModelFlag(state: IModelState, action: {
+        payload: {
+            [key: string]: any;
+        };
+        type: string;
+    }): void;
+}, "Models">;
+export declare const setModelFlag: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    [key: string]: any;
+}, string>;
+export default stateSlice;

package/dist/modules/model/selectors.d.ts

@@ -0,0 +1,12 @@
+export declare const useDataclasses: () => Record<string, catalog.IDataClass>;
+export declare const useCollections: () => Record<string, catalog.IDataClass>;
+export declare const useDataclass: (dataclassId: string) => catalog.IDataClass;
+export declare const useAttribute: (dataclassId: string, attributeId: string) => catalog.IAttribute | undefined;
+export declare const useModelProperties: () => Record<string, any>;
+export declare const useModelFlags: () => {
+    deleteDataclass: any;
+    draggableDataclass: any;
+    flags: {
+        [key: string]: any;
+    };
+};

package/dist/modules/model/subjects.d.ts

@@ -0,0 +1,6 @@
+import { Subject } from 'rxjs';
+import { ServerModel } from './types';
+export declare const modelSubject: Subject<{
+    action: 'reload';
+    payload: ServerModel;
+}>;

package/dist/modules/model/thunks.d.ts

@@ -0,0 +1,55 @@
+import { ITab } from '@ws-ui/shared';
+import { ServerModel } from '../../modules/model/types';
+import { AppState } from '..';
+type AppThunkOpts<T = string> = {
+    state: AppState;
+    rejectValue: T;
+};
+export declare const fetchModel: import("@reduxjs/toolkit").AsyncThunk<ServerModel, void, AppThunkOpts<string>>;
+export declare const saveModel: import("@reduxjs/toolkit").AsyncThunk<{
+    date: string;
+    ext: string;
+    name: string;
+    size: number;
+    type: string;
+    path: string;
+} & {
+    content: ServerModel;
+}, ITab<ServerModel, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: import("@ws-ui/shared").ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>>, AppThunkOpts<string>>;
+export declare const openModel: import("@reduxjs/toolkit").AsyncThunk<void | ITab<any, Partial<{
+    initialLineInfo: {
+        line: number;
+        offset?: number | undefined;
+        lastModification: number;
+    };
+    initialSelectionInfo: {
+        selection: import("@ws-ui/shared").ITextEditorSelection;
+        lastModification: number;
+    };
+    diffContent: string;
+    attributes: import("@ws-ui/shared").IMethodAttributes;
+    source: import("@ws-ui/shared").ISource;
+    editor: import("@ws-ui/shared").IEditor;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+}>>, {}, AppThunkOpts<string>>;
+export declare const tryRenameDataclass: import("@reduxjs/toolkit").AsyncThunk<void, {
+    dataclassId: string;
+    selectionId: string;
+    name: string;
+}, {}>;
+export {};