@vnejs/plugins.views.scenario.choose 0.1.10 → 0.1.12

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,8 @@
+import { regPlugin } from "@vnejs/shared";
+import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/plugins.views.scenario.choose.contract";
+import { Choose } from "./modules/choose.js";
+import { ChooseController } from "./modules/controller.js";
+import { ChooseExec } from "./modules/exec.js";
+import { ChooseScenario } from "./modules/scenario.js";
+import { ChooseView } from "./modules/view.js";
+regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS }, [Choose, ChooseController, ChooseExec, ChooseScenario, ChooseView]);

package/dist/modules/choose.d.ts

@@ -0,0 +1,19 @@
+import { Module, type ModuleGlobalStateRegistry } from "@vnejs/module";
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChooseEmitPayload, ChooseOption, ChooseOptionLine, ChoosePluginModelState, ChooseOptionPayload } from "../utils/choose.js";
+export declare class Choose extends Module<ChoosePluginEvents, ChoosePluginConstants, ChoosePluginSettings, ChoosePluginParams, ChoosePluginModelState> {
+    name: string;
+    subscribe: () => void;
+    onChooseEmit: ({ options, args }?: ChooseEmitPayload) => Promise<void>;
+    onChooseOption: ({ index }?: ChooseOptionPayload) => Promise<void>;
+    onStateSet: (payload: ModuleGlobalStateRegistry) => Promise<unknown[] | undefined>;
+    onStateClear: () => Promise<unknown[]> | undefined;
+    getRealOptions: (options?: ChooseEmitPayload["options"]) => Promise<ChooseOption[]>;
+    mapOptions: ({ optionLine, index }: {
+        optionLine: ChooseOptionLine;
+        index: number;
+    }) => Promise<ChooseOption>;
+    getOptionText: (line: string, args: Record<string, unknown>) => Promise<unknown> | undefined;
+    getOptionCoords: (line: string) => number[] | undefined;
+    getDefaultState: () => ChoosePluginModelState;
+}

package/dist/modules/choose.js

@@ -0,0 +1,64 @@
+import { splitLineKeywords } from "@vnejs/helpers";
+import { Module } from "@vnejs/module";
+export class Choose extends Module {
+    name = "choose";
+    subscribe = () => {
+        this.on(this.EVENTS.CHOOSE.EMIT, this.onChooseEmit);
+        this.on(this.EVENTS.CHOOSE.OPTION, this.onChooseOption);
+        this.on(this.EVENTS.STATE.SET, this.onStateSet);
+        this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
+    };
+    onChooseEmit = async ({ options = [], args = {} } = {}) => {
+        this.emit(this.EVENTS.LOGS.EMIT, { module: this.name, value: { action: "emit", options, args } });
+        this.updateState({ isShow: true, options: await this.getRealOptions(options), args });
+        await this.emit(this.EVENTS.CHOOSE.SHOW);
+    };
+    onChooseOption = async ({ index = 0 } = {}) => {
+        this.emit(this.EVENTS.LOGS.EMIT, { module: this.name, value: { action: "choose", index } });
+        this.globalState.scenario.curLine = this.state.options[index].index + 1;
+        await this.emit(this.EVENTS.CHOOSE.HIDE);
+        this.setDefaultState();
+        this.emit(this.EVENTS.SCENARIO.NEXT, { module: this.name });
+    };
+    onStateSet = async (payload) => {
+        const clonedState = (await this.emitOne(this.EVENTS.VENDORS.CLONE, this.getStateSlice(payload)));
+        if (this.state.isShow === clonedState.isShow)
+            return;
+        this.state.args = clonedState.args;
+        this.state.options = clonedState.options;
+        return this.emit(clonedState.isShow ? this.EVENTS.CHOOSE.SHOW : this.EVENTS.CHOOSE.HIDE, { isForce: true });
+    };
+    onStateClear = () => {
+        this.setDefaultState();
+        return this.emit(this.EVENTS.CHOOSE.HIDE, { isForce: true });
+    };
+    getRealOptions = async (options = []) => Promise.all(options.map(this.mapOptions));
+    mapOptions = async ({ optionLine, index }) => {
+        const args = optionLine.args ?? {};
+        const text = (await this.getOptionText(optionLine.line, args));
+        const result = { index, text, coords: this.getOptionCoords(optionLine.line), ...args };
+        await Promise.all(Object.keys(args).map(async (key) => {
+            if (typeof args[key] !== "string" || !String(args[key]).startsWith(this.CONST.SCENARIO.LINE_PREFIXES.MODULE))
+                return;
+            const { line = "", module = "", keywords = [] } = splitLineKeywords(String(args[key]));
+            result[key] = await this.emitOne(this.EVENTS.CHOOSE.EXEC_GET, { line, module, keywords });
+        }));
+        return result;
+    };
+    getOptionText = (line, args) => {
+        const quotedText = line.slice(line.indexOf('"'), line.lastIndexOf('"') + 1);
+        const text = quotedText.slice(1, quotedText.length - 1);
+        return this.emitOne(this.EVENTS.TEXT.REPLACE, {
+            text,
+            args,
+            label: this.globalState.scenario.label,
+            state: this.globalState,
+        });
+    };
+    getOptionCoords = (line) => {
+        const lineText = line.slice("% option ".length);
+        const numbers = lineText.slice(lineText.lastIndexOf('"') + 2);
+        return numbers === "" ? undefined : numbers.split(" ").map(Number);
+    };
+    getDefaultState = () => ({ options: [], args: {}, isShow: false });
+}

package/dist/modules/controller.d.ts

@@ -0,0 +1,19 @@
+import { ModuleController } from "@vnejs/module.components";
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChoosePluginControllerState } from "../utils/choose.js";
+export declare class ChooseController extends ModuleController<ChoosePluginEvents, ChoosePluginConstants, ChoosePluginSettings, ChoosePluginParams, ChoosePluginControllerState> {
+    name: string;
+    maxCurrentItem: number;
+    updateEvent: "vne:choose:update";
+    controls: {
+        abstract_arrow_up: () => void;
+        abstract_arrow_bottom: () => void;
+        abstract_accept: () => void;
+    };
+    controlsIndex: number;
+    subscribe: () => void;
+    init: () => void;
+    beforeShow: () => Promise<void>;
+    afterHide: () => void;
+    onArrow: (cb: () => void) => void;
+}

