@bratel/dgit 0.0.13 → 0.0.14

package/lib/cmd/utils.d.ts

@@ -1,8 +1,8 @@
-import { PackageInfo, GithubLinkInfo } from './type';
-export declare const GetPackageInfo: () => PackageInfo;
+import type { GithubLinkInfo, PackageInfo } from './type';
+export declare function GetPackageInfo(): PackageInfo;
 export declare const GITHUB_ADDRESS = "https://github.com/";
 export declare const isHttpsLink: (link: string) => boolean;
-export declare const ParseGithubHttpsLink: (httpsLink: string) => GithubLinkInfo;
+export declare function ParseGithubHttpsLink(httpsLink: string): GithubLinkInfo;
 export declare const TextEllipsis: (text: string, maxLen: number) => string;
-export declare const MakeDirs: (dirs: string) => void;
-export declare const AddExtraRandomQs: (origin: string) => string;
+export declare function MakeDirs(dirs: string): void;
+export declare function AddExtraRandomQs(origin: string): string;

package/lib/cmd/utils.js

@@ -1,16 +1,21 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AddExtraRandomQs = exports.MakeDirs = exports.TextEllipsis = exports.ParseGithubHttpsLink = exports.isHttpsLink = exports.GITHUB_ADDRESS = exports.GetPackageInfo = void 0;
+exports.TextEllipsis = exports.isHttpsLink = exports.GITHUB_ADDRESS = void 0;
+exports.GetPackageInfo = GetPackageInfo;
+exports.ParseGithubHttpsLink = ParseGithubHttpsLink;
+exports.MakeDirs = MakeDirs;
+exports.AddExtraRandomQs = AddExtraRandomQs;
 const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
-exports.GetPackageInfo = () => {
-    const buffer = fs_1.default.readFileSync(path_1.default.resolve(__dirname, '../../package.json'));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+function GetPackageInfo() {
+    const buffer = node_fs_1.default.readFileSync(node_path_1.default.resolve(__dirname, '../../package.json'));
     return JSON.parse(buffer.toString());
-};
+}
 exports.GITHUB_ADDRESS = 'https://github.com/';
