@pipelab/asset-electron 1.0.0-beta.0

package/template/src/handlers/steam/raw.js

@@ -0,0 +1,42 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  console.log("json", json);
+
+  await handleSteamRequest(
+    client,
+    json,
+    ws,
+    async (client, json) => {
+      const { body } = json;
+      const { args, method, namespace } = body;
+
+      const result = await client[namespace][method](...args);
+
+      // if (namespace === 'localplayer' && method === 'getSteamId') {
+      //   console.log('result', result)
+      //   // handle bigint to string
+      //   /**
+      //    * @type {{
+      //     steamId64: bigint,
+      //     steamId32: string,
+      //     accountId: number
+      //   }}
+      //    */
+      //   result = {
+      //     steamId64: result.steamId64.toString(),
+      //     steamId32: result.steamId32,
+      //     accountId: result.accountId
+      //   }
+      // }
+
+      return result;
+    },
+    true,
+  );
+};

package/template/src/handlers/steam/saveScreenshot.js

@@ -0,0 +1,66 @@
+import { handleSteamRequest } from "./utils.js";
+import { writeFileSync, unlinkSync, mkdirSync, rmdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+/**
+ * Save screenshot from base64 data URL to Steam library
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {Object} json
+ * @returns {Promise<number>} The screenshot handle
+ */
+const saveScreenshotHandler = async (client, json) => {
+  const { body } = json;
+  const { dataUrl, width, height } = body;
+
+  // Validate input
+  if (!dataUrl || typeof dataUrl !== "string") {
+    throw new Error("dataUrl is required and must be a string");
+  }
+
+  if (!dataUrl.startsWith("data:image/")) {
+    throw new Error("dataUrl must be a base64 data URL (data:image/...)");
+  }
+
+  // Extract base64 data
+  const matches = dataUrl.match(/^data:image\/(\w+);base64,(.+)$/);
+  if (!matches) {
+    throw new Error("Invalid base64 data URL format");
+  }
+
+  const [, format, base64Data] = matches;
+  const buffer = Buffer.from(base64Data, "base64");
+
+  // Create temp file
+  const tempDir = join(tmpdir(), "pipelab-screenshots");
+  mkdirSync(tempDir, { recursive: true });
+  const tempPath = join(tempDir, `screenshot-${randomUUID()}.${format}`);
+
+  // Write to temp file
+  writeFileSync(tempPath, buffer);
+
+  // Add to Steam library
+  const handle = client.screenshots.addScreenshotToLibrary(tempPath, null, width, height);
+
+  // Delete temp file after a delay to allow Steam to process it
+  setTimeout(() => {
+    try {
+      unlinkSync(tempPath);
+      rmdirSync(tempDir);
+    } catch {
+      // Ignore cleanup errors
+    }
+  }, 5000);
+
+  return handle;
+};
+
+/**
+ * @param {Object} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, saveScreenshotHandler);
+};

package/template/src/handlers/steam/state.js

@@ -0,0 +1,26 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop state logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The state result
+ */
+const stateHandler = async (client, json) => {
+  const { itemId } = json.body;
+
+  const itemIdBigInt = BigInt(itemId);
+
+  const result = client.workshop.state(itemIdBigInt);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, stateHandler);
+};

package/template/src/handlers/steam/subscribe.js

@@ -0,0 +1,26 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop subscribe logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The subscribe result
+ */
+const subscribeHandler = async (client, json) => {
+  const { itemId } = json.body;
+
+  const itemIdBigInt = BigInt(itemId);
+
+  const result = await client.workshop.subscribe(itemIdBigInt);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, subscribeHandler);
+};

package/template/src/handlers/steam/unsubscribe.js

@@ -0,0 +1,26 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop unsubscribe logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The unsubscribe result
+ */
+const unsubscribeHandler = async (client, json) => {
+  const { itemId } = json.body;
+
+  const itemIdBigInt = BigInt(itemId);
+
+  const result = await client.workshop.unsubscribe(itemIdBigInt);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, unsubscribeHandler);
+};

package/template/src/handlers/steam/updateItem.js

@@ -0,0 +1,26 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam workshop update item logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The update result
+ */
+const updateItemHandler = async (client, json) => {
+  const { itemId, updateDetails, appID } = json.body;
+
+  const itemIdBigInt = BigInt(itemId);
+
+  const result = await client.workshop.updateItem(itemIdBigInt, updateDetails, appID);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, updateItemHandler);
+};

package/template/src/handlers/steam/uploadScore.js

