@ms-cloudpack/bundler-rollup 0.6.1 → 0.6.2

package/lib/plugins/postcss/index.js

@@ -1,521 +1,12 @@
 // Fork of rollup-plugin-postcss to fix https://github.com/egoist/rollup-plugin-postcss/issues/184.
 // The plugin seems to no longer be maintained and no fork was found.
-/* tslint:disable */
 /* eslint-disable */
 // @ts-nocheck
-// rollup-plugin-postcss v3.0.0
 import path from 'path';
 import { createFilter } from '@rollup/pluginutils';
 import Concat from 'concat-with-sourcemaps';
-import { createRequire } from 'module';
-import postcss from 'postcss';
-import pify from 'pify';
-import resolvePackage from 'resolve';
-import PQueue from 'p-queue';
-// from https://github.com/eemeli/safe-identifier
-// from https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#keywords
-const reserved = new Set([
-    'break',
-    'case',
-    'catch',
-    'class',
-    'const',
-    'continue',
-    'debugger',
-    'default',
-    'delete',
-    'do',
-    'else',
-    'export',
-    'extends',
-    'false',
-    'finally',
-    'for',
-    'function',
-    'if',
-    'import',
-    'in',
-    'instanceof',
-    'new',
-    'null',
-    'return',
-    'super',
-    'switch',
-    'this',
-    'throw',
-    'true',
-    'try',
-    'typeof',
-    'var',
-    'void',
-    'while',
-    'with',
-    'let',
-    'static',
-    'yield',
-    'await',
-]);
-// from https://werxltd.com/wp/2010/05/13/javascript-implementation-of-javas-string-hashcode-method/
-function hashCode(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; ++i) {
-        const char = str.charCodeAt(i);
-        hash = (hash << 5) - hash + char;
-        hash |= 0; // Convert to 32bit integer
-    }
-    return hash;
-}
-function identifier(key, unique) {
-    if (unique)
-        key += ` ${hashCode(key).toString(36)}`;
-    const id = key.trim().replace(/\W+/g, '_');
-    return reserved.has(id) || /^\d/.test(id) ? `_${id}` : id;
-}
-/**
- * Normalize path separators to forward slashes
- * @param {string} p - Path to normalize
- * @returns {string} Normalized path
- */
-function normalizePath(p) {
-    return p?.replace(/\\+/g, '/') || '';
-}
-/**
- * Convert absolute path to relative path from current working directory
- * @param {string} filepath - Absolute file path
- * @returns {string} Relative path
- */
-function humanlizePath(filepath) {
-    return normalizePath(path.relative(process.cwd(), filepath));
-}
-const require = createRequire(import.meta.url);
-const styleInjectPath = require.resolve('style-inject/dist/style-inject.es').replace(/[\\/]+/g, '/');
-/**
- * Escape CSS class name dashes for JavaScript identifiers
- */
-function escapeClassNameDashes(string) {
-    return string.replace(/-+/g, (match) => {
-        return `$${match.replace(/-/g, '_')}$`;
-    });
-}
-/**
- * Ensure class name is a valid JavaScript identifier
- */
-function ensureClassName(name) {
-    const escapedName = escapeClassNameDashes(name);
-    return identifier(escapedName, false);
-}
-/**
- * Ensure PostCSS option is properly loaded
- */
-async function ensurePostCSSOption(option) {
-    if (typeof option === 'string') {
-        try {
-            const { createRequire } = await import('module');
-            const require = createRequire(import.meta.url);
-            const resolvedPath = require.resolve(option);
-            return await import(resolvedPath);
-        }
-        catch {
-            return option;
-        }
-    }
-    return option;
-}
-/**
- * Check if file is a CSS module
- */
-function isModuleFile(file) {
-    return /\.module\.[a-z]{2,6}$/.test(file);
-}
-var postcssLoader = {
-    name: 'postcss',
-    alwaysProcess: true,
-    async process({ code, map }) {
-        // This is modified to not load postcss config.
-        if (this.options.config !== false) {
-            throw new Error('This is a fork of rollup-plugin-postcss that does not support loading postcss config. ' +
-                'Please set `config: false` in the plugin options.');
-        }
-        const { options } = this;
-        const plugins = [...(options.postcss.plugins || [])];
-        const shouldExtract = options.extract;
-        const shouldInject = options.inject;
-        const modulesExported = {};
-        const autoModules = options.autoModules !== false && options.onlyModules !== true;
-        const isAutoModule = autoModules && isModuleFile(this.id);
-        const supportModules = autoModules ? isAutoModule : options.modules;
-        if (supportModules) {
-            const postcssModules = await import('postcss-modules');
-            plugins.unshift(postcssModules.default({
-                generateScopedName: process.env.ROLLUP_POSTCSS_TEST ? '[name]_[local]' : '[name]_[local]__[hash:base64:5]',
-                ...options.modules,
-                getJSON(filepath, json, outpath) {
-                    modulesExported[filepath] = json;
-                    if (typeof options.modules === 'object' && typeof options.modules.getJSON === 'function') {
-                        return options.modules.getJSON(filepath, json, outpath);
-                    }
-                },
-            }));
-        }
-        if (!shouldExtract && options.minimize) {
-            const cssnano = await import('cssnano');
-            plugins.push(cssnano.default(options.minimize));
-        }
-        const postcssOptions = {
-            ...this.options.postcss,
-            to: options.to || this.id,
-            from: this.id,
-            map: this.sourceMap
-                ? shouldExtract
-                    ? { inline: false, annotation: false }
-                    : { inline: true, annotation: false }
-                : false,
-        };
-        delete postcssOptions.plugins;
-        postcssOptions.parser = await ensurePostCSSOption(postcssOptions.parser);
-        postcssOptions.syntax = await ensurePostCSSOption(postcssOptions.syntax);
-        postcssOptions.stringifier = await ensurePostCSSOption(postcssOptions.stringifier);
-        if (map && postcssOptions.map) {
-            postcssOptions.map.prev = typeof map === 'string' ? JSON.parse(map) : map;
-        }
-        if (plugins.length === 0) {
-            const noopPlugin = () => ({
-                postcssPlugin: 'postcss-noop-plugin',
-                Once() { },
-            });
-            plugins.push(noopPlugin());
-        }
-        const result = await postcss(plugins).process(code, postcssOptions);
-        for (const message of result.messages) {
-            if (message.type === 'dependency') {
-                this.dependencies.add(message.file);
-            }
-        }
-        for (const warning of result.warnings()) {
-            if (!warning.message) {
-                warning.message = warning.text;
-            }
-            this.warn(warning);
-        }
-        const outputMap = result.map && JSON.parse(result.map.toString());
-        if (outputMap?.sources) {
-            outputMap.sources = outputMap.sources.map((v) => normalizePath(v));
-        }
-        let output = '';
-        let extracted;
-        if (options.namedExports) {
-            const json = modulesExported[this.id];
-            const getClassName = typeof options.namedExports === 'function' ? options.namedExports : ensureClassName;
-            for (const name in json) {
-                const newName = getClassName(name);
-                // Log transformed class names
-                // But skip this when namedExports is a function
-                // Since a user like you can manually log that if you want
-                if (name !== newName && typeof options.namedExports !== 'function') {
-                    this.warn(`Exported "${name}" as "${newName}" in ${humanlizePath(this.id)}`);
-                }
-                if (!json[newName]) {
-                    json[newName] = json[name];
-                }
-                output += `export var ${newName} = ${JSON.stringify(json[name])};\n`;
-            }
-        }
-        const cssVariableName = identifier('css', true);
-        if (shouldExtract) {
-            output += `export default ${JSON.stringify(modulesExported[this.id])};`;
-            extracted = {
-                id: this.id,
-                code: result.css,
-                map: outputMap,
-            };
-        }
-        else {
-            const module = supportModules ? JSON.stringify(modulesExported[this.id]) : cssVariableName;
-            output += `var ${cssVariableName} = ${JSON.stringify(result.css)};\n`;
-            output += `export default ${module};\n`;
-            output += `export var stylesheet=${JSON.stringify(result.css)};`;
-        }
-        if (!shouldExtract && shouldInject) {
-            output +=
-                typeof options.inject === 'function'
-                    ? options.inject(cssVariableName, this.id)
-                    : `\nimport styleInject from '${styleInjectPath}';\n` +
-                        `styleInject(${cssVariableName}${Object.keys(options.inject).length > 0 ? `,${JSON.stringify(options.inject)}` : ''});`;
-        }
-        return {
-            code: output,
-            map: outputMap,
-            extracted,
-        };
-    },
-};
-/**
- * Load a module using modern ESM dynamic imports
- * @param {string} moduleId - The module to load
- * @returns {Promise<any>} The loaded module
- */
-async function loadModule(moduleId) {
-    try {
-        // Try to import the module directly
-        return await import(moduleId);
-    }
-    catch {
-        // If direct import fails, try resolving from current working directory
-        try {
-            const { createRequire } = await import('module');
-            const require = createRequire(import.meta.url);
-            const resolvedPath = require.resolve(moduleId);
-            return await import(resolvedPath);
-        }
-        catch {
-            // Return null if module cannot be loaded
-            return null;
-        }
-    }
-}
-// This queue makes sure node-sass leaves one thread available for executing fs tasks
-// See: https://github.com/sass/node-sass/issues/857
-const threadPoolSize = process.env.UV_THREADPOOL_SIZE || 4;
-const workQueue = new PQueue({ concurrency: threadPoolSize - 1 });
-const moduleRe = /^~([a-z\d]|@).+/i;
-const getUrlOfPartial = (url) => {
-    const parsedUrl = path.parse(url);
-    return `${parsedUrl.dir}${path.sep}_${parsedUrl.base}`;
-};
-const resolvePromise = pify(resolvePackage);
-// List of supported SASS modules in the order of preference
-const sassModuleIds = ['sass', 'node-sass'];
-/* eslint import/no-anonymous-default-export: [2, {"allowObject": true}] */
-var sassLoader = {
-    name: 'sass',
-    test: /\.(sass|scss)$/,
-    process({ code }) {
-        return new Promise((resolve, reject) => {
-            (async () => {
-                const sassModule = await loadSassOrThrow();
-                // accessing sassModule.default logs an error in latest versions
-                const sass = sassModule.render ? sassModule : sassModule.default;
-                const render = pify(sass.render.bind(sass));
-                const data = this.options.data || '';
-                workQueue.add(() => render({
-                    ...this.options,
-                    file: this.id,
-                    data: data + code,
-                    indentedSyntax: /\.sass$/.test(this.id),
-                    sourceMap: this.sourceMap,
-                    importer: [
-                        (url, importer, done) => {
-                            if (!moduleRe.test(url))
-                                return done({ file: url });
-                            const moduleUrl = url.slice(1);
-                            const partialUrl = getUrlOfPartial(moduleUrl);
-                            const options = {
-                                basedir: path.dirname(importer),
-                                extensions: ['.scss', '.sass', '.css'],
-                            };
-                            const finishImport = (id) => {
-                                done({
-                                    // Do not add `.css` extension in order to inline the file
-                                    file: id.endsWith('.css') ? id.replace(/\.css$/, '') : id,
-                                });
-                            };
-                            const next = () => {
-                                // Catch all resolving errors, return the original file and pass responsibility back to other custom importers
-                                done({ file: url });
-                            };
-                            // Give precedence to importing a partial
-                            resolvePromise(partialUrl, options)
-                                .then(finishImport)
-                                .catch((error) => {
-                                if (error.code === 'MODULE_NOT_FOUND' || error.code === 'ENOENT') {
-                                    resolvePromise(moduleUrl, options).then(finishImport).catch(next);
-                                }
-                                else {
-                                    next();
-                                }
-                            });
-                        },
-                    ].concat(this.options.importer || []),
-                })
-                    .then((result) => {
-                    for (const file of result.stats.includedFiles) {
-                        this.dependencies.add(file);
-                    }
-                    resolve({
-                        code: result.css.toString(),
-                        map: result.map && result.map.toString(),
-                    });
-                })
-                    .catch(reject));
-            })();
-        });
-    },
-};
-async function loadSassOrThrow() {
-    // Loading one of the supported modules
-    for (const moduleId of sassModuleIds) {
-        const module = await loadModule(moduleId);
-        if (module) {
-            return module;
-        }
-    }
-    // Throwing exception if module can't be loaded
-    throw new Error(`You need to install one of the following packages: ${sassModuleIds
-        .map((moduleId) => `"${moduleId}"`)
-        .join(', ')} in order to process SASS files`);
-}
-var stylusLoader = {
-    name: 'stylus',
-    test: /\.(styl|stylus)$/,
-    async process({ code }) {
-        const stylusModule = await loadModule('stylus');
-        if (!stylusModule) {
-            throw new Error('You need to install "stylus" package to process Stylus files');
-        }
-        const stylus = stylusModule.default || stylusModule;
-        const style = stylus(code, {
-            ...this.options,
-            filename: this.id,
-            sourcemap: this.sourceMap && {},
-        });
-        const renderAsync = pify(style.render.bind(style));
-        try {
-            const css = await renderAsync();
-            const deps = style.deps();
-            for (const dep of deps) {
-                this.dependencies.add(dep);
-            }
-            return {
-                code: css,
-                map: style.sourcemap,
-            };
-        }
-        catch (error) {
-            throw new Error(`Stylus compilation failed: ${error.message}`);
-        }
-    },
-};
-var lessLoader = {
-    name: 'less',
-    test: /\.less$/,
-    async process({ code }) {
-        const lessModule = await loadModule('less');
-        if (!lessModule) {
-            throw new Error('You need to install "less" package to process Less files');
-        }
-        const less = lessModule.default || lessModule;
-        const renderAsync = pify(less.render.bind(less));
-        try {
-            const { css, map: initialMap, imports, } = await renderAsync(code, {
-                ...this.options,
-                sourceMap: this.sourceMap && {},
-                filename: this.id,
-            });
-            for (const dep of imports) {
-                this.dependencies.add(dep);
-            }
-            let map = initialMap;
-            if (map) {
-                map = JSON.parse(map);
-                map.sources = map.sources.map((source) => humanlizePath(source));
-            }
-            return {
-                code: css,
-                map,
-            };
-        }
-        catch (error) {
-            throw new Error(`Less compilation failed: ${error.message}`);
-        }
-    },
-};
-const matchFile = (filepath, condition) => {
-    if (typeof condition === 'function') {
-        return condition(filepath);
-    }
-    return condition && condition.test(filepath);
-};
-class Loaders {
-    constructor(options = {}) {
-        this.use = options.use.map((rule) => {
-            if (typeof rule === 'string') {
-                return [rule];
-            }
-            if (Array.isArray(rule)) {
-                return rule;
-            }
-            throw new TypeError('The rule in `use` option must be string or Array!');
-        });
-        this.loaders = [];
-        const extensions = options.extensions || ['.css', '.sss', '.pcss'];
-        const customPostcssLoader = {
-            ...postcssLoader,
-            test: (filepath) => extensions.some((ext) => path.extname(filepath) === ext),
-        };
-        this.registerLoader(customPostcssLoader);
-        this.registerLoader(sassLoader);
-        this.registerLoader(stylusLoader);
-        this.registerLoader(lessLoader);
-        if (options.loaders) {
-            options.loaders.forEach((loader) => this.registerLoader(loader));
-        }
-    }
-    registerLoader(loader) {
-        const existing = this.getLoader(loader.name);
-        if (existing) {
-            this.removeLoader(loader.name);
-        }
-        this.loaders.push(loader);
-        return this;
-    }
-    removeLoader(name) {
-        this.loaders = this.loaders.filter((loader) => loader.name !== name);
-        return this;
-    }
-    isSupported(filepath) {
-        return this.loaders.some((loader) => {
-            return matchFile(filepath, loader.test);
-        });
-    }
-    /**
-     * Process the resource with loaders in serial
-     * @param {object} resource
-     * @param {string} resource.code
-     * @param {any} resource.map
-     * @param {object} context
-     * @param {string} context.id The absolute path to resource
-     * @param {boolean | 'inline'} context.sourceMap
-     * @param {Set<string>} context.dependencies A set of dependencies to watch
-     * @returns {{code: string, map?: any}}
-     */
-    async process({ code, map }, context) {
-        const loaderFunctions = this.use
-            .slice()
-            .reverse()
-            .map(([name, options]) => {
-            const loader = this.getLoader(name);
-            const loaderContext = {
-                options: options || {},
-                ...context,
-            };
-            return (v) => {
-                if (loader.alwaysProcess || matchFile(loaderContext.id, loader.test)) {
-                    return loader.process.call(loaderContext, v);
-                }
-                // Otherwise directly return input value
-                return v;
-            };
-        });
-        let result = { code, map };
-        for (const loaderFn of loaderFunctions) {
-            result = await loaderFn(result);
-        }
-        return result;
-    }
-    getLoader(name) {
-        return this.loaders.find((loader) => loader.name === name);
-    }
-}
+import Loaders from './loaders.js';
+import normalizePath from './utils/normalize-path.js';
 /**
  * The options that could be `boolean` or `object`
  * We convert it to an object when it's truthy
@@ -548,7 +39,7 @@ function getRecursiveImportOrder(id, getModuleInfo, seen = new Set()) {
     return result;
 }
 /* eslint import/no-anonymous-default-export: [2, {"allowArrowFunction": true}] */
