console.log("out1");
console.log("out2");
console.error("err1");
console.log("out3");
console.error("err2");

const child_process = require("child_process");
const net = require("net");

function multiplexChannels(sources, destination) {
  let totalChannels = sources.length;

  for (let i = 0; i < sources.length; i++) {
    sources[i]
      .on("readable", function () {
        let chunk;
        while ((chunk = this.read()) !== null) {
          // 5+chunk byte (Node.js는 바이트 스트림(Octet Stream)만 지원하는건지, Buffer도 최소 단위가 bit이 아니라 byte이다.)
          const outBuff = Buffer.alloc(1 + 4 + chunk.length); // Buffer.alloc(size); === new Buffer(size);
          outBuff.writeUInt8(i, 0); // write(data, idx) - 이 경우에는 idx=0
          outBuff.writeUInt32BE(chunk.length, 1); // write (data, idx) 이 경우에는 idx=1 (앞 데이터는 8bit 이므로, 한 칸만 사용)
          chunk.copy(outBuff, 5); // 앞에서 40bit를 사용해서 다음 데이터의 offset=5
          // chunk가 무슨 타입인지 모르겠지만 Readable이 제공하는 chunk는 copy 메소드가 있는 듯.
          console.log("Sending packet to channel: " + i);
          destination.write(outBuff); // 대상 스트림으로 쓰기
        }
      })
      .on("end", () => {
        // 모든 Readable이 닫힌 후 대상 스트림 종료
        if (--totalChannels === 0) {
          destination.end();
        }
      });
  }
}

// net.connect: (port, host?, callback)
const socket = net.connect(3000, () => {
  //현재 프로세스는 소켓을 열고 끝. net.connect는 Non-blocking call 이다.
  const child = child_process.fork(
    // child_process.fork로 새 프로세스에서 JS 파일을 실행한다. (이 경우 generateData.js)
    process.argv[2],
    process.argv.slice(3), // fork로 실행할 JS파일
    { silent: true } // silent 옵션: Child 프로세스가 독립적인 표준 스트림을 갖도록 (상속받지 않도록)
  );

  multiplexChannels([child.stdout, child.stderr], socket); // 대상 스트림으로 Socket 생성해 전달
});

const net = require("net");
const fs = require("fs");

// 소켓마다 한 번 호출됨 (상태 관리 필요)
// 디멀티플렉싱 수행
function demultiplexChannel(source, destinations) {
  // 상태 관리 필드
  let currentChannel = null;
  let currentLength = null;
  source
    .on("readable", () => {
      // 1. 표준 입력/오류 구분
      let chunk;
      if (currentChannel === null) {
        chunk = source.read(1);
        currentChannel = chunk && chunk.readUInt8(0);
      }

      // 2. 데이터 길이 파싱
      if (currentLength === null) {
        chunk = source.read(4);
        currentLength = chunk && chunk.readUInt32BE(0);
        if (currentLength === null) {
          return;
        }
      }

      // 3. 데이터 길이만큼 읽기
      chunk = source.read(currentLength);
      if (chunk === null) {
        return;
      }

      // 4. 읽은 데이터(chunk)를 대상 스트림에 작성
      console.log("Received packet from: " + currentChannel);
      destinations[currentChannel].write(chunk);

      // chunk 순서대로 호출되므로 여기서 다시 null을 할당하면 됨 :)
      currentChannel = null;
      currentLength = null;
    })
    .on("end", () => {
      // 소켓에서 받은 데이터가 끝난 경우 대상 스트림 모두 종료
      destinations.forEach((destination) => destination.end());
      console.log("Source channel closed");
    });
}

// 소켓 3000번으로 서버 열기
net
  .createServer((socket) => {
    // 연결 수립 시 수행할 Callback
    const stdoutStream = fs.createWriteStream("stdout.log");
    const stderrStream = fs.createWriteStream("stderr.log");
    // Source: 소켓을 통해 전달된 octet-stream, 대상 스트림 2개: 표준 출력, 표준 오류
    demultiplexChannel(socket, [stdoutStream, stderrStream]);
  })
  .listen(3000, () => console.log("Server started"));

