@vnejs/plugins.scenario.point_and_click 0.2.1

package/dist/index.d.ts

@@ -0,0 +1 @@
+import "@vnejs/contracts.scenario.point_and_click";

package/dist/index.js

@@ -0,0 +1,15 @@
+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 { PointAndClickExec } from "./modules/exec.js";
+import { PointAndClickScenario } from "./modules/scenario.block.js";
+import { PointAndClickScenarioModule } from "./modules/scenario.module.js";
+import { PointAndClickScenarioOption } from "./modules/scenario.option.js";
+regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
+    PointAndClick,
+    PointAndClickExec,
+    PointAndClickScenario,
+    PointAndClickScenarioModule,
+    PointAndClickScenarioOption,
+]);

package/dist/modules/exec.d.ts

@@ -0,0 +1,8 @@
+import { ModuleReplaceExec } from "@vnejs/module.replace.exec";
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickExecGetPayload } from "../utils/point-and-click.js";
+export declare class PointAndClickExec extends ModuleReplaceExec<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams, PointAndClickExecGetPayload> {
+    name: string;
+    EXEC_REG_EVENT: "vne:point_and_click:exec_reg";
+    EXEC_GET_EVENT: "vne:point_and_click:exec_get";
+}

package/dist/modules/exec.js

@@ -0,0 +1,6 @@
+import { ModuleReplaceExec } from "@vnejs/module.replace.exec";
+export class PointAndClickExec extends ModuleReplaceExec {
+    name = "point-and-click.exec";
+    EXEC_REG_EVENT = this.EVENTS.POINT_AND_CLICK.EXEC_REG;
+    EXEC_GET_EVENT = this.EVENTS.POINT_AND_CLICK.EXEC_GET;
+}

package/dist/modules/point_and_click.d.ts

@@ -0,0 +1,14 @@
+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> {
+    name: string;
+    subscribe: () => void;
+    onEmit: ({ options, args }?: PointAndClickEmitPayload) => Promise<unknown[] | undefined>;
+    onSkip: () => Promise<undefined>;
+    onOption: ({ index }?: PointAndClickOptionPayload) => Promise<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

@@ -0,0 +1,65 @@
+import { splitLineKeywords, tokenizeExecLine } from "@vnejs/helpers";
+import { ModuleCore } from "@vnejs/module.core";
+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.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();
+    };
+    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, {
+            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;
+    };
+    getDefaultState = () => ({ options: [], args: {}, isShow: false });
+}

package/dist/modules/scenario.block.d.ts

@@ -0,0 +1,8 @@
+import { ModuleCore, type LineExecHandlerArg } from "@vnejs/module.core";
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+export declare class PointAndClickScenario extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams> {
+    name: string;
+    execName: string;
+    init: () => Promise<unknown[]> | undefined;
+    onLineExec: ({ args }?: LineExecHandlerArg) => Promise<unknown[] | undefined>;
+}

package/dist/modules/scenario.block.js

@@ -0,0 +1,22 @@
+import { ModuleCore } from "@vnejs/module.core";
+export class PointAndClickScenario extends ModuleCore {
+    name = "point-and-click.scenario";
+    execName = "point-and-click";
+    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: this.execName, handler: this.onLineExec });
+    onLineExec = async ({ args = {} } = {}) => {
+        const { curLine = 0, label } = this.globalState.scenario;
+        const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label }));
+        const optionsArr = [];
+        let indexShift = 1;
+        let curLineObj = lines[curLine + indexShift];
+        while (curLineObj && (curLineObj.indent ?? 0) > (lines[curLine]?.indent ?? 0)) {
+            curLineObj.line.startsWith(`% ${this.execName}.option`) &&
+                curLineObj.indent === (lines[curLine]?.indent ?? 0) + 2 &&
+                optionsArr.push(curLine + indexShift);
+            indexShift++;
+            curLineObj = lines[curLine + indexShift];
+        }
+        const options = optionsArr.map((index) => ({ index, optionLine: lines[index] }));
+        return this.emit(this.EVENTS.POINT_AND_CLICK.EMIT, { args, options });
+    };
+}

package/dist/modules/scenario.module.d.ts

