sass-loader 16.0.8 → 17.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sass-loader",
-  "version": "16.0.8",
+  "version": "17.0.0",
   "description": "Sass loader for webpack",
   "keywords": [
     "sass",
@@ -17,89 +17,81 @@
   },
   "license": "MIT",
   "author": "J. Tangelder",
-  "main": "dist/cjs.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./types/index.d.ts",
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "default": "./dist/esm/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./types/index.d.ts",
   "files": [
-    "dist"
+    "dist",
+    "types"
   ],
   "scripts": {
-    "start": "npm run build -- -w",
-    "clean": "del-cli dist",
+    "clean": "del-cli dist types",
     "prebuild": "npm run clean",
-    "build": "cross-env NODE_ENV=production babel src -d dist --copy-files",
-    "commitlint": "commitlint --from=main",
+    "build:esm": "babel src -d dist/esm --env-name esm --copy-files --no-copy-ignored",
+    "build:cjs": "babel src -d dist/cjs --env-name cjs --copy-files --no-copy-ignored && node -e \"const fs=require('fs');fs.writeFileSync('dist/cjs/package.json','{\\\"type\\\":\\\"commonjs\\\"}\\n');fs.appendFileSync('dist/cjs/index.js','module.exports = exports.default;\\nmodule.exports.default = exports.default;\\n')\"",
+    "build:types": "tsc && prettier \"types/**/*.ts\" --write",
+    "build": "npm-run-all -p \"build:*\"",
     "security": "npm audit --production",
-    "lint:prettier": "prettier --cache --list-different .",
+    "lint": "npm-run-all -l -p \"lint:**\" && npm run fmt:check",
     "lint:code": "eslint --cache .",
     "lint:spelling": "cspell --cache --no-must-find-files --quiet \"**/*.*\"",
-    "lint": "npm-run-all -l -p \"lint:**\"",
-    "test:only": "cross-env NODE_ENV=test jest",
+    "lint:types": "tsc --pretty --noEmit",
+    "fmt": "npm run fmt:check -- --write",
+    "fmt:check": "prettier --list-different --cache --ignore-unknown .",
+    "fix": "npm run fix:code && npm run fmt",
     "fix:code": "npm run lint:code -- --fix",
-    "fix:prettier": "npm run lint:prettier -- --write",
-    "fix": "npm-run-all -l fix:code fix:prettier",
-    "test:watch": "npm run test:only -- --watch",
-    "test:manual": "npm run build && webpack-dev-server test/manual/src/index.js --open --config test/manual/webpack.config.js",
-    "test:coverage": "npm run test:only -- --collectCoverageFrom=\"src/**/*.js\" --coverage",
     "pretest": "npm run lint",
-    "test": "npm run test:coverage",
+    "test": "npm run test:base",
+    "test:base": "node --import ./test/setup-snapshots.js --test --test-force-exit --test-reporter=dot --test-reporter-destination=stdout --experimental-test-module-mocks",
+    "test:coverage": "npm run test:base -- --experimental-test-coverage --test-reporter=lcov --test-reporter-destination=coverage.lcov --test-coverage-include=\"src/**/*.js\"",
     "prepare": "husky && npm run build",
-    "release": "standard-version"
-  },
-  "dependencies": {
-    "neo-async": "^2.6.2"
+    "version": "changeset version",
+    "release": "npm run build && changeset publish"
   },