@@ -0,0 +1,27 @@
+import { handleSteamRequest } from "./utils.js";
+
+/**
+ * Core Steam leaderboard upload logic
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @returns {Promise<any>} The upload result
+ */
+const uploadScoreHandler = async (client, json) => {
+  const { body } = json;
+  const { name, score, type, metadata } = body;
+
+  const leaderboard = await client.leaderboards.findLeaderboard(name);
+
+  const result = await client.leaderboards.uploadScore(leaderboard, score, type, metadata);
+
+  return result;
+};
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').SteamRaw, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {Omit<import('@pipelab/steamworks.js').Client, "init" | "runCallbacks">} client
+ */
+export default async (json, ws, client) => {
+  await handleSteamRequest(client, json, ws, uploadScoreHandler);
+};

package/template/src/handlers/steam/utils.js

@@ -0,0 +1,78 @@
+/**
+ * Checks if the Steam client is available and properly initialized
+ * @param {Object} client - The Steam client instance to check
+ * @returns {Object|null} Returns an error object if client is not available, null if available
+ */
+function checkSteamClient(client) {
+  if (client === undefined || client === null) {
+    return {
+      success: false,
+      error: "Steam client is not initialized or available",
+    };
+  }
+
+  return null;
+}
+
+/**
+ * Enhanced Steam request handler that combines client validation with response formatting
+ * @param {import('@pipelab/steamworks.js').Client} client - The Steam client instance
+ * @param {Object} json - The JSON request object containing url, correlationId, and body
+ * @param {import('ws').WebSocket} ws - The WebSocket connection
+ * @param {Function} handlerFunction - The handler function to execute if client is valid
+ * @param {boolean} useRawErrorFormat - Whether to use raw error format (default: false)
+ * @returns {Promise<void>} A promise that resolves when the request is handled
+ */
+function handleSteamRequest(client, json, ws, handlerFunction, useRawErrorFormat = false) {
+  // Check if Steam client is initialized
+  const clientError = checkSteamClient(client);
+  if (clientError) {
+    const errorResult = {
+      url: json.url,
+      correlationId: json.correlationId,
+      body: useRawErrorFormat
+        ? {
+            data: null,
+            success: false,
+            error: clientError.error,
+          }
+        : clientError,
+    };
+    ws.send(JSON.stringify(errorResult));
+    return Promise.resolve();
+  }
+
+  // Execute the handler function and format the response
+  return Promise.resolve(handlerFunction(client, json))
+    .then((result) => {
+      const steamResult = {
+        url: json.url,
+        correlationId: json.correlationId,
+        body: {
+          data: result,
+          success: true,
+        },
+      };
+      ws.send(JSON.stringify(steamResult, (_, v) => (typeof v === "bigint" ? v.toString() : v)));
+    })
+    .catch((error) => {
+      console.error("Error in Steam handler:", error);
+      const errorResult = {
+        url: json.url,
+        correlationId: json.correlationId,
+        body: useRawErrorFormat
+          ? {
+              data: null,
+              success: false,
+              error: error.message || "Unknown error occurred",
+            }
+          : {
+              success: false,
+              error: error.message || "Unknown error occurred",
+            },
+      };
+      ws.send(JSON.stringify(errorResult));
+    });
+}
+
+export { checkSteamClient, handleSteamRequest };

package/template/src/handlers/user/folder.js

@@ -0,0 +1,71 @@
+// @ts-check
+
+import { app } from "electron";
+import { join } from "path";
+
+import slash from "slash";
+import { getAppName } from "../../utils.js";
+
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessagePaths, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {ElectronAppConfig.Config} config
+ */
+export default (json, ws, config) => {
+  try {
+    const name = json.body.name;
+
+    let folder;
+
+    const { env } = process;
+    //      windows       linux
+    const { APPDATA, LOCALAPPDATA, XDG_DATA_HOME, XDG_CONFIG_HOME } = env;
+    const appDataBackup = app.getPath("appData");
+    const localAppData = LOCALAPPDATA ?? XDG_DATA_HOME ?? appDataBackup;
+    const appData = APPDATA ?? XDG_CONFIG_HOME ?? appDataBackup;
+
+    const appNameFolder = getAppName(config);
+
+    const localUserData = join(localAppData, appNameFolder);
+    const userData = join(appData, appNameFolder);
+
+    if (name === "app") {
+      folder = app.getAppPath();
+    } else if (name === "project") {
+      folder = join(app.getAppPath(), "src", "app"); // path to construct files
+    } else if (name === "localAppData") {
+      folder = localAppData;
+    } else if (name === "localUserData") {
+      folder = localUserData;
+    } else if (name === "userData") {
+      folder = userData;
+    } else {
+      folder = app.getPath(name);
+    }
+
+    /**
+     * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessagePaths, 'output'>}
+     */
+    const userFolderResult = {
+      url: json.url,
+      correlationId: json.correlationId,
+      body: {
+        data: slash(folder),
+      },
+    };
+    ws.send(JSON.stringify(userFolderResult));
+  } catch (e) {
+    console.error("e", e);
+    /**
+     * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessagePaths, 'output'>}
+     */
+    const userFolderResult = {
+      url: json.url,
+      correlationId: json.correlationId,
+      body: {
+        error: e.message,
+      },
+    };
+    ws.send(JSON.stringify(userFolderResult));
+  }
+};