const fromArray = require('from2-array');
const through = require('through2');
const fs = require('fs');

function concatFiles(destination, files, callback) {
  const destStream = fs.createWriteStream(destination);

  // fromArray.obj: readableStream of param array.
  fromArray.obj(files) 
  // readable 끼리 pipe 수행
  // through.obj(fn) == through({ objectMode: true }, fn) => Transform 스트림 반환
  // 현재는 through를 많이 사용하지 않아도 괜찮음. 
    .pipe(through.obj((file, enc, done) => {
      const src = fs.createReadStream(file);
      // 파일명을 file로 입력 받음
      // src1 => dest 로 pipe 연결 (pipe 사용 시 자동으로 백 프래셔 수행. src에서 데이터 생산만 하면 됨.)
      // src1.end
      // src2 => dest 로 pipe 연결
      // src2.end
      // ...
      // dest.end
      // [끝]
      // ---
      // 연결을 요청함. 이벤트 핸들러 등록과 같은 느낌. 실제 스트림 간의 통신은 비동기로 수행됨.
      src.pipe(destStream, {end: false}); 
      // 이후 src에서 dest로 연결하려면, dest는 종료되지 않아야 함
      // ---
      // 이 파일에 대한 Read Stream이 끝나면, through.obj로 생성하는 Trasnform 스트림의
      // callback인 'done' 함수를 호출하게 함. (단순히 params 이름만 바꾼 것임.)
      src.on('end', done);
    }))
    .on('finish', () => {
      // WritableStream을 종료함.
      destStream.end();
      // concatFiles 호출자에게 종료를 알림.
      callback();
    });
}

// Transform 스트림을 하나 정의한다.
class ParallelStream extends stream.Transform {
  constructor(userTransform) {
    super({objectMode: true});
    this.userTransform = userTransform;
    // const userTransform = (chunk, enc, done, pushFn) => { ... }
    this.running = 0;
    this.terminateCallback = null;
  }

  _transform(chunk, enc, done) {
    this.running++;
    this.userTransform(chunk, enc, this._onComplete.bind(this), this.push.bind(this));
    done();
  }

  // flush는 스트림 종료 직전에 호출되며 즉 done() 의 호출 여부를 결정할 수 있다.
  _flush(done) {
    // 작업이 모두 종료되기 전에 스트림이 종료되려고 하는 경우 done()을 호출하지 않는다.
    // 그 대신 onComplete에서 곧바로 종료할 수 있도록 done 함수를 
    if(this.running > 0) {
      this.terminateCallback = done;
    } else {
      done();
    }
  }

  // userTransform에서 done이라는 이름으로 호출되는 함수. 이 때의 done은 각 단위 작업의 완료를 의미한다.
  _onComplete(err) {
    this.running--;
    if(err) {
      return this.emit('error', err);
    }
    // 실행 중인 작업이 모두 종료되었고 스트림 종류가 한 번 이상 보류된 경우 직접 스트림을 종료한다.
    if(this.running === 0) {
      this.terminateCallback && this.terminateCallback();
    }
  }
};

/*
(ex)
1. process.argv[2]: urls.txt

2. urls.txt:
http://thiswillbedownforsure.com
https://www.naver.com
https://www.google.com
*/
fs.createReadStream(process.argv[2]) //[1] 파일로 readable 스트림 생성
  .pipe(split()) //[2] 파일의 라인 단위로 chunk를 잡아 출력하는 Transform 스트림 생성 (파일 내용은 url 단위로 줄바꿈 돼있음)
  .pipe(
    //[3] pipe로 전달되는 데이터(각 URL) 마다 Transform Stream의 _transform 함수에서 아래의 콜백 함수가 호출된다.
    // 생성자로 이 콜백(userTransform이라고 불리는)을 등록한다.
    new ParallelStream((url, enc, done, push) => {
      if (!url) return done(); // 더 이상 데이터가 없는 경우 (null인 경우) 스트림 종료하도록 (this.running == 0)
      request.head(url, (err, response) => {
        push(url + " is " + (err ? "down" : "up") + "\n");
        done();
      });
    })
  )
  .pipe(fs.createWriteStream("results.txt")) 
  .on("finish", () => console.log("All urls were checked"));
  /*
  result:
  http://thiswillbedownforsure.com is down
  https://www.naver.com is up
  https://www.google.com is up
  */

