@bratel/dgit 0.0.13 → 0.0.15

package/src/cmd/main.ts

@@ -1,70 +1,73 @@
-import program from 'commander';
+import type { PackageInfo } from './type';
+import process from 'node:process';
 import chalk from 'chalk';
 
-import { PackageInfo } from './type';
-import { GetPackageInfo } from './utils';
+import { Command } from 'commander';
 import DownloadAction from './action';
+import { GetPackageInfo } from './utils';
 
 const EXIT_CODE = 1;
+const program = new Command();
 
-const Exit = (): void => {
-    process.exit(EXIT_CODE);
-};
+function Exit(): void {
+  process.exit(EXIT_CODE);
+}
 
-const UnknownCommand = (cmdName: string): void => {
-    console.log(`${ chalk.red('Unknown command') } ${ chalk.yellow(cmdName) }.`);
-};
+function UnknownCommand(cmdName: string): void {
+  console.log(`${chalk.red('Unknown command')} ${chalk.yellow(cmdName)}.`);
+}
 
 const packageInfo: PackageInfo = GetPackageInfo();
 
 program.version(packageInfo.version);
 
 program
-    .command('download [githubLink]')
-    .option('--owner <ownerName>', 'git repo author.')
-    .option('--repo-name <repoName>', 'git repo name.')
-    .option('--ref <refName>', 'git repo branch, commit hash or tagname.')
-    .option(
-        '--relative-path <relativePath>',
-        'specified repo relative path to download.',
-    )
-    .option('-d, --dest <destPath>', 'specified dest path.')
-    .option(
-        '-l, --parallel-limit, <number>',
-        'specified download max parallel limit.',
-    )
-    .option('-u, --username, <username>', 'specified git account username.')
-    .option('-p --password, <password>', 'specified git account password.')
-    .option(
-        '-t --token, <token>',
-        'specified git account personal access token.',
-    )
-    .option(
-        '-e --exclude, <relativePath,...,relativePath>',
-        'indicates which file paths need to be excluded in the current directory.',
-    )
-    .option(
-        '-i --include, <relativePath,...,relativePath>',
-        'indicates which files need to be included in the exclusion file list.',
-    )
-    .option('--log', 'output dgit internal log details.')
-    .option('--log-prefix, <log>', 'dgit internal log prefix.')
-    .option('--proxy, <proxyHttp>', 'dgit proxy download url.')
-    .alias('d')
-    .description('download the file with the specified path of the remote repo.')
-    .action(DownloadAction);
+  .command('download [githubLink]')
+  .option('--owner <ownerName>', 'git repo author.')
+  .option('--repo-name <repoName>', 'git repo name.')
+  .option('--ref <refName>', 'git repo branch, commit hash or tagname.')
+  .option(
+    '--relative-path <relativePath>',
+    'specified repo relative path to download.',
+  )
+  .option('-d, --dest <destPath>', 'specified dest path.')
+  .option(
+    '-l, --parallel-limit, <number>',
+    'specified download max parallel limit.',
+  )
+  .option('-u, --username, <username>', 'specified git account username.')
+  .option('-p --password, <password>', 'specified git account password.')
+  .option(
+    '-t --token, <token>',
+    'specified git account personal access token.',
+  )
+  .option(
+    '-e --exclude, <relativePath,...,relativePath>',
+    'indicates which file paths need to be excluded in the current directory.',
+  )
+  .option(
+    '-i --include, <relativePath,...,relativePath>',
+    'indicates which files need to be included in the exclusion file list.',
+  )
+  .option('--exact-match', 'enable exact path matching instead of prefix matching.')
+  .option('--log', 'output dgit internal log details.')
+  .option('--log-prefix, <log>', 'dgit internal log prefix.')
+  .option('--proxy, <proxyHttp>', 'dgit proxy download url.')
+  .alias('d')
+  .description('download the file with the specified path of the remote repo.')
+  .action(DownloadAction);
 
 program.on('command:*', (cmdObj = []) => {
-    const [ cmd ] = cmdObj;
-    if (cmd) {
-        program.outputHelp();
-        UnknownCommand(cmd);
-        Exit();
-    }
+  const [cmd] = cmdObj;
+  if (cmd) {
+    program.outputHelp();
+    UnknownCommand(cmd);
+    Exit();
+  }
 });
 
 if (process.argv.slice(2).length <= 0) {
-    program.help();
+  program.help();
 }
 
 program.parse(process.argv);