+  "dependencies": {},
   "devDependencies": {
-    "@babel/cli": "^7.28.0",
-    "@babel/core": "^7.28.0",
-    "@babel/preset-env": "^7.28.0",
-    "@commitlint/cli": "^19.8.1",
-    "@commitlint/config-conventional": "^19.8.1",
-    "@eslint/js": "^9.32.0",
-    "@eslint/markdown": "^7.0.0",
-    "@stylistic/eslint-plugin": "^5.2.2",
+    "@babel/cli": "^7.28.6",
+    "@babel/core": "^7.28.6",
+    "@babel/preset-env": "^7.28.6",
+    "@changesets/cli": "^2.30.0",
+    "@changesets/get-github-info": "^0.8.0",
+    "@types/node": "^22.13.4",
     "bootstrap-sass": "^3.4.1",
     "bootstrap-v4": "npm:bootstrap@^4.5.3",
-    "bootstrap-v5": "npm:bootstrap@^5.3.7",
-    "cross-env": "^7.0.3",
-    "cspell": "^8.19.4",
-    "css-loader": "^6.9.0",
-    "del": "^6.1.1",
-    "del-cli": "^5.1.0",
-    "enhanced-resolve": "^5.18.2",
-    "eslint": "^9.32.0",
-    "eslint-config-prettier": "^10.1.8",
-    "eslint-config-webpack": "^4.5.1",
-    "eslint-plugin-import": "^2.32.0",
-    "eslint-plugin-jest": "^29.0.1",
-    "eslint-plugin-jsdoc": "^52.0.0",
-    "eslint-plugin-n": "^17.21.0",
-    "eslint-plugin-prettier": "^5.5.3",
-    "eslint-plugin-unicorn": "^60.0.0",
+    "bootstrap-v5": "npm:bootstrap@^5.3.8",
+    "cspell": "^10.0.0",
+    "css-loader": "^7.1.4",
+    "del": "^8.0.1",
+    "del-cli": "^7.0.0",
+    "enhanced-resolve": "^5.21.5",
+    "eslint": "^9.38.0",
+    "eslint-config-webpack": "^4.9.6",
     "file-loader": "^6.2.0",
     "foundation-sites": "^6.7.5",
-    "globals": "^16.3.0",
     "husky": "^9.1.3",
-    "jest": "^30.0.5",
-    "lint-staged": "^15.5.2",
+    "lint-staged": "^17.0.5",
     "material-components-web": "^9.0.0",
-    "memfs": "^4.23.0",
-    "node-sass": "^9.0.0",
-    "node-sass-glob-importer": "^5.3.2",
+    "memfs": "^4.57.2",
     "npm-run-all": "^4.1.5",
-    "prettier": "^3.6.2",
-    "sass": "^1.89.2",
-    "sass-embedded": "^1.89.2",
-    "semver": "^7.7.2",
-    "standard-version": "^9.3.1",
-    "style-loader": "^3.3.4",
-    "typescript": "^5.9.2",
-    "typescript-eslint": "^8.39.0",
-    "webpack": "^5.101.0",
-    "webpack-cli": "^6.0.1",
-    "webpack-dev-server": "^5.2.2"
+    "prettier": "^3.8.3",
+    "sass": "^1.99.0",
+    "sass-embedded": "^1.99.0",
+    "style-loader": "^4.0.0",
+    "typescript": "^6.0.3",
+    "webpack": "^5.106.2"
   },
   "peerDependencies": {
     "@rspack/core": "0.x || ^1.0.0 || ^2.0.0-0",
-    "node-sass": "^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0 || ^9.0.0",
     "sass": "^1.3.0",
     "sass-embedded": "*",
     "webpack": "^5.0.0"
@@ -108,9 +100,6 @@
     "@rspack/core": {
       "optional": true
     },
-    "node-sass": {
-      "optional": true
-    },
     "sass": {
       "optional": true
     },
@@ -122,6 +111,6 @@
     }
   },
   "engines": {
-    "node": ">= 18.12.0"
+    "node": ">= 22.11.0"
   }
 }

package/types/index.d.ts

@@ -0,0 +1,19 @@
+export default loader;
+export type LoaderContext = import("webpack").LoaderContext<LoaderOptions>;
+export type Schema = import("schema-utils/declarations/validate").Schema;
+export type LoaderOptions = import("./utils.js").LoaderOptions;
+export type SassError = import("./utils.js").SassError;
+/** @typedef {import("webpack").LoaderContext<LoaderOptions>} LoaderContext */
+/** @typedef {import("schema-utils/declarations/validate").Schema} Schema */
+/** @typedef {import("./utils.js").LoaderOptions} LoaderOptions */
+/** @typedef {import("./utils.js").SassError} SassError */
+/**
+ * The sass-loader makes dart-sass and sass-embedded available to webpack modules.
+ * @this {LoaderContext}
+ * @param {string} content content
+ * @returns {Promise<void>} loader result
+ */
+declare function loader(
+  this: import("webpack").LoaderContext<import("./utils.js").LoaderOptions>,
+  content: string,
+): Promise<void>;