package/dist/modules/controller.js

@@ -0,0 +1,34 @@
+import { ModuleController } from "@vnejs/module.components";
+export class ChooseController extends ModuleController {
+    name = "choose.controller";
+    maxCurrentItem = 0;
+    updateEvent = this.EVENTS.CHOOSE.UPDATE;
+    controls = {
+        [this.CONST.CONTROLS.BUTTONS.ARROW_UP]: () => this.onArrow(this.decCurrentItem),
+        [this.CONST.CONTROLS.BUTTONS.ARROW_BOTTOM]: () => this.onArrow(this.incCurrentItem),
+        [this.CONST.CONTROLS.BUTTONS.ACCEPT]: () => {
+            if (this.currentItem !== null)
+                void this.emit(this.EVENTS.CHOOSE.OPTION, { index: this.currentItem });
+        },
+    };
+    controlsIndex = this.PARAMS.CHOOSE.ZINDEX;
+    subscribe = () => {
+        this.on(this.EVENTS.CHOOSE.SHOW, this.onShow);
+        this.on(this.EVENTS.CHOOSE.HIDE, this.onHide);
+    };
+    init = () => {
+        Object.assign(this.controls, this.PARAMS.CHOOSE.CONTROLS_EXTENSIONS);
+    };
+    beforeShow = async () => {
+        const state = (await this.emitOne(this.EVENTS.VENDORS.CLONE, this.globalState.choose));
+        this.updateState(state);
+        this.maxCurrentItem = this.state.options.length - 1;
+        await this.emit(this.EVENTS.CHOOSE.SHOW_BEFORE);
+    };
+    afterHide = () => this.setDefaultState();
+    onArrow = (cb) => {
+        cb();
+        while (this.currentItem !== null && this.state.options?.[this.currentItem]?.hided)
+            cb();
+    };
+}

package/dist/modules/exec.d.ts

@@ -0,0 +1,10 @@
+import { Module } from "@vnejs/module";
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChooseExecGetPayload, ChooseExecRegPayload } from "../utils/choose.js";
+export declare class ChooseExec extends Module<ChoosePluginEvents, ChoosePluginConstants, ChoosePluginSettings, ChoosePluginParams> {
+    name: string;
+    handlers: Record<string, (payload: ChooseExecGetPayload) => unknown>;
+    subscribe: () => void;
+    onChooseExecReg: ({ handler, module }?: ChooseExecRegPayload) => void;
+    onChooseExecGet: ({ module, line, keywords }?: ChooseExecGetPayload) => unknown;
+}

package/dist/modules/exec.js

@@ -0,0 +1,18 @@
+import { Module } from "@vnejs/module";
+export class ChooseExec extends Module {
+    name = "choose.exec";
+    handlers = {};
+    subscribe = () => {
+        this.on(this.EVENTS.CHOOSE.EXEC_REG, this.onChooseExecReg);
+        this.on(this.EVENTS.CHOOSE.EXEC_GET, this.onChooseExecGet);
+    };
+    onChooseExecReg = ({ handler, module = "" } = {}) => {
+        if (handler)
+            this.handlers[module] = handler;
+    };
+    onChooseExecGet = ({ module = "", line = "", keywords = [] } = {}) => {
+        if (typeof this.handlers[module] === "function")
+            return this.handlers[module]({ line, keywords });
+        return "";
+    };
+}

package/dist/modules/scenario.d.ts

@@ -0,0 +1,10 @@
+import { Module } from "@vnejs/module";
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+export declare class ChooseScenario extends Module<ChoosePluginEvents, ChoosePluginConstants, ChoosePluginSettings, ChoosePluginParams> {
+    name: string;
+    execName: string;
+    init: () => Promise<unknown[]> | undefined;
+    onLineExec: ({ args }?: {
+        args?: Record<string, unknown>;
+    }) => Promise<void>;
+}

package/dist/modules/scenario.js

@@ -0,0 +1,19 @@
+import { Module } from "@vnejs/module";
+export class ChooseScenario extends Module {
+    name = "choose.scenario";
+    execName = "choose";
+    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: this.execName, handler: this.onLineExec });
+    onLineExec = async ({ args = {} } = {}) => {
+        const [{ curLine = 0, label }, optionsArr] = [this.globalState.scenario, []];
+        const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label }));
+        let indexShift = 1;
+        let curLineObj = lines[curLine + indexShift];
+        while (curLineObj && (curLineObj.indent ?? 0) >= (lines[curLine]?.indent ?? 0)) {
+            curLineObj.line.startsWith("% 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] }));
+        await this.emit(this.EVENTS.CHOOSE.EMIT, { args, options });
+    };
+}

package/dist/modules/view.d.ts

@@ -0,0 +1,10 @@
+import { ModuleView } from "@vnejs/module.components";
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChoosePluginControllerState } from "../utils/choose.js";
+export declare class ChooseView extends ModuleView<ChoosePluginEvents, ChoosePluginConstants, ChoosePluginSettings, ChoosePluginParams, ChoosePluginControllerState> {
+    name: string;
+    animationTime: number;
+    updateEvent: "vne:choose:update";
+    renderFunc: import("@vnejs/module.components").ViewRenderFunc<ChoosePluginControllerState>;
+    updateHandler: (state?: ChoosePluginControllerState | undefined) => Promise<void>;
+}

package/dist/modules/view.js

@@ -0,0 +1,9 @@
+import { ModuleView } from "@vnejs/module.components";
+import { render } from "../view/index.js";
+export class ChooseView extends ModuleView {
+    name = "choose.view";
+    animationTime = this.PARAMS.CHOOSE.TRANSITION;
+    updateEvent = this.EVENTS.CHOOSE.UPDATE;
+    renderFunc = render;
+    updateHandler = this.onUpdateStoreComponent;
+}

