@hieuxyz/rpc 1.0.6

package/dist/hieuxyz/rpc/HieuxyzRPC.d.ts

@@ -0,0 +1,115 @@
+import { DiscordWebSocket } from "../gateway/DiscordWebSocket";
+import { SettableActivityType } from "../gateway/entities/types";
+import { ImageService } from "./ImageService";
+import { RpcImage } from "./RpcImage";
+interface RpcButton {
+    label: string;
+    url: string;
+}
+export type DiscordPlatform = 'desktop' | 'android' | 'ios' | 'samsung' | 'xbox' | 'ps4' | 'ps5' | 'embedded';
+/**
+ * Class built for creating and managing Discord Rich Presence states.
+ */
+export declare class HieuxyzRPC {
+    private websocket;
+    private imageService;
+    private activity;
+    private assets;
+    private status;
+    private applicationId;
+    private platform;
+    private resolvedAssetsCache;
+    constructor(websocket: DiscordWebSocket, imageService: ImageService);
+    private _toRpcImage;
+    private sanitize;
+    /**
+     * Name the operation (first line of RPC).
+     * @param name - Name to display.
+     * @returns {this}
+     */
+    setName(name: string): this;
+    /**
+     * Set details for the operation (second line of RPC).
+     * @param details - Details to display.
+     * @returns {this}
+     */
+    setDetails(details: string): this;
+    /**
+     * Set the state for the operation (third line of the RPC).
+     * @param state - State to display.
+     * @returns {this}
+     */
+    setState(state: string): this;
+    /**
+     * Set the activity type.
+     * @param type - The type of activity (e.g. 0, 'playing', or ActivityType.Playing).
+     * @returns {this}
+     */
+    setType(type: SettableActivityType): this;
+    /**
+     * Set a start and/or end timestamp for the activity.
+     * @param start - Unix timestamp (milliseconds) for start time.
+     * @param end - Unix timestamp (milliseconds) for the end time.
+     * @returns {this}
+     */
+    setTimestamps(start?: number, end?: number): this;
+    /**
+     * Set party information for the activity.
+     * @param currentSize - Current number of players.
+     * @param maxSize - Maximum number of players.
+     * @returns {this}
+     */
+    setParty(currentSize: number, maxSize: number): this;
+    /**
+     * Set large image and its caption text.
+     * @param source - Image source (URL, asset key, or RpcImage object).
+     * @param text - Text displayed when hovering over image.
+     * @returns {this}
+     */
+    setLargeImage(source: string | RpcImage, text?: string): this;
+    /**
+     * Set the small image and its caption text.
+     * @param source - Image source (URL, asset key, or RpcImage object).
+     * @param text - Text displayed when hovering over image.
+     * @returns {this}
+     */
+    setSmallImage(source: string | RpcImage, text?: string): this;
+    /**
+     * Set clickable buttons for RPC (up to 2).
+     * @param buttons - An array of button objects.
+     * @returns {this}
+     */
+    setButtons(buttons: RpcButton[]): this;
+    /**
+     * Set custom application ID for RPC.
+     * @param id - Discord app ID (must be an 18 or 19 digit number string).
+     * @throws {Error} If ID is invalid.
+     * @returns {this}
+     */
+    setApplicationId(id: string): this;
+    /**
+     * Set the user's status (e.g. online, idle, dnd).
+     * @param status - Desired state.
+     * @returns {this}
+     */
+    setStatus(status: 'online' | 'dnd' | 'idle' | 'invisible' | 'offline'): this;
+    /**
+     * Set the platform on which the activity is running.
+     * @param platform - Platform (e.g. 'desktop', 'xbox').
+     * @returns {this}
+     */
+    setPlatform(platform: DiscordPlatform): this;
+    private buildActivity;
+    /**
+     * Build the final Rich Presence payload and send it to Discord.
+     * @returns {Promise<void>}
+     */
+    build(): Promise<void>;
+    /**
+     * Sends an update to an existing RPC.
+     * This is essentially an alias for `build()`.
+     * @returns {Promise<void>}
+     */
+    updateRPC(): Promise<void>;
+}
+export {};

package/dist/hieuxyz/rpc/HieuxyzRPC.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HieuxyzRPC = void 0;
+const types_1 = require("../gateway/entities/types");
+const RpcImage_1 = require("./RpcImage");
+/**
+ * Class built for creating and managing Discord Rich Presence states.
+ */
+class HieuxyzRPC {
+    websocket;
+    imageService;
+    activity = {};
+    assets = {};
+    status = 'online';
+    applicationId = '1416676323459469363'; // Default ID, can be changed
+    platform = 'desktop';
+    resolvedAssetsCache = {};
+    constructor(websocket, imageService) {
+        this.websocket = websocket;
+        this.imageService = imageService;
+    }
+    _toRpcImage(source) {
+        if (typeof source !== 'string') {
+            return source;
+        }
+        if (source.startsWith('https://') || source.startsWith('http://')) {
+            try {
+                const url = new URL(source);
+                if (url.hostname === 'cdn.discordapp.com' || url.hostname === 'media.discordapp.net') {
+                    const discordAssetPath = url.pathname.substring(1);
+                    return new RpcImage_1.DiscordImage(discordAssetPath);
+                }
+                else {
+                    return new RpcImage_1.ExternalImage(source);
+                }
+            }
+            catch (e) {
+                console.warn(`Could not parse "${source}" into a valid URL. Treating as RawImage.`);
+                return new RpcImage_1.RawImage(source);
+            }
+        }
+        if (source.startsWith('attachments/') || source.startsWith('external/')) {
+            return new RpcImage_1.DiscordImage(source);
+        }
+        return new RpcImage_1.RawImage(source);
+    }
+    sanitize(str, length = 128) {
+        return str.length > length ? str.substring(0, length) : str;
+    }
+    /**
+     * Name the operation (first line of RPC).
+     * @param name - Name to display.
+     * @returns {this}
+     */
+    setName(name) {
+        this.activity.name = this.sanitize(name);
+        return this;
+    }
+    /**
+     * Set details for the operation (second line of RPC).
+     * @param details - Details to display.
+     * @returns {this}
+     */
+    setDetails(details) {
+        this.activity.details = this.sanitize(details);
+        return this;
+    }
+    /**
+     * Set the state for the operation (third line of the RPC).
+     * @param state - State to display.
+     * @returns {this}
+     */
+    setState(state) {
+        this.activity.state = this.sanitize(state);
+        return this;
+    }
+    /**
+     * Set the activity type.
+     * @param type - The type of activity (e.g. 0, 'playing', or ActivityType.Playing).
+     * @returns {this}
+     */
+    setType(type) {
+        if (typeof type === 'string') {
+            const typeMap = {
+                playing: types_1.ActivityType.Playing,
+                streaming: types_1.ActivityType.Streaming,
+                listening: types_1.ActivityType.Listening,
+                watching: types_1.ActivityType.Watching,
+                custom: types_1.ActivityType.Custom,
+                competing: types_1.ActivityType.Competing,
+            };
+            this.activity.type = typeMap[type.toLowerCase()] ?? types_1.ActivityType.Playing;
+        }
+        else {
+            this.activity.type = type;
+        }
+        return this;
+    }
+    /**
+     * Set a start and/or end timestamp for the activity.
+     * @param start - Unix timestamp (milliseconds) for start time.
+     * @param end - Unix timestamp (milliseconds) for the end time.
+     * @returns {this}
+     */
+    setTimestamps(start, end) {
+        this.activity.timestamps = { start, end };
+        return this;
+    }
+    /**
+     * Set party information for the activity.
+     * @param currentSize - Current number of players.
+     * @param maxSize - Maximum number of players.
+     * @returns {this}
+     */
+    setParty(currentSize, maxSize) {
+        this.activity.party = { id: 'hieuxyz', size: [currentSize, maxSize] };
+        return this;
+    }
+    /**
+     * Set large image and its caption text.
+     * @param source - Image source (URL, asset key, or RpcImage object).
+     * @param text - Text displayed when hovering over image.
+     * @returns {this}
+     */
+    setLargeImage(source, text) {
+        this.assets.large_image = this._toRpcImage(source);
+        if (text)
+            this.assets.large_text = this.sanitize(text);
+        delete this.resolvedAssetsCache.large_image;
+        return this;
+    }
+    /**
+     * Set the small image and its caption text.
+     * @param source - Image source (URL, asset key, or RpcImage object).
+     * @param text - Text displayed when hovering over image.
+     * @returns {this}
+     */
+    setSmallImage(source, text) {
+        this.assets.small_image = this._toRpcImage(source);
+        if (text)
+            this.assets.small_text = this.sanitize(text);
+        delete this.resolvedAssetsCache.small_image;
+        return this;
+    }
+    /**
+     * Set clickable buttons for RPC (up to 2).
+     * @param buttons - An array of button objects.
+     * @returns {this}
+     */
+    setButtons(buttons) {
+        const validButtons = buttons.slice(0, 2);
+        this.activity.buttons = validButtons.map(b => this.sanitize(b.label, 32));
+        this.activity.metadata = { button_urls: validButtons.map(b => b.url) };
+        return this;
+    }
+    /**
+     * Set custom application ID for RPC.
+     * @param id - Discord app ID (must be an 18 or 19 digit number string).
+     * @throws {Error} If ID is invalid.
+     * @returns {this}
+     */
+    setApplicationId(id) {
+        if (!/^\d{18,19}$/.test(id)) {
+            throw new Error("The app ID must be an 18 or 19 digit number.");
+        }
+        this.applicationId = id;
+        return this;
+    }
+    /**
+     * Set the user's status (e.g. online, idle, dnd).
+     * @param status - Desired state.
+     * @returns {this}
+     */
+    setStatus(status) {
+        this.status = status;
+        return this;
+    }
+    /**
+     * Set the platform on which the activity is running.
+     * @param platform - Platform (e.g. 'desktop', 'xbox').
+     * @returns {this}
+     */
+    setPlatform(platform) {
+        this.platform = platform;
+        return this;
+    }
+    async buildActivity() {
+        if (this.assets.large_image && !this.resolvedAssetsCache.large_image) {
+            this.resolvedAssetsCache.large_image = await this.assets.large_image.resolve(this.imageService);
+        }
+        if (this.assets.small_image && !this.resolvedAssetsCache.small_image) {
+            this.resolvedAssetsCache.small_image = await this.assets.small_image.resolve(this.imageService);
+        }
+        const finalAssets = {
+            large_text: this.assets.large_text,
+            small_text: this.assets.small_text,
+        };
+        if (this.resolvedAssetsCache.large_image) {
+            finalAssets.large_image = this.resolvedAssetsCache.large_image;
+        }
+        if (this.resolvedAssetsCache.small_image) {
+            finalAssets.small_image = this.resolvedAssetsCache.small_image;
+        }
+        const finalActivity = { ...this.activity };
+        finalActivity.assets = finalAssets;
+        finalActivity.application_id = this.applicationId;
+        finalActivity.platform = this.platform;
+        if (!finalActivity.name) {
+            finalActivity.name = "Custom Status";
+        }
+        if (typeof finalActivity.type === 'undefined') {
+            finalActivity.type = types_1.ActivityType.Playing;
+        }
+        return finalActivity;
+    }
+    /**
+     * Build the final Rich Presence payload and send it to Discord.
+     * @returns {Promise<void>}
+     */
+    async build() {
+        const activity = await this.buildActivity();
+        const presencePayload = {
+            since: 0,
+            activities: [activity],
+            status: this.status,
+            afk: false,
+        };
+        this.websocket.sendActivity(presencePayload);
+    }
+    /**
+     * Sends an update to an existing RPC.
+     * This is essentially an alias for `build()`.
+     * @returns {Promise<void>}
+     */
+    async updateRPC() {
+        await this.build();
+    }
+}
+exports.HieuxyzRPC = HieuxyzRPC;

