@ws-ui/store 0.1.0 → 0.1.2

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

@@ -0,0 +1,13 @@
+declare const _default: import("redux").Reducer<{
+    state: "loading";
+} | {
+    state: "loaded";
+    model: datasources.IEnhancedCatalog;
+} | {
+    state: "error";
+    error: string;
+}>;
+export default _default;
+export * from './reducer';
+export * from './thunks';
+export * from './types';

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

@@ -0,0 +1,20 @@
+/// <reference types="@ws-ui/shared/dist/declarations/datasources/datasource" />
+export type ICatalogState = {
+    state: 'loading';
+} | {
+    state: 'loaded';
+    model: datasources.IEnhancedCatalog;
+} | {
+    state: 'error';
+    error: string;
+};
+declare const stateSlice: import("@reduxjs/toolkit").Slice<{
+    state: 'loading';
+} | {
+    state: 'loaded';
+    model: datasources.IEnhancedCatalog;
+} | {
+    state: 'error';
+    error: string;
+}, {}, "catalog">;
+export default stateSlice;

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

@@ -0,0 +1,4 @@
+/// <reference types="@ws-ui/shared/dist/declarations/datasources/datasource" />
+export declare const fetchCatalog: import("@reduxjs/toolkit").AsyncThunk<datasources.IEnhancedCatalog, void, {
+    rejectValue: string;
+}>;

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

@@ -0,0 +1 @@
+export {};

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

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

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

@@ -0,0 +1,121 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { IAddBreakpointAction, IAddExpressionAction, IAddSessionAction, IBreakpointDecoration, IClearBreakpointsAction, IDebuggerData, IDebuggerSession, IRemoveBreakpointAction, IRemoveExpressionAction, IRemoveSessionAction, IRenameExpressionAction, ISaveExpressionsAction, ISetActiveLineAction, ISetBreakpointsAction, ISetExpressionAction, ISetSourceContentAction, ISetCallChainVariablesAction, IUpdateSessionAction, ISetExpressionVariablesAction, EDebuggerState, IDebuggerMeta, ISetDebuggerMetaAction, EDebuggerErrorType, IExpression, IBreakpoint, IRemoveAllExpressionsAction, IUpdateExpressionAtAction } from './types';
+export interface IDebuggerState {
+    meta: IDebuggerMeta;
+    list: IDebuggerData[];
+    sessions: IDebuggerSession[];
+    expressions: IExpression[];
+}
+declare const stateSlice: import("@reduxjs/toolkit").Slice<IDebuggerState, {
+    addBreakpointDecoration(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IAddBreakpointAction): void;
+    removeBreakpointDecoration(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IRemoveBreakpointAction): void;
+    setBreakpointsDecoration(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: ISetBreakpointsAction): void;
+    clearBreakpoints(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IClearBreakpointsAction): void;
+    setActiveLine(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: ISetActiveLineAction): void;
+    addExpression(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IAddExpressionAction): void;
+    removeExpression(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IRemoveExpressionAction): void;
+    removeAllExpressions(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IRemoveAllExpressionsAction): void;
+    renameExpression(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IRenameExpressionAction): void;
+    setExpression(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: ISetExpressionAction): void;
+    updateExpressionAt(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IUpdateExpressionAtAction): void;
+    saveExpressions(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: ISaveExpressionsAction): void;
+    addSession(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IAddSessionAction): void;
+    updateSession(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IUpdateSessionAction): void;
+    removeSession(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: IRemoveSessionAction): void;
+    removeSessionByIndex(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: PayloadAction<number>): void;
+    setSessions(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: PayloadAction<IDebuggerSession[]>): void;
+    setCallChainVariables(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: ISetCallChainVariablesAction): void;
+    setExpressionVariables(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: ISetExpressionVariablesAction): void;
+    setSourceContent(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: ISetSourceContentAction): void;
+    setDebuggerMeta(state: import("immer/dist/internal.js").WritableDraft<IDebuggerState>, action: ISetDebuggerMetaAction): void;
+}, "debugger">;
+export declare const addBreakpointDecoration: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    filePath: string;
+    fileType: import("./types").IDebuggerFileType;
+    methodName: string;
+    className?: string | undefined;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+    source: import("@ws-ui/shared").ISource;
+    breakpoint: IBreakpointDecoration;
+}, string>, removeBreakpointDecoration: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    filePath: string;
+    methodName: string;
+    line: number;
+    offset?: number | undefined;
+    type?: "draft" | "saved" | undefined;
+}, string>, setBreakpointsDecoration: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    filePath: string;
+    fileType: import("./types").IDebuggerFileType;
+    methodName: string;
+    className?: string | undefined;
+    ext: import("@ws-ui/shared").DebuggerFileExtension;
+    source: import("@ws-ui/shared").ISource;
+    breakpoints: IBreakpoint[];
+    offset?: number | undefined;
+    type?: "draft" | "saved" | undefined;
+    clearDraft?: boolean | undefined;
+}, string>, clearBreakpoints: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    filePath: string;
+    type?: "draft" | "saved" | undefined;
+}, string>, setActiveLine: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    line: number;
+    highlight?: boolean | undefined;
+}, string>, addExpression: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    label: string;
+    save?: boolean | undefined;
+}, string>, renameExpression: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    index: number;
+    replacement: string;
+    save?: boolean | undefined;
+}, string>, removeExpression: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    index: number;
+    save?: boolean | undefined;
+}, string>, removeAllExpressions: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    save?: boolean | undefined;
+}, string>, setExpression: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    expression: IExpression & {
+        index: number;
+    };
+}, string>, updateExpressionAt: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    index: number;
+    value: string | undefined;
+}, string>, saveExpressions: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    expressions: IExpression[];
+}, string>, addSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    channelId: number;
+    stackFrames: import("./types").IStackFrame[];
+    exceptions?: import("./types").IException[] | undefined;
+}, string>, updateSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    changes: Partial<IDebuggerSession>;
+}, string>, removeSession: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+}, string>, removeSessionByIndex: import("@reduxjs/toolkit").ActionCreatorWithPayload<number, string>, setSessions: import("@reduxjs/toolkit").ActionCreatorWithPayload<IDebuggerSession[], string>, setCallChainVariables: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    frameId: number;
+    variables: import("./types").IVariable[];
+}, string>, setExpressionVariables: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    variablesReference: number;
+    variables: import("./types").IVariable[];
+}, string>, setSourceContent: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    threadId: number;
+    content: string;
+}, string>, setDebuggerMeta: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    state: EDebuggerState;
+    error?: Partial<{
+        code: number | null;
+        reason: string;
+        type: EDebuggerErrorType;
+    }> | undefined;
+    override?: boolean | undefined;
+}, string>;
+export default stateSlice;

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

