@bratel/dgit 0.0.13 → 0.0.15

package/src/request.ts

@@ -1,6 +1,7 @@
-import fs from 'fs';
-import request, { UrlOptions, CoreOptions } from 'request';
-import { DgitGlobalOption, DgitLifeCycle } from './type';
+import type fs from 'node:fs';
+import type { CoreOptions, UrlOptions } from 'request';
+import type { DgitGlobalOption, DgitLifeCycle } from './type';
+import request from 'request';
 import { AddExtraRandomQs } from './cmd/utils';
 import { createLogger } from './log';
 
@@ -9,102 +10,100 @@ type RequestOption = UrlOptions & CoreOptions;
 const REQUEST_RETRY_DELAY = 1500;
 const DEFAULT_MAX_RETRY_COUNT = 5;
 
-const requestGet = (
-    options: RequestOption,
-    maxRetryCount: number,
-    hooks?: DgitLifeCycle,
-): void => {
-    const {
-        onSuccess, onError, onFinish, onRetry,
-    } = hooks || {};
-
-    request.get(options, (err, _, body) => {
-        if (err) {
-            if (maxRetryCount < 1) {
-                onError && onError(err);
-                onFinish && onFinish();
-                return;
-            }
-            setTimeout(() => {
-                onRetry && onRetry();
-                requestGet(options, maxRetryCount - 1, hooks);
-            }, REQUEST_RETRY_DELAY);
-            return;
-        }
-
-        onSuccess && onSuccess(body);
+function requestGet(options: RequestOption, maxRetryCount: number, hooks?: DgitLifeCycle): void {
+  const {
+    onSuccess,
+    onError,
+    onFinish,
+    onRetry,
+  } = hooks || {};
+
+  request.get(options, (err, _, body) => {
+    if (err) {
+      if (maxRetryCount < 1) {
+        onError && onError(err);
         onFinish && onFinish();
-    });
-};
-
-export const requestGetPromise = (
-    options: RequestOption,
-    dgitOptions: DgitGlobalOption,
-    hooks?: DgitLifeCycle,
-): Promise<any> => new Promise((resolve, reject) => {
+        return;
+      }
+      setTimeout(() => {
+        onRetry && onRetry();
+        requestGet(options, maxRetryCount - 1, hooks);
+      }, REQUEST_RETRY_DELAY);
+      return;
+    }
+
+    onSuccess && onSuccess(body);
+    onFinish && onFinish();
+  });
+}
+
+export function requestGetPromise(options: RequestOption, dgitOptions: DgitGlobalOption, hooks?: DgitLifeCycle): Promise<any> {
+  return new Promise((resolve, reject) => {
     const { maxRetryCount = DEFAULT_MAX_RETRY_COUNT } = dgitOptions;
 
     const {
-        onSuccess, onError, onFinish, onRetry,
+      onSuccess,
+      onError,
+      onFinish,
+      onRetry,
     } = hooks || {};
 
     const newHooks: DgitLifeCycle = {
-        onSuccess (data: any) {
-            resolve(data);
-            onSuccess && onSuccess(data);
-        },
-        onError (err: any) {
-            reject(err);
-            onError && onError(err);
-        },
-        onFinish,
-        onRetry,
+      onSuccess(data: any) {
+        resolve(data);
+        onSuccess && onSuccess(data);
+      },
+      onError(err: any) {
+        reject(err);
+        onError && onError(err);
+      },
+      onFinish,
+      onRetry,
     };
 
     requestGet(options, maxRetryCount, newHooks);
-});
-
-export const requestOnStream = (
-    url: string,
-    ws: fs.WriteStream,
-    dgitOptions: DgitGlobalOption,
-    hooks?: DgitLifeCycle,
-) => {
-    const { maxRetryCount = DEFAULT_MAX_RETRY_COUNT } = dgitOptions;
-
-    const logger = createLogger(dgitOptions);
-
-    const {
-        onSuccess, onError, onFinish, onRetry,
-    } = hooks || {};
-
-    const fn = (retryCount: number): void => {
-        const downloadUrl = AddExtraRandomQs(url);
-        logger(` dowloading from ${ downloadUrl }...`);
-
-        request(encodeURI(downloadUrl))
-            .on('error', err => {
-                if (retryCount <= 0) {
-                    onError && onError(err);
-                    onFinish && onFinish();
-                    return;
-                }
-                setTimeout(() => {
-                    onRetry && onRetry();
-                    fn(retryCount - 1);
-                }, REQUEST_RETRY_DELAY);
-            })
-            .pipe(ws);
-    };
-
-    ws.on('finish', () => {
-        onSuccess && onSuccess();
-        onFinish && onFinish();
-    });
-
-    ws.on('error', () => {
-        logger(` ${ url }, write stream failed.`);
-    });
-
-    fn(maxRetryCount);
-};
+  });
+}
+
+export function requestOnStream(url: string, ws: fs.WriteStream, dgitOptions: DgitGlobalOption, hooks?: DgitLifeCycle) {
+  const { maxRetryCount = DEFAULT_MAX_RETRY_COUNT } = dgitOptions;
+
+  const logger = createLogger(dgitOptions);
+
+  const {
+    onSuccess,
+    onError,
+    onFinish,
+    onRetry,
+  } = hooks || {};
+
+  const fn = (retryCount: number): void => {
+    const downloadUrl = AddExtraRandomQs(url);
+    logger(` dowloading from ${downloadUrl}...`);
+
+    request(encodeURI(downloadUrl))
+      .on('error', (err) => {
+        if (retryCount <= 0) {
+          onError && onError(err);
+          onFinish && onFinish();
+          return;
+        }
+        setTimeout(() => {
+          onRetry && onRetry();
+          fn(retryCount - 1);
+        }, REQUEST_RETRY_DELAY);
+      })
+      .pipe(ws);
+  };
+
+  ws.on('finish', () => {
+    onSuccess && onSuccess();
+    onFinish && onFinish();
+  });
+
+  ws.on('error', () => {
+    logger(` ${url}, write stream failed.`);
+  });
+
+  fn(maxRetryCount);
+}

