@vnejs/plugins.scenario.point_and_click 0.2.1 → 0.2.2

package/dist/index.js

@@ -1,13 +1,21 @@
 import "@vnejs/contracts.scenario.point_and_click";
 import { regPlugin } from "@vnejs/shared";
 import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.scenario.point_and_click";
-import { PointAndClick } from "./modules/point_and_click.js";
+import { PointAndClickEmit } from "./modules/emit.js";
 import { PointAndClickExec } from "./modules/exec.js";
+import { PointAndClickLogs } from "./modules/logs.js";
+import { PointAndClickOption } from "./modules/option.js";
+import { PointAndClickState } from "./modules/point_and_click.js";
 import { PointAndClickScenario } from "./modules/scenario.block.js";
 import { PointAndClickScenarioModule } from "./modules/scenario.module.js";
 import { PointAndClickScenarioOption } from "./modules/scenario.option.js";
+import { PointAndClickSkip } from "./modules/skip.js";
 regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
-    PointAndClick,
+    PointAndClickState,
+    PointAndClickEmit,
+    PointAndClickOption,
+    PointAndClickSkip,
+    PointAndClickLogs,
     PointAndClickExec,
     PointAndClickScenario,
     PointAndClickScenarioModule,

package/dist/modules/emit.d.ts

@@ -0,0 +1,9 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickEmitPayload, PointAndClickOption } from "../utils/point-and-click.js";
+export declare class PointAndClickEmit extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams> {
+    name: string;
+    subscribe: () => void;
+    onEmit: ({ options, args }?: PointAndClickEmitPayload) => Promise<unknown[] | undefined>;
+    mapOptions: ({ optionLine: { line, args }, index }: NonNullable<PointAndClickEmitPayload["options"]>[number]) => Promise<PointAndClickOption>;
+}

package/dist/modules/emit.js

@@ -0,0 +1,27 @@
+import { splitLineKeywords, tokenizeExecLine } from "@vnejs/helpers";
+import { ModuleCore } from "@vnejs/module.core";
+export class PointAndClickEmit extends ModuleCore {
+    name = "point_and_click.emit";
+    subscribe = () => {
+        this.on(this.EVENTS.POINT_AND_CLICK.EMIT, this.onEmit);
+    };
+    onEmit = async ({ options = [], args = {} } = {}) => {
+        const mappedOptions = await Promise.all(options.map(this.mapOptions));
+        if (!mappedOptions.length || mappedOptions.every((option) => option.hided)) {
+            return this.emit(this.EVENTS.POINT_AND_CLICK.SKIP);
+        }
+        await this.emit(this.EVENTS.POINT_AND_CLICK.STATE_UPDATE, { isShow: true, options: mappedOptions, args });
+        return this.emit(this.EVENTS.POINT_AND_CLICK.SHOW);
+    };
+    mapOptions = async ({ optionLine: { line = "", args = {} }, index }) => {
+        const [, , icon, x, y] = tokenizeExecLine(line).map(String);
+        const result = { index, coords: [x, y].map(Number), icon, ...args };
+        await Promise.all(Object.keys(args).map(async (key) => {
+            if (typeof args[key] !== "string" || !args[key].startsWith(this.CONST.SCENARIO.LINE_PREFIXES.MODULE))
+                return;
+            const { line: execLine = "", module = "", keywords = [] } = splitLineKeywords(String(args[key]));
+            result[key] = await this.emitOne(this.EVENTS.POINT_AND_CLICK.EXEC_GET, { line: execLine, module, keywords });
+        }));
+        return result;
+    };
+}

package/dist/modules/logs.d.ts

@@ -0,0 +1,12 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickEmitPayload, PointAndClickOptionPayload } from "../utils/point-and-click.js";
+export declare class PointAndClickLogs extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams> {
+    name: string;
+    subscribe: () => void;
+    onEmit: ({ options, args }?: PointAndClickEmitPayload) => undefined;
+    onOption: ({ index }?: PointAndClickOptionPayload) => undefined;
+    onSkip: () => void;
+    onShow: () => undefined;
+    onHide: () => undefined;
+}

package/dist/modules/logs.js

