@parcel/transformer-stylus 2.8.3 → 2.9.0

package/lib/StylusTransformer.js

@@ -4,135 +4,93 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 function _plugin() {
   const data = require("@parcel/plugin");
-
   _plugin = function () {
     return data;
   };
-
   return data;
 }
-
 function _utils() {
   const data = require("@parcel/utils");
-
   _utils = function () {
     return data;
   };
-
   return data;
 }
-
 function _path() {
   const data = _interopRequireDefault(require("path"));
-
   _path = function () {
     return data;
   };
-
   return data;
 }
-
 function _fs() {
   const data = _interopRequireDefault(require("fs"));
-
   _fs = function () {
     return data;
   };
-
   return data;
 }
-
 function _stylus() {
   const data = _interopRequireDefault(require("stylus"));
-
   _stylus = function () {
     return data;
   };
-
   return data;
 }
-
 function _parser() {
   const data = _interopRequireDefault(require("stylus/lib/parser"));
-
   _parser = function () {
     return data;
   };
-
   return data;
 }
-
 function _depsResolver() {
   const data = _interopRequireDefault(require("stylus/lib/visitor/deps-resolver"));
-
   _depsResolver = function () {
     return data;
   };
-
   return data;
 }
-
 function _nodes() {
   const data = _interopRequireDefault(require("stylus/lib/nodes"));
-
   _nodes = function () {
     return data;
   };
-
   return data;
 }
-
 function _utils2() {
   const data = _interopRequireDefault(require("stylus/lib/utils"));
-
   _utils2 = function () {
     return data;
   };
-
   return data;
 }
-
 function _evaluator() {
   const data = _interopRequireDefault(require("stylus/lib/visitor/evaluator"));
-
   _evaluator = function () {
     return data;
   };
-
   return data;
 }