package/src/type.ts

@@ -1,61 +1,62 @@
 export type GithubRelativePath = string;
 
 export interface DgitGlobalOption {
-    maxRetryCount?: number;
-    parallelLimit?: number;
-    log?: boolean;
-    logPrefix?: string;
-    exclude?: GithubRelativePath[];
-    include?: GithubRelativePath[];
+  maxRetryCount?: number;
+  parallelLimit?: number;
+  log?: boolean;
+  logPrefix?: string;
+  exclude?: GithubRelativePath[];
+  include?: GithubRelativePath[];
+  exactMatch?: boolean; // 精确匹配，比如只匹配mingw-w64-python，不去匹配mingw-w64-python-*
 }
 
 export interface PrivateOption {
-    username?: string;
-    password?: string;
-    token?: string;
+  username?: string;
+  password?: string;
+  token?: string;
 }
 
 export interface RepoOptionType extends PrivateOption {
-    owner?: string; // github owner
-    repoName?: string; // repository name
-    ref?: string; // branch,  commit hash, tag.
-    relativePath?: string; // download relative path
-    githubLink?: string;
-    proxy?: string;
+  owner?: string; // github owner
+  repoName?: string; // repository name
+  ref?: string; // branch,  commit hash, tag.
+  relativePath?: string; // download relative path
+  githubLink?: string;
+  proxy?: string;
 }
 
 export interface RepoTreeNode {
-    path: string;
-    type: 'blob' | 'tree';
-    size: number;
-    url: string;
+  path: string;
+  type: 'blob' | 'tree';
+  size: number;
+  url: string;
 }
 
 export interface DgitLifeCycle {
-    onSuccess?: (data?: any)=> void;
-    onError?: (err?: any)=> void;
-    onFinish?: ()=> void;
-    onRetry?: ()=> void;
-    onProgress?: (status: ProgressStatus, node: RepoTreeNode)=> void;
-    onResolved?: (status: ProgressStatus)=> void;
+  onSuccess?: (data?: any) => void;
+  onError?: (err?: any) => void;
+  onFinish?: () => void;
+  onRetry?: () => void;
+  onProgress?: (status: ProgressStatus, node: RepoTreeNode) => void;
+  onResolved?: (status: ProgressStatus) => void;
 }
 
 export interface DgitLoadGitTree {
-    beforeLoadTree?: ()=> void;
-    afterLoadTree?: ()=> void;
+  beforeLoadTree?: () => void;
+  afterLoadTree?: () => void;
 }
 
 export interface ProgressStatus {
-    currentSize: number;
-    currentCount: number;
-    totalCount: number;
-    totalSize: number;
+  currentSize: number;
+  currentCount: number;
+  totalCount: number;
+  totalSize: number;
 }
 
 export interface GithubLinkInfo {
-    owner: string;
-    repoName: string;
-    ref: string;
-    relativePath: string;
-    type: string;
+  owner: string;
+  repoName: string;
+  ref: string;
+  relativePath: string;
+  type: string;
 }

