sass-loader 8.0.2 → 9.0.3

package/dist/utils.js

@@ -0,0 +1,383 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = getPossibleRequests;
+exports.getSassImplementation = getSassImplementation;
+exports.getSassOptions = getSassOptions;
+exports.getWebpackImporter = getWebpackImporter;
+exports.getRenderFunctionFromSassImplementation = getRenderFunctionFromSassImplementation;
+
+var _url = _interopRequireDefault(require("url"));
+
+var _path = _interopRequireDefault(require("path"));
+
+var _semver = _interopRequireDefault(require("semver"));
+
+var _klona = _interopRequireDefault(require("klona"));
+
+var _loaderUtils = require("loader-utils");
+
+var _neoAsync = _interopRequireDefault(require("neo-async"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function getDefaultSassImplementation() {
+  let sassImplPkg = 'sass';
+
+  try {
+    require.resolve('sass');
+  } catch (error) {
+    try {
+      require.resolve('node-sass');
+
+      sassImplPkg = 'node-sass';
+    } catch (ignoreError) {
+      sassImplPkg = 'sass';
+    }
+  } // eslint-disable-next-line import/no-dynamic-require, global-require
+
+
+  return require(sassImplPkg);
+}
+
+function getSassImplementation(implementation) {
+  let resolvedImplementation = implementation;
+
+  if (!resolvedImplementation) {
+    // eslint-disable-next-line no-param-reassign
+    resolvedImplementation = getDefaultSassImplementation();
+  }
+
+  const {
+    info
+  } = resolvedImplementation;
+
+  if (!info) {
+    throw new Error('Unknown Sass implementation.');
+  }
+
+  const infoParts = info.split('\t');
+
+  if (infoParts.length < 2) {
+    throw new Error(`Unknown Sass implementation "${info}".`);
+  }
+
+  const [implementationName, version] = infoParts;
+
+  if (implementationName === 'dart-sass') {
+    if (!_semver.default.satisfies(version, '^1.3.0')) {
+      throw new Error(`Dart Sass version ${version} is incompatible with ^1.3.0.`);
+    }
+
+    return resolvedImplementation;
+  } else if (implementationName === 'node-sass') {
+    if (!_semver.default.satisfies(version, '^4.0.0')) {
+      throw new Error(`Node Sass version ${version} is incompatible with ^4.0.0.`);
+    }
+
+    return resolvedImplementation;
+  }
+
+  throw new Error(`Unknown Sass implementation "${implementationName}".`);
+}
+
+function isProductionLikeMode(loaderContext) {
+  return loaderContext.mode === 'production' || !loaderContext.mode;
+}
+
+function proxyCustomImporters(importers, loaderContext) {
+  return [].concat(importers).map(importer => {
+    return function proxyImporter(...args) {
+      this.webpackLoaderContext = loaderContext;
+      return importer.apply(this, args);
+    };
+  });
+}
+/**
+ * Derives the sass options from the loader context and normalizes its values with sane defaults.
+ *
+ * @param {object} loaderContext
+ * @param {object} loaderOptions
+ * @param {string} content
+ * @param {object} implementation
+ * @returns {Object}
+ */
+
+
+function getSassOptions(loaderContext, loaderOptions, content, implementation) {
+  const options = (0, _klona.default)(loaderOptions.sassOptions ? typeof loaderOptions.sassOptions === 'function' ? loaderOptions.sassOptions(loaderContext) || {} : loaderOptions.sassOptions : {});
+  const isDartSass = implementation.info.includes('dart-sass');
+
+  if (isDartSass) {
+    const shouldTryToResolveFibers = !options.fiber && options.fiber !== false;
+
+    if (shouldTryToResolveFibers) {
+      let fibers;
+
+      try {
+        fibers = require.resolve('fibers');
+      } catch (_error) {// Nothing
+      }
+
+      if (fibers) {
+        // eslint-disable-next-line global-require, import/no-dynamic-require
+        options.fiber = require(fibers);
+      }
+    } else if (options.fiber === false) {
+      // Don't pass the `fiber` option for `sass` (`Dart Sass`)
+      delete options.fiber;
+    }
+  } else {
+    // Don't pass the `fiber` option for `node-sass`
+    delete options.fiber;
+  }
+
+  options.file = loaderContext.resourcePath;
+  options.data = loaderOptions.additionalData ? typeof loaderOptions.additionalData === 'function' ? loaderOptions.additionalData(content, loaderContext) : `${loaderOptions.additionalData}\n${content}` : content; // opt.outputStyle
+
+  if (!options.outputStyle && isProductionLikeMode(loaderContext)) {
+    options.outputStyle = 'compressed';
+  }
+
+  const useSourceMap = typeof loaderOptions.sourceMap === 'boolean' ? loaderOptions.sourceMap : loaderContext.sourceMap;
+
+  if (useSourceMap) {
+    // Deliberately overriding the sourceMap option here.
+    // node-sass won't produce source maps if the data option is used and options.sourceMap is not a string.
+    // In case it is a string, options.sourceMap should be a path where the source map is written.
+    // But since we're using the data option, the source map will not actually be written, but
+    // all paths in sourceMap.sources will be relative to that path.
+    // Pretty complicated... :(
+    options.sourceMap = _path.default.join(process.cwd(), '/sass.css.map');
+    options.sourceMapRoot = process.cwd();
+    options.sourceMapContents = true;
+    options.omitSourceMapUrl = true;
+    options.sourceMapEmbed = false;
+  }
+
+  const {
+    resourcePath
+  } = loaderContext;
+
+  const ext = _path.default.extname(resourcePath); // If we are compiling sass and indentedSyntax isn't set, automatically set it.
+
+
+  if (ext && ext.toLowerCase() === '.sass' && typeof options.indentedSyntax === 'undefined') {
+    options.indentedSyntax = true;
+  } else {
+    options.indentedSyntax = Boolean(options.indentedSyntax);
+  } // Allow passing custom importers to `sass`/`node-sass`. Accepts `Function` or an array of `Function`s.
+
+
+  options.importer = options.importer ? proxyCustomImporters(Array.isArray(options.importer) ? options.importer : [options.importer], loaderContext) : [];
+  options.includePaths = [].concat(process.cwd()).concat(options.includePaths || []).concat(process.env.SASS_PATH ? process.env.SASS_PATH.split(process.platform === 'win32' ? ';' : ':') : []);
+  return options;
+} // Examples:
+// - ~package
+// - ~package/
+// - ~@org
+// - ~@org/
+// - ~@org/package
+// - ~@org/package/
+
+
+const isModuleImport = /^~([^/]+|[^/]+\/|@[^/]+[/][^/]+|@[^/]+\/?|@[^/]+[/][^/]+\/)$/;
+/**
+ * When `sass`/`node-sass` tries to resolve an import, it uses a special algorithm.
+ * Since the `sass-loader` uses webpack to resolve the modules, we need to simulate that algorithm.
+ * This function returns an array of import paths to try.
+ * The last entry in the array is always the original url to enable straight-forward webpack.config aliases.
+ *
+ * We don't need emulate `dart-sass` "It's not clear which file to import." errors (when "file.ext" and "_file.ext" files are present simultaneously in the same directory).
+ * This reduces performance and `dart-sass` always do it on own side.
+ *
+ * @param {string} url
+ * @param {boolean} forWebpackResolver
+ * @param {Object} loaderContext
+ * @returns {Array<string>}
+ */
+
+function getPossibleRequests(loaderContext, // eslint-disable-next-line no-shadow
+url, forWebpackResolver = false) {
+  const request = (0, _loaderUtils.urlToRequest)(url, // Maybe it is server-relative URLs
+  forWebpackResolver && url.charAt(0) === '/' ? loaderContext.rootContext : // eslint-disable-next-line no-undefined
+  undefined); // In case there is module request, send this to webpack resolver
+
+  if (forWebpackResolver && isModuleImport.test(url)) {
+    return [...new Set([request, url])];
+  } // Keep in mind: ext can also be something like '.datepicker' when the true extension is omitted and the filename contains a dot.
+  // @see https://github.com/webpack-contrib/sass-loader/issues/167
+
+
+  const ext = _path.default.extname(request).toLowerCase(); // Because @import is also defined in CSS, Sass needs a way of compiling plain CSS @imports without trying to import the files at compile time.
+  // To accomplish this, and to ensure SCSS is as much of a superset of CSS as possible, Sass will compile any @imports with the following characteristics to plain CSS imports:
+  //  - imports where the URL ends with .css.
+  //  - imports where the URL begins http:// or https://.
+  //  - imports where the URL is written as a url().
+  //  - imports that have media queries.
+  //
+  // The `node-sass` package sends `@import` ending on `.css` to importer, it is bug, so we skip resolve
+
+
+  if (ext === '.css') {
+    return [];
+  }
+
+  const dirname = _path.default.dirname(request);
+
+  const basename = _path.default.basename(request);
+
+  return [...new Set([`${dirname}/_${basename}`, request].concat(forWebpackResolver ? [`${_path.default.dirname(url)}/_${basename}`, url] : []))];
+}
+
+const matchCss = /\.css$/i;
+const isSpecialModuleImport = /^~[^/]+$/; // `[drive_letter]:\` + `\\[server]\[sharename]\`
+
+const isNativeWin32Path = /^[a-zA-Z]:[/\\]|^\\\\/i;
+
+function getWebpackImporter(loaderContext, implementation, includePaths) {
+  async function startResolving(resolutionMap) {
+    if (resolutionMap.length === 0) {
+      return Promise.reject();
+    }
+
+    const [{
+      resolve,
+      context,
+      possibleRequests
+    }] = resolutionMap;
+    let result;
+
+    try {
+      result = await resolve(context, possibleRequests[0]);
+    } catch (_ignoreError) {
+      const [, ...tailResult] = possibleRequests;
+
+      if (tailResult.length === 0) {
+        const [, ...tailResolutionMap] = resolutionMap;
+        return startResolving(tailResolutionMap);
+      } // eslint-disable-next-line no-param-reassign
+
+
+      resolutionMap[0].possibleRequests = tailResult;
+      return startResolving(resolutionMap);
+    } // Add the result as dependency.
+    // Although we're also using stats.includedFiles, this might come in handy when an error occurs.
+    // In this case, we don't get stats.includedFiles from node-sass/sass.
+
+
+    loaderContext.addDependency(_path.default.normalize(result)); // By removing the CSS file extension, we trigger node-sass to include the CSS file instead of just linking it.
+
+    return {
+      file: result.replace(matchCss, '')
+    };
+  }
+
+  const sassResolve = loaderContext.getResolve({
+    alias: [],
+    aliasFields: [],
+    conditionNames: [],
+    descriptionFiles: [],
+    extensions: ['.sass', '.scss', '.css'],
+    exportsFields: [],
+    mainFields: [],
+    mainFiles: ['_index', 'index'],
+    modules: [],
+    restrictions: [/\.((sa|sc|c)ss)$/i]
+  });
+  const webpackResolve = loaderContext.getResolve({
+    conditionNames: ['sass', 'style'],
+    mainFields: ['sass', 'style', 'main', '...'],
+    mainFiles: ['_index', 'index', '...'],
+    extensions: ['.sass', '.scss', '.css'],
+    restrictions: [/\.((sa|sc|c)ss)$/i]
+  });
+  return (originalUrl, prev, done) => {
+    let request = originalUrl;
+    const isFileScheme = originalUrl.slice(0, 5).toLowerCase() === 'file:';
+
+    if (isFileScheme) {
+      try {
+        // eslint-disable-next-line no-param-reassign
+        request = _url.default.fileURLToPath(originalUrl);
+      } catch (ignoreError) {
+        request = request.slice(7);
+      }
+    }
+
+    let resolutionMap = [];
+    const needEmulateSassResolver = // `sass` doesn't support module import
+    !isSpecialModuleImport.test(request) && // We need improve absolute paths handling.
+    // Absolute paths should be resolved:
+    // - Server-relative URLs - `<context>/path/to/file.ext` (where `<context>` is root context)
+    // - Absolute path - `/full/path/to/file.ext` or `C:\\full\path\to\file.ext`
+    !isFileScheme && !originalUrl.startsWith('/') && !isNativeWin32Path.test(originalUrl);
+
+    if (includePaths.length > 0 && needEmulateSassResolver) {
+      // The order of import precedence is as follows:
+      //
+      // 1. Filesystem imports relative to the base file.
+      // 2. Custom importer imports.
+      // 3. Filesystem imports relative to the working directory.
+      // 4. Filesystem imports relative to an `includePaths` path.
+      // 5. Filesystem imports relative to a `SASS_PATH` path.
+      //
+      // Because `sass`/`node-sass` run custom importers before `3`, `4` and `5` points, we need to emulate this behavior to avoid wrong resolution.
+      const sassPossibleRequests = getPossibleRequests(loaderContext, request);
+      const isDartSass = implementation.info.includes('dart-sass'); // `node-sass` calls our importer before `1. Filesystem imports relative to the base file.`, so we need emulate this too
+
+      if (!isDartSass) {
+        resolutionMap = resolutionMap.concat({
+          resolve: sassResolve,
+          context: _path.default.dirname(prev),
+          possibleRequests: sassPossibleRequests
+        });
+      }
+
+      resolutionMap = resolutionMap.concat(includePaths.map(context => ({
+        resolve: sassResolve,
+        context,
+        possibleRequests: sassPossibleRequests
+      })));
+    }
+
+    const webpackPossibleRequests = getPossibleRequests(loaderContext, request, true);
+    resolutionMap = resolutionMap.concat({
+      resolve: webpackResolve,
+      context: _path.default.dirname(prev),
+      possibleRequests: webpackPossibleRequests
+    });
+    startResolving(resolutionMap) // Catch all resolving errors, return the original file and pass responsibility back to other custom importers
+    .catch(() => ({
+      file: originalUrl
+    })).then(result => done(result));
+  };
+}
+
+let nodeSassJobQueue = null;
+/**
+ * Verifies that the implementation and version of Sass is supported by this loader.
+ *
+ * @param {Object} implementation
+ * @returns {Function}
+ */
+
+function getRenderFunctionFromSassImplementation(implementation) {
+  const isDartSass = implementation.info.includes('dart-sass');
+
+  if (isDartSass) {
+    return implementation.render.bind(implementation);
+  } // There is an issue with node-sass when async custom importers are used
+  // See https://github.com/sass/node-sass/issues/857#issuecomment-93594360
+  // We need to use a job queue to make sure that one thread is always available to the UV lib
+
+
+  if (nodeSassJobQueue === null) {
+    const threadPoolSize = Number(process.env.UV_THREADPOOL_SIZE || 4);
+    nodeSassJobQueue = _neoAsync.default.queue(implementation.render.bind(implementation), threadPoolSize - 1);
+  }
+
+  return nodeSassJobQueue.push.bind(nodeSassJobQueue);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sass-loader",
-  "version": "8.0.2",
+  "version": "9.0.3",
   "description": "Sass loader for webpack",
   "license": "MIT",
   "repository": "webpack-contrib/sass-loader",
@@ -13,7 +13,7 @@
   },
   "main": "dist/cjs.js",
   "engines": {
-    "node": ">= 8.9.0"
+    "node": ">= 10.13.0"
   },
   "scripts": {
     "start": "npm run build -- -w",
@@ -22,7 +22,7 @@
     "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
     "commitlint": "commitlint --from=master",
     "security": "npm audit",
-    "lint:prettier": "prettier \"{**/*,*}.{js,json,md,yml,css,ts}\" --list-different",
+    "lint:prettier": "prettier --list-different .",
     "lint:js": "eslint --cache .",
     "lint": "npm-run-all -l -p \"lint:**\"",
     "test:only": "cross-env NODE_ENV=test jest",
@@ -56,48 +56,45 @@
     }
   },
   "dependencies": {
-    "clone-deep": "^4.0.1",
-    "loader-utils": "^1.2.3",
-    "neo-async": "^2.6.1",
-    "schema-utils": "^2.6.1",
-    "semver": "^6.3.0"
+    "klona": "^1.1.2",
+    "loader-utils": "^2.0.0",
+    "neo-async": "^2.6.2",
+    "schema-utils": "^2.7.0",
+    "semver": "^7.3.2"
   },
   "devDependencies": {
-    "@babel/cli": "^7.8.0",
-    "@babel/core": "^7.8.0",
-    "@babel/preset-env": "^7.8.2",
-    "@commitlint/cli": "^8.3.4",
-    "@commitlint/config-conventional": "^8.3.4",
+    "@babel/cli": "^7.10.5",
+    "@babel/core": "^7.11.0",
+    "@babel/preset-env": "^7.11.0",
+    "@commitlint/cli": "^9.1.1",
+    "@commitlint/config-conventional": "^9.1.1",
     "@webpack-contrib/defaults": "^6.3.0",
     "@webpack-contrib/eslint-config-webpack": "^3.0.0",
-    "babel-jest": "^24.9.0",
-    "bootstrap": "^4.4.1",
+    "babel-jest": "^26.2.2",
+    "bootstrap": "^4.5.1",
     "bootstrap-sass": "^3.4.1",
-    "commitlint-azure-pipelines-cli": "^1.0.3",
-    "cross-env": "^6.0.3",
-    "css-loader": "^3.4.2",
+    "cross-env": "^7.0.2",
+    "css-loader": "^4.2.0",
     "del": "^5.1.0",
-    "del-cli": "^3.0.0",
-    "eslint": "^6.8.0",
-    "eslint-config-prettier": "^6.9.0",
-    "eslint-plugin-import": "^2.20.0",
-    "fibers": "^4.0.2",
-    "file-loader": "^5.0.2",
-    "husky": "^4.0.7",
-    "jest": "^24.9.0",
-    "jest-junit": "^10.0.0",
-    "jquery": "^3.4.1",
-    "lint-staged": "^9.5.0",
-    "memfs": "^3.0.3",
-    "node-sass": "^4.13.0",
+    "del-cli": "^3.0.1",
+    "eslint": "^7.6.0",
+    "eslint-config-prettier": "^6.11.0",
+    "eslint-plugin-import": "^2.21.2",
+    "fibers": "^5.0.0",
+    "file-loader": "^6.0.0",
+    "foundation-sites": "^6.6.3",
+    "husky": "^4.2.5",
+    "jest": "^26.2.2",
+    "lint-staged": "^10.2.11",
+    "material-components-web": "^7.0.0",
+    "memfs": "^3.2.0",
+    "node-sass": "^4.14.1",
     "npm-run-all": "^4.1.5",
-    "prettier": "^1.19.1",
-    "sass": "^1.24.4",
-    "standard-version": "^7.0.1",
-    "style-loader": "^1.1.2",
-    "webpack": "^4.41.5",
-    "webpack-cli": "^3.3.10",
-    "webpack-dev-server": "^3.10.1"
+    "prettier": "^2.0.5",
+    "sass": "^1.26.10",
+    "standard-version": "^8.0.2",
+    "style-loader": "^1.2.1",
+    "webpack": "^4.44.1"
   },
   "keywords": [
     "sass",

package/dist/getDefaultSassImplementation.js

@@ -1,28 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-function getDefaultSassImplementation() {
-  let sassImplPkg = 'node-sass';
-
-  try {
-    require.resolve('node-sass');
-  } catch (error) {
-    try {
-      require.resolve('sass');
-
-      sassImplPkg = 'sass';
-    } catch (ignoreError) {
-      sassImplPkg = 'node-sass';
-    }
-  } // eslint-disable-next-line import/no-dynamic-require, global-require
-
-
-  return require(sassImplPkg);
-}
-
-var _default = getDefaultSassImplementation;
-exports.default = _default;

package/dist/getRenderFunctionFromSassImplementation.js

@@ -1,39 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _neoAsync = _interopRequireDefault(require("neo-async"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-let nodeSassJobQueue = null;
-/**
- * Verifies that the implementation and version of Sass is supported by this loader.
- *
- * @param {Object} implementation
- * @returns {Function}
- */
-
-function getRenderFunctionFromSassImplementation(implementation) {
-  const isDartSass = implementation.info.includes('dart-sass');
-
-  if (isDartSass) {
-    return implementation.render.bind(implementation);
-  } // There is an issue with node-sass when async custom importers are used
-  // See https://github.com/sass/node-sass/issues/857#issuecomment-93594360
-  // We need to use a job queue to make sure that one thread is always available to the UV lib
-
-
-  if (nodeSassJobQueue === null) {
-    const threadPoolSize = Number(process.env.UV_THREADPOOL_SIZE || 4);
-    nodeSassJobQueue = _neoAsync.default.queue(implementation.render.bind(implementation), threadPoolSize - 1);
-  }
-
-  return nodeSassJobQueue.push.bind(nodeSassJobQueue);
-}
-
-var _default = getRenderFunctionFromSassImplementation;
-exports.default = _default;

package/dist/getSassImplementation.js

@@ -1,56 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _semver = _interopRequireDefault(require("semver"));
-
-var _getDefaultSassImplementation = _interopRequireDefault(require("./getDefaultSassImplementation"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function getSassImplementation(implementation) {
-  let resolvedImplementation = implementation;
-
-  if (!resolvedImplementation) {
-    // eslint-disable-next-line no-param-reassign
-    resolvedImplementation = (0, _getDefaultSassImplementation.default)();
-  }
-
-  const {
-    info
-  } = resolvedImplementation;
-
-  if (!info) {
-    throw new Error('Unknown Sass implementation.');
-  }
-
-  const infoParts = info.split('\t');
-
-  if (infoParts.length < 2) {
-    throw new Error(`Unknown Sass implementation "${info}".`);
-  }
-
-  const [implementationName, version] = infoParts;
-
-  if (implementationName === 'dart-sass') {
-    if (!_semver.default.satisfies(version, '^1.3.0')) {
-      throw new Error(`Dart Sass version ${version} is incompatible with ^1.3.0.`);
-    }
-
-    return resolvedImplementation;
-  } else if (implementationName === 'node-sass') {
-    if (!_semver.default.satisfies(version, '^4.0.0')) {
-      throw new Error(`Node Sass version ${version} is incompatible with ^4.0.0.`);
-    }
-
-    return resolvedImplementation;
-  }
-
-  throw new Error(`Unknown Sass implementation "${implementationName}".`);
-}
-
-var _default = getSassImplementation;
-exports.default = _default;