package/dist/types.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleComponentsConstants, ModuleComponentsEvents, ModuleComponentsParams, ModuleComponentsSettings } from "@vnejs/module.components";
+import type { Constants as ControlsConstants, PluginName as ControlsPluginName } from "@vnejs/plugins.controls.contract";
+import type { PluginName as LogsPluginName, SubscribeEvents as LogsSubscribeEvents } from "@vnejs/plugins.core.logs.contract";
+import type { Constants as ScenarioConstants, PluginName as ScenarioPluginName, SubscribeEvents as ScenarioSubscribeEvents } from "@vnejs/plugins.core.scenario.contract";
+import type { PluginName as StatePluginName, SubscribeEvents as StateSubscribeEvents } from "@vnejs/plugins.core.state.contract";
+import type { PluginName as VendorsPluginName, SubscribeEvents as VendorsSubscribeEvents } from "@vnejs/plugins.core.vendors.contract";
+import type { PluginName as TextPluginName, SubscribeEvents as TextSubscribeEvents } from "@vnejs/plugins.text.contract";
+import type { Params, PluginName, SubscribeEvents } from "@vnejs/plugins.views.scenario.choose.contract";
+export type ChoosePluginEvents = ModuleComponentsEvents & Record<PluginName, SubscribeEvents> & Record<ScenarioPluginName, ScenarioSubscribeEvents> & Record<StatePluginName, StateSubscribeEvents> & Record<VendorsPluginName, VendorsSubscribeEvents> & Record<LogsPluginName, LogsSubscribeEvents> & Record<TextPluginName, TextSubscribeEvents>;
+export type ChoosePluginConstants = ModuleComponentsConstants & Record<ControlsPluginName, ControlsConstants> & Record<ScenarioPluginName, ScenarioConstants>;
+export type ChoosePluginSettings = ModuleComponentsSettings;
+export type ChoosePluginParams = ModuleComponentsParams & Record<PluginName, Params>;

package/dist/types.js

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

package/dist/utils/choose.d.ts

@@ -0,0 +1,47 @@
+import type { ModuleControllerState } from "@vnejs/module.components";
+export type ChooseOptionLine = {
+    line: string;
+    args?: Record<string, unknown>;
+    indent?: number;
+};
+export type ChooseOption = {
+    index: number;
+    text?: string;
+    coords?: number[];
+    hided?: boolean;
+    disabled?: boolean;
+    [key: string]: unknown;
+};
+export type ChoosePluginModelState = {
+    options: ChooseOption[];
+    args: Record<string, unknown>;
+    isShow: boolean;
+};
+export type ChoosePluginControllerState = ModuleControllerState & ChoosePluginModelState & {
+    currentItem?: number | null;
+};
+export type ChooseEmitPayload = {
+    options?: {
+        index: number;
+        optionLine: ChooseOptionLine;
+    }[];
+    args?: Record<string, unknown>;
+};
+export type ChooseOptionPayload = {
+    index?: number;
+};
+export type ChooseExecRegPayload = {
+    handler?: (payload: ChooseExecGetPayload) => unknown;
+    module?: string;
+};
+export type ChooseExecGetPayload = {
+    module?: string;
+    line?: string;
+    keywords?: string[];
+};
+export type ChooseReplacePayload = {
+    text?: string;
+    args?: Record<string, unknown>;
+    label?: string;
+    state?: Record<string, unknown>;
+};

package/dist/utils/choose.js

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

package/dist/view/index.d.ts

@@ -0,0 +1,3 @@
+import type { ViewRenderFunc } from "@vnejs/module.components";
+import type { ChoosePluginControllerState } from "../utils/choose.js";
+export declare const render: ViewRenderFunc<ChoosePluginControllerState>;

package/dist/view/index.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createElement as _createElement } from "react";
+import { PositionBox, Screen, Text, TextControls, createRenderFunc, useCallback, useIsForceHook, useMemo, useStoreState } from "@vnejs/uis.react";
+const renderOptionWithCoords = ({ text, isDisabled, isNotRender, value, coords, props, currentItem, onClick }) => {
+    const [x = 0, y = 0] = coords ?? [];
+    const positionProps = { left: `${x}%`, top: `${y}%`, translateX: "-50%", translateY: "-50%", isNotRender };
+    const propsText = { ...props.PARAMS.CHOOSE.VIEW_PROPS.text, isDisabled, onClick, text, value, isSelected: currentItem === value };
+    return (_createElement(PositionBox, { ...positionProps, key: value },
+        _jsx(Text, { ...propsText })));
+};
+const Choose = ({ store, onMount, emit, EVENTS, PARAMS }) => {
+    const { isShow = false, isForce = false, options = [], currentItem = null } = useStoreState(store, onMount);
+    const onClick = useCallback((value) => void emit(EVENTS.CHOOSE.OPTION, { index: Number(value) }), [emit, EVENTS.CHOOSE.OPTION]);
+    const isRealForce = useIsForceHook(isForce);
+    const optionsMapped = useMemo(() => options.map(({ text, hided, coords, disabled }, i) => ({ text, i, coords, isNotRender: Boolean(hided), isDisabled: Boolean(disabled) })), [options]);
+    const textsInfo = useMemo(() => optionsMapped.map(({ i, ...obj }) => ({ value: i, isSelected: currentItem === i, ...obj })), [optionsMapped, currentItem]);
+    const optionsRegular = useMemo(() => textsInfo.filter((e) => !e.coords), [textsInfo]);
+    const optionsWithCoords = useMemo(() => textsInfo.filter((e) => e.coords), [textsInfo]);
+    const propsView = PARAMS.CHOOSE.VIEW_PROPS;
+    const propsScreen = useMemo(() => ({ ...propsView.screen, isDisableAutoread: true, isIgnoreOnScreenshot: false, isShow, isForce: isRealForce }), [isShow, isRealForce, propsView.screen]);
+    const propsControls = useMemo(() => ({ ...propsView.controls, texts: optionsRegular, onClick }), [optionsRegular, onClick, propsView.controls]);
+    const optionsWithCoordsWithProps = useMemo(() => optionsWithCoords.map((option) => ({ ...option, currentItem, onClick, props: { store, onMount, emit, EVENTS, PARAMS } })), [optionsWithCoords, currentItem, onClick, store, onMount, emit, EVENTS, PARAMS]);
+    return (_jsxs(Screen, { ...propsScreen, children: [optionsWithCoordsWithProps.map(renderOptionWithCoords), _jsx(PositionBox, { ...propsView.position, children: _jsx(TextControls, { ...propsControls }) })] }));
+};
+export const render = createRenderFunc(Choose);

package/package.json

