@block52/poker-vm-sdk 1.0.7 → 1.0.8

package/dist/index.js

@@ -55820,6 +55820,246 @@ async function getAddressFromMnemonic(mnemonic, prefix = "b52") {
     return account.address;
 }
 
+/**
+ * Game Format Utilities
+ *
+ * Helper functions for working with GameFormat and GameVariant enum values.
+ * GameFormat uses kebab-case values: "cash", "sit-and-go", "tournament"
+ * GameVariant uses kebab-case values: "texas-holdem", "omaha"
+ */
+/**
+ * Check if a game format is a tournament-style game (SNG or Tournament).
+ * Tournament-style games have fixed buy-ins and elimination mechanics.
+ *
+ * @param format - GameFormat enum value or string
+ * @returns true if the format is SIT_AND_GO or TOURNAMENT
+ */
+const isTournamentFormat = (format) => {
+    if (!format)
+        return false;
+    return format === exports.GameFormat.SIT_AND_GO ||
+        format === exports.GameFormat.TOURNAMENT ||
+        format === "sit-and-go" ||
+        format === "tournament";
+};
+/**
+ * Check if a game format is a cash game.
+ * Cash games allow flexible buy-ins and players can leave anytime.
+ *
+ * @param format - GameFormat enum value or string
+ * @returns true if the format is CASH
+ */
+const isCashFormat = (format) => {
+    if (!format)
+        return false;
+    return format === exports.GameFormat.CASH || format === "cash";
+};
+/**
+ * Check if a game format is a Sit & Go.
+ * Sit & Go games start when all seats are filled.
+ *
+ * @param format - GameFormat enum value or string
+ * @returns true if the format is SIT_AND_GO
+ */
+const isSitAndGoFormat = (format) => {
+    if (!format)
+        return false;
+    return format === exports.GameFormat.SIT_AND_GO || format === "sit-and-go";
+};
+/**
+ * Format a game format value for display.
+ * Capitalizes words and replaces hyphens with spaces.
+ *
+ * @param format - GameFormat enum value or string
+ * @returns Formatted string for display (e.g., "Sit And Go", "Cash", "Tournament")
+ */
+const formatGameFormatDisplay = (format) => {
+    if (!format)
+        return "Unknown";
+    // Replace hyphens with spaces and capitalize each word
+    return format
+        .split("-")
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(" ");
+};
+/**
+ * Get the string value to send to Cosmos blockchain.
+ * Cosmos accepts kebab-case format values directly.
+ *
+ * @deprecated GameFormat enum values are already in kebab-case.
+ * Use gameOptions.format directly instead of this function.
+ * @param format - GameFormat enum value
+ * @returns The kebab-case string value (e.g., "sit-and-go", "cash", "tournament")
+ */
+const getGameFormatForCosmos = (format) => {
+    // GameFormat enum values are already in kebab-case, which Cosmos accepts
+    return format;
+};
+/**
+ * Get game format, returning "unknown" if it cannot be determined.
+ * Does NOT default to any value - explicitly returns "unknown" for visibility.
+ *
+ * @param format - GameFormat enum value, string, or undefined
+ * @returns GameFormat enum value, or "unknown" if cannot be determined
+ */
+const getGameFormat = (format) => {
+    if (!format)
+        return "unknown";
+    // If it's already a valid GameFormat enum value, return it
+    if (Object.values(exports.GameFormat).includes(format)) {
+        return format;
+    }
+    // Otherwise parse it
+    return parseGameFormat(format);
+};
+/**
+ * Extract game format from a game object with various property name conventions.
+ * Handles different API response formats (camelCase, snake_case, etc.)
+ *
+ * @param game - Game object that may have gameFormat or format properties
+ * @returns GameFormat enum value, or "unknown" if not found
+ */
+const getGameFormatFromObject = (game) => {
+    if (!game)
+        return "unknown";
+    const format = game.gameFormat || game.format;
+    return getGameFormat(format);
+};
+/**
+ * Parse a string value to GameFormat enum.
+ * Handles various input formats (kebab-case, snake_case, etc.)
+ *
+ * @param value - String value to parse
+ * @returns GameFormat enum value, or "unknown" if invalid
+ */
+const parseGameFormat = (value) => {
+    if (!value)
+        return "unknown";
+    const normalized = value.toLowerCase().replace(/_/g, "-");
+    switch (normalized) {
+        case "sit-and-go":
+        case "sitandgo":
+        case "sng":
+            return exports.GameFormat.SIT_AND_GO;
+        case "tournament":
+        case "tourney":
+            return exports.GameFormat.TOURNAMENT;
+        case "cash":
+        case "ring":
+            return exports.GameFormat.CASH;
+        default:
+            return "unknown";
+    }
+};
+/**
+ * Format a game variant value for display.
+ * Capitalizes words and replaces hyphens with spaces.
+ *
+ * @param variant - GameVariant enum value or string
+ * @returns Formatted string for display (e.g., "Texas Holdem", "Omaha", "Unknown")
+ */
+const formatGameVariantDisplay = (variant) => {
+    if (!variant)
+        return "Unknown";
+    // Replace hyphens with spaces and capitalize each word
+    return variant
+        .split("-")
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join(" ");
+};
+/**
+ * Get game variant, returning "unknown" if it cannot be determined.
+ * Does NOT default to any value - explicitly returns "unknown" for visibility.
+ *
+ * @param variant - GameVariant enum value, string, or undefined
+ * @returns GameVariant enum value, or "unknown" if cannot be determined
+ */
+const getGameVariant = (variant) => {
+    if (!variant)
+        return "unknown";
+    // If it's already a valid GameVariant enum value, return it
+    if (Object.values(exports.GameVariant).includes(variant)) {
+        return variant;
+    }
+    // Otherwise parse it
+    return parseGameVariant(variant);
+};
+/**
+ * Parse a string value to GameVariant enum.
+ * Handles various input formats (kebab-case, snake_case, etc.)
+ *
+ * @param value - String value to parse
+ * @returns GameVariant enum value, or "unknown" if invalid
+ */
+const parseGameVariant = (value) => {
+    if (!value)
+        return "unknown";
+    const normalized = value.toLowerCase().replace(/_/g, "-");
+    switch (normalized) {
+        case "texas-holdem":
+        case "texasholdem":
+        case "holdem":
+        case "nlh":
+            return exports.GameVariant.TEXAS_HOLDEM;
+        case "omaha":
+        case "plo":
+            return exports.GameVariant.OMAHA;
+        default:
+            return "unknown";
+    }
+};
+
+/**
+ * Check if a specific action is available in the legal actions list.
+ *
+ * @param legalActions - Array of legal actions available to the player
+ * @param action - The action type to check for
+ * @returns true if the action is available
+ */
+const hasAction = (legalActions, action) => {
+    return legalActions.some(legalAction => legalAction.action === action);
+};
+/**
+ * Find a specific action by type from the legal actions list.
+ *
+ * @param legalActions - Array of legal actions available to the player
+ * @param actionType - The action type to find
+ * @returns The matching LegalActionDTO or undefined if not found
+ */
+const getActionByType = (legalActions, actionType) => {
+    return legalActions.find(action => action.action === actionType || action.action?.toString() === actionType?.toString());
+};
+
+/**
+ * Address Utilities
+ *
+ * Helper functions for validating and checking Cosmos blockchain addresses.
+ */
+/**
+ * Check if an address represents an empty/vacant player slot.
+ * For Cosmos addresses (b52...), we only check for null/undefined/empty.
+ *
+ * @param address - The player address to check
+ * @returns true if the address is empty/vacant, false if it's a real player
+ */
+const isEmptyAddress = (address) => {
+    if (!address)
+        return true;
+    if (address === "")
+        return true;
+    return false;
+};
+/**
+ * Check if an address represents a valid (non-empty) player.
+ * Opposite of isEmptyAddress.
+ *
+ * @param address - The player address to check
+ * @returns true if the address is a valid player address, false if empty
+ */
+const isValidPlayerAddress = (address) => {
+    return !isEmptyAddress(address);
+};
+
 /**
  * Poker hand types in order of strength (weakest to strongest)
  */
