@bratel/dgit 0.0.13 → 0.0.15

package/lib/cmd/prompt.js

@@ -1,86 +1,92 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PasswordPrompt = exports.DownloadPrompt = exports.CreatePrompt = void 0;
+exports.CreatePrompt = void 0;
+exports.DownloadPrompt = DownloadPrompt;
+exports.PasswordPrompt = PasswordPrompt;
 const tslib_1 = require("tslib");
 const inquirer_1 = tslib_1.__importDefault(require("inquirer"));
-exports.CreatePrompt = (questions) => inquirer_1.default.prompt(questions);
-exports.DownloadPrompt = (currentInfo) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
-    if (currentInfo.owner &&
-        currentInfo.repoName &&
-        currentInfo.ref &&
-        currentInfo.relativePath &&
-        currentInfo.dest)
-        return currentInfo;
-    const questions = [
-        {
-            type: 'input',
-            name: 'owner',
-            when() {
-                return !currentInfo.owner;
+const CreatePrompt = (questions) => inquirer_1.default.prompt(questions);
+exports.CreatePrompt = CreatePrompt;
+function DownloadPrompt(currentInfo) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        if (currentInfo.owner
+            && currentInfo.repoName
+            && currentInfo.ref
+            && currentInfo.relativePath
+            && currentInfo.dest) {
+            return currentInfo;
+        }
+        const questions = [
+            {
+                type: 'input',
+                name: 'owner',
+                when() {
+                    return !currentInfo.owner;
+                },
+                validate(input) {
+                    return input && input.length > 0;
+                },
+                message: 'input github ownername.',
             },
-            validate(input) {
-                return input && input.length > 0;
+            {
+                type: 'input',
+                name: 'repoName',
+                when() {
+                    return !currentInfo.repoName;
+                },
+                validate(input) {
+                    return input && input.length > 0;
+                },
+                message: 'input github repoName.',
             },
-            message: 'input github ownername.',
-        },
-        {
-            type: 'input',
-            name: 'repoName',
-            when() {
-                return !currentInfo.repoName;
-            },
-            validate(input) {
-                return input && input.length > 0;
-            },
-            message: 'input github repoName.',
-        },
-        {
-            type: 'input',
-            name: 'ref',
-            when() {
-                return !currentInfo.ref;
-            },
-            validate(input) {
-                return input && input.length > 0;
+            {
+                type: 'input',
+                name: 'ref',
+                when() {
+                    return !currentInfo.ref;
+                },
+                validate(input) {
+                    return input && input.length > 0;
+                },
+                default: 'master',
+                message: 'input github branch or commit hash or tagname.',
             },
-            'default': 'master',
-            message: 'input github branch or commit hash or tagname.',
-        },
-        {
-            type: 'input',
-            name: 'relativePath',
-            when() {
-                return !currentInfo.relativePath;
+            {
+                type: 'input',
+                name: 'relativePath',
+                when() {
+                    return !currentInfo.relativePath;
+                },
+                validate(input) {
+                    return input && input.length > 0;
+                },
+                default: '.',
+                message: 'input github relative path.',
             },
-            validate(input) {
-                return input && input.length > 0;
+            {
+                type: 'input',
+                name: 'dest',
+                when() {
+                    return !currentInfo.dest;
+                },
+                validate(input) {
+                    return input && input.length > 0;
+                },
+                default: '.',
+                message: 'input template output dest path.',
             },
-            'default': '.',
-            message: 'input github relative path.',
-        },
-        {
-            type: 'input',
-            name: 'dest',
-            when() {
-                return !currentInfo.dest;
-            },
-            validate(input) {
-                return input && input.length > 0;
-            },
-            'default': '.',
-            message: 'input template output dest path.',
-        },
-    ];
-    const answer = yield exports.CreatePrompt(questions);
-    return {
-        owner: answer.owner || currentInfo.owner,
-        dest: answer.dest || currentInfo.dest,
-        repoName: answer.repoName || currentInfo.repoName,
-        relativePath: answer.relativePath || currentInfo.relativePath,
-        ref: answer.ref || currentInfo.ref,
-    };
-});
-exports.PasswordPrompt = () => {
+        ];
+        const answer = yield (0, exports.CreatePrompt)(questions);
+        return {
+            owner: answer.owner || currentInfo.owner,
+            dest: answer.dest || currentInfo.dest,
+            repoName: answer.repoName || currentInfo.repoName,
+            relativePath: answer.relativePath || currentInfo.relativePath,
+            ref: answer.ref || currentInfo.ref,
+        };
+    });
+}
+function PasswordPrompt() {
     const question = {
         type: 'password',
         name: 'password',
@@ -89,5 +95,5 @@ exports.PasswordPrompt = () => {
         },
         message: 'input github account password.',
     };
-    return exports.CreatePrompt([question]);
-};
+    return (0, exports.CreatePrompt)([question]);
+}

package/lib/cmd/type.d.ts

@@ -17,6 +17,7 @@ export interface CommandInfo {
     log?: boolean;
     logPrefix?: string;
     proxy?: string;
+    exactMatch?: boolean;
 }
 export interface DownloadPromptInfo {
     dest: string;

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,193 @@
 "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!');
+// https://deepwiki.com/search/python-node-treepythonjula-pyt_e06e7d62-6a9a-4d4b-9e74-0a1cf32f4946?mode=fast
+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 = [], exactMatch = false } = 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);
+                let pathMatch;
+                if (exactMatch) {
+                    // 精确匹配：路径完全相等或者路径后跟分隔符
+                    pathMatch = nPath === rPath || nPath.startsWith(rPath + node_path_1.default.sep) || nPath.startsWith(`${rPath}/`);
+                }
+                else {
+                    pathMatch = nPath.startsWith(rPath);
+                }
+                if (!pathMatch || 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;