@vnejs/plugins.text.wall 0.1.5 → 0.1.6

package/dist/index.js

@@ -1,5 +1,8 @@
 import "@vnejs/contracts.text.wall";
 import { regPlugin } from "@vnejs/shared";
-import { PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.text.wall";
+import { PLUGIN_NAME, SUBSCRIBE_EVENTS, CONSTANTS } from "@vnejs/contracts.text.wall";
 import { TextWall } from "./modules/wall.js";
-regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS }, [TextWall]);
+import { TextWallRecalc } from "./modules/recalc.js";
+import { TextWallExec } from "./modules/exec.js";
+import { TextWallEmitBefore } from "./modules/emit.before.js";
+regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, constants: CONSTANTS }, [TextWallEmitBefore, TextWallExec, TextWallRecalc, TextWall]);

package/dist/modules/emit.before.d.ts

@@ -0,0 +1,9 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { TextEmitBeforePayload } from "@vnejs/contracts.text";
+import type { ModuleGlobalStateTextWall } from "@vnejs/contracts.text.wall";
+import type { TextWallPluginConstants, TextWallPluginEvents, TextWallPluginParams, TextWallPluginSettings } from "../types.js";
+export declare class TextWallEmitBefore extends ModuleCore<TextWallPluginEvents, TextWallPluginConstants, TextWallPluginSettings, TextWallPluginParams, ModuleGlobalStateTextWall> {
+    name: string;
+    init: () => Promise<unknown[]> | undefined;
+    onTextEmitBefore: ({ isExtend }?: TextEmitBeforePayload) => Promise<unknown[] | undefined>;
+}

package/dist/modules/emit.before.js

@@ -0,0 +1,21 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { getTextSpeakerInfo } from "@vnejs/contracts.text";
+export class TextWallEmitBefore extends ModuleCore {
+    name = "text.wall.emit.before";
+    init = () => this.emit(this.EVENTS.TEXT.EMIT_BEFORE_REG, { handler: this.onTextEmitBefore });
+    onTextEmitBefore = async ({ isExtend = false } = {}) => {
+        const state = this.globalState["text.wall"];
+        if (isExtend || !state.isStarted || this.shared.isTextWallSetStateInProcess)
+            return;
+        if (state.shouldSkip)
+            return this.emit(this.EVENTS.TEXT_WALL.STATE_UPDATE, { shouldSkip: false });
+        const { texts, tokens, uid } = this.globalState.text;
+        const speakerState = this.globalState["text.speaker"];
+        const { speaker } = speakerState;
+        const speakerInfo = await this.emitClone(getTextSpeakerInfo(speakerState, speaker));
+        const wall = await this.emitClone(state.wall);
+        const wallElement = await this.emitClone({ texts, tokens, uid, speaker, speakerInfo });
+        await this.emit(this.EVENTS.TEXT_WALL.STATE_UPDATE, { wall: [...wall, wallElement] });
+        await this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.globalState["text.wall"].wall });
+    };
+}

package/dist/modules/exec.d.ts

@@ -0,0 +1,10 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { ModuleGlobalStateTextWall } from "@vnejs/contracts.text.wall";
+import type { LineExecHandlerArg } from "@vnejs/module.core";
+import type { TextWallPluginConstants, TextWallPluginEvents, TextWallPluginParams, TextWallPluginSettings } from "../types.js";
+export declare class TextWallExec extends ModuleCore<TextWallPluginEvents, TextWallPluginConstants, TextWallPluginSettings, TextWallPluginParams, ModuleGlobalStateTextWall> {
+    name: string;
+    init: () => Promise<unknown[]> | undefined;
+    onLineExec: ({ line }?: LineExecHandlerArg) => Promise<void>;
+    emitAction: (action: string) => Promise<unknown[]> | undefined;
+}

package/dist/modules/exec.js

@@ -0,0 +1,21 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { tokenizeExecLine } from "@vnejs/helpers";
+export class TextWallExec extends ModuleCore {
+    name = "text.wall.exec";
+    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: "text.wall", handler: this.onLineExec });
+    onLineExec = async ({ line = "" } = {}) => {
+        const [action = ""] = tokenizeExecLine(line).map(String);
+        await this.emitAction(action);
+        await this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.globalState["text.wall"].wall });
+        this.emitNext();
+    };
+    emitAction = (action) => {
+        const event = this.EVENTS.TEXT_WALL.STATE_UPDATE;
+        if (action === this.CONST.TEXT_WALL.EXEC_ACTIONS.CLEAR)
+            return this.emit(event, { wall: [], shouldSkip: true });
+        if (action === this.CONST.TEXT_WALL.EXEC_ACTIONS.START)
+            return this.emit(event, { wall: [], isStarted: true, shouldSkip: true });
+        if (action === this.CONST.TEXT_WALL.EXEC_ACTIONS.END)
+            return this.emit(event, { wall: [], isStarted: false, shouldSkip: true });
+    };
+}

