📝 [docs] Add comprehensive Electron-Log and Electron-Updater docs

- Introduces detailed documentation for Electron-Log, covering error handling, event logging, extending functionality, initialization in renderer, migration between major versions, and all transport options and formats
- Adds full Electron-Updater documentation, including setup, configuration, events, staged rollouts, compatibility, and advanced usage patterns
- Aims to improve developer onboarding and clarify best practices for logging and auto-update workflows in Electron apps

Author: Nick2bad4u

docs/Packages/Electron-Log/errors.md

@@ -0,0 +1,83 @@
+# Catching errors
+
+electron-log can be used to collect all unhandled errors/rejections
+
+To initialize catching, call the `log.errorHandler.startCatching` method. It
+should be done in both main and renderer processes if you want to collect logs
+on both sides.
+
+#### `log.errorHandler.startCatching(options?)`
+
+Start catching
+
+#### `log.errorHandler.stopCatching()`
+
+Stop error catching
+
+#### `log.errorHandler.handle(error, options?)`
+
+Process an error. Works even if catching isn't started.
+
+## Options
+
+#### `showDialog` {boolean}
+
+Default: `true` 
+
+It follows Electron logic for error handling, so the dialog is
+shown only when error is thrown in the main process. Errors from a renderer
+process and any rejected promises are ignored. Settings it to false disables
+error dialog for any error.
+   
+#### `onError({ createIssue, error, processType, versions }) => void | false`
+   
+Default: `null`
+
+Attach a custom error handler. If the handler returns false, this error will
+not be processed. In a renderer process only the `error` property available.
+
+`createIssue(url, queryParams)` Open the url with query params appended in a
+browser
+
+`error: Error` - handled error
+
+`processType: 'browser' | 'renderer`
+
+`version: { app: string, electron: string, os: string }` - Version information
+which could be useful for an error report
+
+
+   
+## Github issue example   
+   
+```js
+log.errorHandler.startCatching({
+  showDialog: false,
+  onError({ createIssue, error, processType, versions }) {
+    if (processType === 'renderer') {
+      return;
+    }
+    
+    electron.dialog.showMessageBox({
+      title: 'An error occurred',
+      message: error.message,
+      detail: error.stack,
+      type: 'error',
+      buttons: ['Ignore', 'Report', 'Exit'],
+    })
+      .then((result) => {
+        if (result.response === 1) {
+          createIssue('https://github.com/my-acc/my-app/issues/new', {
+            title: `Error report for ${versions.app}`,
+            body: 'Error:\n```' + error.stack + '\n```\n' + `OS: ${versions.os}`
+          });
+          return;
+        }
+      
+        if (result.response === 2) {
+          electron.app.quit();
+        }
+      });
+  }
+});
+```

docs/Packages/Electron-Log/events.md

