@e-mc/watch 0.0.1

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2023 An Pham
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,5 @@
+### @e-mc/watch
+
+### LICENSE
+
+BSD 3-Clause

package/filegroup/index.d.ts

@@ -0,0 +1,6 @@
+import type { FileGroupConstructor } from '../../types/lib/watch';
+import type { ExternalAsset } from '../../types/lib/asset';
+
+declare const FileGroup: FileGroupConstructor<ExternalAsset>;
+
+export = FileGroup;

package/filegroup/index.js

@@ -0,0 +1,181 @@
+"use strict";
+var _a, _b, _c, _d;
+Object.defineProperty(exports, "__esModule", { value: true });
+const types_1 = require("../../types");
+const core_1 = require("../../core");
+const kPaused = Symbol('paused');
+const kServer = Symbol('server');
+const kEtag = Symbol('etag');
+const kLastModified = Symbol('lastModified');
+class SocketRequest {
+    constructor(expires, socketId, id = '') {
+        this.expires = expires;
+        this.socketId = socketId;
+        this.id = id;
+    }
+    get expired() {
+        const expires = this.expires;
+        return expires > 0 && expires !== Infinity && Date.now() > expires;
+    }
+}
+class FileGroup extends core_1.AbortComponent {
+    static checkTimeout(client) {
+        if (client.readyState === 1) {
+            const lastTime = FileGroup.CLIENT_SESSION.get(client);
+            if (!lastTime) {
+                FileGroup.CLIENT_SESSION.set(client, Date.now());
+            }
+            else if (FileGroup.CONNECTION_TIMEOUT > 0 && lastTime + FileGroup.CONNECTION_TIMEOUT <= Date.now()) {
+                client.terminate();
+                return false;
+            }
+            return true;
+        }
+        return false;
+    }
+    static cloneAsset(file) {
+        return (0, types_1.cloneObject)(file, (0, types_1.isPlainObject)(file.watch) && (0, types_1.isArray)(file.watch.assets) ? new WeakSet([file.watch.assets]) : true);
+    }
+    constructor(uri, assets, startTime, abortable) {
+        super();
+        this.uri = uri;
+        this.assets = assets;
+        this.captured = false;
+        this.port = NaN;
+        this.secure = false;
+        this.hot = false;
+        this.always = false;
+        this.sockets = [];
+        this._related = [];
+        this._abortable = false;
+        this[_a] = null;
+        this[_b] = false;
+        this[_c] = '';
+        this[_d] = '';
+        if (typeof startTime === 'boolean') {
+            abortable = startTime;
+            startTime = undefined;
+        }
+        if (typeof abortable === 'boolean') {
+            this._abortable = abortable;
+        }
+        this.startTime = startTime || Date.now();
+    }
+    connection(server, port = 0, secure = false) {
+        this[kServer] = server;
+        if (port > 0) {
+            this.port = port;
+        }
+        this.secure = secure;
+    }
+    add(expires, socketId = '', id) {
+        if (expires >= 0) {
+            const previous = this.find(socketId);
+            if (!previous) {
+                this.sockets.push(new SocketRequest(expires, socketId, id));
+            }
+            else if (expires === 0 || expires > previous.expires) {
+                previous.expires = expires;
+            }
+            return true;
+        }
+        return false;
+    }
+    find(socketId) {
+        return this.sockets.find(item => item.socketId === socketId);
+    }
+    send(event, data) {
+        const server = this.server;
+        let result = false;
+        if (server && (data.socketId = this.socketId)) {
+            data.event = event;
+            data.always ?? (data.always = this.always);
+            const outgoing = JSON.stringify(data);
+            server.clients.forEach(client => {
+                if (FileGroup.checkTimeout(client)) {
+                    client.send(outgoing);
+                    result = true;
+                }
+            });
+        }
+        return result;
+    }
+    pause() {
+        this[kPaused] = true;
+    }
+    resume() {
+        this[kPaused] = false;
+    }
+    reset() {
+        super.reset();
+        this.captured = false;
+    }
+    get server() {
+        return this[kServer];
+    }
+    set related(value) {
+        this._related = value.map(item => {
+            item = FileGroup.cloneAsset(item);
+            item.flags = 1 /* ASSET_FLAG.IGNORE */;
+            return item;
+        });
+    }
+    get related() {
+        return this._related;
+    }
+    get socketId() {
+        const result = this.sockets.filter(item => item.socketId && !item.expired).map(item => item.socketId);
+        switch (result.length) {
+            case 0:
+                return '';
+            case 1:
+                return result[0];
+            default:
+                return result;
+        }
+    }
+    set etag(value) {
+        if (typeof value === 'string') {
+            this[kEtag] = value;
+        }
+    }
+    get etag() {
+        return this[kEtag];
+    }
+    set lastModified(value) {
+        if (typeof value === 'string') {
+            this[kLastModified] = value;
+        }
+    }
+    get lastModified() {
+        return this[kEtag] ? '' : this[kLastModified];
+    }
+    get expires() {
+        let result = 0;
+        for (const { expires } of this.sockets) {
+            if (expires === 0) {
+                return 0;
+            }
+            result = Math.max(expires, result);
+        }
+        return result;
+    }
+    get expired() {
+        return this.sockets.every(item => item.expired);
+    }
+    get paused() {
+        return this[kPaused];
+    }
+    get abortable() {
+        return this._abortable;
+    }
+}
+_a = kServer, _b = kPaused, _c = kEtag, _d = kLastModified;
+FileGroup.CONNECTION_TIMEOUT = 10 * 60000 /* TIME.m */;
+FileGroup.CLIENT_SESSION = new Map();
+exports.default = FileGroup;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/index.d.ts

