commit e268b4598ecb85e06e9aa674f39747e2dcc81521 · kitten.sh/wonka

+30 -14
scripts/generate-flow-files.js
···

       12
       12
        
       const { promisify } = require('util');

     

       13
       13
        
       const { compiler, beautify } = require('flowgen');

     

       14
       14
        
       

     

       15
       15
       +
       const cwd = process.cwd();

     

       15
       16
        
       const writeFile = promisify(fs.writeFile);

     

       17
       17
       +
       const readFile = promisify(fs.readFile);

     

       16
       18
        
       const preamble = '// @flow\n\n';

     

       17
       19
        
       

     

       18
       18
       -
       const gen = async () => {

     

       19
       19
       -
         const cwd = process.cwd();

     

       20
       20
       +
       const genEntry = async () => {

     

       21
       21
       +
         let entry = await readFile(path.resolve(cwd, 'index.js.flow'), { encoding: 'utf8' });

     

       20
       22
        
       

     

       21
       21
       -
         const input = await globby([

     

       22
       22
       -
           'src/*.d.ts',

     

       23
       23
       -
           'src/**/*.d.ts'

     

       24
       24
       -
         ], {

     

       23
       23
       +
         entry = entry.replace(/.\/src/g, '../src');

     

       24
       24
       +
       

     

       25
       25
       +
         const outputCJS = path.resolve(cwd, 'dist/wonka.js.flow');

     

       26
       26
       +
         const outputES = path.resolve(cwd, 'dist/wonka.es.js.flow');

     

       27
       27
       +
       

     

       28
       28
       +
         return Promise.all([

     

       29
       29
       +
           writeFile(outputCJS, entry, { encoding: 'utf8' }),

     

       30
       30
       +
           writeFile(outputES, entry, { encoding: 'utf8' })

     

       31
       31
       +
         ]);

     

       32
       32
       +
       };

     

       33
       33
       +
       

     

       34
       34
       +
       const gen = async () => {

     

       35
       35
       +
         const input = await globby(['src/*.d.ts', 'src/**/*.d.ts'], {

     

       25
       36
        
           gitignore: true

     

       26
       37
        
         });

     

       27
       38
        
       

     
···

       42
       53
        
           const filepath = path.dirname(fullpath);

     

       43
       54
        
           const newpath = path.join(filepath, basename + '.js.flow');

     

       44
       55
        
       

     

       45
       45
       -
           return writeFile(newpath, preamble + flowdef, {

     

       56
       56
       +
           // Fix incorrect imports

     

       57
       57
       +
           const fixedFlowdef = flowdef.replace(/^import \{/g, 'import type {');

     

       58
       58
       +
       

     

       59
       59
       +
           return writeFile(newpath, preamble + fixedFlowdef, {

     

       46
       60
        
             encoding: 'utf8'

     

       47
       61
        
           });

     

       48
       62
        
         });

     

       49
       63
        
       

     

       50
       50
       -
         return Promise.all(write);

     

       64
       64
       +
         return Promise.all([...write, genEntry()]);

     

       51
       65
        
       };

     

       52
       66
        
       

     

       53
       53
       -
       gen().then(() => {

     

       54
       54
       -
         process.exit(0);

     

       55
       55
       -
       }).catch(err => {

     

       56
       56
       -
         console.error(err.message);

     

       57
       57
       -
         process.exit(1);

     

       58
       58
       -
       });

     

       67
       67
       +
       gen()

     

       68
       68
       +
         .then(() => {

     

       69
       69
       +
           process.exit(0);

     

       70
       70
       +
         })

     

       71
       71
       +
         .catch(err => {

     

       72
       72
       +
           console.error(err.message);

     

       73
       73
       +
           process.exit(1);

     

       74
       74
       +
         });