@nx/rollup 22.4.0-beta.2 → 22.4.0-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/rollup",
-  "version": "22.4.0-beta.2",
+  "version": "22.4.0-beta.4",
   "private": false,
   "description": "The Nx Plugin for Rollup contains executors and generators that support building applications using Rollup.",
   "repository": {
@@ -29,8 +29,8 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "22.4.0-beta.2",
-    "@nx/js": "22.4.0-beta.2",
+    "@nx/devkit": "22.4.0-beta.4",
+    "@nx/js": "22.4.0-beta.4",
     "@rollup/plugin-babel": "^6.0.4",
     "@rollup/plugin-commonjs": "^25.0.7",
     "@rollup/plugin-image": "^3.0.3",
@@ -38,16 +38,18 @@
     "@rollup/plugin-node-resolve": "^15.2.3",
     "@rollup/plugin-typescript": "^12.1.0",
     "autoprefixer": "^10.4.9",
+    "concat-with-sourcemaps": "^1.1.0",
     "picocolors": "^1.1.0",
     "picomatch": "4.0.2",
     "postcss": "^8.4.38",
+    "postcss-modules": "^6.0.1",
     "rollup": "^4.14.0",
-    "rollup-plugin-postcss": "^4.0.2",
     "rollup-plugin-typescript2": "^0.36.0",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "nx": "22.4.0-beta.2"
+    "nx": "22.4.0-beta.4",
+    "source-map-js": "^1.2.0"
   },
   "publishConfig": {
     "access": "public"

package/src/plugins/postcss/index.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @nx/rollup PostCSS plugin
+ *
+ * An inlined, simplified version of rollup-plugin-postcss that:
+ * - Processes CSS files through PostCSS
+ * - Supports CSS preprocessors (Sass, Less, Stylus)
+ * - Supports CSS Modules
+ * - Can inject CSS into DOM or extract to separate files
+ *
+ * This replaces the external rollup-plugin-postcss dependency to avoid
+ * peer dependency conflicts and maintenance issues.
+ */
+export { postcss } from './postcss-plugin';
+export { postcss as default } from './postcss-plugin';
+export type { PostCSSPluginOptions, PostCSSModulesOptions, FilterPattern, UseOptions, LessOptions, SassOptions, StylusOptions, } from './options';
+//# sourceMappingURL=index.d.ts.map

package/src/plugins/postcss/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../packages/rollup/src/plugins/postcss/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAEtD,YAAY,EACV,oBAAoB,EACpB,qBAAqB,EACrB,aAAa,EACb,UAAU,EACV,WAAW,EACX,WAAW,EACX,aAAa,GACd,MAAM,WAAW,CAAC"}

package/src/plugins/postcss/index.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * @nx/rollup PostCSS plugin
+ *
+ * An inlined, simplified version of rollup-plugin-postcss that:
+ * - Processes CSS files through PostCSS
+ * - Supports CSS preprocessors (Sass, Less, Stylus)
+ * - Supports CSS Modules
+ * - Can inject CSS into DOM or extract to separate files
+ *
+ * This replaces the external rollup-plugin-postcss dependency to avoid
+ * peer dependency conflicts and maintenance issues.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.postcss = void 0;
+var postcss_plugin_1 = require("./postcss-plugin");
+Object.defineProperty(exports, "postcss", { enumerable: true, get: function () { return postcss_plugin_1.postcss; } });
+var postcss_plugin_2 = require("./postcss-plugin");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return postcss_plugin_2.postcss; } });

package/src/plugins/postcss/loaders/index.d.ts

