@vnejs/plugins.scenario.qte 0.1.1

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,6 @@
+import "@vnejs/contracts.scenario.qte";
+import { regPlugin } from "@vnejs/shared";
+import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.scenario.qte";
+import { Qte } from "./modules/qte.js";
+import { QteScenario } from "./modules/scenario.js";
+regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS }, [Qte, QteScenario]);

package/dist/modules/qte.d.ts

@@ -0,0 +1,10 @@
+import { ModuleCore } from "@vnejs/module.core";
+import type { QtePluginConstants, QtePluginEvents, QtePluginParams, QtePluginSettings } from "../types.js";
+import type { QteEmitPayload, QteResultPayload } from "../utils/qte.js";
+export declare class Qte extends ModuleCore<QtePluginEvents, QtePluginConstants, QtePluginSettings, QtePluginParams> {
+    name: string;
+    subscribe: () => void;
+    onQteEmit: (payload?: QteEmitPayload) => Promise<void>;
+    onQteResult: ({ success }?: QteResultPayload) => Promise<void>;
+    applyResult: (success: boolean) => Promise<void>;
+}

package/dist/modules/qte.js

@@ -0,0 +1,31 @@
+import { ModuleCore } from "@vnejs/module.core";
+export class Qte extends ModuleCore {
+    name = "qte";
+    subscribe = () => {
+        this.on(this.EVENTS.QTE.EMIT, this.onQteEmit);
+        this.on(this.EVENTS.QTE.RESULT, this.onQteResult);
+    };
+    onQteEmit = async (payload = {}) => {
+        this.emitLog({ action: "emit", id: payload.id });
+        await this.emit(this.EVENTS.QTE.OPENED, payload);
+    };
+    onQteResult = async ({ success = false } = {}) => {
+        this.emitLog({ action: "result", success });
+        await this.emit(this.EVENTS.QTE.CLOSED, { isForce: false });
+        await this.applyResult(success);
+        this.emitNext();
+    };
+    applyResult = async (success) => {
+        if (success) {
+            this.globalState.scenario.curLine += 1;
+            return;
+        }
+        const { curLine = 0, label } = this.globalState.scenario;
+        const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label }));
+        const parentIndent = lines[curLine]?.indent ?? 0;
+        let indexShift = 1;
+        while (lines[curLine + indexShift] && (lines[curLine + indexShift].indent ?? 0) > parentIndent)
+            indexShift++;
+        this.globalState.scenario.curLine += indexShift;
+    };
+}

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 { QtePluginConstants, QtePluginEvents, QtePluginParams, QtePluginSettings } from "../types.js";
+export declare class QteScenario extends ModuleCore<QtePluginEvents, QtePluginConstants, QtePluginSettings, QtePluginParams> {
+    name: string;
+    execName: string;
+    init: () => Promise<unknown[]> | undefined;
+    onLineExec: ({ line }?: LineExecHandlerArg) => Promise<void>;
+}

package/dist/modules/scenario.js

