afnm-types 0.6.52 → 0.6.53

package/dist/GameScreen.d.ts

@@ -1 +1,2 @@
 export type GameScreen = 'location' | 'recipe' | 'mission' | 'craftingHall' | 'manual' | 'cultivation' | 'map' | 'healer' | 'market' | 'favour' | 'herbField' | 'mine' | 'recipeLibrary' | 'requestBoard' | 'compendium' | 'library' | 'altar' | 'research' | 'reforge' | 'pillarGrid' | 'fallenStar' | 'trainingGround' | 'tenThousandFlames' | 'lifeScreen' | 'soulShardDelve' | 'enchantmentShop' | 'challengeBoard';
+export type ScreenType = GameScreen | 'newgame' | 'combat' | 'crafting' | 'dualCultivation' | 'event' | 'auction' | 'mysticalRegion' | 'tournament' | 'house' | 'guild' | 'stoneCutting' | 'fallenStar' | 'soulShardDelve';

package/dist/avatarEffects.d.ts

@@ -10,9 +10,10 @@
 export type AvatarEffectId = 'glitch';
 export interface AvatarEffectShader {
     /**
-     * Fragment shader source. Must accept the same base uniforms as the default
-     * fragment shader (u_texA, u_texB, u_mix, u_aspectA, u_aspectB,
-     * u_canvasAspect) plus u_time (float, seconds since the effect started).
+     * Fragment shader source (GLSL ES 3.00, must begin with `#version 300 es`).
+     * Must accept the same uniforms as the base shader: u_texA, u_texB, u_mix,
+     * u_aspectA, u_aspectB, u_canvasAspect, u_time (seconds since effect started).
+     * Use `in vec2 v_uv` and `out vec4 fragColor` instead of the ES 1.00 forms.
      */
     fragSrc: string;
 }

package/dist/avatarEffects.js

@@ -11,9 +11,9 @@
 // Replicates the hand-authored glitch art style: strong persistent chromatic
 // aberration (cyan/magenta fringing always visible), periodic brightness
 // washout, and horizontal scanline tears during burst events.
-const GLITCH_FRAG_SRC = `
+const GLITCH_FRAG_SRC = `#version 300 es
 precision mediump float;
-varying vec2 v_uv;
+in vec2 v_uv;
 uniform sampler2D u_texA;
 uniform sampler2D u_texB;
 uniform float u_mix;
@@ -21,6 +21,7 @@ uniform float u_aspectA;
 uniform float u_aspectB;
 uniform float u_canvasAspect;
 uniform float u_time;
