docs：更新文档

node_modules/postcss-modules/build/behaviours.js

@@ -0,0 +1,50 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.behaviours = undefined;
+exports.getDefaultPlugins = getDefaultPlugins;
+exports.isValidBehaviour = isValidBehaviour;
+
+var _postcssModulesLocalByDefault = require("postcss-modules-local-by-default");
+
+var _postcssModulesLocalByDefault2 = _interopRequireDefault(_postcssModulesLocalByDefault);
+
+var _postcssModulesExtractImports = require("postcss-modules-extract-imports");
+
+var _postcssModulesExtractImports2 = _interopRequireDefault(_postcssModulesExtractImports);
+
+var _postcssModulesScope = require("postcss-modules-scope");
+
+var _postcssModulesScope2 = _interopRequireDefault(_postcssModulesScope);
+
+var _postcssModulesValues = require("postcss-modules-values");
+
+var _postcssModulesValues2 = _interopRequireDefault(_postcssModulesValues);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const behaviours = exports.behaviours = {
+  LOCAL: "local",
+  GLOBAL: "global"
+};
+
+function getDefaultPlugins({
+  behaviour,
+  generateScopedName,
+  exportGlobals
+}) {
+  const scope = (0, _postcssModulesScope2.default)({ generateScopedName, exportGlobals });
+
+  const plugins = {
+    [behaviours.LOCAL]: [_postcssModulesValues2.default, _postcssModulesLocalByDefault2.default, _postcssModulesExtractImports2.default, scope],
+    [behaviours.GLOBAL]: [_postcssModulesValues2.default, _postcssModulesExtractImports2.default, scope]
+  };
+
+  return plugins[behaviour];
+}
+
+function isValidBehaviour(behaviour) {
+  return Object.keys(behaviours).map(key => behaviours[key]).indexOf(behaviour) > -1;
+}

node_modules/postcss-modules/build/css-loader-core/loader.js