package/dist/modules/recalc.d.ts

@@ -0,0 +1,17 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { TokenizedChar } from "@vnejs/contracts.text";
+import type { ModuleGlobalStateTextWall, WallElement } from "@vnejs/contracts.text.wall";
+import type { TextWallPluginConstants, TextWallPluginEvents, TextWallPluginParams, TextWallPluginSettings } from "../types.js";
+export declare class TextWallRecalc extends ModuleCore<TextWallPluginEvents, TextWallPluginConstants, TextWallPluginSettings, TextWallPluginParams, ModuleGlobalStateTextWall> {
+    name: string;
+    subscribe: () => void;
+    onTextRecalc: () => Promise<void>;
+    recalcWallObjToken: (wallObj: WallElement) => Promise<{
+        texts: import("@vnejs/contracts.text").TextItem[];
+        uid: string;
+        speaker: string;
+        speakerInfo: import("@vnejs/contracts.text").TextSpeakerEntry;
+        tokens: TokenizedChar[];
+    }>;
+    getRealText: (text: string, args: Record<string, unknown>) => Promise<string>;
+}

package/dist/modules/recalc.js

@@ -0,0 +1,22 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { tokenizeText } from "@vnejs/helpers";
+export class TextWallRecalc extends ModuleCore {
+    name = "text.wall.recalc";
+    subscribe = () => {
+        this.on(this.EVENTS.TEXT.RECALC, this.onTextRecalc);
+    };
+    onTextRecalc = async () => {
+        const state = this.globalState["text.wall"];
+        if (!state.wall.length)
+            return;
+        await this.emit(this.EVENTS.TEXT_WALL.STATE_UPDATE, { wall: await Promise.all(state.wall.map(this.recalcWallObjToken)) });
+        await this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.globalState["text.wall"].wall });
+    };
+    recalcWallObjToken = async (wallObj) => {
+        const tokens = [];
+        for (let i = 0; i < wallObj.texts.length; i++)
+            tokens.push(...tokenizeText(await this.getRealText(wallObj.texts[i].text, wallObj.texts[i].args)));
+        return { ...wallObj, tokens };
+    };
+    getRealText = (text, args) => this.emitOne(this.EVENTS.TEXT.REPLACE, { text, args, label: this.globalState.scenario.label, state: this.globalState });
+}

package/dist/modules/wall.d.ts

@@ -1,27 +1,13 @@
 import { ModuleCore } from "@vnejs/module.core";
 import type { ModuleGlobalStateRegistry } from "@vnejs/module.core";
-import type { TextEmitBeforePayload, TokenizedChar } from "@vnejs/contracts.text";
-import type { ModuleGlobalStateTextWall, WallElement } from "@vnejs/contracts.text.wall";
-import type { LineExecHandlerArg } from "@vnejs/module.core";
+import type { ModuleGlobalStateTextWall } from "@vnejs/contracts.text.wall";
 import type { TextWallPluginConstants, TextWallPluginEvents, TextWallPluginParams, TextWallPluginSettings } from "../types.js";
 export declare class TextWall extends ModuleCore<TextWallPluginEvents, TextWallPluginConstants, TextWallPluginSettings, TextWallPluginParams, ModuleGlobalStateTextWall> {
     name: string;
-    isSetStateInProcess: boolean;
     subscribe: () => void;
-    init: () => Promise<[unknown[] | undefined, unknown[] | undefined]>;
-    emitWallChanged: () => Promise<unknown[]> | undefined;
-    onLineExec: ({ line }?: LineExecHandlerArg) => Promise<void>;
-    onTextEmitBefore: ({ isExtend }?: TextEmitBeforePayload) => Promise<void>;
-    onTextRecalc: () => Promise<unknown[] | undefined>;
+    init: () => void;
+    onStateUpdate: (payload: Partial<ModuleGlobalStateTextWall>) => void;
     onStateSet: (payload: ModuleGlobalStateRegistry) => Promise<void>;
     onStateClear: () => Promise<unknown[] | undefined>;
-    getRealText: (text: string, args: Record<string, unknown>) => Promise<string>;
-    recalcWallObjToken: (wallObj: WallElement) => Promise<{
-        tokens: TokenizedChar[];
-        texts: import("@vnejs/contracts.text").TextItem[];
-        uid: string;
-        speaker: string;
-        speakerInfo: import("@vnejs/contracts.text").TextSpeakerEntry;
-    }>;
     getDefaultState: () => ModuleGlobalStateTextWall;
 }

package/dist/modules/wall.js

@@ -1,66 +1,24 @@
 import { ModuleCore } from "@vnejs/module.core";