@@ -0,0 +1,17 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { tokenizeExecLine } from "@vnejs/helpers";
+export class QteScenario extends ModuleCore {
+    name = "qte.scenario";
+    execName = "qte";
+    init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: this.execName, handler: this.onLineExec });
+    onLineExec = async ({ line = "" } = {}) => {
+        const [id = ""] = tokenizeExecLine(line).map(String);
+        const item = this.PARAMS.QTE.ITEMS[id];
+        if (!id || !item) {
+            this.emitLog({ action: "missing", id });
+            await this.emit(this.EVENTS.QTE.RESULT, { success: false });
+            return;
+        }
+        await this.emit(this.EVENTS.QTE.EMIT, { id, item });
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,9 @@
+import type { ModuleCoreConstants, ModuleCoreEvents, ModuleCoreParams, ModuleCoreSettings } from "@vnejs/module.core";
+import type { PluginName as LogsPluginName, SubscribeEvents as LogsSubscribeEvents } from "@vnejs/contracts.core.logs";
+import type { Constants as ScenarioConstants, PluginName as ScenarioPluginName, SubscribeEvents as ScenarioSubscribeEvents } from "@vnejs/contracts.core.scenario";
+import type { PluginName as VendorsPluginName, SubscribeEvents as VendorsSubscribeEvents } from "@vnejs/contracts.core.vendors";
+import type { PluginName, SubscribeEvents, Params } from "@vnejs/contracts.scenario.qte";
+export type QtePluginEvents = ModuleCoreEvents & Record<PluginName, SubscribeEvents> & Record<ScenarioPluginName, ScenarioSubscribeEvents> & Record<VendorsPluginName, VendorsSubscribeEvents> & Record<LogsPluginName, LogsSubscribeEvents>;
+export type QtePluginConstants = ModuleCoreConstants & Record<ScenarioPluginName, ScenarioConstants>;
+export type QtePluginSettings = ModuleCoreSettings;
+export type QtePluginParams = ModuleCoreParams & Record<PluginName, Params>;

package/dist/types.js

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

package/dist/utils/qte.d.ts

@@ -0,0 +1,6 @@
+export type { QteEmitPayload, QteItem, QteResultPayload, QteVisibilityPayload } from "@vnejs/contracts.scenario.qte";
+export type ScenarioLine = {
+    line: string;
+    args?: Record<string, unknown>;
+    indent?: number;
+};

package/dist/utils/qte.js

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

package/package.json

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

package/src/index.ts

@@ -0,0 +1,9 @@
+import "@vnejs/contracts.scenario.qte";
+
+import { regPlugin } from "@vnejs/shared";
+import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.scenario.qte";
+
+import { Qte } from "./modules/qte.js";
+import { QteScenario } from "./modules/scenario.js";
+
+regPlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: PARAMS }, [Qte, QteScenario]);

package/src/modules/qte.ts

@@ -0,0 +1,42 @@
+import { ModuleCore } from "@vnejs/module.core";
+
+import type { QtePluginConstants, QtePluginEvents, QtePluginParams, QtePluginSettings } from "../types.js";
+import type { QteEmitPayload, QteResultPayload, QteVisibilityPayload, ScenarioLine } from "../utils/qte.js";
+
+export class Qte extends ModuleCore<QtePluginEvents, QtePluginConstants, QtePluginSettings, QtePluginParams> {
+  name = "qte";
+
+  subscribe = () => {
+    this.on(this.EVENTS.QTE.EMIT, this.onQteEmit);
+    this.on(this.EVENTS.QTE.RESULT, this.onQteResult);
+  };
+
+  onQteEmit = async (payload: QteEmitPayload = {}) => {
+    this.emitLog({ action: "emit", id: payload.id });
+    await this.emit(this.EVENTS.QTE.OPENED, payload satisfies QteVisibilityPayload);
+  };
+
+  onQteResult = async ({ success = false }: QteResultPayload = {}) => {
+    this.emitLog({ action: "result", success });
+    await this.emit(this.EVENTS.QTE.CLOSED, { isForce: false } satisfies QteVisibilityPayload);
+    await this.applyResult(success);
+    this.emitNext();
+  };
+
+  applyResult = async (success: boolean) => {
+    if (success) {
+      this.globalState.scenario.curLine += 1;
+      return;
+    }
+
+    const { curLine = 0, label } = this.globalState.scenario;
+    const lines = (await this.emitOne(this.EVENTS.SCENARIO.LINES_GET, { label })) as ScenarioLine[];
+    const parentIndent = lines[curLine]?.indent ?? 0;
+
+    let indexShift = 1;
+
+    while (lines[curLine + indexShift] && (lines[curLine + indexShift].indent ?? 0) > parentIndent) indexShift++;
+
+    this.globalState.scenario.curLine += indexShift;
+  };
+}

package/src/modules/scenario.ts