@@ -57837,9 +58077,24 @@ exports.SigningCosmosClient = SigningCosmosClient;
 exports.WithdrawalRequest = WithdrawalRequest;
 exports.createSigningClientFromMnemonic = createSigningClientFromMnemonic;
 exports.createWalletFromMnemonic = createWalletFromMnemonic;
+exports.formatGameFormatDisplay = formatGameFormatDisplay;
+exports.formatGameVariantDisplay = formatGameVariantDisplay;
 exports.generateWallet = generateWallet;
+exports.getActionByType = getActionByType;
 exports.getAddressFromMnemonic = getAddressFromMnemonic;
 exports.getDefaultCosmosConfig = getDefaultCosmosConfig;
+exports.getGameFormat = getGameFormat;
+exports.getGameFormatForCosmos = getGameFormatForCosmos;
+exports.getGameFormatFromObject = getGameFormatFromObject;
+exports.getGameVariant = getGameVariant;
+exports.hasAction = hasAction;
+exports.isCashFormat = isCashFormat;
+exports.isEmptyAddress = isEmptyAddress;
+exports.isSitAndGoFormat = isSitAndGoFormat;
+exports.isTournamentFormat = isTournamentFormat;
 exports.isValidMnemonic = isValidMnemonic;
+exports.isValidPlayerAddress = isValidPlayerAddress;
+exports.parseGameFormat = parseGameFormat;
+exports.parseGameVariant = parseGameVariant;
 exports.registry = registry;
 //# sourceMappingURL=index.js.map