@aj-shadow/z-build-project 0.0.0-aj-beta.221

package/project/server/child-client-bundle.js

@@ -0,0 +1,376 @@
+
+'use strict';
+
+const ChildBuildData = require('./child-build-data');
+const Log = require('./log');
+const Babelify = require('babelify');
+const envify = require('envify');
+const { minify } = require('terser');
+const Browserify = require('browserify');
+const Clc = require('cli-color');
+const FastGlob = require('fast-glob');
+const Babel = require("@babel/core");
+const Fs = require('fs');
+const Path = require('path');
+const Zlib = require('zlib');
+
+
+class ChildClientBundle {
+  static START = './build/'.length;
+  static STOP = '.js'.length;
+  static BABEL_PART_PATH = `${Path.sep}node_modules${Path.sep}@babel`;
+  static BROWSERIFY_PART_EMPTY_PATH = `${Path.sep}node_modules${Path.sep}browserify${Path.sep}lib${Path.sep}_empty.js`;
+  
+  constructor(appName, name, silent, bundleName, source, dest, ignores, externals, externalGlobs, exports, exportSource, shim, nodeEnv, buildEnv) {
+    this.appName = appName;
+    this.name = name;
+    this.silent = silent;
+    this.bundleName = bundleName;
+    this.source = source;
+    this.dest = dest;
+    this.ignores = ignores;
+    this.externals = externals;
+    this.externalGlobs = externalGlobs;
+    this.exports = exports;
+    this.exportSource = exportSource;
+    this.shim = shim;
+    process.env.NODE_ENV = nodeEnv;
+    this.production = 1 === buildEnv;
+    this.nestedDependencies = [];
+  }
+  
+  task(cb) {
+    const buildDataPath = Path.resolve(`..${Path.sep}Generated${Path.sep}Build${Path.sep}${this.appName}-${this.name.replaceAll(':', '-').replaceAll('/', '-')}`);
+    ChildBuildData.getBuildData(buildDataPath, (buildData) => {
+      let pendings = 3;
+      let changed = false;
+      let sources = null;
+      let externals = null;
+      const dstFile = `${this.dest.replaceAll('/', Path.sep)}${Path.sep}${this.bundleName}`;
+      Fs.lstat(dstFile, (err, stat) => {
+        if(!!err) {
+          changed = 'ENOENT' === err.code;
+        }
+        if(0 === --pendings) {
+          if(changed) {
+            this._build(sources, externals, buildDataPath, buildData, cb);
+          }
+          else {
+            cb();
+          }
+        }
+      });
+      this._sourceChanged(buildData, (_changed, _sources) => {
+        changed = changed || _changed;
+        sources = _sources;
+        if(0 === --pendings) {
+          if(changed) {
+            this._build(sources, externals, buildDataPath, buildData, cb);
+          }
+          else {
+            cb();
+          }
+        }
+      });
+      this._externalChanged(buildData, (_changed, _externals) => {
+        changed = changed || _changed;
+        externals = _externals;
+        if(0 === --pendings) {
+          if(changed) {
+            this._build(sources, externals, buildDataPath, buildData, cb);
+          }
+          else {
+            cb();
+          }
+        }
+      });
+    });
+  }
+  
+  _printNestedDependencies() {
+    this.nestedDependencies.forEach((nestedDependency) => {
+      if(nestedDependency.isExternal) {
+        if(!nestedDependency.file.includes(ChildClientBundle.BABEL_PART_PATH)) {
+          if(!nestedDependency.file.includes(ChildClientBundle.BROWSERIFY_PART_EMPTY_PATH)) {
+            const bundleDate = new Date();
+            Log.bundle(this.name, bundleDate, nestedDependency.id, nestedDependency.file);
+          }
+          else {
+            const ignoreDate = new Date();
+            Log.ignore(this.name, ignoreDate, nestedDependency.id, nestedDependency.file);
+          }
+        }
+      }
+    });
+  }
+  
+  _build(sources, externals, buildDataPath, buildData, cb) {
+    const browserify = Browserify({
+      entries: sources,
+      debug: false,
+      ignoreMissing: true,
+      transform: [[envify, { global: true }, { NODE_ENV: this.production ? 'production' : 'development'}]]
+    }, this.shim);
+    browserify.pipeline.on('file', (file, id, parent) => {
+      this.nestedDependencies.push({
+        file,
+        id,
+        isExternal: file.includes('node_modules') && !file.includes('@actorjs')
+      });
+    });
+    if(this.ignores) {
+      this.ignores.forEach((ignore) => {
+        if(!Array.isArray(ignore)) {
+          browserify.exclude(ignore);
+          const ignoreDate = new Date();
+          Log.ignore(this.name, ignoreDate, ignore, '');
+        }
+        else {
+          if(this.production) {
+            browserify.exclude(ignore[0]);
+            const ignoreDate = new Date();
+            Log.ignore(this.name, ignoreDate, ignore[0], '');
+          }
+          else {
+            browserify.exclude(ignore[1]);
+            const ignoreDate = new Date();
+            Log.ignore(this.name, ignoreDate, ignore[1], '');
+          }
+        }
+      });
+    }
+    
+    if(this.externals) {
+      this.externals.forEach((external) => {
+        browserify.external(external);
+      });
+    }
+    
+    if(this.exports) {
+      this.exports.forEach((export_) => {
+        if(!Array.isArray(export_)) {
+          browserify.require(export_);
+        }
+        else {
+          if(this.production) {
+            browserify.require(export_[0][0], {expose: export_[0][1]});
+          }
+          else {
+            if(export_[1]) {
+              browserify.require(export_[1][0], {expose: export_[1][1]});
+            }
+            else {
+              browserify.require(export_[0][0], {expose: export_[0][1]});
+            }
+          }
+        }
+      });
+    }
+    
+    sources.forEach((source) => {
+      browserify.require(source, {expose: source.substring(ChildClientBundle.START, source.length - ChildClientBundle.STOP)});
+    });
+    
+    externals.forEach((external) => {
+      browserify.external(external.substring(ChildClientBundle.START, external.length - ChildClientBundle.STOP));
+    });
+    
+    this._bundleClientBundle(browserify, buildDataPath, buildData, cb);
+  }
+  
+  async _sourceChanged(buildData,  cb) {
+    if(this.source && 0 !== this.source.length) {
+      let pendings = this.source.length;
+      const entries = [];
+      let changed = false;
+      for(let i = 0; i < this.source.length; ++i) {
+        const files = await FastGlob([this.source[i]], { caseSensitiveMatch: true, braceExpansion: false });
+        entries.push(files);
+        files.forEach((file) => {
+          ++pendings;
+          Fs.lstat(file, (err, stat) => {
+            const mTimeMs = buildData.map.get(file);
+            if(mTimeMs !== stat.mtimeMs) {
+              changed = true;
+              ChildBuildData.set(buildData, file, stat.mtimeMs);
+            }
+            if(0 === --pendings) {
+              cb(changed, entries.flat());
+            }
+          });
+        });
+        if(0 === --pendings) {
+          cb(changed, entries.flat());
+        }
+      }
+    }
+    else {
+      process.nextTick(cb, false, []);
+    }
+  }
+  
+  async _externalChanged(buildData, cb) {
+    if(this.externalGlobs && 0 !== this.externalGlobs.length) {
+      let pendings = this.externalGlobs.length;
+      const entries = [];
+      let changed = false;
+      for(let i = 0; i < this.externalGlobs.length; ++i) {
+        const files = await FastGlob([this.externalGlobs[i]], { caseSensitiveMatch: true, braceExpansion: false });
+        entries.push(files);
+        files.forEach((file) => {
+          ++pendings;
+          Fs.lstat(file, (err, stat) => {
+            const mTimeMs = buildData.map.get(file);
+            if(mTimeMs !== stat.mtimeMs) {
+              changed = true;
+              ChildBuildData.set(buildData, file, stat.mtimeMs);
+            }
+            if(0 === --pendings) {
+              cb(changed, entries.flat());
+              return;
+            }
+          });
+        });
+        if(0 === --pendings) {
+          cb(changed, entries.flat());
+          return;
+        }
+      }
+      if(0 === pendings) {
+        cb(changed, entries.flat());
+      }
+    }
+    else {
+      process.nextTick(cb.bind(this, false, []));
+    }
+  }
+  
+  async _formatCodeDevelopment(buf, cb) {
+    const result = await minify(buf.toString('utf8'), {
+      compress: {
+        dead_code: true,
+        drop_debugger: false,
+        global_defs: {
+          'process.env.NODE_ENV': '"development"'
+        }
+      },
+      mangle: false,
+      format: {
+        beautify: true
+      }
+    });
+	  cb(result);
+  }
+  
+  async _formatCodeProduction(buf, cb) {
+    const result = await minify(buf.toString('utf8'), {
+      compress: {
+        dead_code: true,
+        drop_debugger: false,
+        passes: 2,
+        global_defs: {
+          'process.env.NODE_ENV': '"production"'
+        }
+      },
+      mangle: false,
+      format: {
+        comments: false
+      }
+    });
+    cb(result);
+  }
+  
+  _bundleClientBundle(browserify, buildDataPath, buildData, cb) {
+    browserify
+    .on('error', console.error.bind(console))
+    .transform(Babelify, {
+      plugins: [
+        "@babel/plugin-transform-runtime",
+        ["transform-inline-environment-variables", {"include": ["NODE_ENV"]}]
+      ],
+      presets: ["@babel/env"],
+      compact: this.production,
+      minified: this.production,
+      comments: !this.production
+    })
+    .bundle((err, buf) => {
+      if(err) {
+        Log.log(this.appName + '.' + this.name + '-----------------------------------------------------------------------------', buf);
+        Log.log(this.appName + '.' + this.name + `Bundle ${this.name} error:`, err);
+        cb();
+      }
+      else if(this.production) {
+        this._formatCodeProduction(buf, (result) => {
+          const dstFile = `${this.dest}${Path.sep}${this.bundleName}`;
+          let pendings = 2;
+          Zlib.gzip(result.code, (err, data) =>  {
+            if(err) {
+              Log.log(this.appName + '.' + this.name + `Bundle Zip ${this.name} error:`, err);
+              if(0 === --pendings) {
+                cb();
+              }
+              return;
+            }
+            Fs.writeFile(dstFile + '.gzip', data, (err) => {
+              if(err) {
+                Log.log(this.appName + '.' + this.name + Clc.red(`Could not write: '`) + dstFile + Clc.red(`'.`), err);
+              }
+              if(0 === --pendings) {
+                ChildBuildData.setBuildData(buildDataPath, buildData, cb);
+                this._printNestedDependencies();
+              }
+            });
+          });
+          Fs.writeFile(dstFile, result.code, (err) => {
+            if(err) {
+              Log.log(this.appName + '.' + this.name + Clc.red(`Could not write: '`) + dstFile + Clc.red(`'.`), err);
+            }
+            if(0 === --pendings) {
+              ChildBuildData.setBuildData(buildDataPath, buildData, cb);
+              this._printNestedDependencies();
+            }
+          });
+        });
+      }
+      else {
+        this._formatCodeDevelopment(buf, (result) => {
+          const dstFile = `${this.dest}${Path.sep}${this.bundleName}`;
+          Fs.writeFile(dstFile, result.code, (err) => {
+            if(err) {
+              Log.log(this.appName + '.' + this.name + Clc.red(`Could not write: '`) + dstFile + Clc.red(`'.`), err);
+            }
+            ChildBuildData.setBuildData(buildDataPath, buildData, cb);
+            this._printNestedDependencies();
+          });
+	      });
+      }
+    });
+  }
+}
+
+
+process.nextTick(() => {
+  const parameters = JSON.parse(process.argv[2]);
+  let isDone = false;
+  const childClientBundle = new ChildClientBundle(...parameters);
+  process.on('exit', (code) => {
+    if(!isDone) {
+      console.log(' EXIT BUNDLE JS - WITHOUT DONE', childClientBundle.name);
+    }
+  });
+  //if('Bundle:AppLayer/client' === childClientBundle.name) {
+  //  console.log('START BUNDLE JS', childClientBundle.name);
+  //}
+  childClientBundle.task(() => {
+    if(!isDone) {
+      //if('Bundle:AppLayer/client' === childClientBundle.name) {
+      //  console.log(' DONE BUNDLE JS', childClientBundle.name);
+      //}
+      isDone = true;
+      process.send(0);
+    }
+    else {
+      console.log(' DONE BUNDLE JS - AGAIN', childClientBundle.name);
+    }
+  });
+});

