@rich-automation/lotto 0.0.1

package/README.md

@@ -0,0 +1,4 @@
+# @rich-automation/lotto
+
+[![ci](https://github.com/rich-automation/lotto-module/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/rich-automation/lotto-module/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/rich-automation/lotto-module/branch/main/graph/badge.svg?token=18IAW1OW77)](https://codecov.io/gh/rich-automation/lotto-module)

package/lib/apis/dhlottery/getWinningNumbers.d.ts

@@ -0,0 +1 @@
+export declare const getWinningNumbers: (volume: number) => Promise<number[]>;

package/lib/apis/dhlottery/getWinningNumbers.js

@@ -0,0 +1,29 @@
+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());
+    });
+};
+import axios from 'axios';
+import LottoError from '../../lottoError';
+export const getWinningNumbers = (volume) => __awaiter(void 0, void 0, void 0, function* () {
+    let res;
+    try {
+        res = yield axios.get(`https://www.dhlottery.co.kr/common.do?method=getLottoNumber&drwNo=${volume}`);
+    }
+    catch (_a) {
+        throw LottoError.NetworkError();
+    }
+    if (res.data.returnValue == 'success') {
+        return toOrderedWinningNumbers(res.data);
+    }
+    else {
+        throw LottoError.InvalidRound();
+    }
+});
+function toOrderedWinningNumbers(data) {
+    return [data.drwtNo1, data.drwtNo2, data.drwtNo3, data.drwtNo4, data.drwtNo5, data.drwtNo6, data.bnusNo];
+}

package/lib/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/lib/constants/dhlottery.d.ts

@@ -0,0 +1,6 @@
+export declare const DHLOTTERY: {
+    DIALOG: {
+        ID_PWD_INCORRECT: string;
+        TOO_MANY_WRONG_SIGN_IN: string;
+    };
+};

package/lib/constants/dhlottery.js

@@ -0,0 +1,6 @@
+export const DHLOTTERY = {
+    DIALOG: {
+        ID_PWD_INCORRECT: '아이디 또는 비밀번호를 잘못 입력하셨습니다',
+        TOO_MANY_WRONG_SIGN_IN: '5회 이상 로그인에 실패하였습니다.'
+    }
+};

package/lib/constants/index.d.ts

@@ -0,0 +1,10 @@
+export declare const CONST: {
+    LAZY_RUN_DEFAULT: number;
+    BROWSER_INIT_RETRY_COUNT: number;
+    BROWSER_INIT_RETRY_TIMEOUT: number;
+    BROWSER_DESTROY_SAFE_TIMEOUT: number;
+    BROWSER_PAGE_POPUP_WAIT: number;
+    BROWSER_PAGE_DIALOG_WAIT: number;
+    WEEK_TO_MILLISECOND: number;
+    THOUSAND_ROUND_DATE: string;
+};

package/lib/constants/index.js

@@ -0,0 +1,10 @@
+export const 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/constants/selectors.d.ts

@@ -0,0 +1,11 @@
+export declare const SELECTORS: {
+    ID_INPUT: string;
+    PWD_INPUT: string;
+    LOGIN_BUTTON: string;
+    PURCHASE_TYPE_RANDOM_BTN: string;
+    PURCHASE_AMOUNT_SELECT: string;
+    PURCHASE_AMOUNT_CONFIRM_BTN: string;
+    PURCHASE_BTN: string;
+    PURCHASE_CONFIRM_BTN: string;
+    PURCHASE_NUMBER_LIST: string;
+};

package/lib/constants/selectors.js

@@ -0,0 +1,11 @@
+export const 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/constants/urls.d.ts

@@ -0,0 +1,6 @@
+export declare const URLS: {
+    MAIN: string;
+    LOGIN: string;
+    LOTTO_645: string;
+    CHECK_WINNING: string;
+};

package/lib/constants/urls.js

@@ -0,0 +1,6 @@
+export const 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/controllers/factory.d.ts

@@ -0,0 +1,3 @@
+import type { BrowserConfigs, BrowserControllerInterface } from '../types';
+import type { LoggerInterface } from '../logger';
+export declare function createBrowserController(name: 'puppeteer', configs: BrowserConfigs, logger: LoggerInterface): BrowserControllerInterface;

package/lib/controllers/factory.js

@@ -0,0 +1,7 @@
+import { PuppeteerController } from './puppeteer';
+export function createBrowserController(name, configs, logger) {
+    switch (name) {
+        case 'puppeteer':
+            return new PuppeteerController(configs, logger);
+    }
+}

