fairnesscoop / permacoop

import path from 'path';

import dotenv from 'dotenv';

import resolve from '@rollup/plugin-node-resolve';

import replace from '@rollup/plugin-replace';

import alias from '@rollup/plugin-alias';

import commonjs from '@rollup/plugin-commonjs';

import json from '@rollup/plugin-json';

import svelte from 'rollup-plugin-svelte';

import babel from 'rollup-plugin-babel';

import {terser} from 'rollup-plugin-terser';

import config from 'sapper/config/rollup.js';

import pkg from './package.json';

dotenv.config();

const mode = process.env.NODE_ENV;

const dev = mode === 'development';

const legacy = !!process.env.SAPPER_LEGACY_BUILD;

const onwarn = (warning, onwarn) =>

  (warning.code === 'CIRCULAR_DEPENDENCY' &&

    /[/\\]@sapper[/\\]/.test(warning.message)) ||

  onwarn(warning);

const dedupe = (importee) =>

  importee === 'svelte' || importee.startsWith('svelte/');

const aliases = [

  { find: 'src', replacement: path.resolve(__dirname, 'src') },

  { find: 'components', replacement: path.resolve(__dirname, 'src/components') },

  { find: 'normalizer', replacement: path.resolve(__dirname, 'src/normalizer') },

  { find: 'utils', replacement: path.resolve(__dirname, 'src/utils') },

  { find: 'store', replacement: path.resolve(__dirname, 'src/store') },

  { find: 'constants', replacement: path.resolve(__dirname, 'src/constants') },

];

const environmentVariables = {

  'process.env.CLIENT_API_URL': JSON.stringify(process.env.CLIENT_API_URL),

  'process.env.CLIENT_API_URL_SSR': JSON.stringify(process.env.CLIENT_API_URL_SSR),

};

export default {

  client: {

    input: config.client.input(),

    output: config.client.output(),

    plugins: [

      replace({

        'process.browser': true,

        'process.env.NODE_ENV': JSON.stringify(mode),

        ...environmentVariables

      }),

      alias({ entries: aliases }),

      svelte({

        dev,

        hydratable: true,

        emitCss: true

      }),

      resolve({

        browser: true,

        dedupe

      }),

      json(),

      commonjs(),

      legacy &&

        babel({

          extensions: ['.js', '.mjs', '.html', '.svelte'],

          runtimeHelpers: true,

          exclude: ['node_modules/@babel/**'],

          presets: [

            [

              '@babel/preset-env',

              {

                targets: '> 0.25%, not dead'

              }

            ]

          ],

          plugins: [

            '@babel/plugin-syntax-dynamic-import',

            [

              '@babel/plugin-transform-runtime',

              {

                useESModules: true

              }

            ]

          ]

        }),

      !dev &&

        terser({

          module: true

        })

    ],

    context: 'this',

    onwarn

  },

  server: {

    input: config.server.input(),

    output: config.server.output(),

    plugins: [

      replace({

        'process.browser': false,

        'process.env.NODE_ENV': JSON.stringify(mode),

        ...environmentVariables,

      }),

      svelte({

        generate: 'ssr',

        dev

      }),

      resolve({

        dedupe

      }),

      json(),

      commonjs(),

      alias({ entries: aliases }),

    ],

    external: Object.keys(pkg.dependencies).concat(

      require('module').builtinModules ||

        Object.keys(process.binding('natives'))

    ),

    onwarn

  },

  serviceworker: {

    input: config.serviceworker.input(),

    output: config.serviceworker.output(),

    plugins: [

      resolve(),

      replace({