package/types/utils.d.ts

@@ -0,0 +1,294 @@
+export type EXPECTED_ANY = any;
+export type SourceLocation = {
+  /**
+   * line number
+   */
+  line: number;
+  /**
+   * column number
+   */
+  column: number;
+  /**
+   * character offset
+   */
+  offset: number;
+};
+export type SourceSpan = {
+  /**
+   * start location
+   */
+  start: SourceLocation;
+  /**
+   * end location
+   */
+  end: SourceLocation;
+  /**
+   * canonical URL of the file
+   */
+  url?: URL | undefined;
+  /**
+   * covered text
+   */
+  text: string;
+  /**
+   * surrounding context
+   */
+  context?: string | undefined;
+};
+export type LoggerWarnOptions = {
+  deprecation?: boolean;
+  span?: SourceSpan;
+  stack?: string;
+};
+export type Logger = {
+  /**
+   * warn handler
+   */
+  warn?: ((message: string, options: LoggerWarnOptions) => void) | undefined;
+  /**
+   * debug handler
+   */
+  debug?:
+    | ((
+        message: string,
+        options: {
+          span: SourceSpan;
+        },
+      ) => void)
+    | undefined;
+};
+export type CompileResult = {
+  /**
+   * css output
+   */
+  css: Buffer | string;
+  /**
+   * source map
+   */
+  sourceMap?: RawSourceMap | undefined;
+  /**
+   * loaded URLs
+   */
+  loadedUrls: URL[];
+};
+export type Importer = {
+  /**
+   * canonicalize
+   */
+  canonicalize: (
+    originalUrl: string,
+    context: {
+      containingUrl: URL | null;
+      fromImport: boolean;
+    },
+  ) => Promise<URL | null>;
+  /**
+   * load
+   */
+  load: (canonicalUrl: URL) => Promise<{
+    contents: string;
+    syntax: "scss" | "indented" | "css";
+    sourceMapUrl?: URL;
+  } | null>;
+};
+export type OutputStyle = "expanded" | "compressed";
+export type KnownSassOptions = {
+  /**
+   * syntax
+   */
+  syntax?: ("scss" | "indented" | "css") | undefined;
+  /**
+   * url
+   */
+  url?: URL | undefined;
+  /**
+   * style
+   */
+  style?: ("expanded" | "compressed") | undefined;
+  /**
+   * load paths
+   */
+  loadPaths?: string[] | undefined;
+  /**
+   * source map
+   */
+  sourceMap?: boolean | undefined;
+  /**
+   * source map include sources
+   */
+  sourceMapIncludeSources?: boolean | undefined;
+  /**
+   * importers
+   */
+  importers?: Importer[] | undefined;
+  /**
+   * logger
+   */
+  logger?: Logger | undefined;
+};
+export type SassOptions = KnownSassOptions & Record<string, EXPECTED_ANY>;
+export type AsyncCompiler = {
+  /**
+   * compile a string
+   */
+  compileStringAsync: (
+    source: string,
+    options?: SassOptions,
+  ) => Promise<CompileResult>;
+  /**
+   * dispose the compiler
+   */
+  dispose: () => Promise<void>;
+};
+export type SassImplementation = {
+  info: string;
+  compileStringAsync(
+    source: string,
+    options?: SassOptions,
+  ): Promise<CompileResult>;
+  initAsyncCompiler?(): Promise<AsyncCompiler>;
+};
+export type ApiType = "auto" | "modern" | "modern-compiler";
+export type LoaderContext = import("webpack").LoaderContext<LoaderOptions>;
+export type LoaderOptions = {
+  /**
+   * SaSS implementation
+   */
+  implementation?: SassImplementation | undefined;
+  /**
+   * SaSS options
+   */
+  sassOptions?:
+    | (SassOptions | ((loaderContext: LoaderContext) => SassOptions))
+    | undefined;
+  /**
+   * true if source map is enabled, otherwise false
+   */
+  sourceMap?: boolean | undefined;
+  /**
+   * prepends Sass/SCSS code before the actual entry file
+   */
+  additionalData?:
+    | (string | ((content: string, loaderContext: LoaderContext) => string))
+    | undefined;
+  /**
+   * true if webpack importer is enabled, otherwise false
+   */
+  webpackImporter?: boolean | undefined;
+  /**
+   * API type
+   */
+  api?: ApiType | undefined;
+  /**
+   * true if treats the `@warn` rule as a webpack warning, otherwise false
+   */
+  warnRuleAsWarning?: boolean | undefined;
+};
+export type Resolver = (
+  context: string,
+  request: string,
+  fromImport?: boolean,
+) => Promise<string>;
+export type ResolutionMap = {
+  resolve: (context: string, request: string) => Promise<string>;
+  context: string;
+  possibleRequests: string[];
+}[];
+export type RawSourceMap = {
+  version: number;
+  sources: string[];
+  names: string[];
+  sourceRoot?: string;
+  sourcesContent?: string[];
+  mappings: string;
+  file: string;
+  debugId?: string;
+  ignoreList?: number[];
+};
+export type SassError = Error & {
+  formatted?: string;
+  span?: {
+    url?: URL;
+    start: {
+      line: number;
+      column: number;
+    };
+    context?: string;
+  };
+};
+/**
+ * @param {Error | SassError} error the original sass error
+ * @returns {Error} a new error
+ */
+export function errorFactory(error: Error | SassError): Error;
+/**
+ * Verifies that the implementation and version of Sass is supported by this loader.
+ * @template {SassImplementation} T
+ * @param {LoaderContext} loaderContext loader context
+ * @param {T} implementation sass implementation
+ * @param {ApiType=} apiType api type
+ * @returns {(sassOptions: SassOptions & { data: string }) => Promise<CompileResult>} compile function
+ */
+export function getCompileFn<T extends SassImplementation>(
+  loaderContext: LoaderContext,
+  implementation: T,
+  apiType?: ApiType | undefined,
+): (
+  sassOptions: SassOptions & {
+    data: string;
+  },
+) => Promise<CompileResult>;
+/**
+ * @param {LoaderContext} loaderContext loader context
+ * @returns {Importer} the modern webpack importer
+ */
+export function getModernWebpackImporter(
+  loaderContext: LoaderContext,
+): Importer;
+/**
+ * This function is not Webpack-specific and can be used by tools wishing to mimic `sass-loader`'s behaviour, so its signature should not be changed.
+ * @param {SassImplementation | string | undefined} implementation sass implementation
+ * @returns {Promise<SassImplementation>} resolved sass implementation
+ */
+export function getSassImplementation(
+  implementation: SassImplementation | string | undefined,
+): Promise<SassImplementation>;
+/**
+ * Derives the sass options from the loader context and normalizes its values with sane defaults.
+ * @param {LoaderContext} loaderContext loader context
+ * @param {LoaderOptions} loaderOptions loader options
+ * @param {string} content content
+ * @param {boolean} useSourceMap true when need to generate source maps, otherwise false
+ * @returns {Promise<Required<KnownSassOptions> & { data: string }>} sass options
+ */
+export function getSassOptions(
+  loaderContext: LoaderContext,
+  loaderOptions: LoaderOptions,
+  content: string,
+  useSourceMap: boolean,
+): Promise<
+  Required<KnownSassOptions> & {
+    data: string;
+  }
+>;
+/**
+ * Create the resolve function used in the custom Sass importer.
+ * Can be used by external tools to mimic how `sass-loader` works, for example
+ * in a Jest transform. Such usages will want to wrap `resolve.create` from
+ * [`enhanced-resolve`]{@link https://github.com/webpack/enhanced-resolve} to
+ * pass as the `resolverFactory` argument.
+ * @param {LoaderContext["getResolve"]} resolverFactory a factory function for creating a Webpack resolver.
+ * @returns {Resolver} webpack resolver
+ */
+export function getWebpackResolver(
+  resolverFactory: LoaderContext["getResolve"],
+): Resolver;
+/**
+ * @param {RawSourceMap} map source map
+ * @param {string} rootContext root context
+ * @returns {RawSourceMap} normalized source map
+ */
+export function normalizeSourceMap(
+  map: RawSourceMap,
+  rootContext: string,
+): RawSourceMap;

