rollup.config.node.mjs

import fs from 'fs';
import path from 'path';
import terser from '@rollup/plugin-terser';
import resolve from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';
import json from '@rollup/plugin-json';
import replace from '@rollup/plugin-replace';
import copy from 'rollup-plugin-copy';
import { getBabelOutputPlugin } from '@rollup/plugin-babel';
import gcPlugin from './scripts/rollup-gc-plugin.mjs';

// import config Babel via import ESM
import babelConfig from './babel.config.json' with { type: 'json' };
import babelNodeOutput from './babel.node-output.json' with { type: 'json' };

// determines environment
const baseResolveOpts = { browser: false, exportConditions: ['node', 'svelte'], preferBuiltins: true };

// common plugins
const replaceOpts = {
  preventAssignment: false,
  delimiters: ['', ''],
  values: {
    '__BUILD_MODE__': JSON.stringify(process.env.NODE_ENV || 'development'),
    'fs/promises")': 'fs").promises',
    "fs/promises')": "fs').promises",
    'getFilename()': '__filename',
    'getDirname()': '__dirname'
  }
}

// Check if this is a production build
const isProduction = process.env.NODE_ENV === 'production' || process.argv.includes('--production')

// Babel config import
// bundles main, preload e workers
const baseBabelOpts = babelConfig;
const nodeBabelOpts = babelNodeOutput;
const watchOpts = { buildDelay: 3000, exclude: 'node_modules/**' };
const external = [
  'electron',
  /.+\.(node|native)$/,
  /premium\./,
  'bytenode' // Must be external - modifies Node.js module system at runtime
];
const outputs = [];

// Plugin to resolve node:sqlite to a mock module (prevents external dependency warning)
function sqliteResolvePlugin() {
  return {
    name: 'sqlite-resolve',
    resolveId(source) {
      // Intercept node:sqlite and return virtual module ID
      if (source === 'node:sqlite') {
        return '\0node:sqlite'; // Virtual module ID (null-byte prefix)
      }
      return null;
    },
    load(id) {
      // Return mock module when virtual ID is loaded
      // This replaces require('node:sqlite') with a mock implementation
      if (id === '\0node:sqlite') {
        return `
// Mock module for node:sqlite (not available on Android)
class DatabaseSync {
  constructor() {}
  close() {}
  prepare() {
    return {
      run: () => {},
      get: () => null,
      all: () => []
    };
  }
}

class StatementSync {}

function openSync() {
  throw new Error('SQLite not available on Android');
}

export { DatabaseSync, StatementSync, openSync };
export default { DatabaseSync, StatementSync, openSync };
`;
      }
      return null;
    }
  };
}

// helper for Node.js bundles
function makeNodeBundle({ input, output, babelOpts, extraPlugins = [], externals = null, isLargeFile = false, isMainProcess = false }) {
  // Specific settings for main process
  const mainProcessConfig = isMainProcess ? {
    maxWorkers: 1, // Reduce workers to save memory
    keep_classnames: false, // Disable to save memory
    keep_fnames: false, // Disable to save memory
    compress: {
      drop_console: isProduction, // Remove console logs in production
      drop_debugger: true,
      passes: 1,
      unsafe: true, // More aggressive optimizations
      unsafe_comps: true,
      unsafe_math: true
    }
  } : {
    maxWorkers: 2,
    keep_classnames: true,
    keep_fnames: true,
    compress: {
      drop_console: isProduction, // Keep console logs in development
      drop_debugger: false,
      passes: 1
    }
  };

  const plugins = [
    sqliteResolvePlugin(), // Resolve node:sqlite to mock module (must be before resolve)
    resolve({
      ...baseResolveOpts,
      // Specific settings for main process
      ...(isMainProcess ? { dedupe: [] } : {})
    }),
    commonjs({ 
      sourcemap: isMainProcess ? false : true, // Disable sourcemap for main process
      dynamicRequireTargets: [
        'node_modules/node-ssdp/lib/server.js',
        'node_modules/*/lib/server.js',
        'node_modules/**/lib/server.js',
        'www/nodejs/modules/premium/modules/cast/node_modules/node-ssdp/lib/server.js',
        'www/nodejs/modules/premium/modules/cast/node_modules/node-ssdp/lib/client.js',
        'www/nodejs/modules/premium/modules/cast/node_modules/node-ssdp/lib/index.js'
      ],
      ignoreDynamicRequires: true,
      ...(isMainProcess ? { requireReturnsDefault: 'auto' } : {})
    }),
    json({ compact: true }),
    getBabelOutputPlugin({
      ...babelOpts,
      // Memory optimizations for main process
      ...(isMainProcess ? { compact: true, minified: true } : {})
    }),
    replace(replaceOpts),    
    ...extraPlugins,
    // Enable terser for production builds with BigInt-safe settings
        ...(isProduction && !isLargeFile ? [terser({
          ecma: 2020, // Use ECMAScript 2020 for better BigInt compatibility
          maxWorkers: 0, // Disable workers to prevent hanging
          keep_classnames: true, // Keep class names to avoid BigInt issues
          keep_fnames: true, // Keep function names to avoid BigInt issues
          output: { comments: false },
    compress: {
      drop_console: isProduction, // Remove console logs in production
            drop_debugger: true,
            passes: 1, // Reduce passes to avoid BigInt issues
            // ✅ ONLY essential disables for BigInt
            reduce_vars: false,     // ← Main: avoids rewriting vars with BigInt
            evaluate: false,        // ← Main: avoids evaluating BigInt expressions
            // Keep other optimizations
            unsafe: false,
            unsafe_comps: false,
            unsafe_math: false,
            unsafe_proto: false,
            unsafe_regexp: false
          }
        })] : []),
    gcPlugin() // Add GC plugin at the end to run after bundle is written
  ];
  outputs.push({
    input,
    output,
    plugins,
    external: Array.isArray(externals) ? externals : external,
    watch: watchOpts,
    maxParallelFileOps: isLargeFile || isMainProcess ? 1 : undefined, // Force 1 for main process
    treeshake: isLargeFile ? false : (isMainProcess ? {
      // Tree shaking enabled for main.js with conservative settings
      moduleSideEffects: (id) => {
        // Preserve modules that may have important side effects
        if (id.includes('analytics.js') || 
            id.includes('crashlog.js') ||
            id.includes('node-cleanup') ||
            id.includes('onexit')) {
          return true; // Preserve side effects
        }
        // For own modules, assume they may have side effects (conservative)
        if (id.includes('www/nodejs/modules/') && !id.includes('node_modules')) {
          return true; // Preserve own modules for safety
        }
        // For node_modules, try tree shaking (safer)
        return false; // Allow tree shaking in node_modules
      },
      propertyReadSideEffects: false, // Properties can be tree-shaken
      tryCatchDeoptimization: false // Don't deoptimize try-catch
    } : undefined),
    // Specific settings for main process
    ...(isMainProcess ? {
      preserveEntrySignatures: 'allow-extension',
      onwarn(warning, warn) {
        // Suppress circular dependency warnings for main process
        if (warning.code === 'CIRCULAR_DEPENDENCY') return;
        warn(warning);
      }
    } : {})
  });
}