package/lib/controllers/puppeteer/index.d.ts

@@ -0,0 +1,14 @@
+import type { BrowserConfigs, BrowserControllerInterface } from '../../types';
+import { Browser } from 'puppeteer';
+import { PuppeteerPage } from './puppeteer.page';
+import { type LoggerInterface } from '../../logger';
+export declare class PuppeteerController implements BrowserControllerInterface {
+    configs: BrowserConfigs;
+    logger: LoggerInterface;
+    browser: Browser;
+    constructor(configs: BrowserConfigs, logger: LoggerInterface);
+    private getBrowser;
+    focus: (pageIndex?: number) => Promise<PuppeteerPage>;
+    close: () => Promise<void>;
+    cleanPages: (remainingPageIndex: number[]) => Promise<void>;
+}

package/lib/controllers/puppeteer/index.js

@@ -0,0 +1,71 @@
+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());
+    });
+};
+import puppeteer, { Browser } from 'puppeteer';
+import { deferred } from '../../utils/deferred';
+import { PuppeteerPage } from './puppeteer.page';
+import { CONST } from '../../constants';
+import {} from '../../logger';
+export class PuppeteerController {
+    constructor(configs, logger) {
+        this.getBrowser = () => __awaiter(this, void 0, void 0, function* () {
+            const p = deferred();
+            if (this.browser) {
+                p.resolve(this.browser);
+            }
+            else {
+                let retry = 0;
+                const interval = setInterval(() => {
+                    if (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++;
+                }, 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 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 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.launch(this.configs).then(browser => (this.browser = browser));
+    }
+}

package/lib/controllers/puppeteer/puppeteer.page.d.ts

@@ -0,0 +1,16 @@
+import type { BrowserPageEvents, BrowserPageInterface, FakeDOMElement, StringifiedCookies } from '../../types';
+import { Page } from 'puppeteer';
+export declare class PuppeteerPage implements BrowserPageInterface {
+    page: Page;
+    constructor(page: Page);
+    url(): Promise<string>;
+    goto(url: string): Promise<void>;
+    fill(selector: string, value: string | number): Promise<void>;
+    click(selector: string): Promise<void>;
+    select(selector: string, value: string): Promise<void>;
+    querySelectorAll<T>(selector: string, callback: (elems: FakeDOMElement[]) => T): Promise<T>;
+    getCookies(): Promise<string>;
+    setCookies(cookies: StringifiedCookies): Promise<void>;
+    wait(param: 'idle' | 'load' | number): Promise<void>;
+    on(event: BrowserPageEvents, callback: (...args: unknown[]) => void): () => import("puppeteer").EventEmitter;
+}

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

@@ -0,0 +1,78 @@
+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());
+    });
+};
+import { Page } from 'puppeteer';
+import { deferred } from '../../utils/deferred';
+import { lazyRun } from '../../utils/lazyRun';
+export 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 = 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 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);
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1 @@
+export { LottoService } from './lottoService';

package/lib/index.js

@@ -0,0 +1 @@
+export { LottoService } from './lottoService';

package/lib/logger.d.ts

@@ -0,0 +1,25 @@
+export declare enum LogLevel {
+    NONE = -1,
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+export interface LoggerInterface {
+    setLogLevel(logLevel: LogLevel): void;
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+}
+export default class Logger implements LoggerInterface {
+    private _logLevel;
+    private _prefix;
+    constructor(logLevel?: LogLevel, prefix?: string);
+    setLogLevel(logLevel: LogLevel): void;
+    get logLevel(): LogLevel;
+    error(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    info(...args: unknown[]): void;
+    debug(...args: unknown[]): void;
+}

package/lib/logger.js

@@ -0,0 +1,48 @@
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+import timezone from 'dayjs/plugin/timezone';
+dayjs.extend(utc);
+dayjs.extend(timezone);
+export 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 || (LogLevel = {}));
+export default 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);
+        }
+    }
+}
+function printNow() {
+    return dayjs.tz(Date.now(), 'Asia/Seoul').format('YYYY/MM/DD HH:mm:ss');
+}

package/lib/lottoError.d.ts