@@ -0,0 +1,38 @@
+import type { LoaderContext, LoaderResult, PostCSSLoaderOptions } from './types';
+import type { UseOptions } from '../options';
+export * from './types';
+export { createPostCSSLoader } from './postcss-loader';
+export { createLessLoader } from './less-loader';
+export { createSassLoader } from './sass-loader';
+export { createStylusLoader } from './stylus-loader';
+interface LoadersOptions {
+    /** PostCSS loader options */
+    postcss: PostCSSLoaderOptions;
+    /** Preprocessor options */
+    use: UseOptions;
+}
+/**
+ * Manages the chain of CSS loaders (preprocessors + PostCSS)
+ */
+export declare class Loaders {
+    private loaders;
+    constructor(options: LoadersOptions);
+    /**
+     * Register preprocessor loaders based on the 'use' option
+     */
+    private registerPreprocessors;
+    /**
+     * Check if any loader can process the given file
+     */
+    isSupported(filepath: string): boolean;
+    /**
+     * Check if a file matches a loader's test
+     */
+    private matchesLoader;
+    /**
+     * Process a file through the loader chain
+     * Preprocessors run first (if matching), then PostCSS always runs
+     */
+    process(code: string, context: LoaderContext): Promise<LoaderResult>;
+}
+//# sourceMappingURL=index.d.ts.map

package/src/plugins/postcss/loaders/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rollup/src/plugins/postcss/loaders/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,aAAa,EACb,YAAY,EACZ,oBAAoB,EAIrB,MAAM,SAAS,CAAC;AAKjB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,cAAc,SAAS,CAAC;AACxB,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAErD,UAAU,cAAc;IACtB,6BAA6B;IAC7B,OAAO,EAAE,oBAAoB,CAAC;IAC9B,2BAA2B;IAC3B,GAAG,EAAE,UAAU,CAAC;CACjB;AAED;;GAEG;AACH,qBAAa,OAAO;IAClB,OAAO,CAAC,OAAO,CAAgB;gBAEnB,OAAO,EAAE,cAAc;IASnC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAuB7B;;OAEG;IACH,WAAW,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO;IAItC;;OAEG;IACH,OAAO,CAAC,aAAa;IAOrB;;;OAGG;IACG,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC;CAwB3E"}

package/src/plugins/postcss/loaders/index.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Loaders = exports.createStylusLoader = exports.createSassLoader = exports.createLessLoader = exports.createPostCSSLoader = void 0;
+const tslib_1 = require("tslib");
+const postcss_loader_1 = require("./postcss-loader");
+const less_loader_1 = require("./less-loader");
+const sass_loader_1 = require("./sass-loader");
+const stylus_loader_1 = require("./stylus-loader");
+tslib_1.__exportStar(require("./types"), exports);
+var postcss_loader_2 = require("./postcss-loader");
+Object.defineProperty(exports, "createPostCSSLoader", { enumerable: true, get: function () { return postcss_loader_2.createPostCSSLoader; } });
+var less_loader_2 = require("./less-loader");
+Object.defineProperty(exports, "createLessLoader", { enumerable: true, get: function () { return less_loader_2.createLessLoader; } });
+var sass_loader_2 = require("./sass-loader");
+Object.defineProperty(exports, "createSassLoader", { enumerable: true, get: function () { return sass_loader_2.createSassLoader; } });
+var stylus_loader_2 = require("./stylus-loader");
+Object.defineProperty(exports, "createStylusLoader", { enumerable: true, get: function () { return stylus_loader_2.createStylusLoader; } });
+/**
+ * Manages the chain of CSS loaders (preprocessors + PostCSS)
+ */
+class Loaders {
+    constructor(options) {
+        this.loaders = [];
+        // Register preprocessor loaders based on 'use' options
+        // These are registered first and process files before PostCSS
+        this.registerPreprocessors(options.use);
+        // Register the PostCSS loader last - it always processes
+        this.loaders.push((0, postcss_loader_1.createPostCSSLoader)(options.postcss));
+    }
+    /**
+     * Register preprocessor loaders based on the 'use' option
+     */
+    registerPreprocessors(use) {
+        // Less loader
+        if (use.less !== false) {
+            const lessOptions = typeof use.less === 'object' ? use.less : {};
+            this.loaders.push((0, less_loader_1.createLessLoader)(lessOptions));
+        }
+        // Sass loader
+        if (use.sass !== false) {
+            const sassOptions = typeof use.sass === 'object' ? use.sass : {};
+            this.loaders.push((0, sass_loader_1.createSassLoader)(sassOptions));
+        }
+        // Stylus loader
+        if (use.stylus !== false) {
+            const stylusOptions = typeof use.stylus === 'object' ? use.stylus : {};
+            this.loaders.push((0, stylus_loader_1.createStylusLoader)(stylusOptions));
+        }
+    }
+    /**
+     * Check if any loader can process the given file
+     */
+    isSupported(filepath) {
+        return this.loaders.some((loader) => this.matchesLoader(loader, filepath));
+    }
+    /**
+     * Check if a file matches a loader's test
+     */
+    matchesLoader(loader, filepath) {
+        if (typeof loader.test === 'function') {
+            return loader.test(filepath);
+        }
+        return loader.test.test(filepath);
+    }
+    /**
+     * Process a file through the loader chain
+     * Preprocessors run first (if matching), then PostCSS always runs
+     */
+    async process(code, context) {
+        let result = { code };
+        // Process through each loader in order
+        for (const loader of this.loaders) {
+            // Skip non-matching loaders unless they always process
+            if (!loader.alwaysProcess && !this.matchesLoader(loader, context.id)) {
+                continue;
+            }
+            // Process with this loader
+            const loaderResult = await loader.process(result.code, context);
+            // Merge the result
+            result = {
+                ...result,
+                ...loaderResult,
+                // Preserve the map from the latest loader that produced one
+                map: loaderResult.map ?? result.map,
+            };
+        }
+        return result;
+    }
+}
+exports.Loaders = Loaders;