@@ -0,0 +1,19 @@
+import { ModuleCore } from "@vnejs/module.core";
+export class PointAndClickLogs extends ModuleCore {
+    name = "point_and_click.logs";
+    subscribe = () => {
+        this.on(this.EVENTS.POINT_AND_CLICK.EMIT, this.onEmit, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+        this.on(this.EVENTS.POINT_AND_CLICK.OPTION, this.onOption, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+        this.on(this.EVENTS.POINT_AND_CLICK.SKIP, this.onSkip, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+        this.on(this.EVENTS.POINT_AND_CLICK.SHOW, this.onShow, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+        this.on(this.EVENTS.POINT_AND_CLICK.HIDE, this.onHide, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+    };
+    onEmit = ({ options = [], args = {} } = {}) => void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.EMIT, options, args });
+    onOption = ({ index = 0 } = {}) => void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.OPTION, index });
+    onSkip = () => {
+        const { curLine = 0, label } = this.globalState.scenario;
+        void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.SKIP, label, from: curLine });
+    };
+    onShow = () => void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.SHOW });
+    onHide = () => void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.HIDE });
+}

package/dist/modules/option.d.ts

@@ -0,0 +1,8 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickOptionPayload } from "../utils/point-and-click.js";
+export declare class PointAndClickOption extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams> {
+    name: string;
+    subscribe: () => void;
+    onOption: ({ index }?: PointAndClickOptionPayload) => Promise<void>;
+}

package/dist/modules/option.js

@@ -0,0 +1,17 @@
+import { ModuleCore } from "@vnejs/module.core";
+export class PointAndClickOption extends ModuleCore {
+    name = "point_and_click.option";
+    subscribe = () => {
+        this.on(this.EVENTS.POINT_AND_CLICK.OPTION, this.onOption);
+    };
+    onOption = async ({ index = 0 } = {}) => {
+        await this.emit(this.EVENTS.POINT_AND_CLICK.HIDE);
+        this.globalState.scenario.curLine = this.globalState.point_and_click.options[index].index + 1;
+        await this.emit(this.EVENTS.POINT_AND_CLICK.STATE_UPDATE, {
+            options: [],
+            args: {},
+            isShow: false,
+        });
+        this.emitNext();
+    };
+}

package/dist/modules/point_and_click.d.ts

@@ -1,14 +1,11 @@
 import { ModuleCore, type ModuleGlobalStateRegistry } from "@vnejs/module.core";
 import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
