steamworks.js-timmy 0.1.1 → 0.1.3

package/dist/osx/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/dist/osx/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