package/src/plugins/postcss/loaders/less-loader.d.ts

@@ -0,0 +1,7 @@
+import type { Loader, LessLoaderOptions } from './types';
+/**
+ * Less preprocessor loader
+ * Compiles .less files to CSS
+ */
+export declare function createLessLoader(options?: LessLoaderOptions): Loader;
+//# sourceMappingURL=less-loader.d.ts.map

package/src/plugins/postcss/loaders/less-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"less-loader.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rollup/src/plugins/postcss/loaders/less-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,MAAM,EAGN,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAwCjB;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CA2CxE"}

package/src/plugins/postcss/loaders/less-loader.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLessLoader = createLessLoader;
+const util_1 = require("util");
+const utils_1 = require("../utils");
+let less;
+/**
+ * Less preprocessor loader
+ * Compiles .less files to CSS
+ */
+function createLessLoader(options = {}) {
+    return {
+        name: 'less',
+        test: /\.less$/,
+        async process(code, context) {
+            if (!less) {
+                less = (0, utils_1.requireModule)('less', 'Less');
+            }
+            const render = (0, util_1.promisify)(less.render.bind(less));
+            const result = await render(code, {
+                ...options,
+                filename: context.id,
+                sourceMap: context.sourceMap
+                    ? {
+                        outputSourceFiles: true,
+                    }
+                    : undefined,
+            });
+            // Track dependencies
+            if (result.imports) {
+                for (const dep of result.imports) {
+                    context.dependencies.add(dep);
+                }
+            }
+            let map;
+            if (result.map) {
+                map = JSON.parse(result.map);
+                if (map && map.sources) {
+                    map.sources = map.sources.map(utils_1.humanizePath);
+                }
+            }
+            return {
+                code: result.css,
+                map,
+            };
+        },
+    };
+}

package/src/plugins/postcss/loaders/postcss-loader.d.ts

@@ -0,0 +1,7 @@
+import type { Loader, PostCSSLoaderOptions } from './types';
+/**
+ * PostCSS loader - processes CSS through PostCSS plugins
+ * This loader always runs last in the chain
+ */
+export declare function createPostCSSLoader(options: PostCSSLoaderOptions): Loader;
+//# sourceMappingURL=postcss-loader.d.ts.map

package/src/plugins/postcss/loaders/postcss-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postcss-loader.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rollup/src/plugins/postcss/loaders/postcss-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,MAAM,EAGN,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAejB;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,oBAAoB,GAAG,MAAM,CAsHzE"}