-import type { PointAndClickEmitPayload, PointAndClickOption, PointAndClickOptionPayload, PointAndClickPluginModelState } from "../utils/point-and-click.js";
-export declare class PointAndClick extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams, PointAndClickPluginModelState> {
+import type { PointAndClickPluginModelState } from "../utils/point-and-click.js";
+export declare class PointAndClickState extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams, PointAndClickPluginModelState> {
     name: string;
     subscribe: () => void;
-    onEmit: ({ options, args }?: PointAndClickEmitPayload) => Promise<unknown[] | undefined>;
-    onSkip: () => Promise<undefined>;
-    onOption: ({ index }?: PointAndClickOptionPayload) => Promise<void>;
+    onStateUpdate: (state?: Partial<PointAndClickPluginModelState>) => void;
     onStateSet: (payload: ModuleGlobalStateRegistry) => Promise<unknown[] | undefined>;
     onStateClear: () => Promise<unknown[]> | undefined;
-    mapOptions: ({ optionLine: { line, args }, index }: NonNullable<PointAndClickEmitPayload["options"]>[number]) => Promise<PointAndClickOption>;
     getDefaultState: () => PointAndClickPluginModelState;
 }

package/dist/modules/point_and_click.js

@@ -1,65 +1,22 @@
-import { splitLineKeywords, tokenizeExecLine } from "@vnejs/helpers";
 import { ModuleCore } from "@vnejs/module.core";
-export class PointAndClick extends ModuleCore {
+export class PointAndClickState extends ModuleCore {
     name = "point_and_click";
     subscribe = () => {
-        this.on(this.EVENTS.POINT_AND_CLICK.EMIT, this.onEmit);
-        this.on(this.EVENTS.POINT_AND_CLICK.OPTION, this.onOption);
-        this.on(this.EVENTS.POINT_AND_CLICK.SKIP, this.onSkip);
+        this.on(this.EVENTS.POINT_AND_CLICK.STATE_UPDATE, this.onStateUpdate);
         this.on(this.EVENTS.STATE.SET, this.onStateSet);
         this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
     };
-    onEmit = async ({ options = [], args = {} } = {}) => {
-        this.emitLog({ action: "emit", options, args });
-        const mappedOptions = await Promise.all(options.map(this.mapOptions));
-        if (!mappedOptions.length || mappedOptions.every((option) => option.hided)) {
-            return this.emit(this.EVENTS.POINT_AND_CLICK.SKIP);
-        }
-        this.updateState({ isShow: true, options: mappedOptions, args });
-        return this.emit(this.EVENTS.POINT_AND_CLICK.OPENED);
-    };
-    onSkip = async () => {
-        const { curLine = 0, label } = this.globalState.scenario;
-        const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label }));
-        const parentIndent = lines[curLine]?.indent ?? 0;
-        let indexShift = 1;
-        let curLineObj = lines[curLine + indexShift];
-        while (curLineObj && (curLineObj.indent ?? 0) > parentIndent) {
-            indexShift++;
-            curLineObj = lines[curLine + indexShift];
-        }
-        this.emitLog({ action: "skip", label, from: curLine, to: curLine + indexShift });
-        this.globalState.scenario.curLine = curLine + indexShift;
-        return this.emitNext();
-    };
-    onOption = async ({ index = 0 } = {}) => {
-        this.emitLog({ action: "point_and_click", index });
-        await this.emit(this.EVENTS.POINT_AND_CLICK.CLOSED);
-        this.globalState.scenario.curLine = this.state.options[index].index + 1;
-        this.setDefaultState();
-        this.emitNext();
-    };
+    onStateUpdate = (state = {}) => this.updateState(state);
     onStateSet = async (payload) => {
         const moduleState = this.getStateSlice(payload);
         if (!moduleState || this.state.isShow === moduleState.isShow)
             return;
         const clonedState = await this.emitClone(moduleState);
         this.setState(clonedState);
-        return this.emit(clonedState.isShow ? this.EVENTS.POINT_AND_CLICK.OPENED : this.EVENTS.POINT_AND_CLICK.CLOSED, {
+        return this.emit(clonedState.isShow ? this.EVENTS.POINT_AND_CLICK.SHOW : this.EVENTS.POINT_AND_CLICK.HIDE, {
             isForce: true,
         });
     };
-    onStateClear = () => this.emit(this.EVENTS.POINT_AND_CLICK.CLOSED, { isForce: true });
-    mapOptions = async ({ optionLine: { line = "", args = {} }, index }) => {
-        const [, , icon, x, y] = tokenizeExecLine(line).map(String);
-        const result = { index, coords: [x, y].map(Number), icon, ...args };
-        await Promise.all(Object.keys(args).map(async (key) => {
-            if (typeof args[key] !== "string" || !args[key].startsWith(this.CONST.SCENARIO.LINE_PREFIXES.MODULE))
-                return;
-            const { line: execLine = "", module = "", keywords = [] } = splitLineKeywords(String(args[key]));
-            result[key] = await this.emitOne(this.EVENTS.POINT_AND_CLICK.EXEC_GET, { line: execLine, module, keywords });
-        }));
-        return result;
-    };
+    onStateClear = () => this.emit(this.EVENTS.POINT_AND_CLICK.HIDE, { isForce: true });
     getDefaultState = () => ({ options: [], args: {}, isShow: false });
 }

package/dist/modules/scenario.module.js

@@ -16,7 +16,7 @@ export class PointAndClickScenarioModule extends ModuleCore {
             this.globalState.scenario.curLine = curLine + 1;
             return this.emitNext();
         }
-        this.emitLog({ action: this.CONST.POINT_AND_CLICK.EXEC_ACTIONS.REPEAT, label, from: curLine, to: targetIndex });
+        this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.REPEAT, label, from: curLine, to: targetIndex });
         this.globalState.scenario.curLine = targetIndex;
         return this.emitNext();
     };

package/dist/modules/skip.d.ts

@@ -0,0 +1,7 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+export declare class PointAndClickSkip extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams> {
+    name: string;
+    subscribe: () => void;
+    onSkip: () => Promise<undefined>;
+}

package/dist/modules/skip.js

@@ -0,0 +1,20 @@
+import { ModuleCore } from "@vnejs/module.core";
+export class PointAndClickSkip extends ModuleCore {
+    name = "point_and_click.skip";
+    subscribe = () => {
+        this.on(this.EVENTS.POINT_AND_CLICK.SKIP, this.onSkip);
+    };
+    onSkip = async () => {
+        const { curLine = 0, label } = this.globalState.scenario;
+        const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label }));
+        const parentIndent = lines[curLine]?.indent ?? 0;
+        let indexShift = 1;
+        let curLineObj = lines[curLine + indexShift];
+        while (curLineObj && (curLineObj.indent ?? 0) > parentIndent) {
+            indexShift++;
+            curLineObj = lines[curLine + indexShift];
+        }
+        this.globalState.scenario.curLine = curLine + indexShift;
+        return this.emitNext();
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/plugins.scenario.point_and_click",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -3,14 +3,22 @@ import "@vnejs/contracts.scenario.point_and_click";
 import { regPlugin } from "@vnejs/shared";
 import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.scenario.point_and_click";
 
-import { PointAndClick } from "./modules/point_and_click.js";
+import { PointAndClickEmit } from "./modules/emit.js";
 import { PointAndClickExec } from "./modules/exec.js";