package/dist/hieuxyz/rpc/ImageService.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A service to handle external image proxying and local image uploading.
+ * Interact with a backend API service to manage image assets.
+ */
+export declare class ImageService {
+    private apiClient;
+    /**
+     * Create an ImageService instance.
+     * @param apiBaseUrl - The base URL of the image upload/proxy API.
+     */
+    constructor(apiBaseUrl?: string);
+    /**
+     * Get an asset key proxy for an external image URL.
+     * @param url - URL of external image.
+     * @returns {Promise<string | undefined>} Asset key resolved or undefined if failed.
+     */
+    getExternalUrl(url: string): Promise<string | undefined>;
+    /**
+     * Upload an image from the local file system to the image service.
+     * @param filePath - Path to the image file.
+     * @param fileName - File name to use when uploading.
+     * @returns {Promise<string | undefined>} Asset key resolved or undefined if failed.
+     */
+    uploadImage(filePath: string, fileName: string): Promise<string | undefined>;
+}

package/dist/hieuxyz/rpc/ImageService.js

@@ -0,0 +1,106 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const fs = __importStar(require("fs"));
+const form_data_1 = __importDefault(require("form-data"));
+const logger_1 = require("../utils/logger");
+/**
+ * A service to handle external image proxying and local image uploading.
+ * Interact with a backend API service to manage image assets.
+ */
+class ImageService {
+    apiClient;
+    /**
+     * Create an ImageService instance.
+     * @param apiBaseUrl - The base URL of the image upload/proxy API.
+     */
+    constructor(apiBaseUrl = 'https://rpc.hieuxyz.fun') {
+        this.apiClient = axios_1.default.create({
+            baseURL: apiBaseUrl,
+        });
+    }
+    /**
+     * Get an asset key proxy for an external image URL.
+     * @param url - URL of external image.
+     * @returns {Promise<string | undefined>} Asset key resolved or undefined if failed.
+     */
+    async getExternalUrl(url) {
+        try {
+            const response = await this.apiClient.get('/image', { params: { url } });
+            if (response.data && response.data.id) {
+                return response.data.id;
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`Unable to get external proxy URL for ${url}: ${error}`);
+        }
+        return undefined;
+    }
+    /**
+     * Upload an image from the local file system to the image service.
+     * @param filePath - Path to the image file.
+     * @param fileName - File name to use when uploading.
+     * @returns {Promise<string | undefined>} Asset key resolved or undefined if failed.
+     */
+    async uploadImage(filePath, fileName) {
+        try {
+            if (!fs.existsSync(filePath)) {
+                logger_1.logger.error(`File not found at path: ${filePath}`);
+                return undefined;
+            }
+            const form = new form_data_1.default();
+            form.append('file', fs.createReadStream(filePath));
+            form.append('file_name', fileName);
+            const response = await this.apiClient.post('/upload', form, {
+                headers: {
+                    ...form.getHeaders()
+                }
+            });
+            if (response.data && response.data.id) {
+                return response.data.id;
+            }
+        }
+        catch (error) {
+            logger_1.logger.error(`Unable to upload image ${fileName}: ${error}`);
+        }
+        return undefined;
+    }
+}
+exports.ImageService = ImageService;