package/src/plugins/postcss/loaders/postcss-loader.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPostCSSLoader = createPostCSSLoader;
+const path_1 = require("path");
+const postcss_1 = require("postcss");
+const utils_1 = require("../utils");
+/**
+ * Check if a file should use CSS modules based on its filename
+ */
+function shouldUseCSSModules(filepath, autoModules) {
+    if (!autoModules) {
+        return false;
+    }
+    // Check for .module.xxx pattern
+    const filename = (0, path_1.basename)(filepath);
+    return /\.module\.[a-z]+$/i.test(filename);
+}
+/**
+ * PostCSS loader - processes CSS through PostCSS plugins
+ * This loader always runs last in the chain
+ */
+function createPostCSSLoader(options) {
+    return {
+        name: 'postcss',
+        test: /\.(css|sss|pcss|sass|scss|less|styl|stylus)$/,
+        alwaysProcess: true,
+        async process(code, context) {
+            const { plugins, modules, autoModules, extract, inject } = options;
+            // Determine if CSS modules should be used
+            const shouldUseModules = modules || shouldUseCSSModules(context.id, autoModules);
+            // Collect CSS module exports
+            let cssModuleExports;
+            // Build the PostCSS plugins array
+            const postcssPlugins = [...plugins];
+            // Add CSS modules plugin if needed
+            if (shouldUseModules) {
+                try {
+                    const postcssModules = require('postcss-modules');
+                    const modulesOptions = typeof modules === 'object' ? modules : {};
+                    postcssPlugins.unshift(postcssModules({
+                        ...modulesOptions,
+                        getJSON(_cssFilename, json, _outputFilename) {
+                            cssModuleExports = json;
+                        },
+                    }));
+                }
+                catch {
+                    throw new Error('You need to install "postcss-modules" package in order to use CSS Modules.');
+                }
+            }
+            // Process with PostCSS
+            const processOptions = {
+                from: context.id,
+                to: context.id,
+                map: context.sourceMap
+                    ? {
+                        inline: context.sourceMap === 'inline',
+                        annotation: false,
+                        sourcesContent: true,
+                    }
+                    : false,
+            };
+            const result = await (0, postcss_1.default)(postcssPlugins).process(code, processOptions);
+            // Track dependencies from PostCSS messages
+            for (const message of result.messages) {
+                if (message.type === 'dependency') {
+                    context.dependencies.add(message.file);
+                }
+            }
+            // Emit warnings
+            for (const warning of result.warnings()) {
+                context.warn(warning.toString());
+            }
+            // Get the source map
+            let map;
+            if (result.map) {
+                map = result.map.toJSON();
+                if (map?.sources) {
+                    map.sources = map.sources.map(utils_1.humanizePath);
+                }
+            }
+            // If extracting CSS, return the extracted content
+            if (extract) {
+                return {
+                    code: generateModuleCode(cssModuleExports),
+                    map: undefined,
+                    extracted: {
+                        code: result.css,
+                        map,
+                    },
+                    exports: cssModuleExports,
+                };
+            }
+            // If injecting CSS, return code that injects at runtime
+            if (inject) {
+                return {
+                    code: generateInjectCode(result.css, context.id, inject, cssModuleExports),
+                    map: undefined,
+                    exports: cssModuleExports,
+                };
+            }
+            // Otherwise return the CSS as a string export
+            return {
+                code: generateModuleCode(cssModuleExports, result.css),
+                map,
+                exports: cssModuleExports,
+            };
+        },
+    };
+}
+/**
+ * Generate JavaScript module code for CSS exports
+ */
+function generateModuleCode(exports, css) {
+    const lines = [];
+    if (exports && Object.keys(exports).length > 0) {
+        // Export each class name
+        for (const [key, value] of Object.entries(exports)) {
+            const safeName = (0, utils_1.safeIdentifier)(key);
+            lines.push(`export var ${safeName} = ${JSON.stringify(value)};`);
+        }
+        // Default export is the full exports object
+        lines.push(`export default ${JSON.stringify(exports)};`);
+    }
+    else if (css !== undefined) {
+        // Export the CSS string as default
+        lines.push(`export default ${JSON.stringify(css)};`);
+    }
+    else {
+        // Empty export
+        lines.push(`export default {};`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Generate JavaScript code that injects CSS at runtime
+ */
+function generateInjectCode(css, id, inject, exports) {
+    const lines = [];
+    // Import style-inject
+    lines.push(`import styleInject from '${utils_1.STYLE_INJECT_PATH}';`);
+    lines.push('');
+    // CSS string variable
+    lines.push(`var css = ${JSON.stringify(css)};`);
+    lines.push('');
+    // Inject the CSS
+    if (typeof inject === 'function') {
+        // Custom inject function
+        lines.push(`(${inject.toString()})(css, ${JSON.stringify(id)});`);
+    }
+    else if (typeof inject === 'object') {
+        // Inject with options
+        lines.push(`styleInject(css, ${JSON.stringify(inject)});`);
+    }
+    else {
+        // Default inject
+        lines.push(`styleInject(css);`);
+    }
+    lines.push('');
+    // Export CSS module classes if any
+    if (exports && Object.keys(exports).length > 0) {
+        for (const [key, value] of Object.entries(exports)) {
+            const safeName = (0, utils_1.safeIdentifier)(key);
+            lines.push(`export var ${safeName} = ${JSON.stringify(value)};`);
+        }
+        lines.push(`export default ${JSON.stringify(exports)};`);
+    }
+    else {
+        lines.push(`export default css;`);
+    }
+    return lines.join('\n');
+}

package/src/plugins/postcss/loaders/sass-loader.d.ts

@@ -0,0 +1,7 @@
+import type { Loader, SassLoaderOptions } from './types';
+/**
+ * Sass/SCSS preprocessor loader
+ * Compiles .sass and .scss files to CSS
+ */
+export declare function createSassLoader(options?: SassLoaderOptions): Loader;
+//# sourceMappingURL=sass-loader.d.ts.map

package/src/plugins/postcss/loaders/sass-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sass-loader.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rollup/src/plugins/postcss/loaders/sass-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,MAAM,EAGN,iBAAiB,EAClB,MAAM,SAAS,CAAC;AA4IjB;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,GAAE,iBAAsB,GAAG,MAAM,CAuGxE"}

package/src/plugins/postcss/loaders/sass-loader.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSassLoader = createSassLoader;
+const path_1 = require("path");
+const utils_1 = require("../utils");
+let sassModule;
+let isModernSass = false;
+/**
+ * Get the sass module, trying modern sass first, then node-sass
+ */
+function getSassModule() {
+    if (sassModule) {
+        return sassModule;
+    }
+    // Try modern sass first
+    const modernSass = (0, utils_1.loadModule)('sass');
+    if (modernSass && typeof modernSass.compile === 'function') {
+        sassModule = modernSass;
+        isModernSass = true;
+        return sassModule;
+    }
+    // Try legacy sass (or node-sass)
+    const legacySass = (0, utils_1.loadModule)('sass') || (0, utils_1.loadModule)('node-sass');
+    if (legacySass && typeof legacySass.render === 'function') {
+        sassModule = legacySass;
+        isModernSass = false;
+        return sassModule;
+    }
+    throw new Error('You need to install "sass" or "node-sass" package in order to process Sass files.');
+}
+/**
+ * Resolve a module import (handles ~ prefix for node_modules)
+ */
+function resolveModuleImport(url, prev) {
+    if (!url.startsWith('~')) {
+        return null;
+    }
+    const modulePath = url.slice(1);
+    const prevDir = (0, path_1.dirname)(prev);
+    // Try to resolve from node_modules
+    const paths = [
+        (0, path_1.join)(prevDir, 'node_modules', modulePath),
+        (0, path_1.join)(process.cwd(), 'node_modules', modulePath),
+    ];
+    // Also try partial file (with underscore prefix)
+    const dir = (0, path_1.dirname)(modulePath);
+    const file = (0, path_1.basename)(modulePath);
+    const partialPaths = [
+        (0, path_1.join)(prevDir, 'node_modules', dir, `_${file}`),
+        (0, path_1.join)(process.cwd(), 'node_modules', dir, `_${file}`),
+    ];
+    // Try all paths with various extensions
+    const extensions = ['', '.scss', '.sass', '.css'];
+    for (const basePath of [...partialPaths, ...paths]) {
+        for (const ext of extensions) {
+            const fullPath = basePath + ext;
+            try {
+                require.resolve(fullPath);
+                return fullPath;
+            }
+            catch {
+                // Continue trying
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Sass/SCSS preprocessor loader
+ * Compiles .sass and .scss files to CSS
+ */
+function createSassLoader(options = {}) {
+    return {
+        name: 'sass',
+        test: /\.(sass|scss)$/,
+        async process(code, context) {
+            const sass = getSassModule();
+            const { implementation: _, ...sassOptions } = options;
+            if (isModernSass) {
+                // Modern sass (Dart Sass) with compile API
+                const modernSass = sass;
+                const result = modernSass.compileString(code, {
+                    ...sassOptions,
+                    loadPaths: [(0, path_1.dirname)(context.id), process.cwd(), 'node_modules'],
+                    sourceMap: !!context.sourceMap,
+                    importers: [
+                        {
+                            findFileUrl(url) {
+                                const resolved = resolveModuleImport(url, context.id);
+                                if (resolved) {
+                                    return new URL(`file://${(0, path_1.resolve)(resolved)}`);
+                                }
+                                return null;
+                            },
+                        },
+                    ],
+                });
+                // Track dependencies
+                for (const loadedUrl of result.loadedUrls) {
+                    if (loadedUrl.protocol === 'file:') {
+                        context.dependencies.add(loadedUrl.pathname);
+                    }
+                }
+                let map;
+                if (result.sourceMap) {
+                    map = result.sourceMap;
+                    if (map?.sources) {
+                        map.sources = map.sources.map(utils_1.humanizePath);
+                    }
+                }
+                return {
+                    code: result.css,
+                    map,
+                };
+            }
+            else {
+                // Legacy sass/node-sass with render API
+                const legacySass = sass;
+                return new Promise((resolvePromise, reject) => {
+                    legacySass.render({
+                        ...sassOptions,
+                        data: code,
+                        file: context.id,
+                        includePaths: [(0, path_1.dirname)(context.id), process.cwd()],
+                        sourceMap: !!context.sourceMap,
+                        outFile: context.id,
+                        sourceMapContents: true,
+                        importer: (url, prev, done) => {
+                            const resolved = resolveModuleImport(url, prev);
+                            if (resolved) {
+                                done({ file: resolved });
+                            }
+                            else {
+                                done(null);
+                            }
+                        },
+                    }, (error, result) => {
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        // Track dependencies
+                        if (result.stats.includedFiles) {
+                            for (const dep of result.stats.includedFiles) {
+                                context.dependencies.add(dep);
+                            }
+                        }
+                        let map;
+                        if (result.map) {
+                            map = JSON.parse(result.map.toString());
+                            if (map?.sources) {
+                                map.sources = map.sources.map(utils_1.humanizePath);
+                            }
+                        }
+                        resolvePromise({
+                            code: result.css.toString(),
+                            map,
+                        });
+                    });
+                });
+            }
+        },
+    };
+}

package/src/plugins/postcss/loaders/stylus-loader.d.ts

@@ -0,0 +1,7 @@
+import type { Loader, StylusLoaderOptions } from './types';
+/**
+ * Stylus preprocessor loader
+ * Compiles .styl and .stylus files to CSS
+ */
+export declare function createStylusLoader(options?: StylusLoaderOptions): Loader;
+//# sourceMappingURL=stylus-loader.d.ts.map

package/src/plugins/postcss/loaders/stylus-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stylus-loader.d.ts","sourceRoot":"","sources":["../../../../../../../packages/rollup/src/plugins/postcss/loaders/stylus-loader.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,MAAM,EAGN,mBAAmB,EACpB,MAAM,SAAS,CAAC;AAqBjB;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,mBAAwB,GAAG,MAAM,CA0D5E"}