@@ -1,17 +1,51 @@
 {
   "name": "@vnejs/plugins.views.scenario.choose",
-  "version": "0.1.10",
-  "main": "index.js",
+  "version": "0.1.12",
+  "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": "echo \"Error: no test specified\" && exit 1",
+    "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": "npm version major && npm publish --access public",
-    "publish:minor": "npm version minor && npm publish --access public",
-    "publish:patch": "npm version patch && npm publish --access public"
+    "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",
-  "description": ""
+  "dependencies": {
+    "@vnejs/plugins.views.scenario.choose.contract": "~0.0.1"
+  },
+  "peerDependencies": {
+    "@vnejs/helpers": "~0.1.0",
+    "@vnejs/plugins.controls.contract": "~0.0.1",
+    "@vnejs/module": "~0.0.1",
+    "@vnejs/module.components": "~0.0.1",
+    "@vnejs/plugins.core.logs.contract": "~0.0.1",
+    "@vnejs/plugins.core.scenario.contract": "~0.0.1",
+    "@vnejs/plugins.core.state.contract": "~0.0.1",
+    "@vnejs/plugins.core.vendors.contract": "~0.0.1",
+    "@vnejs/plugins.text.contract": "~0.0.1",
+    "@vnejs/shared": "~0.0.9",
+    "@vnejs/uis.react": "~0.1.0"
+  },
+  "devDependencies": {
+    "@vnejs/configs.ts-common": "~0.0.1"
+  }
 }

package/src/index.ts

@@ -0,0 +1,10 @@
+import { regPlugin } from "@vnejs/shared";
+import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/plugins.views.scenario.choose.contract";
+
+import { Choose } from "./modules/choose.js";
+import { ChooseController } from "./modules/controller.js";
+import { ChooseExec } from "./modules/exec.js";
+import { ChooseScenario } from "./modules/scenario.js";
+import { ChooseView } from "./modules/view.js";
+
+regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS }, [Choose, ChooseController, ChooseExec, ChooseScenario, ChooseView]);

package/src/modules/choose.ts

@@ -0,0 +1,97 @@
+import { splitLineKeywords } from "@vnejs/helpers";
+import { Module, type ModuleGlobalStateRegistry } from "@vnejs/module";
+
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type {
+  ChooseEmitPayload,
+  ChooseExecGetPayload,
+  ChooseOption,
+  ChooseOptionLine,
+  ChoosePluginModelState,
+  ChooseOptionPayload,
+  ChooseReplacePayload,
+} from "../utils/choose.js";
+
+export class Choose extends Module<ChoosePluginEvents, ChoosePluginConstants, ChoosePluginSettings, ChoosePluginParams, ChoosePluginModelState> {
+  name = "choose";
+
+  subscribe = () => {
+    this.on(this.EVENTS.CHOOSE.EMIT, this.onChooseEmit);
+    this.on(this.EVENTS.CHOOSE.OPTION, this.onChooseOption);
+
+    this.on(this.EVENTS.STATE.SET, this.onStateSet);
+    this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
+  };
+
+  onChooseEmit = async ({ options = [], args = {} }: ChooseEmitPayload = {}) => {
+    this.emit(this.EVENTS.LOGS.EMIT, { module: this.name, value: { action: "emit", options, args } });
+    this.updateState({ isShow: true, options: await this.getRealOptions(options), args });
+    await this.emit(this.EVENTS.CHOOSE.SHOW);
+  };
+
+  onChooseOption = async ({ index = 0 }: ChooseOptionPayload = {}) => {
+    this.emit(this.EVENTS.LOGS.EMIT, { module: this.name, value: { action: "choose", index } });
+    this.globalState.scenario.curLine = this.state.options[index].index + 1;
+    await this.emit(this.EVENTS.CHOOSE.HIDE);
+    this.setDefaultState();
+    this.emit(this.EVENTS.SCENARIO.NEXT, { module: this.name });
+  };
+
+  onStateSet = async (payload: ModuleGlobalStateRegistry) => {
+    const clonedState = (await this.emitOne(this.EVENTS.VENDORS.CLONE, this.getStateSlice(payload))) as ChoosePluginModelState;
+
+    if (this.state.isShow === clonedState.isShow) return;
+
+    this.state.args = clonedState.args;
+    this.state.options = clonedState.options;
+
+    return this.emit(clonedState.isShow ? this.EVENTS.CHOOSE.SHOW : this.EVENTS.CHOOSE.HIDE, { isForce: true });
+  };
+
+  onStateClear = () => {
+    this.setDefaultState();
+
+    return this.emit(this.EVENTS.CHOOSE.HIDE, { isForce: true });
+  };
+
+  getRealOptions = async (options: ChooseEmitPayload["options"] = []) => Promise.all(options.map(this.mapOptions));
+
+  mapOptions = async ({ optionLine, index }: { optionLine: ChooseOptionLine; index: number }) => {
+    const args = optionLine.args ?? {};
+    const text = (await this.getOptionText(optionLine.line, args)) as string;
+    const result: ChooseOption = { index, text, coords: this.getOptionCoords(optionLine.line), ...args };
+
+    await Promise.all(
+      Object.keys(args).map(async (key) => {
+        if (typeof args[key] !== "string" || !String(args[key]).startsWith(this.CONST.SCENARIO.LINE_PREFIXES.MODULE)) return;
+
+        const { line = "", module = "", keywords = [] } = splitLineKeywords(String(args[key]));
+
+        result[key] = await this.emitOne(this.EVENTS.CHOOSE.EXEC_GET, { line, module, keywords } satisfies ChooseExecGetPayload);
+      }),
+    );
+
+    return result;
+  };
+
+  getOptionText = (line: string, args: Record<string, unknown>) => {
+    const quotedText = line.slice(line.indexOf('"'), line.lastIndexOf('"') + 1);
+    const text = quotedText.slice(1, quotedText.length - 1);
+
+    return this.emitOne(this.EVENTS.TEXT.REPLACE, {
+      text,
+      args,
+      label: this.globalState.scenario.label,
+      state: this.globalState,
+    } satisfies ChooseReplacePayload);
+  };
+
+  getOptionCoords = (line: string) => {
+    const lineText = line.slice("% option ".length);
+    const numbers = lineText.slice(lineText.lastIndexOf('"') + 2);
+
+    return numbers === "" ? undefined : numbers.split(" ").map(Number);
+  };
+
+  getDefaultState = (): ChoosePluginModelState => ({ options: [], args: {}, isShow: false });
+}

package/src/modules/controller.ts