package/dist/cjs.js

@@ -1,4 +0,0 @@
-"use strict";
-
-const loader = require("./index");
-module.exports = loader.default;

package/dist/index.js

@@ -1,103 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _nodePath = _interopRequireDefault(require("node:path"));
-var _nodeUrl = _interopRequireDefault(require("node:url"));
-var _options = _interopRequireDefault(require("./options.json"));
-var _utils = require("./utils");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// eslint-disable-next-line jsdoc/no-restricted-syntax
-/**
- * The sass-loader makes node-sass and dart-sass available to webpack modules.
- * @this {LoaderContext<{ string: any }>}
- * @param {string} content content
- */
-async function loader(content) {
-  const options = this.getOptions(_options.default);
-  const callback = this.async();
-  let implementation;
-  try {
-    implementation = (0, _utils.getSassImplementation)(this, options.implementation);
-  } catch (error) {
-    callback(error);
-    return;
-  }
-  const useSourceMap = typeof options.sourceMap === "boolean" ? options.sourceMap : this.sourceMap;
-  // Use `legacy` for `node-sass` and `modern` for `dart-sass` and `sass-embedded`
-  const apiType = typeof implementation.compileStringAsync === "undefined" ? "legacy" : typeof options.api === "undefined" ? "modern" : options.api;
-  const sassOptions = await (0, _utils.getSassOptions)(this, options, content, implementation, useSourceMap, apiType);
-  const shouldUseWebpackImporter = typeof options.webpackImporter === "boolean" ? options.webpackImporter : true;
-  if (shouldUseWebpackImporter) {
-    const isModernAPI = apiType === "modern" || apiType === "modern-compiler";
-    if (!isModernAPI) {
-      const {
-        includePaths
-      } = sassOptions;
-      sassOptions.importer.push((0, _utils.getWebpackImporter)(this, implementation, includePaths));
-    } else {
-      sassOptions.importers.push(
-      // No need to pass `loadPaths`, because modern API handle them itself
-      (0, _utils.getModernWebpackImporter)(this, implementation, []));
-    }
-  }
-  let compile;
-  try {
-    compile = (0, _utils.getCompileFn)(this, implementation, apiType);
-  } catch (error) {
-    callback(error);
-    return;
-  }
-  let result;
-  try {
-    result = await compile(sassOptions);
-  } catch (error) {
-    // There are situations when the `file`/`span.url` property do not exist
-    // Modern API
-    if (error.span && typeof error.span.url !== "undefined") {
-      this.addDependency(_nodeUrl.default.fileURLToPath(error.span.url));
-    }
-    // Legacy API
-    else if (typeof error.file !== "undefined") {
-      // `node-sass` returns POSIX paths
-      this.addDependency(_nodePath.default.normalize(error.file));
-    }
-    callback((0, _utils.errorFactory)(error));
-    return;
-  }
-  let map =
-  // Modern API, then legacy API
-  result.sourceMap || (result.map ? JSON.parse(result.map) : null);
-
-  // Modify source paths only for webpack, otherwise we do nothing
-  if (map && useSourceMap) {
-    map = (0, _utils.normalizeSourceMap)(map, this.rootContext);
-  }
-
-  // Modern API
-  if (typeof result.loadedUrls !== "undefined") {
-    for (const includedFile of result.loadedUrls.filter(loadedUrl => loadedUrl.protocol === "file:")) {
-      const normalizedIncludedFile = _nodeUrl.default.fileURLToPath(includedFile);
-
-      // Custom `importer` can return only `contents` so includedFile will be relative
-      if (_nodePath.default.isAbsolute(normalizedIncludedFile)) {
-        this.addDependency(normalizedIncludedFile);
-      }
-    }
-  }
-  // Legacy API
-  else if (typeof result.stats !== "undefined" && typeof result.stats.includedFiles !== "undefined") {
-    for (const includedFile of result.stats.includedFiles) {
-      const normalizedIncludedFile = _nodePath.default.normalize(includedFile);
-
-      // Custom `importer` can return only `contents` so includedFile will be relative
-      if (_nodePath.default.isAbsolute(normalizedIncludedFile)) {
-        this.addDependency(normalizedIncludedFile);
-      }
-    }
-  }
-  callback(null, result.css.toString(), map);
-}
-var _default = exports.default = loader;