universo-platform-2d

1
import { spawn } from 'node:child_process';
2
import { existsSync } from 'node:fs';
3
import { join } from 'node:path';
4

5
import * as p from '@clack/prompts';
6
import { config } from 'dotenv';
7
import webpack from 'webpack';
8
import WebpackDevServer from 'webpack-dev-server';
9

10
import { getCwdFromDistribution, projectRoot } from '../config/cwd.cjs';
11
import type { BuildFlags } from '../config/index.js';
12
import { createWebpackConfig } from '../webpack/webpack.config.js';
13

14
const flags: BuildFlags = {
15
  distribution:
16
    (process.env.DISTRIBUTION as BuildFlags['distribution']) ?? 'web',
17
  mode: 'development',
18
  static: false,
19
  channel: 'canary',
20
  coverage: process.env.COVERAGE === 'true',
21
};
22

23
const files = ['.env', '.env.local'];
24

25
for (const file of files) {
26
  if (existsSync(join(projectRoot, file))) {
27
    config({
28
      path: join(projectRoot, file),
29
    });
30
    console.log(`${file} loaded`);
31
    break;
32
  }
33
}
34

35
const buildFlags = process.argv.includes('--static')
36
  ? { ...flags, static: true }
37
  : ((await p.group(
38
      {
39
        distribution: () =>
40
          p.select({
41
            message: 'Distribution',
42
            options: [
43
              {
44
                value: 'web',
45
              },
46
              {
47
                value: 'desktop',
48
              },
49
              {
50
                value: 'admin',
51
              },
52
              {
53
                value: 'mobile',
54
              },
55
            ],
56
            initialValue: 'web',
57
          }),
58
        mode: () =>
59
          p.select({
60
            message: 'Mode',
61
            options: [
62
              {
63
                value: 'development',
64
              },
65
              {
66
                value: 'production',
67
              },
68
            ],
69
            initialValue: 'development',
70
          }),
71
        channel: () =>
72
          p.select({
73
            message: 'Channel',
74
            options: [
75
              {
76
                value: 'canary',
77
              },
78
              {
79
                value: 'beta',
80
              },
81
              {
82
                value: 'stable',
83
              },
84
            ],
85
            initialValue: 'canary',
86
          }),
87
        coverage: () =>
88
          p.confirm({
89
            message: 'Enable coverage',
90
            initialValue: process.env.COVERAGE === 'true',
91
          }),
92
      },
93
      {
94
        onCancel: () => {
95
          p.cancel('Operation cancelled.');
96
          process.exit(0);
97
        },
98
      }
99
    )) as BuildFlags);
100

101
flags.distribution = buildFlags.distribution;
102
flags.mode = buildFlags.mode;
103
flags.channel = buildFlags.channel;
104
flags.coverage = buildFlags.coverage;
105
flags.static = buildFlags.static;
106
flags.entry = undefined;
107

108
const cwd = getCwdFromDistribution(flags.distribution);
109

110
process.env.DISTRIBUTION = flags.distribution;
111

112
if (flags.distribution === 'desktop') {
113
  flags.entry = {
114
    app: join(cwd, 'index.tsx'),
115
    shell: join(cwd, 'shell/index.tsx'),
116
  };
117
}
118

119
console.info(flags);
120

121
if (!flags.static) {
122
  spawn('yarn', ['workspace', '@affine/i18n', 'dev'], {
123
    stdio: 'inherit',
124
    shell: true,
125
  });
126
}
127

128
try {
129
  // @ts-expect-error no types
130
  await import('@affine/templates/build-edgeless');
131
  const config = createWebpackConfig(cwd, flags);
132
  if (flags.static) {
133
    config.watch = false;
134
  }
135
  const compiler = webpack(config);
136
  // Start webpack
137
  const devServer = new WebpackDevServer(config.devServer, compiler);
138

139
  await devServer.start();
140
} catch (error) {
141
  console.error('Error during build:', error);
142
  process.exit(1);
143
}
144