-import { tokenizeExecLine, tokenizeText } from "@vnejs/helpers";
-import { getTextSpeakerInfo } from "@vnejs/contracts.text";
 export class TextWall extends ModuleCore {
     name = "text.wall";
-    isSetStateInProcess = false;
     subscribe = () => {
-        this.on(this.EVENTS.TEXT.RECALC, this.onTextRecalc);
+        this.on(this.EVENTS.TEXT_WALL.STATE_UPDATE, this.onStateUpdate);
         this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
         this.on(this.EVENTS.STATE.SET, this.onStateSet);
     };
-    init = () => 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 }),
-    ]);
-    emitWallChanged = () => this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.state.wall });
-    onLineExec = async ({ line = "" } = {}) => {
-        const [action = ""] = tokenizeExecLine(line).map(String);
-        if (action === "clear")
-            this.updateState({ wall: [], shouldSkip: true });
-        if (action === "start")
-            this.updateState({ wall: [], isStarted: true, shouldSkip: true });
-        if (action === "end")
-            this.updateState({ wall: [], isStarted: false, shouldSkip: true });
-        await this.emitWallChanged();
-        this.emitNext();
-    };
-    onTextEmitBefore = async ({ isExtend = false } = {}) => {
-        if (isExtend || !this.state.isStarted || this.isSetStateInProcess)
-            return;
-        if (this.state.shouldSkip)
-            return this.updateState({ shouldSkip: false });
-        const { texts, tokens, uid } = this.globalState.text;
-        const speakerState = this.globalState["text.speaker"];
-        const { speaker } = speakerState;
-        const speakerInfo = await this.emitClone(getTextSpeakerInfo(speakerState, speaker));
-        const wall = await this.emitClone(this.state.wall);
-        const wallElement = await this.emitClone({ texts, tokens, uid, speaker, speakerInfo });
-        this.updateState({ wall: [...wall, wallElement] });
-        await this.emitWallChanged();
-    };
-    onTextRecalc = async () => {
-        if (!this.state.wall.length)
-            return;
-        this.updateState({ wall: await Promise.all(this.state.wall.map(this.recalcWallObjToken)) });
-        return this.emitWallChanged();
+    init = () => {
+        this.shared.isTextWallSetStateInProcess = false;
     };
+    onStateUpdate = (payload) => this.updateState(payload);
     onStateSet = async (payload) => {
-        this.isSetStateInProcess = true;
+        this.shared.isTextWallSetStateInProcess = true;
         await this.onSetStateClone(payload);
-        await this.emitWallChanged();
-        this.isSetStateInProcess = false;
+        await this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.state.wall });
+        this.shared.isTextWallSetStateInProcess = false;
     };
     onStateClear = async () => {
         this.setDefaultState();
-        return this.emitWallChanged();
-    };
-    getRealText = (text, args) => this.emitOne(this.EVENTS.TEXT.REPLACE, { text, args, label: this.globalState.scenario.label, state: this.globalState });
-    recalcWallObjToken = async (wallObj) => {
-        const tokens = [];
-        for (let i = 0; i < wallObj.texts.length; i++)
-            tokens.push(...tokenizeText(await this.getRealText(wallObj.texts[i].text, wallObj.texts[i].args)));
-        return { ...wallObj, tokens };
+        return this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.state.wall });
     };
     getDefaultState = () => ({ wall: [], isStarted: false, shouldSkip: false });
 }

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 import type { ModuleCoreConstants, ModuleCoreEvents, ModuleCoreParams, ModuleCoreSettings } from "@vnejs/module.core";
 import type { PluginName as TextPluginName, SubscribeEvents as TextSubscribeEvents } from "@vnejs/contracts.text";
-import type { PluginName, SubscribeEvents } from "@vnejs/contracts.text.wall";
+import type { PluginName, SubscribeEvents, Constants } from "@vnejs/contracts.text.wall";
 export type TextWallPluginEvents = ModuleCoreEvents & Record<PluginName, SubscribeEvents> & Record<TextPluginName, TextSubscribeEvents>;
-export type TextWallPluginConstants = ModuleCoreConstants;
+export type TextWallPluginConstants = ModuleCoreConstants & Record<PluginName, Constants>;
 export type TextWallPluginSettings = ModuleCoreSettings;
 export type TextWallPluginParams = ModuleCoreParams;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/plugins.text.wall",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/index.ts

@@ -1,8 +1,11 @@
 import "@vnejs/contracts.text.wall";
 
 import { regPlugin } from "@vnejs/shared";
-import { PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.text.wall";
+import { PLUGIN_NAME, SUBSCRIBE_EVENTS, CONSTANTS } from "@vnejs/contracts.text.wall";
 
 import { TextWall } from "./modules/wall.js";
+import { TextWallRecalc } from "./modules/recalc.js";
+import { TextWallExec } from "./modules/exec.js";
+import { TextWallEmitBefore } from "./modules/emit.before.js";
 
-regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS }, [TextWall]);
+regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, constants: CONSTANTS }, [TextWallEmitBefore, TextWallExec, TextWallRecalc, TextWall]);