package/template/src/handlers/window/maximize.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageWindowMaximize, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.maximize();
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageWindowMaximize, 'output'>}
+   */
+  const maximizeResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(maximizeResult));
+};

package/template/src/handlers/window/minimize.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageWindowMinimize, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.minimize();
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageWindowMinimize, 'output'>}
+   */
+  const minimizeResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(minimizeResult));
+};

package/template/src/handlers/window/request-attention.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageRequestAttention, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.flashFrame(true);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageRequestAttention, 'output'>}
+   */
+  const requestAttentionResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(requestAttentionResult));
+};

package/template/src/handlers/window/restore.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageWindowRestore, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.restore();
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageWindowRestore, 'output'>}
+   */
+  const restoreResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(restoreResult));
+};

package/template/src/handlers/window/set-always-on-top.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetAlwaysOnTop, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.setAlwaysOnTop(true);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetAlwaysOnTop, 'output'>}
+   */
+  const setAlwaysOnTopResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(setAlwaysOnTopResult));
+};

package/template/src/handlers/window/set-fullscreen.js

@@ -0,0 +1,26 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetFullscreen, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  if (json.body.value === "fullscreen") {
+    mainWindow.setFullScreen(true);
+  } else if (json.body.value === "normal") {
+    mainWindow.setFullScreen(false);
+  } else {
+    throw new Error("Unsupported value ");
+  }
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetFullscreen, 'output'>}
+   */
+  const showsetFullscreenResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(showsetFullscreenResult));
+};

package/template/src/handlers/window/set-height.js

@@ -0,0 +1,21 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetHeight, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  const [width] = mainWindow.getSize();
+  mainWindow.setSize(width, json.body.value);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetHeight, 'output'>}
+   */
+  const setHeightResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(setHeightResult));
+};

package/template/src/handlers/window/set-ignore-mouse-events.js

@@ -0,0 +1,36 @@
+/**
+ * @param {Object} json
+ * @param {string} json.correlationId
+ * @param {string} json.url
+ * @param {{ ignore: boolean, forward?: boolean }} json.body
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+<<<<<<< HEAD:assets/electron/template/app/src/handlers/window/set-ignore-mouse-events.js
+  const { ignore, forward } = json.body
+
+  mainWindow.setIgnoreMouseEvents(ignore, { forward })
+=======
+  const { ignore, forward } = json.body;
+
+  mainWindow.setIgnoreMouseEvents(ignore, { forward });
+>>>>>>> origin/feature/monorepo:assets/asset-electron/template/src/handlers/window/set-ignore-mouse-events.js
+
+  const result = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+<<<<<<< HEAD:assets/electron/template/app/src/handlers/window/set-ignore-mouse-events.js
+      success: true
+    }
+  }
+  ws.send(JSON.stringify(result))
+}
+=======
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(result));
+};
+>>>>>>> origin/feature/monorepo:assets/asset-electron/template/src/handlers/window/set-ignore-mouse-events.js

package/template/src/handlers/window/set-maximum-size.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetMaximumSize, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.setMaximumSize(json.body.width, json.body.height);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetMaximumSize, 'output'>}
+   */
+  const setMaximumSizeResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(setMaximumSizeResult));
+};

package/template/src/handlers/window/set-minimum-size.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetMinimumSize, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.setMinimumSize(json.body.width, json.body.height);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetMinimumSize, 'output'>}
+   */
+  const setMinimumSizeResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(setMinimumSizeResult));
+};

package/template/src/handlers/window/set-resizable.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetResizable, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.setResizable(true);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetResizable, 'output'>}
+   */
+  const setResizableResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(setResizableResult));
+};

package/template/src/handlers/window/set-title.js

@@ -0,0 +1,20 @@
+/**
+ * @param {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetTitle, 'input'>} json
+ * @param {import('ws').WebSocket} ws
+ * @param {import('electron').BrowserWindow} mainWindow
+ */
+export default async (json, ws, mainWindow) => {
+  mainWindow.setTitle(json.body.value);
+
+  /**
+   * @type {import('@pipelab/core').MakeInputOutput<import('@pipelab/core').MessageSetTitle, 'output'>}
+   */
+  const setTitleResult = {
+    correlationId: json.correlationId,
+    url: json.url,
+    body: {
+      success: true,
+    },
+  };
+  ws.send(JSON.stringify(setTitleResult));
+};