@rich-automation/lotto 0.0.1 → 0.0.2

package/lib/cjs/apis/dhlottery/getWinningNumbers.js

@@ -0,0 +1,36 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWinningNumbers = void 0;
+const axios_1 = __importDefault(require("axios"));
+const lottoError_1 = __importDefault(require("../../lottoError"));
+const getWinningNumbers = (volume) => __awaiter(void 0, void 0, void 0, function* () {
+    let res;
+    try {
+        res = yield axios_1.default.get(`https://www.dhlottery.co.kr/common.do?method=getLottoNumber&drwNo=${volume}`);
+    }
+    catch (_a) {
+        throw lottoError_1.default.NetworkError();
+    }
+    if (res.data.returnValue == 'success') {
+        return toOrderedWinningNumbers(res.data);
+    }
+    else {
+        throw lottoError_1.default.InvalidRound();
+    }
+});
+exports.getWinningNumbers = getWinningNumbers;
+function toOrderedWinningNumbers(data) {
+    return [data.drwtNo1, data.drwtNo2, data.drwtNo3, data.drwtNo4, data.drwtNo5, data.drwtNo6, data.bnusNo];
+}

package/lib/cjs/constants/dhlottery.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DHLOTTERY = void 0;
+exports.DHLOTTERY = {
+    DIALOG: {
+        ID_PWD_INCORRECT: '아이디 또는 비밀번호를 잘못 입력하셨습니다',
+        TOO_MANY_WRONG_SIGN_IN: '5회 이상 로그인에 실패하였습니다.'
+    }
+};

package/lib/cjs/constants/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONST = void 0;
+exports.CONST = {
+    LAZY_RUN_DEFAULT: 1000,
+    BROWSER_INIT_RETRY_COUNT: 10,
+    BROWSER_INIT_RETRY_TIMEOUT: 1000,
+    BROWSER_DESTROY_SAFE_TIMEOUT: 1000,
+    BROWSER_PAGE_POPUP_WAIT: 1500,
+    BROWSER_PAGE_DIALOG_WAIT: 10000,
+    WEEK_TO_MILLISECOND: 604800000,
+    THOUSAND_ROUND_DATE: '2022-01-29T11:50:00'
+};

package/lib/cjs/constants/selectors.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SELECTORS = void 0;
+exports.SELECTORS = {
+    ID_INPUT: '#userId',
+    PWD_INPUT: '#article > div:nth-child(2) > div > form > div > div.inner > fieldset > div.form > input[type=password]:nth-child(2)',
+    LOGIN_BUTTON: '#article > div:nth-child(2) > div > form > div > div.inner > fieldset > div.form > a',
+    PURCHASE_TYPE_RANDOM_BTN: '#tabWay2Buy a#num2',
+    PURCHASE_AMOUNT_SELECT: 'select#amoundApply',
+    PURCHASE_AMOUNT_CONFIRM_BTN: '#btnSelectNum',
+    PURCHASE_BTN: '#btnBuy',
+    PURCHASE_CONFIRM_BTN: '#popupLayerConfirm .btns > input[value="확인"]',
+    PURCHASE_NUMBER_LIST: '#reportRow .nums'
+};

package/lib/cjs/constants/urls.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URLS = void 0;
+exports.URLS = {
+    MAIN: 'https://dhlottery.co.kr/common.do?method=main',
+    LOGIN: 'https://dhlottery.co.kr/user.do?method=login&returnUrl=',
+    LOTTO_645: 'https://ol.dhlottery.co.kr/olotto/game/game645.do',
+    CHECK_WINNING: 'https://dhlottery.co.kr/qr.do'
+};

package/lib/cjs/controllers/factory.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBrowserController = void 0;
+const puppeteer_1 = require("./puppeteer");
+function createBrowserController(name, configs, logger) {
+    switch (name) {
+        case 'puppeteer':
+            return new puppeteer_1.PuppeteerController(configs, logger);
+    }
+}
+exports.createBrowserController = createBrowserController;