+import { PointAndClickLogs } from "./modules/logs.js";
+import { PointAndClickOption } from "./modules/option.js";
+import { PointAndClickState } from "./modules/point_and_click.js";
 import { PointAndClickScenario } from "./modules/scenario.block.js";
 import { PointAndClickScenarioModule } from "./modules/scenario.module.js";
 import { PointAndClickScenarioOption } from "./modules/scenario.option.js";
+import { PointAndClickSkip } from "./modules/skip.js";
 
 regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
-  PointAndClick,
+  PointAndClickState,
+  PointAndClickEmit,
+  PointAndClickOption,
+  PointAndClickSkip,
+  PointAndClickLogs,
   PointAndClickExec,
   PointAndClickScenario,
   PointAndClickScenarioModule,

package/src/modules/emit.ts

@@ -0,0 +1,47 @@
+import { splitLineKeywords, tokenizeExecLine } from "@vnejs/helpers";
+import { ModuleCore } from "@vnejs/module.core";
+
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickEmitPayload, PointAndClickExecGetPayload, PointAndClickOption, PointAndClickPluginModelState } from "../utils/point-and-click.js";
+
+export class PointAndClickEmit extends ModuleCore<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams
+> {
+  name = "point_and_click.emit";
+
+  subscribe = () => {
+    this.on(this.EVENTS.POINT_AND_CLICK.EMIT, this.onEmit);
+  };
+
+  onEmit = async ({ options = [], args = {} }: PointAndClickEmitPayload = {}) => {
+    const mappedOptions = await Promise.all(options.map(this.mapOptions));
+
+    if (!mappedOptions.length || mappedOptions.every((option) => option.hided)) {
+      return this.emit(this.EVENTS.POINT_AND_CLICK.SKIP);
+    }
+
+    await this.emit(this.EVENTS.POINT_AND_CLICK.STATE_UPDATE, { isShow: true, options: mappedOptions, args } satisfies Partial<PointAndClickPluginModelState>);
+
+    return this.emit(this.EVENTS.POINT_AND_CLICK.SHOW);
+  };
+
+  mapOptions = async ({ optionLine: { line = "", args = {} }, index }: NonNullable<PointAndClickEmitPayload["options"]>[number]) => {
+    const [, , icon, x, y] = tokenizeExecLine(line).map(String);
+    const result: PointAndClickOption = { index, coords: [x, y].map(Number), icon, ...args };
+
+    await Promise.all(
+      Object.keys(args).map(async (key) => {
+        if (typeof args[key] !== "string" || !args[key].startsWith(this.CONST.SCENARIO.LINE_PREFIXES.MODULE)) return;
+
+        const { line: execLine = "", module = "", keywords = [] } = splitLineKeywords(String(args[key]));
+
+        result[key] = await this.emitOne(this.EVENTS.POINT_AND_CLICK.EXEC_GET, { line: execLine, module, keywords } satisfies PointAndClickExecGetPayload);
+      }),
+    );
+
+    return result;
+  };
+}

package/src/modules/logs.ts

@@ -0,0 +1,32 @@
+import { ModuleCore } from "@vnejs/module.core";
+
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickEmitPayload, PointAndClickOptionPayload } from "../utils/point-and-click.js";
+
+export class PointAndClickLogs extends ModuleCore<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams
+> {
+  name = "point_and_click.logs";
+
+  subscribe = () => {
+    this.on(this.EVENTS.POINT_AND_CLICK.EMIT, this.onEmit, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+    this.on(this.EVENTS.POINT_AND_CLICK.OPTION, this.onOption, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+    this.on(this.EVENTS.POINT_AND_CLICK.SKIP, this.onSkip, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+    this.on(this.EVENTS.POINT_AND_CLICK.SHOW, this.onShow, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+    this.on(this.EVENTS.POINT_AND_CLICK.HIDE, this.onHide, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
+  };
+
+  onEmit = ({ options = [], args = {} }: PointAndClickEmitPayload = {}) =>
+    void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.EMIT, options, args });
+  onOption = ({ index = 0 }: PointAndClickOptionPayload = {}) => void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.OPTION, index });
+  onSkip = () => {
+    const { curLine = 0, label } = this.globalState.scenario;
+
+    void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.SKIP, label, from: curLine });
+  };
+  onShow = () => void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.SHOW });
+  onHide = () => void this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.HIDE });
+}

package/src/modules/option.ts