package/src/modules/emit.before.ts

@@ -0,0 +1,37 @@
+import { ModuleCore } from "@vnejs/module.core";
+
+import type { TextEmitBeforePayload } from "@vnejs/contracts.text";
+import { getTextSpeakerInfo } from "@vnejs/contracts.text";
+import type { ModuleGlobalStateTextWall, WallElement } from "@vnejs/contracts.text.wall";
+
+import type { TextWallPluginConstants, TextWallPluginEvents, TextWallPluginParams, TextWallPluginSettings } from "../types.js";
+
+export class TextWallEmitBefore extends ModuleCore<
+  TextWallPluginEvents,
+  TextWallPluginConstants,
+  TextWallPluginSettings,
+  TextWallPluginParams,
+  ModuleGlobalStateTextWall
+> {
+  name = "text.wall.emit.before";
+
+  init = () => this.emit(this.EVENTS.TEXT.EMIT_BEFORE_REG, { handler: this.onTextEmitBefore });
+
+  onTextEmitBefore = async ({ isExtend = false }: TextEmitBeforePayload = {}) => {
+    const state = this.globalState["text.wall"];
+
+    if (isExtend || !state.isStarted || this.shared.isTextWallSetStateInProcess) return;
+    if (state.shouldSkip) return this.emit(this.EVENTS.TEXT_WALL.STATE_UPDATE, { shouldSkip: false });
+
+    const { texts, tokens, uid } = this.globalState.text;
+    const speakerState = this.globalState["text.speaker"];
+    const { speaker } = speakerState;
+    const speakerInfo = await this.emitClone(getTextSpeakerInfo(speakerState, speaker));
+
+    const wall = await this.emitClone<WallElement[]>(state.wall);
+    const wallElement = await this.emitClone<WallElement>({ texts, tokens, uid, speaker, speakerInfo });
+
+    await this.emit(this.EVENTS.TEXT_WALL.STATE_UPDATE, { wall: [...wall, wallElement] });
+    await this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.globalState["text.wall"].wall });
+  };
+}

package/src/modules/exec.ts

@@ -0,0 +1,37 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { tokenizeExecLine } from "@vnejs/helpers";
+
+import type { ModuleGlobalStateTextWall } from "@vnejs/contracts.text.wall";
+import type { LineExecHandlerArg } from "@vnejs/module.core";
+
+import type { TextWallPluginConstants, TextWallPluginEvents, TextWallPluginParams, TextWallPluginSettings } from "../types.js";
+
+export class TextWallExec extends ModuleCore<
+  TextWallPluginEvents,
+  TextWallPluginConstants,
+  TextWallPluginSettings,
+  TextWallPluginParams,
+  ModuleGlobalStateTextWall
+> {
+  name = "text.wall.exec";
+
+  init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { module: "text.wall", handler: this.onLineExec });
+
+  onLineExec = async ({ line = "" }: LineExecHandlerArg = {}) => {
+    const [action = ""] = tokenizeExecLine(line).map(String);
+
+    await this.emitAction(action);
+
+    await this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.globalState["text.wall"].wall });
+
+    this.emitNext();
+  };
+
+  emitAction = (action: string) => {
+    const event = this.EVENTS.TEXT_WALL.STATE_UPDATE;
+
+    if (action === this.CONST.TEXT_WALL.EXEC_ACTIONS.CLEAR) return this.emit(event, { wall: [], shouldSkip: true });
+    if (action === this.CONST.TEXT_WALL.EXEC_ACTIONS.START) return this.emit(event, { wall: [], isStarted: true, shouldSkip: true });
+    if (action === this.CONST.TEXT_WALL.EXEC_ACTIONS.END) return this.emit(event, { wall: [], isStarted: false, shouldSkip: true });
+  };
+}

package/src/modules/recalc.ts

@@ -0,0 +1,40 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { tokenizeText } from "@vnejs/helpers";
+
+import type { TokenizedChar } from "@vnejs/contracts.text";
+import type { ModuleGlobalStateTextWall, WallElement } from "@vnejs/contracts.text.wall";
+
+import type { TextWallPluginConstants, TextWallPluginEvents, TextWallPluginParams, TextWallPluginSettings } from "../types.js";
+
+export class TextWallRecalc extends ModuleCore<
+  TextWallPluginEvents,
+  TextWallPluginConstants,
+  TextWallPluginSettings,
+  TextWallPluginParams,
+  ModuleGlobalStateTextWall
+> {
+  name = "text.wall.recalc";
+
+  subscribe = () => {
+    this.on(this.EVENTS.TEXT.RECALC, this.onTextRecalc);
+  };
+
+  onTextRecalc = async () => {
+    const state = this.globalState["text.wall"];
+
+    if (!state.wall.length) return;
+
+    await this.emit(this.EVENTS.TEXT_WALL.STATE_UPDATE, { wall: await Promise.all(state.wall.map(this.recalcWallObjToken)) });
+    await this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.globalState["text.wall"].wall });
+  };
+
+  recalcWallObjToken = async (wallObj: WallElement) => {
+    const tokens: TokenizedChar[] = [];
+
+    for (let i = 0; i < wallObj.texts.length; i++) tokens.push(...tokenizeText(await this.getRealText(wallObj.texts[i].text, wallObj.texts[i].args)));
+
+    return { ...wallObj, tokens };
+  };
+  getRealText = (text: string, args: Record<string, unknown>) =>
+    this.emitOne(this.EVENTS.TEXT.REPLACE, { text, args, label: this.globalState.scenario.label, state: this.globalState }) as Promise<string>;
+}

