@vnejs/plugins.views.scenario.interface 0.2.3 → 0.2.4

package/dist/index.js

@@ -1,8 +1,18 @@
 import "@vnejs/contracts.views.scenario.interface";
 import "@vnejs/contracts.text.meet";
 import { regPlugin } from "@vnejs/shared";
-import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.scenario.interface";
+import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.scenario.interface";
 import { InterfaceController } from "./modules/controller.js";
+import { InterfaceControllerAccept } from "./modules/controller.accept.js";
+import { InterfaceActions } from "./modules/actions.js";
 import { Interface } from "./modules/interface.js";
+import { InterfaceScenario } from "./modules/scenario.js";
 import { InterfaceView } from "./modules/view.js";
-regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS }, [InterfaceController, Interface, InterfaceView]);
+regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
+    InterfaceController,
+    InterfaceControllerAccept,
+    Interface,
+    InterfaceActions,
+    InterfaceScenario,
+    InterfaceView,
+]);

package/dist/modules/actions.d.ts

@@ -0,0 +1,15 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
+import type { InterfaceForcePayload, InterfaceViewPayload } from "../utils/interface.js";
+export declare class InterfaceActions extends ModuleCore<InterfacePluginEvents, InterfacePluginConstants, InterfacePluginSettings, InterfacePluginParams> {
+    name: string;
+    subscribe: () => void;
+    onShow: ({ isForce }?: InterfaceForcePayload) => false | Promise<unknown[] | undefined>;
+    onHide: ({ isForce }?: InterfaceForcePayload) => false | Promise<unknown[] | undefined>;
+    onVisible: ({ isForce }?: InterfaceForcePayload) => Promise<unknown[]> | undefined;
+    onTextHide: () => Promise<unknown[]> | undefined;
+    onView: ({ view, isForce }?: InterfaceViewPayload) => Promise<void>;
+    setShow: (isShow: boolean, isForce?: boolean) => Promise<unknown[] | undefined>;
+    setVisible: (isVisible: boolean, isForce?: boolean) => Promise<unknown[]> | undefined;
+    setView: (view?: string, isForce?: boolean) => Promise<void>;
+}

package/dist/modules/actions.js

@@ -0,0 +1,31 @@
+import { ModuleCore } from "@vnejs/module.core";
+export class InterfaceActions extends ModuleCore {
+    name = "interface.actions";
+    subscribe = () => {
+        this.on(this.EVENTS.INTERFACE.SHOW, this.onShow);
+        this.on(this.EVENTS.INTERFACE.HIDE, this.onHide);
+        this.on(this.EVENTS.INTERFACE.VISIBLE, this.onVisible);
+        this.on(this.EVENTS.INTERFACE.TEXT_HIDE, this.onTextHide);
+        this.on(this.EVENTS.INTERFACE.VIEW, this.onView);
+    };
+    onShow = ({ isForce = false } = {}) => !this.globalState.interface.isShow && this.setShow(true, isForce);
+    onHide = ({ isForce = false } = {}) => this.globalState.interface.isShow && this.setShow(false, isForce);
+    onVisible = ({ isForce = false } = {}) => this.setVisible(!this.globalState.interface.isVisible, isForce);
+    onTextHide = () => this.emit(this.EVENTS.INTERFACE.TEXT_CHANGED, { tokens: [], uid: "", tokensVisible: 0 });
+    onView = ({ view, isForce = false } = {}) => this.setView(view, isForce);
+    setShow = async (isShow, isForce = false) => {
+        this.globalState.interface.isShow = isShow;
+        if (isShow && !this.globalState.interface.isVisible)
+            await this.setVisible(true, isForce);
+        return this.emit(this.EVENTS.INTERFACE.SHOW_CHANGED, { isForce });
+    };
+    setVisible = (isVisible, isForce = false) => {
+        this.globalState.interface.isVisible = isVisible;
+        return this.emit(this.EVENTS.INTERFACE.VISIBLE_CHANGED, { isForce });
+    };
+    setView = async (view, isForce = false) => {
+        this.globalState.interface.view = view ?? "";
+        await this.emit(this.EVENTS.INTERFACE.VIEW_CHANGED, { isForce });
+        await this.waitRerender();
+    };
+}

package/dist/modules/controller.accept.d.ts

@@ -0,0 +1,10 @@
+import { ModuleControllerAccept } from "@vnejs/module.controller.accept";
+import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
+export declare class InterfaceControllerAccept extends ModuleControllerAccept<InterfacePluginEvents, InterfacePluginConstants, InterfacePluginSettings, InterfacePluginParams> {
+    name: string;
+    EVENT_SHOW: "vne:interface:view_show";
+    EVENT_HIDE: "vne:interface:view_hide";
+    EVENT_ACCEPT: "vne:interface:interact";
+    CONTROLS_ZINDEX: number;
+    onAccept: () => undefined;
+}

package/dist/modules/controller.accept.js

@@ -0,0 +1,9 @@
+import { ModuleControllerAccept } from "@vnejs/module.controller.accept";
+export class InterfaceControllerAccept extends ModuleControllerAccept {
+    name = "interface.controller.accept";
+    EVENT_SHOW = this.EVENTS.INTERFACE.VIEW_SHOW;
+    EVENT_HIDE = this.EVENTS.INTERFACE.VIEW_HIDE;
+    EVENT_ACCEPT = this.EVENTS.INTERFACE.INTERACT;
+    CONTROLS_ZINDEX = this.PARAMS.INTERFACE.ZINDEX;
+    onAccept = () => void this.emit(this.globalState.interface.isVisible ? this.EVENTS.INTERACT.EMIT : this.EVENTS.INTERFACE.VISIBLE);
+}

package/dist/modules/controller.d.ts