@@ -0,0 +1,31 @@
+import { ModuleCore } from "@vnejs/module.core";
+
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickOptionPayload, PointAndClickPluginModelState } from "../utils/point-and-click.js";
+
+export class PointAndClickOption extends ModuleCore<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams
+> {
+  name = "point_and_click.option";
+
+  subscribe = () => {
+    this.on(this.EVENTS.POINT_AND_CLICK.OPTION, this.onOption);
+  };
+
+  onOption = async ({ index = 0 }: PointAndClickOptionPayload = {}) => {
+    await this.emit(this.EVENTS.POINT_AND_CLICK.HIDE);
+
+    this.globalState.scenario.curLine = this.globalState.point_and_click.options[index].index + 1;
+
+    await this.emit(this.EVENTS.POINT_AND_CLICK.STATE_UPDATE, {
+      options: [],
+      args: {},
+      isShow: false,
+    } satisfies Partial<PointAndClickPluginModelState>);
+
+    this.emitNext();
+  };
+}

package/src/modules/point_and_click.ts

@@ -1,18 +1,9 @@
-import { splitLineKeywords, tokenizeExecLine } from "@vnejs/helpers";
 import { ModuleCore, type ModuleGlobalStateRegistry } from "@vnejs/module.core";
 
 import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
-import type {
-  PointAndClickEmitPayload,
-  PointAndClickExecGetPayload,
-  PointAndClickOption,
-  PointAndClickOptionLine,
-  PointAndClickOptionPayload,
-  PointAndClickPluginModelState,
-  PointAndClickVisibilityPayload,
-} from "../utils/point-and-click.js";
+import type { PointAndClickPluginModelState, PointAndClickVisibilityPayload } from "../utils/point-and-click.js";
 
-export class PointAndClick extends ModuleCore<
+export class PointAndClickState extends ModuleCore<
   PointAndClickPluginEvents,
   PointAndClickPluginConstants,
   PointAndClickPluginSettings,
@@ -22,55 +13,13 @@ export class PointAndClick extends ModuleCore<
   name = "point_and_click";
 
   subscribe = () => {
-    this.on(this.EVENTS.POINT_AND_CLICK.EMIT, this.onEmit);
-    this.on(this.EVENTS.POINT_AND_CLICK.OPTION, this.onOption);
-    this.on(this.EVENTS.POINT_AND_CLICK.SKIP, this.onSkip);
+    this.on(this.EVENTS.POINT_AND_CLICK.STATE_UPDATE, this.onStateUpdate);
 
     this.on(this.EVENTS.STATE.SET, this.onStateSet);
     this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
   };
 
-  onEmit = async ({ options = [], args = {} }: PointAndClickEmitPayload = {}) => {
-    this.emitLog({ action: "emit", options, args });
-    const mappedOptions = await Promise.all(options.map(this.mapOptions));
-
-    if (!mappedOptions.length || mappedOptions.every((option) => option.hided)) {
-      return this.emit(this.EVENTS.POINT_AND_CLICK.SKIP);
-    }
-
-    this.updateState({ isShow: true, options: mappedOptions, args });
-
-    return this.emit(this.EVENTS.POINT_AND_CLICK.OPENED);
-  };
-
-  onSkip = async () => {
-    const { curLine = 0, label } = this.globalState.scenario;
-    const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label })) as PointAndClickOptionLine[];
-    const parentIndent = lines[curLine]?.indent ?? 0;
-
-    let indexShift = 1;
-    let curLineObj = lines[curLine + indexShift];
-
-    while (curLineObj && (curLineObj.indent ?? 0) > parentIndent) {
-      indexShift++;
-      curLineObj = lines[curLine + indexShift];
-    }
-
-    this.emitLog({ action: "skip", label, from: curLine, to: curLine + indexShift });
-    this.globalState.scenario.curLine = curLine + indexShift;
-
-    return this.emitNext();
-  };
-
-  onOption = async ({ index = 0 }: PointAndClickOptionPayload = {}) => {
-    this.emitLog({ action: "point_and_click", index });
-
-    await this.emit(this.EVENTS.POINT_AND_CLICK.CLOSED);
-
-    this.globalState.scenario.curLine = this.state.options[index].index + 1;
-    this.setDefaultState();
-    this.emitNext();
-  };
+  onStateUpdate = (state: Partial<PointAndClickPluginModelState> = {}) => this.updateState(state);
 
   onStateSet = async (payload: ModuleGlobalStateRegistry) => {
     const moduleState = this.getStateSlice(payload);
@@ -81,29 +30,12 @@ export class PointAndClick extends ModuleCore<
 
     this.setState(clonedState);
 
-    return this.emit(clonedState.isShow ? this.EVENTS.POINT_AND_CLICK.OPENED : this.EVENTS.POINT_AND_CLICK.CLOSED, {
+    return this.emit(clonedState.isShow ? this.EVENTS.POINT_AND_CLICK.SHOW : this.EVENTS.POINT_AND_CLICK.HIDE, {
       isForce: true,
     } satisfies PointAndClickVisibilityPayload);
   };
 
-  onStateClear = () => this.emit(this.EVENTS.POINT_AND_CLICK.CLOSED, { isForce: true } satisfies PointAndClickVisibilityPayload);
-
-  mapOptions = async ({ optionLine: { line = "", args = {} }, index }: NonNullable<PointAndClickEmitPayload["options"]>[number]) => {
-    const [, , icon, x, y] = tokenizeExecLine(line).map(String);
-    const result: PointAndClickOption = { index, coords: [x, y].map(Number), icon, ...args };
-
-    await Promise.all(
-      Object.keys(args).map(async (key) => {
-        if (typeof args[key] !== "string" || !args[key].startsWith(this.CONST.SCENARIO.LINE_PREFIXES.MODULE)) return;
-
-        const { line: execLine = "", module = "", keywords = [] } = splitLineKeywords(String(args[key]));
-
-        result[key] = await this.emitOne(this.EVENTS.POINT_AND_CLICK.EXEC_GET, { line: execLine, module, keywords } satisfies PointAndClickExecGetPayload);
-      }),
-    );
-
-    return result;
-  };
+  onStateClear = () => this.emit(this.EVENTS.POINT_AND_CLICK.HIDE, { isForce: true } satisfies PointAndClickVisibilityPayload);
 
   getDefaultState = (): PointAndClickPluginModelState => ({ options: [], args: {}, isShow: false });
 }

package/src/modules/scenario.module.ts

@@ -32,7 +32,7 @@ export class PointAndClickScenarioModule extends ModuleCore<
       return this.emitNext();
     }
 