package/test/dgit.test.ts

@@ -1,132 +1,135 @@
-import fs from 'fs';
-import path from 'path';
-import dgit from '../src/dgit';
+import fs from 'node:fs';
+import path from 'node:path';
+import { expect } from 'chai';
 import {
-    after, describe, it, before,
+  after,
+  before,
+  describe,
+  it,
 } from 'mocha';
-import { expect } from 'chai';
+import dgit from '../src/dgit';
 
-const Clean = (targets: Array<string>, callback: Function) => {
-    targets.forEach(deletePath => {
-        const stat = fs.statSync(deletePath);
-        if (stat.isFile()) {
-            return fs.unlinkSync(deletePath);
-        }
-        if (stat.isDirectory()) {
-            const nextTargets = fs.readdirSync(deletePath).map(fileName => `${ deletePath }/${ fileName }`);
-            Clean(nextTargets, () => {
-                fs.rmdirSync(deletePath);
-            });
-        }
-    });
-    callback();
-};
+function Clean(targets: Array<string>, callback: () => void) {
+  targets.forEach((deletePath) => {
+    const stat = fs.statSync(deletePath);
+    if (stat.isFile()) {
+      return fs.unlinkSync(deletePath);
+    }
+    if (stat.isDirectory()) {
+      const nextTargets = fs.readdirSync(deletePath).map(fileName => `${deletePath}/${fileName}`);
+      Clean(nextTargets, () => {
+        fs.rmdirSync(deletePath);
+      });
+    }
+  });
+  callback();
+}
 
 describe('dgit功能测试', () => {
-    const baseDir = 'testDir';
-    const basePath = path.resolve(__dirname, '../', baseDir);
-    const target = path.resolve(basePath, './PLAN.txt');
-    const target2 = path.resolve(basePath, './.eslintignore');
-    const target3 = path.resolve(basePath, './webpack.config.js');
-    const target4 = path.resolve(basePath, './config/webpack.base.js');
-    const target5 = path.resolve(basePath, './dgit.ts');
-    const target6 = path.resolve(basePath, './cmd/main.ts');
-    const target7 = path.resolve(basePath, './cmd/action.ts');
+  const baseDir = 'testDir';
+  const basePath = path.resolve(__dirname, '../', baseDir);
+  const target = path.resolve(basePath, './PLAN.txt');
+  const target2 = path.resolve(basePath, './.eslintignore');
+  const target3 = path.resolve(basePath, './webpack.config.js');
+  const target4 = path.resolve(basePath, './config/webpack.base.js');
+  const target5 = path.resolve(basePath, './dgit.ts');
+  const target6 = path.resolve(basePath, './cmd/main.ts');
+  const target7 = path.resolve(basePath, './cmd/action.ts');
 
-    const deleteTarget = (): Promise<void> => new Promise(resolve => {
-        if (fs.existsSync(basePath)) {
-            return Clean([ basePath ], resolve);
-        }
-        resolve();
-    });
+  const deleteTarget = (): Promise<void> => new Promise((resolve) => {
+    if (fs.existsSync(basePath)) {
+      return Clean([basePath], resolve);
+    }
+    resolve();
+  });
 
-    before(deleteTarget);
-    after(deleteTarget);
+  before(deleteTarget);
+  after(deleteTarget);
 
-    it('dgit 能拉取远端git指定目录代码', async () => {
-        await dgit(
-            {
-                owner       : 'JohnApache',
-                repoName    : 'hasaki-cli',
-                ref         : 'master',
-                relativePath: './PLAN.txt',
-            },
-            './testDir',
-            { log: true },
-            {
-                onSuccess () {
-                    expect(fs.existsSync(target)).to.be.equal(true);
-                },
-            },
-        );
-    });
+  it('dgit 能拉取远端git指定目录代码', async () => {
+    await dgit(
+      {
+        owner: 'JohnApache',
+        repoName: 'hasaki-cli',
+        ref: 'master',
+        relativePath: './PLAN.txt',
+      },
+      './testDir',
+      { log: true },
+      {
+        onSuccess() {
+          expect(fs.existsSync(target)).to.be.equal(true);
+        },
+      },
+    );
+  });
 
-    it('dgit 能直接使用githubLink方式拉取远端git指定目录代码', async () => {
-        await dgit(
-            { githubLink: 'https://github.com/JohnApache/hasaki-cli/blob/master/PLAN.txt' },
-            './testDir',
-            {
-                log          : true,
-                parallelLimit: 1,
-            },
-            {
-                onSuccess () {
-                    expect(fs.existsSync(target)).to.be.equal(true);
-                },
-            },
-        );
-    });
+  it('dgit 能直接使用githubLink方式拉取远端git指定目录代码', async () => {
+    await dgit(
+      { githubLink: 'https://github.com/JohnApache/hasaki-cli/blob/master/PLAN.txt' },
+      './testDir',
+      {
+        log: true,
+        parallelLimit: 1,
+      },
+      {
+        onSuccess() {
+          expect(fs.existsSync(target)).to.be.equal(true);
+        },
+      },
+    );
+  });
 
-    it('dgit 能直接使用githubLink方式拉取远端git指定深层指定文件代码', async () => {
-        await dgit(
-            { githubLink: 'https://github.com/JohnApache/hasaki-cli/blob/master/assets/.eslintignore' },
-            './testDir',
-            {
-                log          : true,
-                parallelLimit: 1,
-            },
-            {
-                onSuccess () {
-                    expect(fs.existsSync(target2)).to.be.equal(true);
-                },
-            },
-        );
-    });
+  it('dgit 能直接使用githubLink方式拉取远端git指定深层指定文件代码', async () => {
+    await dgit(
+      { githubLink: 'https://github.com/JohnApache/hasaki-cli/blob/master/assets/.eslintignore' },
+      './testDir',
+      {
+        log: true,
+        parallelLimit: 1,
+      },
+      {
+        onSuccess() {
+          expect(fs.existsSync(target2)).to.be.equal(true);
+        },
+      },
+    );
+  });
 
-    it('dgit 能直接使用githubLink方式拉取远端git指定深层指定目录代码', async () => {
-        await dgit(
-            { githubLink: 'https://github.com/JohnApache/hasaki-cli/tree/master/assets/webpack' },
-            './testDir',
-            {
-                log          : true,
-                parallelLimit: 2,
-            },
-            {
-                onSuccess () {
-                    expect(fs.existsSync(target3)).to.be.equal(true);
-                    expect(fs.existsSync(target4)).to.be.equal(true);
-                },
-            },
-        );
-    });
+  it('dgit 能直接使用githubLink方式拉取远端git指定深层指定目录代码', async () => {
+    await dgit(
+      { githubLink: 'https://github.com/JohnApache/hasaki-cli/tree/master/assets/webpack' },
+      './testDir',
+      {
+        log: true,
+        parallelLimit: 2,
+      },
+      {
+        onSuccess() {
+          expect(fs.existsSync(target3)).to.be.equal(true);
+          expect(fs.existsSync(target4)).to.be.equal(true);
+        },
+      },
+    );
+  });
 
-    it('dgit 能接受exclude include 参数筛选目标目录文件', async () => {
-        await dgit(
-            { githubLink: 'https://github.com/JohnApache/dgit/tree/master/src' },
-            './testDir',
-            {
-                log          : true,
-                parallelLimit: 2,
-                exclude      : [ 'cmd' ],
-                include      : [ 'cmd/main.ts' ],
-            },
-            {
-                onSuccess () {
-                    expect(fs.existsSync(target5)).to.be.equal(true);
-                    expect(fs.existsSync(target6)).to.be.equal(true);
-                    expect(fs.existsSync(target7)).to.be.equal(false);
-                },
-            },
-        );
-    });
+  it('dgit 能接受exclude include 参数筛选目标目录文件', async () => {
+    await dgit(
+      { githubLink: 'https://github.com/JohnApache/dgit/tree/master/src' },
+      './testDir',
+      {
+        log: true,
+        parallelLimit: 2,
+        exclude: ['cmd'],
+        include: ['cmd/main.ts'],
+      },
+      {
+        onSuccess() {
+          expect(fs.existsSync(target5)).to.be.equal(true);
+          expect(fs.existsSync(target6)).to.be.equal(true);
+          expect(fs.existsSync(target7)).to.be.equal(false);
+        },
+      },
+    );
+  });
 });