package/src/modules/wall.ts

@@ -1,11 +1,7 @@
 import { ModuleCore } from "@vnejs/module.core";
 import type { ModuleGlobalStateRegistry } from "@vnejs/module.core";
-import { tokenizeExecLine, tokenizeText } from "@vnejs/helpers";
 
-import type { TextEmitBeforePayload, TokenizedChar } from "@vnejs/contracts.text";
-import { getTextSpeakerInfo } from "@vnejs/contracts.text";
-import type { ModuleGlobalStateTextWall, WallElement } from "@vnejs/contracts.text.wall";
-import type { LineExecHandlerArg } from "@vnejs/module.core";
+import type { ModuleGlobalStateTextWall } from "@vnejs/contracts.text.wall";
 
 import type { TextWallPluginConstants, TextWallPluginEvents, TextWallPluginParams, TextWallPluginSettings } from "../types.js";
 
@@ -18,84 +14,31 @@ export class TextWall extends ModuleCore<
 > {
   name = "text.wall";
 
-  isSetStateInProcess = false;
-
   subscribe = () => {
-    this.on(this.EVENTS.TEXT.RECALC, this.onTextRecalc);
+    this.on(this.EVENTS.TEXT_WALL.STATE_UPDATE, this.onStateUpdate);
 
     this.on(this.EVENTS.STATE.CLEAR, this.onStateClear);
     this.on(this.EVENTS.STATE.SET, this.onStateSet);
   };
 
-  init = () =>
-    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 }),
-    ]);
-
-  emitWallChanged = () => this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.state.wall });
-
-  onLineExec = async ({ line = "" }: LineExecHandlerArg = {}) => {
-    const [action = ""] = tokenizeExecLine(line).map(String);
-
-    if (action === "clear") this.updateState({ wall: [], shouldSkip: true });
-    if (action === "start") this.updateState({ wall: [], isStarted: true, shouldSkip: true });
-    if (action === "end") this.updateState({ wall: [], isStarted: false, shouldSkip: true });
-
-    await this.emitWallChanged();
-
-    this.emitNext();
+  init = () => {
+    this.shared.isTextWallSetStateInProcess = false;
   };
 
-  onTextEmitBefore = async ({ isExtend = false }: TextEmitBeforePayload = {}) => {
-    if (isExtend || !this.state.isStarted || this.isSetStateInProcess) return;
-    if (this.state.shouldSkip) return this.updateState({ shouldSkip: false });
-
-    const { texts, tokens, uid } = this.globalState.text;
-    const speakerState = this.globalState["text.speaker"];
-    const { speaker } = speakerState;
-    const speakerInfo = await this.emitClone(getTextSpeakerInfo(speakerState, speaker));
-
-    const wall = await this.emitClone<WallElement[]>(this.state.wall);
-    const wallElement = await this.emitClone<WallElement>({ texts, tokens, uid, speaker, speakerInfo });
-
-    this.updateState({ wall: [...wall, wallElement] });
-
-    await this.emitWallChanged();
-  };
-
-  onTextRecalc = async () => {
-    if (!this.state.wall.length) return;
-
-    this.updateState({ wall: await Promise.all(this.state.wall.map(this.recalcWallObjToken)) });
-
-    return this.emitWallChanged();
-  };
+  onStateUpdate = (payload: Partial<ModuleGlobalStateTextWall>) => this.updateState(payload);
 
   onStateSet = async (payload: ModuleGlobalStateRegistry) => {
-    this.isSetStateInProcess = true;
+    this.shared.isTextWallSetStateInProcess = true;
 
     await this.onSetStateClone(payload);
-    await this.emitWallChanged();
+    await this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.state.wall });
 
-    this.isSetStateInProcess = false;
+    this.shared.isTextWallSetStateInProcess = false;
   };