-    this.emitLog({ action: this.CONST.POINT_AND_CLICK.EXEC_ACTIONS.REPEAT, label, from: curLine, to: targetIndex });
+    this.emitLog({ action: this.CONST.POINT_AND_CLICK.LOGS_ACTIONS.REPEAT, label, from: curLine, to: targetIndex });
     this.globalState.scenario.curLine = targetIndex;
 
     return this.emitNext();

package/src/modules/skip.ts

@@ -0,0 +1,35 @@
+import { ModuleCore } from "@vnejs/module.core";
+
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickOptionLine } from "../utils/point-and-click.js";
+
+export class PointAndClickSkip extends ModuleCore<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams
+> {
+  name = "point_and_click.skip";
+
+  subscribe = () => {
+    this.on(this.EVENTS.POINT_AND_CLICK.SKIP, this.onSkip);
+  };
+
+  onSkip = async () => {
+    const { curLine = 0, label } = this.globalState.scenario;
+    const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label })) as PointAndClickOptionLine[];
+    const parentIndent = lines[curLine]?.indent ?? 0;
+
+    let indexShift = 1;
+    let curLineObj = lines[curLine + indexShift];
+
+    while (curLineObj && (curLineObj.indent ?? 0) > parentIndent) {
+      indexShift++;
+      curLineObj = lines[curLine + indexShift];
+    }
+
+    this.globalState.scenario.curLine = curLine + indexShift;
+
+    return this.emitNext();
+  };
+}

package/src/tests/logs.test.ts