@@ -0,0 +1,11 @@
+import { ModuleCore, type LineExecHandlerArg } from "@vnejs/module.core";
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickOptionLine } from "../utils/point-and-click.js";
+export declare class PointAndClickScenarioModule extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams> {
+    name: string;
+    execName: string;
+    init: () => Promise<unknown[]> | undefined;
+    onLineExec: ({ line }?: LineExecHandlerArg) => Promise<undefined>;
+    findPreviousBlockLineIndex: (lines: PointAndClickOptionLine[], curLine: number) => number;
+    isBlockLine: (line: string) => boolean;
+}

package/dist/modules/scenario.module.js

@@ -0,0 +1,30 @@
+import { tokenizeExecLine } from "@vnejs/helpers";
+import { ModuleCore } from "@vnejs/module.core";
+export class PointAndClickScenarioModule extends ModuleCore {
+    name = "point-and-click.scenario.module";
+    execName = "point-and-click";
+    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: this.execName, handler: this.onLineExec });
+    onLineExec = async ({ line = "" } = {}) => {
+        const [action = ""] = tokenizeExecLine(line).map(String);
+        if (action !== this.CONST.POINT_AND_CLICK.EXEC_ACTIONS.REPEAT)
+            return;
+        const { label, curLine } = this.globalState.scenario;
+        const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label }));
+        const targetIndex = this.findPreviousBlockLineIndex(lines, curLine);
+        if (targetIndex === -1) {
+            console.error(`[point-and-click] repeat: no preceding "% ${this.execName}" in label "${label}"`);
+            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.globalState.scenario.curLine = targetIndex;
+        return this.emitNext();
+    };
+    findPreviousBlockLineIndex = (lines, curLine) => {
+        for (let i = curLine - 1; i >= 0; i--)
+            if (this.isBlockLine(lines[i]?.line ?? ""))
+                return i;
+        return -1;
+    };
+    isBlockLine = (line) => line.startsWith(`% ${this.execName}`) && !line.startsWith(`% ${this.execName}.option`);
+}

package/dist/modules/scenario.option.d.ts

@@ -0,0 +1,8 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+export declare class PointAndClickScenarioOption extends ModuleCore<PointAndClickPluginEvents, PointAndClickPluginConstants, PointAndClickPluginSettings, PointAndClickPluginParams> {
+    name: string;
+    execName: string;
+    init: () => Promise<unknown[]> | undefined;
+    onLineExec: () => Promise<void>;
+}

package/dist/modules/scenario.option.js

@@ -0,0 +1,13 @@
+import { getOptionExecShift } from "@vnejs/helpers";
+import { ModuleCore } from "@vnejs/module.core";
+export class PointAndClickScenarioOption extends ModuleCore {
+    name = "point-and-click.scenario.option";
+    execName = "point-and-click";
+    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: `${this.execName}.option`, handler: this.onLineExec });
+    onLineExec = async () => {
+        const { label, curLine } = this.globalState.scenario;
+        const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label }));
+        this.globalState.scenario.curLine = curLine + getOptionExecShift(lines, curLine);
+        this.emitNext();
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,10 @@
+import type { ModuleCoreConstants, ModuleCoreEvents, ModuleCoreParams, ModuleCoreSettings } from "@vnejs/module.core";
+import type { PluginName as LogsPluginName, SubscribeEvents as LogsSubscribeEvents } from "@vnejs/contracts.core.logs";
+import type { Constants as ScenarioConstants, PluginName as ScenarioPluginName, SubscribeEvents as ScenarioSubscribeEvents } from "@vnejs/contracts.core.scenario";
+import type { PluginName as StatePluginName, SubscribeEvents as StateSubscribeEvents } from "@vnejs/contracts.core.state";
+import type { PluginName as VendorsPluginName, SubscribeEvents as VendorsSubscribeEvents } from "@vnejs/contracts.core.vendors";
+import type { Constants as PointAndClickConstants, PluginName, SubscribeEvents, Params } from "@vnejs/contracts.scenario.point_and_click";
+export type PointAndClickPluginEvents = ModuleCoreEvents & Record<PluginName, SubscribeEvents> & Record<ScenarioPluginName, ScenarioSubscribeEvents> & Record<StatePluginName, StateSubscribeEvents> & Record<VendorsPluginName, VendorsSubscribeEvents> & Record<LogsPluginName, LogsSubscribeEvents>;
+export type PointAndClickPluginConstants = ModuleCoreConstants & Record<PluginName, PointAndClickConstants> & Record<ScenarioPluginName, ScenarioConstants>;
+export type PointAndClickPluginSettings = ModuleCoreSettings;
+export type PointAndClickPluginParams = ModuleCoreParams & Record<PluginName, Params>;