package/src/cmd/prompt.ts

@@ -1,98 +1,99 @@
-import inquirer, { Question } from 'inquirer';
-import { DownloadPromptInfo, PasswordPromptInfo } from './type';
+import type { Question } from 'inquirer';
+import type { DownloadPromptInfo, PasswordPromptInfo } from './type';
+import inquirer from 'inquirer';
 
 export const CreatePrompt = (questions: Array<Question>): Promise<any> => inquirer.prompt(questions);
 
-export const DownloadPrompt = async (
-    currentInfo: DownloadPromptInfo,
-): Promise<DownloadPromptInfo> => {
-    if (
-        currentInfo.owner &&
-        currentInfo.repoName &&
-        currentInfo.ref &&
-        currentInfo.relativePath &&
-        currentInfo.dest
-    ) return currentInfo;
+export async function DownloadPrompt(currentInfo: DownloadPromptInfo): Promise<DownloadPromptInfo> {
+  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: string) {
-                return input && input.length > 0;
-            },
-            message: 'input github ownername.',
-        },
-        {
-            type: 'input',
-            name: 'repoName',
-            when () {
-                return !currentInfo.repoName;
-            },
-            validate (input: string) {
-                return input && input.length > 0;
-            },
-            message: 'input github repoName.',
-        },
-        {
-            type: 'input',
-            name: 'ref',
-            when () {
-                return !currentInfo.ref;
-            },
-            validate (input: string) {
-                return input && input.length > 0;
-            },
-            'default': 'master',
-            message  : 'input github branch or commit hash or tagname.',
-        },
-        {
-            type: 'input',
-            name: 'relativePath',
-            when () {
-                return !currentInfo.relativePath;
-            },
-            validate (input: string) {
-                return input && input.length > 0;
-            },
-            'default': '.',
-            message  : 'input github relative path.',
-        },
-        {
-            type: 'input',
-            name: 'dest',
-            when () {
-                return !currentInfo.dest;
-            },
-            validate (input: string) {
-                return input && input.length > 0;
-            },
-            'default': '.',
-            message  : 'input template output dest path.',
-        },
-    ];
+  const questions = [
+    {
+      type: 'input',
+      name: 'owner',
+      when() {
+        return !currentInfo.owner;
+      },
+      validate(input: string) {
+        return input && input.length > 0;
+      },
+      message: 'input github ownername.',
+    },
+    {
+      type: 'input',
+      name: 'repoName',
+      when() {
+        return !currentInfo.repoName;
+      },
+      validate(input: string) {
+        return input && input.length > 0;
+      },
+      message: 'input github repoName.',
+    },
+    {
+      type: 'input',
+      name: 'ref',
+      when() {
+        return !currentInfo.ref;
+      },
+      validate(input: string) {
+        return input && input.length > 0;
+      },
+      default: 'master',
+      message: 'input github branch or commit hash or tagname.',
+    },
+    {
+      type: 'input',
+      name: 'relativePath',
+      when() {
+        return !currentInfo.relativePath;
+      },
+      validate(input: string) {
+        return input && input.length > 0;
+      },
+      default: '.',
+      message: 'input github relative path.',
+    },
+    {
+      type: 'input',
+      name: 'dest',
+      when() {
+        return !currentInfo.dest;
+      },
+      validate(input: string) {
+        return input && input.length > 0;
+      },
+      default: '.',
+      message: 'input template output dest path.',
+    },
+  ];
 
-    const answer = await 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,
-    };
-};
+  const answer = await 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,
+  };
+}
 
