gyomu 0.1.0

package/lib/variable.js

@@ -0,0 +1,280 @@
+"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 __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _VariableTranslator_instances, _VariableTranslator_marketAccess, _VariableTranslator_translateDate, _VariableTranslator_translate, _VariableTranslator_getSupportedMarket;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VariableTranslator = void 0;
+const dateOperation_1 = require("./dateOperation");
+const dbsingleton_1 = __importDefault(require("./dbsingleton"));
+const holidays_1 = __importDefault(require("./holidays"));
+const date_fns_1 = require("date-fns");
+const errors_1 = require("./errors");
+const result_1 = require("./result");
+const VariableType = {
+    Date: 'Date',
+    ParamMaster: 'Parameter',
+    ParamMasterStringDictionary: 'ParameterDictionary',
+    Argument: 'Argument',
+    ArgumentFile: 'File',
+};
+const VariableDateKeyword = {
+    TODAY: 'TODAY',
+    BBOM: 'BBOM',
+    NEXTBBOM: 'NEXTBBOM',
+    BOM: 'BOM',
+    BEOM: 'BEOM',
+    NEXTBEOM: 'NEXTBEOM',
+    PREVBEOM: 'PREVBEOM',
+    EOM: 'EOM',
+    NEXTBUS: 'NEXTBUS',
+    NEXTDAY: 'NEXTDAY',
+    PREVBUS: 'PREVBUS',
+    PREVDAY: 'PREVDAY',
+    EOY: 'EOY',
+    BEOY: 'BEOY',
+    BBOY: 'BBOY',
+    BOY: 'BOY',
+};
+class VariableTranslator {
+    //readonly #ctx: Context;
+    constructor(marketAccess) {
+        _VariableTranslator_instances.add(this);
+        _VariableTranslator_marketAccess.set(this, void 0);
+        this.__supportedMarkets = new Array();
+        //constructor(marketAccess: MarketDateAccess, ctx: Context) {
+        __classPrivateFieldSet(this, _VariableTranslator_marketAccess, marketAccess, "f");
+        //this.#ctx = ctx;
+    }
+    static getTranslator(market) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const result = yield holidays_1.default.getMarketAccess(market);
+            if (result.isFailure())
+                return result;
+            const access = result.value;
+            const translator = new VariableTranslator(access);
+            yield translator.init();
+            return (0, result_1.success)(translator);
+        });
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.__supportedMarkets = yield __classPrivateFieldGet(this, _VariableTranslator_instances, "m", _VariableTranslator_getSupportedMarket).call(this);
+        });
+    }
+    parse(inputString, targetDate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const startIndex = inputString.indexOf('{%');
+            const endIndex = inputString.indexOf('%}');
+            if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+                const prefix = inputString.substring(0, startIndex);
+                const keyword = inputString.substring(startIndex + 2, endIndex);
+                const suffix = inputString.substring(endIndex + 2);
+                const result = yield __classPrivateFieldGet(this, _VariableTranslator_instances, "m", _VariableTranslator_translate).call(this, keyword, targetDate);
+                if (result.isFailure())
+                    return result;
+                const parsedString = prefix + result.value + suffix;
+                return yield this.parse(parsedString, targetDate);
+            }
+            else
+                return (0, result_1.success)(inputString);
+            // return new Promise((resolve, reject) => {
+            //   resolve(success(inputString));
+            // });
+        });
+    }
+    parseDate(keyword, targetDate) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const parts = keyword.split('$');
+            let factorIndex = 1;
+            let translateMarketAccess = __classPrivateFieldGet(this, _VariableTranslator_marketAccess, "f");
+            // const supportedMarket = await this.#getSupportedMarket();
+            for (var item of parts) {
+                if (!isNaN(parseInt(item))) {
+                    factorIndex = parseInt(item);
+                }
+                else if (this.__supportedMarkets.includes(item)) {
+                    const result = yield holidays_1.default.getMarketAccess(item);
+                    if (result.isFailure())
+                        return new result_1.Failure(new errors_1.ParseError(`Fail to retrieve market data ${item}`, result.error));
+                    translateMarketAccess = result.value;
+                }
+                else if (item in VariableDateKeyword) {
+                    return __classPrivateFieldGet(this, _VariableTranslator_instances, "m", _VariableTranslator_translateDate).call(this, translateMarketAccess, targetDate, item, factorIndex);
+                }
+            }
+            return (0, result_1.promiseFail)('No keyword: Not supported', errors_1.ParseError);
+        });
+    }
+}
+exports.VariableTranslator = VariableTranslator;
+_VariableTranslator_marketAccess = new WeakMap(), _VariableTranslator_instances = new WeakSet(), _VariableTranslator_translateDate = function _VariableTranslator_translateDate(targetMarketAccess, targetDate, dateParameter, factorIndex) {
+    switch (dateParameter) {
+        case VariableDateKeyword.TODAY:
+            return (0, result_1.success)(targetDate);
+        case VariableDateKeyword.BBOM:
+            // Business Day of Beginning of Month
+            return (0, result_1.success)(targetMarketAccess.businessDayOfBeginningMonthWithOffset(targetDate, factorIndex));
+        case VariableDateKeyword.NEXTBBOM:
+            // Business Day of Beginning of Next Month
+            return (0, result_1.success)(targetMarketAccess.businessDayOfBeginningOfNextMonthWithOffset(targetDate, factorIndex));
+        case VariableDateKeyword.BOM:
+            // Beginning of Month
+            return (0, result_1.success)((0, date_fns_1.addDays)((0, dateOperation_1.createDateOnly)(targetDate.getFullYear(), targetDate.getMonth() + 1, 1), factorIndex - 1));
+        case VariableDateKeyword.BEOM:
+            // Business Day of End Of Month
+            return (0, result_1.success)(targetMarketAccess.businessDayOfEndMonthWithOffset(targetDate, factorIndex));
+        case VariableDateKeyword.NEXTBEOM:
+            // Business Day of End of Next Month
+            const twoMonthAfter = (0, date_fns_1.addMonths)(targetDate, 2);
+            return (0, result_1.success)(targetMarketAccess.businessDayOfBeginningMonthWithOffset(twoMonthAfter, -factorIndex));
+        case VariableDateKeyword.PREVBEOM:
+            // Business Day of End of Previous Month
+            const bom = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear(), targetDate.getMonth() + 1, 1);
+            return (0, result_1.success)(targetMarketAccess.businessDay(bom, -factorIndex));
+        case VariableDateKeyword.EOM:
+            // End Of Month
+            const nextMonth = (0, date_fns_1.addMonths)(targetDate, 1);
+            return (0, result_1.success)((0, date_fns_1.subDays)((0, dateOperation_1.createDateOnly)(nextMonth.getFullYear(), nextMonth.getMonth() + 1, 1), factorIndex));
+        case VariableDateKeyword.NEXTBUS:
+            // Next Business Day
+            return (0, result_1.success)(targetMarketAccess.businessDay(targetDate, factorIndex));
+        case VariableDateKeyword.NEXTDAY:
+            // Next Day
+            return (0, result_1.success)((0, date_fns_1.addDays)(targetDate, factorIndex));
+        case VariableDateKeyword.PREVBUS:
+            // Previous Business Day
+            return (0, result_1.success)(targetMarketAccess.businessDay(targetDate, -factorIndex));
+        case VariableDateKeyword.PREVDAY:
+            // Previous Day
+            return (0, result_1.success)((0, date_fns_1.subDays)(targetDate, factorIndex));
+        case VariableDateKeyword.EOY:
+            // End of Year
+            const nextYear = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear() + 1, 1, 1);
+            return (0, result_1.success)((0, date_fns_1.subDays)(nextYear, factorIndex));
+        case VariableDateKeyword.BEOY:
+            // Business Day of End of Year
+            const nextYear2 = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear() + 1, 1, 1);
+            return (0, result_1.success)(targetMarketAccess.businessDay(nextYear2, -factorIndex));
+        case VariableDateKeyword.BBOY:
+            // Business Day Of Beginning of Year
+            const thisYear = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear(), 1, 1);
+            return (0, result_1.success)(targetMarketAccess.businessDay(thisYear, factorIndex - (targetMarketAccess.isBusinessDay(thisYear) ? 1 : 0)));
+        case VariableDateKeyword.BOY:
+            // Beginning of Year
+            const thisYear2 = (0, dateOperation_1.createDateOnly)(targetDate.getFullYear(), 1, 1);
+            return (0, result_1.success)((0, date_fns_1.addDays)(thisYear2, factorIndex - 1));
+        default:
+            return (0, result_1.fail)(`${dateParameter} is not supported`, errors_1.ParseError);
+    }
+}, _VariableTranslator_translate = function _VariableTranslator_translate(keyword, targetDate) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const parts = keyword.split('$');
+        let factorIndex = 1;
+        let variableType = VariableType.Date;
+        let translateMarketAccess = __classPrivateFieldGet(this, _VariableTranslator_marketAccess, "f");
+        //const supportedMarket = await this.#getSupportedMarket();
+        const stringList = new Array();
+        let dateParameter = (0, result_1.fail)('init', errors_1.ParseError);
+        // console.log('keyword', keyword);
+        // console.log('parts', parts);
+        for (var item of parts) {
+            if (!isNaN(parseInt(item))) {
+                factorIndex = parseInt(item);
+            }
+            else if (this.__supportedMarkets.includes(item)) {
+                // console.log('Market', item);
+                const result = yield holidays_1.default.getMarketAccess(item);
+                if (result.isFailure())
+                    return new result_1.Failure(new errors_1.ParseError(`Fail to retrieve market data ${item}`, result.error));
+                translateMarketAccess = result.value;
+            }
+            else if (item in VariableDateKeyword) {
+                // console.log('internal keyword', item);
+                dateParameter = yield __classPrivateFieldGet(this, _VariableTranslator_instances, "m", _VariableTranslator_translateDate).call(this, translateMarketAccess, targetDate, item, factorIndex);
+                if (dateParameter.isFailure())
+                    return dateParameter;
+                // console.log('parse date', dateParameter);
+            }
+            else {
+                switch (item) {
+                    case 'PARAMMASTER':
+                        // Retrieve from DB Parameter
+                        variableType = VariableType.ParamMaster;
+                        break;
+                    case 'PARAMDICTIONARY':
+                        variableType = VariableType.ParamMasterStringDictionary;
+                        break;
+                    case 'ARGUMENT':
+                        variableType = VariableType.Argument;
+                        break;
+                    case 'ATTACHMENTFILE':
+                        variableType = VariableType.ArgumentFile;
+                        break;
+                    default:
+                        switch (variableType) {
+                            case VariableType.Date:
+                                const translateFormat = item;
+                                if (!dateParameter || dateParameter.isFailure())
+                                    return (0, result_1.fail)(`Invalid Keyword Setting for date: ${keyword}`, errors_1.ParseError);
+                                // console.log('format', item, dateParameter);
+                                if (dateParameter.isFailure())
+                                    return dateParameter;
+                                // console.log(
+                                //   'formated date',
+                                //   format(dateParameter.value, translateFormat)
+                                // );
+                                stringList.push((0, date_fns_1.format)(dateParameter.value, translateFormat));
+                                break;
+                            case VariableType.ParamMaster:
+                                stringList.push('');
+                                break;
+                            case VariableType.ParamMasterStringDictionary:
+                                stringList.push('');
+                                break;
+                            case VariableType.Argument:
+                                stringList.push(arguments[factorIndex - 1]);
+                                break;
+                            case VariableType.ArgumentFile:
+                                break;
+                        }
+                }
+            }
+        }
+        parts.forEach((item) => __awaiter(this, void 0, void 0, function* () { }));
+        //console.log('parsed result', stringList);
+        return (0, result_1.success)(stringList.join(''));
+    });
+}, _VariableTranslator_getSupportedMarket = function _VariableTranslator_getSupportedMarket() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const distinctMarkets = yield dbsingleton_1.default.gyomu_market_holiday.findMany({
+            select: { market: true },
+            distinct: ['market'],
+        });
+        const markets = new Array();
+        for (var row of distinctMarkets) {
+            markets.push(row.market);
+        }
+        return markets;
+    });
+};

package/lib/web/attribute.d.ts

@@ -0,0 +1,6 @@
+export declare class Attribute {
+    #private;
+    constructor(attribute: Attr);
+    get name(): string;
+    get value(): string;
+}

package/lib/web/attribute.js

@@ -0,0 +1,29 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _Attribute_attribute;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Attribute = void 0;
+class Attribute {
+    constructor(attribute) {
+        _Attribute_attribute.set(this, void 0);
+        __classPrivateFieldSet(this, _Attribute_attribute, attribute, "f");
+    }
+    get name() {
+        return __classPrivateFieldGet(this, _Attribute_attribute, "f").name;
+    }
+    get value() {
+        return __classPrivateFieldGet(this, _Attribute_attribute, "f").value;
+    }
+}
+exports.Attribute = Attribute;
+_Attribute_attribute = new WeakMap();

package/lib/web/element.d.ts

@@ -0,0 +1,24 @@
+import { Attribute } from './attribute';
+import xpath from 'xpath';
+export declare class DOMElement {
+    protected __node: HTMLElement;
+    constructor(node: HTMLElement);
+    get childElements(): Array<DOMElement>;
+    protected getNode<E extends HTMLElement>(): E;
+    get id(): string;
+    get innerHtml(): string;
+    get innerText(): string;
+    get childNodeValue(): string;
+    get classList(): string[];
+    get attributes(): Array<Attribute>;
+    getAttribute(name: string): Attribute | undefined;
+    searchByXPath(path: string): (string | number | boolean | Attribute | GenericElement<HTMLElement>)[];
+    searchOneByXPath(path: string): string | number | boolean | Attribute | GenericElement<HTMLElement> | undefined;
+    static parseXPathResultValue(searchValue: xpath.SelectedValue | undefined): string | number | boolean | Attribute | GenericElement<HTMLElement> | undefined;
+    static parseXPathResultValidValue(searchValue: xpath.SelectedValue): string | number | boolean | Attribute | GenericElement<HTMLElement>;
+}
+export declare class GenericElement<T extends HTMLElement> extends DOMElement {
+    constructor(node: T);
+    get node(): T;
+    getGenericElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): GenericElement<HTMLElementTagNameMap[K]>[];
+}

