@vnejs/plugins.views.achievement 0.2.0 → 0.2.2

package/dist/modules/achievement.d.ts

@@ -1,9 +1,10 @@
 import { ModuleCore } from "@vnejs/module.core";
 import type { AchievementPluginConstants, AchievementPluginEvents, AchievementPluginParams, AchievementPluginSettings } from "../types.js";
-import type { AchievementUnlockPayload } from "../utils/achievement.js";
+import type { AchievementLockPayload, AchievementUnlockPayload } from "../utils/achievement.js";
 export declare class Achievement extends ModuleCore<AchievementPluginEvents, AchievementPluginConstants, AchievementPluginSettings, AchievementPluginParams> {
     name: string;
     subscribe: () => void;
     onAchievementClear: () => Promise<unknown> | undefined;
+    onAchievementLock: ({ id }?: AchievementLockPayload) => Promise<void>;
     onAchievementUnlock: ({ id, isSkipIfPossible }?: AchievementUnlockPayload) => Promise<unknown[] | undefined>;
 }

package/dist/modules/achievement.js

@@ -4,9 +4,14 @@ export class Achievement extends ModuleCore {
     name = "achievement";
     subscribe = () => {
         this.on(this.EVENTS.ACHIEVEMENT.CLEAR, this.onAchievementClear);
+        this.on(this.EVENTS.ACHIEVEMENT.LOCK, this.onAchievementLock);
         this.on(this.EVENTS.ACHIEVEMENT.UNLOCK, this.onAchievementUnlock);
     };
     onAchievementClear = () => this.emitOne(this.EVENTS.STORAGE.RM_ALL, { module: this.name });
+    onAchievementLock = async ({ id = "" } = {}) => {
+        this.emit(this.EVENTS.STORAGE.RM, { module: this.name, key: id });
+        this.emit(this.EVENTS.ACHIEVEMENT.LOCKED, { id });
+    };
     onAchievementUnlock = async ({ id = "", isSkipIfPossible = false } = {}) => {
         const storageValue = await this.emitOne(this.EVENTS.STORAGE.GET, { module: this.name, key: id });
         this.emit(this.EVENTS.STORAGE.SET, { module: this.name, key: id, value: STORAGE_VALUE });

package/dist/modules/exec.d.ts

@@ -7,6 +7,7 @@ export declare class AchievementExec extends ModuleCore<AchievementPluginEvents,
     onLineExec: ({ keywords, line }?: LineExecHandlerArg) => Promise<void>;
     onLineLoad: ({ line, priority }?: LineLoadHandlerArg) => Promise<unknown> | undefined;
     emitActionExec: (action?: string, tokens?: string[], keywords?: string[]) => Promise<unknown> | undefined;
+    emitLockExec: (id?: string, isSkipIfPossible?: boolean) => Promise<unknown> | undefined;
     emitUnlockExec: (id?: string, isSkipIfPossible?: boolean) => Promise<unknown> | undefined;
     emitActionLoad: (action?: string, tokens?: string[], priority?: number) => Promise<unknown> | undefined;
     emitUnlockLoad: (id?: string, priority?: number) => Promise<unknown> | undefined;

package/dist/modules/exec.js

@@ -17,9 +17,12 @@ export class AchievementExec extends ModuleCore {
     };
     emitActionExec = (action = "", tokens = [], keywords = []) => {
         const isSkipIfPossible = keywords.includes(this.CONST.SCENARIO.LINE_KEYWORDS.SKIP_IF_POSSIBLE);
+        if (action === this.CONST.ACHIEVEMENT.EXEC_ACTIONS.LOCK)
+            return this.emitLockExec(tokens[0], isSkipIfPossible);
         if (action === this.CONST.ACHIEVEMENT.EXEC_ACTIONS.UNLOCK)
             return this.emitUnlockExec(tokens[0], isSkipIfPossible);
     };
+    emitLockExec = (id = "", isSkipIfPossible = false) => this.emitOne(this.EVENTS.ACHIEVEMENT.LOCK, { id, isSkipIfPossible });
     emitUnlockExec = (id = "", isSkipIfPossible = false) => this.emitOne(this.EVENTS.ACHIEVEMENT.UNLOCK, { id, isSkipIfPossible });
     emitActionLoad = (action = "", tokens = [], priority) => {
         if (action === this.CONST.ACHIEVEMENT.EXEC_ACTIONS.UNLOCK)

package/dist/modules/logs.d.ts

@@ -1,8 +1,9 @@
 import { ModuleCore } from "@vnejs/module.core";
 import type { AchievementPluginConstants, AchievementPluginEvents, AchievementPluginParams, AchievementPluginSettings } from "../types.js";
-import type { AchievementUnlockedPayload } from "../utils/achievement.js";
+import type { AchievementLockedPayload, AchievementUnlockedPayload } from "../utils/achievement.js";
 export declare class AchievementLogs extends ModuleCore<AchievementPluginEvents, AchievementPluginConstants, AchievementPluginSettings, AchievementPluginParams> {
     name: string;
     subscribe: () => void;
+    onAchievementLocked: ({ id }?: AchievementLockedPayload) => undefined;
     onAchievementUnlocked: ({ id }?: AchievementUnlockedPayload) => undefined;
 }

package/dist/modules/logs.js

@@ -2,7 +2,9 @@ import { ModuleCore } from "@vnejs/module.core";
 export class AchievementLogs extends ModuleCore {
     name = "achievement.logs";
     subscribe = () => {
+        this.on(this.EVENTS.ACHIEVEMENT.LOCKED, this.onAchievementLocked, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
         this.on(this.EVENTS.ACHIEVEMENT.UNLOCKED, this.onAchievementUnlocked, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
     };
+    onAchievementLocked = ({ id = "" } = {}) => void this.emitLog({ action: this.CONST.ACHIEVEMENT.LOGS_ACTIONS.LOCKED, id });
     onAchievementUnlocked = ({ id = "" } = {}) => void this.emitLog({ action: this.CONST.ACHIEVEMENT.LOGS_ACTIONS.UNLOCKED, id });
 }

package/dist/utils/achievement.d.ts

@@ -10,6 +10,10 @@ export type AchievementPluginState = {
     array?: AchievementItem[];
     locs?: Record<string, string>;
 };
+export type AchievementLockPayload = {
+    id?: string;
+    isSkipIfPossible?: boolean;
+};
 export type AchievementUnlockPayload = {
     id?: string;
     isSkipIfPossible?: boolean;
@@ -21,6 +25,9 @@ export type AchievementLoadPayload = {
     id?: string;
     priority?: number;
 };
+export type AchievementLockedPayload = {
+    id?: string;
+};
 export type AchievementUnlockedPayload = {
     id?: string;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vnejs/plugins.views.achievement",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/modules/achievement.ts

@@ -1,7 +1,7 @@
 import { ModuleCore } from "@vnejs/module.core";
 
 import type { AchievementPluginConstants, AchievementPluginEvents, AchievementPluginParams, AchievementPluginSettings } from "../types.js";
-import type { AchievementUnlockPayload } from "../utils/achievement.js";
+import type { AchievementLockPayload, AchievementUnlockPayload } from "../utils/achievement.js";
 
 const STORAGE_VALUE = 1;
 
@@ -10,11 +10,17 @@ export class Achievement extends ModuleCore<AchievementPluginEvents, Achievement
 
   subscribe = () => {
     this.on(this.EVENTS.ACHIEVEMENT.CLEAR, this.onAchievementClear);
+    this.on(this.EVENTS.ACHIEVEMENT.LOCK, this.onAchievementLock);
     this.on(this.EVENTS.ACHIEVEMENT.UNLOCK, this.onAchievementUnlock);
   };
 
   onAchievementClear = () => this.emitOne(this.EVENTS.STORAGE.RM_ALL, { module: this.name });
 
+  onAchievementLock = async ({ id = "" }: AchievementLockPayload = {}) => {
+    this.emit(this.EVENTS.STORAGE.RM, { module: this.name, key: id });
+    this.emit(this.EVENTS.ACHIEVEMENT.LOCKED, { id });
+  };
+
   onAchievementUnlock = async ({ id = "", isSkipIfPossible = false }: AchievementUnlockPayload = {}) => {
     const storageValue = await this.emitOne(this.EVENTS.STORAGE.GET, { module: this.name, key: id });
 

package/src/modules/controller.ts

@@ -41,6 +41,5 @@ export class AchievementController extends ModuleController<
     this.updateStateAndViewFast({ array: this.state.array?.filter((i) => i.id !== id) });
   };
 
-  getIconSrc = async (icon = "") =>
-    (await this.loadImageMedia(`achievement/${icon}`, "icons", this.shared.settings[this.SETTINGS.LAYER.QUALITY])).src;
+  getIconSrc = async (icon = "") => (await this.loadImageMedia(`achievement/${icon}`, "icons", this.shared.settings[this.SETTINGS.LAYER.QUALITY])).src;
 }

package/src/modules/exec.ts

@@ -31,9 +31,12 @@ export class AchievementExec extends ModuleCore<AchievementPluginEvents, Achieve
   emitActionExec = (action = "", tokens: string[] = [], keywords: string[] = []) => {
     const isSkipIfPossible = keywords.includes(this.CONST.SCENARIO.LINE_KEYWORDS.SKIP_IF_POSSIBLE);
 
+    if (action === this.CONST.ACHIEVEMENT.EXEC_ACTIONS.LOCK) return this.emitLockExec(tokens[0], isSkipIfPossible);
     if (action === this.CONST.ACHIEVEMENT.EXEC_ACTIONS.UNLOCK) return this.emitUnlockExec(tokens[0], isSkipIfPossible);
   };
 
+  emitLockExec = (id = "", isSkipIfPossible = false) => this.emitOne(this.EVENTS.ACHIEVEMENT.LOCK, { id, isSkipIfPossible });
+
   emitUnlockExec = (id = "", isSkipIfPossible = false) => this.emitOne(this.EVENTS.ACHIEVEMENT.UNLOCK, { id, isSkipIfPossible });
 
   emitActionLoad = (action = "", tokens: string[] = [], priority?: number) => {

package/src/modules/logs.ts

@@ -1,15 +1,17 @@
 import { ModuleCore } from "@vnejs/module.core";
 
 import type { AchievementPluginConstants, AchievementPluginEvents, AchievementPluginParams, AchievementPluginSettings } from "../types.js";
-import type { AchievementUnlockedPayload } from "../utils/achievement.js";
+import type { AchievementLockedPayload, AchievementUnlockedPayload } from "../utils/achievement.js";
 
 export class AchievementLogs extends ModuleCore<AchievementPluginEvents, AchievementPluginConstants, AchievementPluginSettings, AchievementPluginParams> {
   name = "achievement.logs";
 
   subscribe = () => {
+    this.on(this.EVENTS.ACHIEVEMENT.LOCKED, this.onAchievementLocked, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
     this.on(this.EVENTS.ACHIEVEMENT.UNLOCKED, this.onAchievementUnlocked, this.CONST.LOGS.FILTER_FROM_RESULT_OPTIONS);
   };
 
-  onAchievementUnlocked = ({ id = "" }: AchievementUnlockedPayload = {}) =>
-    void this.emitLog({ action: this.CONST.ACHIEVEMENT.LOGS_ACTIONS.UNLOCKED, id });
+  onAchievementLocked = ({ id = "" }: AchievementLockedPayload = {}) => void this.emitLog({ action: this.CONST.ACHIEVEMENT.LOGS_ACTIONS.LOCKED, id });
+
+  onAchievementUnlocked = ({ id = "" }: AchievementUnlockedPayload = {}) => void this.emitLog({ action: this.CONST.ACHIEVEMENT.LOGS_ACTIONS.UNLOCKED, id });
 }

package/src/tests/exec.test.ts

@@ -16,7 +16,7 @@ describe("AchievementExec", () => {
     const unlock = spyEvent(observer, SUBSCRIBE_EVENTS.UNLOCK);
 
     await (module as AchievementExec).init();
-    await (module as AchievementExec).onLineExec({ line: 'unlock kekw', keywords: [] });
+    await (module as AchievementExec).onLineExec({ line: "unlock kekw", keywords: [] });
 
     expect(unlock).toHaveBeenCalledExactlyOnceWith({ id: "kekw", isSkipIfPossible: false });
   });
@@ -26,7 +26,7 @@ describe("AchievementExec", () => {
     const unlock = spyEvent(observer, SUBSCRIBE_EVENTS.UNLOCK);
 
     await (module as AchievementExec).onLineExec({
-      line: 'unlock kekw',
+      line: "unlock kekw",
       keywords: [SCENARIO_CONST.LINE_KEYWORDS.SKIP_IF_POSSIBLE],
     });
 
@@ -37,7 +37,7 @@ describe("AchievementExec", () => {
     const { module, observer } = createAchievementTestModule(AchievementExec, { subscribe: false });
     const load = spyEvent(observer, SUBSCRIBE_EVENTS.LOAD);
 
-    await (module as AchievementExec).onLineLoad({ line: 'unlock kekw' });
+    await (module as AchievementExec).onLineLoad({ line: "unlock kekw" });
 
     expect(load).toHaveBeenCalledOnce();
   });
@@ -48,7 +48,7 @@ describe("AchievementExec", () => {
 
     observer.subscribe("vne:scenario:next", next);
 
-    await (module as AchievementExec).onLineExec({ line: 'unlock kekw' });
+    await (module as AchievementExec).onLineExec({ line: "unlock kekw" });
 
     expect(next).toHaveBeenCalledOnce();
   });

package/src/tests/setup.ts

@@ -2,13 +2,7 @@ import { CONSTANTS as LAYER_CONST, PLUGIN_NAME as LAYER, SETTINGS_KEYS as LAYER_
 import { SUBSCRIBE_EVENTS as MEDIA_EVENTS } from "@vnejs/contracts.core.media";
 import { SUBSCRIBE_EVENTS as STORAGE_EVENTS } from "@vnejs/contracts.core.storage";
 import { CONSTANTS, PARAMS, PLUGIN_NAME, SUBSCRIBE_EVENTS } from "@vnejs/contracts.views.achievement";
-import {
-  createTestModule as baseCreateTestModule,
-  registerCoreVne,
-  registerVnePlugin,
-  stubEvent,
-  stubSilentEvent,
-} from "@vnejs/test-utils";
+import { createTestModule as baseCreateTestModule, registerCoreVne, registerVnePlugin, stubEvent, stubSilentEvent } from "@vnejs/test-utils";
 
 export const registerAchievementPluginVne = () => {
   registerCoreVne();

package/src/types.ts

@@ -1,6 +1,10 @@
 import type { ModuleComponentsConstants, ModuleComponentsEvents, ModuleComponentsParams, ModuleComponentsSettings } from "@vnejs/module.components";
 import type { Constants as LogsConstants, 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 {
+  Constants as ScenarioConstants,
+  PluginName as ScenarioPluginName,
+  SubscribeEvents as ScenarioSubscribeEvents,
+} from "@vnejs/contracts.core.scenario";
 import type { PluginName as StoragePluginName, SubscribeEvents as StorageSubscribeEvents } from "@vnejs/contracts.core.storage";
 import type { Constants, Params, PluginName, SubscribeEvents } from "@vnejs/contracts.views.achievement";
 

package/src/utils/achievement.ts

@@ -12,6 +12,11 @@ export type AchievementPluginState = {
   locs?: Record<string, string>;
 };
 
+export type AchievementLockPayload = {
+  id?: string;
+  isSkipIfPossible?: boolean;
+};
+
 export type AchievementUnlockPayload = {
   id?: string;
   isSkipIfPossible?: boolean;
@@ -26,6 +31,10 @@ export type AchievementLoadPayload = {
   priority?: number;
 };
 
+export type AchievementLockedPayload = {
+  id?: string;
+};
+
 export type AchievementUnlockedPayload = {
   id?: string;
 };