package/dist/hieuxyz/rpc/RpcImage.d.ts

@@ -0,0 +1,47 @@
+import { ImageService } from './ImageService';
+/**
+ * Base abstract class for all RPC image types.
+ */
+export declare abstract class RpcImage {
+    /**
+     * Resolve the image into an asset key that Discord can understand.
+     * @param imageService - An instance of ImageService to handle uploads or proxies.
+     * @returns {Promise<string | undefined>} Asset key has been resolved.
+     */
+    abstract resolve(imageService: ImageService): Promise<string | undefined>;
+}
+/**
+ * Represents an image that already exists on Discord's servers (e.g., via proxy or previous upload).
+ */
+export declare class DiscordImage extends RpcImage {
+    private imageKey;
+    constructor(imageKey: string);
+    resolve(): Promise<string | undefined>;
+}
+/**
+ * Represents an image from an external URL.
+ */
+export declare class ExternalImage extends RpcImage {
+    private url;
+    constructor(url: string);
+    resolve(imageService: ImageService): Promise<string | undefined>;
+}
+/**
+ * Represents an image from the local file system.
+ * Images will be uploaded via ImageService.
+ */
+export declare class LocalImage extends RpcImage {
+    private filePath;
+    private fileName;
+    constructor(filePath: string, fileName?: string);
+    resolve(imageService: ImageService): Promise<string | undefined>;
+}
+/**
+ * Represents a resolved raw asset key.
+ * No further processing required.
+ */
+export declare class RawImage extends RpcImage {
+    private assetKey;
+    constructor(assetKey: string);
+    resolve(imageService: ImageService): Promise<string | undefined>;
+}

