@ws-ui/store 1.11.12-rc7 → 1.11.12

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

@@ -1,4 +1,4 @@
-declare const _default: import('redux').Reducer<import('@ws-ui/shared').ITreeItem[]>;
+declare const _default: import('redux').Reducer<import('./types').ITreeItem[]>;
 export default _default;
 export * from './reducer';
 export * from './thunks';

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

@@ -1,5 +1,5 @@
 import { PayloadAction } from '@reduxjs/toolkit';
-import { ITreeItem } from '@ws-ui/shared';
+import { ITreeItem } from './types';
 export declare const findNodeByPath: (tree: ITreeItem[], path: string) => ITreeItem | null;
 declare const stateSlice: import('@reduxjs/toolkit').Slice<ITreeItem[], {
     renameClassesFolder: (state: ITreeItem[], action: PayloadAction<{

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

@@ -1,8 +1,16 @@
-import { FileFolderType, IFileInfo, ISaveFileResponse, ISetFileContentResponse, ITab, ITextEditorSelection, ICreateNewFilePayload, ITreeItem } from '@ws-ui/shared';
+import { FileFolderType, IFileInfo, ISaveFileResponse, ISetFileContentResponse, ITab, ITextEditorSelection } from '@ws-ui/shared';
 import { ClassFileTypes } from '../root/types';
 import { AppState } from '..';
 import { ISettingsState } from '../settings';
-import { IOpenFilePayload, ISwitchEditorPayload } from './types';
+import { IOpenFilePayload, ISwitchEditorPayload, 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']): never[] | "" | {
     metadata: {
         v: string;

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

@@ -1,4 +1,29 @@
-import { IEditor, IFileInfo, ITabFlags, ITab } from '@ws-ui/shared';
+import { FileFolderType, IEditor, IFileInfo, ITabFlags, ITab } from '@ws-ui/shared';
+export interface ITreeItem {
+    id?: string;
+    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;
+    info?: {
+        [key: string]: any;
+    };
+}
 export interface INodePermissions {
     canRemove: boolean;
     canAdd: boolean;

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

@@ -1,6 +1,6 @@
-import { ITreeItem, INodeInfo, IEditor } from '@ws-ui/shared';
-import { IEditors } from './types';
+import { IEditors, ITreeItem } from './types';
 import { AppState } from '..';
+import { INodeInfo, IEditor } from '@ws-ui/shared';
 export declare function getNodeRelativePath(nodePath: string): string;
 export declare function parseEditor(path: string, key: string | null, fallbackEditor?: IEditor): IEditor;
 export declare function getEditors(path: string): IEditors;

package/dist/modules/index.d.ts

@@ -1,9 +1,9 @@
 import { default as rootReducer } from './root';
 export declare const stateReducer: import('redux').Reducer<import('redux').CombinedState<{
     root: import('./root').IRootState;
-    explorer: import('@ws-ui/shared').ITreeItem[];
+    explorer: import('./explorer').ITreeItem[];
     debugger: import('./debugger').IDebuggerState;
-    settings: import('@ws-ui/shared').ISettingsState;
+    settings: import('./settings').ISettingsState;
     catalog: {
         state: "loading";
     } | {
@@ -13,7 +13,7 @@ export declare const stateReducer: import('redux').Reducer<import('redux').Combi
         state: "error";
         error: string;
     };
-    roles: import('@ws-ui/shared').IRolesState;
+    roles: import('./roles').IRolesState;
     sharedDatasources: import('./shared-datasources').ISharedDatasourcesState;
     sharedAppEvents: import('./shared-app-events').ISharedAppEventsState;
     savedConditions: import('./shared-conditions').ISavedConditionsState;

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

@@ -1,4 +1,11 @@
-import { IOpenModalPayload, IOpenModalReturnValue } from '@ws-ui/shared';
+import { IModal, ModalType } from '@ws-ui/shared';
+interface IOpenModalPayload extends Omit<IModal, 'id' | 'isOpen' | 'type'> {
+    type?: ModalType;
+}
+interface IOpenModalReturnValue {
+    confirmed?: boolean;
+    options?: Record<string, boolean>;
+}
 export declare const openModal: import('@reduxjs/toolkit').AsyncThunk<IOpenModalReturnValue, IOpenModalPayload, {
     state?: unknown;
     dispatch?: import('redux').Dispatch;
@@ -9,3 +16,4 @@ export declare const openModal: import('@reduxjs/toolkit').AsyncThunk<IOpenModal
     fulfilledMeta?: unknown;
     rejectedMeta?: unknown;
 }>;
+export {};

package/dist/modules/roles/adapter.d.ts

@@ -1,5 +1,184 @@
-import { EPermissionType, IResourcePermission, TRole, TRolesDict, TById } from '@ws-ui/shared';
+import { EPermissionType, IGraphData, IPermission, IPrivilege, IResource, IResourcePermission, IResourcesByPermission, ISanitized, TById, TRawData, TRole, TRolesDict, TSanitizedPrivilege } from './types';
+/**
+ * pushes uniquely list of items
+ * @param array input array
+ * @param args list of elements to add to the array
+ * @returns an array containing unique fields
+ */
+export declare function uniquePush<T = string>(array: T[], ...args: T[]): T[];
+/**
+ * Sanitize a privileges array
+ * @param data unsanitized data
+ * @returns sanitized data
+ */
+export declare function sanitizePrivileges(data: IPrivilege[]): TById;
+/**
+ * sort list of sanitized pivileges
+ * @param dict sanitized data
+ * @returns sorted privileges
+ */
+export declare function sort(dict: TById): TSanitizedPrivilege[];
+/**
+ * Lists the parents of a specific element
+ * @param id identifier of the current element
+ * @param dict sanitized privileges
+ * @returns parents of the current element
+ */
+export declare function parents(id: string, dict: TById): string[];
+/**
+ * Lists the children of a specific element
+ * @param id identifier of the current element
+ * @param dict sanitized privileges
+ * @returns children of the current element
+ */
+export declare function children(id: string, dict: TById): string[];
+/**
+ * Calculates from a sanitized privileges dictionary the list of allowed to include children
+ * @param id identifier of the current element
+ * @param dict sanitized privileges
+ * @returns allowed to include privileges
+ */
+export declare function allowed(id: string, dict: TById): string[];
+/**
+ * Removes an element from a sanitized dictionary
+ * @param id identifier of the current element
+ * @param dict sanitized privileges
+ * @returns new dictionary containing the initialone except the one with "id"
+ */
+export declare function remove(id: string, dict: TById): TById;
+/**
+ * Adds an existing node as a child of another node
+ * @param parentId the parent identifier
+ * @param childId the child identifer
+ * @param dict sanitized privileges dictionary
+ * @returns the new dictionary
+ */
+export declare function addIn(parentId: string, childId: string, dict: TById): TById;
+/**
+ * Removes an existing node from its (specified) parent
+ * @param parentId the parent identifier
+ * @param childId the child identifer
+ * @param dict sanitized privileges dictionary
+ * @returns the new dictionary
+ */
+export declare function removeFrom(parentId: string, childId: string, dict: TById): TById;
+/**
+ * Create a new privilege
+ * @param name the privilege name
+ * @param dict sanitized privileges dictionary
+ * @returns the new dictionary
+ */
+export declare function create(name: string, dict: TById): TById;
 export declare function createWithResource(name: string, resource: string, type: EPermissionType, action: IResourcePermission['name'], dict: TById): TById;
+/**
+ * Renames an existing node
+ * @param name the new name
+ * @param id the node identifier
+ * @param dict sanitized privileges dictionary
+ * @returns the new dictionary
+ */
+export declare function rename(name: string, id: string, dict: TById): TById;
+/**
+ * Populates a list privileges IDs
+ * @param ids the identifiers of privileges to populate
+ * @param dict sanitized privileges dictionary
+ * @returns populated privileges
+ */
+export declare function populateShallow(ids: string[], dict: TById): (IPrivilege | null)[];
+/**
+ * Get the privilege object from its identifier
+ * @param id the identifier of the node
+ * @param dict sanitized privileges dictionary
+ * @returns populated privilege
+ */
+export declare function getPrivilegeById(id: string, dict: TById): TSanitizedPrivilege | null;
+/**
+ * Maps the privileges to their permissions
+ * @param param0 the raw permission object
+ * @returns an object mapping the privilege to its permission
+ */
+export declare function actionsToPrivs({ applyTo: _, type, ...actions }: IPermission): {
+    [privName: string]: string[];
+};
+/**
+ * Converts a raw permission to a resource
+ * @param item a permission
+ * @returns the resource object
+ */
+export declare function getResourceFromType(item: IPermission): IResource;
+/**
+ * Sanitizes the raw permissions
+ * @param data list of raw permissions
+ * @param byKey dictionary
+ * @returns a new dictionary containing the sanitized permissions
+ */
+export declare function sanitizePermissions(data: IPermission[], byKey: TById): TById;
+/**
+ * Converts a dictionary indexed by id to a new one indexed by name
+ * @param dict dictioanry
+ * @returns a new dictionary indexed by privilege name
+ */
+export declare function getDictByName(dict: TById): TById;
+/**
+ * Sanitizes the content of roles.json file
+ * @param data raw data
+ * @returns sanitized data
+ */
+export declare function sanitize(data: TRawData): ISanitized;
+/**
+ * Converts sanitized data to a valid API payload
+ * @param data sanitized dictionary
+ * @returns raw data
+ */
+export declare function toAPI(data: ISanitized): TRawData;
+export declare function getGraphData(id: string, dict: TById): IGraphData;
+/**
+ *
+ * @param id privilege id
+ * @param permission
+ * @param dict
+ */
+export declare function addPermission(id: string, permission: IPermission, dict: TById): TById;
+/**
+ *
+ * @param id
+ * @param permission
+ * @param dict
+ */
+export declare function removePermission(id: string, permission: IPermission, dict: TById): TById;
+/**
+ * @param resourcesByPermission
+ * @param dict
+ */
+export declare function removeMultiplePermissions(resourcesByPermission: IResourcesByPermission, dict: TById): TById;
+/**
+ *
+ * @param id
+ * @param permission
+ * @param dict
+ */
+export declare function resetResources(id: string, dict: TById): TById;
+/**
+ *
+ * @param id privilege id
+ * @param resource resource name
+ * @param type resource type
+ * @param permission permission name
+ * @param dict privileges dictionary
+ * @returns
+ */
 export declare function togglePrivilegePermission(id: string, resource: string, type: EPermissionType, permission: IResourcePermission['name'], dict: TById): TById;
+/**
+ *
+ * @param id
+ * @param permission
+ * @param dict
+ */
+export declare function togglePermission(id: string, resource: IResource, permission: IResourcePermission, dict: TById): TById;
+export declare function getPromotions(id: string, dict: TById): Record<string, string[]>;
+export declare function getInheritedResources(id: string, dict: TById): IResource[];
 export declare const toState: (rolesArray: TRole[]) => TRolesDict;
+export declare const removeRole: (id: string, roles: TRolesDict) => TRolesDict;
 export declare const editRole: (id: string, newName: string, roles: TRolesDict) => TRolesDict;
+export declare const createRole: (id: string, name: string, roles: TRolesDict) => TRolesDict;
+export declare const saveRole: (role: TRole, roles: TRolesDict) => TRolesDict;

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

@@ -1,5 +1,6 @@
-declare const _default: import('redux').Reducer<import('@ws-ui/shared').IRolesState>;
+declare const _default: import('redux').Reducer<import('./types').IRolesState>;
 export default _default;
 export * from './reducer';
 export * from './thunks';
+export * from './types';
 export * from './adapter';

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

@@ -1,5 +1,5 @@
 import { PayloadAction } from '@reduxjs/toolkit';
-import { IRolesState, TById, TRawData, TRolesDict } from '@ws-ui/shared';
+import { IRolesState, TById, TRawData, TRolesDict } from './types';
 declare const stateSlice: import('@reduxjs/toolkit').Slice<IRolesState, {
     updatePrivileges: (state: import('immer/dist/internal').WritableDraft<IRolesState>, action: PayloadAction<TById>) => void;
     updateRoles: (state: import('immer/dist/internal').WritableDraft<IRolesState>, action: PayloadAction<TRolesDict>) => void;

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

@@ -1,5 +1,6 @@
-import { ITabFlags, IFileContentResponse, ISetFileContentResponse, ISanitized } from '@ws-ui/shared';
+import { ITabFlags, IFileContentResponse, ISetFileContentResponse } from '@ws-ui/shared';
 import { AppState } from '..';
+import { ISanitized } from './types';
 export declare const fetchRoles: import('@reduxjs/toolkit').AsyncThunk<IFileContentResponse<ISanitized>, void, {
     state: AppState;
     rejectValue: string;

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

@@ -0,0 +1,108 @@
+import { ITabFlags } from '@ws-ui/shared';
+export type TRawData = Partial<{
+    privileges: IPrivilege[];
+    roles: IRole[];
+    permissions: Partial<{
+        allowed: IPermission[];
+    }>;
+    forceLogin: boolean;
+    restrictedByDefault: boolean;
+}>;
+export type TPermissionOption = Pick<IPermission, 'applyTo' | 'type' | 'subType'>;
+export type TAction = 'read' | 'create' | 'update' | 'drop' | 'execute' | 'promote';
+export type IRolesState = ISanitized & {
+    flags: ITabFlags;
+    date?: string;
+    selectedTab: 'privileges' | 'roles';
+    initialState?: {
+        roles: TRolesDict;
+        privileges: TById;
+        forceLogin?: boolean;
+        restrictedByDefault?: boolean;
+    };
+};
+export interface IPrivilege {
+    id?: string;
+    privilege: string;
+    includes?: string[];
+}
+export interface IRole {
+    id?: string;
+    role: string;
+    privileges?: string[];
+}
+export type TRole = Required<IRole>;
+export declare enum EPermissionType {
+    DATACLASS = "dataclass",
+    METHOD = "method",
+    ATTRIBUTE = "attribute",
+    DATASTORE = "datastore",
+    SINGLETON = "singleton",
+    SINGLETON_METHOD = "singletonMethod"
+}
+export declare enum ESubPermissionType {
+    DS_METHOD = "dsMethod",
+    DATACLASS_METHOD = "dataclassMethod",
+    ENTITY_METHOD = "entityMethod",
+    ENTITY_SEL_METHOD = "entityselMethod"
+}
+export interface IPermission {
+    applyTo: string;
+    type: EPermissionType | ESubPermissionType;
+    subType?: ESubPermissionType;
+    read?: string | string[];
+    create?: string | string[];
+    update?: string | string[];
+    drop?: string | string[];
+    execute?: string | string[];
+    promote?: string | string[];
+}
+export interface IResourcesByPermission {
+    [id: string]: {
+        applyTo: IPermission['applyTo'];
+        type: IPermission['type'];
+        subType?: IPermission['subType'];
+    }[];
+}
+/**
+ * Sanitized data
+ */
+export interface ISanitized {
+    privileges: TById;
+    roles: TRolesDict;
+    forceLogin?: boolean;
+    restrictedByDefault?: boolean;
+}
+export interface IResourcePermission {
+    name: TAction;
+    from: string[];
+    checked?: boolean;
+    info?: string;
+}
+export interface IResource {
+    resource: string;
+    type: EPermissionType | ESubPermissionType;
+    subType?: ESubPermissionType;
+    permissions: IResourcePermission[];
+    exists?: boolean;
+}
+export type TSanitizedPrivilege = Required<IPrivilege> & {
+    parents: string[];
+    resources: IResource[];
+};
+export type TById = {
+    [id: string]: TSanitizedPrivilege;
+};
+export type TRolesDict = {
+    [id: string]: TRole;
+};
+export interface ILink {
+    source: string;
+    target: string;
+}
+export interface IGraphData {
+    selected: string;
+    parents: string[][];
+    children: string[][];
+    links: ILink[];
+}

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

@@ -1,4 +1,4 @@
-declare const _default: import('redux').Reducer<import('@ws-ui/shared').ISettingsState>;
+declare const _default: import('redux').Reducer<import('./reducer').ISettingsState>;
 export default _default;
 export * from './reducer';
 export * from './thunks';

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

@@ -1,6 +1,18 @@
 import { PayloadAction } from '@reduxjs/toolkit';
-import { ISettingsState, TSettingPath } from '@ws-ui/shared';
-import { TSetSettingPayload } from './types';
+import { IAppSettingsResponse } from '@ws-ui/shared';
+import { TSetSettingPayload, TSettingPath } from './types';
+export interface ISettingsState {
+    session: {
+        [key: string]: unknown;
+    };
+    project: {
+        [key: string]: unknown;
+    };
+    server: IAppSettingsResponse;
+    welcometour: {
+        [key: string]: unknown;
+    };
+}
 declare const stateSlice: import('@reduxjs/toolkit').Slice<ISettingsState, {
     setSetting(state: ISettingsState, action: TSetSettingPayload): void;
     setSettings(state: ISettingsState, action: PayloadAction<{
@@ -14,7 +26,11 @@ declare const stateSlice: import('@reduxjs/toolkit').Slice<ISettingsState, {
         };
     }>): void;
 }, "settings">;
-export declare const setSetting: import('@reduxjs/toolkit').ActionCreatorWithPayload<import('@ws-ui/shared').ISetSettingPayload, "settings/setSetting">, setSettings: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+export declare const setSetting: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
+    path: TSettingPath;
+    settingsKey: string;
+    value: any;
+}, "settings/setSetting">, setSettings: import('@reduxjs/toolkit').ActionCreatorWithPayload<{
     path: TSettingPath;
     value: any;
 }, "settings/setSettings">, setSettingsAsText: import('@reduxjs/toolkit').ActionCreatorWithPayload<{

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

@@ -1,3 +1,7 @@
 import { PayloadAction } from '@reduxjs/toolkit';
-import { ISetSettingPayload } from '@ws-ui/shared';
-export type TSetSettingPayload = PayloadAction<ISetSettingPayload>;
+export type TSettingPath = 'session' | 'project' | 'welcometour';
+export type TSetSettingPayload = PayloadAction<{
+    path: TSettingPath;
+    settingsKey: string;
+    value: any;
+}>;

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

@@ -1,8 +1,8 @@
 export declare const selectAllTasks: ((state: import('redux').EmptyObject & {
     root: import('..').IRootState;
-    explorer: import('@ws-ui/shared').ITreeItem[];
+    explorer: import('..').ITreeItem[];
     debugger: import('..').IDebuggerState;
-    settings: import('@ws-ui/shared').ISettingsState;
+    settings: import('..').ISettingsState;
     catalog: {
         state: "loading";
     } | {
@@ -12,7 +12,7 @@ export declare const selectAllTasks: ((state: import('redux').EmptyObject & {
         state: "error";
         error: string;
     };
-    roles: import('@ws-ui/shared').IRolesState;
+    roles: import('..').IRolesState;
     sharedDatasources: import('..').ISharedDatasourcesState;
     sharedAppEvents: import('..').ISharedAppEventsState;
     savedConditions: import('..').ISavedConditionsState;

package/dist/modules/webforms/datasources.adapter.d.ts

@@ -1,8 +1,8 @@
 export declare const listDsNamespaces: import('lodash').CurriedFunction2<string, import('redux').CombinedState<{
     root: import('..').IRootState;
-    explorer: import('@ws-ui/shared').ITreeItem[];
+    explorer: import('..').ITreeItem[];
     debugger: import('..').IDebuggerState;
-    settings: import('@ws-ui/shared').ISettingsState;
+    settings: import('..').ISettingsState;
     catalog: {
         state: "loading";
     } | {
@@ -12,7 +12,7 @@ export declare const listDsNamespaces: import('lodash').CurriedFunction2<string,
         state: "error";
         error: string;
     };
-    roles: import('@ws-ui/shared').IRolesState;
+    roles: import('..').IRolesState;
     sharedDatasources: import('..').ISharedDatasourcesState;
     sharedAppEvents: import('..').ISharedAppEventsState;
     savedConditions: import('..').ISavedConditionsState;