euberdeveloper/dree | Build 9488762248 | source/lib/index.ts | Coveralls

1

import { resolve, basename, extname, relative } from 'node:path';

1✔

2

import { homedir } from 'node:os';

1✔

3

import { BinaryToTextEncoding, createHash, Hash } from 'node:crypto';

1✔

4

import { statSync, readdirSync, readFileSync, lstatSync, Stats } from 'node:fs';

1✔

5

import { stat as statAsync, readdir as readdirAsync, readFile as readFileAsync, lstat as lstatAsync } from 'node:fs/promises';

1✔

6

1✔

7

import { makeRe } from 'minimatch';

1✔

8

1✔

9

/* DREE TYPES */

1✔

10

1✔

11

/**

1✔

12

 * Enum whose values are DIRECTORY or FILE

1✔

13

*/

1✔

14

export enum Type {

1✔

15

    DIRECTORY = 'directory',

1✔

16

    FILE = 'file'

1✔

17

1✔

18

1✔

19

/**

1✔

20

 * Callback used by [[scan]] when a file or dir is encountered.

1✔

21

 * Note that it can extend the node that will be returned in the directory tree.

1✔

22

 * @template Node The type of the tree object, which can be extended and changed by the onFile and onDir functions.

1✔

23

*/

1✔

24

export type Callback<Node extends Dree = Dree> = (dirTree: Node, stat: Stats) => void;

1✔

25

/**

1✔

26

 * Callback used by [[scanAsync]] when a file or dir is encountered.

1✔

27

 * Note that it can extend the node that will be returned in the directory tree.

1✔

28

 * @template Node The type of the tree object, which can be extended and changed by the onFile and onDir functions.

1✔

29

*/

1✔

30

export type CallbackAsync<Node extends Dree = Dree> = (dirTree: Node, stat: Stats) => void | Promise<void>;

1✔

31

1✔

32

1✔

33

/**

1✔

34

 * Enum whose values are used to determine how the paths should be sorted

1✔

35

*/

1✔

36

export enum SortMethodPredefined {

1✔

37

    /** Alphabetical order */

1✔

38

    ALPHABETICAL = 'alpha',

1✔

39

    /** Alphabetical order, reversed */

1✔

40

    ALPHABETICAL_REVERSE = 'antialpha',

1✔

41

    /** Alphabetical order, case insensitive */

1✔

42

    ALPHABETICAL_INSENSITIVE = 'alpha-insensitive',

1✔

43

    /** Alphabetical order, reversed, case insensitive */

1✔

44

    ALPHABETICAL_INSENSITIVE_REVERSE = 'antialpha-insensitive'

1✔

45

};

1✔

46

/**

1✔

47

 * Function used to sort paths

1✔

48

*/

1✔

49

export type SortDiscriminator = (x: string, y: string) => number;

1✔

50

1✔

51

/**

1✔

52

 * Enum whose values are used to determine how the nodes should be sorted. Differently from [[SortMethodPredefined]],

1✔

53

 * it specifies the behavior of the sorting after all the children of a folder are scanned.

1✔

54

*/

1✔

55

export enum PostSortMethodPredefined {

1✔

56

    /** Alphabetical order */

1✔

57

    ALPHABETICAL = 'alpha',

1✔

58

    /** Alphabetical order, reversed */

1✔

59

    ALPHABETICAL_REVERSE = 'antialpha',

1✔

60

    /** Alphabetical order, case insensitive */

1✔

61

    ALPHABETICAL_INSENSITIVE = 'alpha-insensitive',

1✔

62

    /** Alphabetical order, reversed, case insensitive */

1✔

63

    ALPHABETICAL_INSENSITIVE_REVERSE = 'antialpha-insensitive',

1✔

64

    /** Folders first, files after */

1✔

65

    FOLDERS_FIRST = 'folders-first',

1✔

66

    /** Files first, folders after */

1✔

67

    FILES_FIRST = 'files-first'

1✔

68

};

1✔

69

/**

1✔

70

 * Function used to sort nodes

1✔

71

*/

1✔

72

export type PostSortDiscriminator = (x: Dree, y: Dree) => number;

1✔

73

1✔

74

/**

1✔

75

 * Interface of an object representing a Directory Tree

1✔

76

*/

1✔

77

export interface Dree {

1✔

78

/**

1✔

79

     *  The name of the node as a string

1✔

80

*/

1✔

81

    name: string;

1✔

82

/**

1✔

83

     * The absolute path of the node

1✔

84

*/

1✔

85

    path: string;

1✔

86

/**

1✔

87

     * The relative path from the root of the node

1✔

88

*/

1✔

89

    relativePath: string;

1✔

90

/**

1✔

91

     * Values: Type.DIRECTORY or Type.FILE

1✔

92

*/

1✔

93

    type: Type;

1✔

94

/**

1✔

95

     * A boolean with true value if the node is a symbolic link

1✔

96

*/

1✔

97

    isSymbolicLink: boolean;

1✔

98

/**

1✔

99

     * Optional. The size in bytes of the node

1✔

100

*/

1✔

101

    sizeInBytes?: number;

1✔

102

/**

1✔

103

     * Optional. The size of the node, rounded to two decimals and appropriate unit

1✔

104

*/

1✔

105

    size?: string;

1✔

106

/**

1✔

107

     * Optional. The hash of the node

1✔

108

*/

1✔

109

    hash?: string;

1✔

110

/**

1✔

111

     * Optional. The extension (without dot) of the node. Returned only if the node is a file

1✔

112

*/

1✔

113

    extension?: string;

1✔

114

/**

1✔

115

     * Optional. True if the node is a directory and contains no files and no directories

1✔

116

*/

1✔

117

    isEmpty?: boolean;

1✔

118

/**

1✔

119

     * Optional. The fs.lstat or fs.fstat of the node

1✔

120

*/

1✔

121

    stat?: Stats;

1✔

122

/**

1✔

123

     * Optional. The number of descendants of the node. Returned only if the node is a directory and [[descendants]] option is specified

1✔

124

*/

1✔

125

    descendants?: number;

1✔

126

/**

1✔

127

     * Optional. An array of Dree objects, containing all the children of the node

1✔

128

*/

1✔

129

    children?: Dree[];

1✔

130

1✔

131

1✔

132

/**

1✔

133

 * Interface of the options object used with "scan" function

1✔

134

*/

1✔

135

export interface ScanOptions {

1✔

136

/**

1✔

137

     * If true every node of the result will contain stat property, provided by fs.lstat or fs.stat

1✔

138

*/

1✔

139

    stat?: boolean;

1✔

140

/**

1✔

141

     * If true, on windows, normalize each path replacing each backslash \\\\ with a slash /

1✔

142

*/

1✔

143

    normalize?: boolean;

1✔

144

/**

1✔

145

     * If true, all symbolic links found will be included in the result. Could not work on Windows

1✔

146

*/

1✔

147

    symbolicLinks?: boolean;

1✔

148

/**

1✔

149

     * If true, all symbolic links will be followed, including even their content if they link to a folder.

1✔

150

     * Could not work on Windows

1✔

151

*/

1✔

152

    followLinks?: boolean;

1✔

153

/**

1✔

154

     * If true, every node in the result will contain sizeInBytes property as the number of bytes of the content.

1✔

155

     * If a node is a folder, only its considered inner files will be computed to have this size

1✔

156

*/

1✔

157