@@ -0,0 +1,11 @@
+import { AppState } from '../../modules';
+export declare const wipeDebuggerSessions: import("@reduxjs/toolkit").AsyncThunk<void, void, {
+    state: AppState;
+}>;
+export declare const removeDebuggerSessionsNotIn: import("@reduxjs/toolkit").AsyncThunk<{
+    staleThreadIds: number[];
+}, {
+    threadIds: number[];
+}, {
+    state: AppState;
+}>;

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

@@ -0,0 +1,226 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { DebugProtocol } from 'vscode-debugprotocol';
+import { DebuggerFileExtension, FileFolderType, ICodeDescriptor, ISource } from '@ws-ui/shared';
+export interface IExpression {
+    label: string;
+    result?: string;
+    nakedResult?: string;
+    variablesReference?: number;
+    presentationHint?: IVariablePresentationHint;
+}
+export interface IBreakpoint extends DebugProtocol.SourceBreakpoint {
+    verified?: boolean;
+}
+export type IDebuggerFileType = FileFolderType.METHOD | FileFolderType.CLASS;
+interface IBreakpointsData {
+    locations: IBreakpoint[];
+    offset?: number;
+}
+export type IDebuggerData = {
+    filePath: string;
+    fileType: IDebuggerFileType;
+    methodName: string;
+    className?: string;
+    ext: DebuggerFileExtension;
+    source: ISource;
+    breakpoints: {
+        draft: IBreakpointsData;
+        saved: IBreakpointsData;
+    };
+};
+export type BreakpointType = keyof IDebuggerData['breakpoints'];
+export interface IVariablePresentationHint extends DebugProtocol.VariablePresentationHint {
+    iconID: number;
+}
+export interface IVariable extends DebugProtocol.Variable {
+    nakedValue: string;
+    presentationHint?: IVariablePresentationHint;
+}
+export interface IStackFrame extends DebugProtocol.StackFrame {
+    source: DebugProtocol.Source & {
+        codeDescriptorInfo?: ICodeDescriptor;
+        content?: string;
+    };
+    offset: number;
+    lineIndex: number;
+}
+export interface ICallChainVariable {
+    frameId: number;
+    items: IVariable[];
+}
+export interface IExpressionVariable {
+    variablesReference: number;
+    items: IVariable[];
+}
+export type ISessionVariable = ICallChainVariable | IExpressionVariable;
+export interface IException {
+    errMess: string;
+    location: string;
+    locationLine: number;
+    formula: string;
+    formulaError_begin: number;
+    formulaError_end: number;
+    formulaError_indent?: number;
+    errorIdentifier: string;
+}
+export interface IFdException extends IException {
+    locationLineIndex: number;
+}
+export interface IDebuggerSession {
+    tabPath: string;
+    threadId: number;
+    channelId: number;
+    stackFrames: IStackFrame[];
+    currentStackFrame: IStackFrame;
+    exceptions: IException[];
+    expressions: IExpression[];
+    highlightedLines: {
+        start: number;
+        end?: number;
+    } | null;
+    activeLine: number | null;
+    variables: {
+        callchain: ICallChainVariable[];
+        expressions: IExpressionVariable[];
+    };
+    stopped?: boolean;
+}
+export type DebuggerVariablesKey = keyof IDebuggerSession['variables'];
+export interface IBreakpointDecoration {
+    line: number;
+    offset?: number;
+    type?: BreakpointType;
+}
+export type IAddBreakpointAction = PayloadAction<{
+    filePath: string;
+    fileType: IDebuggerFileType;
+    methodName: string;
+    className?: string;
+    ext: DebuggerFileExtension;
+    source: ISource;
+    breakpoint: IBreakpointDecoration;
+}>;
+export type IRemoveBreakpointAction = PayloadAction<{
+    filePath: string;
+    methodName: string;
+    line: number;
+    offset?: number;
+    type?: BreakpointType;
+}>;
+export type ISetBreakpointsAction = PayloadAction<{
+    filePath: string;
+    fileType: IDebuggerFileType;
+    methodName: string;
+    className?: string;
+    ext: DebuggerFileExtension;
+    source: ISource;
+    breakpoints: IBreakpoint[];
+    offset?: number;
+    type?: BreakpointType;
+    clearDraft?: boolean;
+}>;
+export type IClearBreakpointsAction = PayloadAction<{
+    filePath: string;
+    type?: BreakpointType;
+}>;
+export type ISetActiveLineAction = PayloadAction<{
+    threadId: number;
+    line: number;
+    highlight?: boolean;
+}>;
+export type IAddExpressionAction = PayloadAction<{
+    threadId: number;
+    label: string;
+    save?: boolean;
+}>;
+export type IRemoveExpressionAction = PayloadAction<{
+    threadId: number;
+    index: number;
+    save?: boolean;
+}>;
+export type IRemoveAllExpressionsAction = PayloadAction<{
+    threadId: number;
+    save?: boolean;
+}>;
+export type IRenameExpressionAction = PayloadAction<{
+    threadId: number;
+    index: number;
+    replacement: string;
+    save?: boolean;
+}>;
+export type ISetExpressionAction = PayloadAction<{
+    threadId: number;
+    expression: IExpression & {
+        index: number;
+    };
+}>;
+export type IUpdateExpressionAtAction = PayloadAction<{
+    threadId: number;
+    index: number;
+    value: IExpression['result'];
+}>;
+export type ISaveExpressionsAction = PayloadAction<{
+    expressions: IExpression[];
+}>;
+export type IAddSessionAction = PayloadAction<{
+    threadId: number;
+    channelId: number;
+    stackFrames: IStackFrame[];
+    exceptions?: IException[];
+}>;
+export type IUpdateSessionAction = PayloadAction<{
+    threadId: number;
+    changes: Partial<IDebuggerSession>;
+}>;
+export type IRemoveSessionAction = PayloadAction<{
+    threadId: number;
+}>;
+export type ISetCallChainVariablesAction = PayloadAction<{
+    threadId: number;
+    frameId: number;
+    variables: IVariable[];
+}>;
+export type ISetExpressionVariablesAction = PayloadAction<{
+    threadId: number;
+    variablesReference: number;
+    variables: IVariable[];
+}>;
+export type ISetSourceContentAction = PayloadAction<{
+    threadId: number;
+    content: string;
+}>;
+export declare enum ExpressionIndex {
+    First = 0,
+    Last = -1
+}
+export declare enum EDebuggerState {
+    ATTACHED = "attached",
+    DETACHED = "detached",
+    ERROR = "error"
+}
+export declare enum EDebuggerErrorType {
+    SOCKET_ERROR = "socket-error",
+    SOCKET_CLOSURE = "socket-closure"
+}
+export declare enum EDebuggerErrorReason {
+    NOT_STARTED = "remote debugger not started",
+    ALREADY_IN_USE = "already in use",
+    TIMEOUT = "timeout"
+}
+type IDebuggerError = Partial<{
+    code: number | null;
+    reason: string;
+    type: EDebuggerErrorType;
+}>;
+export interface IDebuggerMeta {
+    state: EDebuggerState;
+    error?: IDebuggerError & {
+        time: number;
+    };
+}
+export type ISetDebuggerMetaAction = PayloadAction<{
+    state: EDebuggerState;
+    error?: IDebuggerError;
+    override?: boolean;
+}>;
+export {};

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