@@ -0,0 +1,51 @@
+import { ModuleController } from "@vnejs/module.components";
+
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChoosePluginControllerState } from "../utils/choose.js";
+
+export class ChooseController extends ModuleController<
+  ChoosePluginEvents,
+  ChoosePluginConstants,
+  ChoosePluginSettings,
+  ChoosePluginParams,
+  ChoosePluginControllerState
+> {
+  name = "choose.controller";
+
+  maxCurrentItem = 0;
+  updateEvent = this.EVENTS.CHOOSE.UPDATE;
+
+  controls = {
+    [this.CONST.CONTROLS.BUTTONS.ARROW_UP]: () => this.onArrow(this.decCurrentItem),
+    [this.CONST.CONTROLS.BUTTONS.ARROW_BOTTOM]: () => this.onArrow(this.incCurrentItem),
+    [this.CONST.CONTROLS.BUTTONS.ACCEPT]: () => {
+      if (this.currentItem !== null) void this.emit(this.EVENTS.CHOOSE.OPTION, { index: this.currentItem });
+    },
+  };
+  controlsIndex = this.PARAMS.CHOOSE.ZINDEX;
+
+  subscribe = () => {
+    this.on(this.EVENTS.CHOOSE.SHOW, this.onShow);
+    this.on(this.EVENTS.CHOOSE.HIDE, this.onHide);
+  };
+
+  init = () => {
+    Object.assign(this.controls, this.PARAMS.CHOOSE.CONTROLS_EXTENSIONS);
+  };
+
+  beforeShow = async () => {
+    const state = (await this.emitOne(this.EVENTS.VENDORS.CLONE, this.globalState.choose)) as ChoosePluginControllerState;
+
+    this.updateState(state);
+    this.maxCurrentItem = this.state.options.length - 1;
+
+    await this.emit(this.EVENTS.CHOOSE.SHOW_BEFORE);
+  };
+
+  afterHide = () => this.setDefaultState();
+
+  onArrow = (cb: () => void) => {
+    cb();
+    while (this.currentItem !== null && this.state.options?.[this.currentItem]?.hided) cb();
+  };
+}

package/src/modules/exec.ts

@@ -0,0 +1,24 @@
+import { Module } from "@vnejs/module";
+
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChooseExecGetPayload, ChooseExecRegPayload } from "../utils/choose.js";
+
+export class ChooseExec extends Module<ChoosePluginEvents, ChoosePluginConstants, ChoosePluginSettings, ChoosePluginParams> {
+  name = "choose.exec";
+
+  handlers: Record<string, (payload: ChooseExecGetPayload) => unknown> = {};
+
+  subscribe = () => {
+    this.on(this.EVENTS.CHOOSE.EXEC_REG, this.onChooseExecReg);
+    this.on(this.EVENTS.CHOOSE.EXEC_GET, this.onChooseExecGet);
+  };
+
+  onChooseExecReg = ({ handler, module = "" }: ChooseExecRegPayload = {}) => {
+    if (handler) this.handlers[module] = handler;
+  };
+
+  onChooseExecGet = ({ module = "", line = "", keywords = [] }: ChooseExecGetPayload = {}) => {
+    if (typeof this.handlers[module] === "function") return this.handlers[module]({ line, keywords });
+    return "";
+  };
+}

package/src/modules/scenario.ts

@@ -0,0 +1,30 @@
+import { Module } from "@vnejs/module";
+
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChooseEmitPayload, ChooseOptionLine } from "../utils/choose.js";
+
+export class ChooseScenario extends Module<ChoosePluginEvents, ChoosePluginConstants, ChoosePluginSettings, ChoosePluginParams> {
+  name = "choose.scenario";
+
+  execName = "choose";
+
+  init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: this.execName, handler: this.onLineExec });
+
+  onLineExec = async ({ args = {} }: { args?: Record<string, unknown> } = {}) => {
+    const [{ curLine = 0, label }, optionsArr] = [this.globalState.scenario, [] as number[]];
+    const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label })) as ChooseOptionLine[];
+
+    let indexShift = 1;
+    let curLineObj = lines[curLine + indexShift];
+
+    while (curLineObj && (curLineObj.indent ?? 0) >= (lines[curLine]?.indent ?? 0)) {
+      curLineObj.line.startsWith("% 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] }));
+
+    await this.emit(this.EVENTS.CHOOSE.EMIT, { args, options } satisfies ChooseEmitPayload);
+  };
+}

package/src/modules/view.ts

@@ -0,0 +1,21 @@
+import { ModuleView } from "@vnejs/module.components";
+
+import { render } from "../view/index.js";
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChoosePluginControllerState } from "../utils/choose.js";
+
+export class ChooseView extends ModuleView<
+  ChoosePluginEvents,
+  ChoosePluginConstants,
+  ChoosePluginSettings,
+  ChoosePluginParams,
+  ChoosePluginControllerState
+> {
+  name = "choose.view";
+
+  animationTime = this.PARAMS.CHOOSE.TRANSITION;
+  updateEvent = this.EVENTS.CHOOSE.UPDATE;
+
+  renderFunc = render;
+  updateHandler = this.onUpdateStoreComponent;
+}

package/src/types.ts

@@ -0,0 +1,24 @@
+import type { ModuleComponentsConstants, ModuleComponentsEvents, ModuleComponentsParams, ModuleComponentsSettings } from "@vnejs/module.components";
+import type { Constants as ControlsConstants, PluginName as ControlsPluginName } from "@vnejs/plugins.controls.contract";
+import type { PluginName as LogsPluginName, SubscribeEvents as LogsSubscribeEvents } from "@vnejs/plugins.core.logs.contract";
+import type { Constants as ScenarioConstants, PluginName as ScenarioPluginName, SubscribeEvents as ScenarioSubscribeEvents } from "@vnejs/plugins.core.scenario.contract";
+import type { PluginName as StatePluginName, SubscribeEvents as StateSubscribeEvents } from "@vnejs/plugins.core.state.contract";
+import type { PluginName as VendorsPluginName, SubscribeEvents as VendorsSubscribeEvents } from "@vnejs/plugins.core.vendors.contract";
+import type { PluginName as TextPluginName, SubscribeEvents as TextSubscribeEvents } from "@vnejs/plugins.text.contract";
+import type { Params, PluginName, SubscribeEvents } from "@vnejs/plugins.views.scenario.choose.contract";
+
+export type ChoosePluginEvents = ModuleComponentsEvents &
+  Record<PluginName, SubscribeEvents> &
+  Record<ScenarioPluginName, ScenarioSubscribeEvents> &
+  Record<StatePluginName, StateSubscribeEvents> &
+  Record<VendorsPluginName, VendorsSubscribeEvents> &
+  Record<LogsPluginName, LogsSubscribeEvents> &
+  Record<TextPluginName, TextSubscribeEvents>;
+
+export type ChoosePluginConstants = ModuleComponentsConstants &
+  Record<ControlsPluginName, ControlsConstants> &
+  Record<ScenarioPluginName, ScenarioConstants>;
+
+export type ChoosePluginSettings = ModuleComponentsSettings;
+
+export type ChoosePluginParams = ModuleComponentsParams & Record<PluginName, Params>;