@@ -4,10 +4,7 @@ import type { InterfaceForcePayload, InterfacePluginState, InterfaceSpeakerChang
 export declare class InterfaceController extends ModuleController<InterfacePluginEvents, InterfacePluginConstants, InterfacePluginSettings, InterfacePluginParams, InterfacePluginState> {
     name: string;
     EVENT_UPDATE_VIEW: "vne:interface:view_update";
-    CONTROLS: {
-        abstract_interact: () => undefined;
-        abstract_accept: () => undefined;
-    };
+    CONTROLS: {};
     CONTROLS_UNVISIBLE: {};
     CONTROLS_INDEX: number;
     isStateChangeInProcess: boolean;

package/dist/modules/controller.js

@@ -1,13 +1,9 @@
 import { ModuleController } from "@vnejs/module.components";
-import { CONSTANTS as ControlsConstants } from "@vnejs/contracts.controls";
 import { getTextSpeakerInfo } from "@vnejs/contracts.text";
 export class InterfaceController extends ModuleController {
     name = "interface.controller";
     EVENT_UPDATE_VIEW = this.EVENTS.INTERFACE.VIEW_UPDATE;
-    CONTROLS = {
-        [ControlsConstants.BUTTONS.INTERACT]: () => void this.emit(this.EVENTS.INTERFACE.INTERACT),
-        [ControlsConstants.BUTTONS.ACCEPT]: () => void this.emit(this.EVENTS.INTERFACE.INTERACT),
-    };
+    CONTROLS = {};
     CONTROLS_UNVISIBLE = {};
     CONTROLS_INDEX = this.PARAMS.INTERFACE.ZINDEX;
     isStateChangeInProcess = false;

package/dist/modules/interface.d.ts

@@ -1,30 +1,11 @@
 import { ModuleCore, type ModuleGlobalStateRegistry } from "@vnejs/module.core";
-import type { LineExecHandlerArg } from "@vnejs/module.core";
-import type { InterfaceVisibleTokensChangedPayload } from "@vnejs/contracts.views.scenario.interface";
 import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
-import type { InterfaceForcePayload, InterfaceModuleState, InterfaceSpeakerChangedPayload, InterfaceTextChangedPayload, InterfaceViewPayload } from "../utils/interface.js";
+import type { InterfaceModuleState } from "../utils/interface.js";
 export declare class Interface extends ModuleCore<InterfacePluginEvents, InterfacePluginConstants, InterfacePluginSettings, InterfacePluginParams, InterfaceModuleState> {
     name: string;
     subscribe: () => void;
-    init: () => Promise<[unknown[] | undefined, unknown[] | undefined]>;
-    onLineExec: ({ line }?: LineExecHandlerArg) => Promise<void>;
-    onInteract: () => Promise<unknown[]> | undefined;
-    onShow: ({ isForce }?: InterfaceForcePayload) => false | Promise<unknown[] | undefined>;
-    onHide: ({ isForce }?: InterfaceForcePayload) => false | Promise<unknown[] | undefined>;
-    onVisible: ({ isForce }?: InterfaceForcePayload) => Promise<unknown[]> | undefined;
-    onTextChanged: ({ tokens, uid }?: InterfaceTextChangedPayload) => Promise<unknown[]> | undefined;
-    onVisibleTokensChanged: ({ tokensVisible, uid }?: InterfaceVisibleTokensChangedPayload) => Promise<unknown[]> | undefined;
-    onTextSpeakerChanged: ({ speaker }?: InterfaceSpeakerChangedPayload) => Promise<unknown[]> | undefined;
-    onTextEmitBefore: () => Promise<unknown[]> | undefined;
-    onTextHide: () => Promise<unknown[]> | undefined;
-    onView: ({ view, isForce }?: InterfaceViewPayload) => Promise<void>;
     onStateSet: (payload: ModuleGlobalStateRegistry) => Promise<unknown[]> | undefined;
     onStateClear: () => Promise<unknown[]> | undefined;
-    setView: (view?: string, isForce?: boolean) => Promise<void>;
-    setShow: (isShow: boolean, isForce?: boolean) => Promise<unknown[] | undefined>;
-    setVisible: (isVisible: boolean, isForce?: boolean) => Promise<unknown[]> | undefined;
-    emitTextChanged: (tokens?: InterfaceTextChangedPayload["tokens"], uid?: string, tokensVisible?: number) => Promise<unknown[]> | undefined;
-    emitSpeakerChanged: (speaker?: string) => Promise<unknown[]> | undefined;
     setNewState: (view?: string, isVisible?: boolean, isShow?: boolean) => Promise<unknown[]> | undefined;
     getDefaultState: () => InterfaceModuleState;
 }

package/dist/modules/interface.js

@@ -1,73 +1,15 @@
 import { ModuleCore } from "@vnejs/module.core";
-import { tokenizeExecLine } from "@vnejs/helpers";
 export class Interface extends ModuleCore {
     name = "interface";
     subscribe = () => {
-        this.on(this.EVENTS.INTERFACE.INTERACT, this.onInteract);
-        this.on(this.EVENTS.INTERFACE.SHOW, this.onShow);
-        this.on(this.EVENTS.INTERFACE.HIDE, this.onHide);
-        this.on(this.EVENTS.INTERFACE.VISIBLE, this.onVisible);
-        this.on(this.EVENTS.INTERFACE.TEXT_HIDE, this.onTextHide);
-        this.on(this.EVENTS.INTERFACE.VIEW, this.onView);
-        this.on(this.EVENTS.INTERFACE.VISIBLE_TOKENS_CHANGED, this.onVisibleTokensChanged);
-        this.on(this.EVENTS.TEXT.CHANGED, this.onTextChanged);
-        this.on(this.EVENTS.TEXT.SPEAKER_CHANGED, this.onTextSpeakerChanged);
         this.on(this.EVENTS.STATE.SET, this.onStateSet);
         this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
     };
-    init = () => {
-        this.shared.interfaceTextShowAllTokensOnChange = true;
-        return Promise.all([
-            this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: this.name, handler: this.onLineExec }),
-            this.emit(this.EVENTS.TEXT.EMIT_BEFORE_REG, { handler: this.onTextEmitBefore }),
-        ]);
-    };
-    onLineExec = async ({ line = "" } = {}) => {
-        const isForce = this.shared.viewForceAnimationSources.isNotEmpty();
-        const [action = "", execArg = ""] = tokenizeExecLine(line);
-        if (action === "show")
-            await this.emit(this.EVENTS.INTERFACE.SHOW, { isForce });
-        if (action === "hide")
-            await this.emit(this.EVENTS.INTERFACE.HIDE, { isForce });
-        if (action === "view")
-            await this.emit(this.EVENTS.INTERFACE.VIEW, { view: execArg, isForce });
-        this.emitNext();
-    };
-    onInteract = () => this.emit(this.state.isVisible ? this.EVENTS.INTERACT.EMIT : this.EVENTS.INTERFACE.VISIBLE);
-    onShow = ({ isForce = false } = {}) => !this.state.isShow && this.setShow(true, isForce);
-    onHide = ({ isForce = false } = {}) => this.state.isShow && this.setShow(false, isForce);
-    onVisible = ({ isForce = false } = {}) => this.setVisible(!this.state.isVisible, isForce);
-    onTextChanged = ({ tokens = [], uid = "" } = {}) => {
-        const tokensVisible = this.shared.interfaceTextShowAllTokensOnChange ? tokens.length : 0;
-        return this.emitTextChanged(tokens, uid, tokensVisible);
-    };
-    onVisibleTokensChanged = ({ tokensVisible = 0, uid = "" } = {}) => this.emitTextChanged(this.globalState.text.tokens, uid, tokensVisible);
-    onTextSpeakerChanged = ({ speaker } = {}) => this.emitSpeakerChanged(speaker);
-    onTextEmitBefore = () => this.emit(this.EVENTS.INTERFACE.SHOW);
-    onTextHide = () => this.emitTextChanged([], "", 0);
-    onView = ({ view, isForce = false } = {}) => this.setView(view, isForce);
     onStateSet = (payload) => {
         const moduleState = this.getStateSlice(payload);
         return this.setNewState(moduleState?.view, moduleState?.isVisible, moduleState?.isShow);
     };
     onStateClear = () => this.setNewState(this.PARAMS.INTERFACE.DEFAULT_VIEW, false, false);
-    setView = async (view, isForce = false) => {
-        this.state.view = view ?? "";
-        await this.emit(this.EVENTS.INTERFACE.VIEW_CHANGED, { isForce });
-        await this.waitRerender();
-    };
-    setShow = async (isShow, isForce = false) => {
-        this.state.isShow = isShow;
-        if (isShow && !this.state.isVisible)
-            await this.setVisible(true, isForce);
-        return this.emit(this.EVENTS.INTERFACE.SHOW_CHANGED, { isForce });
-    };
-    setVisible = (isVisible, isForce = false) => {
-        this.state.isVisible = isVisible;
-        return this.emit(this.EVENTS.INTERFACE.VISIBLE_CHANGED, { isForce });
-    };
-    emitTextChanged = (tokens = [], uid = "", tokensVisible) => this.emit(this.EVENTS.INTERFACE.TEXT_CHANGED, { tokens, uid, tokensVisible });
-    emitSpeakerChanged = (speaker = "") => this.emit(this.EVENTS.INTERFACE.SPEAKER_CHANGED, { speaker });
     setNewState = (view, isVisible, isShow) => {
         Object.assign(this.state, { isShow, view, isVisible });
         return this.emit(this.EVENTS.INTERFACE.STATE_CHANGED);

package/dist/modules/scenario.d.ts

@@ -0,0 +1,9 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { LineExecHandlerArg } from "@vnejs/module.core";
+import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
+export declare class InterfaceScenario extends ModuleCore<InterfacePluginEvents, InterfacePluginConstants, InterfacePluginSettings, InterfacePluginParams> {
+    name: string;
+    execName: string;
+    init: () => Promise<unknown[]> | undefined;
+    onLineExec: ({ line }?: LineExecHandlerArg) => Promise<void>;
+}

package/dist/modules/scenario.js

@@ -0,0 +1,18 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { tokenizeExecLine } from "@vnejs/helpers";
+export class InterfaceScenario extends ModuleCore {
+    name = "interface.scenario";
+    execName = "interface";
+    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: this.execName, handler: this.onLineExec });
+    onLineExec = async ({ line = "" } = {}) => {
+        const isForce = this.shared.viewForceAnimationSources.isNotEmpty();
+        const [action = "", execArg = ""] = tokenizeExecLine(line);
+        if (action === this.CONST.INTERFACE.EXEC_ACTIONS.SHOW)
+            await this.emit(this.EVENTS.INTERFACE.SHOW, { isForce });
+        if (action === this.CONST.INTERFACE.EXEC_ACTIONS.HIDE)
+            await this.emit(this.EVENTS.INTERFACE.HIDE, { isForce });
+        if (action === this.CONST.INTERFACE.EXEC_ACTIONS.VIEW)
+            await this.emit(this.EVENTS.INTERFACE.VIEW, { view: execArg, isForce });
+        this.emitNext();
+    };
+}

package/dist/types.d.ts

@@ -4,11 +4,11 @@ import type { Constants as ControlsConstants, PluginName as ControlsPluginName }
 import type { PluginName as InteractPluginName, SubscribeEvents as InteractSubscribeEvents } from "@vnejs/contracts.core.interact";
 import type { 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 TextPluginName, Params as TextParams, SubscribeEvents as TextSubscribeEvents } from "@vnejs/contracts.text";
-import type { Params, PluginName, SubscribeEvents } from "@vnejs/contracts.views.scenario.interface";
+import type { PluginName as TextPluginName, Params as TextParams } from "@vnejs/contracts.text";
+import type { Constants, Params, PluginName, SubscribeEvents } from "@vnejs/contracts.views.scenario.interface";
 import type { InterfacePluginState } from "./utils/interface.js";
-export type InterfacePluginEvents = ModuleComponentsEvents & Record<PluginName, SubscribeEvents> & Record<ScenarioPluginName, ScenarioSubscribeEvents> & Record<StatePluginName, StateSubscribeEvents> & Record<TextPluginName, TextSubscribeEvents> & Record<InteractPluginName, InteractSubscribeEvents>;
-export type InterfacePluginConstants = ModuleComponentsConstants & Record<ControlsPluginName, ControlsConstants>;
+export type InterfacePluginEvents = ModuleComponentsEvents & Record<PluginName, SubscribeEvents> & Record<ScenarioPluginName, ScenarioSubscribeEvents> & Record<StatePluginName, StateSubscribeEvents> & Record<InteractPluginName, InteractSubscribeEvents>;
+export type InterfacePluginConstants = ModuleComponentsConstants & Record<ControlsPluginName, ControlsConstants> & Record<PluginName, Constants>;
 export type InterfacePluginSettings = ModuleComponentsSettings;
 export type InterfacePluginParams = ModuleComponentsParams & Record<PluginName, Params> & Record<TextPluginName, TextParams>;
 export type InterfacePluginViewState = InterfacePluginState & {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/plugins.views.scenario.interface",
-  "version": "0.2.3",
+  "version": "0.2.4",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,6 +36,7 @@
     "@vnejs/helpers": "~0.2.0",
     "@vnejs/module.core": "~0.2.0",
     "@vnejs/module.components": "~0.2.0",
+    "@vnejs/module.controller.accept": "~0.2.0",
     "@vnejs/contracts.text": "~0.2.0",
     "@vnejs/contracts.text.meet": "~0.2.0",
     "@vnejs/contracts.text.wall": "~0.2.0",
@@ -52,6 +53,7 @@
     "@vnejs/helpers": "~0.2.0",
     "@vnejs/module.core": "~0.2.0",
     "@vnejs/module.components": "~0.2.0",
+    "@vnejs/module.controller.accept": "~0.2.0",
     "@vnejs/contracts.text.meet": "~0.2.0",
     "@vnejs/contracts.text.wall": "~0.2.0",
     "@vnejs/shared": "~0.2.0",

package/src/index.ts

@@ -2,10 +2,20 @@ import "@vnejs/contracts.views.scenario.interface";
 import "@vnejs/contracts.text.meet";
 
 import { regPlugin } from "@vnejs/shared";
-import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.scenario.interface";
+import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.scenario.interface";
 
 import { InterfaceController } from "./modules/controller.js";
+import { InterfaceControllerAccept } from "./modules/controller.accept.js";
+import { InterfaceActions } from "./modules/actions.js";
 import { Interface } from "./modules/interface.js";
+import { InterfaceScenario } from "./modules/scenario.js";
 import { InterfaceView } from "./modules/view.js";
 
-regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS }, [InterfaceController, Interface, InterfaceView]);
+regPlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS }, [
+  InterfaceController,
+  InterfaceControllerAccept,
+  Interface,
+  InterfaceActions,
+  InterfaceScenario,
+  InterfaceView,
+]);

package/src/modules/actions.ts

@@ -0,0 +1,41 @@
+import { ModuleCore } from "@vnejs/module.core";
+
+import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
+import type { InterfaceForcePayload, InterfaceViewPayload } from "../utils/interface.js";
+
+export class InterfaceActions extends ModuleCore<InterfacePluginEvents, InterfacePluginConstants, InterfacePluginSettings, InterfacePluginParams> {
+  name = "interface.actions";
+
+  subscribe = () => {
+    this.on(this.EVENTS.INTERFACE.SHOW, this.onShow);
+    this.on(this.EVENTS.INTERFACE.HIDE, this.onHide);
+    this.on(this.EVENTS.INTERFACE.VISIBLE, this.onVisible);
+    this.on(this.EVENTS.INTERFACE.TEXT_HIDE, this.onTextHide);
+    this.on(this.EVENTS.INTERFACE.VIEW, this.onView);
+  };
+
+  onShow = ({ isForce = false }: InterfaceForcePayload = {}) => !this.globalState.interface.isShow && this.setShow(true, isForce);
+  onHide = ({ isForce = false }: InterfaceForcePayload = {}) => this.globalState.interface.isShow && this.setShow(false, isForce);
+  onVisible = ({ isForce = false }: InterfaceForcePayload = {}) => this.setVisible(!this.globalState.interface.isVisible, isForce);
+  onTextHide = () => this.emit(this.EVENTS.INTERFACE.TEXT_CHANGED, { tokens: [], uid: "", tokensVisible: 0 });
+  onView = ({ view, isForce = false }: InterfaceViewPayload = {}) => this.setView(view, isForce);
+
+  setShow = async (isShow: boolean, isForce = false) => {
+    this.globalState.interface.isShow = isShow;
+
+    if (isShow && !this.globalState.interface.isVisible) await this.setVisible(true, isForce);
+
+    return this.emit(this.EVENTS.INTERFACE.SHOW_CHANGED, { isForce });
+  };
+  setVisible = (isVisible: boolean, isForce = false) => {
+    this.globalState.interface.isVisible = isVisible;
+
+    return this.emit(this.EVENTS.INTERFACE.VISIBLE_CHANGED, { isForce });
+  };
+  setView = async (view?: string, isForce = false) => {
+    this.globalState.interface.view = view ?? "";
+
+    await this.emit(this.EVENTS.INTERFACE.VIEW_CHANGED, { isForce });
+    await this.waitRerender();
+  };
+}