package/lib/cjs/controllers/puppeteer/index.js

@@ -0,0 +1,77 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerController = void 0;
+const puppeteer_1 = __importDefault(require("puppeteer"));
+const deferred_1 = require("../../utils/deferred");
+const puppeteer_page_1 = require("./puppeteer.page");
+const constants_1 = require("../../constants");
+class PuppeteerController {
+    constructor(configs, logger) {
+        this.getBrowser = () => __awaiter(this, void 0, void 0, function* () {
+            const p = (0, deferred_1.deferred)();
+            if (this.browser) {
+                p.resolve(this.browser);
+            }
+            else {
+                let retry = 0;
+                const interval = setInterval(() => {
+                    if (constants_1.CONST.BROWSER_INIT_RETRY_COUNT < retry) {
+                        clearInterval(interval);
+                        p.reject(new Error('Browser is not initialized'));
+                    }
+                    else if (this.browser) {
+                        clearInterval(interval);
+                        p.resolve(this.browser);
+                    }
+                    retry++;
+                }, constants_1.CONST.BROWSER_INIT_RETRY_TIMEOUT);
+            }
+            return p.promise;
+        });
+        this.focus = (pageIndex = -1) => __awaiter(this, void 0, void 0, function* () {
+            const browser = yield this.getBrowser();
+            const pages = yield browser.pages();
+            if (pages.length === 0) {
+                const page = yield browser.newPage();
+                return new puppeteer_page_1.PuppeteerPage(page);
+            }
+            else {
+                const isWithinRange = Math.max(0, Math.min(pageIndex, pages.length - 1)) === pageIndex;
+                const page = pages.at(isWithinRange ? pageIndex : -1);
+                if (!page)
+                    throw new Error('Page is not found');
+                return new puppeteer_page_1.PuppeteerPage(page);
+            }
+        });
+        this.close = () => __awaiter(this, void 0, void 0, function* () {
+            const browser = yield this.getBrowser();
+            return browser.close();
+        });
+        this.cleanPages = (remainingPageIndex) => __awaiter(this, void 0, void 0, function* () {
+            const browser = yield this.getBrowser();
+            const pages = yield browser.pages();
+            const promises = pages.map((page, index) => __awaiter(this, void 0, void 0, function* () {
+                if (!remainingPageIndex.includes(index)) {
+                    return page.close();
+                }
+            }));
+            yield Promise.all(promises);
+        });
+        this.configs = configs;
+        this.logger = logger;
+        puppeteer_1.default.launch(this.configs).then(browser => (this.browser = browser));
+    }
+}
+exports.PuppeteerController = PuppeteerController;

package/lib/cjs/controllers/puppeteer/puppeteer.page.js

@@ -0,0 +1,81 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerPage = void 0;
+const deferred_1 = require("../../utils/deferred");
+const lazyRun_1 = require("../../utils/lazyRun");
+class PuppeteerPage {
+    constructor(page) {
+        this.page = page;
+    }
+    url() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.page.url();
+        });
+    }
+    goto(url) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.page.goto(url, { waitUntil: 'load' });
+        });
+    }
+    fill(selector, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.page.type(selector, value.toString());
+        });
+    }
+    click(selector) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.page.click(selector);
+        });
+    }
+    select(selector, value) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.page.select(selector, value);
+        });
+    }
+    querySelectorAll(selector, callback) {
+        return this.page.$$eval(selector, callback);
+    }
+    getCookies() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cookies = yield this.page.cookies();
+            return JSON.stringify(cookies);
+        });
+    }
+    setCookies(cookies) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const cookieParams = JSON.parse(cookies);
+            yield this.page.setCookie(...cookieParams);
+        });
+    }
+    wait(param) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const p = (0, deferred_1.deferred)();
+            if (param === 'idle') {
+                yield this.page.waitForNavigation({ waitUntil: 'networkidle0' });
+                p.resolve();
+            }
+            if (param === 'load') {
+                yield this.page.waitForNavigation({ waitUntil: 'load' });
+                p.resolve();
+            }
+            if (typeof param === 'number') {
+                yield (0, lazyRun_1.lazyRun)(() => __awaiter(this, void 0, void 0, function* () { return p.resolve(); }), param);
+            }
+            return p.promise;
+        });
+    }
+    on(event, callback) {
+        this.page.on(event, callback);
+        return () => this.page.off(event, callback);
+    }
+}
+exports.PuppeteerPage = PuppeteerPage;