@@ -0,0 +1,28 @@
+import { ModuleCore } from "@vnejs/module.core";
+import { tokenizeExecLine } from "@vnejs/helpers";
+
+import type { LineExecHandlerArg } from "@vnejs/module.core";
+
+import type { QtePluginConstants, QtePluginEvents, QtePluginParams, QtePluginSettings } from "../types.js";
+import type { QteEmitPayload } from "../utils/qte.js";
+
+export class QteScenario extends ModuleCore<QtePluginEvents, QtePluginConstants, QtePluginSettings, QtePluginParams> {
+  name = "qte.scenario";
+
+  execName = "qte";
+
+  init = () => this.emit(this.EVENTS.SCENARIO.LINE_EXEC_REG, { block: this.execName, handler: this.onLineExec });
+
+  onLineExec = async ({ line = "" }: LineExecHandlerArg = {}) => {
+    const [id = ""] = tokenizeExecLine(line).map(String);
+    const item = this.PARAMS.QTE.ITEMS[id];
+
+    if (!id || !item) {
+      this.emitLog({ action: "missing", id });
+      await this.emit(this.EVENTS.QTE.RESULT, { success: false });
+      return;
+    }
+
+    await this.emit(this.EVENTS.QTE.EMIT, { id, item } satisfies QteEmitPayload);
+  };
+}

package/src/tests/qte.test.ts