-export const PasswordPrompt = (): Promise<PasswordPromptInfo> => {
-    const question = {
-        type: 'password',
-        name: 'password',
-        validate (input: string) {
-            return input && input.length > 0;
-        },
-        message: 'input github account password.',
-    };
-    return CreatePrompt([ question ]);
-};
+export function PasswordPrompt(): Promise<PasswordPromptInfo> {
+  const question = {
+    type: 'password',
+    name: 'password',
+    validate(input: string) {
+      return input && input.length > 0;
+    },
+    message: 'input github account password.',
+  };
+  return CreatePrompt([question]);
+}

package/src/cmd/type.ts

@@ -1,41 +1,42 @@
 export interface PackageInfo {
-    version: string;
-    name: string;
+  version: string;
+  name: string;
 }
 
 export interface CommandInfo {
-    dest?: string;
-    owner?: string;
-    repoName?: string;
-    ref?: string;
-    relativePath?: string;
-    parallelLimit?: string;
-    username?: string;
-    password?: string;
-    token?: string;
-    exclude?: string;
-    include?: string;
-    log?: boolean;
-    logPrefix?: string;
-    proxy?: string;
+  dest?: string;
+  owner?: string;
+  repoName?: string;
+  ref?: string;
+  relativePath?: string;
+  parallelLimit?: string;
+  username?: string;
+  password?: string;
+  token?: string;
+  exclude?: string;
+  include?: string;
+  log?: boolean;
+  logPrefix?: string;
+  proxy?: string;
+  exactMatch?: boolean;
 }
 
 export interface DownloadPromptInfo {
-    dest: string;
-    owner: string;
-    repoName: string;
-    ref: string;
-    relativePath: string;
+  dest: string;
+  owner: string;
+  repoName: string;
+  ref: string;
+  relativePath: string;
 }
 
 export interface GithubLinkInfo {
-    owner: string;
-    repoName: string;
-    ref: string;
-    relativePath: string;
-    type: string;
+  owner: string;
+  repoName: string;
+  ref: string;
+  relativePath: string;
+  type: string;
 }
 
 export interface PasswordPromptInfo {
-    password: string;
+  password: string;
 }

package/src/cmd/utils.ts

@@ -1,88 +1,93 @@
-import fs from 'fs';
-import path from 'path';
-import { PackageInfo, GithubLinkInfo } from './type';
+import type { GithubLinkInfo, PackageInfo } from './type';
+import fs from 'node:fs';
+import path from 'node:path';
 
-export const GetPackageInfo = (): PackageInfo => {
-    const buffer = fs.readFileSync(path.resolve(__dirname, '../../package.json'));
-    return JSON.parse(buffer.toString());
-};
+export function GetPackageInfo(): PackageInfo {
+  const buffer = fs.readFileSync(path.resolve(__dirname, '../../package.json'));
+  return JSON.parse(buffer.toString());
+}
 
 export const GITHUB_ADDRESS = 'https://github.com/';
 export const isHttpsLink = (link: string) => link.trim().startsWith(GITHUB_ADDRESS);
 
