poops 1.0.18 → 1.0.20

package/lib/markups.js

@@ -5,7 +5,7 @@ const nunjucks = require('nunjucks')
 const path = require('node:path')
 const PrintStyle = require('./utils/print-style.js')
 
-const { pathExists, pathIsDirectory, readDataFile, deleteDirectory } = helpers
+const { pathExists, pathIsDirectory, readDataFile, deleteDirectory, mkDir, parseFrontMatter, clearFrontMatterCache } = helpers
 const pstyle = new PrintStyle()
 
 class RelativeLoader extends nunjucks.Loader {
@@ -13,7 +13,7 @@ class RelativeLoader extends nunjucks.Loader {
     super()
     this.templatesDir = templatesDir
     this.includePaths = includePaths || []
-    this.includePaths.push('_*') // XXX: It is better to define templates and layouts directories in the config file? then all toghether include paths?
+    this.includePaths.push('_*') // XXX: It is better to define templates and layouts directories in the config file? then all together include paths?
   }
 
   getSource(name) {
@@ -31,12 +31,16 @@ class RelativeLoader extends nunjucks.Loader {
       return { src: '', path: fullPath, noCache: true }
     }
 
-    let source = fs.readFileSync(fullPath, 'utf-8')
+    let source = ''
     let frontMatter = {}
-    const match = source.match(/^\s*---\s*([\s\S]*?)---\s*/)
-    if (match) {
-      frontMatter = require('yaml').parse(match[1])
-      source = source.slice(match[0].length) // Remove front matter
+
+    try {
+      const frontMatterResult = parseFrontMatter(fullPath)
+      frontMatter = frontMatterResult.frontMatter
+      source = frontMatterResult.content
+    } catch (err) {
+      console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${fullPath}${pstyle.reset}`)
+      console.log(err)
     }
 
     if (path.extname(fullPath) === '.md') {
@@ -194,7 +198,15 @@ module.exports = class Markups {
   getSingleCollectionData(collectionName) {
     const collectionData = []
     glob.sync(path.join(process.cwd(), this.config.markup.in, collectionName, '**/*.+(html|njk|md)'), { ignore: ['**/index.+(html|njk|md)'] }).forEach((file) => {
-      const frontMatter = this.getFrontMatter(file)
+      let frontMatter = {}
+
+      try {
+        const frontMatterResult = parseFrontMatter(file)
+        frontMatter = frontMatterResult.frontMatter
+      } catch (err) {
+        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${file}${pstyle.reset}`)
+        console.log(err)
+      }
 
       if (frontMatter.published === false) return // Skip unpublished items
 
@@ -223,69 +235,109 @@ module.exports = class Markups {
     const collectionData = {}
 
     for (const indexFile of indexFiles) {
-      const frontMatter = this.getFrontMatter(indexFile)
+      let frontMatter = {}
+
+      try {
+        const frontMatterResult = parseFrontMatter(indexFile)
+        frontMatter = frontMatterResult.frontMatter
+      } catch (err) {
+        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${indexFile}${pstyle.reset}`)
+        console.log(err)
+      }
+
       if (!frontMatter.collection) continue
 
       if (frontMatter.collection === true) {
         frontMatter.collection = path.basename(path.dirname(indexFile))
       }
 
-      if (frontMatter.collection.trim() === '') continue
+      const collectionName = frontMatter.collection.trim()
 
-      const collection = { name: frontMatter.collection }
+      if (collectionName === '') continue
 
-      if (frontMatter.paginate && !isNaN(parseInt(frontMatter.paginate))) {
-        collection.paginate = parseInt(frontMatter.paginate)
-      }
+      frontMatter.name = collectionName
+      const collection = this.buildCollectionObject(frontMatter)
+      if (!collection) continue
+      collectionData[collection.name] = collection
+    }
 
-      if (frontMatter.sort) {
-        collection.sort = frontMatter.sort
-      }
+    return collectionData
+  }
 
-      if (typeof collection.sort === 'string') {
-        collection.sort = { by: collection.sort }
-      }
+  getCollectionDataBasedOnConfig(collectionConfig) {
+    if (!collectionConfig) return {}
 
-      if (!collection.sort) {
-        collection.sort = { by: 'date' }
-      }
+    const items = Array.isArray(collectionConfig)
+      ? collectionConfig
+      : [collectionConfig]
 
-      if (!collection.sort.by) {
-        collection.sort.by = 'date'
-      }
+    const collectionData = {}
 
-      if (collection.sort.by === 'date') {
-        collection.sort.type = 'date'
-      } else {
-        collection.sort.type = 'alphabetical'
-      }
+    for (let item of items) {
+      if (typeof item === 'string') item = { name: item }
+      if (!item || !item.name) continue
+      const collection = this.buildCollectionObject(item)
+      if (collection) collectionData[item.name] = collection
+    }
 
-      if (!collection.sort.order) {
-        collection.sort.order = collection.sort.type === 'date' ? 'desc' : 'asc'
-      }
+    return collectionData
+  }
 
-      collectionData[collection.name] = collection
+  buildCollectionObject(collectionProtoObject) {
+    const collection = {
+      name: collectionProtoObject.name,
+      items: this.getSingleCollectionData(collectionProtoObject.name)
+    }
 
-      collectionData[collection.name].items = this.getSingleCollectionData(collection.name)
+    if (collection.items.length === 0) return null
 
-      collectionData[collection.name].items.sort((a, b) => {
-        if (collection.sort.type === 'date') {
-          if (collection.sort.order === 'asc') {
-            return new Date(a[collection.sort.by]) - new Date(b[collection.sort.by])
-          }
+    if (collectionProtoObject.paginate && !isNaN(parseInt(collectionProtoObject.paginate))) {
+      collection.paginate = parseInt(collectionProtoObject.paginate)
+    }
 
-          return new Date(b[collection.sort.by]) - new Date(a[collection.sort.by])
-        } else {
-          if (collection.sort.order === 'asc') {
-            return a[collection.sort.by] > b[collection.sort.by] ? 1 : -1
-          }
+    if (collectionProtoObject.sort) {
+      collection.sort = collectionProtoObject.sort
+    }
 
-          return a[collection.sort.by] < b[collection.sort.by] ? 1 : -1
-        }
-      })
+    if (typeof collection.sort === 'string') {
+      collection.sort = { by: collection.sort }
     }
 
-    return collectionData
+    if (!collection.sort) {
+      collection.sort = { by: 'date' }
+    }
+
+    if (!collection.sort.by) {
+      collection.sort.by = 'date'
+    }
+
+    if (collection.sort.by === 'date') {
+      collection.sort.type = 'date'
+    } else {
+      collection.sort.type = 'alphabetical'
+    }
+
+    if (!collection.sort.order) {
+      collection.sort.order = collection.sort.type === 'date' ? 'desc' : 'asc'
+    }
+
+    collection.items.sort((a, b) => {
+      if (collection.sort.type === 'date') {
+        if (collection.sort.order === 'asc') {
+          return new Date(a[collection.sort.by]) - new Date(b[collection.sort.by])
+        }
+
+        return new Date(b[collection.sort.by]) - new Date(a[collection.sort.by])
+      } else {
+        if (collection.sort.order === 'asc') {
+          return a[collection.sort.by] > b[collection.sort.by] ? 1 : -1
+        }
+
+        return a[collection.sort.by] < b[collection.sort.by] ? 1 : -1
+      }
+    })
+
+    return collection
   }
 
   clearCollectionOutputDir(collectionName) {
@@ -293,15 +345,27 @@ module.exports = class Markups {
     deleteDirectory(collectionDirectoryPath) // Remove collection directory
   }
 
-  getRelativePathPrefix(outputDir) {
-    const relativeDir = path.relative(process.cwd(), outputDir)
+  getRelativePathPrefix(outputDir, fromDir) {
+    let relativeDir = path.relative(process.cwd(), outputDir)
+    const fromRelativeDir = fromDir ? path.relative(process.cwd(), fromDir) : ''
+
+    if (fromRelativeDir && relativeDir.startsWith(fromRelativeDir)) {
+      relativeDir = relativeDir.replace(fromRelativeDir, '')
+    }
+
+    return this.getUpDirPrefix(relativeDir)
+  }
+
+  getUpDirPrefix(relativeDir) {
     if (relativeDir.trim() === '') return ''
+    if (relativeDir.startsWith(path.sep)) relativeDir = relativeDir.slice(1)
+    if (relativeDir.endsWith(path.sep)) relativeDir = relativeDir.slice(0, -1)
     const relativePathParts = relativeDir.split(path.sep)
-    let relativePathPrefix = ''
+    let upDir = ''
     for (let i = 0; i < relativePathParts.length; i++) {
-      relativePathPrefix += '../'
+      upDir += `..${path.sep}`
     }
-    return relativePathPrefix
+    return upDir
   }
 
   getPageUrl(outputPath) {
@@ -323,8 +387,6 @@ module.exports = class Markups {
   }
 
   compileEntry(templateName, additionalContext) {
-    const source = fs.readFileSync(templateName, 'utf-8')
-    const match = source.match(/^\s*---\s*([\s\S]*?)---\s*/) // Front matter match
     const context = { page: {} }
     let pageUrl
 
@@ -335,13 +397,13 @@ module.exports = class Markups {
       }
       Object.assign(context, additionalContext)
     }
-    if (match) {
-      try {
-        context.page = require('yaml').parse(match[1]) // Pass front matter to the template
-      } catch (err) {
-        console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${templateName}${pstyle.reset}`)
-        console.log(err)
-      }
+
+    try {
+      const frontMatterResult = parseFrontMatter(templateName)
+      context.page = frontMatterResult.frontMatter
+    } catch (err) {
+      console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${templateName}${pstyle.reset}`)
+      console.log(err)
     }
 
     if (pageUrl) context.page.url = pageUrl
@@ -358,106 +420,122 @@ module.exports = class Markups {
     })
   }
 
+  getCollectionIndexFile(collectionName) {
+    const indexFiles = glob.sync(path.join(process.cwd(), this.config.markup.in, collectionName, 'index.+(html|njk|md)'))
+    if (indexFiles.length === 0) return null
+    return indexFiles[0]
+  }
+
+  buildCollectionPaginationData(collectionData) {
+    if (!collectionData) return
+
+    for (const collectionName of Object.keys(collectionData)) {
+      const collection = collectionData[collectionName]
+
+      if (!collection.paginate) continue
+
+      collection.pages = []
+      let pageItems = []
+      for (const item of collection.items) {
+        if (pageItems.length === collection.paginate) {
+          collection.pages.push(pageItems)
+          pageItems = []
+        }
+        pageItems.push(item)
+      }
+      collection.pages.push(pageItems)
+
+      collection.totalPages = collection.pages.length
+    }
+  }
+
+  generateCollectionPaginationPages(collectionData, compilePromises) {
+    if (!collectionData) return
+
+    for (const collectionName of Object.keys(collectionData)) {
+      const collection = collectionData[collectionName]
+      const file = this.getCollectionIndexFile(collectionName)
+
+      if (!collection.totalPages || collection.totalPages === 0) {
+        collection.totalPages = 1
+        collection.pages = [collection.items]
+      }
+
+      for (let i = 0; i < collection.totalPages; i++) {
+        collection.pageItems = collection.pages[i]
+        collection.pageNumber = i + 1
+        collection.pageUrl = collection.pageNumber === 1 ? collection.name : `${collection.name}/${collection.pageNumber}`
+        collection.nextPage = collection.pageNumber === collection.totalPages ? null : collection.pageNumber + 1
+        collection.nextPageUrl = collection.pageNumber === collection.totalPages ? null : `${collection.name}/${collection.pageNumber + 1}`
+        collection.prevPage = collection.pageNumber === 1 ? null : collection.pageNumber - 1
+        collection.prevPageUrl = collection.pageNumber === 1 ? null : `${collection.name}/${collection.pageNumber - 1}`
+        if (collection.prevPage === 1) {
+          collection.prevPageUrl = collection.name
+        }
+
+        const markupOut = path.join(process.cwd(), this.config.markup.out, collection.pageUrl, 'index.html')
+        const fromPath = path.join(process.cwd(), this.config.markup.out)
+        const markupOutDir = path.dirname(markupOut)
+
+        mkDir(markupOutDir)
+
+        collectionData.relativePathPrefix = this.getRelativePathPrefix(markupOutDir, fromPath)
+        collectionData._url = this.getPageUrl(markupOut)
+
+        if (!file) {
+          continue
+        }
+
+        const compilePromise = this.compileEntry(file, collectionData).then((result) => {
+          fs.writeFileSync(markupOut, result)
+        })
+        compilePromises.push(compilePromise)
+      }
+    }
+  }
+
   compile() {
-    // TODO: should support multiple markup paths, for loop here!
     if (!this.config.markup || !this.config.markup.in) return
 
     const markupIn = path.join(process.cwd(), this.config.markup.in)
+    const compilePromises = []
 
     if (!pathExists(markupIn)) {
       console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} ${pstyle.dim}Markup path does not exist:${pstyle.reset} ${pstyle.italic + pstyle.underline}${markupIn}${pstyle.reset}`)
       return
     }
 
+    const collectionData = {
+      ...this.collectionAutoDiscovery(),
+      ...this.getCollectionDataBasedOnConfig(this.config.markup.options.collections)
+    }
+
+    // Create collection pages
+    this.buildCollectionPaginationData(collectionData)
+    this.generateCollectionPaginationPages(collectionData, compilePromises)
+
     if (pathIsDirectory(markupIn)) {
       const markupFiles = [...glob.sync(path.join(markupIn, this.generateMarkupGlobPattern(this.includePaths))), ...glob.sync(path.join(markupIn, '*.+(html|xml|rss|atom|json|njk|md)'))]
-      const collectionData = this.collectionAutoDiscovery()
-      const compilePromises = []
+
       markupFiles.forEach((file) => {
         const relativePath = path.relative(markupIn, file)
         const relativePathParts = relativePath.split(path.sep)
 
-        // Create pagination for collection pages
+        // Collection pages already generated, skip them
         if (relativePathParts.length > 1 &&
           collectionData[relativePathParts[0]] &&
-          (relativePathParts[1] === 'index.html' || relativePathParts[1] === 'index.njk' || relativePathParts[1] === 'index.md') &&
+          /^index\.(html|njk|md)$/.test(relativePathParts[1]) &&
           collectionData[relativePathParts[0]].items.length > 0) {
-          let frontMatter = {}
-          const source = fs.readFileSync(file, 'utf-8')
-          const match = source.match(/^\s*---\s*([\s\S]*?)---\s*/) // Front matter match
-          if (match) {
-            try {
-              frontMatter = require('yaml').parse(match[1]) // Pass front matter to the template
-            } catch (err) {
-              console.log(`${pstyle.redBright + pstyle.bold}[error]${pstyle.reset}${pstyle.dim} Failed parsing front matter:${pstyle.reset} ${pstyle.italic + pstyle.underline}${file}${pstyle.reset}`)
-              console.log(err)
-            }
-          }
-
-          if (frontMatter.paginate && !isNaN(parseInt(frontMatter.paginate))) {
-            frontMatter.paginate = parseInt(frontMatter.paginate)
-          }
-
-          // TODO: sorting should be done via frontMatter not the config file.  Collection autodiscovery from frontMatter as well
-
-          const collectionName = relativePathParts[0]
-
-          if (frontMatter.paginate) {
-            const collection = collectionData[collectionName]
-            collection.paginate = frontMatter.paginate
-            collection.pages = []
-            let pageItems = []
-            for (const item of collection.items) {
-              if (pageItems.length === collection.paginate) {
-                collection.pages.push(pageItems)
-                pageItems = []
-              }
-              pageItems.push(item)
-            }
-            collection.pages.push(pageItems)
-
-            collection.totalPages = collection.pages.length
-
-            for (let i = 0; i < collection.totalPages; i++) {
-              collection.pageItems = collection.pages[i]
-              collection.pageNumber = i + 1
-              collection.pageUrl = collection.pageNumber === 1 ? collectionName : `${collectionName}/${collection.pageNumber}`
-              collection.nextPage = collection.pageNumber === collection.totalPages ? null : collection.pageNumber + 1
-              collection.nextPageUrl = collection.pageNumber === collection.totalPages ? null : `${collectionName}/${collection.pageNumber + 1}`
-              collection.prevPage = collection.pageNumber === 1 ? null : collection.pageNumber - 1
-              collection.prevPageUrl = collection.pageNumber === 1 ? null : `${collectionName}/${collection.pageNumber - 1}`
-              if (collection.prevPage === 1) {
-                collection.prevPageUrl = collectionName
-              }
-
-              const markupOut = path.join(process.cwd(), this.config.markup.out, collection.pageUrl, 'index.html')
-              const markupOutDir = path.dirname(markupOut)
-
-              if (!pathExists(markupOutDir)) {
-                fs.mkdirSync(markupOutDir, { recursive: true })
-              }
-
-              collectionData.relativePathPrefix = this.getRelativePathPrefix(markupOutDir)
-              collectionData._url = this.getPageUrl(markupOut)
-
-              const compilePromise = this.compileEntry(file, collectionData).then((result) => {
-                fs.writeFileSync(markupOut, result)
-              })
-              compilePromises.push(compilePromise)
-            }
-          }
-
           return
         }
 
-        let markupOut = path.join(process.cwd(), relativePath)
+        let markupOut = path.join(process.cwd(), this.config.markup.out, relativePath)
+        const fromPath = path.join(process.cwd(), this.config.markup.out)
         const markupOutDir = path.dirname(markupOut)
 
-        if (!pathExists(markupOutDir)) {
-          fs.mkdirSync(markupOutDir, { recursive: true })
-        }
+        mkDir(markupOutDir)
 
-        collectionData.relativePathPrefix = this.getRelativePathPrefix(markupOutDir)
+        collectionData.relativePathPrefix = this.getRelativePathPrefix(markupOutDir, fromPath)
         collectionData._url = this.getPageUrl(markupOut)
 
         const compilePromise = this.compileEntry(file, collectionData).then((result) => {
@@ -470,27 +548,32 @@ module.exports = class Markups {
       return new Promise((resolve, reject) => {
         Promise.all(compilePromises).then(() => {
           console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.dim}Compiled: ${pstyle.reset}${markupFiles.length} file${markupFiles.length > 1 ? 's' : ''} into ${pstyle.italic + pstyle.underline}${this.config.markup.out}${pstyle.reset}`)
+          clearFrontMatterCache()
           resolve()
         }).catch((err) => {
           console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} ${pstyle.dim}Failed compiling${pstyle.reset + pstyle.bell}`)
           console.log(err)
+          clearFrontMatterCache()
           reject(err)
         })
       })
     } else {
       let markupOut = path.join(process.cwd(), this.config.markup.out)
       const markupOutDir = path.dirname(markupOut)
-      const additionalContext = {}
-      additionalContext.relativePathPrefix = this.getRelativePathPrefix(markupOutDir)
-      additionalContext._url = this.getPageUrl(markupOut)
+      mkDir(markupOutDir)
+
+      collectionData.relativePathPrefix = this.getRelativePathPrefix(markupOutDir)
+      collectionData._url = this.getPageUrl(markupOut)
 
-      return this.compileEntry(markupIn, additionalContext).then((result) => {
+      return this.compileEntry(markupIn, collectionData).then((result) => {
         markupOut = this.replaceOutExtensions(markupOut)
         fs.writeFileSync(markupOut, result)
         console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.dim}Compiled:${pstyle.reset} ${pstyle.italic + pstyle.underline}${path.relative(process.cwd(), path.join(process.cwd(), this.config.markup.out, path.basename(markupIn)))}${pstyle.reset}`)
+        clearFrontMatterCache()
       }).catch((err) => {
         console.log(`${pstyle.cyanBright + pstyle.bold}[markup]${pstyle.reset} ${pstyle.redBright + pstyle.bold}[error]${pstyle.reset} ${pstyle.dim}Failed compiling:${pstyle.reset} ${pstyle.italic + pstyle.underline}${path.relative(process.cwd(), path.join(process.cwd(), this.config.markup.out, path.basename(markupIn)))}${pstyle.reset + pstyle.bell}`)
         console.log(err)
+        clearFrontMatterCache()
       })
     }
   }

package/lib/styles.js

@@ -20,47 +20,88 @@ const {
 const pstyle = new PrintStyle()
 
 function tryToFindFile(filePath, extensions) {
-  const fileExt = extensions.find(ext => fs.existsSync(`${filePath}.${ext}`))
-  if (fileExt) {
-    return `${filePath}.${fileExt}`
+  const pathParts = path.parse(filePath)
+  if (pathParts.ext && pathParts.ext.length > 0 && extensions.includes(pathParts.ext.slice(1))) {
+    if (fs.existsSync(filePath)) return filePath
   }
+
+  let fileExt = extensions.find(ext => fs.existsSync(`${filePath}.${ext}`))
+  if (fileExt) return `${filePath}.${fileExt}`
+
+  if (!pathParts.name.startsWith('_')) {
+    pathParts.name = `_${pathParts.name}`
+    const underscoredFilePath = path.format(pathParts)
+    fileExt = extensions.find(ext => fs.existsSync(`${underscoredFilePath}.${ext}`))
+    if (fileExt) return `${underscoredFilePath}.${fileExt}`
+  }
+
   return null
 }
 
+function extractMainPathFromPackageJson(packageJsonPath) {
+  if (!pathExists(packageJsonPath, 'package.json')) return null
+
+  const pkg = require(path.join(process.cwd(), packageJsonPath, 'package.json'))
+
+  const mainPath = pkg.sass || pkg.scss || pkg.style || pkg.css || pkg.main
+  if (!mainPath) return null
+
+  return mainPath
+}
+
+function getPackagePath(url) {
+  const parts = path.parse(url)
+  if (!parts.dir) return null
+  const dirChunks = parts.dir.split(path.sep)
+  if (dirChunks.length === 0) return null
+  if (dirChunks[0].startsWith('@') && dirChunks.length > 1) {
+    return path.join(dirChunks[0], dirChunks[1])
+  }
+  return dirChunks[0]
+}
+
 function sassPathResolver(url, resolvePath, infilePath) {
+  // check if resole path, like `node_modules` exists
   const resolvedPath = pathToFileURL(resolvePath)
   if (!fs.existsSync(resolvedPath.pathname)) return null
   const importPath = path.relative(process.cwd(), path.join(resolvedPath.pathname, url))
 
-  if (!fs.existsSync(importPath)) { // Will this ever fire?
-    const correctFile = tryToFindFile(importPath, ['sass', 'scss', 'css'])
-    if (correctFile) return new URL(correctFile, resolvedPath)
-  }
+  // 1. Maybe it's a directory?
+  if (pathExists(importPath) && pathIsDirectory(importPath)) {
+    // Try to find an index file within the directory
+    const correctIndexFile = tryToFindFile(path.join(importPath, 'index'), ['sass', 'scss', 'css'])
+    if (correctIndexFile) return new URL(correctIndexFile, resolvedPath)
 
-  if (pathIsDirectory(importPath) && !pathExists(importPath, 'index.sass') && !pathExists(importPath, 'index.scss')) {
-    const correctFile = tryToFindFile(importPath, ['sass', 'scss', 'css'])
+    // package.json discovery
+    const style = extractMainPathFromPackageJson(importPath)
 
-    if (correctFile) return new URL(correctFile, resolvedPath)
+    const stylePath = new URL(path.join(importPath, style), resolvedPath)
+    if (fs.existsSync(stylePath)) return stylePath
+  }
 
-    if (!pathExists(importPath, 'package.json')) return null
+  // 2. Maybe it's a file?
+  if (pathExists(importPath)) return pathToFileURL(importPath)
 
-    const pkg = require(path.join(process.cwd(), importPath, 'package.json'))
+  // 2.1 Try to find the correct file with different formats
+  const correctFile = tryToFindFile(importPath, ['sass', 'scss', 'css'])
+  if (correctFile) return new URL(correctFile, resolvedPath)
 
-    let style = pkg.sass || pkg.scss || pkg.style || pkg.css || pkg.main
-    if (!style) return null
+  // 2.2 Maybe it's a file within a package?
+  const packagePath = getPackagePath(url)
+  if (packagePath) {
+    const packageFullPath = path.relative(process.cwd(), path.join(resolvedPath.pathname, packagePath))
+    const stylePath = extractMainPathFromPackageJson(packageFullPath)
 
-    if (!Array.isArray(style)) {
-      style = [style]
-    }
+    if (stylePath) {
+      const styleDir = path.dirname(stylePath)
+      const styleFinalPath = path.join(packageFullPath, styleDir, url.replace(packagePath, ''))
 
-    for (const styleEntry of style) {
-      if (typeof styleEntry !== 'string') continue
-      const stylePath = new URL(path.join(importPath, styleEntry), resolvedPath)
-      if (fs.existsSync(stylePath)) return stylePath
+      const correctPackageFile = tryToFindFile(styleFinalPath, ['sass', 'scss', 'css'])
+      if (correctPackageFile) return new URL(correctPackageFile, resolvedPath)
     }
   }
 
-  return new URL(importPath, resolvedPath)
+  return null
 }
 
 module.exports = class Styles {
@@ -90,8 +131,8 @@ module.exports = class Styles {
         // Resolve `includePaths`.
         findFileUrl(url) {
           for (const includePath of includePaths) {
-            const resolvedPath = sassPathResolver(url, includePath)
-            if (resolvedPath) return resolvedPath
+            const resolvedPath = sassPathResolver(url, includePath, infilePath)
+            if (resolvedPath && pathExists(resolvedPath.pathname)) return resolvedPath
           }
           return null
         }