@@ -0,0 +1,5 @@
+import type { IFileManager, WatchConstructor } from '../types/lib';
+
+declare const Watch: WatchConstructor<IFileManager>;
+
+export = Watch;

package/index.js

@@ -0,0 +1,798 @@
+"use strict";
+var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const https = require("https");
+const ws = require("ws");
+const util_1 = require("../request/util");
+const types_1 = require("../types");
+const core_1 = require("../core");
+const request_1 = require("../request");
+const filegroup_1 = require("./filegroup");
+const kInterval = Symbol('interval');
+const kPort = Symbol('port');
+const kSecurePort = Symbol('securePort');
+const kCa = Symbol('ca');
+const kTlsKey = Symbol('tlsKey');
+const kTlsCert = Symbol('tlsCert');
+const kTlsVersion = Symbol('tlsVersion');
+const kTlsPassphrase = Symbol('tlsPassphrase');
+const kTlsConfig = Symbol('tlsConfig');
+let STATE_MAP = new WeakSet();
+let HTTP_MAP = {};
+let DISK_MAP = {};
+let PORT_MAP = {};
+let SECURE_MAP = {};
+function isConnectionTimeout(err) {
+    switch (err instanceof Error && err.code) {
+        case 'ETIMEDOUT':
+        case 'ECONNRESET':
+            return true;
+        default:
+            return false;
+    }
+}
+function abortTimeout(group) {
+    group.timeout.aborted = true;
+    if (group.watcher) {
+        group.watcher.close();
+        group.watcher = null;
+    }
+}
+const getInterval = ({ watch }) => Math.max((0, types_1.isObject)(watch) && watch.interval || 0, 0);
+const formatDate = (value) => new Date(value).toLocaleString().replace(/\/20\d+, /, '@').replace(/:\d+ (AM|PM)$/, (...match) => match[1]);
+class Watch extends core_1.Client {
+    static createServer(port, secure, active) {
+        if (typeof secure === 'boolean') {
+            active = secure;
+            secure = null;
+        }
+        let wss;
+        try {
+            if ((0, types_1.isPlainObject)(secure)) {
+                if (!(wss = SECURE_MAP[port])) {
+                    const { ca, passphrase, version, config } = secure;
+                    let { key, cert } = secure;
+                    if (key && cert && (key = request_1.default.readTLSKey(key, true)) && (cert = request_1.default.readTLSKey(cert, true))) {
+                        const server = https.createServer({
+                            ...config,
+                            ca: ca && request_1.default.readCACert(ca, true) || undefined,
+                            key: passphrase ? [{ pem: key, passphrase }] : key,
+                            cert,
+                            minVersion: version || config?.minVersion
+                        });
+                        server.listen(port);
+                        wss = new ws.Server({ server });
+                        SECURE_MAP[port] = wss;
+                        if (active) {
+                            STATE_MAP.add(wss);
+                        }
+                    }
+                    else {
+                        this.writeFail('TLS/SSL key and cert not found', (0, types_1.errorMessage)('ws', 'Missing TLS/SSL credentials'));
+                    }
+                }
+                else {
+                    return wss;
+                }
+            }
+            else if (!(wss = PORT_MAP[port])) {
+                wss = new ws.Server({ port });
+                PORT_MAP[port] = wss;
+                if (active) {
+                    STATE_MAP.add(wss);
+                }
+            }
+            else {
+                return wss;
+            }
+        }
+        catch (err) {
+            this.writeFail("Unknown" /* ERR_MESSAGE.UNKNOWN */, err);
+        }
+        if (wss) {
+            wss.on('connection', function (socket) {
+                socket.on('message', function () {
+                    filegroup_1.default.CLIENT_SESSION.delete(this);
+                });
+                socket.on('close', function () {
+                    filegroup_1.default.CLIENT_SESSION.delete(this);
+                });
+                this.clients.forEach(client => filegroup_1.default.checkTimeout(client));
+            });
+            wss.on('error', function (err) {
+                const data = JSON.stringify({ event: types_1.WATCH_EVENT.ERROR, errors: [err.message] });
+                this.clients.forEach(client => filegroup_1.default.checkTimeout(client) && client.send(data));
+            });
+            wss.on('close', function () {
+                this.clients.forEach(client => client.terminate());
+            });
+            return wss;
+        }
+    }
+    static shutdown() {
+        for (const item of [HTTP_MAP, DISK_MAP]) {
+            for (const uri in item) {
+                for (const group of item[uri].values()) {
+                    abortTimeout(group);
+                }
+            }
+        }
+        for (const item of [PORT_MAP, SECURE_MAP]) {
+            for (const port in item) {
+                item[port].close(err => err && this.writeFail([`Unable to shutdown ${item === PORT_MAP ? 'WS' : 'WSS'} server`, 'port: ' + port], err));
+            }
+        }
+        filegroup_1.default.CLIENT_SESSION.clear();
+        HTTP_MAP = {};
+        DISK_MAP = {};
+        PORT_MAP = {};
+        SECURE_MAP = {};
+        STATE_MAP = new WeakSet();
+    }
+    static checkTimeout(client) {
+        return filegroup_1.default.checkTimeout(client);
+    }
+    static setTimeout(value) {
+        if ((value = (0, types_1.parseTime)(value)) > 0) {
+            filegroup_1.default.CONNECTION_TIMEOUT = Math.min(value, core_1.Client.MAX_TIMEOUT);
+        }
+    }
+    constructor(data, port, securePort, extensions) {
+        super(data);
+        this.connectTimeout = Watch.PROCESS_TIMEOUT;
+        this._moduleName = 'watch';
+        this._assets = [];
+        this._extensions = [];
+        this._hostEvents = [];
+        this[_a] = 500 /* HTTP.INTERVAL */;
+        this[_b] = 80 /* HTTP.PORT */;
+        this[_c] = 443 /* HTTP.PORT_SECURE */;
+        this[_d] = '';
+        this[_e] = '';
+        this[_f] = '';
+        this[_g] = '';
+        this[_h] = undefined;
+        this[_j] = undefined;
+        let interval;
+        if ((0, types_1.isPlainObject)(data)) {
+            let secure;
+            ({ interval, port, secure } = data);
+            if (secure) {
+                securePort = secure.port;
+                if (secure.cert && secure.key) {
+                    this.configureServer(secure);
+                }
+            }
+        }
+        if ((interval = (0, util_1.asInt)(interval)) > 0) {
+            this.interval = interval;
+        }
+        if ((port = (0, util_1.asInt)(port)) > 0) {
+            this.port = port;
+        }
+        if ((securePort = (0, util_1.asInt)(securePort)) > 0) {
+            this.securePort = securePort;
+        }
+        if ((0, types_1.isArray)(extensions)) {
+            this.module.extensions = extensions;
+        }
+    }
+    start(assets, permission) {
+        var _k;
+        if (this.aborted) {
+            return;
+        }
+        if (permission) {
+            this.permission = permission;
+        }
+        const destMap = Object.create(null);
+        const startTime = Date.now();
+        for (const item of assets) {
+            if ((0, types_1.ignoreFlag)(item.flags)) {
+                continue;
+            }
+            const { bundleId, uri, localUri } = item;
+            if (!(0, types_1.isEmpty)(bundleId)) {
+                (destMap[_k = ':' + bundleId] || (destMap[_k] = [])).push(item);
+            }
+            else if (uri && localUri) {
+                (destMap[localUri] || (destMap[localUri] = [])).push(item);
+            }
+        }
+        for (let dest in destMap) {
+            const items = destMap[dest];
+            if (!items.some(item => item.watch)) {
+                continue;
+            }
+            let watchInterval, bundleMain;
+            if (dest[0] === ':') {
+                items.sort((a, b) => a.bundleIndex - b.bundleIndex);
+                bundleMain = items[0];
+                dest = bundleMain.localUri;
+                const leading = items.find(item => getInterval(item) > 0);
+                if (leading) {
+                    watchInterval = getInterval(leading);
+                }
+            }
+            const related = [];
+            for (let i = 0, length = items.length; i < length; ++i) {
+                const watch = items[i].watch;
+                if ((0, types_1.isObject)(watch) && watch.assets) {
+                    watch.assets.forEach(other => {
+                        if (items.includes(other)) {
+                            return;
+                        }
+                        if ((0, types_1.watchFlag)(other.flags)) {
+                            if (!other.watch) {
+                                other = filegroup_1.default.cloneAsset(other);
+                                other.watch = { ...watch };
+                            }
+                            other.flags &= ~1 /* ASSET_FLAG.IGNORE */;
+                            other.invalid = undefined;
+                            items.push(other);
+                        }
+                        else if (!related.includes(other)) {
+                            related.push(other);
+                        }
+                    });
+                }
+            }
+            for (const item of items) {
+                const { watch, sourceFiles } = item;
+                if (watch) {
+                    const interval = getInterval(item) || watchInterval || this.interval;
+                    const fatalError = (map, target, err) => {
+                        const uri = target.value.uri;
+                        delete map[uri];
+                        abortTimeout(target);
+                        this.writeFail(["Unable to watch file" /* ERR_MESSAGE.WATCH_FILE */, uri], err, 16 /* LOG_TYPE.WATCH */);
+                    };
+                    const watchExpired = (map, target, message = 'Expired') => {
+                        this.formatMessage(16 /* LOG_TYPE.WATCH */, 'WATCH', [message, target.startTime ? 'since ' + formatDate(target.startTime) : ''], target.uri, { titleColor: 'grey' });
+                        const data = map[target.uri];
+                        if (!data || data.size === 0) {
+                            delete map[target.uri];
+                            return true;
+                        }
+                        return false;
+                    };
+                    let expires = 0, status = 0, wss, main, id, socketId, port, secure, hot, always, watched, message;
+                    if ((0, types_1.isPlainObject)(watch)) {
+                        const reload = watch.reload;
+                        id = watch.id;
+                        if (watch.main) {
+                            main = item;
+                        }
+                        if (watch.expires) {
+                            expires = (0, types_1.parseExpires)(watch.expires, startTime);
+                        }
+                        if (reload && (socketId = reload.socketId)) {
+                            ({ port, module: hot, always } = reload);
+                            if (reload.secure) {
+                                const key = this[kTlsKey];
+                                const cert = this[kTlsCert];
+                                if (key && cert) {
+                                    wss = Watch.createServer(port || (port = this.securePort), { ca: this[kCa], key, cert, passphrase: this[kTlsPassphrase], version: this[kTlsVersion], config: this[kTlsConfig] });
+                                }
+                                secure = true;
+                            }
+                            else {
+                                wss = Watch.createServer(port || (port = this.port));
+                            }
+                            if (!wss) {
+                                this.writeFail('Unable to create WebSocket server', (0, types_1.errorMessage)(secure ? 'wss' : 'ws', "Invalid parameters" /* ERR_MESSAGE.PARAMETERS */, 'port: ' + (port || "Unknown" /* ERR_MESSAGE.UNKNOWN */)), 16 /* LOG_TYPE.WATCH */);
+                                socketId = undefined;
+                                port = undefined;
+                                secure = undefined;
+                                hot = undefined;
+                                always = undefined;
+                            }
+                        }
+                    }
+                    const watching = (uri, esm) => {
+                        const group = new filegroup_1.default(uri, main ? assets : items, startTime, this.willAbort("(watch)" /* ABORT_NAME.WATCH */));
+                        group.add(expires, socketId, id);
+                        if (main) {
+                            group.main = main;
+                        }
+                        else if (related.length) {
+                            group.related = related;
+                        }
+                        if (bundleMain) {
+                            group.bundleMain = bundleMain;
+                        }
+                        if (item.document) {
+                            group.document = item.document;
+                        }
+                        if (hot) {
+                            group.hot = true;
+                        }
+                        if (always) {
+                            group.always = true;
+                        }
+                        if (sourceFiles) {
+                            group.sourceFiles = sourceFiles.filter(file => file !== uri);
+                        }
+                        if (wss) {
+                            group.connection(wss, port, secure);
+                        }
+                        const timeout = { interval, retries: 0, aborted: false };
+                        const target = { value: group, timeout, watcher: null };
+                        const isMap = (value) => value ? value.size > 0 : false;
+                        const checkAborted = (result, current) => result?.aborted && current.abortable && current.abort();
+                        const checkPreceding = (map) => {
+                            const data = map[uri];
+                            if (!data) {
+                                return;
+                            }
+                            const current = data.get(dest)?.value;
+                            if (current && !current.expired) {
+                                let reset;
+                                if (id) {
+                                    const sockets = current.sockets;
+                                    for (let i = 0, active; i < sockets.length; ++i) {
+                                        const socket = sockets[i];
+                                        if (socket.id === id) {
+                                            if (active) {
+                                                sockets.splice(i, 1);
+                                            }
+                                            else {
+                                                reset = true;
+                                            }
+                                            break;
+                                        }
+                                        if (!socket.expired) {
+                                            active = true;
+                                        }
+                                    }
+                                }
+                                if (!reset) {
+                                    if (wss) {
+                                        const server = current.server;
+                                        if (!server) {
+                                            current.connection(wss, port, secure);
+                                        }
+                                        else if (server !== wss) {
+                                            if (wss.clients.size === 0 && !STATE_MAP.has(wss)) {
+                                                if (secure) {
+                                                    delete SECURE_MAP[port];
+                                                }
+                                                else {
+                                                    delete PORT_MAP[port];
+                                                }
+                                                wss.close();
+                                            }
+                                            message = 'Destination already watched @ ' + (current.secure ? 'wss' : 'ws') + '://hostname:' + current.port;
+                                            return 3 /* ERR.SERVER */;
+                                        }
+                                    }
+                                    const socket = socketId && current.find(socketId);
+                                    if (socket) {
+                                        socket.expires = expires;
+                                    }
+                                    else {
+                                        current.add(expires, socketId, id);
+                                    }
+                                    return 0 /* ERR.NONE */;
+                                }
+                            }
+                            data.set(dest, target);
+                            return 0 /* ERR.NONE */;
+                        };
+                        if (core_1.Client.isFile(uri, 'http/s')) {
+                            group.url = item.url;
+                            group.etag = item.etag;
+                            group.lastModified = item.lastModified;
+                            if (!group.etag && !group.lastModified) {
+                                return 1 /* ERR.ETAG */;
+                            }
+                            if ((status = checkPreceding(HTTP_MAP)) !== undefined) {
+                                return status;
+                            }
+                            const url = group.url || (group.url = new URL(uri));
+                            const request = this.host?.Request || new request_1.default();
+                            const agentTimeout = Math.max(timeout.interval * 10, this.connectTimeout);
+                            const opts = request.opts(url, { method: 'HEAD', httpVersion: 1, timeout: agentTimeout, agentTimeout });
+                            (function recurse() {
+                                let client = null;
+                                new Promise((resolve, reject) => {
+                                    client = request.open(uri, opts)
+                                        .on('response', res => {
+                                        if (group.aborted) {
+                                            return;
+                                        }
+                                        if (this.aborted) {
+                                            reject((0, types_1.createAbortError)());
+                                            return;
+                                        }
+                                        const statusCode = res.statusCode;
+                                        const valid = statusCode >= 200 /* HTTP_STATUS.OK */ && statusCode < 300 /* HTTP_STATUS.MULTIPLE_CHOICES */;
+                                        const map = HTTP_MAP[uri];
+                                        const etag = res.headers.etag;
+                                        const lastModified = res.headers['last-modified'];
+                                        if (valid && map?.size && (etag || lastModified)) {
+                                            for (const [destUrl, input] of map) {
+                                                const value = input.value;
+                                                if (value.paused) {
+                                                    continue;
+                                                }
+                                                let aborted = value.aborted;
+                                                if (!aborted) {
+                                                    if (value.expired) {
+                                                        aborted = true;
+                                                    }
+                                                    else if (value.etag) {
+                                                        if (etag) {
+                                                            if (etag !== value.etag) {
+                                                                value.etag = etag;
+                                                                this.modified(value).then(result => checkAborted(result, value));
+                                                            }
+                                                        }
+                                                    }
+                                                    else if (value.lastModified && lastModified) {
+                                                        if (lastModified !== value.lastModified) {
+                                                            value.lastModified = lastModified;
+                                                            this.modified(value).then(result => checkAborted(result, value));
+                                                        }
+                                                    }
+                                                }
+                                                if (aborted) {
+                                                    map.delete(destUrl);
+                                                    if (watchExpired(HTTP_MAP, value)) {
+                                                        abortTimeout(target);
+                                                    }
+                                                }
+                                            }
+                                        }
+                                        else {
+                                            if (isMap(map)) {
+                                                reject(valid ? (0, types_1.errorValue)('ETag not supported', uri) : (0, types_1.errorMessage)(statusCode, 'Invalid HTTP request', uri));
+                                                return;
+                                            }
+                                            watchExpired(HTTP_MAP, group);
+                                            abortTimeout(target);
+                                        }
+                                        if (client) {
+                                            client.destroy();
+                                        }
+                                        resolve();
+                                    })
+                                        .on('error', err => {
+                                        if (!timeout.aborted && !(isConnectionTimeout(err) && ++timeout.retries <= 10 /* HTTP.TIMEOUT_LIMIT */)) {
+                                            reject(err);
+                                            return;
+                                        }
+                                        resolve();
+                                    })
+                                        .on('timeout', () => {
+                                        if (!timeout.aborted && ++timeout.retries > 10 /* HTTP.TIMEOUT_LIMIT */) {
+                                            reject((0, types_1.errorMessage)(408 /* HTTP_STATUS.REQUEST_TIMEOUT */, 'HTTP request timeout'));
+                                            return;
+                                        }
+                                        resolve();
+                                    });
+                                })
+                                    .then(() => {
+                                    if (!timeout.aborted) {
+                                        const map = HTTP_MAP[uri];
+                                        if (isMap(map)) {
+                                            let ms = Watch.MAX_TIMEOUT;
+                                            for (const session of map.values()) {
+                                                ms = Math.min(session.timeout.interval, ms);
+                                            }
+                                            setTimeout(recurse.bind(this), timeout.interval = ms);
+                                        }
+                                        else {
+                                            delete HTTP_MAP[uri];
+                                        }
+                                    }
+                                })
+                                    .catch(err => {
+                                    fatalError(HTTP_MAP, target, err);
+                                    if (client) {
+                                        client.destroy();
+                                    }
+                                });
+                            }).call(this);
+                            HTTP_MAP[uri] = new Map([[dest, target]]);
+                        }
+                        else if (esm || path.isAbsolute(uri = core_1.Client.resolveFile(uri)) && this.canRead(uri, { hostPermissionOnly: !!this.host })) {
+                            if ((status = checkPreceding(DISK_MAP)) !== undefined) {
+                                return status;
+                            }
+                            let ptime = 0;
+                            target.watcher = fs.watch(uri, (event, filename) => {
+                                if (this.aborted || group.aborted) {
+                                    fatalError(DISK_MAP, target, (0, types_1.createAbortError)());
+                                    return;
+                                }
+                                const map = DISK_MAP[uri];
+                                switch (event) {
+                                    case 'change': {
+                                        if (isMap(map)) {
+                                            try {
+                                                const mtime = Math.floor(fs.statSync(uri).mtimeMs);
+                                                if (mtime > ptime) {
+                                                    for (const [key, input] of map) {
+                                                        const value = input.value;
+                                                        if (value.expired) {
+                                                            map.delete(key);
+                                                            if (watchExpired(DISK_MAP, value)) {
+                                                                abortTimeout(target);
+                                                            }
+                                                        }
+                                                        else if (value.aborted) {
+                                                            map.delete(key);
+                                                            if (map.size === 0) {
+                                                                abortTimeout(target);
+                                                            }
+                                                        }
+                                                        else {
+                                                            this.modified(value).then(result => checkAborted(result, value));
+                                                        }
+                                                    }
+                                                    ptime = mtime + 100 /* INTERNAL.WATCH_THRESHOLD */;
+                                                }
+                                                break;
+                                            }
+                                            catch (err) {
+                                                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(uri)], err, { type: 32 /* LOG_TYPE.FILE */, fatal: false });
+                                            }
+                                        }
+                                    }
+                                    case 'rename':
+                                        if (map) {
+                                            map.clear();
+                                        }
+                                        watchExpired(DISK_MAP, group, event === 'rename' ? 'File renamed: ' + filename : undefined);
+                                        abortTimeout(target);
+                                        break;
+                                }
+                            });
+                            DISK_MAP[uri] = new Map([[dest, target]]);
+                        }
+                        else {
+                            return 2 /* ERR.LOCAL_ACCESS */;
+                        }
+                        return 0 /* ERR.NONE */;
+                    };
+                    if ((0, types_1.isArray)(sourceFiles) && sourceFiles.some(file => this.canRead(file, { hostPermissionOnly: !!this.host }))) {
+                        let index = 0;
+                        for (const file of new Set(sourceFiles)) {
+                            if (index++ > 0) {
+                                watching(file, true);
+                            }
+                            else if ((status = watching(watched = file, true)) > 0) {
+                                break;
+                            }
+                        }
+                    }
+                    else if (watched = item.uri) {
+                        status = watching(watched, false);
+                    }
+                    else {
+                        continue;
+                    }
+                    if (status > 0) {
+                        if (!message) {
+                            switch (status) {
+                                case 1 /* ERR.ETAG */:
+                                    if ((0, types_1.existsFlag)(item.flags)) {
+                                        continue;
+                                    }
+                                    message = 'ETag unavailable';
+                                    break;
+                                case 2 /* ERR.LOCAL_ACCESS */:
+                                    message = 'No read permission';
+                                    break;
+                                case 3 /* ERR.SERVER */:
+                                    message = 'Server already in use';
+                                    break;
+                                default:
+                                    message = "Unknown" /* ERR_MESSAGE.UNKNOWN */;
+                                    break;
+                            }
+                        }
+                        this.formatFail((16 /* LOG_TYPE.WATCH */ | (status === 2 /* ERR.LOCAL_ACCESS */ ? 8192 /* LOG_TYPE.PERMISSION */ : 0)), 'WATCH', ["Unable to watch file" /* ERR_MESSAGE.WATCH_FILE */, path.basename(watched)], (0, types_1.errorValue)(message, watched));
+                    }
+                    else {
+                        this.formatMessage(16 /* LOG_TYPE.WATCH */, 'WATCH', ['Start', interval + 'ms ' + (expires ? formatDate(expires) : 'never')], watched, { titleColor: 'blue' });
+                    }
+                }
+            }
+        }
+    }
+    async modified(watch) {
+        this.formatMessage(16 /* LOG_TYPE.WATCH */, 'WATCH', 'File modified', watch.uri, { ...core_1.Client.LOG_STYLE_WARN });
+        const { host, assets } = this;
+        let items, sanitize = false;
+        if (watch.main) {
+            sanitize = watch.assets.length > assets.length;
+            items = sanitize ? watch.assets.map(item => filegroup_1.default.cloneAsset(item)) : assets.map(item => (0, types_1.cloneObject)(item, true));
+        }
+        else {
+            items = [];
+            if (assets.length) {
+                for (const item of watch.assets) {
+                    const asset = assets.find(other => item.id && item.id === other.id);
+                    if (!asset) {
+                        sanitize = true;
+                        break;
+                    }
+                    items.push((0, types_1.cloneObject)(item, true));
+                }
+            }
+            else {
+                sanitize = true;
+            }
+            if (sanitize) {
+                items = watch.assets.map(item => filegroup_1.default.cloneAsset(item));
+            }
+            if (watch.related.length) {
+                items.push(...watch.related);
+            }
+        }
+        if (!sanitize) {
+            items.forEach(item => item.flags |= 2 /* ASSET_FLAG.CLONE */);
+        }
+        watch.captured = false;
+        try {
+            const manager = this.whenModified?.(items, sanitize);
+            for (const callback of this.extensions) {
+                try {
+                    const listener = callback(watch, items);
+                    if (typeof listener === 'function') {
+                        if (manager) {
+                            manager.on('end', listener);
+                        }
+                        else if (!watch.aborted) {
+                            listener([], []);
+                        }
+                    }
+                }
+                catch {
+                }
+            }
+            if (manager) {
+                if (host && watch.document) {
+                    for (const { instance } of host.Document) {
+                        if (host.hasDocument(instance, watch.document)) {
+                            const result = instance.watchInit?.(watch, items, sanitize);
+                            if (result) {
+                                if ((0, types_1.isArray)(result.using)) {
+                                    manager.using(...result.using);
+                                }
+                                if (Array.isArray(result.dataSource)) {
+                                    const document = manager.find(instance.moduleName);
+                                    if (document) {
+                                        document.dataSource = result.dataSource;
+                                    }
+                                }
+                            }
+                            const listener = instance.watchModified?.(watch, items);
+                            if (typeof listener === 'function') {
+                                manager.on('end', listener);
+                            }
+                        }
+                    }
+                }
+                return await manager.start();
+            }
+        }
+        catch (err) {
+            this.writeFail(["Unknown" /* ERR_MESSAGE.UNKNOWN */, watch.url?.pathname || path.basename(watch.uri)], err);
+        }
+    }
+    configureServer({ ca, key, cert, passphrase, version, config }) {
+        if ((0, types_1.isString)(key) && (0, types_1.isString)(cert)) {
+            if (ca) {
+                this.setCA(ca);
+            }
+            if (request_1.default.isCert(key) || core_1.Client.isPath(key = path.resolve(key = key.trim())) && this.canRead(key, { ownPermissionOnly: true })) {
+                this[kTlsKey] = key.trim();
+            }
+            if (request_1.default.isCert(cert) || core_1.Client.isPath(cert = path.resolve(cert = cert.trim())) && this.canRead(cert, { ownPermissionOnly: true })) {
+                this[kTlsCert] = cert.trim();
+            }
+            if ((0, types_1.isString)(passphrase)) {
+                this[kTlsPassphrase] = passphrase;
+            }
+            if (!(0, types_1.isPlainObject)(config)) {
+                config = undefined;
+            }
+            else if (version || (version = config.minVersion)) {
+                delete config.minVersion;
+                delete config.secureProtocol;
+            }
+            switch (version) {
+                case 'TLSv1':
+                case 'TLSv1.1':
+                case 'TLSv1.2':
+                case 'TLSv1.3':
+                    break;
+                default:
+                    version = undefined;
+                    break;
+            }
+            this[kTlsConfig] = config;
+            this[kTlsVersion] = version;
+            return this.hasSecureProtocol();
+        }
+        return false;
+    }
+    setCA(value) {
+        if ((0, types_1.isString)(value) && core_1.Client.isPath(value = path.resolve(value = value.trim())) && this.canRead(value, { ownPermissionOnly: true })) {
+            this[kCa] = value;
+            return true;
+        }
+        return false;
+    }
+    setSSLKey(value) {
+        this[kTlsConfig] = { secureProtocol: 'SSLv23_method' };
+        this[kTlsVersion] = undefined;
+        return !!(this[kTlsKey] = request_1.default.readTLSKey(value, true));
+    }
+    setSSLCert(value) {
+        return !!(this[kTlsCert] = request_1.default.readTLSCert(value, true));
+    }
+    hasSecureProtocol() {
+        return !!this[kTlsKey] && !!this[kTlsCert];
+    }
+    willAbort(value) {
+        return this.host ? this.host.willAbort(value) : value === "(watch)" /* ABORT_NAME.WATCH */;
+    }
+    set host(value) {
+        super.host = value;
+        if (value && (0, types_1.isArray)(value.assets)) {
+            this.assets = value.assets;
+        }
+    }
+    get host() {
+        return this._host;
+    }
+    set assets(value) {
+        const length = value.length;
+        const items = new Array(length);
+        for (let i = 0; i < length; ++i) {
+            items[i] = Object.freeze((0, types_1.cloneObject)(value[i], true));
+        }
+        this._assets = items;
+    }
+    get assets() {
+        return this._assets;
+    }
+    set interval(value) {
+        if (value > 0) {
+            this[kInterval] = value;
+        }
+    }
+    get interval() {
+        return this[kInterval];
+    }
+    set port(value) {
+        if (value > 0) {
+            this[kPort] = value;
+        }
+    }
+    get port() {
+        return this[kPort];
+    }
+    set securePort(value) {
+        if (value > 0) {
+            this[kSecurePort] = value;
+        }
+    }
+    get securePort() {
+        return this[kSecurePort];
+    }
+}
+_a = kInterval, _b = kPort, _c = kSecurePort, _d = kCa, _e = kTlsKey, _f = kTlsCert, _g = kTlsPassphrase, _h = kTlsVersion, _j = kTlsConfig;
+Watch.PROCESS_TIMEOUT = 5 * 1000 /* TIME.S */;
+exports.default = Watch;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@e-mc/watch",
+  "version": "0.0.1",
+  "description": "Watch constructor for e-mc.",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anpham6/e-mc.git",
+    "directory": "src/watch"
+  },
+  "keywords": [
+    "squared",
+    "squared-functions"
+  ],
+  "author": "An Pham <anpham6@gmail.com>",
+  "license": "BSD 3-Clause",
+  "homepage": "https://github.com/anpham6/e-mc#readme",
+  "dependencies": {
+    "@e-mc/core": "0.0.1",
+    "@e-mc/request": "0.0.1",
+    "ws": "^8.12.1"
+  }
+}