-
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
 const URL_RE = /^(?:url\s*\(\s*)?['"]?(?:[#/]|(?:https?:)?\/\/)/i;
-
 var _default = new (_plugin().Transformer)({
   async loadConfig({
     config
   }) {
-    let configFile = await config.getConfig(['.stylusrc', '.stylusrc.js', '.stylusrc.cjs'], {
+    let configFile = await config.getConfig(['.stylusrc', '.stylusrc.js', '.stylusrc.cjs', '.stylusrc.mjs'], {
       packageKey: 'stylus'
     });
-
     if (configFile) {
-      let isJavascript = _path().default.extname(configFile.filePath).endsWith('js');
-
-      if (isJavascript) {
-        config.invalidateOnStartup();
-      } // Resolve relative paths from config file
-
-
+      // Resolve relative paths from config file
       if (configFile.contents.paths) {
         configFile.contents.paths = configFile.contents.paths.map(p => _path().default.resolve(_path().default.dirname(configFile.filePath), p));
       }
-
       return configFile.contents;
     }
   },
-
   async transform({
     asset,
     resolve,
@@ -141,11 +99,12 @@ var _default = new (_plugin().Transformer)({
   }) {
     let stylusConfig = config !== null && config !== void 0 ? config : {};
     let code = await asset.getCode();
-    let style = (0, _stylus().default)(code, { ...stylusConfig
+    let style = (0, _stylus().default)(code, {
+      ...stylusConfig
     });
     style.set('filename', asset.filePath);
-    style.set('include css', true); // Setup a handler for the URL function so we add dependencies for linked assets.
-
+    style.set('include css', true);
+    // Setup a handler for the URL function so we add dependencies for linked assets.
     style.define('url', node => {
       let filename = asset.addURLDependency(node.val, {
         loc: (0, _utils().createDependencyLocation)({
@@ -165,54 +124,49 @@ var _default = new (_plugin().Transformer)({
     asset.meta.hasDependencies = false;
     return [asset];
   }
-
 });
-
 exports.default = _default;
-
 function attemptResolve(importedPath, filepath, asset, resolve, deps) {
   if (deps.has(importedPath)) {
     return;
   }
-
   if ((0, _utils().isGlob)(importedPath)) {
     // Invalidate when new files are created that match the glob pattern.
     let absoluteGlob = _path().default.resolve(_path().default.dirname(filepath), importedPath);
-
     asset.invalidateOnFileCreate({
       glob: absoluteGlob
     });
     deps.set(importedPath, (0, _utils().glob)(absoluteGlob, asset.fs, {
       onlyFiles: true
-    }).then(entries => Promise.all(entries.map(entry => resolve(filepath, './' + _path().default.relative(_path().default.dirname(filepath), entry))))));
+    }).then(entries => Promise.all(entries.map(entry => resolve(filepath, './' + _path().default.relative(_path().default.dirname(filepath), entry), {
+      packageConditions: ['stylus', 'style']
+    })))));
   } else {
-    deps.set(importedPath, resolve(filepath, importedPath));
+    deps.set(importedPath, resolve(filepath, importedPath, {
+      packageConditions: ['stylus', 'style']
+    }));
   }
 }
-
 async function getDependencies(code, filepath, asset, resolve, options, parcelOptions, nativeGlob, seen = new Set(), includeImports = true) {
   seen.add(filepath);
   _nodes().default.filename = asset.filePath;
   let parser = new (_parser().default)(code, options);
   let ast = parser.parse();
   let deps = new Map();
-
   if (includeImports && options.imports) {
     for (let importedPath of options.imports) {
       attemptResolve(importedPath, filepath, asset, resolve, deps);
     }
   }
-
   class ImportVisitor extends _depsResolver().default {
     visitImport(imported) {
       let importedPath = imported.path.first.string;
       attemptResolve(importedPath, filepath, asset, resolve, deps);
     }
-
   }
+  new ImportVisitor(ast, options).visit(ast);
 
-  new ImportVisitor(ast, options).visit(ast); // Recursively process depdendencies, and return a map with all resolved paths.
-
+  // Recursively process depdendencies, and return a map with all resolved paths.
   let res = new Map();
   await Promise.all(Array.from(deps.entries()).map(async ([importedPath, resolved]) => {
     try {
@@ -220,47 +174,41 @@ async function getDependencies(code, filepath, asset, resolve, options, parcelOp
     } catch (err) {
       resolved = null;
     }
-
     let found;
-
     if (resolved && (!Array.isArray(resolved) || resolved.length > 0)) {
       found = Array.isArray(resolved) ? resolved : [resolved];
       res.set(importedPath, resolved);
     } else {
       // If we couldn't resolve, try the normal stylus resolver.
       // We just need to do this to keep track of the dependencies - stylus does the real work.
+
       // support optional .styl
       let originalPath = importedPath;
-
       if (!/\.styl$/i.test(importedPath)) {
         importedPath += '.styl';
-      } // Patch the native FS so we use Parcel's FS, and track files that are
-      // checked so we invalidate the cache when they are created.
-
+      }
 
+      // Patch the native FS so we use Parcel's FS, and track files that are
+      // checked so we invalidate the cache when they are created.
       let restore = patchNativeFS(asset.fs, nativeGlob);
       let paths = [...new Set((options.paths || []).concat(_path().default.dirname(filepath || '.')))];
       found = _utils2().default.find(importedPath, paths, filepath);
-
       if (!found) {
         found = _utils2().default.lookupIndex(originalPath, paths, filepath);
       }
-
       for (let invalidation of restore()) {
         asset.invalidateOnFileCreate(invalidation);
       }
-
       if (!found) {
         throw new Error('failed to locate file ' + originalPath);
       }
-    } // Recursively process resolved files as well to get nested deps
-
+    }
 
+    // Recursively process resolved files as well to get nested deps
     for (let resolved of found) {
       if (!seen.has(resolved)) {
         await asset.invalidateOnFileChange(resolved);
         let code = await asset.fs.readFile(resolved, 'utf8');
-
         for (let [path, resolvedPath] of await getDependencies(code, resolved, asset, resolve, options, parcelOptions, nativeGlob, seen, false)) {
           res.set(path, resolvedPath);
         }
@@ -269,22 +217,22 @@ async function getDependencies(code, filepath, asset, resolve, options, parcelOp
   }));
   return res;
 }
-
 async function createEvaluator(code, asset, resolve, options, parcelOptions, nativeGlob) {
-  const deps = await getDependencies(code, asset.filePath, asset, resolve, options, parcelOptions, nativeGlob); // This is a custom stylus evaluator that extends stylus with support for the node
+  const deps = await getDependencies(code, asset.filePath, asset, resolve, options, parcelOptions, nativeGlob);
+
+  // This is a custom stylus evaluator that extends stylus with support for the node
   // require resolution algorithm. It also adds all dependencies to the parcel asset
   // tree so the file watcher works correctly, etc.
-
   class CustomEvaluator extends _evaluator().default {
     visitImport(imported) {
       let node = this.visit(imported.path).first;
       let path = node.string;
-
       if (node.name !== 'url' && path && !URL_RE.test(path)) {
-        let resolved = deps.get(path); // First try resolving using the node require resolution algorithm.
+        let resolved = deps.get(path);
+
+        // First try resolving using the node require resolution algorithm.
         // This allows stylus files in node_modules to be resolved properly.
         // If we find something, update the AST so stylus gets the absolute path to load later.
-
         if (resolved) {
           if (!Array.isArray(resolved)) {
             node.string = resolved;
@@ -300,34 +248,30 @@ async function createEvaluator(code, asset, resolve, options, parcelOptions, nat
             }));
           }
         }
-      } // Patch the native FS so stylus uses Parcel's FS to read the file.
-
+      }
 
-      let restore = patchNativeFS(asset.fs, nativeGlob); // Done. Let stylus do its thing.
+      // Patch the native FS so stylus uses Parcel's FS to read the file.
+      let restore = patchNativeFS(asset.fs, nativeGlob);
 
+      // Done. Let stylus do its thing.
       let res = super.visitImport(imported);
       restore();
       return res;
     }
-
   }
-
   return CustomEvaluator;
 }
-
 function patchNativeFS(fs, nativeGlob) {
   let invalidations = [];
-
   let readFileSync = _fs().default.readFileSync;
+  let statSync = _fs().default.statSync;
 
-  let statSync = _fs().default.statSync; // $FlowFixMe
-
-
+  // $FlowFixMe
   _fs().default.readFileSync = (filename, encoding) => {
     return fs.readFileSync(filename, encoding);
-  }; // $FlowFixMe
-
+  };
 
+  // $FlowFixMe
   _fs().default.statSync = p => {
     try {
       return fs.statSync(p);
@@ -338,17 +282,14 @@ function patchNativeFS(fs, nativeGlob) {
           filePath: p
         });
       }
-
       throw err;
     }
-  }; // Patch the `glob` module as well so we use the Parcel FS and track invalidations.
-
+  };
 
+  // Patch the `glob` module as well so we use the Parcel FS and track invalidations.
   let glob = nativeGlob.sync;
-
   nativeGlob.sync = p => {
     let res = (0, _utils().globSync)(p, fs);
-
     if (!p.includes(`node_modules${_path().default.sep}stylus`)) {
       // Sometimes stylus passes file paths with no glob parts to the `glob` module.
       // We want to avoid treating these as globs for performance.
@@ -362,27 +303,23 @@ function patchNativeFS(fs, nativeGlob) {
         });
       }
     }
-
     return res;
   };
-
   return () => {
     // $FlowFixMe
-    _fs().default.readFileSync = readFileSync; // $FlowFixMe
-
+    _fs().default.readFileSync = readFileSync;
+    // $FlowFixMe
     _fs().default.statSync = statSync;
     nativeGlob.sync = glob;
     return invalidations;
   };
 }
+
 /**
  * Puts the content of all given node blocks into the first one, essentially merging them.
  */
-
-
 function mergeBlocks(blocks) {
   let finalBlock;
-
   for (const block of blocks) {
     if (finalBlock) {
       // $FlowFixMe - finalBlock is definitely defined
@@ -391,6 +328,5 @@ function mergeBlocks(blocks) {
       finalBlock = block;
     }
   }
-
   return finalBlock;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parcel/transformer-stylus",
-  "version": "2.8.3",
+  "version": "2.9.0",
   "license": "MIT",
   "publishConfig": {
     "access": "public"
@@ -17,12 +17,12 @@
   "source": "src/StylusTransformer.js",
   "engines": {
     "node": ">= 12.0.0",
-    "parcel": "^2.8.3"
+    "parcel": "^2.9.0"
   },
   "dependencies": {
-    "@parcel/plugin": "2.8.3",
-    "@parcel/utils": "2.8.3",
+    "@parcel/plugin": "2.9.0",
+    "@parcel/utils": "2.9.0",
     "stylus": "^0.55.0"
   },
-  "gitHead": "349a6caf40ec8abb6a49fcae0765f8f8deb2073d"
+  "gitHead": "dd9435be8afed35c5ffc161cf4b586fd6c78fc1f"
 }

package/src/StylusTransformer.js

@@ -16,18 +16,13 @@ const URL_RE = /^(?:url\s*\(\s*)?['"]?(?:[#/]|(?:https?:)?\/\/)/i;
 export default (new Transformer({
   async loadConfig({config}) {
     let configFile = await config.getConfig(
-      ['.stylusrc', '.stylusrc.js', '.stylusrc.cjs'],
+      ['.stylusrc', '.stylusrc.js', '.stylusrc.cjs', '.stylusrc.mjs'],
       {
         packageKey: 'stylus',
       },
     );
 
     if (configFile) {
-      let isJavascript = path.extname(configFile.filePath).endsWith('js');
-      if (isJavascript) {
-        config.invalidateOnStartup();
-      }
-
       // Resolve relative paths from config file
       if (configFile.contents.paths) {
         configFile.contents.paths = configFile.contents.paths.map(p =>
@@ -101,13 +96,21 @@ function attemptResolve(importedPath, filepath, asset, resolve, deps) {
             resolve(
               filepath,
               './' + path.relative(path.dirname(filepath), entry),
+              {
+                packageConditions: ['stylus', 'style'],
+              },
             ),
           ),
         ),
       ),
     );
   } else {
-    deps.set(importedPath, resolve(filepath, importedPath));
+    deps.set(
+      importedPath,
+      resolve(filepath, importedPath, {
+        packageConditions: ['stylus', 'style'],
+      }),
+    );
   }
 }