@@ -0,0 +1,3 @@
+import { ISource } from '@ws-ui/shared';
+export declare function getDebuggerTabPath(threadId: number): string;
+export declare function getDebuggerTabName(threadId: number, source: ISource): string;

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

@@ -0,0 +1,6 @@
+declare const _default: import("redux").Reducer<import("immer/dist/internal.js").WritableDraft<import("./types").ITreeItem>[]>;
+export default _default;
+export * from './reducer';
+export * from './thunks';
+export * from './types';
+export * from './utils';

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

@@ -0,0 +1,38 @@
+import { PayloadAction } from '@reduxjs/toolkit';
+import { ITreeItem } from './types';
+export declare const findNodeByPath: (tree: ITreeItem[], path: string) => ITreeItem | null;
+declare const stateSlice: import("@reduxjs/toolkit").Slice<import("immer/dist/internal.js").WritableDraft<ITreeItem>[], {
+    toggleExpandFolder: (state: import("immer/dist/internal.js").WritableDraft<ITreeItem>[], action: PayloadAction<ITreeItem>) => import("immer/dist/internal.js").WritableDraft<ITreeItem>[];
+    expandFolder: (state: import("immer/dist/internal.js").WritableDraft<ITreeItem>[], action: PayloadAction<ITreeItem>) => import("immer/dist/internal.js").WritableDraft<ITreeItem>[];
+    openAddFileInput: (state: import("immer/dist/internal.js").WritableDraft<ITreeItem>[], action: PayloadAction<ITreeItem>) => ITreeItem[];
+    addNewFile: (state: import("immer/dist/internal.js").WritableDraft<ITreeItem>[], action: PayloadAction<{
+        parent: ITreeItem;
+        child: ITreeItem;
+    }>) => ITreeItem[];
+    removeFile: (state: import("immer/dist/internal.js").WritableDraft<ITreeItem>[], action: PayloadAction<{
+        parent: ITreeItem;
+        child: ITreeItem;
+    }>) => ITreeItem[];
+    refreshFile: (state: import("immer/dist/internal.js").WritableDraft<ITreeItem>[], action: PayloadAction<{
+        parent: ITreeItem;
+        child: ITreeItem;
+    }>) => ITreeItem[];
+    setFolderChildren: (state: import("immer/dist/internal.js").WritableDraft<ITreeItem>[], action: PayloadAction<{
+        parentPath: string;
+        children: ITreeItem[];
+    }>) => ITreeItem[];
+}, "explorer">;
+export declare const toggleExpandFolder: import("@reduxjs/toolkit").ActionCreatorWithPayload<ITreeItem, string>, expandFolder: import("@reduxjs/toolkit").ActionCreatorWithPayload<ITreeItem, string>, openAddFileInput: import("@reduxjs/toolkit").ActionCreatorWithPayload<ITreeItem, string>, addNewFile: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    parent: ITreeItem;
+    child: ITreeItem;
+}, string>, refreshFile: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    parent: ITreeItem;
+    child: ITreeItem;
+}, string>, removeFile: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    parent: ITreeItem;
+    child: ITreeItem;
+}, string>, setFolderChildren: import("@reduxjs/toolkit").ActionCreatorWithPayload<{
+    parentPath: string;
+    children: ITreeItem[];
+}, string>;
+export default stateSlice;