source control 1.1

Tomas

2022-05-19 957a1f10a06fdbb76f1a0ba94fe44126c613fee3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
"use strict";
 
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ExplorerSync = void 0;
 
var _path = _interopRequireDefault(require("path"));
 
var _ExplorerBase = require("./ExplorerBase");
 
var _readFile = require("./readFile");
 
var _cacheWrapper = require("./cacheWrapper");
 
var _getDirectory = require("./getDirectory");
 
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
class ExplorerSync extends _ExplorerBase.ExplorerBase {
  constructor(options) {
    super(options);
  }
 
  searchSync(searchFrom = process.cwd()) {
    const startDirectory = (0, _getDirectory.getDirectorySync)(searchFrom);
    const result = this.searchFromDirectorySync(startDirectory);
    return result;
  }
 
  searchFromDirectorySync(dir) {
    const absoluteDir = _path.default.resolve(process.cwd(), dir);
 
    const run = () => {
      const result = this.searchDirectorySync(absoluteDir);
      const nextDir = this.nextDirectoryToSearch(absoluteDir, result);
 
      if (nextDir) {
        return this.searchFromDirectorySync(nextDir);
      }
 
      const transformResult = this.config.transform(result);
      return transformResult;
    };
 
    if (this.searchCache) {
      return (0, _cacheWrapper.cacheWrapperSync)(this.searchCache, absoluteDir, run);
    }
 
    return run();
  }
 
  searchDirectorySync(dir) {
    for (const place of this.config.searchPlaces) {
      const placeResult = this.loadSearchPlaceSync(dir, place);
 
      if (this.shouldSearchStopWithResult(placeResult) === true) {
        return placeResult;
      }
    } // config not found
 
 
    return null;
  }
 
  loadSearchPlaceSync(dir, place) {
    const filepath = _path.default.join(dir, place);
 
    const content = (0, _readFile.readFileSync)(filepath);
    const result = this.createCosmiconfigResultSync(filepath, content);
    return result;
  }
 
  loadFileContentSync(filepath, content) {
    if (content === null) {
      return null;
    }
 
    if (content.trim() === '') {
      return undefined;
    }
 
    const loader = this.getLoaderEntryForFile(filepath);
    const loaderResult = loader(filepath, content);
    return loaderResult;
  }
 
  createCosmiconfigResultSync(filepath, content) {
    const fileContent = this.loadFileContentSync(filepath, content);
    const result = this.loadedContentToCosmiconfigResult(filepath, fileContent);
    return result;
  }
 
  loadSync(filepath) {
    this.validateFilePath(filepath);
 
    const absoluteFilePath = _path.default.resolve(process.cwd(), filepath);
 
    const runLoadSync = () => {
      const content = (0, _readFile.readFileSync)(absoluteFilePath, {
        throwNotFound: true
      });
      const cosmiconfigResult = this.createCosmiconfigResultSync(absoluteFilePath, content);
      const transformResult = this.config.transform(cosmiconfigResult);
      return transformResult;
    };
 
    if (this.loadCache) {
      return (0, _cacheWrapper.cacheWrapperSync)(this.loadCache, absoluteFilePath, runLoadSync);
    }
 
    return runLoadSync();
  }
 
}
 
exports.ExplorerSync = ExplorerSync;
//# sourceMappingURL=ExplorerSync.js.map