@@ -0,0 +1,36 @@
+declare const ErrorCode: {
+    INVALID_ROUND: 300001;
+    INVALID_LOTTO_NUMBER: 300002;
+    NOT_AUTHENTICATED: 300003;
+    PURCHASE_UNAVAILABLE: 300004;
+    CREDENTIALS_INCORRECT: 200001;
+    INVALID_COOKIE: 200002;
+    NETWORK_ERROR: 100001;
+    UNKNOWN_ERROR: 199999;
+};
+type ErrorCodeNumber = (typeof ErrorCode)[keyof typeof ErrorCode];
+export default class LottoError extends Error {
+    static NetworkError(): LottoError;
+    static UnknownError(): LottoError;
+    static CredentialsIncorrect(): LottoError;
+    static InvalidCookies(): LottoError;
+    static InvalidRound(): LottoError;
+    static InvalidLottoNumber(): LottoError;
+    static NotAuthenticated(): LottoError;
+    static PurchaseUnavailable(): LottoError;
+    static get code(): {
+        INVALID_ROUND: 300001;
+        INVALID_LOTTO_NUMBER: 300002;
+        NOT_AUTHENTICATED: 300003;
+        PURCHASE_UNAVAILABLE: 300004;
+        CREDENTIALS_INCORRECT: 200001;
+        INVALID_COOKIE: 200002;
+        NETWORK_ERROR: 100001;
+        UNKNOWN_ERROR: 199999;
+    };
+    static getMessage(code: ErrorCodeNumber): string;
+    static getName(code: ErrorCodeNumber): "INVALID_ROUND" | "INVALID_LOTTO_NUMBER" | "NOT_AUTHENTICATED" | "PURCHASE_UNAVAILABLE" | "CREDENTIALS_INCORRECT" | "INVALID_COOKIE" | "NETWORK_ERROR" | "UNKNOWN_ERROR";
+    code: number;
+    constructor(code: ErrorCodeNumber, message?: string);
+}
+export {};

package/lib/lottoError.js

@@ -0,0 +1,68 @@
+import { invertObject } from './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 = 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]: '현재는 로또 구매가 불가능합니다.'
+};
+export default 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;
+    }
+}

package/lib/lottoService.d.ts

@@ -0,0 +1,19 @@
+import type { BrowserConfigs, BrowserControllerInterface, LottoServiceInterface } from './types';
+import { type LoggerInterface } from './logger';
+export declare class LottoService implements LottoServiceInterface {
+    context: {
+        authenticated: boolean;
+    };
+    browserController: BrowserControllerInterface;
+    logger: LoggerInterface;
+    constructor(configs?: BrowserConfigs);
+    destroy: () => Promise<void>;
+    signInWithCookie: (cookies: string) => Promise<string>;
+    signIn: (id: string, password: string) => Promise<string>;
+    purchase: (amount?: number) => Promise<number[][]>;
+    check: (numbers: number[], round?: number) => Promise<{
+        rank: number;
+        matchedNumbers: number[];
+    }>;
+    getCheckWinningLink: (round: number, numbers: number[][]) => string;
+}

package/lib/lottoService.js