constructor(concurrency, userTransform) {
  // ... 아래 두 멤버 필드만 추가된다.
  this.concurrency = concurrency;
  this.continueCallback = null;
}

// 입력은 직접 제한하지 않고 계속 받는다.
// 완료를 의미하는 콜백을 호출해서 다음 chunk를 처리하지 않으면, 스트림 내부의 버퍼에 쌓이게 된다.
// 그러면 Node.js 런타임이 자동으로 백 프레셔를 수행한다.
_transform(chunk, enc, done) {
  this.running++;
  this.userTransform(chunk, enc, this.push.bind(this), this._onComplete.bind(this));
  if (this.running < this.concurrency) {
    done();
  } else {
    // 만약 현재 running의 최대치에 도달한 경우 완료 콜백을 수행하지 않는다. 이는 자연스럽게 백 프래셔 발동으로 이어진다.
    this.continueCallback = done;
  }
}

_onComplete(err) {
  this.running--;
  if (err) {
    return this.emit("error", err);
  }

  // continueCallback이 할당되어 있으면 호출한다.
  // 이 시점에서 앞 chunk들은 모두 처리됐음이 보장된다.
  // 왜냐하면 입력이 출력보다 충분히 빨라 버퍼링이 되는 시점에서는 항상 continueCallback으로 done()이 호출되게 된다.
  // 항상 this.running == this.concurrency여서 꽉 차 있는 상태이기 때문이다.
  // (설명이 부드럽지 못한데 실행 흐름을 보고 설명을 다시 읽어보면 이해가 될 것이다.)
  const tmpCallback = this.continueCallback;
  this.continueCallback = null;
  tmpCallback && tmpCallback();

  if (this.running === 0) {
    this.terminateCallback && this.terminateCallback();
  }
}

const RandomStream = require("./randomStream");
const randomStream = new RandomStream();

// readable 스트림:
// stream.read() 로 내용을 읽는 것을 의미한다.
randomStream.on("readable", () => {
  let chunk;
  while ((chunk = randomStream.read()) !== null) {
    console.log(`Chunk received: ${chunk.toString()}`);
  }
});

const stream = require('stream'); // 코어 모듈 (stream)
const chance = new require('chance')(); // 랜덤 (외부 의존성)

// [1] Readable 구현체
class RandomStream extends stream.Readable {
  constructor(options) {
    super(options);
  }

  // Readable에서 구현해야 하는 함수는 _read 하나임
  // 
  _read(size) {
    const chunk = chance.string();        //[1] 랜덤값 생성
    console.log(`Pushing chunk of size: ${chunk.length}`);
    this.push(chunk, 'utf8');             //[2] Encoding을 설정하면 String으로 읽음
    if(chance.bool({likelihood: 5})) {    //[3] null을 보내면 종료하기로 약속함
      this.push(null);
    }
  }
}

// [2] 스트림 사용
const randomStream = new RandomStream();

randomStream.on('readable', () => {
  let chunk;
  while((chunk = randomStream.read()) !== null) { // [1] 약속한대로 null 이면 읽기 종료
    console.log(`Chunk received: ${chunk.toString()}`);
  }
});

// res가 Writable Stream 이다 :)
// "Writable Stream은 데이터의 목적지를 나타낸다"는 뜻은
// stream.write(내용) 을 쓰면 해당 stream으로 전달된다는 뜻이다.
// 전송하는 입장에선 writable이지만, 받는 입장에선 readable로 취급하면 쓰기, 읽기가 각각 되는 것이다.
require("http")
  .createServer((req, res) => {
    res.writeHead(200, { "Content-Type": "text/plain" }); 
    while (chance.bool({ likelihood: 95 })) { // 5% 확률로 루프 빠져나오는 코드.
      res.write(chance.string() + "\n");
    }
    res.end("\nThe end...\n");
    res.on("finish", () => console.log("All data was sent")); // 스트림에 finish 이벤트 리스너 등록 후 종료
  })
  .listen(8080, () => console.log("Listening on http://localhost:8080"));