-exports.isHttpsLink = (link) => link.trim().startsWith(exports.GITHUB_ADDRESS);
-exports.ParseGithubHttpsLink = (httpsLink) => {
+const isHttpsLink = (link) => link.trim().startsWith(exports.GITHUB_ADDRESS);
+exports.isHttpsLink = isHttpsLink;
+function ParseGithubHttpsLink(httpsLink) {
     let nextLink = httpsLink.trim().slice(exports.GITHUB_ADDRESS.length);
     let index = nextLink.indexOf('/');
     if (index === -1)
@@ -62,26 +67,27 @@ exports.ParseGithubHttpsLink = (httpsLink) => {
         relativePath,
         type,
     };
-};
-exports.TextEllipsis = (text, maxLen) => (text.length >= maxLen ? `${text.slice(0, maxLen)}...` : text);
-exports.MakeDirs = (dirs) => {
+}
+const TextEllipsis = (text, maxLen) => (text.length >= maxLen ? `${text.slice(0, maxLen)}...` : text);
+exports.TextEllipsis = TextEllipsis;
+function MakeDirs(dirs) {
     const mkdirs = (dir, callback) => {
-        if (fs_1.default.existsSync(dir)) {
+        if (node_fs_1.default.existsSync(dir)) {
             callback && callback();
             return;
         }
-        mkdirs(path_1.default.dirname(dir), () => {
-            fs_1.default.mkdirSync(dir);
+        mkdirs(node_path_1.default.dirname(dir), () => {
+            node_fs_1.default.mkdirSync(dir);
             callback && callback();
         });
     };
-    if (fs_1.default.existsSync(dirs))
+    if (node_fs_1.default.existsSync(dirs))
         return;
     mkdirs(dirs);
-};
-exports.AddExtraRandomQs = (origin) => {
-    if (origin.indexOf('?') !== -1) {
+}
+function AddExtraRandomQs(origin) {
+    if (origin.includes('?')) {
         return `${origin}&_t=${Math.random()}`;
     }
     return `${origin}?_t=${Math.random()}`;
-};
+}

package/lib/dgit.d.ts

@@ -1,3 +1,3 @@
-import { DgitGlobalOption, RepoOptionType, DgitLifeCycle, DgitLoadGitTree } from './type';
-declare const dgit: (repoOption: RepoOptionType, dPath: string, dgitOptions?: DgitGlobalOption | undefined, hooks?: (DgitLifeCycle & DgitLoadGitTree) | undefined) => Promise<void>;
+import type { DgitGlobalOption, DgitLifeCycle, DgitLoadGitTree, RepoOptionType } from './type';
+declare function dgit(repoOption: RepoOptionType, dPath: string, dgitOptions?: DgitGlobalOption, hooks?: DgitLifeCycle & DgitLoadGitTree): Promise<void>;
 export default dgit;

package/lib/dgit.js

@@ -1,179 +1,184 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const fs_1 = tslib_1.__importDefault(require("fs"));
-const path_1 = tslib_1.__importDefault(require("path"));
+const node_fs_1 = tslib_1.__importDefault(require("node:fs"));
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const node_process_1 = tslib_1.__importDefault(require("node:process"));
 const async_1 = tslib_1.__importDefault(require("async"));
-const repo_1 = tslib_1.__importDefault(require("./repo"));
+const utils_1 = require("./cmd/utils");
 const log_1 = require("./log");
+const repo_1 = tslib_1.__importDefault(require("./repo"));
 const request_1 = require("./request");
-const utils_1 = require("./cmd/utils");
 const UserAgent = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/142.0.0.0 Safari/537.36';
 const DEFAULT_PARALLEL_LIMIT = 10;
 const MAX_PARALLEL_LIMIT = 100;
 const JSON_STRINGIFY_PADDING = 2;
-const dgit = (repoOption, dPath, dgitOptions, hooks) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-    const { username, password, token, githubLink, proxy = '', } = repoOption;
-    let { owner, repoName, ref = 'master', relativePath = '.', } = repoOption;
-    if (githubLink && utils_1.isHttpsLink(githubLink)) {
-        const parseResult = utils_1.ParseGithubHttpsLink(githubLink);
-        owner = parseResult.owner;
-        repoName = parseResult.repoName;
-        ref = parseResult.ref;
-        relativePath = parseResult.relativePath;
-    }
-    if (!owner || !repoName) {
-        throw new Error('invalid repo option.');
-    }
-    const logger = log_1.createLogger(dgitOptions);
-    const { exclude = [], include = [] } = dgitOptions || {};
-    let { parallelLimit = DEFAULT_PARALLEL_LIMIT } = dgitOptions || {};
-    if (!parallelLimit || parallelLimit <= 0) {
-        logger('parallelLimit value is invalid.');
-        parallelLimit = DEFAULT_PARALLEL_LIMIT;
-    }
-    parallelLimit > MAX_PARALLEL_LIMIT && (parallelLimit = MAX_PARALLEL_LIMIT);
-    const { onSuccess, onError, onProgress, onFinish, onRetry, onResolved, beforeLoadTree, afterLoadTree, } = hooks || {};
-    let onSuccessResolve = () => { };
-    let onErrorReject = () => { };
-    const prom = new Promise((resolve, reject) => {
-        onSuccessResolve = resolve;
-        onErrorReject = reject;
-    });
-    const { getRepoTreeUrl, getDownloadUrl } = repo_1.default(owner, repoName, ref, proxy);
-    const url = getRepoTreeUrl();
-    const headers = {
-        'User-Agent': UserAgent,
-        Authorization: token ? `token ${token}` : undefined,
-    };
-    const auth = username && password ?
-        {
-            user: username,
-            pass: password,
-            sendImmediately: true,
-        } :
-        undefined;
-    const options = {
-        url, headers, auth,
-    };
-    const destPath = path_1.default.isAbsolute(dPath) ? dPath : path_1.default.resolve(process.cwd(), dPath);
-    logger(' request repo tree options.');
-    logger(JSON.stringify(options, null, JSON_STRINGIFY_PADDING));
-    try {
-        logger(' loading remote repo tree...');
-        beforeLoadTree && beforeLoadTree();
-        const body = yield request_1.requestGetPromise(options, dgitOptions || {}, {
-            onRetry() {
-                logger(` request ${url} failed. Retrying...`);
-                onRetry && onRetry();
-            },
-        });
-        logger(' loading remote repo tree succeed.');
-        afterLoadTree && afterLoadTree();
-        const result = JSON.parse(body);
-        if (!result.tree || result.tree.length <= 0) {
-            throw new Error('404 repo not found!');
+function dgit(repoOption, dPath, dgitOptions, hooks) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        const { username, password, token, githubLink, proxy = '', } = repoOption;
+        let { owner, repoName, ref = 'master', relativePath = '.', } = repoOption;
+        if (githubLink && (0, utils_1.isHttpsLink)(githubLink)) {
+            const parseResult = (0, utils_1.ParseGithubHttpsLink)(githubLink);
+            owner = parseResult.owner;
+            repoName = parseResult.repoName;
+            ref = parseResult.ref;
+            relativePath = parseResult.relativePath;
+        }
+        if (!owner || !repoName) {
+            throw new Error('invalid repo option.');
+        }
+        const logger = (0, log_1.createLogger)(dgitOptions);
+        const { exclude = [], include = [] } = dgitOptions || {};
+        let { parallelLimit = DEFAULT_PARALLEL_LIMIT } = dgitOptions || {};
+        if (!parallelLimit || parallelLimit <= 0) {
+            logger('parallelLimit value is invalid.');
+            parallelLimit = DEFAULT_PARALLEL_LIMIT;
         }
-        const treeNodeList = result.tree;
-        const includeTreeNodeList = treeNodeList.filter(node => {
-            const nPath = path_1.default.resolve(__dirname, node.path);
-            const rPath = path_1.default.resolve(__dirname, relativePath);
-            if (!nPath.startsWith(rPath) || node.type !== 'blob') {
-                return false;
+        parallelLimit > MAX_PARALLEL_LIMIT && (parallelLimit = MAX_PARALLEL_LIMIT);
+        const { onSuccess, onError, onProgress, onFinish, onRetry, onResolved, beforeLoadTree, afterLoadTree, } = hooks || {};
+        let onSuccessResolve = () => { };
+        let onErrorReject = () => { };
+        const prom = new Promise((resolve, reject) => {
+            onSuccessResolve = resolve;
+            onErrorReject = reject;
+        });
+        const { getRepoTreeUrl, getDownloadUrl } = (0, repo_1.default)(owner, repoName, ref, proxy);
+        const url = getRepoTreeUrl();
+        const headers = {
+            'User-Agent': UserAgent,
+            'Authorization': token ? `token ${token}` : undefined,
+        };
+        const auth = username && password
+            ? {
+                user: username,
+                pass: password,
+                sendImmediately: true,
             }
-            if (exclude.some(v => nPath.startsWith(path_1.default.resolve(rPath, v))) &&
-                include.every(v => !nPath.startsWith(path_1.default.resolve(rPath, v)))) {
-                return false;
+            : undefined;
+        const options = {
+            url,
+            headers,
+            auth,
+        };
+        const destPath = node_path_1.default.isAbsolute(dPath) ? dPath : node_path_1.default.resolve(node_process_1.default.cwd(), dPath);
+        logger(' request repo tree options.');
+        logger(JSON.stringify(options, null, JSON_STRINGIFY_PADDING));
+        try {
+            logger(' loading remote repo tree...');
+            beforeLoadTree && beforeLoadTree();
+            const body = yield (0, request_1.requestGetPromise)(options, dgitOptions || {}, {
+                onRetry() {
+                    logger(` request ${url} failed. Retrying...`);
+                    onRetry && onRetry();
+                },
+            });
+            logger(' loading remote repo tree succeed.');
+            afterLoadTree && afterLoadTree();
+            const result = JSON.parse(body);
+            if (!result.tree || result.tree.length <= 0) {
+                throw new Error('404 repo not found!');
             }
-            return true;
-        });
-        if (includeTreeNodeList.length <= 0) {
-            throw new Error(`404 repo ${relativePath} not found!`);
-        }
-        const totalStatus = includeTreeNodeList.reduce((prev, cur) => {
-            if (cur.type === 'blob') {
-                prev.size += cur.size;
-                prev.count++;
+            const treeNodeList = result.tree;
+            const includeTreeNodeList = treeNodeList.filter((node) => {
+                const nPath = node_path_1.default.resolve(__dirname, node.path);
+                const rPath = node_path_1.default.resolve(__dirname, relativePath);
+                if (!nPath.startsWith(rPath) || node.type !== 'blob') {
+                    return false;
+                }
+                if (exclude.some(v => nPath.startsWith(node_path_1.default.resolve(rPath, v)))
+                    && include.every(v => !nPath.startsWith(node_path_1.default.resolve(rPath, v)))) {
+                    return false;
+                }
+                return true;
+            });
+            if (includeTreeNodeList.length <= 0) {
+                throw new Error(`404 repo ${relativePath} not found!`);
             }
-            return prev;
-        }, { size: 0, count: 0 });
-        let currentSize = 0;
-        let currentCount = 0;
-        onResolved &&
-            onResolved({
+            const totalStatus = includeTreeNodeList.reduce((prev, cur) => {
+                if (cur.type === 'blob') {
+                    prev.size += cur.size;
+                    prev.count++;
+                }
+                return prev;
+            }, { size: 0, count: 0 });
+            let currentSize = 0;
+            let currentCount = 0;
+            onResolved
+                && onResolved({
+                    currentSize,
+                    currentCount,
+                    totalSize: totalStatus.size,
+                    totalCount: totalStatus.count,
+                });
+            logger(' include files resolved.');
+            logger('', JSON.stringify({
                 currentSize,
                 currentCount,
                 totalSize: totalStatus.size,
                 totalCount: totalStatus.count,
-            });
-        logger(' include files resolved.');
-        logger('', JSON.stringify({
-            currentSize,
-            currentCount,
-            totalSize: totalStatus.size,
-            totalCount: totalStatus.count,
-        }));
-        async_1.default.eachLimit(includeTreeNodeList, parallelLimit, (node, callback) => {
-            const downloadUrl = getDownloadUrl(node.path);
-            const rPath = path_1.default.resolve(destPath, relativePath);
-            const tPath = path_1.default.resolve(destPath, node.path);
-            const root = path_1.default.resolve(destPath, '.');
-            let targetPath;
-            if (rPath === tPath) {
-                targetPath = path_1.default.resolve(destPath, path_1.default.basename(tPath));
-            }
-            else {
-                targetPath = tPath.replace(rPath, root);
-            }
-            logger('', node.path, relativePath, targetPath);
-            if (!fs_1.default.existsSync(path_1.default.dirname(targetPath))) {
-                utils_1.MakeDirs(path_1.default.dirname(targetPath));
-            }
-            const ws = fs_1.default.createWriteStream(targetPath);
-            logger(` downloading from ${downloadUrl}...`);
-            request_1.requestOnStream(downloadUrl, ws, dgitOptions || {}, {
-                onSuccess() {
-                    currentCount++;
-                    currentSize += node.size;
-                    logger(` write file ${node.path} succeed. 
+            }));
+            async_1.default.eachLimit(includeTreeNodeList, parallelLimit, (node, callback) => {
+                const downloadUrl = getDownloadUrl(node.path);
+                const rPath = node_path_1.default.resolve(destPath, relativePath);
+                const tPath = node_path_1.default.resolve(destPath, node.path);
+                const root = node_path_1.default.resolve(destPath, '.');
+                let targetPath;
+                if (rPath === tPath) {
+                    targetPath = node_path_1.default.resolve(destPath, node_path_1.default.basename(tPath));
+                }
+                else {
+                    targetPath = tPath.replace(rPath, root);
+                }
+                logger('', node.path, relativePath, targetPath);
+                if (!node_fs_1.default.existsSync(node_path_1.default.dirname(targetPath))) {
+                    (0, utils_1.MakeDirs)(node_path_1.default.dirname(targetPath));
+                }
+                const ws = node_fs_1.default.createWriteStream(targetPath);
+                logger(` downloading from ${downloadUrl}...`);
+                (0, request_1.requestOnStream)(downloadUrl, ws, dgitOptions || {}, {
+                    onSuccess() {
+                        currentCount++;
+                        currentSize += node.size;
+                        logger(` write file ${node.path} succeed. 
                             size: [${currentSize}/${totalStatus.size}], 
                             count: [${currentCount}/${totalStatus.count}]`);
-                    onProgress &&
-                        onProgress({
-                            totalCount: totalStatus.count,
-                            totalSize: totalStatus.size,
-                            currentSize,
-                            currentCount,
-                        }, node);
-                    callback();
-                },
-                onError(err) {
-                    logger('', err);
-                    callback(new Error(` request ${downloadUrl} failed.`));
-                },
-                onRetry() {
-                    logger(` request ${downloadUrl} failed. Retrying...`);
-                    onRetry && onRetry();
-                },
+                        onProgress
+                            && onProgress({
+                                totalCount: totalStatus.count,
+                                totalSize: totalStatus.size,
+                                currentSize,
+                                currentCount,
+                            }, node);
+                        callback();
+                    },
+                    onError(err) {
+                        logger('', err);
+                        callback(new Error(` request ${downloadUrl} failed.`));
+                    },
+                    onRetry() {
+                        logger(` request ${downloadUrl} failed. Retrying...`);
+                        onRetry && onRetry();
+                    },
+                });
+            }, (err) => {
+                if (err) {
+                    onError && onError(err);
+                    onFinish && onFinish();
+                    onErrorReject(err);
+                }
+                else {
+                    onSuccess && onSuccess();
+                    onFinish && onFinish();
+                    onSuccessResolve();
+                }
             });
-        }, err => {
-            if (err) {
-                onError && onError(err);
-                onFinish && onFinish();
-                onErrorReject(err);
-            }
-            else {
-                onSuccess && onSuccess();
-                onFinish && onFinish();
-                onSuccessResolve();
-            }
-        });
-    }
-    catch (error) {
-        onError && onError(error);
-        onFinish && onFinish();
-        onErrorReject(error);
-    }
-    return prom;
-});
+        }
+        catch (error) {
+            onError && onError(error);
+            onFinish && onFinish();
+            onErrorReject(error);
+        }
+        return prom;
+    });
+}
 exports.default = dgit;

package/lib/log.d.ts

@@ -1,2 +1,2 @@
-import { DgitGlobalOption } from './type';
-export declare const createLogger: (option?: DgitGlobalOption | undefined) => (...message: any[]) => void;
+import type { DgitGlobalOption } from './type';
+export declare function createLogger(option?: DgitGlobalOption): (...message: any[]) => void;

package/lib/log.js

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createLogger = void 0;
+exports.createLogger = createLogger;
 const DEFAULT_PREFIX = '[dgit-logger]';
-exports.createLogger = (option) => (...message) => {
-    if (option && option.log) {
-        const prefix = option ?
-            option.logPrefix || DEFAULT_PREFIX :
-            DEFAULT_PREFIX;
-        console.log(prefix, ...message, '\n');
-    }
-};
+function createLogger(option) {
+    return (...message) => {
+        if (option && option.log) {
+            const prefix = option
+                ? option.logPrefix || DEFAULT_PREFIX
+                : DEFAULT_PREFIX;
+            console.log(prefix, ...message, '\n');
+        }
+    };
+}

package/lib/repo.d.ts

@@ -1,4 +1,4 @@
-declare const repoUtils: (owner: string, repoName: string, ref: string, proxy: string) => {
+declare function repoUtils(owner: string, repoName: string, ref: string, proxy: string): {
     getRepoTreeUrl: () => string;
     getDownloadUrl: (path: string) => string;
 };

package/lib/repo.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const repoUtils = (owner, repoName, ref, proxy) => ({
-    getRepoTreeUrl: () => `https://api.github.com/repos/${owner}/${repoName}/git/trees/${ref}?recursive=1`,
-    getDownloadUrl: (path) => `${proxy ? `${proxy}/` : ''}https://raw.githubusercontent.com/${owner}/${repoName}/${ref}/${path}`,
-});
+function repoUtils(owner, repoName, ref, proxy) {
+    return {
+        getRepoTreeUrl: () => `https://api.github.com/repos/${owner}/${repoName}/git/trees/${ref}?recursive=1`,
+        getDownloadUrl: (path) => `${proxy ? `${proxy}/` : ''}https://raw.githubusercontent.com/${owner}/${repoName}/${ref}/${path}`,
+    };
+}
 exports.default = repoUtils;

package/lib/request.d.ts

@@ -1,7 +1,7 @@
-import fs from 'fs';
-import { UrlOptions, CoreOptions } from 'request';
-import { DgitGlobalOption, DgitLifeCycle } from './type';
-declare type RequestOption = UrlOptions & CoreOptions;
-export declare const requestGetPromise: (options: RequestOption, dgitOptions: DgitGlobalOption, hooks?: DgitLifeCycle | undefined) => Promise<any>;
-export declare const requestOnStream: (url: string, ws: fs.WriteStream, dgitOptions: DgitGlobalOption, hooks?: DgitLifeCycle | undefined) => void;
+import type fs from 'node:fs';
+import type { CoreOptions, UrlOptions } from 'request';
+import type { DgitGlobalOption, DgitLifeCycle } from './type';
+type RequestOption = UrlOptions & CoreOptions;
+export declare function requestGetPromise(options: RequestOption, dgitOptions: DgitGlobalOption, hooks?: DgitLifeCycle): Promise<any>;
+export declare function requestOnStream(url: string, ws: fs.WriteStream, dgitOptions: DgitGlobalOption, hooks?: DgitLifeCycle): void;
 export {};

package/lib/request.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestOnStream = exports.requestGetPromise = void 0;
+exports.requestGetPromise = requestGetPromise;
+exports.requestOnStream = requestOnStream;
 const tslib_1 = require("tslib");
 const request_1 = tslib_1.__importDefault(require("request"));
 const utils_1 = require("./cmd/utils");
 const log_1 = require("./log");
 const REQUEST_RETRY_DELAY = 1500;
 const DEFAULT_MAX_RETRY_COUNT = 5;
-const requestGet = (options, maxRetryCount, hooks) => {
+function requestGet(options, maxRetryCount, hooks) {
     const { onSuccess, onError, onFinish, onRetry, } = hooks || {};
     request_1.default.get(options, (err, _, body) => {
         if (err) {
@@ -25,33 +26,35 @@ const requestGet = (options, maxRetryCount, hooks) => {
         onSuccess && onSuccess(body);
         onFinish && onFinish();
     });
-};
-exports.requestGetPromise = (options, dgitOptions, hooks) => new Promise((resolve, reject) => {
-    const { maxRetryCount = DEFAULT_MAX_RETRY_COUNT } = dgitOptions;
-    const { onSuccess, onError, onFinish, onRetry, } = hooks || {};
-    const newHooks = {
-        onSuccess(data) {
-            resolve(data);
-            onSuccess && onSuccess(data);
-        },
-        onError(err) {
-            reject(err);
-            onError && onError(err);
-        },
-        onFinish,
-        onRetry,
-    };
-    requestGet(options, maxRetryCount, newHooks);
-});
-exports.requestOnStream = (url, ws, dgitOptions, hooks) => {
+}
+function requestGetPromise(options, dgitOptions, hooks) {
+    return new Promise((resolve, reject) => {
+        const { maxRetryCount = DEFAULT_MAX_RETRY_COUNT } = dgitOptions;
+        const { onSuccess, onError, onFinish, onRetry, } = hooks || {};
+        const newHooks = {
+            onSuccess(data) {
+                resolve(data);
+                onSuccess && onSuccess(data);
+            },
+            onError(err) {
+                reject(err);
+                onError && onError(err);
+            },
+            onFinish,
+            onRetry,
+        };
+        requestGet(options, maxRetryCount, newHooks);
+    });
+}
+function requestOnStream(url, ws, dgitOptions, hooks) {
     const { maxRetryCount = DEFAULT_MAX_RETRY_COUNT } = dgitOptions;
-    const logger = log_1.createLogger(dgitOptions);
+    const logger = (0, log_1.createLogger)(dgitOptions);
     const { onSuccess, onError, onFinish, onRetry, } = hooks || {};
     const fn = (retryCount) => {
-        const downloadUrl = utils_1.AddExtraRandomQs(url);
+        const downloadUrl = (0, utils_1.AddExtraRandomQs)(url);
         logger(` dowloading from ${downloadUrl}...`);
-        request_1.default(encodeURI(downloadUrl))
-            .on('error', err => {
+        (0, request_1.default)(encodeURI(downloadUrl))
+            .on('error', (err) => {
             if (retryCount <= 0) {
                 onError && onError(err);
                 onFinish && onFinish();
@@ -72,4 +75,4 @@ exports.requestOnStream = (url, ws, dgitOptions, hooks) => {
         logger(` ${url}, write stream failed.`);
     });
     fn(maxRetryCount);
-};
+}

package/lib/type.d.ts

@@ -1,4 +1,4 @@
-export declare type GithubRelativePath = string;
+export type GithubRelativePath = string;
 export interface DgitGlobalOption {
     maxRetryCount?: number;
     parallelLimit?: number;