@@ -0,0 +1,95 @@
+# Save electron events
+
+Sometimes it's helpful to save critical electron events to the log file.
+
+`log.eventLogger.startLogging(options?)`;
+
+By default, it saves the following events:
+- `certificate-error`, `child-process-gone`, `render-process-gone` of `app`
+- `crashed`, `gpu-process-crashed` of `webContents`
+- `did-fail-load`, `did-fail-provisional-load`, `plugin-crashed`,
+  `preload-error` of every WebContents. You can switch any event on/off.
+
+## Methods
+
+#### `log.eventLogger.startLogging(options?: EventLoggerOptions)`
+
+Start saving event logs.
+
+#### `log.eventLogger.stopLogging()`
+
+Stop saving logs.
+
+#### `log.eventLogger.setOptions(options: EventLoggerOptions)`
+
+Set logging options.
+
+## Options
+
+#### `log.eventLogger.format` {string | (input: EventFormatterInput) => any[]}
+
+Default: `'{eventSource}#{eventName}:'`
+
+Custom format function example:
+
+```js
+log.eventLogger.format = ({ args, event, eventName, eventSource }) => {
+  return [`${eventSource}#${eventName}:`, JSON.stringify(args)];
+};
+```
+
+#### `log.eventLogger.formatters` {object}
+
+A set of functions which formats a specific event.
+
+```js
+log.eventLogger.formatters.webContents['console-message'] = ({
+  args: [level, message, line, sourceId],
+  event,
+  eventName,
+  eventSource
+}) => {
+  const webContents = event.sender;
+
+  if (level > 2) {
+    return undefined;
+  }
+
+  return { message, source: `${sourceId}:${line}`, url: webContents?.getURL() };
+};
+```
+
+#### `log.eventLogger.events` {object}
+
+Allow switching specific events on/off easily
+
+Default:
+
+```js
+log.eventLogger.events = {
+  app: {
+    'certificate-error': true,
+    'child-process-gone': true,
+    'render-process-gone': true,
+  },
+  webContents: {
+    'did-fail-load': true,
+    'did-fail-provisional-load': true,
+    'plugin-crashed': true,
+    'preload-error': true,
+    'unresponsive': true,
+  }
+}
+```
+
+#### `log.eventLogger.level` {LogLevel}
+
+Which log level is used for logging
+
+Default: `'warn'`
+
+#### `log.eventLogger.scope` {LogLevel}
+
+Which log scope is used for logging
+
+Default: `''`

docs/Packages/Electron-Log/extend.md

@@ -0,0 +1,118 @@
+# Extending electron-log
+
+Each process in Electron has its own electron-log instance, so make sure you 
+define a custom transport or hook in each process. It's a good idea to save 
+such a code in a separated file and require it from inside each process.
+
+## Transport
+
+Transport is just a function `(msg: LogMessage) => void`, so you can override 
+it or add your own transport.
+
+```js
+import util from 'util';
+
+log.transports.console = (message) => {
+  const text = util.format.apply(util, message.data);
+  console.log(`[${message.date.toLocaleTimeString()} ${message.level}] ${text}`);
+};
+```
+
+Please be aware, if you override a transport function, the default
+transport options (like level or format) will be undefined.
+
+### Transforms
+
+Each transport has a `transform` option which is an array of functions. Before
+doing some work, a log message is passed through each transform function to 
+format `data` before processing.
+
+A transform has the following interface:
+
+```typescript
+({ data, message, logger, transport }) => any;
+```
+
+It returns a message `data` property with some transformations applied.
+
+Example of adding a custom transform function
+
+```js
+log.transports.file.transforms.push(({ data, logger, message, transport }) => {
+  if (data.join().includes('paynment')) {
+    return ['[PAYNMENT]', ...data];
+  }
+  
+  return data;
+});
+```
+
+## Hooks
+
+In some situations, you may want to get more control over logging. Hook
+is a function called on each transport call.
+
+`(msg: LogMessage, transport: Transport) => LogMessage`
+
+Hook function return original or modified message. If the hook function
+returns false, the current transport will be skipped.
+
+In this example, the file transport is disabled for all messages that contain 
+'password' phrase, and hides token text:
+
+```js
+log.hooks.push((message, transport, transportName) => {
+  if (transportName !== 'file') {
+    return message;
+  }
+
+  if (message.data.join().includes('password')) {
+    return false;
+  }
+  
+  if (message.data.join().includes('token')) {
+    return {
+      ...message,
+       data: message.data.slice(0, 2),
+    };
+  }
+
+  return message;
+});
+```
+
+## Log levels
+
+Add a new "notice" level before "info" (index = 2):
+
+```js
+log.addLevel('notice', 2);
+log.notice('New level added');
+```
+
+Also, you can add TypeScript type definition:
+
+*electron-log.extend.d.ts:*
+```typescript
+import 'electron-log'
+
+declare module 'electron-log' {
+  interface LogFunctions {
+    notice(...params: any[]): void;
+  }
+}
+
+```
+
+## LogMessage
+
+ - data: any[] Arguments passed to log function
+ - date: Date
+ - level: 'error' | 'warn' | 'info' | 'verbose' | 'debug' | 'silly'
+ - logId: string
+ - scope: string | undefined
+ - variables?: { [name: string]: any } When a log message is created,
+   values from `log.variables` are set as `message.variables` (to make it 
+ - possible to pass these Variables between main and renderer processes)
+   
+See more details in [the type definition](../src/index.d.ts#L41)