class ToFileStream extends stream.Writable {
  constructor() {
    super({objectMode: true});
  }

  _write (chunk, encoding, callback) {
    mkdirp(path.dirname(chunk.path), err => {
      if (err) {
        return callback(err);
      }
      fs.writeFile(chunk.path, chunk.content, callback);
    });
  }
}

require("http")
  .createServer((req, res) => {
    res.writeHead(200, { "Content-Type": "text/plain" });

    function generateMore() {
      while (chance.bool({ likelihood: 95 })) {
        const shouldContinue = res.write(
          // res.write가 Falsy를 반환하면 내부 버퍼를 다 사용한 것
          // (자세한 내용은 나중에 포스팅할 예정)
          chance.string({ length: 16 * 1024 - 1 })
        );
        if (!shouldContinue) {
          console.log("Backpressure"); // 백 프래셔를 수행해야 하는 시점
          return res.once("drain", generateMore); // once로 drain 이벤트 핸들러를 등록해 재시작 대기
        }
      }
      res.end("\nThe end...\n", () => console.log("All data was sent"));
    }
    generateMore();
  })
  .listen(8080, () => console.log("Listening on http://localhost:8080"));

const ReplaceStream = require("./replaceStream");

const rs = new ReplaceStream("World", "Node.js");
rs.on("data", (chunk) => console.log(chunk.toString()));

rs.write("Hello W");
rs.write("orld!");
rs.end();
// Hello Node.js

class ReplaceStream extends stream.Transform {
  constructor(searchString, replaceString) {
    super();
    this.searchString = searchString;
    this.replaceString = replaceString;
    this.tailPiece = '';
  }

  _transform(chunk, encoding, callback) {
    const pieces = (this.tailPiece + chunk)
      .split(this.searchString);
    const lastPiece = pieces[pieces.length - 1];
    const tailPieceLen = this.searchString.length - 1;

    this.tailPiece = lastPiece.slice(-tailPieceLen); 
    pieces[pieces.length - 1] = lastPiece.slice(0,-tailPieceLen);

    this.push(pieces.join(this.replaceString));
    // 여기서의 callback은 각 chunk의 처리가 완료됐음을 알리는 함수이다.
    callback();
  }

  // 여기서의 callback은 스트림을 종료시키는 함수이다.
  _flush(callback) {
    // flush라는 이름 답게 출력되지 않은 데이터의 출력을 수행한다.
    this.push(this.tailPiece);
    // 스트림을 종료한다.
    callback();
  }
}

"use strict";

// fnArgs는 함수의 인자 목록을 String 배열로 반환한다.
const fnArgs = require("parse-fn-args");

module.exports = () => {
  const dependencies = {};
  const factories = {};
  const diContainer = {};

  // factory, register 둘 다 단순 등록 기능이다.
  // factory 메소드의 경우 의존성 주입이 필요한 객체인 경우 사용한다.
  diContainer.factory = (name, factory) => {
    factories[name] = factory;
  };

  // register 메소드의 경우 의존성 주입이 필요 없는 객체(상수 등)를 등록할 때 사용한다.
  diContainer.register = (name, dep) => {
    dependencies[name] = dep;
  };

  /*
  1. get은 dependencies에 없는 경우 factory로 간주하고 가져옴
  2. 만약 가져오려 했던 객체가 존재하면 해당 객체로 inject를 호출함 (inject를 통해 재귀적으로 의존성을 resolve.)
  3. (2)의 결과를 dependencies에 저장
  4. 만약 그래도 dependencies에 없는 경우 모듈을 찾을 수 없는 것.
  */
  diContainer.get = (name) => {
    if (!dependencies[name]) {
      const factory = factories[name];
      dependencies[name] = factory && diContainer.inject(factory);
      if (!dependencies[name]) {
        throw new Error("Cannot find module: " + name);
      }
    }
    return dependencies[name];
  };

  /*
  1. factory로 등록된 객체를 전달받음
  2. fnArgs는 함수(factory의 경우, 의존성을 명시한 함수를 export 함.)의 인자를 가져옴
  3. 인자에 대해 map으로 get을 수행한 배열을 args 변수에 저장함
  4. factory(생성자)를 resolved 된 dependencies로 호출함
  */
  diContainer.inject = (factory) => {
    const args = fnArgs(factory).map(function (dependency) {
      return diContainer.get(dependency);
    });
    return factory.apply(null, args);
  };

  return diContainer;
};