package/dist/types.js

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

package/dist/utils/point-and-click.d.ts

@@ -0,0 +1 @@
+export type { PointAndClickEmitPayload, PointAndClickExecGetPayload, PointAndClickExecRegPayload, PointAndClickOption, PointAndClickOptionLine, PointAndClickOptionPayload, PointAndClickPluginModelState, PointAndClickVisibilityPayload, } from "@vnejs/contracts.scenario.point_and_click";

package/dist/utils/point-and-click.js

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

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@vnejs/plugins.scenario.point_and_click",
+  "version": "0.2.1",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "tsconfig.json"
+  ],
+  "scripts": {
+    "test": "npx @vnejs/monorepo test",
+    "build": "npx @vnejs/monorepo package",
+    "publish:major:plugin": "npm run publish:major",
+    "publish:minor:plugin": "npm run publish:minor",
+    "publish:patch:plugin": "npm run publish:patch",
+    "publish:major": "npx @vnejs/monorepo publish major --access public",
+    "publish:minor": "npx @vnejs/monorepo publish minor --access public",
+    "publish:patch": "npx @vnejs/monorepo publish patch --access public"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "@vnejs/contracts.scenario.point_and_click": "~0.2.0"
+  },
+  "peerDependencies": {
+    "@vnejs/helpers": "~0.2.0",
+    "@vnejs/module.core": "~0.2.0",
+    "@vnejs/module.replace.exec": "~0.2.0",
+    "@vnejs/shared": "~0.2.0"
+  },
+  "devDependencies": {
+    "@vnejs/configs.ts-common": "~0.2.0",
+    "@vnejs/configs.vitest": "~0.2.0",
+    "@vnejs/test-utils": "~0.2.0",
+    "@vnejs/contracts.scenario.point_and_click": "~0.2.0",
+    "@vnejs/helpers": "~0.2.0",
+    "@vnejs/module.core": "~0.2.0",
+    "@vnejs/module.replace.exec": "~0.2.0",
+    "@vnejs/shared": "~0.2.0",
+    "@vnejs/sources-set": "~0.2.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,18 @@
+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 { PointAndClickExec } from "./modules/exec.js";
+import { PointAndClickScenario } from "./modules/scenario.block.js";
+import { PointAndClickScenarioModule } from "./modules/scenario.module.js";
+import { PointAndClickScenarioOption } from "./modules/scenario.option.js";
+
+regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
+  PointAndClick,
+  PointAndClickExec,
+  PointAndClickScenario,
+  PointAndClickScenarioModule,
+  PointAndClickScenarioOption,
+]);

package/src/modules/exec.ts

@@ -0,0 +1,17 @@
+import { ModuleReplaceExec } from "@vnejs/module.replace.exec";
+
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickExecGetPayload } from "../utils/point-and-click.js";
+
+export class PointAndClickExec extends ModuleReplaceExec<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams,
+  PointAndClickExecGetPayload
+> {
+  name = "point-and-click.exec";
+
+  EXEC_REG_EVENT = this.EVENTS.POINT_AND_CLICK.EXEC_REG;
+  EXEC_GET_EVENT = this.EVENTS.POINT_AND_CLICK.EXEC_GET;
+}

package/src/modules/point_and_click.ts