-export const ParseGithubHttpsLink = (httpsLink: string): GithubLinkInfo => {
-    let nextLink = httpsLink.trim().slice(GITHUB_ADDRESS.length);
-    let index = nextLink.indexOf('/');
-    if (index === -1) throw new Error('invalid github address.');
-    const owner = nextLink.slice(0, index);
-    nextLink = nextLink.slice(owner.length + 1);
-    index = nextLink.indexOf('/');
-    let repoName: string;
-    if (index === -1) {
-        repoName = nextLink.slice(0);
-        if (!repoName) throw new Error('invalid github address.');
-        return {
-            owner,
-            repoName,
-            ref         : 'master',
-            relativePath: '',
-            type        : 'tree',
-        };
+export function ParseGithubHttpsLink(httpsLink: string): GithubLinkInfo {
+  let nextLink = httpsLink.trim().slice(GITHUB_ADDRESS.length);
+  let index = nextLink.indexOf('/');
+  if (index === -1)
+    throw new Error('invalid github address.');
+  const owner = nextLink.slice(0, index);
+  nextLink = nextLink.slice(owner.length + 1);
+  index = nextLink.indexOf('/');
+  let repoName: string;
+  if (index === -1) {
+    repoName = nextLink.slice(0);
+    if (!repoName)
+      throw new Error('invalid github address.');
+    return {
+      owner,
+      repoName,
+      ref: 'master',
+      relativePath: '',
+      type: 'tree',
+    };
+  }
+  repoName = nextLink.slice(0, index);
+  nextLink = nextLink.slice(repoName.length + 1);
+  index = nextLink.indexOf('/');
+  let ref = 'master';
+  let relativePath = '';
+  let type = 'tree';
+  if (index === -1) {
+    if (repoName.endsWith('.git')) {
+      const lastIndex = -4;
+      repoName = repoName.slice(0, lastIndex);
     }
-    repoName = nextLink.slice(0, index);
-    nextLink = nextLink.slice(repoName.length + 1);
+  }
+  else {
+    type = nextLink.slice(0, index);
+    nextLink = nextLink.slice(type.length + 1);
     index = nextLink.indexOf('/');
-    let ref = 'master';
-    let relativePath = '';
-    let type = 'tree';
     if (index === -1) {
-        if (repoName.endsWith('.git')) {
-            const lastIndex = -4;
-            repoName = repoName.slice(0, lastIndex);
-        }
-    } else {
-        type = nextLink.slice(0, index);
-        nextLink = nextLink.slice(type.length + 1);
-        index = nextLink.indexOf('/');
-        if (index === -1) {
-            ref = nextLink.slice(0) || 'master';
-        } else {
-            ref = nextLink.slice(0, index);
-            relativePath = nextLink.slice(ref.length + 1);
-        }
+      ref = nextLink.slice(0) || 'master';
+    }
+    else {
+      ref = nextLink.slice(0, index);
+      relativePath = nextLink.slice(ref.length + 1);
     }
+  }
 
-    return {
-        owner,
-        repoName,
-        ref,
-        relativePath,
-        type,
-    };
-};
+  return {
+    owner,
+    repoName,
+    ref,
+    relativePath,
+    type,
+  };
+}
 
-export const TextEllipsis = (text: string, maxLen: number): string => (text.length >= maxLen ? `${ text.slice(0, maxLen) }...` : text);
+export const TextEllipsis = (text: string, maxLen: number): string => (text.length >= maxLen ? `${text.slice(0, maxLen)}...` : text);
 
-export const MakeDirs = (dirs: string): void => {
-    const mkdirs = (dir: string, callback?: ()=> void) => {
-        if (fs.existsSync(dir)) {
-            callback && callback();
-            return;
-        }
+export function MakeDirs(dirs: string): void {
+  const mkdirs = (dir: string, callback?: () => void) => {
+    if (fs.existsSync(dir)) {
+      callback && callback();
+      return;
+    }
 
-        mkdirs(path.dirname(dir), () => {
-            fs.mkdirSync(dir);
-            callback && callback();
-        });
-    };
+    mkdirs(path.dirname(dir), () => {
+      fs.mkdirSync(dir);
+      callback && callback();
+    });
+  };
 
-    if (fs.existsSync(dirs)) return;
-    mkdirs(dirs);
-};
+  if (fs.existsSync(dirs))
+    return;
+  mkdirs(dirs);
+}
 
-export const AddExtraRandomQs = (origin: string): string => {
-    if (origin.indexOf('?') !== -1) {
-        return `${ origin }&_t=${ Math.random() }`;
-    }
-    return `${ origin }?_t=${ Math.random() }`;
-};
+export function AddExtraRandomQs(origin: string): string {
+  if (origin.includes('?')) {
+    return `${origin}&_t=${Math.random()}`;
+  }
+  return `${origin}?_t=${Math.random()}`;
+}