@@ -0,0 +1,126 @@
+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());
+    });
+};
+import LottoError from './lottoError';
+import { SELECTORS } from './constants/selectors';
+import { createBrowserController } from './controllers/factory';
+import { URLS } from './constants/urls';
+import { deferred } from './utils/deferred';
+import { CONST } from './constants';
+import { lazyRun } from './utils/lazyRun';
+import Logger, {} from './logger';
+import { getCurrentLottoRound } from './utils/getCurrentLottoRound';
+import { validateLottoNumber } from './utils/validateLottoNumber';
+import { getWinningNumbers } from './apis/dhlottery/getWinningNumbers';
+import { checkWinning } from './utils/checkWinning';
+import { validatePurchaseAvailability } from './utils/validatePurchaseAvailability';
+import { getCheckWinningLink } from './utils/getCheckWinningLink';
+export class LottoService {
+    constructor(configs) {
+        this.context = {
+            authenticated: false
+        };
+        this.destroy = () => __awaiter(this, void 0, void 0, function* () {
+            return lazyRun(this.browserController.close, 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.LOGIN);
+            this.logger.debug('[signInWithCookie]', 'page url', yield page.url());
+            // 팝업 제거용
+            this.logger.debug('[signInWithCookie]', 'clear popups');
+            yield page.wait(CONST.BROWSER_PAGE_POPUP_WAIT);
+            yield this.browserController.cleanPages([0]);
+            // 로그인이 되지 않았으면 에러처리
+            if (URLS.LOGIN === (yield page.url())) {
+                this.logger.info('[signInWithCookie]', 'failure');
+                throw LottoError.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 = 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.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.LOGIN.replace('https://', '')): {
+                            this.logger.info('[signIn]', 'fallback to login page', 'failure');
+                            unsubscribe();
+                            p.reject(LottoError.CredentialsIncorrect());
+                            break;
+                        }
+                        // 로그인 성공
+                        case url.includes(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(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.ID_INPUT, id);
+                yield page.fill(SELECTORS.PWD_INPUT, password);
+                yield page.click(SELECTORS.LOGIN_BUTTON);
+            }));
+            return p.promise;
+        });
+        this.purchase = (amount = 5) => __awaiter(this, void 0, void 0, function* () {
+            if (!this.context.authenticated)
+                throw LottoError.NotAuthenticated();
+            validatePurchaseAvailability();
+            // move
+            const page = yield this.browserController.focus(0);
+            yield page.goto(URLS.LOTTO_645);
+            // click auto button
+            yield page.click(SELECTORS.PURCHASE_TYPE_RANDOM_BTN);
+            // set and confirm amount
+            const amountString = String(Math.max(1, Math.min(5, amount)));
+            yield page.select(SELECTORS.PURCHASE_AMOUNT_SELECT, amountString);
+            yield page.click(SELECTORS.PURCHASE_AMOUNT_CONFIRM_BTN);
+            // click purchase button
+            yield page.click(SELECTORS.PURCHASE_BTN);
+            yield page.click(SELECTORS.PURCHASE_CONFIRM_BTN);
+            yield page.wait(1000);
+            // game result
+            return page.querySelectorAll(SELECTORS.PURCHASE_NUMBER_LIST, elems => {
+                return elems.map(it => Array.from(it.children).map(child => Number(child.innerHTML)));
+            });
+        });
+        this.check = (numbers, round = getCurrentLottoRound()) => __awaiter(this, void 0, void 0, function* () {
+            validateLottoNumber(numbers);
+            const winningNumbers = yield getWinningNumbers(round);
+            return checkWinning(numbers, winningNumbers);
+        });
+        this.getCheckWinningLink = (round, numbers) => {
+            return getCheckWinningLink(round, numbers);
+        };
+        this.logger = new Logger(configs === null || configs === void 0 ? void 0 : configs.logLevel, '[LottoService]');
+        this.browserController = createBrowserController('puppeteer', Object.assign({ headless: false, defaultViewport: { width: 1080, height: 1024 } }, configs), this.logger);
+    }
+}

package/lib/types.d.ts

@@ -0,0 +1,69 @@
+import type { LogLevel } from './logger';
+export interface LottoServiceInterface {
+    destroy(): Promise<void>;
+    signIn(id: string, password: string): Promise<string>;
+    signInWithCookie(cookie: string): Promise<string>;
+    check(numbers: number[], volume?: number): Promise<{
+        rank: number;
+        matchedNumbers: number[];
+    }>;
+    purchase(amount: number): Promise<number[][]>;
+    getCheckWinningLink(round: number, numbers: number[][]): string;
+}
+export interface BrowserConfigs {
+    logLevel?: LogLevel;
+    headless?: boolean;
+    defaultViewport?: {
+        width: number;
+        height: number;
+    };
+    [key: string]: unknown;
+    args?: string[];
+}
+export interface BrowserControllerInterface {
+    configs: BrowserConfigs;
+    focus(pageIndex?: number): Promise<BrowserPageInterface>;
+    cleanPages(remainingPageIndex: number[]): Promise<void>;
+    close(): Promise<void>;
+}
+export interface BrowserPageInterface {
+    url(): Promise<string>;
+    goto(url: string): Promise<void>;
+    fill(selector: string, value: string | number): Promise<void>;
+    click(selector: string): Promise<void>;
+    select(selector: string, value: string): Promise<void>;
+    querySelectorAll<T>(selector: string, callback: (elems: FakeDOMElement[]) => T): Promise<T>;
+    wait(time: number): Promise<void>;
+    wait(type: 'load'): Promise<void>;
+    wait(type: 'idle'): Promise<void>;
+    getCookies(): Promise<StringifiedCookies>;
+    setCookies(cookies: StringifiedCookies): Promise<void>;
+    on(event: BrowserPageEvents, callback: (...args: any[]) => void): Unsubscribe;
+}
+export type FakeDOMElement = {
+    className: string;
+    innerHTML: string;
+    children: FakeDOMElement[];
+};
+export type BrowserPageEvents = 'load' | 'close' | 'dialog' | 'response';
+export type Unsubscribe = () => void;
+export type StringifiedCookies = string;
+export type GetWinningNumbersResponse = {
+    returnValue: 'success' | 'fail';
+    drwtNo1: number;
+    drwtNo2: number;
+    drwtNo3: number;
+    drwtNo4: number;
+    drwtNo5: number;
+    drwtNo6: number;
+    bnusNo: number;
+};
+declare global {
+    namespace NodeJS {
+        interface ProcessEnv {
+            LOTTO_ID: string;
+            LOTTO_PWD: string;
+            LOTTO_COOKIE: string;
+        }
+    }
+}