@@ -0,0 +1,77 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { SUBSCRIBE_EVENTS as LOGS_EVENTS } from "@vnejs/contracts.core.logs";
+import { spyEvent } from "@vnejs/test-utils";
+
+import { PointAndClickLogs } from "../modules/logs.js";
+import { CONSTANTS, createPointAndClickTestModule, registerPointAndClickPluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("PointAndClickLogs", () => {
+  beforeEach(() => {
+    registerPointAndClickPluginVne();
+  });
+
+  it("EMIT emits LOGS.EMIT with emit action", async () => {
+    const { observer } = createPointAndClickTestModule(PointAndClickLogs);
+    const logs = spyEvent(observer, LOGS_EVENTS.EMIT);
+    const options = [{ index: 0, optionLine: { line: "% point-and-click.option star 1 2", args: {} } }];
+
+    await observer.emit(SUBSCRIBE_EVENTS.EMIT, { options, args: { a: 1 } });
+
+    expect(logs).toHaveBeenCalledExactlyOnceWith({
+      module: "point_and_click.logs",
+      value: { action: CONSTANTS.LOGS_ACTIONS.EMIT, options, args: { a: 1 } },
+    });
+  });
+
+  it("OPTION emits LOGS.EMIT with option action and index", async () => {
+    const { observer } = createPointAndClickTestModule(PointAndClickLogs);
+    const logs = spyEvent(observer, LOGS_EVENTS.EMIT);
+
+    await observer.emit(SUBSCRIBE_EVENTS.OPTION, { index: 2 });
+
+    expect(logs).toHaveBeenCalledExactlyOnceWith({
+      module: "point_and_click.logs",
+      value: { action: CONSTANTS.LOGS_ACTIONS.OPTION, index: 2 },
+    });
+  });
+
+  it("SKIP emits LOGS.EMIT with skip action and scenario cursor", async () => {
+    const { observer, state } = createPointAndClickTestModule(PointAndClickLogs);
+    const logs = spyEvent(observer, LOGS_EVENTS.EMIT);
+
+    state.scenario.curLine = 3;
+    state.scenario.label = "lab";
+
+    await observer.emit(SUBSCRIBE_EVENTS.SKIP);
+
+    expect(logs).toHaveBeenCalledExactlyOnceWith({
+      module: "point_and_click.logs",
+      value: { action: CONSTANTS.LOGS_ACTIONS.SKIP, label: "lab", from: 3 },
+    });
+  });
+
+  it("SHOW emits LOGS.EMIT with show action", async () => {
+    const { observer } = createPointAndClickTestModule(PointAndClickLogs);
+    const logs = spyEvent(observer, LOGS_EVENTS.EMIT);
+
+    await observer.emit(SUBSCRIBE_EVENTS.SHOW);
+
+    expect(logs).toHaveBeenCalledExactlyOnceWith({
+      module: "point_and_click.logs",
+      value: { action: CONSTANTS.LOGS_ACTIONS.SHOW },
+    });
+  });
+
+  it("HIDE emits LOGS.EMIT with hide action", async () => {
+    const { observer } = createPointAndClickTestModule(PointAndClickLogs);
+    const logs = spyEvent(observer, LOGS_EVENTS.EMIT);
+
+    await observer.emit(SUBSCRIBE_EVENTS.HIDE);
+
+    expect(logs).toHaveBeenCalledExactlyOnceWith({
+      module: "point_and_click.logs",
+      value: { action: CONSTANTS.LOGS_ACTIONS.HIDE },
+    });
+  });
+});

package/src/tests/point_and_click.test.ts

@@ -2,32 +2,52 @@ import { beforeEach, describe, expect, it } from "vitest";
 
 import { spyEvent } from "@vnejs/test-utils";
 
-import { PointAndClick } from "../modules/point_and_click.js";
-import { createPointAndClickTestModule, registerPointAndClickPluginVne, SCENARIO_EVENTS, SUBSCRIBE_EVENTS } from "./setup.js";
+import { PointAndClickState } from "../modules/point_and_click.js";
+import {
+  createPointAndClickFlowModules,
+  createPointAndClickTestModule,
+  registerPointAndClickPluginVne,
+  SCENARIO_EVENTS,
+  SUBSCRIBE_EVENTS,
+} from "./setup.js";
+
+describe("PointAndClickState", () => {
+  beforeEach(() => {
+    registerPointAndClickPluginVne();
+  });
+
+  it("STATE_UPDATE merges partial point_and_click state", async () => {
+    const { module, observer } = createPointAndClickTestModule(PointAndClickState);
+
+    await observer.emit(SUBSCRIBE_EVENTS.STATE_UPDATE, { isShow: true });
 
-describe("PointAndClick", () => {
+    expect((module as PointAndClickState).state.isShow).toBe(true);
+  });
+});
+
+describe("PointAndClick flow", () => {
   beforeEach(() => {
     registerPointAndClickPluginVne();
   });
 
-  it("EMIT stores options and emits OPENED", async () => {
-    const { module, observer } = createPointAndClickTestModule(PointAndClick);
-    const opened = spyEvent(observer, SUBSCRIBE_EVENTS.OPENED);
+  it("EMIT stores options and emits SHOW", async () => {
+    const { stateModule, observer } = createPointAndClickFlowModules();
+    const show = spyEvent(observer, SUBSCRIBE_EVENTS.SHOW);
     const skip = spyEvent(observer, SUBSCRIBE_EVENTS.SKIP);
 
     await observer.emit(SUBSCRIBE_EVENTS.EMIT, {
       options: [{ index: 0, optionLine: { line: "% point-and-click.option star 100 200", args: {} } }],
     });
 
-    expect((module as PointAndClick).state.isShow).toBe(true);
-    expect((module as PointAndClick).state.options[0]).toMatchObject({ index: 0, icon: "star", coords: [100, 200] });
-    expect(opened).toHaveBeenCalledOnce();
+    expect(stateModule.state.isShow).toBe(true);
+    expect(stateModule.state.options[0]).toMatchObject({ index: 0, icon: "star", coords: [100, 200] });
+    expect(show).toHaveBeenCalledOnce();
     expect(skip).not.toHaveBeenCalled();
   });
 
   it("EMIT with all hided options emits SKIP and advances past the block", async () => {
-    const { module, observer, state } = createPointAndClickTestModule(PointAndClick);
-    const opened = spyEvent(observer, SUBSCRIBE_EVENTS.OPENED);
+    const { stateModule, observer, state } = createPointAndClickFlowModules();
+    const show = spyEvent(observer, SUBSCRIBE_EVENTS.SHOW);
     const skip = spyEvent(observer, SUBSCRIBE_EVENTS.SKIP);
     const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
     const lines = [
@@ -44,14 +64,14 @@ describe("PointAndClick", () => {
     });
 
     expect(skip).toHaveBeenCalledOnce();
-    expect(opened).not.toHaveBeenCalled();
-    expect((module as PointAndClick).state.isShow).toBe(false);
+    expect(show).not.toHaveBeenCalled();
+    expect(stateModule.state.isShow).toBe(false);
     expect(state.scenario.curLine).toBe(2);
     expect(next).toHaveBeenCalledOnce();
   });
 
   it("EMIT with empty options emits SKIP and advances past the block", async () => {
-    const { observer, state } = createPointAndClickTestModule(PointAndClick);
+    const { observer, state } = createPointAndClickFlowModules();
     const skip = spyEvent(observer, SUBSCRIBE_EVENTS.SKIP);
     const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
     const lines = [
@@ -69,20 +89,20 @@ describe("PointAndClick", () => {
     expect(next).toHaveBeenCalledOnce();
   });
 
-  it("OPTION emits CLOSED, updates curLine and resets state", async () => {
-    const { module, observer, state } = createPointAndClickTestModule(PointAndClick);
-    const closed = spyEvent(observer, SUBSCRIBE_EVENTS.CLOSED);
+  it("OPTION emits HIDE, updates curLine and resets state", async () => {
+    const { stateModule, observer, state } = createPointAndClickFlowModules();
+    const hide = spyEvent(observer, SUBSCRIBE_EVENTS.HIDE);
 
-    (module as PointAndClick).state = {
+    stateModule.setState({
       options: [{ index: 3, icon: "star", coords: [0, 0] }],
       args: {},
       isShow: true,
-    };
+    });
 
     await observer.emit(SUBSCRIBE_EVENTS.OPTION, { index: 0 });
 
-    expect(closed).toHaveBeenCalledOnce();
+    expect(hide).toHaveBeenCalledOnce();
     expect(state.scenario.curLine).toBe(4);
-    expect((module as PointAndClick).state.isShow).toBe(false);
+    expect(stateModule.state.isShow).toBe(false);
   });
 });

package/src/tests/setup.ts

@@ -3,6 +3,11 @@ import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contrac
 import { SourcesSet } from "@vnejs/sources-set";
 import { createTestModule as baseCreateTestModule, registerCoreVne, registerVnePlugin, stubSilentEvent } from "@vnejs/test-utils";
 
+import { PointAndClickEmit } from "../modules/emit.js";
+import { PointAndClickOption } from "../modules/option.js";
+import { PointAndClickState } from "../modules/point_and_click.js";
+import { PointAndClickSkip } from "../modules/skip.js";
+
 export const registerPointAndClickPluginVne = () => {
   registerCoreVne();
   registerVnePlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS });
@@ -25,10 +30,31 @@ export const createPointAndClickTestModule = <T extends Parameters<typeof baseCr
     ...options,
   });
 
-  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.OPENED);
-  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.CLOSED);
+  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.SHOW);
+  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.HIDE);
 
   return result;
 };
 
+export const createPointAndClickFlowModules = (options: Parameters<typeof baseCreateTestModule>[1] = {}) => {
+  const { module: stateModule, observer, state, shared } = createPointAndClickTestModule(PointAndClickState, options);
+
+  const attach = <T extends new () => InstanceType<T>>(ModuleClass: T) => {
+    const module = new ModuleClass();
+    module.inject({ observer, state, shared, media: {} });
+    module.subscribe();
+    return module;
+  };
+
+  return {
+    stateModule: stateModule as PointAndClickState,
+    emitModule: attach(PointAndClickEmit),
+    optionModule: attach(PointAndClickOption),
+    skipModule: attach(PointAndClickSkip),
+    observer,
+    state,
+    shared,
+  };
+};
+
 export { CONSTANTS, SUBSCRIBE_EVENTS, PARAMS, PLUGIN_NAME, SCENARIO_EVENTS };