"use strict";

//...

const diContainer = require("./lib/diContainer")();

// register는 추가적으로 의존성 주입이 필요 없는 객체를 등록한다. (상수 등)
diContainer.register("dbName", "example-db");
diContainer.register("tokenSecret", "SHHH!");

// factory는 의존성 주입이 필요한 객체를 등록한다.
diContainer.factory("db", require("./lib/db"));
// Service 객체 등록 (의존성 주입 필요한 상태)
diContainer.factory("authService", require("./lib/authService"));
// Controller 객체 등록 (의존성 주입 필요한 상태)
diContainer.factory("authController", require("./lib/authController"));

// get은 의존성을 반환한다. (재귀적으로 의존성 주입이 된 채로 반환된다.)
const authController = diContainer.get("authController");

// Express에 Controller 등록
app.post("/login", authController.login);
app.get("/checkToken", authController.checkToken);

//...

"use strict";

// Express에서 일반적으로 사용되는 Controller 예제이다.
// 모듈 차원에서 함수로 내보내며(DI 컨테이너 작동 방식에 맞춤), 인자에 이름으로 의존성을 명시한다.
module.exports = (authService) => { // DI 컨테이너에 의해 authService 의존성을 주입 받게 된다.
  const authController = {};
  
  authController.login = (req, res, next) => {
    authService.login(req.body.username, req.body.password,
      (err, result) => {
        if (err) {
          return res.status(401).send({
            ok: false,
            error: 'Invalid username/password'
          });
        }
        res.status(200).send({ok: true, token: result});
      }
    );
  };

  authController.checkToken = (req, res, next) => {
    authService.checkToken(req.query.token,
      (err, result) => {
        if (err) {
          return res.status(401).send({
            ok: false,
            error: 'Token is invalid or expired'  
          });
        }
        res.status(200).send({ok: 'true', user: result});
      }
    );
  };
  
  return authController;
};

"use strict";

const jwt = require('jwt-simple');
const bcrypt = require('bcrypt');

// 역시 모듈을 함수로 내보내며 의존성을 명시했다.
// 이 예제에서는 db 객체에 대해선 생략하였다. (DI 설명에서 의미 없는 구성 요소)
module.exports = (db, tokenSecret) => {
  const users = db.(...);
  const authService = {};
  
  authService.login = (username, password, callback) => {
    users.get(username, (err, user) => {
      if (err) return callback(err);
      
      bcrypt.compare(password, user.hash, (err, res) => {
        if (err) return callback(err);
        if (!res) return callback(new Error('Invalid password'));
        
        const token = jwt.encode({
          username: username,
          expire: Date.now() + (1000 * 60 * 60) //1 hour
        }, tokenSecret);
        
        callback(null, token);
      });
    });
  };

  authService.checkToken = (token, callback) => {
    let userData;
    try {
      userData = jwt.decode(token, tokenSecret);
      if (userData.expire <= Date.now()) {
        throw new Error('Token expired');
      }
    } catch(err) {
      return process.nextTick(callback.bind(null, err));
    }
      
    users.get(userData.username, (err, user) => {
      if (err) return callback(err);
      callback(null, {username: userData.username});
    });
  };
  
  return authService;
};

// AuthController.js - AuthService에 의존한다.
// AuthController는 ServiceLocator에만 '직접' 의존한다.
module.exports = (serviceLocator) => {
  const authService = serviceLocator.get('authService'); // TS 등 정적 타입 언어에서는 타입으로 받아온다.
  // Javascript는 딱히 타입이 없으므로 String으로 의존성(객체)을 식별한다.
  // require()와 사용 방식이 매우 닮아있다. 차이가 있다면, require는 전체 경로를 명시한다는 점이다.
  const authController = {};
  //...
}