package/src/modules/controller.accept.ts

@@ -0,0 +1,20 @@
+import { ModuleControllerAccept } from "@vnejs/module.controller.accept";
+
+import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
+
+export class InterfaceControllerAccept extends ModuleControllerAccept<
+  InterfacePluginEvents,
+  InterfacePluginConstants,
+  InterfacePluginSettings,
+  InterfacePluginParams
+> {
+  name = "interface.controller.accept";
+
+  EVENT_SHOW = this.EVENTS.INTERFACE.VIEW_SHOW;
+  EVENT_HIDE = this.EVENTS.INTERFACE.VIEW_HIDE;
+  EVENT_ACCEPT = this.EVENTS.INTERFACE.INTERACT;
+
+  CONTROLS_ZINDEX = this.PARAMS.INTERFACE.ZINDEX;
+
+  onAccept = () => void this.emit(this.globalState.interface.isVisible ? this.EVENTS.INTERACT.EMIT : this.EVENTS.INTERFACE.VISIBLE);
+}

package/src/modules/controller.ts

@@ -1,6 +1,5 @@
 import { ModuleController } from "@vnejs/module.components";
 import type { ControlsPopPayload, ControlsPushPayload } from "@vnejs/module.components";
-import { CONSTANTS as ControlsConstants } from "@vnejs/contracts.controls";
 import { getTextSpeakerInfo } from "@vnejs/contracts.text";
 
 import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
