📦 darrachequesne / synceddb

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123import { promises as fsp } from 'fs';
import { promisify } from 'util';
import { basename } from 'path';

import { terser } from 'rollup-plugin-terser';
import resolve from 'rollup-plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs';
import del from 'del';
import glob from 'glob';

import simpleTS from './lib/simple-ts';

const globP = promisify(glob);

export default async function ({ watch }) {
  await del(['build', 'tmp']);

  const builds = [];

  // Main
  builds.push({
    plugins: [simpleTS('test', { watch })],
    input: ['src/index.ts', 'src/async-iterators.ts'],
    output: [
      {
        dir: 'build/',
        format: 'esm',
        entryFileNames: '[name].js',
        chunkFileNames: '[name].js',
      },
      {
        dir: 'build/',
        format: 'cjs',
        entryFileNames: '[name].cjs',
        chunkFileNames: '[name].cjs',
      },
    ],
  });

  // Minified iife
  builds.push({
    input: 'build/index.js',
    plugins: [
      terser({
        compress: { ecma: 2019 },
      }),
    ],
    output: {
      file: 'build/umd.js',
      format: 'umd',
      esModule: false,
      name: 'idb',
    },
  });

  // Minified iife including iteration
  builds.push({
    input: './with-async-ittr.js',
    plugins: [
      terser({
        compress: { ecma: 2019 },
      }),
    ],
    output: {
      file: 'build/umd-with-async-ittr.js',
      format: 'umd',
      esModule: false,
      name: 'idb',
    },
  });

  // Tests
  if (!process.env.PRODUCTION) {
    builds.push({
      plugins: [
        simpleTS('test', { noBuild: true }),
        resolve(),
        commonjs(),
        {
          async generateBundle() {
            this.emitFile({
              type: 'asset',
              source: await fsp.readFile('test/index.html'),
              fileName: 'index.html',
            });
          },
        },
      ],
      input: [
        'test/index.ts',
        'test/main.ts',
        'test/open.ts',
        'test/iterate.ts',
      ],
      output: {
        dir: 'build/test',
        format: 'esm',
      },
    });
  }

  builds.push(
    ...(await globP('size-tests/*.js').then((paths) =>
      paths.map((path) => ({
        input: path,
        plugins: [
          terser({
            compress: { ecma: 2020 },
          }),
        ],
        output: [
          {
            file: `tmp/size-tests/${basename(path)}`,
            format: 'esm',
          },
        ],
      })),
    )),
  );

  return builds;
}