// Node.js bundles only
makeNodeBundle({
  input: 'www/nodejs/main.mjs',
  output: { 
    format: 'cjs', 
    file: 'www/nodejs/dist/main.js', 
    inlineDynamicImports: true, 
    sourcemap: false,
    // Polyfill Web APIs for Node.js < 20
    banner: `
// Polyfill Web APIs for undici (node-fetch wrapper)
if (typeof globalThis.File === 'undefined' || typeof globalThis.Blob === 'undefined') {
  try {
    const { File: FileClass, Blob: BlobClass } = require('buffer');
    if (typeof globalThis.File === 'undefined') globalThis.File = FileClass;
    if (typeof globalThis.Blob === 'undefined') globalThis.Blob = BlobClass;
  } catch (e) {
    console.warn('Failed to apply Web API polyfills:', e.message);
  }
}
    `.trim()
  }, // Disable sourcemap for main process
  babelOpts: nodeBabelOpts,
  isMainProcess: true, // Enable main-process specific optimizations
  extraPlugins: [
    copy({ targets: [
      { src: 'node_modules/dayjs/locale/*.js', dest: 'www/nodejs/dist/dayjs-locale' },
      { src: 'node_modules/create-desktop-shortcuts/src/windows.vbs', dest: 'www/nodejs/dist' },
      { src: 'node_modules/hls.js/dist/hls.min.js', dest: 'www/nodejs/renderer/dist' },
      { src: 'node_modules/mpegts.js/dist/mpegts.js', dest: 'www/nodejs/renderer/dist' },
      { src: 'node_modules/bytenode/**/*', dest: 'www/nodejs/dist/node_modules/bytenode' },
      { src: 'node_modules/@edenware/tv-channels-by-country/channels/*.json', dest: 'www/nodejs/channels' },
    ] })
  ]
});

makeNodeBundle({
  input: 'www/nodejs/electron.mjs',
  output: { format: 'cjs', file: 'www/nodejs/dist/electron.js', inlineDynamicImports: true, sourcemap: true },
  babelOpts: nodeBabelOpts,
  externals: ['electron', /.+\.(node|native)$/]
});

[
  'preload.mjs',
  'modules/lists/updater-worker.js',
  'modules/epg/worker/EPGManager.js',
  'modules/streamer/utils/mpegts-processor-worker.js',
  'modules/multi-worker/worker.mjs'
].forEach(file => {
  const outputFile = path.basename(file).replace('.mjs','.js');
  const isLargeFile = file.includes('EPGManager.js');
  makeNodeBundle({
    input: `www/nodejs/${file}`,
    output: { format: 'cjs', file: `www/nodejs/dist/${outputFile}`, inlineDynamicImports: true, sourcemap: true },
    babelOpts: nodeBabelOpts,
    externals: ['electron', /.+\.(node|native)$/],
    isLargeFile
  });
});

if (fs.existsSync('www/nodejs/modules/premium/premium.js')) {
  makeNodeBundle({
    input: 'www/nodejs/modules/premium/premium.js',
    output: { format: 'cjs', file: 'www/nodejs/dist/premium.js', inlineDynamicImports: true, sourcemap: true },
    babelOpts: nodeBabelOpts,
    externals: ['electron', /.+\.(node|native)$/]
  });
}

export default outputs;