-
   onStateClear = async () => {
     this.setDefaultState();
 
-    return this.emitWallChanged();
-  };
-
-  getRealText = (text: string, args: Record<string, unknown>) =>
-    this.emitOne(this.EVENTS.TEXT.REPLACE, { text, args, label: this.globalState.scenario.label, state: this.globalState }) as Promise<string>;
-
-  recalcWallObjToken = async (wallObj: WallElement) => {
-    const tokens: TokenizedChar[] = [];
-
-    for (let i = 0; i < wallObj.texts.length; i++) tokens.push(...tokenizeText(await this.getRealText(wallObj.texts[i].text, wallObj.texts[i].args)));
-
-    return { ...wallObj, tokens };
+    return this.emit(this.EVENTS.TEXT_WALL.CHANGED, { wall: this.state.wall });
   };
 
   getDefaultState = (): ModuleGlobalStateTextWall => ({ wall: [], isStarted: false, shouldSkip: false });

package/src/tests/emit.before.test.ts

@@ -0,0 +1,86 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+
+import { TextWallEmitBefore } from "../modules/emit.before.js";
+import { createTextWallTestModule, createTextWallWithModule, registerTextWallPluginVne, SUBSCRIBE_EVENTS, TEXT_EVENTS } from "./setup.js";
+
+describe("TextWallEmitBefore", () => {
+  beforeEach(() => {
+    registerTextWallPluginVne();
+  });
+
+  it("init registers emit before handler", async () => {
+    const { module, observer } = createTextWallTestModule(TextWallEmitBefore, { subscribe: false });
+    const emitBeforeReg = spyEvent(observer, TEXT_EVENTS.EMIT_BEFORE_REG);
+
+    await (module as TextWallEmitBefore).init();
+
+    expect(emitBeforeReg).toHaveBeenCalledExactlyOnceWith({ handler: (module as TextWallEmitBefore).onTextEmitBefore });
+  });
+
+  it("skips when wall is not started", async () => {
+    const { module, observer } = createTextWallWithModule(TextWallEmitBefore);
+    const stateUpdate = spyEvent(observer, SUBSCRIBE_EVENTS.STATE_UPDATE);
+
+    await (module as TextWallEmitBefore).onTextEmitBefore();
+
+    expect(stateUpdate).not.toHaveBeenCalled();
+  });
+
+  it("skips when isExtend", async () => {
+    const { wall, module, observer } = createTextWallWithModule(TextWallEmitBefore);
+    const stateUpdate = spyEvent(observer, SUBSCRIBE_EVENTS.STATE_UPDATE);
+
+    wall.setState({ wall: [], isStarted: true, shouldSkip: false });
+
+    await (module as TextWallEmitBefore).onTextEmitBefore({ isExtend: true });
+
+    expect(stateUpdate).not.toHaveBeenCalled();
+  });
+
+  it("skips when set state is in process", async () => {
+    const { wall, module, observer, shared } = createTextWallWithModule(TextWallEmitBefore);
+    const stateUpdate = spyEvent(observer, SUBSCRIBE_EVENTS.STATE_UPDATE);
+
+    wall.setState({ wall: [], isStarted: true, shouldSkip: false });
+    shared.isTextWallSetStateInProcess = true;
+
+    await (module as TextWallEmitBefore).onTextEmitBefore();
+
+    expect(stateUpdate).not.toHaveBeenCalled();
+  });
+
+  it("clears shouldSkip without appending wall element", async () => {
+    const { wall, module, observer } = createTextWallWithModule(TextWallEmitBefore);
+    const changed = spyEvent(observer, SUBSCRIBE_EVENTS.CHANGED);
+
+    wall.setState({ wall: [], isStarted: true, shouldSkip: true });
+
+    await (module as TextWallEmitBefore).onTextEmitBefore();
+
+    expect(wall.state.shouldSkip).toBe(false);
+    expect(wall.state.wall).toEqual([]);
+    expect(changed).not.toHaveBeenCalled();
+  });
+
+  it("appends current text to wall when started", async () => {
+    const { wall, module, observer } = createTextWallWithModule(TextWallEmitBefore);
+    const changed = spyEvent(observer, SUBSCRIBE_EVENTS.CHANGED);
+
+    wall.setState({ wall: [], isStarted: true, shouldSkip: false });
+
+    await (module as TextWallEmitBefore).onTextEmitBefore();
+
+    expect(wall.state.wall).toEqual([
+      {
+        texts: [{ text: "line", args: {} }],
+        tokens: [],
+        uid: "1",
+        speaker: "hero",
+        speakerInfo: {},
+      },
+    ]);
+    expect(changed).toHaveBeenCalledOnce();
+  });
+});

package/src/tests/exec.test.ts