// 직접 가져온다.
const authService = require('./authService');

exports.login = (req, res, next) => {
  authService.login(...);
  //...
};

// authService를 전달 받아서 사용한다. authService의 출처와 구현체에 대해 아는 것은 더 이상 이 객체의 책임이 아니다. 그냥 사용만 하면 된다.
module.exports = (authService) => {
  const authController = {};
  
  authController.login = (req, res, next) => {
    authService.login(req.body.username, req.body.password, ...);
    //...
  }
  return authController
};

const fs = require('fs');
const zlib = require('zlib');

const file = process.argv[2];

fs.readFile(file, (err, buffer) => {
  zlib.gzip(buffer, (err, buffer) => {
    fs.writeFile(file + '.gz', buffer, err => {
      console.log('File successfully compressed');
    });
  });
});

const fs = require('fs');
const zlib = require('zlib');

const file = process.argv[2];

// 파일을 읽는데에 buffer 크기만큼만 메모리를 점유하기 때문에 공간 효율적
// pipe 체이닝으로 각 chunk에 대해 이런 저런 처리를 할 수 있음.
fs.createReadStream(file)
  .pipe(zlib.createGzip())
  .pipe(fs.createWriteStream(file + '.gz'))
  .on('finish', () => console.log('File successfully compressed'));

const http = require('http');
const fs = require('fs');
const zlib = require('zlib');

const server = http.createServer((req, res) => {
  const filename = req.headers.filename;
  console.log('File request received: ' + filename);
  req
    .pipe(zlib.createGunzip())
    .pipe(fs.createWriteStream(filename))
    .on('finish', () => {
      res.writeHead(201 /* CREATED */, {'Content-Type': 'text/plain'});
      res.end('That\'s it\n');
      console.log(`File saved: ${filename}`);
    });
});

server.listen(3000, () => console.log('Listening'));

const fs = require('fs');
const zlib = require('zlib');
const http = require('http');
const path = require('path');

const file = process.argv[2];
const server = process.argv[3];

const options = {
  hostname: server,
  port: 3000,
  path: '/',
  method: 'PUT',
  headers: {
    filename: path.basename(file),
    'Content-Type': 'application/octet-stream',
    'Content-Encoding': 'gzip'
  }
};

const req = http.request(options, res => {
  console.log('Server response: ' + res.statusCode);
});

fs.createReadStream(file)
  .pipe(zlib.createGzip())
  .pipe(req)
  .on('finish', () => {
    console.log('File successfully sent');
  })
;

// 복호화
.pipe(crypto.createDecipheriv("aes-192-gcm", "a_shared_secret"))

// 암호화
.pipe(crypto.createCipheriv("aes-192-gcm", "a_shared_secret"))

process.stdin
  .on('readable', () => {
    let chunk;
    console.log('New data available');
    while((chunk = process.stdin.read()) !== null) {
      console.log(
        `Chunk read: (${chunk.length}) "${chunk.toString()}"`
      );
    }
  })
  .on('end', () => process.stdout.write('End of stream'));

const stream = require('stream');
const Chance = require('chance');

const chance = new Chance();

// [1] 생성
class RandomStream extends stream.Readable {
  constructor(options) {
    super(options);
  }

  _read(size) {
    const chunk = chance.string();
    console.log(`Pushing chunk of size: ${chunk.length}`);
    this.push(chunk, 'utf8');
    if(chance.bool({likelihood: 5})) { 
      this.push(null);
    }
  }
}

// [2] 사용
const RandomStream = require('./randomStream');
const randomStream = new RandomStream();

randomStream.on('readable', () => {
  let chunk;
  while((chunk = randomStream.read()) !== null) {
    console.log(`Chunk received: ${chunk.toString()}`);
  }
});