@@ -0,0 +1,109 @@
+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";
+
+export class PointAndClick extends ModuleCore<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams,
+  PointAndClickPluginModelState
+> {
+  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.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();
+  };
+
+  onStateSet = async (payload: ModuleGlobalStateRegistry) => {
+    const moduleState = this.getStateSlice(payload);
+
+    if (!moduleState || this.state.isShow === moduleState.isShow) return;
+
+    const clonedState = await this.emitClone<PointAndClickPluginModelState>(moduleState);
+
+    this.setState(clonedState);
+
+    return this.emit(clonedState.isShow ? this.EVENTS.POINT_AND_CLICK.OPENED : this.EVENTS.POINT_AND_CLICK.CLOSED, {
+      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;
+  };
+
+  getDefaultState = (): PointAndClickPluginModelState => ({ options: [], args: {}, isShow: false });
+}

package/src/modules/scenario.block.ts

@@ -0,0 +1,38 @@
+import { ModuleCore, type LineExecHandlerArg } from "@vnejs/module.core";
+
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickEmitPayload, PointAndClickOptionLine } from "../utils/point-and-click.js";
+
+export class PointAndClickScenario extends ModuleCore<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams
+> {
+  name = "point-and-click.scenario";
+
+  execName = "point-and-click";
+
+  init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: this.execName, handler: this.onLineExec });
+
+  onLineExec = async ({ args = {} }: LineExecHandlerArg = {}) => {
+    const { curLine = 0, label } = this.globalState.scenario;
+    const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label })) as PointAndClickOptionLine[];
+    const optionsArr: number[] = [];
+
+    let indexShift = 1;
+    let curLineObj = lines[curLine + indexShift];
+
+    while (curLineObj && (curLineObj.indent ?? 0) > (lines[curLine]?.indent ?? 0)) {
+      curLineObj.line.startsWith(`% ${this.execName}.option`) &&
+        curLineObj.indent === (lines[curLine]?.indent ?? 0) + 2 &&
+        optionsArr.push(curLine + indexShift);
+      indexShift++;
+      curLineObj = lines[curLine + indexShift];
+    }
+
+    const options = optionsArr.map((index) => ({ index, optionLine: lines[index] }));
+
+    return this.emit(this.EVENTS.POINT_AND_CLICK.EMIT, { args, options } satisfies PointAndClickEmitPayload);
+  };
+}

package/src/modules/scenario.module.ts

@@ -0,0 +1,48 @@
+import { tokenizeExecLine } from "@vnejs/helpers";
+import { ModuleCore, type LineExecHandlerArg } from "@vnejs/module.core";
+
+import type { PointAndClickPluginConstants, PointAndClickPluginEvents, PointAndClickPluginParams, PointAndClickPluginSettings } from "../types.js";
+import type { PointAndClickOptionLine } from "../utils/point-and-click.js";
+
+export class PointAndClickScenarioModule extends ModuleCore<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams
+> {
+  name = "point-and-click.scenario.module";
+
+  execName = "point-and-click";
+
+  init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: this.execName, handler: this.onLineExec });
+
+  onLineExec = async ({ line = "" }: LineExecHandlerArg = {}) => {
+    const [action = ""] = tokenizeExecLine(line).map(String);
+
+    if (action !== this.CONST.POINT_AND_CLICK.EXEC_ACTIONS.REPEAT) return;
+
+    const { label, curLine } = this.globalState.scenario;
+    const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label })) as PointAndClickOptionLine[];
+    const targetIndex = this.findPreviousBlockLineIndex(lines, curLine);
+
+    if (targetIndex === -1) {
+      console.error(`[point-and-click] repeat: no preceding "% ${this.execName}" in label "${label}"`);
+      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.globalState.scenario.curLine = targetIndex;
+
+    return this.emitNext();
+  };
+
+  findPreviousBlockLineIndex = (lines: PointAndClickOptionLine[], curLine: number) => {
+    for (let i = curLine - 1; i >= 0; i--) if (this.isBlockLine(lines[i]?.line ?? "")) return i;
+
+    return -1;
+  };
+
+  isBlockLine = (line: string) => line.startsWith(`% ${this.execName}`) && !line.startsWith(`% ${this.execName}.option`);
+}

package/src/modules/scenario.option.ts