package/src/utils/choose.ts

@@ -0,0 +1,54 @@
+import type { ModuleControllerState } from "@vnejs/module.components";
+
+export type ChooseOptionLine = {
+  line: string;
+  args?: Record<string, unknown>;
+  indent?: number;
+};
+
+export type ChooseOption = {
+  index: number;
+  text?: string;
+  coords?: number[];
+  hided?: boolean;
+  disabled?: boolean;
+  [key: string]: unknown;
+};
+
+export type ChoosePluginModelState = {
+  options: ChooseOption[];
+  args: Record<string, unknown>;
+  isShow: boolean;
+};
+
+export type ChoosePluginControllerState = ModuleControllerState &
+  ChoosePluginModelState & {
+    currentItem?: number | null;
+  };
+
+export type ChooseEmitPayload = {
+  options?: { index: number; optionLine: ChooseOptionLine }[];
+  args?: Record<string, unknown>;
+};
+
+export type ChooseOptionPayload = {
+  index?: number;
+};
+
+export type ChooseExecRegPayload = {
+  handler?: (payload: ChooseExecGetPayload) => unknown;
+  module?: string;
+};
+
+export type ChooseExecGetPayload = {
+  module?: string;
+  line?: string;
+  keywords?: string[];
+};
+
+export type ChooseReplacePayload = {
+  text?: string;
+  args?: Record<string, unknown>;
+  label?: string;
+  state?: Record<string, unknown>;
+};

package/src/view/index.tsx

@@ -0,0 +1,83 @@
+import type { ViewRenderFunc } from "@vnejs/module.components";
+import type { ReactComponentProps } from "@vnejs/uis.react";
+import { PositionBox, Screen, Text, TextControls, createRenderFunc, useCallback, useIsForceHook, useMemo, useStoreState } from "@vnejs/uis.react";
+
+import type { ChoosePluginConstants, ChoosePluginEvents, ChoosePluginParams, ChoosePluginSettings } from "../types.js";
+import type { ChooseOption, ChoosePluginControllerState } from "../utils/choose.js";
+
+type ChooseComponentProps = ReactComponentProps<
+  ChoosePluginEvents,
+  ChoosePluginConstants,
+  ChoosePluginSettings,
+  ChoosePluginParams,
+  ChoosePluginControllerState
+>;
+
+type OptionWithCoordsProps = {
+  text?: string;
+  isDisabled?: boolean;
+  isNotRender?: boolean;
+  value?: number;
+  coords?: number[];
+  props: ChooseComponentProps;
+  currentItem?: number | null;
+  onClick: (value?: unknown) => void;
+};
+
+const renderOptionWithCoords = ({ text, isDisabled, isNotRender, value, coords, props, currentItem, onClick }: OptionWithCoordsProps) => {
+  const [x = 0, y = 0] = coords ?? [];
+  const positionProps = { left: `${x}%`, top: `${y}%`, translateX: "-50%", translateY: "-50%", isNotRender };
+  const propsText = { ...props.PARAMS.CHOOSE.VIEW_PROPS.text, isDisabled, onClick, text, value, isSelected: currentItem === value };
+
+  return (
+    <PositionBox
+      {...positionProps}
+      key={value}
+    >
+      <Text {...propsText} />
+    </PositionBox>
+  );
+};
+
+const Choose = ({ store, onMount, emit, EVENTS, PARAMS }: ChooseComponentProps) => {
+  const { isShow = false, isForce = false, options = [], currentItem = null } = useStoreState<ChoosePluginControllerState>(store, onMount);
+
+  const onClick = useCallback((value?: unknown) => void emit(EVENTS.CHOOSE.OPTION, { index: Number(value) }), [emit, EVENTS.CHOOSE.OPTION]);
+
+  const isRealForce = useIsForceHook(isForce);
+
+  const optionsMapped = useMemo(
+    () => options.map(({ text, hided, coords, disabled }: ChooseOption, i: number) => ({ text, i, coords, isNotRender: Boolean(hided), isDisabled: Boolean(disabled) })),
+    [options],
+  );
+  const textsInfo = useMemo(
+    () => optionsMapped.map(({ i, ...obj }) => ({ value: i, isSelected: currentItem === i, ...obj })),
+    [optionsMapped, currentItem],
+  );
+  const optionsRegular = useMemo(() => textsInfo.filter((e) => !e.coords), [textsInfo]);
+  const optionsWithCoords = useMemo(() => textsInfo.filter((e) => e.coords), [textsInfo]);
+
+  const propsView = PARAMS.CHOOSE.VIEW_PROPS;
+
+  const propsScreen = useMemo(
+    () => ({ ...propsView.screen, isDisableAutoread: true, isIgnoreOnScreenshot: false, isShow, isForce: isRealForce }),
+    [isShow, isRealForce, propsView.screen],
+  );
+  const propsControls = useMemo(() => ({ ...propsView.controls, texts: optionsRegular, onClick }), [optionsRegular, onClick, propsView.controls]);
+
+  const optionsWithCoordsWithProps = useMemo(
+    () => optionsWithCoords.map((option) => ({ ...option, currentItem, onClick, props: { store, onMount, emit, EVENTS, PARAMS } as ChooseComponentProps })),
+    [optionsWithCoords, currentItem, onClick, store, onMount, emit, EVENTS, PARAMS],
+  );
+
+  return (
+    <Screen {...propsScreen}>
+      {optionsWithCoordsWithProps.map(renderOptionWithCoords)}
+      <PositionBox {...propsView.position}>
+        <TextControls {...propsControls} />
+      </PositionBox>
+    </Screen>
+  );
+};
+
+export const render: ViewRenderFunc<ChoosePluginControllerState> = createRenderFunc(Choose);