package/lib/cjs/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LottoService = void 0;
+var lottoService_1 = require("./lottoService");
+Object.defineProperty(exports, "LottoService", { enumerable: true, get: function () { return lottoService_1.LottoService; } });

package/lib/cjs/logger.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogLevel = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const timezone_1 = __importDefault(require("dayjs/plugin/timezone"));
+dayjs_1.default.extend(utc_1.default);
+dayjs_1.default.extend(timezone_1.default);
+var LogLevel;
+(function (LogLevel) {
+    LogLevel[LogLevel["NONE"] = -1] = "NONE";
+    LogLevel[LogLevel["ERROR"] = 0] = "ERROR";
+    LogLevel[LogLevel["WARN"] = 1] = "WARN";
+    LogLevel[LogLevel["INFO"] = 2] = "INFO";
+    LogLevel[LogLevel["DEBUG"] = 3] = "DEBUG";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+class Logger {
+    constructor(logLevel = LogLevel.INFO, prefix = '') {
+        this._logLevel = logLevel;
+        this._prefix = prefix;
+    }
+    setLogLevel(logLevel) {
+        this._logLevel = logLevel;
+    }
+    get logLevel() {
+        return this._logLevel;
+    }
+    error(...args) {
+        if (this._logLevel >= LogLevel.ERROR) {
+            console.error(printNow(), this._prefix, ...args);
+        }
+    }
+    warn(...args) {
+        if (this._logLevel >= LogLevel.WARN) {
+            console.warn(printNow(), this._prefix, ...args);
+        }
+    }
+    info(...args) {
+        if (this._logLevel >= LogLevel.INFO) {
+            console.info(printNow(), this._prefix, ...args);
+        }
+    }
+    debug(...args) {
+        if (this._logLevel >= LogLevel.DEBUG) {
+            console.debug(printNow(), this._prefix, ...args);
+        }
+    }
+}
+exports.default = Logger;
+function printNow() {
+    return dayjs_1.default.tz(Date.now(), 'Asia/Seoul').format('YYYY/MM/DD HH:mm:ss');
+}

package/lib/cjs/lottoError.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const invertObject_1 = require("./utils/invertObject");
+const BaseErrorCode = {
+    NETWORK_ERROR: 100001,
+    UNKNOWN_ERROR: 199999
+};
+const LoginErrorCode = {
+    CREDENTIALS_INCORRECT: 200001,
+    INVALID_COOKIE: 200002
+};
+const LottoErrorCode = {
+    INVALID_ROUND: 300001,
+    INVALID_LOTTO_NUMBER: 300002,
+    NOT_AUTHENTICATED: 300003,
+    PURCHASE_UNAVAILABLE: 300004
+};
+const ErrorCode = Object.assign(Object.assign(Object.assign({}, BaseErrorCode), LoginErrorCode), LottoErrorCode);
+const ErrorName = (0, invertObject_1.invertObject)(ErrorCode);
+const ErrorMessage = {
+    [ErrorCode.NETWORK_ERROR]: '네트워크 에러가 발생했습니다.',
+    [ErrorCode.UNKNOWN_ERROR]: '알 수 없는 오류가 발생했습니다.',
+    [ErrorCode.CREDENTIALS_INCORRECT]: '아이디 혹은 비밀번호가 일치하지 않습니다.',
+    [ErrorCode.INVALID_COOKIE]: '쿠키가 만료됐거나 유효하지 않습니다.',
+    [ErrorCode.INVALID_ROUND]: '로또 회차가 올바르지 않습니다.',
+    [ErrorCode.INVALID_LOTTO_NUMBER]: '로또 번호가 올바르지 않습니다.',
+    [ErrorCode.NOT_AUTHENTICATED]: '인증되지 않았습니다.',
+    [ErrorCode.PURCHASE_UNAVAILABLE]: '현재는 로또 구매가 불가능합니다.'
+};
+class LottoError extends Error {
+    static NetworkError() {
+        return new LottoError(ErrorCode.NETWORK_ERROR);
+    }
+    static UnknownError() {
+        return new LottoError(ErrorCode.UNKNOWN_ERROR);
+    }
+    static CredentialsIncorrect() {
+        return new LottoError(ErrorCode.CREDENTIALS_INCORRECT);
+    }
+    static InvalidCookies() {
+        return new LottoError(ErrorCode.INVALID_COOKIE);
+    }
+    static InvalidRound() {
+        return new LottoError(ErrorCode.INVALID_ROUND);
+    }
+    static InvalidLottoNumber() {
+        return new LottoError(ErrorCode.INVALID_LOTTO_NUMBER);
+    }
+    static NotAuthenticated() {
+        return new LottoError(ErrorCode.NOT_AUTHENTICATED);
+    }
+    static PurchaseUnavailable() {
+        return new LottoError(ErrorCode.PURCHASE_UNAVAILABLE);
+    }
+    static get code() {
+        return ErrorCode;
+    }
+    static getMessage(code) {
+        return ErrorMessage[code];
+    }
+    static getName(code) {
+        return ErrorName[code];
+    }
+    constructor(code, message) {
+        var _a;
+        super(message !== null && message !== void 0 ? message : ErrorMessage[code]);
+        this.name = (_a = ErrorName[code]) !== null && _a !== void 0 ? _a : 'LottoError';
+        this.code = code;
+    }
+}
+exports.default = LottoError;

package/lib/cjs/lottoService.js

@@ -0,0 +1,133 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LottoService = void 0;
+const lottoError_1 = __importDefault(require("./lottoError"));
+const selectors_1 = require("./constants/selectors");
+const factory_1 = require("./controllers/factory");
+const urls_1 = require("./constants/urls");
+const deferred_1 = require("./utils/deferred");
+const constants_1 = require("./constants");
+const lazyRun_1 = require("./utils/lazyRun");
+const logger_1 = __importDefault(require("./logger"));
+const getCurrentLottoRound_1 = require("./utils/getCurrentLottoRound");
+const validateLottoNumber_1 = require("./utils/validateLottoNumber");
+const getWinningNumbers_1 = require("./apis/dhlottery/getWinningNumbers");
+const checkWinning_1 = require("./utils/checkWinning");
+const validatePurchaseAvailability_1 = require("./utils/validatePurchaseAvailability");
+const getCheckWinningLink_1 = require("./utils/getCheckWinningLink");
+class LottoService {
+    constructor(configs) {
+        this.context = {
+            authenticated: false
+        };
+        this.destroy = () => __awaiter(this, void 0, void 0, function* () {
+            return (0, lazyRun_1.lazyRun)(this.browserController.close, constants_1.CONST.BROWSER_DESTROY_SAFE_TIMEOUT);
+        });
+        this.signInWithCookie = (cookies) => __awaiter(this, void 0, void 0, function* () {
+            // 쿠키 설정 & 페이지 이동
+            const page = yield this.browserController.focus(0);
+            this.logger.debug('[signInWithCookie]', 'setCookies');
+            yield page.setCookies(cookies);
+            this.logger.debug('[signInWithCookie]', 'goto', 'login page');
+            yield page.goto(urls_1.URLS.LOGIN);
+            this.logger.debug('[signInWithCookie]', 'page url', yield page.url());
+            // 팝업 제거용
+            this.logger.debug('[signInWithCookie]', 'clear popups');
+            yield page.wait(constants_1.CONST.BROWSER_PAGE_POPUP_WAIT);
+            yield this.browserController.cleanPages([0]);
+            // 로그인이 되지 않았으면 에러처리
+            if (urls_1.URLS.LOGIN === (yield page.url())) {
+                this.logger.info('[signInWithCookie]', 'failure');
+                throw lottoError_1.default.InvalidCookies();
+            }
+            this.logger.info('[signInWithCookie]', 'success');
+            this.context.authenticated = true;
+            return page.getCookies();
+        });
+        this.signIn = (id, password) => __awaiter(this, void 0, void 0, function* () {
+            const p = (0, deferred_1.deferred)();
+            queueMicrotask(() => __awaiter(this, void 0, void 0, function* () {
+                // 페이지 이동
+                const page = yield this.browserController.focus(0);
+                this.logger.debug('[signIn]', 'goto', 'login page');
+                yield page.goto(urls_1.URLS.LOGIN);
+                this.logger.debug('[signIn]', 'page url', yield page.url());
+                const unsubscribe = page.on('response', (response) => __awaiter(this, void 0, void 0, function* () {
+                    const url = response.url();
+                    switch (true) {
+                        // 로그인 실패
+                        case url.includes(urls_1.URLS.LOGIN.replace('https://', '')): {
+                            this.logger.info('[signIn]', 'fallback to login page', 'failure');
+                            unsubscribe();
+                            p.reject(lottoError_1.default.CredentialsIncorrect());
+                            break;
+                        }
+                        // 로그인 성공
+                        case url.includes(urls_1.URLS.MAIN.replace('https://', '')): {
+                            this.logger.info('[signIn]', 'fallback to main page', 'success');
+                            this.context.authenticated = true;
+                            unsubscribe();
+                            this.logger.debug('[signIn]', 'clear popups');
+                            yield page.wait(constants_1.CONST.BROWSER_PAGE_POPUP_WAIT);
+                            yield this.browserController.cleanPages([0]);
+                            const cookies = yield page.getCookies();
+                            p.resolve(cookies);
+                            break;
+                        }
+                    }
+                }));
+                // 로그인 시도
+                this.logger.debug('[signIn]', 'try login');
+                yield page.fill(selectors_1.SELECTORS.ID_INPUT, id);
+                yield page.fill(selectors_1.SELECTORS.PWD_INPUT, password);
+                yield page.click(selectors_1.SELECTORS.LOGIN_BUTTON);
+            }));
+            return p.promise;
+        });
+        this.purchase = (amount = 5) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.context.authenticated)
+                throw lottoError_1.default.NotAuthenticated();
+            (0, validatePurchaseAvailability_1.validatePurchaseAvailability)();
+            // move
+            const page = yield this.browserController.focus(0);
+            yield page.goto(urls_1.URLS.LOTTO_645);
+            // click auto button
+            yield page.click(selectors_1.SELECTORS.PURCHASE_TYPE_RANDOM_BTN);
+            // set and confirm amount
+            const amountString = String(Math.max(1, Math.min(5, amount)));
+            yield page.select(selectors_1.SELECTORS.PURCHASE_AMOUNT_SELECT, amountString);
+            yield page.click(selectors_1.SELECTORS.PURCHASE_AMOUNT_CONFIRM_BTN);
+            // click purchase button
+            yield page.click(selectors_1.SELECTORS.PURCHASE_BTN);
+            yield page.click(selectors_1.SELECTORS.PURCHASE_CONFIRM_BTN);
+            yield page.wait(1000);
+            // game result
+            return page.querySelectorAll(selectors_1.SELECTORS.PURCHASE_NUMBER_LIST, elems => {
+                return elems.map(it => Array.from(it.children).map(child => Number(child.innerHTML)));
+            });
+        });
+        this.check = (numbers, round = (0, getCurrentLottoRound_1.getCurrentLottoRound)()) => __awaiter(this, void 0, void 0, function* () {
+            (0, validateLottoNumber_1.validateLottoNumber)(numbers);
+            const winningNumbers = yield (0, getWinningNumbers_1.getWinningNumbers)(round);
+            return (0, checkWinning_1.checkWinning)(numbers, winningNumbers);
+        });
+        this.getCheckWinningLink = (round, numbers) => {
+            return (0, getCheckWinningLink_1.getCheckWinningLink)(round, numbers);
+        };
+        this.logger = new logger_1.default(configs === null || configs === void 0 ? void 0 : configs.logLevel, '[LottoService]');
+        this.browserController = (0, factory_1.createBrowserController)('puppeteer', Object.assign({ headless: false, defaultViewport: { width: 1080, height: 1024 } }, configs), this.logger);
+    }
+}
+exports.LottoService = LottoService;

