@dsh0416/steamworks.js 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Gabriel Francisco Dos Santos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,88 @@
+[![Build Status](https://github.com/ceifa/steamworks.js/actions/workflows/publish.yml/badge.svg)](https://github.com/ceifa/steamworks.js/actions/workflows/publish.yml)
+[![npm](https://img.shields.io/npm/v/steamworks.js.svg)](https://npmjs.com/package/steamworks.js)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Chat](https://img.shields.io/discord/663831597690257431?label=chat&logo=discord)](https://discord.gg/H6B7UE7fMY)
+
+# Steamworks.js
+
+A modern implementation of the Steamworks SDK for HTML/JS and NodeJS based applications.
+
+## Why
+
+I used [greenworks](https://github.com/greenheartgames/greenworks) for a long time and it's great, but I gave up for the following reasons.
+
+* It's not being maintained anymore.
+* It's not up to date.
+* It's not context-aware.
+* You have to build the binaries by yourself.
+* Don't have typescript definitions.
+* The API it's not trustful.
+* The API implement callbacks instead of return flags or promises.
+* I hate C++.
+
+## API
+
+```js
+const steamworks = require('steamworks.js')
+
+// You can pass an appId, or don't pass anything and use a steam_appid.txt file
+const client = steamworks.init(480)
+
+// Print Steam username
+console.log(client.localplayer.getName())
+
+// Tries to activate an achievement
+if (client.achievement.activate('ACHIEVEMENT')) {
+    // ...
+}
+```
+
+You can refer to the [declarations file](https://github.com/ceifa/steamworks.js/blob/main/client.d.ts) to check the API support and get more detailed documentation of each function.
+
+## Installation
+
+To use steamworks.js you don't have to build anything, just install it from npm:
+
+```sh
+$: npm i steamworks.js
+```
+
+### Electron
+
+Steamworks.js is a native module and cannot be used by default in the renderer process. To enable the usage of native modules on the renderer process, the following configurations should be made on `main.js`:
+
+```js
+const mainWindow = new BrowserWindow({
+    // ...
+    webPreferences: {
+        // ...
+        contextIsolation: false,
+        nodeIntegration: true
+    }
+})
+```
+
+To make the steam overlay working, call the `electronEnableSteamOverlay` on the end of your `main.js` file:
+
+```js
+require('steamworks.js').electronEnableSteamOverlay()
+```
+
+For the production build, copy the relevant distro files from `sdk/redistributable_bin/{YOUR_DISTRO}` into the root of your build. If you are using electron-forge, look for [#75](https://github.com/ceifa/steamworks.js/issues/75).
+
+
+## How to build
+
+> You **only** need to build if you are going to change something on steamworks.js code, if you are looking to just consume the library or use it in your game, refer to the [installation section](#installation).
+
+Make sure you have the latest [node.js](https://nodejs.org/en/), [Rust](https://www.rust-lang.org/tools/install) and [Clang](https://rust-lang.github.io/rust-bindgen/requirements.html). We also need [Steam](https://store.steampowered.com/about/) installed and running.
+
+Install dependencies with `npm install` and then run `npm run build:debug` to build the library.
+
+There is no way to build for all targets easily. The good news is that you don't need to. You can develop and test on your current target, and open a PR. When the code is merged to main, a github action will build for all targets and publish a new version.
+
+### Testing Electron
+
+Go to the [test/electron](./test/electron) directory. There, you can run `npm install` and then `npm start` to run the Electron app.
+
+Click "activate overlay" to test the overlay.

package/callbacks.d.ts

@@ -0,0 +1,56 @@
+import client = require('./client')
+
+export const enum ChatMemberStateChange {
+    /** This user has joined or is joining the lobby. */
+    Entered,
+    /** This user has left or is leaving the lobby. */
+    Left,
+    /** User disconnected without leaving the lobby first. */
+    Disconnected,
+    /** The user has been kicked. */
+    Kicked,
+    /** The user has been kicked and banned. */
+    Banned,
+}
+
+export interface CallbackReturns {
+    [client.callback.SteamCallback.PersonaStateChange]: {
+        steam_id: bigint
+        flags: { bits: number }
+    }
+    [client.callback.SteamCallback.SteamServersConnected]: {}
+    [client.callback.SteamCallback.SteamServersDisconnected]: {
+        reason: number
+    }
+    [client.callback.SteamCallback.SteamServerConnectFailure]: {
+        reason: number
+        still_retrying: boolean
+    }
+    [client.callback.SteamCallback.LobbyDataUpdate]: {
+        lobby: bigint
+        member: bigint
+        success: boolean
+    }
+    [client.callback.SteamCallback.LobbyChatUpdate]: {
+        lobby: bigint
+        user_changed: bigint
+        making_change: bigint
+        member_state_change: ChatMemberStateChange
+    }
+    [client.callback.SteamCallback.P2PSessionRequest]: {
+        remote: bigint
+    }
+    [client.callback.SteamCallback.P2PSessionConnectFail]: {
+        remote: bigint
+        error: number
+    }
+    [client.callback.SteamCallback.GameLobbyJoinRequested]: {
+        lobby_steam_id: bigint
+        friend_steam_id: bigint
+    }
+    [client.callback.SteamCallback.MicroTxnAuthorizationResponse]: {
+        app_id: number
+        order_id: number | bigint
+        authorized: boolean
+    }
+}

package/client.d.ts

@@ -0,0 +1,486 @@
+/// <reference types="node" />
+export declare function init(appId?: number | undefined | null): void
+
+export interface PlayerSteamId {
+  steamId64: bigint
+  steamId32: string
+  accountId: number
+}
+
+export declare function restartAppIfNecessary(appId: number): boolean
+
+export declare function runCallbacks(): void
+
+export declare namespace achievement {
+  export function activate(achievement: string): boolean
+  export function clear(achievement: string): boolean
+  export function isActivated(achievement: string): boolean
+  export function names(): Array<string>
+}
+
+export declare namespace apps {
+  export function appBuildId(): number
+  export function appInstallDir(appId: number): string
+  export function appOwner(): PlayerSteamId
+  export function availableGameLanguages(): Array<string>
+  export function currentBetaName(): string | null
+  export function currentGameLanguage(): string
+  export function isAppInstalled(appId: number): boolean
+  export function isCybercafe(): boolean
+  export function isDlcInstalled(appId: number): boolean
+  export function isLowViolence(): boolean
+  export function isSubscribed(): boolean
+  export function isSubscribedApp(appId: number): boolean
+  export function isSubscribedFromFreeWeekend(): boolean
+  export function isVacBanned(): boolean
+}
+
+export declare namespace auth {
+  export class Ticket {
+    cancel(): void
+    getBytes(): Buffer
+  }
+  export function getAuthTicketForWebApi(identity: string, timeoutSeconds?: number | undefined | null): Promise<Ticket>
+  /**
+   * @param ip - The string of IPv4 or IPv6 address. Use as NetworkIdentity of the remote system that will authenticate the ticket.
+   * @param timeoutSeconds - The number of seconds to wait for the ticket to be validated. Default value is 10 seconds.
+   */
+  export function getSessionTicketWithIp(ip: string, timeoutSeconds?: number | undefined | null): Promise<Ticket>
+  /**
+   * @param steamId64 - The user steam id or game server steam id. Use as NetworkIdentity of the remote system that will authenticate the ticket. If it is peer-to-peer then the user steam ID. If it is a game server, then the game server steam ID may be used if it was obtained from a trusted 3rd party
+   * @param timeoutSeconds - The number of seconds to wait for the ticket to be validated. Default value is 10 seconds.
+   */
+  export function getSessionTicketWithSteamId(steamId64: bigint, timeoutSeconds?: number | undefined | null): Promise<Ticket>
+}
+
+export declare namespace callback {
+  export class Handle {
+    disconnect(): void
+  }
+  export function register<C extends keyof import('./callbacks').CallbackReturns>(steamCallback: C, handler: (value: import('./callbacks').CallbackReturns[C]) => void): Handle
+  export const enum SteamCallback {
+    PersonaStateChange = 0,
+    SteamServersConnected = 1,
+    SteamServersDisconnected = 2,
+    SteamServerConnectFailure = 3,
+    LobbyDataUpdate = 4,
+    LobbyChatUpdate = 5,
+    P2PSessionRequest = 6,
+    P2PSessionConnectFail = 7,
+    GameLobbyJoinRequested = 8,
+    MicroTxnAuthorizationResponse = 9
+  }
+}
+
+export declare namespace cloud {
+  export function deleteFile(name: string): boolean
+  export function fileExists(name: string): boolean
+  export interface FileInfo {
+    name: string
+    size: bigint
+  }
+  export function isEnabledForAccount(): boolean
+  export function isEnabledForApp(): boolean
+  export function listFiles(): Array<FileInfo>
+  export function readFile(name: string): string
+  export function setEnabledForApp(enabled: boolean): void
+  export function writeFile(name: string, content: string): boolean
+}
+
+export declare namespace input {
+  export class Controller {
+    activateActionSet(actionSetHandle: bigint): void
+    isDigitalActionPressed(actionHandle: bigint): boolean
+    getAnalogActionVector(actionHandle: bigint): AnalogActionVector
+    getType(): InputType
+    getHandle(): bigint
+  }
+  export interface AnalogActionVector {
+    x: number
+    y: number
+  }
+  export function getActionSet(actionSetName: string): bigint
+  export function getAnalogAction(actionName: string): bigint
+  export function getControllers(): Array<Controller>
+  export function getDigitalAction(actionName: string): bigint
+  export function init(): void
+  export const enum InputType {
+    Unknown = 'Unknown',
+    SteamController = 'SteamController',
+    XBox360Controller = 'XBox360Controller',
+    XBoxOneController = 'XBoxOneController',
+    GenericGamepad = 'GenericGamepad',
+    PS4Controller = 'PS4Controller',
+    AppleMFiController = 'AppleMFiController',
+    AndroidController = 'AndroidController',
+    SwitchJoyConPair = 'SwitchJoyConPair',
+    SwitchJoyConSingle = 'SwitchJoyConSingle',
+    SwitchProController = 'SwitchProController',
+    MobileTouch = 'MobileTouch',
+    PS3Controller = 'PS3Controller',
+    PS5Controller = 'PS5Controller',
+    SteamDeckController = 'SteamDeckController'
+  }
+  export function shutdown(): void
+}
+
+export declare namespace localplayer {
+  /** @returns the 2 digit ISO 3166-1-alpha-2 format country code which client is running in, e.g. "US" or "UK". */
+  export function getIpCountry(): string
+  export function getLevel(): number
+  export function getName(): string
+  export function getSteamId(): PlayerSteamId
+  export function setRichPresence(key: string, value?: string | undefined | null): void
+}
+
+export declare namespace matchmaking {
+  export class Lobby {
+    get id(): bigint
+    join(): Promise<Lobby>
+    leave(): void
+    openInviteDialog(): void
+    getMemberCount(): bigint
+    getMemberLimit(): bigint | null
+    getMembers(): Array<PlayerSteamId>
+    getOwner(): PlayerSteamId
+    setJoinable(joinable: boolean): boolean
+    getData(key: string): string | null
+    setData(key: string, value: string): boolean
+    deleteData(key: string): boolean
+    /** Get an object containing all the lobby data */
+    getFullData(): Record<string, string>
+    /**
+     * Merge current lobby data with provided data in a single batch
+     * @returns true if all data was set successfully
+     */
+    mergeFullData(data: Record<string, string>): boolean
+  }
+  export function createLobby(lobbyType: LobbyType, maxMembers: number): Promise<Lobby>
+  export function getLobbies(): Promise<Array<Lobby>>
+  export function joinLobby(lobbyId: bigint): Promise<Lobby>
+  export const enum LobbyType {
+    Private = 0,
+    FriendsOnly = 1,
+    Public = 2,
+    Invisible = 3
+  }
+}
+
+export declare namespace networking {
+  export function acceptP2PSession(steamId64: bigint): void
+  export function isP2PPacketAvailable(): number
+  export interface P2PPacket {
+    data: Buffer
+    size: number
+    steamId: PlayerSteamId
+  }
+  export function readP2PPacket(size: number): P2PPacket
+  export function sendP2PPacket(steamId64: bigint, sendType: SendType, data: Buffer): boolean
+  /** The method used to send a packet */
+  export const enum SendType {
+    /**
+     * Send the packet directly over udp.
+     *
+     * Can't be larger than 1200 bytes
+     */
+    Unreliable = 0,
+    /**
+     * Like `Unreliable` but doesn't buffer packets
+     * sent before the connection has started.
+     */
+    UnreliableNoDelay = 1,
+    /**
+     * Reliable packet sending.
+     *
+     * Can't be larger than 1 megabyte.
+     */
+    Reliable = 2,
+    /**
+     * Like `Reliable` but applies the nagle
+     * algorithm to packets being sent
+     */
+    ReliableWithBuffering = 3
+  }
+}
+
+export declare namespace overlay {
+  export function activateDialog(dialog: Dialog): void
+  export function activateDialogToUser(dialog: Dialog, steamId64: bigint): void
+  export function activateInviteDialog(lobbyId: bigint): void
+  export function activateToStore(appId: number, flag: StoreFlag): void
+  export function activateToWebPage(url: string): void
+  export const enum Dialog {
+    Friends = 0,
+    Community = 1,
+    Players = 2,
+    Settings = 3,
+    OfficialGameGroup = 4,
+    Stats = 5,
+    Achievements = 6
+  }
+  export const enum StoreFlag {
+    None = 0,
+    AddToCart = 1,
+    AddToCartAndShow = 2
+  }
+}
+
+export declare namespace stats {
+  export function getInt(name: string): number | null
+  export function resetAll(achievementsToo: boolean): boolean
+  export function setInt(name: string, value: number): boolean
+  export function store(): boolean
+}
+
+export declare namespace utils {
+  export const enum FloatingGamepadTextInputMode {
+    SingleLine = 0,
+    MultipleLines = 1,
+    Email = 2,
+    Numeric = 3
+  }
+  export const enum GamepadTextInputLineMode {
+    SingleLine = 0,
+    MultipleLines = 1
+  }
+  export const enum GamepadTextInputMode {
+    Normal = 0,
+    Password = 1
+  }
+  export function getAppId(): number
+  export function getServerRealTime(): number
+  export function isSteamRunningOnSteamDeck(): boolean
+  /** @returns true if the floating keyboard was shown, otherwise, false */
+  export function showFloatingGamepadTextInput(keyboardMode: FloatingGamepadTextInputMode, x: number, y: number, width: number, height: number): Promise<boolean>
+  /** @returns the entered text, or null if cancelled or could not show the input */
+  export function showGamepadTextInput(inputMode: GamepadTextInputMode, inputLineMode: GamepadTextInputLineMode, description: string, maxCharacters: number, existingText?: string | undefined | null): Promise<string | null>
+}
+
+export declare namespace workshop {
+  export interface AppIDs {
+    creator?: number
+    consumer?: number
+  }
+  export function createItem(appId?: number | undefined | null): Promise<UgcResult>
+  export function deleteItem(itemId: bigint): Promise<void>
+  /**
+   * Download or update a workshop item.
+   *
+   * @param highPriority - If high priority is true, start the download in high priority mode, pausing any existing in-progress Steam downloads and immediately begin downloading this workshop item.
+   * @returns true or false
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#DownloadItem}
+   */
+  export function download(itemId: bigint, highPriority: boolean): boolean
+  /**
+   * Get info about a pending download of a workshop item.
+   *
+   * @returns an object with the properties {current, total}
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#GetItemDownloadInfo}
+   */
+  export function downloadInfo(itemId: bigint): DownloadInfo | null
+  export interface DownloadInfo {
+    current: bigint
+    total: bigint
+  }
+  export function getAllItems(page: number, queryType: UGCQueryType, itemType: UGCType, creatorAppId: number, consumerAppId: number, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopPaginatedResult>
+  export function getItem(item: bigint, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopItem | null>
+  export function getItems(items: Array<bigint>, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopItemsResult>
+  /**
+   * Get all subscribed workshop items.
+   * @returns an array of subscribed workshop item ids
+   */
+  export function getSubscribedItems(includeLocallyDisabled: boolean): Array<bigint>
+  export function getUserItems(page: number, accountId: number, listType: UserListType, itemType: UGCType, sortOrder: UserListOrder, appIds: AppIDs, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopPaginatedResult>
+  /**
+   * Gets info about currently installed content on the disc for workshop item.
+   *
+   * @returns an object with the the properties {folder, size_on_disk, timestamp}
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#GetItemInstallInfo}
+   */
+  export function installInfo(itemId: bigint): InstallInfo | null
+  export interface InstallInfo {
+    folder: string
+    sizeOnDisk: bigint
+    timestamp: number
+  }
+  /**
+   * Gets the current state of a workshop item on this client. States can be combined.
+   *
+   * @returns a number with the current item state, e.g. 9
+   * 9 = 1 (The current user is subscribed to this item) + 8 (The item needs an update)
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#GetItemState}
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#EItemState}
+   */
+  export function state(itemId: bigint): number
+  /**
+   * Subscribe to a workshop item. It will be downloaded and installed as soon as possible.
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#SubscribeItem}
+   */
+  export function subscribe(itemId: bigint): Promise<void>
+  export const enum UgcItemVisibility {
+    Public = 0,
+    FriendsOnly = 1,
+    Private = 2,
+    Unlisted = 3
+  }
+  export const enum UGCQueryType {
+    RankedByVote = 0,
+    RankedByPublicationDate = 1,
+    AcceptedForGameRankedByAcceptanceDate = 2,
+    RankedByTrend = 3,
+    FavoritedByFriendsRankedByPublicationDate = 4,
+    CreatedByFriendsRankedByPublicationDate = 5,
+    RankedByNumTimesReported = 6,
+    CreatedByFollowedUsersRankedByPublicationDate = 7,
+    NotYetRated = 8,
+    RankedByTotalVotesAsc = 9,
+    RankedByVotesUp = 10,
+    RankedByTextSearch = 11,
+    RankedByTotalUniqueSubscriptions = 12,
+    RankedByPlaytimeTrend = 13,
+    RankedByTotalPlaytime = 14,
+    RankedByAveragePlaytimeTrend = 15,
+    RankedByLifetimeAveragePlaytime = 16,
+    RankedByPlaytimeSessionsTrend = 17,
+    RankedByLifetimePlaytimeSessions = 18,
+    RankedByLastUpdatedDate = 19
+  }
+  export interface UgcResult {
+    itemId: bigint
+    needsToAcceptAgreement: boolean
+  }
+  export const enum UGCType {
+    Items = 0,
+    ItemsMtx = 1,
+    ItemsReadyToUse = 2,
+    Collections = 3,
+    Artwork = 4,
+    Videos = 5,
+    Screenshots = 6,
+    AllGuides = 7,
+    WebGuides = 8,
+    IntegratedGuides = 9,
+    UsableInGame = 10,
+    ControllerBindings = 11,
+    GameManagedItems = 12,
+    All = 13
+  }
+  export interface UgcUpdate {
+    title?: string
+    description?: string
+    changeNote?: string
+    previewPath?: string
+    contentPath?: string
+    tags?: Array<string>
+    visibility?: UgcItemVisibility
+  }
+  /**
+   * Unsubscribe from a workshop item. This will result in the item being removed after the game quits.
+   *
+   * {@link https://partner.steamgames.com/doc/api/ISteamUGC#UnsubscribeItem}
+   */
+  export function unsubscribe(itemId: bigint): Promise<void>
+  export function updateItem(itemId: bigint, updateDetails: UgcUpdate, appId?: number | undefined | null): Promise<UgcResult>
+  export function updateItemWithCallback(itemId: bigint, updateDetails: UgcUpdate, appId: number | undefined | null, successCallback: (data: UgcResult) => void, errorCallback: (err: any) => void, progressCallback?: (data: UpdateProgress) => void, progressCallbackIntervalMs?: number | undefined | null): void
+  export interface UpdateProgress {
+    status: UpdateStatus
+    progress: bigint
+    total: bigint
+  }
+  export const enum UpdateStatus {
+    Invalid = 0,
+    PreparingConfig = 1,
+    PreparingContent = 2,
+    UploadingContent = 3,
+    UploadingPreviewFile = 4,
+    CommittingChanges = 5
+  }
+  export const enum UserListOrder {
+    CreationOrderAsc = 0,
+    CreationOrderDesc = 1,
+    TitleAsc = 2,
+    LastUpdatedDesc = 3,
+    SubscriptionDateDesc = 4,
+    VoteScoreDesc = 5,
+    ForModeration = 6
+  }
+  export const enum UserListType {
+    Published = 0,
+    VotedOn = 1,
+    VotedUp = 2,
+    VotedDown = 3,
+    Favorited = 4,
+    Subscribed = 5,
+    UsedOrPlayed = 6,
+    Followed = 7
+  }
+  export interface WorkshopItem {
+    publishedFileId: bigint
+    creatorAppId?: number
+    consumerAppId?: number
+    title: string
+    description: string
+    owner: PlayerSteamId
+    /** Time created in unix epoch seconds format */
+    timeCreated: number
+    /** Time updated in unix epoch seconds format */
+    timeUpdated: number
+    /** Time when the user added the published item to their list (not always applicable), provided in Unix epoch format (time since Jan 1st, 1970). */
+    timeAddedToUserList: number
+    visibility: UgcItemVisibility
+    banned: boolean
+    acceptedForUse: boolean
+    tags: Array<string>
+    tagsTruncated: boolean
+    url: string
+    numUpvotes: number
+    numDownvotes: number
+    numChildren: number
+    previewUrl?: string
+    statistics: WorkshopItemStatistic
+  }
+  export interface WorkshopItemQueryConfig {
+    cachedResponseMaxAge?: number
+    includeMetadata?: boolean
+    includeLongDescription?: boolean
+    includeAdditionalPreviews?: boolean
+    onlyIds?: boolean
+    onlyTotal?: boolean
+    language?: string
+    matchAnyTag?: boolean
+    requiredTags?: Array<string>
+    excludedTags?: Array<string>
+    searchText?: string
+    rankedByTrendDays?: number
+  }
+  export interface WorkshopItemsResult {
+    items: Array<WorkshopItem | undefined | null>
+    wasCached: boolean
+  }
+  export interface WorkshopItemStatistic {
+    numSubscriptions?: bigint
+    numFavorites?: bigint
+    numFollowers?: bigint
+    numUniqueSubscriptions?: bigint
+    numUniqueFavorites?: bigint
+    numUniqueFollowers?: bigint
+    numUniqueWebsiteViews?: bigint
+    reportScore?: bigint
+    numSecondsPlayed?: bigint
+    numPlaytimeSessions?: bigint
+    numComments?: bigint
+    numSecondsPlayedDuringTimePeriod?: bigint
+    numPlaytimeSessionsDuringTimePeriod?: bigint
+  }
+  export interface WorkshopPaginatedResult {
+    items: Array<WorkshopItem | undefined | null>
+    returnedResults: number
+    totalResults: number
+    wasCached: boolean
+  }
+}

package/index.d.ts

@@ -0,0 +1,5 @@
+export function init(appId?: number): Omit<Client, "init" | "runCallbacks">;
+export function restartAppIfNecessary(appId: number): boolean;
+export function electronEnableSteamOverlay(disableEachFrameInvalidation?: boolean): void;
+export type Client = typeof import("./client.d");
+export const SteamCallback: typeof import("./client.d").callback.SteamCallback;

package/index.js

@@ -0,0 +1,77 @@
+const { platform, arch } = process
+
+/** @typedef {typeof import('./client.d')} Client */
+/** @type {Client} */
+let nativeBinding = undefined
+
+if (platform === 'win32' && arch === 'x64') {
+    nativeBinding = require('./dist/win64/steamworksjs.win32-x64-msvc.node')
+} else if (platform === 'linux' && arch === 'x64') {
+    nativeBinding = require('./dist/linux64/steamworksjs.linux-x64-gnu.node')
+} else if (platform === 'darwin') {
+    if (arch === 'x64') {
+        nativeBinding = require('./dist/osx/steamworksjs.darwin-x64.node')
+    } else if (arch === 'arm64') {
+        nativeBinding = require('./dist/osx/steamworksjs.darwin-arm64.node')
+    }
+} else {
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+let runCallbacksInterval = undefined
+
+/**
+ * Initialize the steam client or throw an error if it fails
+ * @param {number} [appId] - App ID of the game to load, if undefined, will search for a steam_appid.txt file
+ * @returns {Omit<Client, 'init' | 'runCallbacks'>}
+*/
+module.exports.init = (appId) => {
+    const { init: internalInit, runCallbacks, restartAppIfNecessary, ...api } = nativeBinding
+
+    internalInit(appId)
+
+    clearInterval(runCallbacksInterval)
+    runCallbacksInterval = setInterval(runCallbacks, 1000 / 30)
+
+    return api
+}
+
+/**
+ * @param {number} appId - App ID of the game to load
+ * {@link https://partner.steamgames.com/doc/api/steam_api#SteamAPI_RestartAppIfNecessary}
+ * @returns {boolean} 
+ */
+module.exports.restartAppIfNecessary = (appId) => nativeBinding.restartAppIfNecessary(appId);
+
+/**
+ * Enable the steam overlay on electron
+ * @param {boolean} [disableEachFrameInvalidation] - Should attach a single pixel to be rendered each frame
+*/
+module.exports.electronEnableSteamOverlay = (disableEachFrameInvalidation) => {
+    const electron = require('electron')
+    if (!electron) {
+        throw new Error('Electron module not found')
+    }
+
+    electron.app.commandLine.appendSwitch('in-process-gpu')
+    electron.app.commandLine.appendSwitch('disable-direct-composition')
+
+    if (!disableEachFrameInvalidation) {
+        /** @param {electron.BrowserWindow} browserWindow */
+        const attachFrameInvalidator = (browserWindow) => {
+            browserWindow.steamworksRepaintInterval = setInterval(() => {
+                if (browserWindow.isDestroyed()) {
+                    clearInterval(browserWindow.steamworksRepaintInterval)
+                } else if (!browserWindow.webContents.isPainting()) {
+                    browserWindow.webContents.invalidate()
+                }
+            }, 1000 / 60)
+        }
+
+        electron.BrowserWindow.getAllWindows().forEach(attachFrameInvalidator)
+        electron.app.on('browser-window-created', (_, bw) => attachFrameInvalidator(bw))
+    }
+}
+
+const SteamCallback = nativeBinding.callback.SteamCallback
+module.exports.SteamCallback = SteamCallback

package/package.json

@@ -0,0 +1,49 @@
+{
+    "name": "@dsh0416/steamworks.js",
+    "version": "0.4.1",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "napi": {
+        "binaryName": "steamworksjs",
+        "targets": [
+            "x86_64-pc-windows-msvc",
+            "x86_64-unknown-linux-gnu",
+            "x86_64-apple-darwin",
+            "aarch64-apple-darwin"
+        ]
+    },
+    "files": [
+        "dist/*",
+        "index.js",
+        "*.d.ts",
+        "README.md"
+    ],
+    "license": "MIT",
+    "devDependencies": {
+        "@napi-rs/cli": "^3.7.0",
+        "electron": "^42.3.3",
+        "rimraf": "^6.1.3",
+        "typescript": "^6.0.3"
+    },
+    "dependencies": {
+        "@types/node": "^25.9.1"
+    },
+    "engines": {
+        "node": ">= 14"
+    },
+    "scripts": {
+        "build": "npm run types && node build --release",
+        "build:debug": "node build",
+        "prune": "rimraf dist target client.d.ts",
+        "format": "cargo clippy --fix --allow-staged && cargo fmt",
+        "types": "tsc index.js --allowJs --declaration --emitDeclarationOnly"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/dsh0416/steamworks.js"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org"
+    }
+}