@@ -0,0 +1,56 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent, stubEvent } from "@vnejs/test-utils";
+import { SUBSCRIBE_EVENTS as SCENARIO_EVENTS } from "@vnejs/contracts.core.scenario";
+
+import { Qte } from "../modules/qte.js";
+import { createQteTestModule, registerQtePluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+const LINES = [
+  { line: "% qte door_lock", indent: 0 },
+  { line: '"success"', indent: 2 },
+  { line: '"after"', indent: 0 },
+];
+
+describe("Qte", () => {
+  beforeEach(() => registerQtePluginVne());
+
+  it("EMIT bridges to OPENED", async () => {
+    const { observer } = createQteTestModule(Qte);
+    const opened = spyEvent(observer, SUBSCRIBE_EVENTS.OPENED);
+    const payload = { id: "door_lock", item: { start: 70, size: 20, duration: 1500 } };
+
+    await observer.emit(SUBSCRIBE_EVENTS.EMIT, payload);
+
+    expect(opened).toHaveBeenCalledExactlyOnceWith(payload);
+  });
+
+  it("RESULT success enters the block", async () => {
+    const { module, observer, state } = createQteTestModule(Qte);
+    const closed = spyEvent(observer, SUBSCRIBE_EVENTS.CLOSED);
+    const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
+
+    stubEvent(observer, SCENARIO_EVENTS.LINES_GET, () => LINES);
+    state.scenario.curLine = 0;
+
+    await observer.emit(SUBSCRIBE_EVENTS.RESULT, { success: true });
+
+    expect(closed).toHaveBeenCalledOnce();
+    expect(state.scenario.curLine).toBe(1);
+    expect(next).toHaveBeenCalledOnce();
+    expect((module as Qte).name).toBe("qte");
+  });
+
+  it("RESULT fail skips the block", async () => {
+    const { observer, state } = createQteTestModule(Qte);
+    const next = spyEvent(observer, SCENARIO_EVENTS.NEXT);
+
+    stubEvent(observer, SCENARIO_EVENTS.LINES_GET, () => LINES);
+    state.scenario.curLine = 0;
+
+    await observer.emit(SUBSCRIBE_EVENTS.RESULT, { success: false });
+
+    expect(state.scenario.curLine).toBe(2);
+    expect(next).toHaveBeenCalledOnce();
+  });
+});

package/src/tests/scenario.test.ts

@@ -0,0 +1,41 @@
+import { beforeEach, describe, expect, it } from "vitest";
+
+import { spyEvent } from "@vnejs/test-utils";
+import { SUBSCRIBE_EVENTS as SCENARIO_EVENTS } from "@vnejs/contracts.core.scenario";
+
+import { QteScenario } from "../modules/scenario.js";
+import { createQteTestModule, registerQtePluginVne, SUBSCRIBE_EVENTS } from "./setup.js";
+
+describe("QteScenario", () => {
+  beforeEach(() => registerQtePluginVne());
+
+  it("onLineExec emits EMIT with item from PARAMS", async () => {
+    const { module, observer } = createQteTestModule(QteScenario, { subscribe: false });
+    const emit = spyEvent(observer, SUBSCRIBE_EVENTS.EMIT);
+
+    await (module as QteScenario).onLineExec({ line: "door_lock" });
+
+    expect(emit).toHaveBeenCalledExactlyOnceWith({
+      id: "door_lock",
+      item: { start: 70, size: 20, duration: 1500 },
+    });
+  });
+
+  it("onLineExec emits RESULT fail when item is missing", async () => {
+    const { module, observer } = createQteTestModule(QteScenario, { subscribe: false });
+    const result = spyEvent(observer, SUBSCRIBE_EVENTS.RESULT);
+
+    await (module as QteScenario).onLineExec({ line: "unknown" });
+
+    expect(result).toHaveBeenCalledExactlyOnceWith({ success: false });
+  });
+
+  it("init registers block handler", async () => {
+    const { module, observer } = createQteTestModule(QteScenario, { subscribe: false, init: false });
+    const reg = spyEvent(observer, SCENARIO_EVENTS.LINE_EXEC_REG);
+
+    await (module as QteScenario).init();
+
+    expect(reg).toHaveBeenCalledExactlyOnceWith({ block: "qte", handler: expect.any(Function) });
+  });
+});

package/src/tests/setup.ts

@@ -0,0 +1,28 @@
+import { PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.scenario.qte";
+import { createTestModule as baseCreateTestModule, registerCoreVne, registerVnePlugin, stubSilentEvent } from "@vnejs/test-utils";
+import { SUBSCRIBE_EVENTS as SCENARIO_EVENTS } from "@vnejs/contracts.core.scenario";
+
+export const registerQtePluginVne = () => {
+  registerCoreVne();
+  registerVnePlugin(PLUGIN_NAME, { events: SUBSCRIBE_EVENTS, params: { ...PARAMS, ITEMS: { door_lock: { start: 70, size: 20, duration: 1500 } } } });
+};
+
+export const createQteTestModule = <T extends Parameters<typeof baseCreateTestModule>[0]>(
+  ModuleClass: T,
+  options: Parameters<typeof baseCreateTestModule>[1] = {},
+) => {
+  const result = baseCreateTestModule(ModuleClass, {
+    state: {
+      scenario: { curLine: 0, label: "start" },
+      ...(options.state ?? {}),
+    },
+    ...options,
+  });
+
+  stubSilentEvent(result.observer, SCENARIO_EVENTS.NEXT);
+  stubSilentEvent(result.observer, SCENARIO_EVENTS.LINE_EXEC_REG);
+
+  return result;
+};
+
+export { SUBSCRIBE_EVENTS, PLUGIN_NAME, SCENARIO_EVENTS };

package/src/types.ts

@@ -0,0 +1,23 @@
+import type { ModuleCoreConstants, ModuleCoreEvents, ModuleCoreParams, ModuleCoreSettings } from "@vnejs/module.core";
+
+import type { PluginName as LogsPluginName, SubscribeEvents as LogsSubscribeEvents } from "@vnejs/contracts.core.logs";
+import type {
+  Constants as ScenarioConstants,
+  PluginName as ScenarioPluginName,
+  SubscribeEvents as ScenarioSubscribeEvents,
+} from "@vnejs/contracts.core.scenario";
+import type { PluginName as VendorsPluginName, SubscribeEvents as VendorsSubscribeEvents } from "@vnejs/contracts.core.vendors";
+
+import type { PluginName, SubscribeEvents, Params } from "@vnejs/contracts.scenario.qte";
+
+export type QtePluginEvents = ModuleCoreEvents &
+  Record<PluginName, SubscribeEvents> &
+  Record<ScenarioPluginName, ScenarioSubscribeEvents> &
+  Record<VendorsPluginName, VendorsSubscribeEvents> &
+  Record<LogsPluginName, LogsSubscribeEvents>;
+
+export type QtePluginConstants = ModuleCoreConstants & Record<ScenarioPluginName, ScenarioConstants>;
+
+export type QtePluginSettings = ModuleCoreSettings;
+
+export type QtePluginParams = ModuleCoreParams & Record<PluginName, Params>;

package/src/utils/qte.ts

@@ -0,0 +1,7 @@
+export type { QteEmitPayload, QteItem, QteResultPayload, QteVisibilityPayload } from "@vnejs/contracts.scenario.qte";
+
+export type ScenarioLine = {
+  line: string;
+  args?: Record<string, unknown>;
+  indent?: number;
+};

package/tsconfig.json

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