@@ -23,10 +22,7 @@ export class InterfaceController extends ModuleController<
 
   EVENT_UPDATE_VIEW = this.EVENTS.INTERFACE.VIEW_UPDATE;
 
-  CONTROLS = {
-    [ControlsConstants.BUTTONS.INTERACT]: () => void this.emit(this.EVENTS.INTERFACE.INTERACT),
-    [ControlsConstants.BUTTONS.ACCEPT]: () => void this.emit(this.EVENTS.INTERFACE.INTERACT),
-  };
+  CONTROLS = {};
   CONTROLS_UNVISIBLE = {};
   CONTROLS_INDEX = this.PARAMS.INTERFACE.ZINDEX;
 

package/src/modules/interface.ts

@@ -1,18 +1,7 @@
 import { ModuleCore, type ModuleGlobalStateRegistry } from "@vnejs/module.core";
-import { tokenizeExecLine } from "@vnejs/helpers";
-
-import type { LineExecHandlerArg } from "@vnejs/module.core";
-
-import type { InterfaceVisibleTokensChangedPayload } from "@vnejs/contracts.views.scenario.interface";
 
 import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
-import type {
-  InterfaceForcePayload,
-  InterfaceModuleState,
-  InterfaceSpeakerChangedPayload,
-  InterfaceTextChangedPayload,
-  InterfaceViewPayload,
-} from "../utils/interface.js";
+import type { InterfaceModuleState } from "../utils/interface.js";
 
 export class Interface extends ModuleCore<
   InterfacePluginEvents,
@@ -24,57 +13,10 @@ export class Interface extends ModuleCore<
   name = "interface";
 
   subscribe = () => {
-    this.on(this.EVENTS.INTERFACE.INTERACT, this.onInteract);
-    this.on(this.EVENTS.INTERFACE.SHOW, this.onShow);
-    this.on(this.EVENTS.INTERFACE.HIDE, this.onHide);
-    this.on(this.EVENTS.INTERFACE.VISIBLE, this.onVisible);
-    this.on(this.EVENTS.INTERFACE.TEXT_HIDE, this.onTextHide);
-    this.on(this.EVENTS.INTERFACE.VIEW, this.onView);
-    this.on(this.EVENTS.INTERFACE.VISIBLE_TOKENS_CHANGED, this.onVisibleTokensChanged);
-
-    this.on(this.EVENTS.TEXT.CHANGED, this.onTextChanged);
-    this.on(this.EVENTS.TEXT.SPEAKER_CHANGED, this.onTextSpeakerChanged);
-
     this.on(this.EVENTS.STATE.SET, this.onStateSet);
     this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
   };
 
-  init = () => {
-    this.shared.interfaceTextShowAllTokensOnChange = true;
-
-    return Promise.all([
-      this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: this.name, handler: this.onLineExec }),
-      this.emit(this.EVENTS.TEXT.EMIT_BEFORE_REG, { handler: this.onTextEmitBefore }),
-    ]);
-  };
-
-  onLineExec = async ({ line = "" }: LineExecHandlerArg = {}) => {
-    const isForce = this.shared.viewForceAnimationSources.isNotEmpty();
-
-    const [action = "", execArg = ""] = tokenizeExecLine(line);
-
-    if (action === "show") await this.emit(this.EVENTS.INTERFACE.SHOW, { isForce });
-    if (action === "hide") await this.emit(this.EVENTS.INTERFACE.HIDE, { isForce });
-    if (action === "view") await this.emit(this.EVENTS.INTERFACE.VIEW, { view: execArg, isForce });
-
-    this.emitNext();
-  };
-
-  onInteract = () => this.emit(this.state.isVisible ? this.EVENTS.INTERACT.EMIT : this.EVENTS.INTERFACE.VISIBLE);
-  onShow = ({ isForce = false }: InterfaceForcePayload = {}) => !this.state.isShow && this.setShow(true, isForce);
-  onHide = ({ isForce = false }: InterfaceForcePayload = {}) => this.state.isShow && this.setShow(false, isForce);
-  onVisible = ({ isForce = false }: InterfaceForcePayload = {}) => this.setVisible(!this.state.isVisible, isForce);
-  onTextChanged = ({ tokens = [], uid = "" }: InterfaceTextChangedPayload = {}) => {
-    const tokensVisible = this.shared.interfaceTextShowAllTokensOnChange ? tokens.length : 0;
-
-    return this.emitTextChanged(tokens, uid, tokensVisible);
-  };
-  onVisibleTokensChanged = ({ tokensVisible = 0, uid = "" }: InterfaceVisibleTokensChangedPayload = {}) =>
-    this.emitTextChanged(this.globalState.text.tokens, uid, tokensVisible);
-  onTextSpeakerChanged = ({ speaker }: InterfaceSpeakerChangedPayload = {}) => this.emitSpeakerChanged(speaker);
-  onTextEmitBefore = () => this.emit(this.EVENTS.INTERFACE.SHOW);
-  onTextHide = () => this.emitTextChanged([], "", 0);
-  onView = ({ view, isForce = false }: InterfaceViewPayload = {}) => this.setView(view, isForce);
   onStateSet = (payload: ModuleGlobalStateRegistry) => {
     const moduleState = this.getStateSlice(payload);
 
@@ -82,27 +24,6 @@ export class Interface extends ModuleCore<
   };
   onStateClear = () => this.setNewState(this.PARAMS.INTERFACE.DEFAULT_VIEW, false, false);
 