package/lib/cjs/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/cjs/utils/checkWinning.js

@@ -0,0 +1,37 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkWinning = void 0;
+const checkWinning = (myNumber, winningNumbers) => __awaiter(void 0, void 0, void 0, function* () {
+    const mainWinningNumbers = winningNumbers.slice(0, 6);
+    const bonusNumber = winningNumbers.at(-1);
+    const matchedNumbers = myNumber.filter(n => mainWinningNumbers.includes(n));
+    const matchingNumbersCount = matchedNumbers.length;
+    let rank = 0;
+    if (matchingNumbersCount === 6) {
+        rank = 1;
+    }
+    else if (matchingNumbersCount === 5 && myNumber.includes(bonusNumber)) {
+        matchedNumbers.push(bonusNumber);
+        rank = 2;
+    }
+    else if (matchingNumbersCount === 5) {
+        rank = 3;
+    }
+    else if (matchingNumbersCount === 4) {
+        rank = 4;
+    }
+    else if (matchingNumbersCount === 3) {
+        rank = 5;
+    }
+    return { rank, matchedNumbers };
+});
+exports.checkWinning = checkWinning;

package/lib/cjs/utils/deferred.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deferred = void 0;
+const deferred = () => {
+    let state = 'pending';
+    let resolve;
+    let reject;
+    const promise = new Promise((res, rej) => {
+        resolve = (value) => {
+            state = 'fulfilled';
+            res(value);
+        };
+        reject = (reason) => {
+            state = 'rejected';
+            rej(reason);
+        };
+    });
+    return {
+        get state() {
+            return state;
+        },
+        promise,
+        resolve,
+        reject
+    };
+};
+exports.deferred = deferred;