package/tsconfig.json

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

package/const/events.js

@@ -1,9 +0,0 @@
-export const SUBSCRIBE_EVENTS = {
-  EMIT: "vne:choose:emit",
-  OPTION: "vne:choose:option",
-  SHOW: "vne:choose:show",
-  HIDE: "vne:choose:hide",
-  UPDATE: "vne:choose:update",
-  EXEC_REG: "vne:choose:exec_reg",
-  EXEC_GET: "vne:choose:exec_get",
-};

package/const/params.js

@@ -1,11 +0,0 @@
-export const TRANSITION = 300;
-export const ZINDEX = 1200;
-
-export const VIEW_PROPS = {
-  screen: { withBlur: true, withDark: true, zIndex: ZINDEX, transition: TRANSITION },
-  position: { isCentered: true },
-  controls: { flexDirection: "column", flexGap: 60, textSize: 96, textAlign: "center" },
-  text: { size: 96 },
-};
-
-export const CONTROLS_EXTENSIONS = {};

package/index.js

@@ -1,12 +0,0 @@
-import { regPlugin } from "@vnejs/shared";
-
-import { SUBSCRIBE_EVENTS } from "./const/events";
-import * as params from "./const/params";
-
-import { Choose } from "./modules/choose";
-import { ChooseController } from "./modules/controller";
-import { ChooseExec } from "./modules/exec";
-import { ChooseScenario } from "./modules/scenario";
-import { ChooseView } from "./modules/view";
-
-regPlugin("CHOOSE", { events: SUBSCRIBE_EVENTS, params }, [Choose, ChooseController, ChooseExec, ChooseScenario, ChooseView]);

package/modules/choose.js

@@ -1,75 +0,0 @@
-import { splitLineKeywords } from "@vnejs/helpers";
-import { Module } from "@vnejs/module";
-
-export class Choose extends Module {
-  name = "choose";
-
-  subscribe = () => {
-    this.on(this.EVENTS.CHOOSE.EMIT, this.onChooseEmit);
-    this.on(this.EVENTS.CHOOSE.OPTION, this.onChooseOption);
-
-    this.on(this.EVENTS.STATE.SET, this.onStateSet);
-    this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
-  };
-
-  onChooseEmit = async ({ options, args } = {}) => {
-    this.emit(this.EVENTS.LOGS.EMIT, { module: this.name, value: { action: "emit", options, args } });
-    this.updateState({ isShow: true, options: await this.getRealOptions(options), args });
-    await this.emit(this.EVENTS.CHOOSE.SHOW);
-  };
-  onChooseOption = async ({ index = 0 } = {}) => {
-    this.emit(this.EVENTS.LOGS.EMIT, { module: this.name, value: { action: "choose", index } });
-    this.globalState.scenario.curLine = this.state.options[index].index + 1;
-    await this.emit(this.EVENTS.CHOOSE.HIDE);
-    this.setDefaultState();
-    this.emit(this.EVENTS.SCENARIO.NEXT, { module: this.name });
-  };
-
-  onStateSet = async ({ [this.name]: state } = {}) => {
-    const clonedState = await this.emitOne(this.EVENTS.VENDORS.CLONE, state);
-
-    if (this.state.isShow === clonedState.isShow) return;
-
-    this.state.args = clonedState.args;
-    this.state.options = clonedState.options;
-
-    return this.emit(state.isShow ? this.EVENTS.CHOOSE.SHOW : this.EVENTS.CHOOSE.HIDE, { isForce: true });
-  };
-  onStateClear = () => {
-    this.setDefaultState();
-
-    return this.emit(this.EVENTS.CHOOSE.HIDE, { isForce: true });
-  };
-
-  getRealOptions = async (options = []) => Promise.all(options.map(this.mapOptions));
-  mapOptions = async ({ optionLine, index } = {}) => {
-    const text = await this.getOptionText(optionLine.line, optionLine.args);
-    const result = { index, text, coords: this.getOptionCoords(optionLine.line), ...optionLine.args };
-
-    await Promise.all(
-      Object.keys(optionLine.args).map(async (key) => {
-        if (typeof optionLine.args[key] !== "string" || !optionLine.args[key].startsWith(this.CONST.SCENARIO.LINE_PREFIXES.MODULE)) return;
-
-        const { line = "", module = "", keywords = [] } = splitLineKeywords(optionLine.args[key]);
-
-        result[key] = await this.emitOne(this.EVENTS.CHOOSE.EXEC_GET, { line, module, keywords });
-      }),
-    );
-
-    return result;
-  };
-  getOptionText = (line, args) => {
-    const quotedText = line.slice(line.indexOf('"'), line.lastIndexOf('"') + 1);
-    const text = quotedText.slice(1, quotedText.length - 1);
-
-    return this.emitOne(this.EVENTS.TEXT.REPLACE, { text, args, label: this.globalState.scenario.label, state: this.globalState });
-  };
-  getOptionCoords = (line) => {
-    const lineText = line.slice("% option ".length);
-    const numbers = lineText.slice(lineText.lastIndexOf('"') + 2);
-
-    return numbers === "" ? undefined : numbers.split(" ").map(Number);
-  };
-
-  getDefaultState = () => ({ options: [], args: {}, isShow: false });
-}

package/modules/controller.js

@@ -1,38 +0,0 @@
-import { ModuleController } from "@vnejs/module.components";
-
-export class ChooseController extends ModuleController {
-  name = "choose.controller";
-
-  maxCurrentItem = 0;
-  updateEvent = this.EVENTS.CHOOSE.UPDATE;
-
-  controls = {
-    [this.CONST.CONTROLS.BUTTONS.ARROW_UP]: () => this.onArrow(this.decCurrentItem),
-    [this.CONST.CONTROLS.BUTTONS.ARROW_BOTTOM]: () => this.onArrow(this.incCurrentItem),
-    [this.CONST.CONTROLS.BUTTONS.ACCEPT]: () => this.currentItem !== null && this.emit(this.EVENTS.CHOOSE.OPTION, { index: this.currentItem }),
-  };
-  controlsIndex = this.PARAMS.CHOOSE.ZINDEX;
-
-  subscribe = () => {
-    this.on(this.EVENTS.CHOOSE.SHOW, this.onShow);
-    this.on(this.EVENTS.CHOOSE.HIDE, this.onHide);
-  };
-  init = () => {
-    Object.assign(this.controls, this.PARAMS.CHOOSE.CONTROLS_EXTENSIONS);
-  };
-
-  beforeShow = async () => {
-    const state = await this.emitOne(this.EVENTS.VENDORS.CLONE, this.globalState.choose);
-
-    this.updateState(state);
-    this.maxCurrentItem = this.state.options.length - 1;
-
-    return this.emit(this.EVENTS.INTERFACE.HIDE);
-  };
-  afterHide = () => this.setDefaultState();
-
-  onArrow = (cb) => {
-    cb();
-    while (this.state.options?.[this.currentItem].hided) cb();
-  };
-}