package/lib/types.js

@@ -0,0 +1 @@
+export {};

package/lib/utils/checkWinning.d.ts

@@ -0,0 +1,4 @@
+export declare const checkWinning: (myNumber: number[], winningNumbers: number[]) => Promise<{
+    rank: number;
+    matchedNumbers: number[];
+}>;

package/lib/utils/checkWinning.js

@@ -0,0 +1,33 @@
+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());
+    });
+};
+export 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 };
+});

package/lib/utils/deferred.d.ts

@@ -0,0 +1,8 @@
+interface Deferred<T> {
+    get state(): 'pending' | 'fulfilled' | 'rejected';
+    promise: Promise<T>;
+    resolve: (value?: T | PromiseLike<T>) => void;
+    reject: (reason?: unknown) => void;
+}
+export declare const deferred: <T>() => Deferred<T>;
+export {};

package/lib/utils/deferred.js

@@ -0,0 +1,23 @@
+export 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
+    };
+};

package/lib/utils/getCheckWinningLink.d.ts

@@ -0,0 +1 @@
+export declare function getCheckWinningLink(round: number, numbers: number[][]): string;

package/lib/utils/getCheckWinningLink.js

@@ -0,0 +1,5 @@
+import { URLS } from '../constants/urls';
+export function getCheckWinningLink(round, numbers) {
+    const nums = numbers.map(it => 'q' + it.map(n => String(n).padStart(2, '0')).join('')).join('');
+    return `${URLS.CHECK_WINNING}?method=winQr&v=${round}${nums}`;
+}

package/lib/utils/getCurrentLottoRound.d.ts

@@ -0,0 +1 @@
+export declare const getCurrentLottoRound: () => number;

package/lib/utils/getCurrentLottoRound.js

@@ -0,0 +1,7 @@
+import { CONST } from '../constants';
+export const getCurrentLottoRound = () => {
+    const standardDate = new Date(CONST.THOUSAND_ROUND_DATE);
+    const now = new Date(global.Date.now());
+    const ADDITIONAL_ROUND = Math.floor((now.getTime() - standardDate.getTime()) / CONST.WEEK_TO_MILLISECOND);
+    return 1000 + ADDITIONAL_ROUND;
+};

package/lib/utils/invertObject.d.ts

@@ -0,0 +1,6 @@
+type Obj = Record<string | number, string | number>;
+type Inverted<T extends Obj> = {
+    [P in keyof T as T[P]]: P;
+};
+export declare function invertObject<T extends Obj>(obj: T): Inverted<T>;
+export {};

package/lib/utils/invertObject.js

@@ -0,0 +1,7 @@
+export function invertObject(obj) {
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        result[value] = key;
+    }
+    return result;
+}

package/lib/utils/lazyRun.d.ts

@@ -0,0 +1 @@
+export declare function lazyRun<T extends () => Promise<void>>(callback: T, timeout?: number): Promise<void>;

package/lib/utils/lazyRun.js

@@ -0,0 +1,11 @@
+import { CONST } from '../constants';
+import { deferred } from './deferred';
+export function lazyRun(callback, timeout = CONST.LAZY_RUN_DEFAULT) {
+    const p = deferred();
+    setTimeout(() => {
+        callback()
+            .then(() => p.resolve())
+            .catch((e) => p.reject(e));
+    }, timeout);
+    return p.promise;
+}

package/lib/utils/seconds.d.ts

@@ -0,0 +1 @@
+export declare const seconds: (n: number) => number;

package/lib/utils/seconds.js

@@ -0,0 +1 @@
+export const seconds = (n) => 1000 * n;

package/lib/utils/validateLottoNumber.d.ts

