refactor: code

Author: cap-Bernardito

src/index.js

@@ -53,6 +53,7 @@ export default function loader(content, map, meta) {
       mainFiles: ['index', '...'],
       extensions: ['.css'],
       restrictions: [/\.css$/i],
+      conditionNames: ['style'],
     });
 
     plugins.push(

src/plugins/postcss-import-parser.js

@@ -1,8 +1,7 @@
 import postcss from 'postcss';
 import valueParser from 'postcss-value-parser';
-import { isUrlRequest, urlToRequest } from 'loader-utils';
 
-import { normalizeUrl, resolveRequests } from '../utils';
+import { normalizeUrl, resolveRequests, isUrlRequestable } from '../utils';
 
 const pluginName = 'postcss-import-parser';
 
@@ -77,23 +76,18 @@ export default postcss.plugin(pluginName, (options) => (css, result) => {
         return;
       }
 
-      let request;
+      let normalizedUrl;
 
-      // May be url is server-relative url, but not //example.com
-      if (url.charAt(0) === '/' && url.charAt(1) !== '/') {
-        request = urlToRequest(url, options.rootContext);
-      }
-
-      const isRequestable = isUrlRequest(url);
+      const isRequestable = isUrlRequestable(url);
 
       if (isRequestable) {
-        url = normalizeUrl(url, isStringValue);
+        normalizedUrl = normalizeUrl(url, isStringValue, options.rootContext);
 
         // Empty url after normalize - `@import '\
         // \
         // \
         // ';
-        if (url.trim().length === 0) {
+        if (normalizedUrl.trim().length === 0) {
           result.warn(`Unable to find uri in "${atRule.toString()}"`, {
             node: atRule,
           });
@@ -104,7 +98,10 @@ export default postcss.plugin(pluginName, (options) => (css, result) => {
 
       const media = valueParser.stringify(nodes.slice(1)).trim().toLowerCase();
 
-      if (options.filter && !options.filter({ url, media })) {
+      if (
+        options.filter &&
+        !options.filter({ url: normalizedUrl || url, media })
+      ) {
         return;
       }
 
@@ -114,8 +111,8 @@ export default postcss.plugin(pluginName, (options) => (css, result) => {
 
       tasks.push(
         Promise.resolve(index).then(async (currentIndex) => {
-          if (isRequestable || request) {
-            const importKey = url;
+          if (isRequestable) {
+            const importKey = normalizedUrl;
             let importName = importsMap.get(importKey);
 
             if (!importName) {
@@ -124,20 +121,13 @@ export default postcss.plugin(pluginName, (options) => (css, result) => {
 
               const { resolver, context } = options;
 
-              const possibleRequest = [url];
-
-              if (request) {
-                possibleRequest.push(request);
-              }
-
               let resolvedUrl;
 
               try {
-                resolvedUrl = await resolveRequests(
-                  resolver,
-                  context,
-                  possibleRequest
-                );
+                resolvedUrl = await resolveRequests(resolver, context, [
+                  normalizedUrl,
+                  url,
+                ]);
               } catch (error) {
                 throw error;
               }

src/utils.js

@@ -4,7 +4,12 @@
 */
 import path from 'path';
 
-import { stringifyRequest, urlToRequest, interpolateName } from 'loader-utils';
+import {
+  stringifyRequest,
+  urlToRequest,
+  interpolateName,
+  isUrlRequest,
+} from 'loader-utils';
 import normalizePath from 'normalize-path';
 import cssesc from 'cssesc';
 import modulesValues from 'postcss-modules-values';
@@ -18,6 +23,7 @@ const unescapeRegExp = new RegExp(
   `\\\\([\\da-f]{1,6}${whitespace}?|(${whitespace})|.)`,
   'ig'
 );
+const matchNativeWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
 
 function unescape(str) {
   return str.replace(unescapeRegExp, (_, escaped, escapedWhitespace) => {
@@ -72,17 +78,19 @@ function getLocalIdent(loaderContext, localIdentName, localName, options) {
   ).replace(/\\\[local\\\]/gi, localName);
 }
 
-function normalizeUrl(url, isStringValue) {
-  const matchNativeWin32Path = /^[A-Z]:[/\\]|^\\\\/i;
-
+function normalizeUrl(url, isStringValue, rootContext) {
   let normalizedUrl = url;
 
   if (isStringValue && /\\[\n]/.test(normalizedUrl)) {
     normalizedUrl = normalizedUrl.replace(/\\[\n]/g, '');
   }
 
-  return matchNativeWin32Path.test(url)
-    ? urlToRequest(url, true)
+  if (matchNativeWin32Path.test(normalizedUrl)) {
+    return normalizedUrl;
+  }
+
+  return mayBeServerRelativeUrl(normalizedUrl)
+    ? urlToRequest(decodeURIComponent(unescape(normalizedUrl)), rootContext)
     : urlToRequest(decodeURIComponent(unescape(normalizedUrl)));
 }
 
@@ -452,6 +460,25 @@ function sortByName(array, orderNames) {
   return result;
 }
 
+/*
+ * May be url is server-relative url, but not //example.com
+ * */
+function mayBeServerRelativeUrl(url) {
+  if (url.charAt(0) === '/' && !/^\/\//.test(url)) {
+    return true;
+  }
+
+  return false;
+}
+
+function isUrlRequestable(url) {
+  if (mayBeServerRelativeUrl(url)) {
+    return true;
+  }
+
+  return isUrlRequest(url);
+}
+
 export {
   normalizeUrl,
   getFilter,
@@ -464,4 +491,5 @@ export {
   shouldUseModulesPlugins,
   resolveRequests,
   sortByName,
+  isUrlRequestable,
 };