Blame view

node_modules/less/lib/less-browser/file-manager.js 4.08 KB
ce4c83ff   wxy   初始提交
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
  /* global window, XMLHttpRequest */
  
  module.exports = function(options, logger) {
  
      var AbstractFileManager = require('../less/environment/abstract-file-manager.js');
  
      var fileCache = {};
  
      // TODOS - move log somewhere. pathDiff and doing something similar in node. use pathDiff in the other browser file for the initial load
      var FileManager = function() {
      };
  
      FileManager.prototype = new AbstractFileManager();
  
      FileManager.prototype.alwaysMakePathsAbsolute = function alwaysMakePathsAbsolute() {
          return true;
      };
      FileManager.prototype.join = function join(basePath, laterPath) {
          if (!basePath) {
              return laterPath;
          }
          return this.extractUrlParts(laterPath, basePath).path;
      };
      FileManager.prototype.doXHR = function doXHR(url, type, callback, errback) {
  
          var xhr = new XMLHttpRequest();
          var async = options.isFileProtocol ? options.fileAsync : true;
  
          if (typeof xhr.overrideMimeType === 'function') {
              xhr.overrideMimeType('text/css');
          }
          logger.debug('XHR: Getting \'' + url + '\'');
          xhr.open('GET', url, async);
          xhr.setRequestHeader('Accept', type || 'text/x-less, text/css; q=0.9, */*; q=0.5');
          xhr.send(null);
  
          function handleResponse(xhr, callback, errback) {
              if (xhr.status >= 200 && xhr.status < 300) {
                  callback(xhr.responseText,
                      xhr.getResponseHeader('Last-Modified'));
              } else if (typeof errback === 'function') {
                  errback(xhr.status, url);
              }
          }
  
          if (options.isFileProtocol && !options.fileAsync) {
              if (xhr.status === 0 || (xhr.status >= 200 && xhr.status < 300)) {
                  callback(xhr.responseText);
              } else {
                  errback(xhr.status, url);
              }
          } else if (async) {
              xhr.onreadystatechange = function () {
                  if (xhr.readyState == 4) {
                      handleResponse(xhr, callback, errback);
                  }
              };
          } else {
              handleResponse(xhr, callback, errback);
          }
      };
      FileManager.prototype.supports = function(filename, currentDirectory, options, environment) {
          return true;
      };
  
      FileManager.prototype.clearFileCache = function() {
          fileCache = {};
      };
  
      FileManager.prototype.loadFile = function loadFile(filename, currentDirectory, options, environment) {
          // TODO: Add prefix support like less-node?
          // What about multiple paths?
  
          if (currentDirectory && !this.isPathAbsolute(filename)) {
              filename = currentDirectory + filename;
          }
  
          filename = options.ext ? this.tryAppendExtension(filename, options.ext) : filename;
  
          options = options || {};
  
          // sheet may be set to the stylesheet for the initial load or a collection of properties including
          // some context variables for imports
          var hrefParts = this.extractUrlParts(filename, window.location.href);
          var href      = hrefParts.url;
          var self      = this;
          
          return new Promise(function(resolve, reject) {
              if (options.useFileCache && fileCache[href]) {
                  try {
                      var lessText = fileCache[href];
                      return resolve({ contents: lessText, filename: href, webInfo: { lastModified: new Date() }});
                  } catch (e) {
                      return reject({ filename: href, message: 'Error loading file ' + href + ' error was ' + e.message });
                  }
              }
  
              self.doXHR(href, options.mime, function doXHRCallback(data, lastModified) {
                  // per file cache
                  fileCache[href] = data;
  
                  // Use remote copy (re-parse)
                  resolve({ contents: data, filename: href, webInfo: { lastModified: lastModified }});
              }, function doXHRError(status, url) {
                  reject({ type: 'File', message: '\'' + url + '\' wasn\'t found (' + status + ')', href: href });
              });
          });
      };
  
      return FileManager;
  };