package/lib/cjs/utils/getCheckWinningLink.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCheckWinningLink = void 0;
+const urls_1 = require("../constants/urls");
+function getCheckWinningLink(round, numbers) {
+    const nums = numbers.map(it => 'q' + it.map(n => String(n).padStart(2, '0')).join('')).join('');
+    return `${urls_1.URLS.CHECK_WINNING}?method=winQr&v=${round}${nums}`;
+}
+exports.getCheckWinningLink = getCheckWinningLink;

package/lib/cjs/utils/getCurrentLottoRound.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentLottoRound = void 0;
+const constants_1 = require("../constants");
+const getCurrentLottoRound = () => {
+    const standardDate = new Date(constants_1.CONST.THOUSAND_ROUND_DATE);
+    const now = new Date(global.Date.now());
+    const ADDITIONAL_ROUND = Math.floor((now.getTime() - standardDate.getTime()) / constants_1.CONST.WEEK_TO_MILLISECOND);
+    return 1000 + ADDITIONAL_ROUND;
+};
+exports.getCurrentLottoRound = getCurrentLottoRound;

package/lib/cjs/utils/invertObject.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.invertObject = void 0;
+function invertObject(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[value] = key;
+    }
+    return result;
+}
+exports.invertObject = invertObject;

package/lib/cjs/utils/lazyRun.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lazyRun = void 0;
+const constants_1 = require("../constants");
+const deferred_1 = require("./deferred");
+function lazyRun(callback, timeout = constants_1.CONST.LAZY_RUN_DEFAULT) {
+    const p = (0, deferred_1.deferred)();
+    setTimeout(() => {
+        callback()
+            .then(() => p.resolve())
+            .catch((e) => p.reject(e));
+    }, timeout);
+    return p.promise;
+}
+exports.lazyRun = lazyRun;