package/dist/hieuxyz/rpc/RpcImage.js

@@ -0,0 +1,103 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RawImage = exports.LocalImage = exports.ExternalImage = exports.DiscordImage = exports.RpcImage = void 0;
+const path = __importStar(require("path"));
+/**
+ * Base abstract class for all RPC image types.
+ */
+class RpcImage {
+}
+exports.RpcImage = RpcImage;
+/**
+ * Represents an image that already exists on Discord's servers (e.g., via proxy or previous upload).
+ */
+class DiscordImage extends RpcImage {
+    imageKey;
+    constructor(imageKey) {
+        super();
+        this.imageKey = imageKey;
+    }
+    async resolve() {
+        return this.imageKey.startsWith('mp:') ? this.imageKey : `mp:${this.imageKey}`;
+    }
+}
+exports.DiscordImage = DiscordImage;
+/**
+ * Represents an image from an external URL.
+ */
+class ExternalImage extends RpcImage {
+    url;
+    constructor(url) {
+        super();
+        this.url = url;
+    }
+    async resolve(imageService) {
+        return imageService.getExternalUrl(this.url);
+    }
+}
+exports.ExternalImage = ExternalImage;
+/**
+ * Represents an image from the local file system.
+ * Images will be uploaded via ImageService.
+ */
+class LocalImage extends RpcImage {
+    filePath;
+    fileName;
+    constructor(filePath, fileName) {
+        super();
+        this.filePath = filePath;
+        this.fileName = fileName || path.basename(filePath);
+    }
+    async resolve(imageService) {
+        return imageService.uploadImage(this.filePath, this.fileName);
+    }
+}
+exports.LocalImage = LocalImage;
+/**
+ * Represents a resolved raw asset key.
+ * No further processing required.
+ */
+class RawImage extends RpcImage {
+    assetKey;
+    constructor(assetKey) {
+        super();
+        this.assetKey = assetKey;
+    }
+    async resolve(imageService) {
+        return this.assetKey;
+    }
+}
+exports.RawImage = RawImage;

package/dist/hieuxyz/utils/logger.d.ts

@@ -0,0 +1,5 @@
+export declare const logger: {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+};

package/dist/hieuxyz/utils/logger.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = void 0;
+exports.logger = {
+    info: (message) => console.log(`[INFO] ${new Date().toISOString()} - ${message}`),
+    warn: (message) => console.warn(`[WARN] ${new Date().toISOString()} - ${message}`),
+    error: (message) => console.error(`[ERROR] ${new Date().toISOString()} - ${message}`),
+};

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { Client, ClientOptions } from './hieuxyz/Client';
+export { DiscordWebSocket } from './hieuxyz/gateway/DiscordWebSocket';
+export { HieuxyzRPC } from './hieuxyz/rpc/HieuxyzRPC';
+export { ImageService } from './hieuxyz/rpc/ImageService';
+export { RpcImage, DiscordImage, ExternalImage, LocalImage, RawImage } from './hieuxyz/rpc/RpcImage';
+export { logger } from './hieuxyz/utils/logger';
+export * from './hieuxyz/gateway/entities/types';