+out vec4 fragColor;
 
 float hash(float n) {
   return fract(sin(n) * 43758.5453);
@@ -39,7 +40,7 @@ vec4 sampleContain(sampler2D tex, vec2 uv, float texAspect) {
   if (mapped.x < 0.0 || mapped.x > 1.0 || mapped.y < 0.0 || mapped.y > 1.0) {
     return vec4(0.0);
   }
-  return texture2D(tex, mapped);
+  return texture(tex, mapped);
 }
 
 void main() {
@@ -86,7 +87,7 @@ void main() {
   float blowout = decay * 0.45;
   col.rgb = mix(col.rgb, vec3(1.0), blowout * col.a);
 
-  gl_FragColor = col;
+  fragColor = col;
 }`;
 // ─── Registry ─────────────────────────────────────────────────────────────────
 /**

package/dist/cli/extract-mod-translations/index.js

@@ -326,7 +326,7 @@ async function main() {
     console.log(`Template-ready strings : ${templateStrings.length}`);
     // Generate hierarchical template
     console.log('\nGenerating translation template...');
-    const template = (0, reporters_js_1.generateHierarchicalTemplate)(templateStrings);
+    const template = (0, reporters_js_1.generateHierarchicalTemplate)(templateStrings, undefined, undefined, false);
     const sortedTemplate = deepSortObject(template);
     const stringCount = countHierarchicalStrings(sortedTemplate);
     console.log(`  ${stringCount} unique translatable entries found.`);

package/dist/cli/extract-translations/reporters.js

@@ -243,7 +243,7 @@ function findMinimalUniquePaths(paths) {
  * - If different texts have same simple field -> use minimal unique path prefix
  * - If text is unique for its simple field -> just use simple field
  */
-function generateHierarchicalTemplate(allStrings, techniqueTooltipsData, textsRequiringContext) {
+function generateHierarchicalTemplate(allStrings, techniqueTooltipsData, textsRequiringContext, includeRootPatterns = true) {
     const template = {};
     const intermediate = new Map();
     // Helper to add entry to intermediate structure
@@ -637,37 +637,39 @@ function generateHierarchicalTemplate(allStrings, techniqueTooltipsData, textsRe
             }
         }
     }
-    // Add hardcoded patterns to a special category
-    if (!template['_patterns']) {
-        template['_patterns'] = {};
-    }
-    if (!template['_patterns']['hardcoded']) {
-        template['_patterns']['hardcoded'] = {};
-    }
-    // Add stack-related strings
-    template['_patterns']['hardcoded']['[word] stack'] = '';
-    template['_patterns']['hardcoded']['[word] stacks'] = '';
-    // Add dynamic template patterns
-    for (const tmpl of config_js_1.HARDCODED_TEMPLATE_PATTERNS) {
-        template['_patterns']['hardcoded'][`[template] ${tmpl}`] = '';
-    }
-    // Add condition words
-    if (!template['_patterns']['conditions']) {
-        template['_patterns']['conditions'] = {};
-    }
-    for (const word of config_js_1.CONDITION_WORDS) {
-        template['_patterns']['conditions'][`[word] ${word}`] = '';
-    }
-    // Add condition template strings from describeTechniqueCondition.ts and describeCraftingTechniqueCondition.ts
-    for (const tmpl of config_js_1.CONDITION_TEMPLATES) {
-        template['_patterns']['conditions'][`[condition] ${tmpl}`] = '';
-    }
-    // Add requirement strings
-    if (!template['_patterns']['requirements']) {
-        template['_patterns']['requirements'] = {};
-    }
-    for (const reqStr of config_js_1.REQUIREMENT_STRINGS) {
-        template['_patterns']['requirements'][`[requirement] ${reqStr}`] = '';
+    // Add hardcoded patterns to a special category (only when extracting for the game, not for mods)
+    if (includeRootPatterns) {
+        if (!template['_patterns']) {
+            template['_patterns'] = {};
+        }
+        if (!template['_patterns']['hardcoded']) {
+            template['_patterns']['hardcoded'] = {};
+        }
+        // Add stack-related strings
+        template['_patterns']['hardcoded']['[word] stack'] = '';
+        template['_patterns']['hardcoded']['[word] stacks'] = '';
+        // Add dynamic template patterns
+        for (const tmpl of config_js_1.HARDCODED_TEMPLATE_PATTERNS) {
+            template['_patterns']['hardcoded'][`[template] ${tmpl}`] = '';
+        }
+        // Add condition words
+        if (!template['_patterns']['conditions']) {
+            template['_patterns']['conditions'] = {};
+        }
+        for (const word of config_js_1.CONDITION_WORDS) {
+            template['_patterns']['conditions'][`[word] ${word}`] = '';
+        }
+        // Add condition template strings from describeTechniqueCondition.ts and describeCraftingTechniqueCondition.ts
+        for (const tmpl of config_js_1.CONDITION_TEMPLATES) {
+            template['_patterns']['conditions'][`[condition] ${tmpl}`] = '';
+        }
+        // Add requirement strings
+        if (!template['_patterns']['requirements']) {
+            template['_patterns']['requirements'] = {};
+        }
+        for (const reqStr of config_js_1.REQUIREMENT_STRINGS) {
+            template['_patterns']['requirements'][`[requirement] ${reqStr}`] = '';
+        }
     }
     return template;
 }

package/dist/components.d.ts

@@ -1,5 +1,5 @@
 import type { Breakpoint, ButtonProps, IconButtonProps } from '@mui/material';
-import type { ReactNode, PropsWithChildren } from 'react';
+import type { ReactNode, PropsWithChildren, ReactElement } from 'react';
 import type { SoundEffectName } from './audio';
 import type { ScreenEffectType } from './ScreenEffectType';
 import type React from 'react';
@@ -55,4 +55,22 @@ export interface BackgroundImageProps {
 }
 export type BackgroundImageFC = React.FC<BackgroundImageProps>;
 export type MemoBackgroundImageFC = React.NamedExoticComponent<BackgroundImageProps>;
+export interface GameTooltipProps {
+    provider: () => ReactNode;
+    children: ReactElement;
+    flipped?: boolean;
+    disabled?: boolean;
+    minimal?: boolean;
+}
+export interface GameTooltipBoxProps {
+    isSecondary?: boolean;
+    isAux?: boolean;
+    removeWidthLimit?: boolean;
+}
+export interface TooltipLineProps {
+    children?: React.ReactNode;
+}
+export type GameTooltipFC = React.FC<GameTooltipProps>;
+export type GameTooltipBoxFC = React.FC<PropsWithChildren<GameTooltipBoxProps>>;
+export type TooltipLineFC = React.ComponentType<TooltipLineProps>;
 export {};

package/dist/craftingState.d.ts

@@ -27,7 +27,7 @@ export interface HarmonyData {
     inscribedPatterns?: InscribedPatternsData;
     resonance?: ResonanceData;
     recommendedTechniqueTypes: CraftingTechniqueType[];
-    additionalData?: any;
+    additionalData?: unknown;
 }
 export interface CraftingEffectTracking {
     icon: string;

package/dist/dualCultivation.d.ts

@@ -1,10 +1,10 @@
 import type { Translatable } from './translatable';
-declare const intimateStats: readonly ["satisfaction", "energy", "painThreshold"];
-export type IntimateStat = (typeof intimateStats)[number];
-declare const intimateResources: readonly ["pain", "harmony", "excitement", "rhythm"];
-export type IntimateResource = (typeof intimateResources)[number];
-declare const intimateTechniqueTypes: readonly ["rough", "tender", "passionate"];
-export type IntimateTechniqueType = (typeof intimateTechniqueTypes)[number];
+declare const _intimateStats: readonly ["satisfaction", "energy", "painThreshold"];
+export type IntimateStat = (typeof _intimateStats)[number];
+declare const _intimateResources: readonly ["pain", "harmony", "excitement", "rhythm"];
+export type IntimateResource = (typeof _intimateResources)[number];
+declare const _intimateTechniqueTypes: readonly ["rough", "tender", "passionate"];
+export type IntimateTechniqueType = (typeof _intimateTechniqueTypes)[number];
 export declare const intimateTechniqueTypeToName: Record<IntimateTechniqueType, string>;
 export declare const intimateResourceToName: Record<IntimateResource, string>;
 export declare const dualCultivationCompletionStateToName: Record<string, string>;

package/dist/dualCultivation.js

@@ -1,6 +1,6 @@
-const intimateStats = ['satisfaction', 'energy', 'painThreshold'];
-const intimateResources = ['pain', 'harmony', 'excitement', 'rhythm'];
-const intimateTechniqueTypes = ['rough', 'tender', 'passionate'];
+const _intimateStats = ['satisfaction', 'energy', 'painThreshold'];
+const _intimateResources = ['pain', 'harmony', 'excitement', 'rhythm'];
+const _intimateTechniqueTypes = ['rough', 'tender', 'passionate'];
 export const intimateTechniqueTypeToName = {
     rough: 'Rough',
     tender: 'Tender',

package/dist/entity.js

@@ -1,4 +1,11 @@
-export const entityTypes = ['Player', 'Lifeform', 'Enemy', 'PlayerParty', 'EnemyParty', 'System'];
+export const entityTypes = [
+    'Player',
+    'Lifeform',
+    'Enemy',
+    'PlayerParty',
+    'EnemyParty',
+    'System',
+];
 export const sexes = ['male', 'female'];
 export const sexToName = {
     male: 'Male',

package/dist/gameVersion.d.ts

@@ -15,4 +15,4 @@
  *   };
  * }
  */
-export declare const GAME_VERSION = "0.6.52";
+export declare const GAME_VERSION = "0.6.53";

package/dist/gameVersion.js

@@ -15,4 +15,4 @@
  *   };
  * }
  */
-export const GAME_VERSION = "0.6.52";
+export const GAME_VERSION = "0.6.53";

package/dist/mod.d.ts

@@ -6,6 +6,8 @@ import type { AuctionItemDef, AuctionItem } from './auction';
 import type { Background } from './background';
 import type { Breakthrough } from './breakthrough';
 import type { Buff } from './buff';
+import type { BreakthroughState } from './breakthrough';
+import type { CharactersState } from './reduxState';
 import type { CalendarEvent } from './calendar';
 import type { Character } from './character';
 import type { CraftingTechnique, CraftingRecipeStats } from './craftingTechnique';
@@ -35,7 +37,7 @@ import type { ItemKind } from './item';
 import type { SoundEffectName } from './audio';
 import type { ScreenEffectType } from './ScreenEffectType';
 import type { RootState } from './reduxState';
-import type { GameDialogFC, GameButtonExoticFC, GameIconButtonExoticFC, MemoBackgroundImageFC } from './components';
+import type { GameDialogFC, GameButtonExoticFC, GameIconButtonExoticFC, MemoBackgroundImageFC, GameTooltipFC, GameTooltipBoxFC, TooltipLineFC } from './components';
 import type { PuppetType } from './trainingGround';
 import type { TechniqueElement } from './element';
 import type { AlternativeStart } from './alternativeStart';
@@ -43,8 +45,10 @@ import type { Tutorial } from './tutorial';
 import type { Sex } from './entity';
 import type { DamageType } from './DamageType';
 import { AvatarEffectShader } from './avatarEffects';
-import type { Translatable, TranslatableString } from '../types/translatable';
+import type { Translatable, TranslatableString } from './translatable';
 import type { SaveFileInfo } from './electron';
+import type { KeybindingDefinition } from './keybindings';
+import { ScreenType } from './GameScreen';
 /**
  * Sprite images for a custom player character.
  * All images should be strings (either mod:// URLs for mod assets, or data: URLs).
@@ -163,7 +167,7 @@ export interface ModReduxAPI {
          * @example
          * setModData('myMod', 'customNPC_affinity', { npcId: 'elder_li', value: 75 });
          */
-        setModData: (modName: string, key: string, data: any) => void;
+        setModData: (modName: string, key: string, data: unknown) => void;
         /**
          * Move player to a different location on the world map.
          * @param location - Location key from the locations data
@@ -303,35 +307,6 @@ export interface ModReduxAPI {
          * console.log('Completion after:', preview.progressState?.completion);
          */
         previewCraftingTechnique: (technique: CraftingTechnique, state: CraftingState) => CraftingState;
-        /**
-         * Save the current game state to a character-scoped backup file. The save is
-         * written to the character's backup folder with the given filename. Throws an
-         * error if no save is currently loaded or if the save operation fails.
-         * @param filename - Name of the save file (e.g. 'quicksave-001.json')
-         * @example
-         * makeSave('quicksave-001.json'); // Save to character-backup/quicksave-001.json
-         * makeSave('backup-myprogress.json');
-         */
-        makeSave: (filename: string) => Promise<void>;
-        /**
-         * Load game state from a character-scoped backup file. The current game state
-         * will be replaced by the loaded save. Throws an error if the file cannot be
-         * read or parsed.
-         * @param filename - Name of the save file to load (must exist in character backup folder)
-         * @example
-         * loadSave('quicksave-001.json'); // Load from character-backup/quicksave-001.json
-         * loadSave('backup-myprogress.json');
-         */
-        loadSave: (filename: string) => Promise<void>;
-        /**
-         * List all backup save files available for the current character. Throws if
-         * no save is currently loaded or if the operation fails.
-         * @returns Array of save file metadata
-         * @example
-         * const saves = listSaves();
-         * saves.forEach(s => console.log(s.name, new Date(s.lastModified)));
-         */
-        listSaves: () => Promise<SaveFileInfo[]>;
     };
     components: {
         GameDialog: GameDialogFC;
@@ -339,6 +314,14 @@ export interface ModReduxAPI {
         GameIconButton: GameIconButtonExoticFC;
         BackgroundImage: MemoBackgroundImageFC;
         PlayerComponent: React.FC;
+        GameTooltip: GameTooltipFC;
+        GameTooltipBox: GameTooltipBoxFC;
+        TooltipLine: TooltipLineFC;
+    };
+    utils: {
+        parseTooltipLine: (tooltip: string) => React.ReactNode;
+        expandTooltipTemplate: (template: string, templateValues: Map<string, string>, addPeriod?: boolean) => string;
+        expandTooltipTags: (template: string) => string;
     };
 }
 export type ModScreenFC = React.FC<{
@@ -1062,6 +1045,22 @@ export interface ModAPI {
          * const highScore = flags['myMod_highScore'] ?? 0;
          */
         getGlobalFlags: () => Record<string, number>;
+        /**
+         * Register a custom keybinding for your mod.
+         * Once registered, the keybinding is permanent for the session (mods cannot be unloaded without restarting the game).
+         * Users can rebind registered keybindings in the game settings Controls tab.
+         * @param definition - The keybinding definition including action name, category, display name, and default key
+         * @example
+         * registerKeybinding({
+         *   action: 'myMod.specialAction',
+         *   category: 'general',
+         *   displayName: 'Special Action',
+         *   description: 'Performs a special action',
+         *   defaultKey: 'F',
+         *   allowRebind: true,
+         * });
+         */
+        registerKeybinding: (definition: KeybindingDefinition) => void;
     };
     utils: {
         /**
@@ -1952,8 +1951,92 @@ export interface ModAPI {
          * };
          */
         tr: (key: string, variables?: Record<string, Translatable | number>, context?: string) => TranslatableString;
+        /**
+         * Save the current game state to a character-scoped backup file.
+         * Throws if no save is loaded or if the write fails.
+         * @param filename - Name of the backup file (e.g. 'quicksave-001.json')
+         */
+        makeSave: (filename: string) => Promise<void>;
+        /**
+         * Load game state from a character-scoped backup file, replacing current state.
+         * Throws if no save is loaded or if the file cannot be read.
+         * @param filename - Name of the backup file to load
+         */
+        loadSave: (filename: string) => Promise<void>;
+        /**
+         * List all backup save files available for the current character.
+         * Throws if no save is loaded.
+         * @returns Array of backup file metadata
+         */
+        listSaves: () => Promise<SaveFileInfo[]>;
+        /**
+         * Display a toast notification on the screen.
+         * @param message - The text message or ReactNode to display
+         * @param timeout - Optional timeout in milliseconds (default 3000ms)
+         * @param style - Optional toast style: 'info' (default), 'success', 'warning', 'error'
+         * @param customStyle - Optional custom styling { bg?, border?, color? }
+         * @example
+         * showToast('Item added to inventory');
+         * showToast('Quest completed!', 5000);
+         * showToast('Warning message', 3000, 'warning');
+         * showToast('Error!', 5000, 'error');
+         * showToast(<div><button>Click me</button></div>, 5000, 'info', { bg: '#ff0000', color: '#ffffff' });
+         */
+        showToast: (message: React.ReactNode, timeout?: number, style?: 'info' | 'success' | 'warning' | 'error', customStyle?: {
+            bg?: string;
+            border?: string;
+            color?: string;
+        }) => void;
+        /**
+         * Determine the current screen/game state from the Redux root state.
+         * @param rootState - The Redux root state
+         * @returns The current screen type identifier
+         * @example
+         * const screen = determineCurrentScreen(store.getState());
+         */
+        determineCurrentScreen: (rootState: RootState) => ScreenType;
     };
     hooks: {
+        /**
+         * Hook into player combat entity creation to modify stats.
+         * @param interceptor - Function to modify combat entity
+         * @example
+         * onCreatePlayerCombatEntity((player, combatEntity, breakthrough, flags) => {
+         *   if (flags.enhanced_powers) {
+         *     combatEntity.stats.power *= 1.2;
+         *   }
+         *   return combatEntity;
+         * });
+         */
+        onCreatePlayerCombatEntity: (interceptor: (player: PlayerEntity, combatEntity: CombatEntity, breakthrough: BreakthroughState, gameFlags: Record<string, number>) => CombatEntity) => void;
+        /**
+         * Hook into player crafting entity creation to modify stats.
+         * @param interceptor - Function to modify crafting entity
+         * @example
+         * onCreatePlayerCraftingEntity((player, craftingEntity, breakthrough, characters, flags) => {
+         *   if (flags.master_craftsman) {
+         *     craftingEntity.stats.control *= 1.2;
+         *   }
+         *   return craftingEntity;
+         * });
+         */
+        onCreatePlayerCraftingEntity: (interceptor: (player: PlayerEntity, craftingEntity: CraftingEntity, breakthrough: BreakthroughState, characters: CharactersState | undefined, gameFlags: Record<string, number>) => CraftingEntity) => void;
+        /**
+         * Hook called before crafting begins to modify recipe, recipe stats, or player.
+         * @param interceptor - Function returning modified recipe/stats/player or undefined
+         * @example
+         * onBeforeCraft((player, recipe, recipeStats, flags) => {
+         *   if (flags.sharp_tools && recipeStats.difficulty > 100) {
+         *     return { recipeStats: { ...recipeStats, difficulty: recipeStats.difficulty * 0.9 } };
+         *   }
+         *   return undefined;
+         * });
+         */
+        onBeforeCraft: (interceptor: (player: CraftingEntity, recipe: RecipeItem, recipeStats: CraftingRecipeStats, gameFlags: Record<string, number>) => {
+            recipe?: RecipeItem;
+            recipeStats?: CraftingRecipeStats;
+            player?: CraftingEntity;
+        } | undefined) => void;
         /**
          * Hook into enemy combat entity creation to modify stats.
          * @param interceptor - Function to modify combat entity

package/dist/reduxState.d.ts

@@ -62,6 +62,7 @@ export interface InventoryState {
     recipes: RecipeState[];
     money: number;
     favour: number;
+    favoritedItems?: string[];
 }
 export interface StanceTracking {
     techniques: string[];
@@ -275,7 +276,7 @@ export interface HouseState {
 }
 export interface ModSliceProps {
     activeMods: string[];
-    data: Record<string, Record<string, any>>;
+    data: Record<string, Record<string, unknown>>;
 }
 export interface DualCultivationState {
     partner?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "afnm-types",
-  "version": "0.6.52",
+  "version": "0.6.53",
   "description": "Type definitions for Ascend From Nine Mountains",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/dist/itemAction.d.ts

@@ -1,33 +0,0 @@
-import type { ReactNode } from 'react';
-import type { AppDispatch } from '../store';
-import type { BreakthroughState } from './breakthrough';
-import type { SoundEffectName } from './audio';
-import type { Item } from './item';
-import type { PlayerEntity } from './entity';
-import type { InventoryState } from './reduxState';
-interface OpenItem {
-    item: Item;
-    data: unknown;
-    onComplete: () => void;
-}
-export interface ItemActionContext {
-    item: Item;
-    player: PlayerEntity;
-    inventory: InventoryState;
-    breakthrough: BreakthroughState;
-    flags: Record<string, number | string | boolean>;
-    dispatch: AppDispatch;
-    setResult: (result: ReactNode) => void;
-    setClicked: (clicked: boolean) => void;
-    setOpenItem?: (openItem: OpenItem) => void;
-    setDoEnchant?: (doEnchant: boolean) => void;
-    setDoUpgrade?: (doUpgrade: boolean) => void;
-    setDoAppearanceChange?: (doAppearanceChange: boolean) => void;
-    playSfx: (sound: SoundEffectName) => void;
-    usageRestricted: boolean;
-}
-export interface ItemActionResult {
-    buttons: ReactNode[];
-}
-export type ItemActionHandler = (context: ItemActionContext) => ItemActionResult;
-export {};

package/dist/itemAction.js

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

package/dist/manual.d.ts

@@ -1,8 +0,0 @@
-import { Realm } from './realm';
-export interface Manual {
-    name: string;
-    icon: string;
-    realm: Realm;
-    techniques: string[];
-    stance: string[];
-}

package/dist/manual.js

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

package/dist/typeTests.d.ts

@@ -1,9 +0,0 @@
-/**
- * Type Tests - These files ensure type compatibility across the codebase
- * If any of these fail to compile, it means we have a type mismatch
- */
-import type { RootState as StoreRootState } from '../store';
-import type { RootState as TypesRootState } from './reduxState';
-type TestExactMatch = StoreRootState extends TypesRootState ? TypesRootState extends StoreRootState ? true : false : false;
-export type RootStateIsConsistent = TestExactMatch;
-export {};