package/lib/web/element.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenericElement = exports.DOMElement = void 0;
+const attribute_1 = require("./attribute");
+const xpath_1 = __importDefault(require("xpath"));
+const errors_1 = require("../errors");
+class DOMElement {
+    constructor(node) {
+        this.__node = node;
+    }
+    get childElements() {
+        const children = new Array();
+        for (var child of Array.from(this.__node.childNodes)) {
+            if (child instanceof HTMLElement) {
+                const childElement = new DOMElement(child);
+                children.push(childElement);
+            }
+        }
+        return children;
+    }
+    getNode() {
+        return this.__node;
+    }
+    get id() {
+        return this.__node.id;
+    }
+    get innerHtml() {
+        return this.__node.innerHTML;
+    }
+    get innerText() {
+        var _a;
+        return (_a = this.__node.textContent) !== null && _a !== void 0 ? _a : this.childNodeValue;
+    }
+    get childNodeValue() {
+        var _a;
+        const cnodes = this.__node.childNodes;
+        return cnodes.length > 0 ? (_a = cnodes.item(0).nodeValue) !== null && _a !== void 0 ? _a : '' : '';
+    }
+    get classList() {
+        let classArray = new Array();
+        this.__node.classList.forEach((val) => {
+            classArray.push(val);
+        });
+        return classArray;
+    }
+    get attributes() {
+        const attributeArray = new Array();
+        const nodeAttributes = this.__node.attributes;
+        for (let i = 0; i < nodeAttributes.length; i++) {
+            const nodeAttribute = nodeAttributes.item(i);
+            if (!!nodeAttribute) {
+                const attribute = new attribute_1.Attribute(nodeAttribute);
+                attributeArray.push(attribute);
+            }
+        }
+        return attributeArray;
+    }
+    getAttribute(name) {
+        const nodeAttribute = this.__node.attributes.getNamedItem(name);
+        if (!nodeAttribute)
+            return undefined;
+        else
+            return new attribute_1.Attribute(nodeAttribute);
+    }
+    searchByXPath(path) {
+        return xpath_1.default.select(path, this.__node).map((v) => {
+            return DOMElement.parseXPathResultValidValue(v);
+        });
+    }
+    searchOneByXPath(path) {
+        const searchValue = xpath_1.default.select(path, this.__node, true);
+        return DOMElement.parseXPathResultValue(searchValue);
+    }
+    static parseXPathResultValue(searchValue) {
+        if (!searchValue)
+            return undefined;
+        return DOMElement.parseXPathResultValidValue(searchValue);
+    }
+    static parseXPathResultValidValue(searchValue) {
+        switch (typeof searchValue) {
+            case 'string':
+                return searchValue;
+            case 'number':
+                return searchValue;
+            case 'boolean':
+                return searchValue;
+            default:
+                if (searchValue instanceof Attr) {
+                    return new attribute_1.Attribute(searchValue);
+                }
+                else {
+                    if (searchValue instanceof HTMLElement) {
+                        return new GenericElement(searchValue);
+                    }
+                    else {
+                        throw new errors_1.WebParseError(`Unsupported Value: ${JSON.stringify(searchValue)}`);
+                    }
+                }
+        }
+    }
+}
+exports.DOMElement = DOMElement;
+class GenericElement extends DOMElement {
+    constructor(node) {
+        super(node);
+    }
+    get node() {
+        return this.__node;
+    }
+    getGenericElementsByTagName(qualifiedName) {
+        return Array.from(this.__node.getElementsByTagName(qualifiedName)).map((element) => {
+            return new GenericElement(element);
+        });
+    }
+}
+exports.GenericElement = GenericElement;