const length = N;
const tasks = [
  /* ... */
];
const data = [
  /* ... */
];
const callback = (f) => f;
const iterate = (idx) => {
  if (idx === length) return callback();

  const task = tasks[idx];
  task(data[idx], (err) => {
    if (err) return callback(err);
    iterate(idx + 1);
  });
};
iterate(0); // Callback이 재귀적으로 수행돼, N 만큼 수행된다.

// 실행 중인 job을 등록한다. 공유 리소스 동기화는 필요 없다.
const jobs = new Map();
const fn = (id, data, callback) => {
  // 이 코드로 타이밍 문제를 해결할 수 있다.
  if (jobs.has(id))
    return process.nextTick(callback);

  jobs.set(id, true);
  // 정상 분기.
};

const tasks = [
  /* ... */
];
const limit = 2; // 동시 실행 제한 개수
let running = 0,
  completed = 0,
  idx = 0;

const next = () => {
  // 여유 작업 개수만큼 반복
  while (running < limit && idx < tasks.length) {
    const task = tasks[idx++];
    task(() => {
      // 새 작업을 할 수 없음
      if (completed === tasks.length)
        return finish();
      completed++;
      running--;
      next(); // 새 작업을 할 여유가 있음
    });
    running++;
  }
};

// 동시 실행 제한 개수를 채우며 계속 실행함.
next();

// Queue로 구현하는 방식
// 로직은 같은데 Queue를 사용하는 것만 다르다.
class TaskQueue {
  constructor(limit) {
    this.limit = limit;
    this.running = 0;
    this.queue = [];
  }

  // task :: callback => void; (must call callback)
  // task를 tasks에서 가져오는 게 아니라, Queue에 넣은 것이 나온다.
  // => 새 작업을 큐에 동적으로 추가할 수 있다.
  pushTask(task) {
    this.queue.push(task);
    this.next();
  }

  next() {
    while (
      this.running < this.limit &&
      this.queue.length
    ) {
      const task = this.queue.shift();
      task(() => {
        this.running--;
        this.next();
      });
      this.running++;
    }
  }
}

class FindPattern extends EventEmitter {
  //...
}

const findPattern = new FindPattern(/hello \w+/g);
findPattern.on(/* ... */);

const module = (() => {
  const privateFoo = () => {
    /* private functionality */
  };
  let privateCounter = 0;

  const increase = () => ++privateCounter;
  const decrease = () => --privateCounter;

  // 이 객체를 반환하므로, 외부에선 privateFoo, Bar에 접근할 수 없다.
  return { increase, decrease };
})(); // 즉시 실행하여, { increase, decrease } 객체가 반환된다.

const require = (modulePath) => {
  // path를 가져오고, unique한 id로 활용한다.
  const id = require.resolveAbsolutePath(
    modulePath,
  );

  // 캐시된 모듈은 캐시를 반환한다.
  if (require.cache[id])
    return require.cache[id].exports;

  // 처음 로딩하는 경우 새 exports 객체가 필요하다.
  const module = {
    exports: {},
    id,
  };

  // 객체는 캐시한다.
  require.cache[id] = module;

  // 이 함수가 소스 코드를 읽어 exports 객체에 export 내용들을 할당한다.
  readFileAndEvaluate(id, module, require);

  return module.exports;
};

require.cache = {};
require.resolveAbsolutePath = (modulePath) => {
  /* implementation */
};

module.exports = mainFn;
exports.subFn1 = subFn1;
// 2...N-1
exports.subFnN = subFnN;

// 메인 함수
module.exports = (msg) =>
  console.log(`${this.name} ${msg}`);

// 서브 함수 1
exports.verbose = (msg) =>
  console.log(`[verbose] ${this.name} ${msg}`);

module.exports = class Logger {
  constructor(name) {
    // implementation
  }

  log(msg) {
    console.log(`${this.name} ${msg}`);
  }

  verbose(msg) {
    console.log(`[verbose] ${this.name} ${msg}`);
  }
};

class Logger {
  constructor(name) {
    // implementation
  }

  log(msg) {
    console.log(`${this.name} ${msg}`);
  }

  verbose(msg) {
    console.log(`[verbose] ${this.name} ${msg}`);
  }
}

module.exports = new Logger('App');