@pipelab/steamworks.js 0.7.3

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,115 @@
+# steamworks.js (Community Fork)
+
+> **Note**: This is an actively maintained community fork of [steamworks.js](https://github.com/CynToolkit/steamworks.js).
+> We're keeping the project active by reviewing and merging pending PRs and addressing issues.
+
+## Why This Fork?
+
+- ✅ Actively reviewing and merging PRs
+- ✅ Regular updates and bug fixes
+- ✅ Community-driven development
+- ✅ NW.js support improvements
+- ✅ Incorporating pending PRs from upstream
+
+## Installation
+
+```bash
+# npm - use our scoped package
+npm install @mikaldev/steamworks.js
+
+# Or reference directly from GitHub
+npm install github:MikalDev/steamworks.js
+
+# For Electron/NW.js projects
+npm install github:MikalDev/steamworks.js --runtime=electron --target=27.0.0
+npm install github:MikalDev/steamworks.js --runtime=node-webkit --target=0.75.0
+
+
+[![Build Status](https://github.com/CynToolkit/steamworks.js/actions/workflows/publish.yml/badge.svg)](https://github.com/CynToolkit/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/CynToolkit/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/CynToolkit/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,519 @@
+export declare function init(appId?: number | undefined | null): void
+export declare function restartAppIfNecessary(appId: number): boolean
+export declare function runCallbacks(): void
+export interface PlayerSteamId {
+  steamId64: bigint
+  steamId32: string
+  accountId: number
+}
+export declare namespace achievement {
+  export function activate(achievement: string): boolean
+  export function isActivated(achievement: string): boolean
+  export function clear(achievement: string): boolean
+  export function names(): Array<string>
+}
+export declare namespace apps {
+  export function isSubscribedApp(appId: number): boolean
+  export function isAppInstalled(appId: number): boolean
+  export function isDlcInstalled(appId: number): boolean
+  export function isSubscribedFromFreeWeekend(): boolean
+  export function isVacBanned(): boolean
+  export function isCybercafe(): boolean
+  export function isLowViolence(): boolean
+  export function isSubscribed(): boolean
+  export function appBuildId(): number
+  export function appInstallDir(appId: number): string
+  export function appOwner(): PlayerSteamId
+  export function availableGameLanguages(): Array<string>
+  export function currentGameLanguage(): string
+  export function currentBetaName(): string | null
+}
+export declare namespace auth {
+  /**
+   * @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>
+  /**
+   * @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>
+  export function getAuthTicketForWebApi(identity: string, timeoutSeconds?: number | undefined | null): Promise<Ticket>
+  export class Ticket {
+    cancel(): void
+    getBytes(): Buffer
+  }
+}
+export declare namespace callback {
+  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 function register<C extends keyof import('./callbacks').CallbackReturns>(steamCallback: C, handler: (value: import('./callbacks').CallbackReturns[C]) => void): Handle
+  export class Handle {
+    disconnect(): void
+  }
+}
+export declare namespace cloud {
+  export function isEnabledForAccount(): boolean
+  export function isEnabledForApp(): boolean
+  export function setEnabledForApp(enabled: boolean): void
+  export function readFile(name: string): string
+  export function writeFile(name: string, content: string): boolean
+  export function deleteFile(name: string): boolean
+  export function fileExists(name: string): boolean
+  export function listFiles(): Array<FileInfo>
+  export class FileInfo {
+    name: string
+    size: bigint
+  }
+}
+export declare namespace friends {
+  export function getFriendName(steamId64: bigint): string
+}
+export declare namespace input {
+  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 interface AnalogActionVector {
+    x: number
+    y: number
+  }
+  export function init(): void
+  export function getControllers(): Array<Controller>
+  export function getActionSet(actionSetName: string): bigint
+  export function getDigitalAction(actionName: string): bigint
+  export function getAnalogAction(actionName: string): bigint
+  export function shutdown(): void
+  export class Controller {
+    activateActionSet(actionSetHandle: bigint): void
+    isDigitalActionPressed(actionHandle: bigint): boolean
+    getAnalogActionVector(actionHandle: bigint): AnalogActionVector
+    getType(): InputType
+    getHandle(): bigint
+  }
+}
+export declare namespace leaderboards {
+  export interface LeaderboardEntry {
+    globalRank: number
+    score: number
+    steamId: bigint
+    details: Array<number>
+  }
+  export const enum SortMethod {
+    Ascending = 0,
+    Descending = 1
+  }
+  export const enum DisplayType {
+    Numeric = 0,
+    TimeSeconds = 1,
+    TimeMilliSeconds = 2
+  }
+  export const enum DataRequest {
+    Global = 0,
+    GlobalAroundUser = 1,
+    Friends = 2
+  }
+  export const enum UploadScoreMethod {
+    KeepBest = 0,
+    ForceUpdate = 1
+  }
+  export function findLeaderboard(name: string): Promise<string | null>
+  export function findOrCreateLeaderboard(name: string, sortMethod: SortMethod, displayType: DisplayType): Promise<string | null>
+  export function uploadScore(leaderboardName: string, score: number, uploadMethod: UploadScoreMethod, details?: Array<number> | undefined | null): Promise<LeaderboardEntry | null>
+  export function downloadScores(leaderboardName: string, dataRequest: DataRequest, rangeStart: number, rangeEnd: number): Promise<Array<LeaderboardEntry>>
+  export function getLeaderboardName(leaderboardName: string): string | null
+  export function getLeaderboardEntryCount(leaderboardName: string): number | null
+  export function getLeaderboardSortMethod(leaderboardName: string): SortMethod | null
+  export function getLeaderboardDisplayType(leaderboardName: string): DisplayType | null
+  export function clearLeaderboardHandle(leaderboardName: string): boolean
+  export function getCachedLeaderboardNames(): Array<string>
+}
+export declare namespace localplayer {
+  export function getSteamId(): PlayerSteamId
+  export function getName(): string
+  export function getLevel(): number
+  /** @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 setRichPresence(key: string, value?: string | undefined | null): void
+}
+export declare namespace matchmaking {
+  export const enum LobbyType {
+    Private = 0,
+    FriendsOnly = 1,
+    Public = 2,
+    Invisible = 3
+  }
+  export function createLobby(lobbyType: LobbyType, maxMembers: number): Promise<Lobby>
+  export function joinLobby(lobbyId: bigint): Promise<Lobby>
+  export function getLobbies(): Promise<Array<Lobby>>
+  export class Lobby {
+    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 declare namespace networking {
+  export interface P2PPacket {
+    data: Buffer
+    size: number
+    steamId: PlayerSteamId
+  }
+  /** 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 function sendP2PPacket(steamId64: bigint, sendType: SendType, data: Buffer): boolean
+  export function sendP2PPacketOnChannel(steamId64: bigint, sendType: SendType, data: Buffer, channel: number): boolean
+  export function isP2PPacketAvailable(): number
+  export function isP2PPacketAvailableOnChannel(channel: number): number
+  export function readP2PPacket(size: number): P2PPacket
+  export function readP2PPacketFromChannel(size: number, channel: number): P2PPacket
+  export function acceptP2PSession(steamId64: bigint): void
+}
+export declare namespace networking_messages {
+  export interface Message {
+    data: Buffer
+    steamId?: PlayerSteamId
+  }
+  export function sendMessageToUser(steamId64: bigint, data: Buffer): void
+  export function receiveMessagesOnChannel(): Array<Message>
+}
+export declare namespace overlay {
+  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 function activateDialog(dialog: Dialog): void
+  export function activateDialogToUser(dialog: Dialog, steamId64: bigint): void
+  export function activateInviteDialog(lobbyId: bigint): void
+  export function activateToWebPage(url: string): void
+  export function activateToStore(appId: number, flag: StoreFlag): void
+}
+export declare namespace stats {
+  export function getInt(name: string): number | null
+  export function setInt(name: string, value: number): boolean
+  export function store(): boolean
+  export function resetAll(achievementsToo: boolean): boolean
+}
+export declare namespace utils {
+  export function getAppId(): number
+  export function getServerRealTime(): number
+  export function isSteamRunningOnSteamDeck(): boolean
+  export const enum GamepadTextInputMode {
+    Normal = 0,
+    Password = 1
+  }
+  export const enum GamepadTextInputLineMode {
+    SingleLine = 0,
+    MultipleLines = 1
+  }
+  /** @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 const enum FloatingGamepadTextInputMode {
+    SingleLine = 0,
+    MultipleLines = 1,
+    Email = 2,
+    Numeric = 3
+  }
+  /** @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>
+}
+export declare namespace workshop {
+  export interface UgcResult {
+    itemId: bigint
+    needsToAcceptAgreement: boolean
+  }
+  export const enum UgcItemVisibility {
+    Public = 0,
+    FriendsOnly = 1,
+    Private = 2,
+    Unlisted = 3
+  }
+  export interface UgcUpdate {
+    title?: string
+    description?: string
+    changeNote?: string
+    previewPath?: string
+    contentPath?: string
+    tags?: Array<string>
+    visibility?: UgcItemVisibility
+  }
+  export interface InstallInfo {
+    folder: string
+    sizeOnDisk: bigint
+    timestamp: number
+  }
+  export interface DownloadInfo {
+    current: bigint
+    total: bigint
+  }
+  export const enum UpdateStatus {
+    Invalid = 0,
+    PreparingConfig = 1,
+    PreparingContent = 2,
+    UploadingContent = 3,
+    UploadingPreviewFile = 4,
+    CommittingChanges = 5
+  }
+  export interface UpdateProgress {
+    status: UpdateStatus
+    progress: bigint
+    total: bigint
+  }
+  export function createItem(appId?: number | undefined | null): Promise<UgcResult>
+  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
+  /**
+   * 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>
+  /**
+   * 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>
+  /**
+   * 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
+  /**
+   * 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
+  /**
+   * 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
+  /**
+   * 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 all subscribed workshop items.
+   * @returns an array of subscribed workshop item ids
+   */
+  export function getSubscribedItems(includeLocallyDisabled: boolean): Array<bigint>
+  export function deleteItem(itemId: bigint): Promise<void>
+  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 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 const enum UserListType {
+    Published = 0,
+    VotedOn = 1,
+    VotedUp = 2,
+    VotedDown = 3,
+    Favorited = 4,
+    Subscribed = 5,
+    UsedOrPlayed = 6,
+    Followed = 7
+  }
+  export const enum UserListOrder {
+    CreationOrderAsc = 0,
+    CreationOrderDesc = 1,
+    TitleAsc = 2,
+    LastUpdatedDesc = 3,
+    SubscriptionDateDesc = 4,
+    VoteScoreDesc = 5,
+    ForModeration = 6
+  }
+  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 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 WorkshopPaginatedResult {
+    items: Array<WorkshopItem | undefined | null>
+    returnedResults: number
+    totalResults: number
+    wasCached: boolean
+  }
+  export interface WorkshopItemsResult {
+    items: Array<WorkshopItem | undefined | null>
+    wasCached: boolean
+  }
+  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 AppIDs {
+    creator?: number
+    consumer?: number
+  }
+  export function getItem(item: bigint, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopItem | null>
+  export function getItems(items: Array<bigint>, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopItemsResult>
+  export function getAllItems(page: number, queryType: UGCQueryType, itemType: UGCType, creatorAppId: number, consumerAppId: number, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopPaginatedResult>
+  export function getUserItems(page: number, accountId: number, listType: UserListType, itemType: UGCType, sortOrder: UserListOrder, appIds: AppIDs, queryConfig?: WorkshopItemQueryConfig | undefined | null): Promise<WorkshopPaginatedResult>
+}

package/index.d.ts

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

package/index.js

@@ -0,0 +1,153 @@
+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
+let steamOverlayInitialized = false
+
+/**
+ * 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))
+    }
+}
+
+module.exports.electronEnableSteamOverlay2 = (fpsLimit = 30) => {
+    if (steamOverlayInitialized) {
+        console.log('Steam overlay already initialized');
+        return;
+    }
+
+    const electron = require('electron')
+    if (!electron) {
+        throw new Error('Electron module not found')
+    }
+    const app = electron.app
+
+    // Check if app is ready
+    if (!app.isReady()) {
+        throw new Error('Electron app is not ready');
+    }
+
+    // Wrap switch appending in try-catch
+    try {
+        app.commandLine.appendSwitch('in-process-gpu');
+        app.commandLine.appendSwitch('disable-direct-composition');
+        app.commandLine.appendSwitch('disable-gpu-shader-disk-cache');
+        app.commandLine.appendSwitch('disable-http-cache');
+        app.commandLine.appendSwitch('use-angle', 'd3d11');
+        app.commandLine.appendSwitch('disable-renderer-backgrounding');
+        app.commandLine.appendSwitch('disable-background-timer-throttling');
+    } catch (error) {
+        console.error('Error appending command line switches:', error);
+        throw error;
+    }
+
+    /** @param {electron.BrowserWindow} browserWindow */
+    const attachOverlayInvalidator = (window) => {
+        // Validate window and webContents existence
+        if (!window || !window.webContents) {
+            console.error('Invalid window or webContents');
+            return;
+        }
+
+        const FPS_LIMIT = fpsLimit;
+
+        try {
+            const intervalId = setInterval(() => {
+                try {
+                    if (!window.isDestroyed() && window.isVisible()) {
+                        // Invalidation "douce" sans forcer si le compositeur est déjà occupé
+                        const { webContents } = window;
+                        if (webContents && !webContents.isPainting()) {
+                            webContents.invalidate();
+                        }
+                    }
+                } catch (error) {
+                    console.error('Error in overlay invalidator interval:', error);
+                }
+            }, 1000 / FPS_LIMIT);
+
+            window.once('closed', () => {
+                clearInterval(intervalId);
+            });
+        } catch (error) {
+            console.error('Error setting up overlay invalidator:', error);
+        }
+    };
+
+    try {
+        electron.BrowserWindow.getAllWindows().forEach(attachOverlayInvalidator)
+        electron.app.on('browser-window-created', (_, bw) => attachOverlayInvalidator(bw))
+    } catch (error) {
+        console.error('Error attaching overlay invalidator:', error);
+        throw error;
+    }
+
+    steamOverlayInitialized = true;
+}
+
+const SteamCallback = nativeBinding.callback.SteamCallback
+module.exports.SteamCallback = SteamCallback

package/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "@pipelab/steamworks.js",
+    "version": "0.7.3",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/",
+        "access": "public"
+    },
+    "napi": {
+        "name": "steamworksjs",
+        "triples": {
+            "additional": [
+                "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": "2.18.4",
+        "electron": "24.2.0",
+        "rimraf": "6.0.1",
+        "typescript": "5.5.3"
+    },
+    "dependencies": {
+        "@types/node": "*"
+    },
+    "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/CynToolkit/steamworks.js"
+    }
+}