-  setView = async (view?: string, isForce = false) => {
-    this.state.view = view ?? "";
-
-    await this.emit(this.EVENTS.INTERFACE.VIEW_CHANGED, { isForce });
-    await this.waitRerender();
-  };
-  setShow = async (isShow: boolean, isForce = false) => {
-    this.state.isShow = isShow;
-
-    if (isShow && !this.state.isVisible) await this.setVisible(true, isForce);
-
-    return this.emit(this.EVENTS.INTERFACE.SHOW_CHANGED, { isForce });
-  };
-  setVisible = (isVisible: boolean, isForce = false) => {
-    this.state.isVisible = isVisible;
-
-    return this.emit(this.EVENTS.INTERFACE.VISIBLE_CHANGED, { isForce });
-  };
-  emitTextChanged = (tokens: InterfaceTextChangedPayload["tokens"] = [], uid = "", tokensVisible?: number) =>
-    this.emit(this.EVENTS.INTERFACE.TEXT_CHANGED, { tokens, uid, tokensVisible });
-  emitSpeakerChanged = (speaker = "") => this.emit(this.EVENTS.INTERFACE.SPEAKER_CHANGED, { speaker });
   setNewState = (view?: string, isVisible?: boolean, isShow?: boolean) => {
     Object.assign(this.state, { isShow, view, isVisible });
 

package/src/modules/scenario.ts

@@ -0,0 +1,26 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { tokenizeExecLine } from "@vnejs/helpers";
+
+import type { LineExecHandlerArg } from "@vnejs/module.core";
+
+import type { InterfacePluginConstants, InterfacePluginEvents, InterfacePluginParams, InterfacePluginSettings } from "../types.js";
+
+export class InterfaceScenario extends ModuleCore<InterfacePluginEvents, InterfacePluginConstants, InterfacePluginSettings, InterfacePluginParams> {
+  name = "interface.scenario";
+
+  execName = "interface";
+
+  init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: this.execName, handler: this.onLineExec });
+
+  onLineExec = async ({ line = "" }: LineExecHandlerArg = {}) => {
+    const isForce = this.shared.viewForceAnimationSources.isNotEmpty();
+
+    const [action = "", execArg = ""] = tokenizeExecLine(line);
+
+    if (action === this.CONST.INTERFACE.EXEC_ACTIONS.SHOW) await this.emit(this.EVENTS.INTERFACE.SHOW, { isForce });
+    if (action === this.CONST.INTERFACE.EXEC_ACTIONS.HIDE) await this.emit(this.EVENTS.INTERFACE.HIDE, { isForce });
+    if (action === this.CONST.INTERFACE.EXEC_ACTIONS.VIEW) await this.emit(this.EVENTS.INTERFACE.VIEW, { view: execArg, isForce });
+
+    this.emitNext();
+  };
+}

package/src/tests/accept.test.ts

@@ -0,0 +1,76 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+
+import { InterfaceControllerAccept } from "../modules/controller.accept.js";
+import { CONTROLS_EVENTS, createInterfaceTestModule, INTERACT_EVENTS, PARAMS, registerInterfacePluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("InterfaceControllerAccept", () => {
+  beforeEach(() => {
+    registerInterfacePluginVne();
+  });
+
+  it("VIEW_SHOW pushes ACCEPT and INTERACT controls", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceControllerAccept);
+    const accept = module as InterfaceControllerAccept;
+    const push = spyEvent(observer, CONTROLS_EVENTS.PUSH);
+
+    await observer.emit(SUBSCRIBE_EVENTS.VIEW_SHOW);
+
+    expect(push).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        key: "interface.controller.accept",
+        checkNext: true,
+        index: accept.PARAMS.INTERFACE.ZINDEX + 1,
+      }),
+    );
+    expect(push.mock.calls[0][0].controls).toHaveProperty(accept.CONST.CONTROLS.BUTTONS.ACCEPT);
+    expect(push.mock.calls[0][0].controls).toHaveProperty(accept.CONST.CONTROLS.BUTTONS.INTERACT);
+  });
+
+  it("VIEW_HIDE pops ACCEPT controls", async () => {
+    const { observer } = createInterfaceTestModule(InterfaceControllerAccept);
+    const pop = spyEvent(observer, CONTROLS_EVENTS.POP);
+
+    await observer.emit(SUBSCRIBE_EVENTS.VIEW_HIDE);
+
+    expect(pop).toHaveBeenCalledExactlyOnceWith({ key: "interface.controller.accept" });
+  });
+
+  it("ACCEPT and INTERACT emit INTERFACE.INTERACT", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceControllerAccept);
+    const accept = module as InterfaceControllerAccept;
+    const interact = spyEvent(observer, SUBSCRIBE_EVENTS.INTERACT);
+
+    accept.CONTROLS[accept.CONST.CONTROLS.BUTTONS.ACCEPT]();
+    accept.CONTROLS[accept.CONST.CONTROLS.BUTTONS.INTERACT]();
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(interact).toHaveBeenCalledTimes(2);
+  });
+
+  it("INTERACT emits VISIBLE when interface is hidden", async () => {
+    const { observer } = createInterfaceTestModule(InterfaceControllerAccept);
+    const visible = spyEvent(observer, SUBSCRIBE_EVENTS.VISIBLE);
+    const emit = spyEvent(observer, INTERACT_EVENTS.EMIT);
+
+    await observer.emit(SUBSCRIBE_EVENTS.INTERACT);
+
+    expect(visible).toHaveBeenCalledOnce();
+    expect(emit).not.toHaveBeenCalled();
+  });
+
+  it("INTERACT emits INTERACT.EMIT when interface is visible", async () => {
+    const { observer } = createInterfaceTestModule(InterfaceControllerAccept, {
+      state: { interface: { view: PARAMS.DEFAULT_VIEW, isShow: true, isVisible: true } },
+    });
+    const visible = spyEvent(observer, SUBSCRIBE_EVENTS.VISIBLE);
+    const emit = spyEvent(observer, INTERACT_EVENTS.EMIT);
+
+    await observer.emit(SUBSCRIBE_EVENTS.INTERACT);
+
+    expect(emit).toHaveBeenCalledOnce();
+    expect(visible).not.toHaveBeenCalled();
+  });
+});