@@ -0,0 +1,49 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { SUBSCRIBE_EVENTS as SCENARIO_EVENTS } from "@vnejs/contracts.core.scenario";
+import { spyEvent } from "@vnejs/test-utils";
+
+import { TextWallExec } from "../modules/exec.js";
+import { CONSTANTS, createTextWallTestModule, createTextWallWithModule, registerTextWallPluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("TextWallExec", () => {
+  beforeEach(() => {
+    registerTextWallPluginVne();
+  });
+
+  it("init registers line exec handler", async () => {
+    const { module, observer } = createTextWallTestModule(TextWallExec, { subscribe: false });
+    const lineExecReg = spyEvent(observer, SCENARIO_EVENTS.LINE_EXEC_REG);
+
+    await (module as TextWallExec).init();
+
+    expect(lineExecReg).toHaveBeenCalledExactlyOnceWith({ module: "text.wall", handler: (module as TextWallExec).onLineExec });
+  });
+
+  it("start command enables wall capture", async () => {
+    const { wall, module, observer } = createTextWallWithModule(TextWallExec);
+    const changed = spyEvent(observer, SUBSCRIBE_EVENTS.CHANGED);
+    const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
+
+    await (module as TextWallExec).onLineExec({ line: CONSTANTS.EXEC_ACTIONS.START });
+
+    expect(wall.state.isStarted).toBe(true);
+    expect(changed).toHaveBeenCalledOnce();
+    expect(next).toHaveBeenCalledOnce();
+  });
+
+  it("clear command resets wall", async () => {
+    const { wall, module } = createTextWallWithModule(TextWallExec);
+
+    wall.setState({
+      wall: [{ texts: [], tokens: [], uid: "1", speaker: "hero", speakerInfo: {} }],
+      isStarted: true,
+      shouldSkip: false,
+    });
+
+    await (module as TextWallExec).onLineExec({ line: CONSTANTS.EXEC_ACTIONS.CLEAR });
+
+    expect(wall.state.wall).toEqual([]);
+    expect(wall.state.shouldSkip).toBe(true);
+  });
+});

package/src/tests/recalc.test.ts

@@ -0,0 +1,50 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+
+import { TextWallRecalc } from "../modules/recalc.js";
+import { createTextWallWithModule, registerTextWallPluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("TextWallRecalc", () => {
+  beforeEach(() => {
+    registerTextWallPluginVne();
+  });
+
+  it("does nothing when wall is empty", async () => {
+    const { module, observer } = createTextWallWithModule(TextWallRecalc, { subscribe: true });
+    const stateUpdate = spyEvent(observer, SUBSCRIBE_EVENTS.STATE_UPDATE);
+    const changed = spyEvent(observer, SUBSCRIBE_EVENTS.CHANGED);
+
+    await (module as TextWallRecalc).onTextRecalc();
+
+    expect(stateUpdate).not.toHaveBeenCalled();
+    expect(changed).not.toHaveBeenCalled();
+  });
+
+  it("recalculates wall tokens and emits changed", async () => {
+    const { wall, module, observer } = createTextWallWithModule(TextWallRecalc, { subscribe: true });
+    const changed = spyEvent(observer, SUBSCRIBE_EVENTS.CHANGED);
+
+    wall.setState({
+      wall: [
+        {
+          texts: [{ text: "ab", args: {} }],
+          tokens: [],
+          uid: "1",
+          speaker: "hero",
+          speakerInfo: {},
+        },
+      ],
+      isStarted: true,
+      shouldSkip: false,
+    });
+
+    await (module as TextWallRecalc).onTextRecalc();
+
+    expect(wall.state.wall[0].tokens).toEqual([
+      { token: "a", marks: [] },
+      { token: "b", marks: [] },
+    ]);
+    expect(changed).toHaveBeenCalledOnce();
+  });
+});

package/src/tests/setup.ts

@@ -1,29 +1,68 @@
-import { CONSTANTS as TEXT_CONST, PLUGIN_NAME as TEXT, SUBSCRIBE_EVENTS as TEXT_EVENTS } from "@vnejs/contracts.text";
-import { PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.text.wall";
-import { createTestModule as baseCreateTestModule, registerCoreVne, registerVnePlugin, stubSilentEvent } from "@vnejs/test-utils";
+import { PLUGIN_NAME as TEXT, SUBSCRIBE_EVENTS as TEXT_EVENTS } from "@vnejs/contracts.text";
+import { CONSTANTS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.text.wall";
+import {
+  createCoreGlobalState,
+  createTestModule as baseCreateTestModule,
+  registerCoreVne,
+  registerVnePlugin,
+  stubEvent,
+  stubSilentEvent,
+  stubVendorEvents,
+} from "@vnejs/test-utils";
+
+import { TextWall } from "../modules/wall.js";
 
 export const registerTextWallPluginVne = () => {
   registerCoreVne();
   registerVnePlugin(TEXT, { events: TEXT_EVENTS });
-  registerVnePlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS });
+  registerVnePlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, constants: CONSTANTS });
 };
 
 export const createTextWallTestModule = <T extends Parameters<typeof baseCreateTestModule>[0]>(
   ModuleClass: T,
   options: Parameters<typeof baseCreateTestModule>[1] = {},
 ) => {
+  const { state: optionState, ...rest } = options;
   const result = baseCreateTestModule(ModuleClass, {
-    state: {
-      text: { uid: "1", texts: [{ text: "line", args: {} }], tokens: [], speaker: "hero" },
-      "text.speaker": { speakers: { hero: {} }, speaker: "hero" },
-      ...(options.state ?? {}),
-    },
-    ...options,
+    ...rest,
+    state:
+      optionState ??
+      {
+        ...createCoreGlobalState(),
+        text: { uid: "1", texts: [{ text: "line", args: {} }], tokens: [], speaker: "hero" },
+        "text.speaker": { speaker: "hero", args: {}, speakersInfo: { hero: {} } },
+      },
   });
 
-  stubSilentEvent(result.observer, SUBSCRIBE_EVENTS.CHANGED);
+  const observer = result.module.observer ?? result.observer;
+
+  stubVendorEvents(observer);
+  stubEvent(observer, TEXT_EVENTS.REPLACE, ({ text }) => text);
+  stubSilentEvent(observer, SUBSCRIBE_EVENTS.CHANGED);
+
+  return { ...result, observer };
+};
+
+export const createTextWallWithModule = <T extends Parameters<typeof baseCreateTestModule>[0]>(
+  ModuleClass: T,
+  options: Parameters<typeof baseCreateTestModule>[1] = {},
+) => {
+  const wallResult = createTextWallTestModule(TextWall);
+  const siblingResult = createTextWallTestModule(ModuleClass, {
+    subscribe: false,
+    ...options,
+    observer: wallResult.observer,
+    state: wallResult.state,
+    shared: wallResult.shared,
+  });
 
-  return result;
+  return {
+    wall: wallResult.module as TextWall,
+    module: siblingResult.module,
+    observer: wallResult.observer,
+    state: wallResult.state,
+    shared: wallResult.shared,
+  };
 };
 