@@ -0,0 +1,27 @@
+import { getOptionExecShift } from "@vnejs/helpers";
+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 PointAndClickScenarioOption extends ModuleCore<
+  PointAndClickPluginEvents,
+  PointAndClickPluginConstants,
+  PointAndClickPluginSettings,
+  PointAndClickPluginParams
+> {
+  name = "point-and-click.scenario.option";
+
+  execName = "point-and-click";
+
+  init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: `${this.execName}.option`, handler: this.onLineExec });
+
+  onLineExec = async () => {
+    const { label, curLine } = this.globalState.scenario;
+    const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label })) as PointAndClickOptionLine[];
+
+    this.globalState.scenario.curLine = curLine + getOptionExecShift(lines, curLine);
+
+    this.emitNext();
+  };
+}

package/src/tests/exec.test.ts

@@ -0,0 +1,21 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { PointAndClickExec } from "../modules/exec.js";
+import { createPointAndClickTestModule, registerPointAndClickPluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("PointAndClickExec", () => {
+  beforeEach(() => {
+    registerPointAndClickPluginVne();
+  });
+
+  it("EXEC_REG stores handler and EXEC_GET invokes it", async () => {
+    const { observer } = createPointAndClickTestModule(PointAndClickExec);
+    const handler = vi.fn(() => "ok");
+
+    await observer.emit(SUBSCRIBE_EVENTS.EXEC_REG, { module: "vars", handler });
+    const [result] = await observer.emit(SUBSCRIBE_EVENTS.EXEC_GET, { module: "vars", line: "test", keywords: [] });
+
+    expect(handler).toHaveBeenCalledOnce();
+    expect(result).toBe("ok");
+  });
+});

package/src/tests/point_and_click.test.ts

@@ -0,0 +1,88 @@
+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";
+
+describe("PointAndClick", () => {
+  beforeEach(() => {
+    registerPointAndClickPluginVne();
+  });
+
+  it("EMIT stores options and emits OPENED", async () => {
+    const { module, observer } = createPointAndClickTestModule(PointAndClick);
+    const opened = spyEvent(observer, SUBSCRIBE_EVENTS.OPENED);
+    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(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 skip = spyEvent(observer, SUBSCRIBE_EVENTS.SKIP);
+    const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
+    const lines = [
+      { line: "% point-and-click", indent: 0 },
+      { line: "% point-and-click.option star 100 200", indent: 2 },
+      { line: '"after"', indent: 0 },
+    ];
+
+    observer.subscribe(SCENARIO_EVENTS.LINES_GET, () => lines);
+    state.scenario.curLine = 0;
+
+    await observer.emit(SUBSCRIBE_EVENTS.EMIT, {
+      options: [{ index: 1, optionLine: { line: "% point-and-click.option star 100 200", args: { hided: true } } }],
+    });
+
+    expect(skip).toHaveBeenCalledOnce();
+    expect(opened).not.toHaveBeenCalled();
+    expect((module as PointAndClick).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 skip = spyEvent(observer, SUBSCRIBE_EVENTS.SKIP);
+    const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
+    const lines = [
+      { line: "% point-and-click", indent: 0 },
+      { line: '"after"', indent: 0 },
+    ];
+
+    observer.subscribe(SCENARIO_EVENTS.LINES_GET, () => lines);
+    state.scenario.curLine = 0;
+
+    await observer.emit(SUBSCRIBE_EVENTS.EMIT, { options: [] });
+
+    expect(skip).toHaveBeenCalledOnce();
+    expect(state.scenario.curLine).toBe(1);
+    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);
+
+    (module as PointAndClick).state = {
+      options: [{ index: 3, icon: "star", coords: [0, 0] }],
+      args: {},
+      isShow: true,
+    };
+
+    await observer.emit(SUBSCRIBE_EVENTS.OPTION, { index: 0 });
+
+    expect(closed).toHaveBeenCalledOnce();
+    expect(state.scenario.curLine).toBe(4);
+    expect((module as PointAndClick).state.isShow).toBe(false);
+  });
+});

package/src/tests/scenario.test.ts

@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+
+import { PointAndClickScenario } from "../modules/scenario.block.js";
+import { PointAndClickScenarioModule } from "../modules/scenario.module.js";
+import { PointAndClickScenarioOption } from "../modules/scenario.option.js";
+import { createPointAndClickTestModule, registerPointAndClickPluginVne, SCENARIO_EVENTS, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("PointAndClickScenario", () => {
+  beforeEach(() => {
+    registerPointAndClickPluginVne();
+  });
+
+  it("init registers % point-and-click block handler", async () => {
+    const { module, observer } = createPointAndClickTestModule(PointAndClickScenario, { subscribe: false });
+    const lineExecReg = spyEvent(observer, SCENARIO_EVENTS.LINE_EXEC_REG);
+    const scenario = module as PointAndClickScenario;
+
+    await scenario.init();
+
+    expect(lineExecReg).toHaveBeenCalledOnce();
+    expect(lineExecReg).toHaveBeenCalledWith({ block: "point-and-click", handler: scenario.onLineExec });
+  });
+
+  it("onLineExec collects option lines and emits EMIT", async () => {
+    const { module, observer } = createPointAndClickTestModule(PointAndClickScenario);
+    const emit = spyEvent(observer, SUBSCRIBE_EVENTS.EMIT);
+    const lines = [
+      { line: "point-and-click", indent: 0 },
+      { line: "% point-and-click.option star 10 20", indent: 2 },
+    ];
+
+    observer.subscribe(SCENARIO_EVENTS.LINES_GET, () => lines);
+
+    await (module as PointAndClickScenario).onLineExec({ args: { test: 1 } });
+
+    expect(emit).toHaveBeenCalledOnce();
+    expect(emit.mock.calls[0][0]).toMatchObject({ args: { test: 1 }, options: [{ index: 1, optionLine: lines[1] }] });
+  });
+});
+
+describe("PointAndClickScenarioOption", () => {
+  beforeEach(() => {
+    registerPointAndClickPluginVne();
+  });
+
+  it("init registers % point-and-click.option block handler", async () => {
+    const { module, observer } = createPointAndClickTestModule(PointAndClickScenarioOption, { subscribe: false });
+    const lineExecReg = spyEvent(observer, SCENARIO_EVENTS.LINE_EXEC_REG);
+    const scenario = module as PointAndClickScenarioOption;
+
+    await scenario.init();
+
+    expect(lineExecReg).toHaveBeenCalledOnce();
+    expect(lineExecReg).toHaveBeenCalledWith({ block: "point-and-click.option", handler: scenario.onLineExec });
+  });
+});
+
+describe("PointAndClickScenarioModule", () => {
+  beforeEach(() => {
+    registerPointAndClickPluginVne();
+  });
+
+  it("init registers $ point-and-click module handler", async () => {
+    const { module, observer } = createPointAndClickTestModule(PointAndClickScenarioModule, { subscribe: false });
+    const lineExecReg = spyEvent(observer, SCENARIO_EVENTS.LINE_EXEC_REG);
+    const scenario = module as PointAndClickScenarioModule;
+
+    await scenario.init();
+
+    expect(lineExecReg).toHaveBeenCalledOnce();
+    expect(lineExecReg).toHaveBeenCalledWith({ module: "point-and-click", handler: scenario.onLineExec });
+  });
+
+  it("repeat sets curLine to preceding point-and-click block", async () => {
+    const { module, observer, state } = createPointAndClickTestModule(PointAndClickScenarioModule);
+    const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
+    const lines = [
+      { line: "% point-and-click", indent: 0 },
+      { line: "% point-and-click.option star 10 20", indent: 2 },
+      { line: '"text"', indent: 2 },
+      { line: "$ point-and-click repeat", indent: 2 },
+    ];
+
+    observer.subscribe(SCENARIO_EVENTS.LINES_GET, () => lines);
+    state.scenario.curLine = 3;
+
+    await (module as PointAndClickScenarioModule).onLineExec({ line: "repeat" });
+
+    expect(state.scenario.curLine).toBe(0);
+    expect(next).toHaveBeenCalledOnce();
+  });
+
+  it("repeat without preceding block increments curLine and emits NEXT", async () => {
+    const { module, observer, state } = createPointAndClickTestModule(PointAndClickScenarioModule);
+    const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    observer.subscribe(SCENARIO_EVENTS.LINES_GET, () => [{ line: "$ point-and-click repeat", indent: 0 }]);
+    state.scenario.curLine = 0;
+
+    await (module as PointAndClickScenarioModule).onLineExec({ line: "repeat" });
+
+    expect(state.scenario.curLine).toBe(1);
+    expect(next).toHaveBeenCalledOnce();
+    expect(consoleError).toHaveBeenCalledOnce();
+
+    consoleError.mockRestore();
+  });
+});

package/src/tests/setup.ts

@@ -0,0 +1,34 @@
+import { SUBSCRIBE_EVENTS as SCENARIO_EVENTS } from "@vnejs/contracts.core.scenario";
+import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.scenario.point_and_click";
+import { SourcesSet } from "@vnejs/sources-set";
+import { createTestModule as baseCreateTestModule, registerCoreVne, registerVnePlugin, stubSilentEvent } from "@vnejs/test-utils";
+
+export const registerPointAndClickPluginVne = () => {
+  registerCoreVne();
+  registerVnePlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS });
+};
+
+export const createPointAndClickTestModule = <T extends Parameters<typeof baseCreateTestModule>[0]>(
+  ModuleClass: T,
+  options: Parameters<typeof baseCreateTestModule>[1] = {},
+) => {
+  const result = baseCreateTestModule(ModuleClass, {
+    state: {
+      point_and_click: { options: [], args: {}, isShow: false },
+      scenario: { curLine: 0, label: "start" },
+      ...(options.state ?? {}),
+    },
+    shared: {
+      viewForceAnimationSources: new SourcesSet(),
+      ...(options.shared ?? {}),
+    },
+    ...options,
+  });
+
+  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.OPENED);
+  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.CLOSED);
+
+  return result;
+};
+
+export { CONSTANTS, SUBSCRIBE_EVENTS, PARAMS, PLUGIN_NAME, SCENARIO_EVENTS };