package/src/tests/actions.test.ts

@@ -0,0 +1,85 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+
+import { InterfaceActions } from "../modules/actions.js";
+import { createInterfaceTestModule, registerInterfacePluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("InterfaceActions", () => {
+  beforeEach(() => {
+    registerInterfacePluginVne();
+  });
+
+  it("SHOW sets isShow and emits SHOW_CHANGED", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceActions);
+    const showChanged = spyEvent(observer, SUBSCRIBE_EVENTS.SHOW_CHANGED);
+
+    await (module as InterfaceActions).onShow();
+
+    expect(module.globalState.interface.isShow).toBe(true);
+    expect(showChanged).toHaveBeenCalledOnce();
+    expect(showChanged).toHaveBeenCalledWith({ isForce: false });
+  });
+
+  it("SHOW makes interface visible when it was hidden", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceActions);
+    const visibleChanged = spyEvent(observer, SUBSCRIBE_EVENTS.VISIBLE_CHANGED);
+
+    await (module as InterfaceActions).onShow();
+
+    expect(module.globalState.interface.isVisible).toBe(true);
+    expect(visibleChanged).toHaveBeenCalledOnce();
+  });
+
+  it("SHOW is a no-op when already shown", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceActions);
+    module.globalState.interface.isShow = true;
+    const showChanged = spyEvent(observer, SUBSCRIBE_EVENTS.SHOW_CHANGED);
+
+    await (module as InterfaceActions).onShow();
+
+    expect(showChanged).not.toHaveBeenCalled();
+  });
+
+  it("HIDE clears isShow and emits SHOW_CHANGED", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceActions);
+    module.globalState.interface.isShow = true;
+    const showChanged = spyEvent(observer, SUBSCRIBE_EVENTS.SHOW_CHANGED);
+
+    await (module as InterfaceActions).onHide();
+
+    expect(module.globalState.interface.isShow).toBe(false);
+    expect(showChanged).toHaveBeenCalledOnce();
+  });
+
+  it("VISIBLE toggles isVisible", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceActions);
+    const visibleChanged = spyEvent(observer, SUBSCRIBE_EVENTS.VISIBLE_CHANGED);
+
+    await (module as InterfaceActions).onVisible();
+
+    expect(module.globalState.interface.isVisible).toBe(true);
+    expect(visibleChanged).toHaveBeenCalledWith({ isForce: false });
+  });
+
+  it("TEXT_HIDE emits empty TEXT_CHANGED", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceActions);
+    const textChanged = spyEvent(observer, SUBSCRIBE_EVENTS.TEXT_CHANGED);
+
+    await (module as InterfaceActions).onTextHide();
+
+    expect(textChanged).toHaveBeenCalledOnce();
+    expect(textChanged).toHaveBeenCalledWith({ tokens: [], uid: "", tokensVisible: 0 });
+  });
+
+  it("VIEW writes view and emits VIEW_CHANGED", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceActions);
+    const viewChanged = spyEvent(observer, SUBSCRIBE_EVENTS.VIEW_CHANGED);
+
+    await (module as InterfaceActions).onView({ view: "wall" });
+
+    expect(module.globalState.interface.view).toBe("wall");
+    expect(viewChanged).toHaveBeenCalledOnce();
+    expect(viewChanged).toHaveBeenCalledWith({ isForce: false });
+  });
+});

package/src/tests/interface.test.ts

@@ -1,62 +1,13 @@
 import { beforeEach, describe, expect, it } from "vitest";
 
-import { spyEvent } from "@vnejs/test-utils";
-
 import { Interface } from "../modules/interface.js";
-import { createInterfaceTestModule, PARAMS, registerInterfacePluginVne, SCENARIO_EVENTS, SUBSCRIBE_EVENTS, TEXT_EVENTS } from "./setup.js";
+import { createInterfaceTestModule, PARAMS, registerInterfacePluginVne } from "./setup.js";
 
 describe("Interface", () => {
   beforeEach(() => {
     registerInterfacePluginVne();
   });
 
-  it("init registers scenario line exec and text emit before handlers", async () => {
-    const { module, observer } = createInterfaceTestModule(Interface, { subscribe: false });
-    const lineExecReg = spyEvent(observer, SCENARIO_EVENTS.LINE_EXEC_REG);
-    const textEmitBeforeReg = spyEvent(observer, TEXT_EVENTS.EMIT_BEFORE_REG);
-
-    await (module as Interface).init();
-
-    expect(lineExecReg).toHaveBeenCalledOnce();
-    expect(textEmitBeforeReg).toHaveBeenCalledOnce();
-  });
-
-  it("onLineExec show sets isShow", async () => {
-    const { module } = createInterfaceTestModule(Interface);
-
-    await (module as Interface).onLineExec({ line: "show" });
-
-    expect((module as Interface).state.isShow).toBe(true);
-  });
-
-  it("onLineExec hide clears isShow", async () => {
-    const { module } = createInterfaceTestModule(Interface);
-
-    (module as Interface).state.isShow = true;
-    await (module as Interface).onLineExec({ line: "hide" });
-
-    expect((module as Interface).state.isShow).toBe(false);
-  });
-
-  it("onLineExec view changes view", async () => {
-    const { module } = createInterfaceTestModule(Interface);
-    const viewChanged = spyEvent(module.observer!, SUBSCRIBE_EVENTS.VIEW_CHANGED);
-
-    await (module as Interface).onLineExec({ line: "view wall" });
-
-    expect((module as Interface).state.view).toBe("wall");
-    expect(viewChanged).toHaveBeenCalledOnce();
-  });
-
-  it("onInteract emits VISIBLE when interface is hidden", async () => {
-    const { module, observer } = createInterfaceTestModule(Interface);
-    const visible = spyEvent(observer, SUBSCRIBE_EVENTS.VISIBLE);
-
-    await observer.emit(SUBSCRIBE_EVENTS.INTERACT);
-
-    expect(visible).toHaveBeenCalledOnce();
-  });
-
   it("onStateClear resets to default view", async () => {
     const { module } = createInterfaceTestModule(Interface);
 

package/src/tests/scenario.test.ts

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+
+import { InterfaceScenario } from "../modules/scenario.js";
+import { createInterfaceTestModule, registerInterfacePluginVne, SCENARIO_EVENTS, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("InterfaceScenario", () => {
+  beforeEach(() => {
+    registerInterfacePluginVne();
+  });
+
+  it("init registers scenario line exec handler", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceScenario, { subscribe: false });
+    const lineExecReg = spyEvent(observer, SCENARIO_EVENTS.LINE_EXEC_REG);
+
+    await (module as InterfaceScenario).init();
+
+    expect(lineExecReg).toHaveBeenCalledOnce();
+    expect(lineExecReg).toHaveBeenCalledWith({ module: "interface", handler: (module as InterfaceScenario).onLineExec });
+  });
+
+  it("onLineExec show emits SHOW", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceScenario);
+    const show = spyEvent(observer, SUBSCRIBE_EVENTS.SHOW);
+
+    await (module as InterfaceScenario).onLineExec({ line: "show" });
+
+    expect(show).toHaveBeenCalledOnce();
+    expect(show).toHaveBeenCalledWith({ isForce: false });
+  });
+
+  it("onLineExec hide emits HIDE", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceScenario);
+    const hide = spyEvent(observer, SUBSCRIBE_EVENTS.HIDE);
+
+    await (module as InterfaceScenario).onLineExec({ line: "hide" });
+
+    expect(hide).toHaveBeenCalledOnce();
+    expect(hide).toHaveBeenCalledWith({ isForce: false });
+  });
+
+  it("onLineExec view emits VIEW", async () => {
+    const { module, observer } = createInterfaceTestModule(InterfaceScenario);
+    const view = spyEvent(observer, SUBSCRIBE_EVENTS.VIEW);
+
+    await (module as InterfaceScenario).onLineExec({ line: "view wall" });
+
+    expect(view).toHaveBeenCalledOnce();
+    expect(view).toHaveBeenCalledWith({ view: "wall", isForce: false });
+  });
+});