-export { SUBSCRIBE_EVENTS, PLUGIN_NAME };
+export { SUBSCRIBE_EVENTS, CONSTANTS, PLUGIN_NAME, TEXT_EVENTS };

package/src/tests/wall.test.ts

@@ -1,8 +1,5 @@
 import { beforeEach, describe, expect, it } from "vitest";
 
-import { SUBSCRIBE_EVENTS as SCENARIO_EVENTS } from "@vnejs/contracts.core.scenario";
-import { spyEvent } from "@vnejs/test-utils";
-
 import { TextWall } from "../modules/wall.js";
 import { createTextWallTestModule, registerTextWallPluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
 
@@ -11,26 +8,12 @@ describe("TextWall", () => {
     registerTextWallPluginVne();
   });
 
-  it("start command enables wall capture", async () => {
-    const { module, observer } = createTextWallTestModule(TextWall, { subscribe: false });
-    const changed = spyEvent(observer, SUBSCRIBE_EVENTS.CHANGED);
-    const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
+  it("STATE_UPDATE merges partial wall state", async () => {
+    const { module, observer } = createTextWallTestModule(TextWall);
 
-    await (module as TextWall).onLineExec({ line: "start" });
+    await observer.emit(SUBSCRIBE_EVENTS.STATE_UPDATE, { isStarted: true, shouldSkip: true });
 
     expect((module as TextWall).state.isStarted).toBe(true);
-    expect(changed).toHaveBeenCalledOnce();
-    expect(next).toHaveBeenCalledOnce();
-  });
-
-  it("clear command resets wall", async () => {
-    const { module, observer } = createTextWallTestModule(TextWall, { subscribe: false });
-
-    (module as TextWall).setState({ wall: [{ texts: [], tokens: [], uid: "1", speaker: "hero", speakerInfo: {} }], isStarted: true, shouldSkip: false });
-
-    await (module as TextWall).onLineExec({ line: "clear" });
-
-    expect((module as TextWall).state.wall).toEqual([]);
     expect((module as TextWall).state.shouldSkip).toBe(true);
   });
 });

package/src/types.ts

@@ -1,10 +1,10 @@
 import type { ModuleCoreConstants, ModuleCoreEvents, ModuleCoreParams, ModuleCoreSettings } from "@vnejs/module.core";
 import type { PluginName as TextPluginName, SubscribeEvents as TextSubscribeEvents } from "@vnejs/contracts.text";
-import type { PluginName, SubscribeEvents } from "@vnejs/contracts.text.wall";
+import type { PluginName, SubscribeEvents, Constants } from "@vnejs/contracts.text.wall";
 
 export type TextWallPluginEvents = ModuleCoreEvents & Record<PluginName, SubscribeEvents> & Record<TextPluginName, TextSubscribeEvents>;
 
-export type TextWallPluginConstants = ModuleCoreConstants;
+export type TextWallPluginConstants = ModuleCoreConstants & Record<PluginName, Constants>;
 
 export type TextWallPluginSettings = ModuleCoreSettings;