package/lib/web/index.d.ts

@@ -0,0 +1,7 @@
+export { Page, PageOption, PageResponseOption, PageTextOption } from './page';
+export { Attribute } from './attribute';
+export { DOMElement, GenericElement } from './element';
+export { Table } from './table';
+export { TableRow } from './tableRow';
+export { TableColumn } from './tableColumn';
+export { convertGenericElementByTagName, convertHTMLElementByTagName, } from './util';

package/lib/web/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertHTMLElementByTagName = exports.convertGenericElementByTagName = exports.TableColumn = exports.TableRow = exports.Table = exports.GenericElement = exports.DOMElement = exports.Attribute = exports.Page = void 0;
+var page_1 = require("./page");
+Object.defineProperty(exports, "Page", { enumerable: true, get: function () { return page_1.Page; } });
+var attribute_1 = require("./attribute");
+Object.defineProperty(exports, "Attribute", { enumerable: true, get: function () { return attribute_1.Attribute; } });
+var element_1 = require("./element");
+Object.defineProperty(exports, "DOMElement", { enumerable: true, get: function () { return element_1.DOMElement; } });
+Object.defineProperty(exports, "GenericElement", { enumerable: true, get: function () { return element_1.GenericElement; } });
+var table_1 = require("./table");
+Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return table_1.Table; } });
+var tableRow_1 = require("./tableRow");
+Object.defineProperty(exports, "TableRow", { enumerable: true, get: function () { return tableRow_1.TableRow; } });
+var tableColumn_1 = require("./tableColumn");
+Object.defineProperty(exports, "TableColumn", { enumerable: true, get: function () { return tableColumn_1.TableColumn; } });
+var util_1 = require("./util");
+Object.defineProperty(exports, "convertGenericElementByTagName", { enumerable: true, get: function () { return util_1.convertGenericElementByTagName; } });
+Object.defineProperty(exports, "convertHTMLElementByTagName", { enumerable: true, get: function () { return util_1.convertHTMLElementByTagName; } });