package/src/tests/setup.ts

@@ -1,7 +1,8 @@
 import { CONSTANTS as CONTROLS_CONST, PLUGIN_NAME as CONTROLS, SUBSCRIBE_EVENTS as CONTROLS_EVENTS } from "@vnejs/contracts.controls";
+import { SUBSCRIBE_EVENTS as INTERACT_EVENTS } from "@vnejs/contracts.core.interact";
 import { SUBSCRIBE_EVENTS as SCENARIO_EVENTS } from "@vnejs/contracts.core.scenario";
 import { SUBSCRIBE_EVENTS as TEXT_EVENTS, PLUGIN_NAME as TEXT } from "@vnejs/contracts.text";
-import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.scenario.interface";
+import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.scenario.interface";
 import { SourcesSet } from "@vnejs/sources-set";
 import { createTestModule as baseCreateTestModule, registerCoreVne, registerVnePlugin, stubEvent, stubSilentEvent } from "@vnejs/test-utils";
 
@@ -9,7 +10,7 @@ export const registerInterfacePluginVne = () => {
   registerCoreVne();
   registerVnePlugin(CONTROLS, { constants: CONTROLS_CONST, events: CONTROLS_EVENTS });
   registerVnePlugin(TEXT, { events: TEXT_EVENTS });
-  registerVnePlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS });
+  registerVnePlugin(PLUGIN_NAME, { constants: CONSTANTS, events: SUBSCRIBE_EVENTS, params: PARAMS });
 };
 
 export const createInterfaceTestModule = <T extends Parameters<typeof baseCreateTestModule>[0]>(
@@ -35,6 +36,7 @@ export const createInterfaceTestModule = <T extends Parameters<typeof baseCreate
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.VIEW_UPDATE);
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.VIEW_SHOW);
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.VIEW_HIDE);
+  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.INTERACT);
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.SHOW_CHANGED);
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.VISIBLE_CHANGED);
   stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.VISIBLE);
@@ -45,4 +47,4 @@ export const createInterfaceTestModule = <T extends Parameters<typeof baseCreate
   return result;
 };
 
-export { SUBSCRIBE_EVENTS, PARAMS, PLUGIN_NAME, SCENARIO_EVENTS, TEXT_EVENTS, CONTROLS_EVENTS };
+export { SUBSCRIBE_EVENTS, PARAMS, PLUGIN_NAME, SCENARIO_EVENTS, TEXT_EVENTS, CONTROLS_EVENTS, INTERACT_EVENTS };

package/src/types.ts

@@ -4,8 +4,8 @@ import type { Constants as ControlsConstants, PluginName as ControlsPluginName }
 import type { PluginName as InteractPluginName, SubscribeEvents as InteractSubscribeEvents } from "@vnejs/contracts.core.interact";
 import type { 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 TextPluginName, Params as TextParams, SubscribeEvents as TextSubscribeEvents } from "@vnejs/contracts.text";
-import type { Params, PluginName, SubscribeEvents } from "@vnejs/contracts.views.scenario.interface";
+import type { PluginName as TextPluginName, Params as TextParams } from "@vnejs/contracts.text";
+import type { Constants, Params, PluginName, SubscribeEvents } from "@vnejs/contracts.views.scenario.interface";
 
 import type { InterfacePluginState } from "./utils/interface.js";
 
@@ -13,10 +13,9 @@ export type InterfacePluginEvents = ModuleComponentsEvents &
   Record<PluginName, SubscribeEvents> &
   Record<ScenarioPluginName, ScenarioSubscribeEvents> &
   Record<StatePluginName, StateSubscribeEvents> &
-  Record<TextPluginName, TextSubscribeEvents> &
   Record<InteractPluginName, InteractSubscribeEvents>;
 
-export type InterfacePluginConstants = ModuleComponentsConstants & Record<ControlsPluginName, ControlsConstants>;
+export type InterfacePluginConstants = ModuleComponentsConstants & Record<ControlsPluginName, ControlsConstants> & Record<PluginName, Constants>;
 
 export type InterfacePluginSettings = ModuleComponentsSettings;