    sizeInBytes?: boolean;

1✔

158

/**

1✔

159

     * If true, every node in the result will contain size property. Same as sizeInBytes, but it

1✔

160

     * is a string rounded to the second decimal digit and with an appropriate unit

1✔

161

*/

1✔

162

    size?: boolean;

1✔

163

/**

1✔

164

     * If true, every node in the result will contain hash property, computed by taking in consideration

1✔

165

     * the name and the content of the node. If the node is a folder, all his considered inner files will be used by the algorithm

1✔

166

*/

1✔

167

    hash?: boolean;

1✔

168

/**

1✔

169

     * Hash algorithm used by cryptojs to return the hash

1✔

170

*/

1✔

171

    hashAlgorithm?: 'md5' | 'sha1';

1✔

172

/**

1✔

173

     * Hash encoding used by cryptojs to return the hash

1✔

174

*/

1✔

175

    hashEncoding?: BinaryToTextEncoding;

1✔

176

/**

1✔

177

     * If true, all hidden files and dirs will be included in the result. A hidden file or a directory

1✔

178

     * has a name which starts with a dot and in some systems like Linux are hidden

1✔

179

*/

1✔

180

    showHidden?: boolean;

1✔

181

/**

1✔

182

     * It is a number which says the max depth the algorithm can reach scanning the given path.

1✔

183

     * All files and dirs which are beyound the max depth will not be considered by the algorithm

1✔

184

*/

1✔

185

    depth?: number;

1✔

186

/**

1✔

187

     * It is a regex, string (glob patterns) or array of them and all the matching paths will not be considered by the algorithm.

1✔

188

*/

1✔

189

    exclude?: string | RegExp | (RegExp | string)[];

1✔

190

/**

1✔

191

     * It is a regex, string (glob pattern) or array of them and all the non-matching paths will not be considered by the algorithm. Note: All the

1✔

192

     * ancestors of a matching node will be added.

1✔

193

*/

1✔

194

    matches?: string | RegExp | (RegExp | string)[];

1✔

195

/**

1✔

196

     * It is an array of strings and all the files whose extension is not included in that array will be skipped by the algorithm.

1✔

197

     * If value is undefined, all file extensions will be considered, if it is [], no files will be included

1✔

198

*/

1✔

199

    extensions?: string[];

1✔

200

/**

1✔

201

     * If true, every node of type directory in the result will contain isEmpty property, which will be true if the folder contains

1✔

202

     * no files and no directories

1✔

203

*/

1✔

204

    emptyDirectory?: boolean;

1✔

205

/**

1✔

206

     * If true, every empty directory will be excluded from the result. If the directory is not empty but all the contained files

1✔

207

     * and directories are excluded by other options such as exclude or extensions, the directory will not be included in the result

1✔

208

*/

1✔

209

    excludeEmptyDirectories?: boolean;

1✔

210

/**

1✔

211

     * If true, also the number of descendants of each node will be added to the result.

1✔

212

*/

1✔

213

    descendants?: boolean;

1✔

214

/**

1✔

215

     * If true, only files will be count as descendants of a node. It does not have effect if [[descendants]] option is not true.

1✔

216

*/

1✔

217

    descendantsIgnoreDirectories?: boolean;

1✔

218

/**

1✔

219

     * If true, directories and files will be scanned ordered by path. The value can be both boolean for default alpha order, a

1✔

220

     * custom sorting function or a predefined sorting method in [[SortMethodPredefined]].

1✔

221

*/

1✔

222

    sorted?: boolean | SortMethodPredefined | SortDiscriminator;

1✔

223

/**

1✔

224

     * If true, the child nodes of a node will be ordered. The value can be both boolean for default alpha order, a

1✔

225

     * custom sorting function or a predefined sorting method in [[PostSortMethodPredefined]].

1✔

226

*/

1✔

227

    postSorted?: boolean | PostSortMethodPredefined | PostSortDiscriminator;

1✔

228

/**

1✔

229

     * If true, the unix homedir shortcut ~ will be expanded to the user home directory

1✔

230

*/

1✔

231

    homeShortcut?: boolean;

1✔

232

/**

1✔

233

     * If true, folders whose user has not permissions will be skipped. An error will be thrown otherwise. Note: in fact every

1✔

234

     * error thrown by fs calls will be ignored

1✔

235

*/

1✔

236

    skipErrors?: boolean;

1✔

237

1✔

238

1✔

239

/**

1✔

240

 * Interface of the options object used with "parse" or "parseTree" functions

1✔

241

*/

1✔

242

export interface ParseOptions {

1✔

243

/**

1✔

244

     * If true, all symbolic links found will be included in the result. Could not work on Windows

1✔

245

*/

1✔

246

    symbolicLinks?: boolean;

1✔

247

/**

1✔

248

     * If true, all symbolic links will be followed, including even their content if they link to a folder.

1✔

249

     * Could not work on Windows

1✔

250

*/

1✔

251

    followLinks?: boolean;

1✔

252

/**

1✔

253

     * If true, all hidden files and dirs will be included in the result. A hidden file or a directory

1✔

254

     * has a name which starts with a dot and in some systems like Linux are hidden

1✔

255

*/

1✔

256

    showHidden?: boolean;

1✔

257

/**

1✔

258

     * It is a number which says the max depth the algorithm can reach scanning the given path.

1✔

259

     * All files and dirs which are beyound the max depth will not be considered by the algorithm

1✔

260

*/

1✔

261

    depth?: number;

1✔

262

/**

1✔

263

     * It is a regex, string (glob patterns) or array of them and all the matched paths will not be considered by the algorithm

1✔

264

*/

1✔

265

    exclude?: string | RegExp | (RegExp | string)[];

1✔

266

/**

1✔

267

     * It is an array of strings and all the files whose extension is not included in that array will be skipped by the algorithm.

1✔

268

     * If value is undefined, all file extensions will be considered, if it is [], no files will be included

1✔

269

*/

1✔

270

    extensions?: string[];

1✔

271

/**

1✔

272

     * If true, directories and files will be scanned ordered by path. The value can be both boolean for default alpha order, a

1✔

273

     * custom sorting function or a predefined sorting method in [[SortMethodPredefined]].

1✔

274

*/

1✔

275

    sorted?: boolean | SortMethodPredefined | SortDiscriminator;

1✔

276

/**

1✔

277

     * If true, the child nodes of a node will be ordered. The value can be both boolean for default alpha order, a

1✔

278

     * custom sorting function or a predefined sorting method in [[PostSortMethodPredefined]].

1✔

279

*/

1✔

280

    postSorted?: boolean | PostSortMethodPredefined | PostSortDiscriminator;

1✔

281

/**

1✔

282

     * If true, the unix homedir shortcut ~ will be expanded to the user home directory

1✔

283

*/

1✔

284

    homeShortcut?: boolean;

1✔

285

/**

1✔

286

     * If true, folders whose user has not permissions will be skipped. An error will be thrown otherwise. Note: in fact every

1✔

287

     * error thrown by fs calls will be ignored

1✔

288

*/

1✔

289