package/project/server/child-client-js.js

@@ -0,0 +1,279 @@
+
+'use strict';
+
+const ChildBuildData = require('./child-build-data');
+const Log = require('./log');
+const Pendings = require('./pendings');
+const TaskRunnerGlob = require('./task-runner-glob');
+const Clc = require('cli-color');
+const Fs = require('fs');
+const Os = require('os');
+const Path = require('path');
+
+
+class ChildClientJs {
+  static SEARCH_requireAsBundle = Buffer.from('requireAsBundle');
+  static SEARCH_start = 'requireAsBundle'.length + 2;
+  static SEARCH_stop = Buffer.from('\')');
+  static SEARCH_empty_string = Buffer.from('\'\'');
+  static SEARCH_template_litteral = Buffer.from('`');
+  
+  static BUILD_RELEASE_START = '#BUILD_RELEASE_START';
+  static BUILD_RELEASE_START_COMMENT_LINE = '// #BUILD_RELEASE_START';
+  static BUILD_RELEASE_START_COMMENT_ALL = '/* #BUILD_RELEASE_START';
+  static BUILD_RELEASE_STOP = '#BUILD_RELEASE_STOP';
+  static BUILD_RELEASE_STOP_COMMENT_LINE = '// #BUILD_RELEASE_STOP';
+  static BUILD_RELEASE_STOP_COMMENT_ALL = '#BUILD_RELEASE_STOP */';
+  static BUILD_DEBUG_START = '#BUILD_DEBUG_START';
+  static BUILD_DEBUG_START_COMMENT_LINE = '// #BUILD_DEBUG_START';
+  static BUILD_DEBUG_START_COMMENT_ALL = '/* #BUILD_DEBUG_START';
+  static BUILD_DEBUG_STOP = '#BUILD_DEBUG_STOP';
+  static BUILD_DEBUG_STOP_COMMENT_LINE = '// #BUILD_DEBUG_STOP';
+  static BUILD_DEBUG_STOP_COMMENT_ALL = '#BUILD_DEBUG_STOP */';
+  
+  constructor(appName, name, silent, repo, source, dest, nodeEnv) {
+    this.appName = appName;
+    this.name = name;
+    this.silent = silent;
+    this.repo = repo;
+    this.source = source;
+    this.dest = dest;
+    this.isDebug = 'development' === nodeEnv;
+    process.env.NODE_ENV = nodeEnv;
+  }
+  
+  task(cb) {
+    const resolvedPath = Path.resolve(this.repo ? Path.resolve(this.repo) : '.');
+    const buildDataPath = Path.resolve(`..${Path.sep}Generated${Path.sep}Build${Path.sep}${this.appName}-${this.name.replaceAll(':', '-').replaceAll('/', '-')}`);
+    ChildBuildData.getBuildData(buildDataPath, (buildData) => {
+      TaskRunnerGlob.glob(this.source, this.dest, resolvedPath, null, cb, (srcFile, dstFile, done) => {
+        let shallBuild = true;
+        const pendings = new Pendings(1, null);
+        Fs.lstat(dstFile, (err, stat) => {
+          if(shallBuild) {
+            if(!!err && 'ENOENT' === err.code) {
+              shallBuild = false;
+              this._build(pendings, srcFile, dstFile, resolvedPath, buildDataPath, buildData, done);
+            }
+            else {
+              this._setBuildData(pendings, buildDataPath, buildData, done);
+            }
+          }
+          else {
+            this._setBuildData(pendings, buildDataPath, buildData, done);
+          }
+        });
+        pendings.inc();
+        Fs.lstat(srcFile, (err, stat) => {
+          if(shallBuild) {
+            const mTimeMs = buildData.map.get(srcFile);
+            if(mTimeMs === stat.mtimeMs) {
+              this._setBuildData(pendings, buildDataPath, buildData, done);
+            }
+            else {
+              shallBuild = false;
+              this._build(pendings, srcFile, dstFile, resolvedPath, buildDataPath, buildData, done);
+            }
+          }
+          else {
+            this._setBuildData(pendings, buildDataPath, buildData, done);
+          }
+        });
+      });
+    });
+  }
+  
+  _setBuildData(pendings, buildDataPath, buildData, done) {
+    if(pendings.dec()) {
+      ChildBuildData.setBuildData(buildDataPath, buildData, done);
+    }
+  }
+  
+  _build(pendings, srcFile, dstFile, resolvedPath, buildDataPath, buildData, cb) {
+    Fs.readFile(srcFile, (err, data) => {
+      if(err) {
+        Log.log(Clc.red(`Could not read: '`) + srcFile + Clc.red(`'.`), err);
+        if(pendings.dec()) {
+          cb();
+        }
+      }
+      else {
+        TaskRunnerGlob.verifyPath(dstFile, (err) => {
+          if(err) {
+            if(pendings.dec()) {
+              cb();
+            }
+          }
+          else {
+            const bundleIndex = data.indexOf(ChildClientJs.SEARCH_requireAsBundle);
+            if(-1 !== bundleIndex) {
+              data = this._macro(data);
+              ChildBuildData.write(srcFile, dstFile, data.subarray(0, bundleIndex), buildData, (err) => {
+                if(!err) {
+                  const buffers = [];
+                  this._bundle(buffers, data, bundleIndex, srcFile, dstFile, resolvedPath, () => {
+                    this._appendFile(dstFile, buffers, (err) => {
+                      if(err) {
+                        Log.log(Clc.red(`Could not write: '`) + dstFile + Clc.red(`'.`), err);
+                        if(pendings.dec()) {
+                          cb();
+                        }
+                        return;
+                      }
+                      if(pendings.dec()) {
+                        ChildBuildData.setBuildData(buildDataPath, buildData, cb);
+                      }
+                    });
+                  });
+                }
+                else {
+                  if(pendings.dec()) {
+                    ChildBuildData.setBuildData(buildDataPath, buildData, cb);
+                  }
+                }
+              });
+            }
+            else {
+              data = this._macro(data);
+              ChildBuildData.write(srcFile, dstFile, data, buildData, () => {
+                if(pendings.dec()) {
+                  ChildBuildData.setBuildData(buildDataPath, buildData, cb);
+                }
+              });
+            }
+          }
+        });
+      }
+    });
+  }
+  
+  _appendFile(dstFile, buffers, cb) {
+    const buffer = buffers.shift();
+    if(!buffer) {
+      return cb();
+    }
+    Fs.appendFile(dstFile, buffer, (err) => {
+      if(err) {
+        Log.log(Clc.red(`Could not append: '`) + dstFile + Clc.red(`'.`), err);
+        cb(err);
+      }
+      else {
+        this._appendFile(dstFile, buffers, cb);
+      }
+    });
+  }
+  
+  _bundle(buffers, data, bundleIndex, srcFile, dstFile, resolvedPath, cb) {
+    const stopIndex = data.indexOf(ChildClientJs.SEARCH_stop, bundleIndex);
+    const bundleInculde = data.subarray(bundleIndex + ChildClientJs.SEARCH_start, stopIndex).toString().replaceAll('/', Path.sep);
+    let file = null;
+    let srcBase = null;
+    if(bundleInculde.startsWith('.')) {
+      const lastIndex = srcFile.lastIndexOf(Path.sep);
+      srcBase = srcFile.substring(0, lastIndex);
+      file = Path.normalize(srcBase + Path.sep + bundleInculde) + '.js';
+    }
+    else {
+      const lastIndex = resolvedPath.lastIndexOf(Path.sep);
+      srcBase = resolvedPath.substring(0, lastIndex);
+      const firstIndex = bundleInculde.indexOf(Path.sep);
+      file = Path.normalize(srcBase + Path.sep + bundleInculde.substring(0, firstIndex) + Path.sep + 'project' + Path.sep + bundleInculde.substring(firstIndex)) + '.js';
+    }
+    Fs.readFile(file, (err, src) => {
+      if(!err) {
+        buffers.push(ChildClientJs.SEARCH_template_litteral);
+        let replacedSrc = src.toString().replace('`', '\`');
+        this._removeLine(buffers, replacedSrc, ['\'use strict\';', 'module.exports', '= require(\''], 0);
+        buffers.push(ChildClientJs.SEARCH_template_litteral);
+      }
+      else {
+        Log.log(err);
+        buffers.push(ChildClientJs.SEARCH_empty_string);
+      }
+      const nextBundleIndex = data.indexOf(ChildClientJs.SEARCH_requireAsBundle, stopIndex + 2);
+      if(-1 === nextBundleIndex) {
+        buffers.push(data.subarray(stopIndex + 2));
+        process.nextTick(cb);
+      }
+      else {
+        buffers.push(data.subarray(stopIndex + 2, nextBundleIndex));
+        this._bundle(buffers, data, nextBundleIndex, srcFile, dstFile, resolvedPath, cb);
+      }
+    });
+  }
+  
+  _removeLine(buffers, src, texts, index) {
+    let foundIndex = -1;
+    for(let i = 0; i < texts.length; ++i) {
+      const fIndex = src.indexOf(texts[i], index);
+      if(-1 !== fIndex) {
+        if(-1 === foundIndex) {
+          foundIndex = fIndex;
+        }
+        else if(fIndex < foundIndex) {
+          foundIndex = fIndex;
+        }
+      }
+    }
+    if(-1 === foundIndex) {
+      if(0 === index) {
+        buffers.push(Buffer.from(src));
+      }
+      else {
+        buffers.push(Buffer.from(src.substring(index)));
+      }
+      return;
+    }
+    else {
+      const startIndex = src.lastIndexOf(Os.EOL, foundIndex);
+      const endIndex = src.indexOf(Os.EOL, foundIndex);
+      if(-1 !== endIndex) {
+        buffers.push(Buffer.from(src.substring(index, startIndex)));
+        this._removeLine(buffers, src, texts, endIndex);
+      }
+    }
+  }
+  
+  _macro(data) {
+    const mightHaveMacro = data.indexOf('#');
+    if(-1 !== mightHaveMacro) {
+      if('string' !== typeof data) {
+        data = data.toString();
+      }
+      if(this.isDebug) {
+        data = data.replaceAll(ChildClientJs.BUILD_DEBUG_START, ChildClientJs.BUILD_DEBUG_START_COMMENT_LINE);
+        data = data.replaceAll(ChildClientJs.BUILD_DEBUG_STOP, ChildClientJs.BUILD_DEBUG_STOP_COMMENT_LINE);
+        data = data.replaceAll(ChildClientJs.BUILD_RELEASE_START, ChildClientJs.BUILD_RELEASE_START_COMMENT_ALL);
+        data = data.replaceAll(ChildClientJs.BUILD_RELEASE_STOP, ChildClientJs.BUILD_RELEASE_STOP_COMMENT_ALL);
+      }
+      else {
+        data = data.replaceAll(ChildClientJs.BUILD_RELEASE_START, ChildClientJs.BUILD_RELEASE_START_COMMENT_LINE);
+        data = data.replaceAll(ChildClientJs.BUILD_RELEASE_STOP, ChildClientJs.BUILD_RELEASE_STOP_COMMENT_LINE);
+        data = data.replaceAll(ChildClientJs.BUILD_DEBUG_START, ChildClientJs.BUILD_DEBUG_START_COMMENT_ALL);
+        data = data.replaceAll(ChildClientJs.BUILD_DEBUG_STOP, ChildClientJs.BUILD_DEBUG_STOP_COMMENT_ALL);
+      }
+    }
+    return data;
+  }
+}
+
+
+process.nextTick(() => {
+  const parameters = JSON.parse(process.argv[2]);
+  let isDone = false;
+  const childClientJs = new ChildClientJs(...parameters);
+  process.on('exit', (code) => {
+    if(!isDone) {
+      console.log(' EXIT CLIENT JS - WITHOUT DONE', childClientJs.name, childClientJs.pendings.value);
+    }
+  });
+  childClientJs.task(() => {
+    if(!isDone) {
+      isDone = true;
+      process.send(0);
+    }
+    else {
+      console.log(' DONE CLIENT JS - AGAIN', childClientJs.name);
+    }
+  });
+});