@@ -0,0 +1,121 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _postcss = require("postcss");
+
+var _postcss2 = _interopRequireDefault(_postcss);
+
+var _fs = require("fs");
+
+var _fs2 = _interopRequireDefault(_fs);
+
+var _path = require("path");
+
+var _path2 = _interopRequireDefault(_path);
+
+var _parser = require("./parser");
+
+var _parser2 = _interopRequireDefault(_parser);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Copied from https://github.com/css-modules/css-modules-loader-core
+
+class Core {
+  constructor(plugins) {
+    this.plugins = plugins || Core.defaultPlugins;
+  }
+
+  load(sourceString, sourcePath, trace, pathFetcher) {
+    let parser = new _parser2.default(pathFetcher, trace);
+
+    return (0, _postcss2.default)(this.plugins.concat([parser.plugin])).process(sourceString, { from: "/" + sourcePath }).then(result => {
+      return {
+        injectableSource: result.css,
+        exportTokens: parser.exportTokens
+      };
+    });
+  }
+}
+
+// Sorts dependencies in the following way:
+// AAA comes before AA and A
+// AB comes after AA and before A
+// All Bs come after all As
+// This ensures that the files are always returned in the following order:
+// - In the order they were required, except
+// - After all their dependencies
+const traceKeySorter = (a, b) => {
+  if (a.length < b.length) {
+    return a < b.substring(0, a.length) ? -1 : 1;
+  } else if (a.length > b.length) {
+    return a.substring(0, b.length) <= b ? -1 : 1;
+  } else {
+    return a < b ? -1 : 1;
+  }
+};
+
+class FileSystemLoader {
+  constructor(root, plugins) {
+    this.root = root;
+    this.sources = {};
+    this.traces = {};
+    this.importNr = 0;
+    this.core = new Core(plugins);
+    this.tokensByFile = {};
+  }
+
+  fetch(_newPath, relativeTo, _trace) {
+    let newPath = _newPath.replace(/^["']|["']$/g, ""),
+        trace = _trace || String.fromCharCode(this.importNr++);
+    return new Promise((resolve, reject) => {
+      let relativeDir = _path2.default.dirname(relativeTo),
+          rootRelativePath = _path2.default.resolve(relativeDir, newPath),
+          fileRelativePath = _path2.default.resolve(_path2.default.join(this.root, relativeDir), newPath);
+
+      // if the path is not relative or absolute, try to resolve it in node_modules
+      if (newPath[0] !== "." && newPath[0] !== "/") {
+        try {
+          fileRelativePath = require.resolve(newPath);
+        } catch (e) {
+          // noop
+        }
+      }
+
+      const tokens = this.tokensByFile[fileRelativePath];
+      if (tokens) {
+        return resolve(tokens);
+      }
+
+      _fs2.default.readFile(fileRelativePath, "utf-8", (err, source) => {
+        if (err) reject(err);
+        this.core.load(source, rootRelativePath, trace, this.fetch.bind(this)).then(({ injectableSource, exportTokens }) => {
+          this.sources[fileRelativePath] = injectableSource;
+          this.traces[trace] = fileRelativePath;
+          this.tokensByFile[fileRelativePath] = exportTokens;
+          resolve(exportTokens);
+        }, reject);
+      });
+    });
+  }
+
+  get finalSource() {
+    const traces = this.traces;
+    const sources = this.sources;
+    let written = new Set();
+
+    return Object.keys(traces).sort(traceKeySorter).map(key => {
+      const filename = traces[key];
+      if (written.has(filename)) {
+        return null;
+      }
+      written.add(filename);
+
+      return sources[filename];
+    }).join("");
+  }
+}
+exports.default = FileSystemLoader;

node_modules/postcss-modules/build/css-loader-core/parser.js

@@ -0,0 +1,74 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+var _icssReplaceSymbols = require("icss-replace-symbols");
+
+var _icssReplaceSymbols2 = _interopRequireDefault(_icssReplaceSymbols);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// Copied from https://github.com/css-modules/css-modules-loader-core
+
+const importRegexp = /^:import\((.+)\)$/;
+class Parser {
+  constructor(pathFetcher, trace) {
+    this.pathFetcher = pathFetcher;
+    this.plugin = this.plugin.bind(this);
+    this.exportTokens = {};
+    this.translations = {};
+    this.trace = trace;
+  }
+
+  plugin(css) {
+    return Promise.all(this.fetchAllImports(css)).then(() => this.linkImportedSymbols(css)).then(() => this.extractExports(css));
+  }
+
+  fetchAllImports(css) {
+    let imports = [];
+    css.each(node => {
+      if (node.type == "rule" && node.selector.match(importRegexp)) {
+        imports.push(this.fetchImport(node, css.source.input.from, imports.length));
+      }
+    });
+    return imports;
+  }
+
+  linkImportedSymbols(css) {
+    (0, _icssReplaceSymbols2.default)(css, this.translations);
+  }
+
+  extractExports(css) {
+    css.each(node => {
+      if (node.type == "rule" && node.selector == ":export") this.handleExport(node);
+    });
+  }
+
+  handleExport(exportNode) {
+    exportNode.each(decl => {
+      if (decl.type == "decl") {
+        Object.keys(this.translations).forEach(translation => {
+          decl.value = decl.value.replace(translation, this.translations[translation]);
+        });
+        this.exportTokens[decl.prop] = decl.value;
+      }
+    });
+    exportNode.remove();
+  }
+
+  fetchImport(importNode, relativeTo, depNr) {
+    let file = importNode.selector.match(importRegexp)[1],
+        depTrace = this.trace + String.fromCharCode(depNr);
+    return this.pathFetcher(file, relativeTo, depTrace).then(exports => {
+      importNode.each(decl => {
+        if (decl.type == "decl") {
+          this.translations[decl.prop] = exports[decl.value];
+        }
+      });
+      importNode.remove();
+    }, err => console.log(err));
+  }
+}
+exports.default = Parser;

node_modules/postcss-modules/build/generateScopedName.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = generateScopedName;
+
+var _stringHash = require("string-hash");
+
+var _stringHash2 = _interopRequireDefault(_stringHash);
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function generateScopedName(name, filename, css) {
+  const i = css.indexOf(`.${name}`);
+  const lineNumber = css.substr(0, i).split(/[\r\n]/).length;
+  const hash = (0, _stringHash2.default)(css).toString(36).substr(0, 5);
+
+  return `_${name}_${hash}_${lineNumber}`;
+}

node_modules/postcss-modules/build/index.js

@@ -0,0 +1,169 @@
+"use strict";
+
+var _postcss = require("postcss");
+
+var _postcss2 = _interopRequireDefault(_postcss);
+
+var _lodash = require("lodash.camelcase");
+
+var _lodash2 = _interopRequireDefault(_lodash);
+
+var _genericNames = require("generic-names");
+
+var _genericNames2 = _interopRequireDefault(_genericNames);
+
+var _parser = require("./css-loader-core/parser");
+
+var _parser2 = _interopRequireDefault(_parser);
+
+var _loader = require("./css-loader-core/loader");
+
+var _loader2 = _interopRequireDefault(_loader);
+
+var _generateScopedName = require("./generateScopedName");
+
+var _generateScopedName2 = _interopRequireDefault(_generateScopedName);
+
+var _saveJSON = require("./saveJSON");
+
+var _saveJSON2 = _interopRequireDefault(_saveJSON);
+
+var _behaviours = require("./behaviours");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+
+const PLUGIN_NAME = "postcss-modules";
+
+function getDefaultScopeBehaviour(opts) {
+  if (opts.scopeBehaviour && (0, _behaviours.isValidBehaviour)(opts.scopeBehaviour)) {
+    return opts.scopeBehaviour;
+  }
+
+  return _behaviours.behaviours.LOCAL;
+}
+
+function getScopedNameGenerator(opts) {
+  const scopedNameGenerator = opts.generateScopedName || _generateScopedName2.default;
+
+  if (typeof scopedNameGenerator === "function") return scopedNameGenerator;
+  return (0, _genericNames2.default)(scopedNameGenerator, {
+    context: process.cwd(),
+    hashPrefix: opts.hashPrefix
+  });
+}
+
+function getLoader(opts, plugins) {
+  const root = typeof opts.root === "undefined" ? "/" : opts.root;
+  return typeof opts.Loader === "function" ? new opts.Loader(root, plugins) : new _loader2.default(root, plugins);
+}
+
+function isGlobalModule(globalModules, inputFile) {
+  return globalModules.some(regex => inputFile.match(regex));
+}
+
+function getDefaultPluginsList(opts, inputFile) {
+  const globalModulesList = opts.globalModulePaths || null;
+  const exportGlobals = opts.exportGlobals || false;
+  const defaultBehaviour = getDefaultScopeBehaviour(opts);
+  const generateScopedName = getScopedNameGenerator(opts);
+
+  if (globalModulesList && isGlobalModule(globalModulesList, inputFile)) {
+    return (0, _behaviours.getDefaultPlugins)({
+      behaviour: _behaviours.behaviours.GLOBAL,
+      generateScopedName,
+      exportGlobals
+    });
+  }
+
+  return (0, _behaviours.getDefaultPlugins)({
+    behaviour: defaultBehaviour,
+    generateScopedName,
+    exportGlobals
+  });
+}
+
+function isOurPlugin(plugin) {
+  return plugin.postcssPlugin === PLUGIN_NAME;
+}
+
+function dashesCamelCase(string) {
+  return string.replace(/-+(\w)/g, (_, firstLetter) => firstLetter.toUpperCase());
+}
+
+module.exports = _postcss2.default.plugin(PLUGIN_NAME, (opts = {}) => {
+  const getJSON = opts.getJSON || _saveJSON2.default;
+
+  return (() => {
+    var _ref = _asyncToGenerator(function* (css, result) {
+      const inputFile = css.source.input.file;
+      const pluginList = getDefaultPluginsList(opts, inputFile);
+      const resultPluginIndex = result.processor.plugins.findIndex(function (plugin) {
+        return isOurPlugin(plugin);
+      });
+      if (resultPluginIndex === -1) {
+        throw new Error('Plugin missing from options.');
+      }
+      const earlierPlugins = result.processor.plugins.slice(0, resultPluginIndex);
+      const loaderPlugins = [...earlierPlugins, ...pluginList];
+      const loader = getLoader(opts, loaderPlugins);
+      const parser = new _parser2.default(loader.fetch.bind(loader));
+
+      yield (0, _postcss2.default)([...pluginList, parser.plugin]).process(css, {
+        from: inputFile
+      });
+
+      const out = loader.finalSource;
+      if (out) css.prepend(out);
+
+      if (opts.localsConvention) {
+        const isFunc = typeof opts.localsConvention === "function";
+
+        parser.exportTokens = Object.entries(parser.exportTokens).reduce(function (tokens, [className, value]) {
+          if (isFunc) {
+            tokens[opts.localsConvention(className, value, inputFile)] = value;
+
+            return tokens;
+          }
+
+          switch (opts.localsConvention) {
+            case "camelCase":
+              tokens[className] = value;
+              tokens[(0, _lodash2.default)(className)] = value;
+
+              break;
+            case "camelCaseOnly":
+              tokens[(0, _lodash2.default)(className)] = value;
+
+              break;
+            case "dashes":
+              tokens[className] = value;
+              tokens[dashesCamelCase(className)] = value;
+
+              break;
+            case "dashesOnly":
+              tokens[dashesCamelCase(className)] = value;
+
+              break;
+          }
+
+          return tokens;
+        }, {});
+      }
+
+      result.messages.push({
+        type: "export",
+        plugin: "postcss-modules",
+        exportTokens: parser.exportTokens
+      });
+
+      // getJSON may return a promise
+      return getJSON(css.source.input.file, parser.exportTokens, result.opts.to);
+    });
+
+    return function (_x, _x2) {
+      return _ref.apply(this, arguments);
+    };
+  })();
+});

node_modules/postcss-modules/build/saveJSON.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = saveJSON;
+
+var _fs = require("fs");
+
+function saveJSON(cssFile, json) {
+  return new Promise((resolve, reject) => {
+    (0, _fs.writeFile)(`${cssFile}.json`, JSON.stringify(json), e => e ? reject(e) : resolve(json));
+  });
+}