-var index = (options = {}) => {
+export default (options = {}) => {
     const filter = createFilter(options.include, options.exclude);
     const postcssPlugins = Array.isArray(options.plugins) ? options.plugins.filter(Boolean) : options.plugins;
     const { sourceMap } = options;
@@ -578,14 +69,13 @@ var index = (options = {}) => {
             exec: options.exec,
         },
     };
-    let use = ['sass', 'stylus', 'less'];
+    let use = ['sass', 'less'];
     if (Array.isArray(options.use)) {
-        ({ use } = options);
+        use = options.use;
     }
     else if (options.use !== null && typeof options.use === 'object') {
         use = [
             ['sass', options.use.sass || {}],
-            ['stylus', options.use.stylus || {}],
             ['less', options.use.less || {}],
         ];
     }
@@ -634,6 +124,7 @@ var index = (options = {}) => {
         augmentChunkHash() {
             if (extracted.size === 0)
                 return;
+            // eslint-disable-next-line unicorn/no-reduce
             const extractedValue = [...extracted].reduce((object, [key, value]) => ({
                 ...object,
                 [key]: value,
@@ -680,7 +171,7 @@ var index = (options = {}) => {
                     code,
                     map: sourceMap === true && concat.sourceMap,
                     codeFileName: fileName,
-                    mapFileName: `${fileName}.map`,
+                    mapFileName: fileName + '.map',
                 };
             };
             if (options.onExtract) {
@@ -689,9 +180,7 @@ var index = (options = {}) => {
                     return;
                 }
             }
-            const { code: initialCode, codeFileName, map: initialMap, mapFileName } = getExtracted();
-            let code = initialCode;
-            let map = initialMap;
+            let { code, codeFileName, map, mapFileName } = getExtracted();
             // Perform cssnano on the extracted file
             if (postcssLoaderOptions.minimize) {
                 const cssOptions = {};
@@ -725,5 +214,4 @@ var index = (options = {}) => {
         },
     };
 };
-export { index as default };
 //# sourceMappingURL=index.js.map