package/lib/web/page.d.ts

@@ -0,0 +1,22 @@
+import { AxiosResponse } from 'axios';
+import { DOMElement, GenericElement } from './element';
+export declare type PageResponseOption = {
+    kind: 'response';
+    response: AxiosResponse;
+};
+export declare type PageTextOption = {
+    kind: 'html';
+    htmlText: string;
+};
+export declare type PageOption = PageResponseOption | PageTextOption;
+export declare class Page {
+    #private;
+    constructor(option: PageOption);
+    getElementById<T extends HTMLElement>(id: string): GenericElement<T> | undefined;
+    getDOMElementsByClassName(className: string): DOMElement[];
+    getElementsByClassName<T extends HTMLElement>(className: string): GenericElement<T>[];
+    get html(): string;
+    searchByXPath(path: string): (string | number | boolean | import("./attribute").Attribute | GenericElement<HTMLElement>)[];
+    searchOneByXPath(path: string): string | number | boolean | import("./attribute").Attribute | GenericElement<HTMLElement> | undefined;
+    get title(): string | undefined;
+}

package/lib/web/page.js

@@ -0,0 +1,102 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+var _Page_response, _Page_xdoc, _Page_htmlString;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Page = void 0;
+const xmlserializer_1 = __importDefault(require("xmlserializer"));
+const xmldom_1 = __importDefault(require("xmldom"));
+// import { tmpNameSync } from 'tmp';
+// import { writeFileSync } from 'fs';
+const element_1 = require("./element");
+const parse5_1 = require("parse5");
+const xpath_1 = __importDefault(require("xpath"));
+class Page {
+    constructor(option) {
+        _Page_response.set(this, void 0);
+        //readonly #dom: JSDOM;
+        _Page_xdoc.set(this, void 0);
+        _Page_htmlString.set(this, void 0);
+        if (option.kind === 'response') {
+            __classPrivateFieldSet(this, _Page_response, option.response, "f");
+            __classPrivateFieldSet(this, _Page_htmlString, __classPrivateFieldGet(this, _Page_response, "f").data, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _Page_htmlString, option.htmlText, "f");
+        }
+        const document = (0, parse5_1.parse)(__classPrivateFieldGet(this, _Page_htmlString, "f"));
+        const xhtml = xmlserializer_1.default.serializeToString(document);
+        __classPrivateFieldSet(this, _Page_xdoc, new xmldom_1.default.DOMParser().parseFromString(xhtml), "f");
+        // this.#dom = new JSDOM(response.data as string);
+        // this.#dom.window.document.evaluate;
+    }
+    getElementById(id) {
+        const element = __classPrivateFieldGet(this, _Page_xdoc, "f").getElementById(id);
+        if (!element || !element)
+            return undefined;
+        return new element_1.GenericElement(element);
+    }
+    getDOMElementsByClassName(className) {
+        return Array.from(__classPrivateFieldGet(this, _Page_xdoc, "f").getElementsByClassName(className))
+            .filter((value) => {
+            if (!value || !value)
+                return false;
+            return true;
+        })
+            .map((e) => new element_1.DOMElement(e));
+    }
+    getElementsByClassName(className) {
+        //const elementArray = new Array<HTMLElement>();
+        return Array.from(__classPrivateFieldGet(this, _Page_xdoc, "f").getElementsByClassName(className))
+            .filter((value) => {
+            if (!value || !value)
+                return false;
+            return true;
+        })
+            .map((e) => new element_1.GenericElement(e));
+        //return elementArray;
+    }
+    get html() {
+        return __classPrivateFieldGet(this, _Page_htmlString, "f");
+    }
+    searchByXPath(path) {
+        return xpath_1.default.select(path, __classPrivateFieldGet(this, _Page_xdoc, "f")).map((v) => {
+            return element_1.DOMElement.parseXPathResultValidValue(v);
+        });
+    }
+    searchOneByXPath(path) {
+        const searchValue = xpath_1.default.select(path, __classPrivateFieldGet(this, _Page_xdoc, "f"), true);
+        return element_1.DOMElement.parseXPathResultValue(searchValue);
+    }
+    get title() {
+        let fileName;
+        if (!!__classPrivateFieldGet(this, _Page_response, "f")) {
+            if ('Content-Disposition' in __classPrivateFieldGet(this, _Page_response, "f").headers) {
+                const headerValue = __classPrivateFieldGet(this, _Page_response, "f").headers['Content-Disposition'];
+                fileName = decodeURI(headerValue.substring(headerValue.indexOf('filename=') + 9));
+            }
+        }
+        if (!fileName) {
+            const titleElements = __classPrivateFieldGet(this, _Page_xdoc, "f").getElementsByTagName('title');
+            if (titleElements.length > 0) {
+                const titleElement = titleElements.item(0);
+                fileName = titleElement.innerText;
+            }
+        }
+        return fileName;
+    }
+}
+exports.Page = Page;
+_Page_response = new WeakMap(), _Page_xdoc = new WeakMap(), _Page_htmlString = new WeakMap();

package/lib/web/table.d.ts

@@ -0,0 +1,15 @@
+import { GenericElement } from './element';
+import { TableRow } from './tableRow';
+export declare type TableOption = {
+    headerExist: boolean;
+};
+export declare class Table extends GenericElement<HTMLTableElement> {
+    #private;
+    constructor(node: HTMLTableElement, { headerExist }?: TableOption);
+    __headers: TableRow[];
+    __records: TableRow[];
+    get rows(): TableRow[];
+    toDictionaryArray(): {
+        [key: string]: string;
+    }[];
+}