@@ -0,0 +1 @@
+export declare const validateLottoNumber: (numbers: number[]) => void;

package/lib/utils/validateLottoNumber.js

@@ -0,0 +1,12 @@
+import LottoError from '../lottoError';
+export 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.InvalidLottoNumber();
+    }
+};

package/lib/utils/validatePurchaseAvailability.d.ts

@@ -0,0 +1 @@
+export declare const validatePurchaseAvailability: () => void;

package/lib/utils/validatePurchaseAvailability.js

@@ -0,0 +1,19 @@
+import dayjs from 'dayjs';
+import utc from 'dayjs/plugin/utc';
+import timezone from 'dayjs/plugin/timezone';
+import LottoError from '../lottoError';
+dayjs.extend(utc);
+dayjs.extend(timezone);
+const getSeoulTime = () => dayjs.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
+export 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.PurchaseUnavailable();
+    }
+};

package/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "@rich-automation/lotto",
+  "version": "0.0.1",
+  "description": "Lotto module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "contributors": [
+    {
+      "name": "bang9",
+      "url": "https://github.com/bang9"
+    },
+    {
+      "name": "DongGukMon",
+      "url": "https://github.com/DongGukMon"
+    }
+  ],
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib",
+    "package.json",
+    "README.md"
+  ],
+  "packageManager": "yarn@1.22.19",
+  "scripts": {
+    "start": "ts-node ./example/app",
+    "build": "rm -rf lib && tsc --build",
+    "test": "jest --forceExit --detectOpenHandles",
+    "install:chrome": "node ./node_modules/puppeteer/install.js",
+    "fix": "yarn fix:eslint && yarn fix:prettier",
+    "fix:eslint": "eslint --fix src --ext js,jsx,ts,tsx ",
+    "fix:prettier": "prettier --write \"src/**/*.{ts,tsx,js}\"",
+    "lint": "yarn lint:ts && yarn lint:eslint && yarn lint:prettier",
+    "lint:ts": "tsc --noEmit",
+    "lint:eslint": "eslint src --ext js,jsx,ts,tsx ",
+    "lint:prettier": "prettier --check \"src/**/*.{ts,tsx,js}\""
+  },
+  "dependencies": {
+    "axios": "^1.3.5",
+    "dayjs": "^1.11.7",
+    "puppeteer": "^19.8.5"
+  },
+  "devDependencies": {
+    "@babel/core": "^7.21.4",
+    "@babel/preset-env": "^7.21.4",
+    "@babel/preset-typescript": "^7.21.4",
+    "@types/jest": "^29.5.0",
+    "@typescript-eslint/eslint-plugin": "^5.58.0",
+    "@typescript-eslint/parser": "^5.58.0",
+    "babel-jest": "^29.5.0",
+    "dotenv": "^16.0.3",
+    "eslint": "^8.38.0",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^29.5.0",
+    "prettier": "^2.8.7",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.0.4"
+  },
+  "eslintConfig": {
+    "root": true,
+    "extends": [
+      "eslint:recommended",
+      "plugin:@typescript-eslint/recommended",
+      "eslint-config-prettier"
+    ],
+    "plugins": [
+      "@typescript-eslint",
+      "eslint-plugin-prettier"
+    ],
+    "parser": "@typescript-eslint/parser",
+    "parserOptions": {
+      "ecmaVersion": 2018,
+      "sourceType": "module"
+    },
+    "rules": {
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          "argsIgnorePattern": "^_",
+          "varsIgnorePattern": "^_"
+        }
+      ],
+      "@typescript-eslint/no-namespace": "off",
+      "prettier/prettier": [
+        "error",
+        {
+          "printWidth": 120,
+          "tabWidth": 2,
+          "useTabs": false,
+          "semi": true,
+          "singleQuote": true,
+          "trailingComma": "none",
+          "bracketSpacing": true,
+          "arrowParens": "avoid",
+          "bracketSameLine": false,
+          "proseWrap": "never"
+        }
+      ]
+    },
+    "ignorePatterns": [
+      "node_modules/",
+      "lib/"
+    ]
+  },
+  "prettier": {
+    "printWidth": 120,
+    "tabWidth": 2,
+    "useTabs": false,
+    "semi": true,
+    "singleQuote": true,
+    "trailingComma": "none",
+    "bracketSpacing": true,
+    "arrowParens": "avoid",
+    "bracketSameLine": false,
+    "proseWrap": "never"
+  }
+}