package/lib/cjs/utils/seconds.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seconds = void 0;
+const seconds = (n) => 1000 * n;
+exports.seconds = seconds;

package/lib/cjs/utils/validateLottoNumber.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateLottoNumber = void 0;
+const lottoError_1 = __importDefault(require("../lottoError"));
+const validateLottoNumber = (numbers) => {
+    const isValid = numbers
+        .filter(number => {
+        return typeof number === 'number' && Math.max(number, 45) === 45 && Math.min(number, 1) === 1;
+    })
+        .filter((number, index) => numbers.indexOf(number) === index)
+        .filter(number => Number.isInteger(number)).length === 6;
+    if (!isValid) {
+        throw lottoError_1.default.InvalidLottoNumber();
+    }
+};
+exports.validateLottoNumber = validateLottoNumber;

package/lib/cjs/utils/validatePurchaseAvailability.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePurchaseAvailability = void 0;
+const dayjs_1 = __importDefault(require("dayjs"));
+const utc_1 = __importDefault(require("dayjs/plugin/utc"));
+const timezone_1 = __importDefault(require("dayjs/plugin/timezone"));
+const lottoError_1 = __importDefault(require("../lottoError"));
+dayjs_1.default.extend(utc_1.default);
+dayjs_1.default.extend(timezone_1.default);
+const getSeoulTime = () => dayjs_1.default.tz(Date.now(), 'Asia/Seoul');
+const resetTime = (dayjs) => dayjs.hour(0).minute(0).second(0).millisecond(0);
+// 평일/일요일: 06:00 ~ 24:00
+// 토요일: 06:00 ~ 20:00
+const validatePurchaseAvailability = () => {
+    const now = getSeoulTime();
+    const isSaturday = now.day() === 6;
+    const openingTime = resetTime(getSeoulTime()).hour(6);
+    const closingTime = isSaturday ? resetTime(getSeoulTime()).hour(20) : resetTime(getSeoulTime()).hour(24);
+    if (now.isBefore(openingTime) || now.isAfter(closingTime)) {
+        throw lottoError_1.default.PurchaseUnavailable();
+    }
+};
+exports.validatePurchaseAvailability = validatePurchaseAvailability;