package/src/types.ts

@@ -0,0 +1,26 @@
+import type { ModuleCoreConstants, ModuleCoreEvents, ModuleCoreParams, ModuleCoreSettings } from "@vnejs/module.core";
+
+import type { PluginName as LogsPluginName, SubscribeEvents as LogsSubscribeEvents } from "@vnejs/contracts.core.logs";
+import type {
+  Constants as ScenarioConstants,
+  PluginName as ScenarioPluginName,
+  SubscribeEvents as ScenarioSubscribeEvents,
+} from "@vnejs/contracts.core.scenario";
+import type { PluginName as StatePluginName, SubscribeEvents as StateSubscribeEvents } from "@vnejs/contracts.core.state";
+import type { PluginName as VendorsPluginName, SubscribeEvents as VendorsSubscribeEvents } from "@vnejs/contracts.core.vendors";
+import type { Constants as PointAndClickConstants, PluginName, SubscribeEvents, Params } from "@vnejs/contracts.scenario.point_and_click";
+
+export type PointAndClickPluginEvents = ModuleCoreEvents &
+  Record<PluginName, SubscribeEvents> &
+  Record<ScenarioPluginName, ScenarioSubscribeEvents> &
+  Record<StatePluginName, StateSubscribeEvents> &
+  Record<VendorsPluginName, VendorsSubscribeEvents> &
+  Record<LogsPluginName, LogsSubscribeEvents>;
+
+export type PointAndClickPluginConstants = ModuleCoreConstants &
+  Record<PluginName, PointAndClickConstants> &
+  Record<ScenarioPluginName, ScenarioConstants>;
+
+export type PointAndClickPluginSettings = ModuleCoreSettings;
+
+export type PointAndClickPluginParams = ModuleCoreParams & Record<PluginName, Params>;

package/src/utils/point-and-click.ts

@@ -0,0 +1,10 @@
+export type {
+  PointAndClickEmitPayload,
+  PointAndClickExecGetPayload,
+  PointAndClickExecRegPayload,
+  PointAndClickOption,
+  PointAndClickOptionLine,
+  PointAndClickOptionPayload,
+  PointAndClickPluginModelState,
+  PointAndClickVisibilityPayload,
+} from "@vnejs/contracts.scenario.point_and_click";

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@vnejs/configs.ts-common/tsconfig.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist"
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["dist", "node_modules", "src/tests"]
+}