package/modules/exec.js

@@ -1,21 +0,0 @@
-import { Module } from "@vnejs/module";
-
-export class ChooseExec extends Module {
-  name = "choose.exec";
-
-  handlers = {};
-
-  subscribe = () => {
-    this.on(this.EVENTS.CHOOSE.EXEC_REG, this.onChooseExecReg);
-    this.on(this.EVENTS.CHOOSE.EXEC_GET, this.onChooseExecGet);
-  };
-
-  onChooseExecReg = ({ handler, module } = {}) => {
-    this.handlers[module] = handler;
-  };
-
-  onChooseExecGet = ({ module, line = "", keywords = [] } = {}) => {
-    if (typeof this.handlers[module] === "function") return this.handlers[module]({ line, keywords });
-    return "";
-  };
-}

package/modules/scenario.js

@@ -1,26 +0,0 @@
-import { Module } from "@vnejs/module";
-
-export class ChooseScenario extends Module {
-  name = "choose.scenario";
-
-  execName = "choose";
-
-  init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: this.execName, handler: this.onLineExec });
-
-  onLineExec = async ({ args = {} } = {}) => {
-    const [{ curLine = 0, label }, optionsArr] = [this.globalState.scenario, []];
-    const lines = await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label });
-
-    let [indexShift, curLineObj] = [1, lines[curLine + 1]];
-
-    while (curLineObj && curLineObj.indent >= lines[curLine].indent) {
-      curLineObj.line.startsWith("% option") && curLineObj.indent === lines[curLine].indent + 2 && optionsArr.push(curLine + indexShift);
-      indexShift++;
-      curLineObj = lines[curLine + indexShift];
-    }
-
-    const options = optionsArr.map((index) => ({ index, optionLine: lines[index] }));
-
-    await this.emit(this.EVENTS.CHOOSE.EMIT, { args, options });
-  };
-}

package/modules/view.js

@@ -1,13 +0,0 @@
-import { ModuleView } from "@vnejs/module.components";
-
-import { render } from "../view";
-
-export class ChooseView extends ModuleView {
-  name = "choose.view";
-
-  animationTime = this.PARAMS.CHOOSE.TRANSITION;
-  updateEvent = this.EVENTS.CHOOSE.UPDATE;
-
-  renderFunc = render;
-  updateHandler = this.onUpdateStoreComponent;
-}

package/view/index.jsx

@@ -1,66 +0,0 @@
-import { useCallback, useEffect, useMemo, useState } from "react";
-import { createRoot } from "react-dom/client";
-
-import { PositionBox, Screen, Text, TextControls, useIsForceHook } from "@vnejs/uis.react";
-
-const EMPTY_ARRAY = [];
-
-const renderOptionWithCoords = ({ text, isDisabled, isNotRender, value, coords: [x, y], props, currentItem, onClick } = {}) => {
-  const positionProps = { left: `${x}%`, top: `${y}%`, translateX: "-50%", translateY: "-50%", isNotRender };
-  const propsText = { ...props.PARAMS.CHOOSE.VIEW_PROPS.text, isDisabled, onClick, text, value, isSelected: currentItem === value };
-
-  return (
-    <PositionBox
-      {...positionProps}
-      key={value}
-    >
-      <Text {...propsText} />
-    </PositionBox>
-  );
-};
-
-const Choose = ({ store, onMount, ...props } = {}) => {
-  const [{ isShow = false, isForce = false, options = EMPTY_ARRAY, currentItem = null }, setState] = useState({});
-
-  useEffect(() => store.subscribe(setState), []);
-  useEffect(() => void onMount(), []);
-
-  const onClick = useCallback((index) => props.emit(props.EVENTS.CHOOSE.OPTION, { index }), []);
-
-  const isRealForce = useIsForceHook(isForce);
-
-  const optionsMapped = useMemo(
-    () => options.map(({ text, hided, coords, disabled }, i) => ({ text, i, coords, isNotRender: Boolean(hided), isDisabled: Boolean(disabled) })),
-    [options],
-  );
-  const textsInfo = useMemo(
-    () => optionsMapped.map(({ i, ...obj } = {}) => ({ value: i, isSelected: currentItem === i, ...obj })),
-    [optionsMapped, currentItem],
-  );
-  const optionsRegular = useMemo(() => textsInfo.filter((e) => !e.coords), [textsInfo]);
-  const optionsWithCoords = useMemo(() => textsInfo.filter((e) => e.coords), [textsInfo]);
-
-  const propsView = props.PARAMS.CHOOSE.VIEW_PROPS;
-
-  const propsScreen = useMemo(
-    () => ({ ...propsView.screen, isDisableAutoread: true, isIgnoreOnScreenshot: false, isShow, isForce: isRealForce }),
-    [isShow, isRealForce],
-  );
-  const propsControls = useMemo(() => ({ ...propsView.controls, texts: optionsRegular, onClick }), [optionsRegular]);
-
-  const optionsWithCoordsWithProps = useMemo(
-    () => optionsWithCoords.map((option) => ({ ...option, currentItem, onClick, props })),
-    [optionsWithCoords, currentItem, onClick],
-  );
-
-  return (
-    <Screen {...propsScreen}>
-      {optionsWithCoordsWithProps.map(renderOptionWithCoords)}
-      <PositionBox {...propsView.position}>
-        <TextControls {...propsControls} />
-      </PositionBox>
-    </Screen>
-  );
-};
-
-export const render = (props, root) => createRoot(root).render(<Choose {...props} />);