package/lib/esm/apis/dhlottery/requestBuy.js

@@ -0,0 +1,11 @@
+"use strict";
+// POST
+// https://ol.dhlottery.co.kr/olotto/game/execBuy.do
+// form
+// {
+//   round: 1066,
+//   direct: 172.17.20.52,
+//   nBuyAmount: 1000,
+//   param: [{"genType": "0","arrGameChoiceNum": null, "alpabet": "A"}]
+//   gameCnt:1
+// }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rich-automation/lotto",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Lotto module",
   "publishConfig": {
     "access": "public"
@@ -15,9 +15,9 @@
       "url": "https://github.com/DongGukMon"
     }
   ],
-  "type": "module",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "main": "lib/cjs/index",
+  "module": "lib/esm/index",
+  "types": "lib/typescript/index.d.ts",
   "files": [
     "lib",
     "package.json",
@@ -25,8 +25,12 @@
   ],
   "packageManager": "yarn@1.22.19",
   "scripts": {
+    "prepack": "yarn build",
     "start": "ts-node ./example/app",
-    "build": "rm -rf lib && tsc --build",
+    "build": "rm -rf lib && yarn build:cjs && yarn build:esm && yarn build:dts",
+    "build:cjs": "tsc --project tsconfig.cjs.json --verbatimModuleSyntax false",
+    "build:esm": "tsc --project tsconfig.esm.json",
+    "build:dts": "tsc --project tsconfig.json --emitDeclarationOnly --declaration --declarationDir lib/typescript",
     "test": "jest --forceExit --detectOpenHandles",
     "install:chrome": "node ./node_modules/puppeteer/install.js",
     "fix": "yarn fix:eslint && yarn fix:prettier",