    skipErrors?: boolean;

1✔

290

1✔

291

1✔

292

/* DEFAULT OPTIONS */

1✔

293

1✔

294

const SCAN_DEFAULT_OPTIONS: Required<ScanOptions> = {

1✔

295

    stat: false,

1✔

296

    normalize: false,

1✔

297

    symbolicLinks: true,

1✔

298

    followLinks: false,

1✔

299

    sizeInBytes: true,

1✔

300

    size: true,

1✔

301

    hash: true,

1✔

302

    hashAlgorithm: 'md5',

1✔

303

    hashEncoding: 'hex',

1✔

304

    showHidden: true,

1✔

305

    depth: undefined,

1✔

306

    exclude: undefined,

1✔

307

    matches: undefined,

1✔

308

    extensions: undefined,

1✔

309

    emptyDirectory: false,

1✔

310

    excludeEmptyDirectories: false,

1✔

311

    descendants: false,

1✔

312

    descendantsIgnoreDirectories: false,

1✔

313

    sorted: false,

1✔

314

    postSorted: false,

1✔

315

    homeShortcut: false,

1✔

316

    skipErrors: true

1✔

317

};

1✔

318

1✔

319

const PARSE_DEFAULT_OPTIONS: Required<ParseOptions> = {

1✔

320

    symbolicLinks: true,

1✔

321

    followLinks: false,

1✔

322

    showHidden: true,

1✔

323

    depth: undefined,

1✔

324

    exclude: undefined,

1✔

325

    extensions: undefined,

1✔

326

    sorted: false,

1✔

327

    postSorted: false,

1✔

328

    homeShortcut: false,

1✔

329

    skipErrors: true

1✔

330

};

1✔

331

1✔

332

/* SUPPORT FUNCTIONS */

1✔

333

1✔

334

function resolvePath(path: string, options: ScanOptions | ParseOptions): string {

115✔

335

    return resolve(options.homeShortcut ? path.replace(/^~($|\/|\\)/, homedir() + '$1') : path);

115✔

336

115✔

337

1✔

338

function purgePatternsIntoArrayOfRegex(patterns: string | RegExp | (RegExp | string)[]): RegExp[] {

429✔

339

    return (Array.isArray(patterns) ? patterns : [patterns]).map(pattern => pattern instanceof RegExp ? pattern : makeRe(pattern, {

429✔

340

        dot: true,

202✔

341

202✔

342

    })).filter(pattern => pattern instanceof RegExp) as RegExp[];

429✔

343

429✔

344

1✔

345

function mergeScanOptions(options?: ScanOptions): ScanOptions {

85✔

346

    let result: ScanOptions = {};

85✔

347

    if (options) {

85✔

348

        for (const key in SCAN_DEFAULT_OPTIONS) {

69✔

349

            result[key] = (options[key] !== undefined) ? options[key] : SCAN_DEFAULT_OPTIONS[key];

1,518✔

350

1,518✔

351

        if (result.depth as number < 0) {

69✔

352

            result.depth = 0;

2✔

353

2✔

354

69✔

355

    else {

16✔

356

        result = SCAN_DEFAULT_OPTIONS;

16✔

357

16✔

358

    return result;

85✔

359

85✔

360

1✔

361

function mergeParseOptions(options?: ParseOptions): ParseOptions {

58✔

362

    let result: ParseOptions = {};

58✔

363

    if (options) {

58✔

364

        for (const key in PARSE_DEFAULT_OPTIONS) {

54✔

365

            result[key] = (options[key] !== undefined) ? options[key] : PARSE_DEFAULT_OPTIONS[key];

540✔

366

540✔

367

        if (result.depth as number < 0) {

54✔

368

            result.depth = 0;

4✔

369

4✔

370

54✔

371

    else {

4✔

372

        result = PARSE_DEFAULT_OPTIONS;

4✔

373

4✔

374

    return result;

58✔

375

58✔

376

1✔

377

function parseSize(size: number): string {

1,005✔

378

    const units = ['B', 'KB', 'MB', 'GB', 'TB'];

1,005✔

379

    let i: number;

1,005✔

380

    for (i = 0; i < units.length && size > 1000; i++) {

1,005✔

381

        size /= 1000;

516✔

382

516✔

383

    return Math.round(size * 100) / 100 + ' ' + units[i];

1,005✔

384

1,005✔

385

1✔

386

function sortAlphabetical(a: string, b: string): number {

168✔

387

    return a.localeCompare(b);

168✔

388

168✔

389

1✔

390

function sortAlphabeticalInsensitive(a: string, b: string): number {

112✔

391

    return a.toLowerCase().localeCompare(b.toLowerCase());

112✔

392

112✔

393

1✔

394

function sortFiles(files: string[], sortOption: boolean | SortMethodPredefined | SortDiscriminator): string[] {

666✔

395

    if (!sortOption) {

666✔

396

        return files;

450✔

397

450✔

398

216✔

399

    if (sortOption === true) {

666✔

400

        return files.sort(sortAlphabetical);

36✔

401

36✔

402

    else if (typeof sortOption === 'string') {

180✔

403

        switch (sortOption) {

144✔

404

            case SortMethodPredefined.ALPHABETICAL:

144✔

405

                return files.sort(sortAlphabetical);

36✔

406

            case SortMethodPredefined.ALPHABETICAL_REVERSE:

144✔

407

                return files.sort(sortAlphabetical).reverse();

36✔

408

            case SortMethodPredefined.ALPHABETICAL_INSENSITIVE:

144✔

409

                return files.sort(sortAlphabeticalInsensitive);

36✔

410

            case SortMethodPredefined.ALPHABETICAL_INSENSITIVE_REVERSE:

144✔

411

                return files.sort(sortAlphabeticalInsensitive).reverse();

36✔

414

144✔

415

144✔

416

    else if (typeof sortOption === 'function') {

36✔

417

        return files.sort(sortOption);

36✔

418

36✔

419

666✔

420

1✔

424

1✔

428

1✔

440

function postSortFilesFirst(x: Dree, y: Dree): number {

22✔

441

    if (x.type === Type.FILE && y.type === Type.DIRECTORY) {

22✔

442

        return -1;

6✔

443

6✔

444

    if (x.type === Type.DIRECTORY && y.type === Type.FILE) {

22✔

445

        return 1;

6✔

446

6✔

447

    else {

10✔

448

        return 0;

10✔

449

10✔

450

22✔

451

1✔

452

function postSortFiles(nodes: Dree[], postSortOption: boolean | PostSortMethodPredefined | PostSortDiscriminator): Dree[] {

12✔

454

        /* c8 ignore next */

1✔

455

        return nodes;

1✔

457

12✔

461

    else if (typeof postSortOption === 'string') {

12✔

462

        switch (postSortOption) {

12✔

473

            case PostSortMethodPredefined.FILES_FIRST:

12✔

474

                return nodes.sort(postSortFilesFirst);

12✔

477

12✔

478

12✔

482

12✔

483

1✔

484

function sortDreeNodes(dreeNodes: Dree[], sortOption: boolean | SortMethodPredefined | SortDiscriminator): Dree[] {

160✔

485

    if (!sortOption) {

160✔

486

        return dreeNodes;

88✔

487

88✔

488

72✔

489

    if (sortOption === true) {

160✔

490

        return dreeNodes.sort((x, y) => sortAlphabetical(x.relativePath, y.relativePath));

12✔

491

12✔

492

    else if (typeof sortOption === 'string') {

60✔

493

        switch (sortOption) {

48✔

494

            case SortMethodPredefined.ALPHABETICAL:

48✔

495

                return dreeNodes.sort((x, y) => sortAlphabetical(x.relativePath, y.relativePath));

12✔

496

            case SortMethodPredefined.ALPHABETICAL_REVERSE:

48✔

497

                return dreeNodes.sort((x, y) => sortAlphabetical(x.relativePath, y.relativePath)).reverse();

12✔

498

            case SortMethodPredefined.ALPHABETICAL_INSENSITIVE:

48✔

499

                return dreeNodes.sort((x, y) => sortAlphabeticalInsensitive(x.relativePath, y.relativePath));

12✔

500

            case SortMethodPredefined.ALPHABETICAL_INSENSITIVE_REVERSE:

48✔

501

                return dreeNodes.sort((x, y) => sortAlphabeticalInsensitive(x.relativePath, y.relativePath)).reverse();

12✔

504

48✔

505

48✔

506

    else if (typeof sortOption === 'function') {

12✔

507

        return dreeNodes.sort((x, y) => sortOption(x.relativePath, y.relativePath));

12✔

508

12✔

509

160✔

510

1✔

511

function _scan<Node extends Dree = Dree>(root: string, path: string, depth: number, options: ScanOptions, onFile?: Callback<Node>, onDir?: Callback<Node>): Node | null {

808✔

512

    if (options.depth !== undefined && depth > options.depth) {

808✔

513

        return null;

71✔

514

71✔

515

737✔

516

    const relativePath = (root === path) ? '.' : relative(root, path);

808✔

517

808✔

518

    if (options.exclude && root !== path) {

808✔

519

        const excludes = purgePatternsIntoArrayOfRegex(options.exclude);

125✔

520

        if (excludes.some(pattern => pattern.test(`/${relativePath}`))) {

125✔

521

            return null;

14✔

522

14✔

523

125✔

524

723✔

525

    const name = basename(path);

723✔

526

    let stat: Stats;

723✔

527

    try {

723✔

528

        stat = statSync(path);

723✔

529

723✔

530

    catch (exception) {

808✔

531

        if (options.skipErrors) {

3✔

532

            return null;

2✔

533

2✔

534

        else {

1✔

535

            throw exception;

1✔

536

1✔

537

3✔

538

    let lstat: Stats;

720✔

539

    try {

720✔

540

        lstat = lstatSync(path);

720✔

541

720✔

542

    /* c8 ignore start */

1✔

543

    catch (exception) {

1✔

544

        if (options.skipErrors) {

1✔

545

            return null;

1✔

546

1✔

547

        else {

1✔

548

            throw exception;

1✔

549

1✔

550

1✔

551

    /* c8 ignore stop */

1✔

552

    const symbolicLink = lstat.isSymbolicLink();

720✔

553

    const type = stat.isFile() ? Type.FILE : Type.DIRECTORY;

808✔

554

808✔

555

    if (!options.showHidden && name.charAt(0) === '.') {

808✔

556

        return null;

1✔

557

1✔

558

    if (!options.symbolicLinks && symbolicLink) {

808✔

559

        return null;

2✔

560

2✔

561

717✔

562

    let hash: Hash;

717✔

563

    if (options.hash) {

717✔

564

        const hashAlgorithm = options.hashAlgorithm as string;

717✔

565

        hash = createHash(hashAlgorithm);

717✔

566

        hash.update(name);

717✔

567

717✔

568

717✔

569

    const dirTree = {

717✔

570

        name: name,

717✔

571

        path: options.normalize ? path.replace(/\\/g, '/') : path,

808✔

572

        relativePath: options.normalize ? relativePath.replace(/\\/g, '/') : relativePath,

808✔

573

        type: type,

808✔

574

        isSymbolicLink: symbolicLink,

808✔

575

        stat: options.followLinks ? stat : lstat

808✔

576

    } as Node;

808✔

577

    if (!options.stat) {

808✔

578

        delete dirTree.stat;

717✔

579

717✔

580

717✔

581

    switch (type) {

717✔

582

        case Type.DIRECTORY:

808✔

583

            const children: Node[] = [];

373✔

584

            let files: string[];

373✔

585

            if (options.followLinks || !symbolicLink) {

373✔

586

                try {

325✔

587

                    files = readdirSync(path);

325✔

588

                    files = sortFiles(files, options.sorted);

325✔

589

325✔

590

                /* c8 ignore start */

1✔

591

                catch (exception) {

1✔

592

                    if (options.skipErrors) {

1✔

593

                        return null;

1✔

594

1✔

595

                    else {

1✔

596

                        throw exception;

1✔

597

1✔

598

1✔

599

                /* c8 ignore stop */

1✔

600

                if (options.emptyDirectory) {

325✔

601

                    dirTree.isEmpty = !files.length

5✔

602

5✔

603

                files.forEach(file => {

325✔

604

                    const child: Node | null = _scan<Node>(root, resolve(path, file), depth + 1, options, onFile, onDir);

752✔

605

                    if (child !== null) {

752✔

606

                        children.push(child);

638✔

607

638✔

608

});

325✔

609

                if (options.excludeEmptyDirectories && !children.length) {

325✔

610

                    return null;

2✔

611

2✔

612

325✔

613

            if (options.matches && root !== path) {

373✔

614

                const handledMatches = purgePatternsIntoArrayOfRegex(options.matches);

12✔

615

                if (!children.length && handledMatches.some(pattern => !pattern.test(`/${relativePath}`))) {

12✔

616

                    return null;

8✔

617

8✔

618

12✔

619

            if (options.sizeInBytes || options.size) {

373✔

620

                const size = children.reduce((previous, current) => previous + (current.sizeInBytes as number), 0);

363✔

621

                dirTree.sizeInBytes = size;

363✔

623

                if (!options.sizeInBytes) {

363✔

624

                    children.forEach(child => child.sizeInBytes = undefined);

7✔

625

7✔

626

363✔

627

            if (options.hash) {

363✔

628

                children.forEach(child => {

363✔

629

                    hash.update(child.hash);

638✔

630

});

363✔

631

                const hashEncoding = options.hashEncoding as BinaryToTextEncoding;

363✔

632

                dirTree.hash = hash.digest(hashEncoding);

363✔

633

363✔

634

            if (options.descendants) {

373✔

635

                dirTree.descendants = children.reduce((acc, child) => acc + (child.type === Type.DIRECTORY && options.descendantsIgnoreDirectories ? 0 : 1) + (child.descendants ?? 0), 0);

14✔

636

14✔

637

            if (children.length) {

373✔

638

                dirTree.children = options.postSorted ? postSortFiles(children, options.postSorted) : children;

295✔

639

295✔

640

            break;

363✔

641

        case Type.FILE:

808✔

642

            dirTree.extension = extname(path).replace('.', '');

344✔

643

            if (options.extensions && options.extensions.indexOf(dirTree.extension) === -1) {

344✔

644

                return null;

5✔

645

5✔

646

            if (options.matches && root !== path) {

344✔

647

                const handledMatches = purgePatternsIntoArrayOfRegex(options.matches);

14✔

648

                if (handledMatches.some(pattern => !pattern.test(`/${relativePath}`))) {

14✔

649

                    return null;

11✔

650

11✔

651

14✔

652

            if (options.sizeInBytes || options.size) {

344✔

653

                const size = (options.followLinks ? stat.size : lstat.size);

328✔

654

                dirTree.sizeInBytes = size;

328✔

656

328✔

657

            if (options.hash) {

328✔

658

                let data: Buffer;

328✔

659

                try {

328✔

660

                    data = readFileSync(path);

328✔

661

328✔

662

                /* c8 ignore start */

1✔

663

                catch (exception) {

1✔

664

                    if (options.skipErrors) {

1✔

665

                        return null;

1✔

666

1✔

667

                    else {

1✔

668

                        throw exception;

1✔

669

1✔

670

1✔

671

                /* c8 ignore end */

1✔

672

                hash.update(data);

1✔

673

                const hashEncoding = options.hashEncoding as BinaryToTextEncoding;

1✔

674

                dirTree.hash = hash.digest(hashEncoding);

1✔

675

1✔

676

            break;

1✔

677

        /* c8 ignore start */

1✔

678

        default:

1✔

679

            return null;

1✔

680

        /* c8 ignore end */

1✔

681

1✔

682

1✔

683

    if (onFile && type === Type.FILE) {

1✔

684

        onFile(dirTree, options.followLinks ? stat : lstat);

1✔

685

1✔

686

    else if (onDir && type === Type.DIRECTORY) {

1✔

687

        onDir(dirTree, options.followLinks ? stat : lstat);

1✔

688

1✔

689

1✔

690

    return dirTree;

1✔

691

1✔

692

1✔

693

async function _scanAsync<Node extends Dree = Dree>(root: string, path: string, depth: number, options: ScanOptions, onFile?: CallbackAsync<Node>, onDir?: CallbackAsync<Node>): Promise<Node | null> {

1✔

694

1✔

695

    if (options.depth !== undefined && depth > options.depth) {

1✔

696

        return null;

1✔

697

1✔

698

1✔

699

    const relativePath = (root === path) ? '.' : relative(root, path);

1✔

700

1✔

701

    if (options.exclude && root !== path) {

1✔

702

        const excludes = purgePatternsIntoArrayOfRegex(options.exclude);

1✔

703

        if (excludes.some(pattern => pattern.test(`/${relativePath}`))) {

1✔

704

            return null;

1✔

705

1✔

706

1✔

707

1✔

708

    const name = basename(path);

1✔

709

    let stat: Stats;

1✔

710

    try {

1✔

711

        stat = await statAsync(path);

1✔

712

1✔

713

    /* c8 ignore start */

1✔

714

    catch (exception) {

1✔

715

        if (options.skipErrors) {

1✔

716

            return null;

1✔

717

1✔

718

        else {

1✔

719

            throw exception;

1✔

720

1✔

721

1✔

722

    /* c8 ignore end */

1✔

723

    let lstat: Stats;

1✔

724

    try {

1✔

725

        lstat = await lstatAsync(path);

1✔

726

1✔

727

    /* c8 ignore start */

1✔

728

    catch (exception) {

1✔

729

        if (options.skipErrors) {

1✔

730

            return null;

1✔

731

1✔

732

        else {

1✔

733

            throw exception;

1✔

734

1✔

735

1✔

736

    /* c8 ignore end */

1✔

737

    const symbolicLink = lstat.isSymbolicLink();

1✔

738

    const type = stat.isFile() ? Type.FILE : Type.DIRECTORY;

1✔

739

1✔

740

    if (!options.showHidden && name.charAt(0) === '.') {

1✔

741

        return null;

1✔

742

1✔

743

    if (!options.symbolicLinks && symbolicLink) {

1✔

744

        return null;

1✔

745

1✔

746

1✔

747

    let hash: any;

1✔

748

    if (options.hash) {

1✔

749

        const hashAlgorithm = options.hashAlgorithm as string;

1✔

750

        hash = createHash(hashAlgorithm);

1✔

751

        hash.update(name);

1✔

752

1✔

753

1✔

754

    const dirTree = {

1✔

755

        name: name,

1✔

756

        path: options.normalize ? path.replace(/\\/g, '/') : path,

1✔

757

        relativePath: options.normalize ? relativePath.replace(/\\/g, '/') : relativePath,

1✔

758

        type: type,

1✔

759

        isSymbolicLink: symbolicLink,

1✔

760

        stat: options.followLinks ? stat : lstat

1✔

761

    } as Node;

1✔

762

    if (!options.stat) {

1✔

763

        delete dirTree.stat;

1✔

764

1✔

765

1✔

766

    switch (type) {

1✔

767

        case Type.DIRECTORY:

1✔

768

            let children: Dree[] = [];

1✔

769

            let files: string[];

1✔

770

            if (options.followLinks || !symbolicLink) {

1✔

771

                try {

1✔

772

                    files = await readdirAsync(path);

1✔

773

                    files = sortFiles(files, options.sorted);

1✔

774

1✔

775

                /* c8 ignore start */

1✔

776

                catch (exception) {

1✔

777

                    if (options.skipErrors) {

1✔

778

                        return null;

1✔

779

1✔

780

                    else {

1✔

781

                        throw exception;

1✔

782

1✔

783

1✔

784

                /* c8 ignore end */

1✔

785

                if (options.emptyDirectory) {

1✔

786

                    dirTree.isEmpty = !files.length

1✔

787

1✔

788

                children = await Promise.all(files.map(async file => {

1✔

789

                    const child: Node | null = await _scanAsync<Node>(root, resolve(path, file), depth + 1, options, onFile, onDir);

1✔

790

                    return child;

1✔

791

                }));

1✔

792

                children = children.filter(ch => ch !== null);

1✔

793

                if (options.excludeEmptyDirectories && !children.length) {

1✔

794

                    return null;

1✔

795

1✔

796

1✔

797

            if (options.matches && root !== path) {

1✔

798

                const handledMatches = purgePatternsIntoArrayOfRegex(options.matches);

1✔

799

                if (!children.length && handledMatches.some(pattern => !pattern.test(`/${relativePath}`))) {

1✔

800

                    return null;

1✔

801

1✔

802

1✔

803

            if (options.sizeInBytes || options.size) {

1✔

804

                const size = children.reduce((previous, current) => previous + (current.sizeInBytes as number), 0);

1✔

805

                dirTree.sizeInBytes = size;

1✔

806

                dirTree.size = options.size ? parseSize(size) : undefined;

1✔

807

                if (!options.sizeInBytes) {

1✔

808

                    children.forEach(child => child.sizeInBytes = undefined);

1✔

809

1✔

810

1✔

811

            if (options.hash) {

1✔

812

                children.forEach(child => {

1✔

813

                    hash.update(child.hash);

1✔

814

});

1✔

815

                const hashEncoding = options.hashEncoding as BinaryToTextEncoding;

1✔

816

                dirTree.hash = hash.digest(hashEncoding);

1✔

817

1✔

818

            if (options.descendants) {

1✔

819

                dirTree.descendants = children.reduce((acc, child) => acc + (child.type === Type.DIRECTORY && options.descendantsIgnoreDirectories ? 0 : 1) + (child.descendants ?? 0), 0);

1✔

820

1✔

821

            if (children.length) {

1✔

822

                dirTree.children = options.postSorted ? postSortFiles(children, options.postSorted) : children;

1✔

823

1✔

824

            break;

1✔

825

        case Type.FILE:

1✔

826

            dirTree.extension = extname(path).replace('.', '');

1✔

827

            if (options.extensions && options.extensions.indexOf(dirTree.extension) === -1) {

1✔

828

                return null;

1✔

829

1✔

830

            if (options.matches && root !== path) {

1✔

831

                const handledMatches = purgePatternsIntoArrayOfRegex(options.matches);

1✔

832

                if (handledMatches.some(pattern => !pattern.test(`/${relativePath}`))) {

1✔

833

                    return null;

1✔

834

1✔

835

1✔

836

            if (options.sizeInBytes || options.size) {

1✔

837

                const size = (options.followLinks ? stat.size : lstat.size);

1✔

838

                dirTree.sizeInBytes = size;

1✔

839

                dirTree.size = options.size ? parseSize(size) : undefined;

1✔

840

1✔

841

            if (options.hash) {

1✔

842

                let data: Buffer;

1✔

843

                try {

1✔

844

                    data = await readFileAsync(path);

1✔

845

1✔

846

                /* c8 ignore start */

1✔

847

                catch (exception) {

1✔

848

                    if (options.skipErrors) {

1✔

849

                        return null;

1✔

850

1✔

851

                    else {

1✔

852

                        throw exception;

1✔

853

1✔

854

1✔

855

                /* c8 ignore end */

1✔

856

                hash.update(data);

1✔

857

                const hashEncoding = options.hashEncoding as BinaryToTextEncoding;

1✔

858

                dirTree.hash = hash.digest(hashEncoding);

1✔

859

1✔

860

            break;

1✔

861

        /* c8 ignore start */

1✔

862

        default:

1✔

863

            return null;

1✔

864

        /* c8 ignore end */

1✔

865

1✔

866

1✔

867

    if (onFile && type === Type.FILE) {

1✔

868

        await onFile(dirTree, options.followLinks ? stat : lstat);

1✔

869

1✔

870

    else if (onDir && type === Type.DIRECTORY) {

1✔

871

        await onDir(dirTree, options.followLinks ? stat : lstat);

1✔

872

1✔

873

1✔

874

    return dirTree;

1✔

875

1✔

876

1✔

877

function skip(child: Dree, options: ParseOptions, depth: number): boolean {

1✔

878

    return (!options.symbolicLinks && child.isSymbolicLink)

1✔

879

        || (!options.showHidden && child.name.charAt(0) === '.')

1✔

880

        || (options.extensions !== undefined && child.type === Type.FILE

1✔

881

            && (options.extensions.indexOf(child.extension as string) === -1))

1✔

882

        || (options.exclude && purgePatternsIntoArrayOfRegex(options.exclude).some(pattern => pattern.test(`/${child.relativePath}`)))

1✔

883

        || (options.depth !== undefined && depth > options.depth);

1✔

884

1✔

885

1✔

886

function _parse(root: string, children: string[], prefix: string, options: ParseOptions, depth: number): string {

1✔

887

    let result = '';

1✔

888

    const lines = children.map((child, index) => {

1✔

889

        let result = '';

1✔

890

1✔

891

        if (options.depth !== undefined && depth > options.depth) {

1✔

892

            return '';

1✔

893

1✔

894

1✔

895

        if (options.exclude) {

1✔

896

            const excludes = purgePatternsIntoArrayOfRegex(options.exclude);

1✔

897

            if (excludes.some(pattern => pattern.test(`/${relative(root, child)}`))) {

1✔

898

                return '';

1✔

899

1✔

900

1✔

901

1✔

902

        const name = basename(child);

1✔

903

        let stat: Stats;

1✔

904

        try {

1✔

905

            stat = statSync(child);

1✔

906

1✔

907

        /* c8 ignore start */

1✔

908

        catch (exception) {

1✔

909

            if (options.skipErrors) {

1✔

910

                return null;

1✔

911

1✔

912

            else {

1✔

913

                throw exception;

1✔

914

1✔

915

1✔

916

        /* c8 ignore end */

1✔

917

        let lstat: Stats;

1✔

918

        try {

1✔

919

            lstat = lstatSync(child);

1✔

920

1✔

921

        /* c8 ignore start */

1✔

922

        catch (exception) {

1✔

923

            if (options.skipErrors) {

1✔

924

                return null;

1✔

925

1✔

926

            else {

1✔

927

                throw exception;

1✔

928

1✔

929

1✔

930

        /* c8 ignore end */

1✔

931

        const symbolicLink = lstat.isSymbolicLink();

1✔

932

        const type = stat.isFile() ? Type.FILE : Type.DIRECTORY;

1✔

933

1✔

934

        if (!options.showHidden && name.charAt(0) === '.') {

1✔

935

            return '';

1✔

936

1✔

937

        if (!options.symbolicLinks && symbolicLink) {

1✔

938

            return '';

1✔

939

1✔

940

        const extension = extname(child).replace('.', '');

1✔

941

        if (options.extensions && type === Type.FILE && options.extensions.indexOf(extension) === -1) {

1✔

942

            return '';

1✔

943

1✔

944

1✔

945

        const last = symbolicLink ? '>>' : (type === Type.DIRECTORY ? '─> ' : '── ');

1✔

946

        const newPrefix = prefix + (index === children.length - 1 ? '    ' : '│   ');

1✔

947

        result += last + name;

1✔

948

1✔

949

        if ((options.followLinks || !symbolicLink) && type === Type.DIRECTORY) {

1✔

950

            let children: string[];

1✔

951

            try {

1✔

952

                children = readdirSync(child).map(file => resolve(child, file));

1✔

953

                children = sortFiles(children, options.sorted);

1✔

954

1✔

955

            /* c8 ignore start */

1✔

956

            catch (exception) {

1✔

957

                if (options.skipErrors) {

1✔

958

                    return null;

1✔

959

1✔

960

                else {

1✔

961

                    throw exception;

1✔

962

1✔

963

1✔

964

            /* c8 ignore end */

1✔

965

            result += children.length ? _parse(root, children, newPrefix, options, depth + 1) : '';

1✔

966

1✔

967

1✔

968

        return result;

1✔

969

});

1✔

970

    lines.filter(line => !!line).forEach((line, index, lines) => {

1✔

971

        result += prefix + (index === lines.length - 1 ? '└' + line : '├' + line);

1✔

972

});

1✔

973

    return result;

1✔

974

1✔

975

1✔

976

async function _parseAsync(root: string, children: string[], prefix: string, options: ParseOptions, depth: number): Promise<string> {

1✔

977

    let result = '';

1✔

978

    const lines = await Promise.all(children.map(async (child, index) => {

1✔

979

        let result = '';

1✔

980

1✔

981

        if (options.depth !== undefined && depth > options.depth) {

1✔

982

            return '';

1✔

983

1✔

984

1✔

985

        if (options.exclude) {

1✔

986

            const excludes = purgePatternsIntoArrayOfRegex(options.exclude);

1✔

987

            if (excludes.some(pattern => pattern.test(`/${relative(root, child)}`))) {

1✔

988

                return '';

1✔

989

1✔

990

1✔

991

1✔

992

        const name = basename(child);

1✔

993

        let stat: Stats;

1✔

994

        try {

1✔

995

            stat = await statAsync(child);

1✔

996

1✔

997

        /* c8 ignore start */

1✔

998

        catch (exception) {

1✔

999

            if (options.skipErrors) {

1✔

1000

                return null;

1✔

1001

1✔

1002

            else {

1✔

1003

                throw exception;

1✔

1004

1✔

1005

1✔

1006

        /* c8 ignore end */

1✔

1007

        let lstat: Stats;

1✔

1008

        try {

1✔

1009

            lstat = await lstatAsync(child);

1✔

1010

1✔

1011

        /* c8 ignore start */

1✔

1012

        catch (exception) {

1✔

1013

            if (options.skipErrors) {

1✔

1014

                return null;

1✔

1015

1✔

1016

            else {

1✔

1017

                throw exception;

1✔

1018

1✔

1019

1✔

1020

        /* c8 ignore end */

1✔

1021

        const symbolicLink = lstat.isSymbolicLink();

1✔

1022

        const type = stat.isFile() ? Type.FILE : Type.DIRECTORY;

1✔

1023

1✔

1024

        if (!options.showHidden && name.charAt(0) === '.') {

1✔

1025

            return '';

1✔

1026

1✔

1027

        if (!options.symbolicLinks && symbolicLink) {

1✔

1028

            return '';

1✔

1029

1✔

1030

        const extension = extname(child).replace('.', '');

1✔

1031

        if (options.extensions && type === Type.FILE && options.extensions.indexOf(extension) === -1) {

1✔

1032

            return '';

1✔

1033

1✔

1034

1✔

1035

        const last = symbolicLink ? '>>' : (type === Type.DIRECTORY ? '─> ' : '── ');

1✔

1036

        const newPrefix = prefix + (index === children.length - 1 ? '    ' : '│   ');

1✔

1037

        result += last + name;

1✔

1038

1✔

1039

        if ((options.followLinks || !symbolicLink) && type === Type.DIRECTORY) {

1✔

1040

            let children: string[];

1✔

1041

            try {

1✔

1042

                children = (await readdirAsync(child)).map(file => resolve(child, file));

1✔

1043

                children = sortFiles(children, options.sorted);

1✔

1044

1✔

1045

            /* c8 ignore start */

1✔

1046

            catch (exception) {

1✔

1047

                if (options.skipErrors) {

1✔

1048

                    return null;

1✔

1049

1✔

1050

                else {

1✔

1051

                    throw exception;

1✔

1052

1✔

1053

1✔

1054

            /* c8 ignore end */

1✔

1055

            result += children.length ? (await _parseAsync(root, children, newPrefix, options, depth + 1)) : '';

1✔

1056

1✔

1057

1✔

1058

        return result;

1✔

1059

    }));

1✔

1060

    lines.filter(line => !!line).forEach((line, index, lines) => {

1✔

1061

        result += prefix + (index === lines.length - 1 ? '└' + line : '├' + line);

1✔

1062

});

1✔

1063

    return result;

1✔

1064

1✔

1065

1✔

1066

function _parseTree(children: Dree[], prefix: string, options: ParseOptions, depth: number): string {

1✔

1067

    let result = '';

1✔

1068

    children = sortDreeNodes(children, options.sorted);

1✔

1069

    children

1✔

1070

        .filter(child => !skip(child, options, depth))

1✔

1071

        .forEach((child, index, children) => {

1✔

1072

            const last = child.isSymbolicLink ? '>>' : (child.type === Type.DIRECTORY ? '─> ' : '── ');

1✔

1073

            const line = (index === children.length - 1) ? '└' + last : '├' + last;

1✔

1074

            const newPrefix = prefix + (index === children.length - 1 ? '    ' : '│   ');

1✔

1075

            result += prefix + line + child.name;

1✔

1076

            result += (child.children && (options.followLinks || !child.isSymbolicLink) ? _parseTree(child.children, newPrefix, options, depth + 1) : '');

1✔

1077

});

1✔

1078

    return result;

1✔

1079

1✔

1080

1✔

1081

async function _parseTreeAsync(children: Dree[], prefix: string, options: ParseOptions, depth: number): Promise<string> {

1✔

1082

    let result = '';

1✔

1083

    children = sortDreeNodes(children, options.sorted);

1✔

1084

    const filteredChildren = children.filter(child => !skip(child, options, depth));

1✔

1085

    for (let index = 0; index < filteredChildren.length; index++) {

1✔

1086

        const child = filteredChildren[index];

1✔

1087

        const last = child.isSymbolicLink ? '>>' : (child.type === Type.DIRECTORY ? '─> ' : '── ');

1✔

1088

        const line = (index === filteredChildren.length - 1) ? '└' + last : '├' + last;

1✔

1089

        const newPrefix = prefix + (index === filteredChildren.length - 1 ? '    ' : '│   ');

1✔

1090

        result += prefix + line + child.name;

1✔

1091

        result += (child.children && (options.followLinks || !child.isSymbolicLink) ? (await _parseTreeAsync(child.children, newPrefix, options, depth + 1)) : '');

1✔

1092

1✔

1093

    return result;

1✔

1094

1✔

1095

1✔

1096

/* EXPORTED FUNCTIONS */

1✔

1097

1✔

1098

/**

1✔

1099

 * Returns the Directory Tree of a given path. This function in synchronous.

1✔

1100

 * @param  {string} path The path which you want to inspect

1✔

1101

 * @param  {object} options An object used as options of the function

1✔

1102

 * @param  {function} onFile A function called when a file is added. It has the tree object and its stat as parameters. The object can me changed and extended here, on typescript there the function uses indeed generics.

1✔

1103

 * @param  {function} onDir A function called when a dir is added. It has the tree object and its stat as parameters. The object can me changed and extended here, on typescript there the function uses indeed generics.

1✔

1104

 * @return {object} The directory tree as a Dree object

1✔

1105

 * @template Node The type of the tree object, which can be extended and changed by the onFile and onDir functions.

1✔

1106

*/

1✔

1107

export function scan<Node extends Dree = Dree>(path: string, options?: ScanOptions, onFile?: Callback<Node>, onDir?: Callback<Node>): Node {

1✔

1108

    const opt = mergeScanOptions(options);

1✔

1109

    const root = resolvePath(path, opt);

1✔

1110

    const result = _scan<Node>(root, root, 0, opt, onFile, onDir);

1✔

1111

    if (result) {

1✔

1112

        result.sizeInBytes = opt.sizeInBytes ? result.sizeInBytes : undefined;

1✔

1113

1✔

1114

    return result;

1✔

1115

1✔

1116

1✔

1117

/**

1✔

1118

 * Returns in a promise the Directory Tree of a given path. This function is asynchronous.

1✔

1119

 * @param  {string} path The path which you want to inspect

1✔

1120

 * @param  {object} options An object used as options of the function

1✔

1121

 * @param  {function} onFile A function called when a file is added - has the tree object and its stat as parameters

1✔

1122

 * @param  {function} onDir A function called when a dir is added - has the tree object and its stat as parameters

1✔

1123

 * @return {Promise<object>} A promise to the directory tree as a Dree object

1✔

1124

 * @template Node The type of the tree object, which can be extended and changed by the onFile and onDir functions.

1✔

1125

*/

1✔

1126

export async function scanAsync<Node extends Dree = Dree>(path: string, options?: ScanOptions, onFile?: CallbackAsync<Node>, onDir?: CallbackAsync<Node>): Promise<Node> {

1✔

1127

    const opt = mergeScanOptions(options);

1✔

1128

    const root = resolvePath(path, opt);

1✔

1129

    const result = await _scanAsync<Node>(root, root, 0, opt, onFile, onDir);

1✔

1130

    if (result) {

1✔

1131

        result.sizeInBytes = opt.sizeInBytes ? result.sizeInBytes : undefined;

1✔

1132

1✔

1133

    return result;

1✔

1134

1✔

1135

1✔

1136

/**

1✔

1137

 * Returns a string representation of a Directory Tree given a path to a directory or file

1✔

1138

 * @param  {string} path The path which you want to inspect

1✔

1139

 * @param  {object} options An object used as options of the function

1✔

1140

 * @return {string} A string representing the Directory Tree of the given path

1✔

1141

*/

1✔

1142

export function parse(path: string, options?: ParseOptions): string {

1✔

1143

    let result = '';

1✔

1144

1✔

1145

    const opt = mergeParseOptions(options);

1✔

1146

    const root = resolvePath(path, opt);

1✔

1147

    const name = basename(root);

1✔

1148

    result += name;

1✔

1149

1✔

1150

    let stat: Stats;

1✔

1151

    try {

1✔

1152

        stat = statSync(root);

1✔

1153

1✔

1154

    /* c8 ignore start */

1✔

1155

    catch (exception) {

1✔

1156

        if (opt.skipErrors) {

1✔

1157

            return null;

1✔

1158

1✔

1159

        else {

1✔

1160

            throw exception;

1✔

1161

1✔

1162

1✔

1163

    /* c8 ignore end */

1✔

1164

    let lstat: Stats;

1✔

1165

    try {

1✔

1166

        lstat = lstatSync(root);

1✔

1167

1✔

1168

    /* c8 ignore start */

1✔

1169

    catch (exception) {

1✔

1170

        if (opt.skipErrors) {

1✔

1171

            return null;

1✔

1172

1✔

1173

        else {

1✔

1174

            throw exception;

1✔

1175

1✔

1176

1✔

1177

    /* c8 ignore end */

1✔

1178

    const symbolicLink = lstat.isSymbolicLink();

1✔

1179

1✔

1180

    if ((opt.followLinks || !symbolicLink) && stat.isDirectory()) {

1✔

1181

        let children: string[];

1✔

1182

        try {

1✔

1183

            children = readdirSync(root).map(file => resolve(root, file));

1✔

1184

            children = sortFiles(children, opt.sorted);

1✔

1185

1✔

1186

        /* c8 ignore start */

1✔

1187

        catch (exception) {

1✔

1188

            if (opt.skipErrors) {

1✔

1189

                return null;

1✔

1190

1✔

1191

            else {

1✔

1192

                throw exception;

1✔

1193

1✔

1194

1✔

1195

        /* c8 ignore end */

1✔

1196

        result += children.length ? _parse(root, children, '\n ', opt, 1) : '';

1✔

1197

1✔

1198

1✔

1199

    return result;

1✔

1200

1✔

1201

1✔

1202

/**

1✔

1203

 * Returns a promise to a string representation of a Directory Tree given a path to a directory or file

1✔

1204

 * @param  {string} path The path which you want to inspect

1✔

1205

 * @param  {object} options An object used as options of the function

1✔

1206

 * @return {Promise<string>} A promise to a string representing the Directory Tree of the given path

1✔

1207

*/

1✔

1208

export async function parseAsync(path: string, options?: ParseOptions): Promise<string> {

1✔

1209

    let result = '';

1✔

1210

1✔

1211

    const opt = mergeParseOptions(options);

1✔

1212

    const root = resolvePath(path, opt);

1✔

1213

    const name = basename(root);

1✔

1214

    result += name;

1✔

1215

1✔

1216

    let stat: Stats;

1✔

1217

    try {

1✔

1218

        stat = await statAsync(root);

1✔

1219

1✔

1220

    /* c8 ignore start */

1✔

1221

    catch (exception) {

1✔

1222

        if (opt.skipErrors) {

1✔

1223

            return null;

1✔

1224

1✔

1225

        else {

1✔

1226

            throw exception;

1✔

1227

1✔

1228

1✔

1229

    /* c8 ignore end */

1✔

1230

    let lstat: Stats;

1✔

1231

    try {

1✔

1232

        lstat = await lstatAsync(root);

1✔

1233

1✔

1234

    /* c8 ignore start */

1✔

1235

    catch (exception) {

1✔

1236

        if (opt.skipErrors) {

1✔

1237

            return null;

1✔

1238

1✔

1239

        else {

1✔

1240

            throw exception;

1✔

1241

1✔

1242

1✔

1243

    /* c8 ignore end */

1✔

1244

    const symbolicLink = lstat.isSymbolicLink();

1✔

1245

1✔

1246

    if ((opt.followLinks || !symbolicLink) && stat.isDirectory()) {

1✔

1247

        let children: string[];

1✔

1248

        try {

1✔

1249

            children = (await readdirAsync(root)).map(file => resolve(root, file));

1✔

1250

            children = sortFiles(children, opt.sorted);

1✔

1251

1✔

1252

        /* c8 ignore start */

1✔

1253

        catch (exception) {

1✔

1254

            if (opt.skipErrors) {

1✔

1255

                return null;

1✔

1256

1✔

1257

            else {

1✔

1258

                throw exception;

1✔

1259

1✔

1260

1✔

1261

        /* c8 ignore end */

1✔

1262

        result += children.length ? (await _parseAsync(root, children, '\n ', opt, 1)) : '';

1✔

1263

1✔

1264

1✔

1265

    return result;

1✔

1266

1✔

1267

1✔

1268

/**

1✔

1269

 * Returns a string representation of a Directory Tree given an object returned from scan

1✔

1270

 * @param  {object} dirTree The object returned from scan, which will be parsed

1✔

1271

 * @param  {object} options An object used as options of the function

1✔

1272

 * @return {string} A string representing the object given as first parameter

1✔

1273

*/

1✔

1274

export function parseTree(dirTree: Dree, options?: ParseOptions): string {

1✔

1275

    let result = '';

1✔

1276

    const opt = mergeParseOptions(options);

1✔

1277

    result += dirTree ? dirTree.name : '';

1✔

1278

    result += (dirTree.children ? _parseTree(dirTree.children, '\n ', opt, 1) : '');

1✔

1279

    return result;

1✔

1280

1✔

1281

1✔

1282

/**

1✔

1283

 * Returns a promise to a string representation of a Directory Tree given an object returned from scan

1✔

1284

 * @param  {object} dirTree The object returned from scan, which will be parsed

1✔

1285

 * @param  {object} options An object used as options of the function

1✔

1286

 * @return {Promise<string>} A promise to a string representing the object given as first parameter

1✔

1287

*/

1✔

1288

export async function parseTreeAsync(dirTree: Dree, options?: ParseOptions): Promise<string> {

1✔

1289

    let result = '';

1✔

1290

    const opt = mergeParseOptions(options);

1✔

1291

    result += dirTree ? dirTree.name : '';

1✔

1292

    result += (dirTree.children ? (await _parseTreeAsync(dirTree.children, '\n ', opt, 1)) : '');

1✔

1293

    return result;

1✔

1294

1✔

euberdeveloper / dree / 9488762248

Source File
Press 'n' to go to next uncovered line, 'b' for previous

euberdeveloper / dree / 9488762248

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous