fix(resolvers): respect configPath over layers

Author: ineshbose

src/resolvers.ts

@@ -2,35 +2,34 @@ import { existsSync } from 'fs'
 import { defu } from 'defu'
 import { join, relative, resolve } from 'pathe'
 import { findPath, useNuxt, tryResolveModule, resolveAlias } from '@nuxt/kit'
-import type { Arrayable, EditorSupportConfig, ExposeConfig, InjectPosition, ModuleOptions, ViewerConfig } from './types'
+import type { EditorSupportConfig, ExposeConfig, InjectPosition, ModuleOptions, ViewerConfig } from './types'
 
 /**
  * Resolves all configPath values for an application
  *
  * @param path configPath for a layer
  * @returns array of resolved paths
  */
-export const resolveConfigPath = async (path: Arrayable<string>) => (
- await Promise.all(
+const resolveConfigPath = async (path: ModuleOptions['configPath']) =>
+ Promise.all(
  (Array.isArray(path) ? path : [path])
  .filter(Boolean)
  .map((path) => findPath(path, { extensions: ['.js', '.cjs', '.mjs', '.ts'] }))
- )
-).filter((i): i is string => Boolean(i))
+ ).then((paths) => paths.filter((p): p is string => Boolean(p)))
 
 /**
  *
  * @param srcDir
  * @returns array of resolved content globs
  */
-export const resolveContentPaths = (srcDir: string, nuxt = useNuxt()) => {
+const resolveContentPaths = (srcDir: string, nuxtOptions = useNuxt().options) => {
  const r = (p: string) => p.startsWith(srcDir) ? p : resolve(srcDir, p)
  const extensionFormat = (s: string[]) => s.length > 1 ? `.{${s.join(',')}}` : `.${s.join('') || 'vue'}`
 
  const defaultExtensions = extensionFormat(['js', 'ts', 'mjs'])
- const sfcExtensions = extensionFormat(Array.from(new Set(['.vue', ...nuxt.options.extensions])).map(e => e.replace(/^\.*/, '')))
+ const sfcExtensions = extensionFormat(Array.from(new Set(['.vue', ...nuxtOptions.extensions])).map(e => e.replace(/^\.*/, '')))
 
- const importDirs = [...(nuxt.options.imports?.dirs || [])].map(r)
+ const importDirs = [...(nuxtOptions.imports?.dirs || [])].map(r)
  const [composablesDir, utilsDir] = [resolve(srcDir, 'composables'), resolve(srcDir, 'utils')]
 
  if (!importDirs.includes(composablesDir)) importDirs.push(composablesDir)
@@ -39,16 +38,16 @@ export const resolveContentPaths = (srcDir: string, nuxt = useNuxt()) => {
  return [
  r(`components/**/*${sfcExtensions}`),
  ...(() => {
- if (nuxt.options.components) {
- return (Array.isArray(nuxt.options.components) ? nuxt.options.components : typeof nuxt.options.components === 'boolean' ? ['components'] : nuxt.options.components.dirs).map(d => `${resolveAlias(typeof d === 'string' ? d : d.path)}/**/*${sfcExtensions}`)
+ if (nuxtOptions.components) {
+ return (Array.isArray(nuxtOptions.components) ? nuxtOptions.components : typeof nuxtOptions.components === 'boolean' ? ['components'] : nuxtOptions.components.dirs).map(d => `${resolveAlias(typeof d === 'string' ? d : d.path)}/**/*${sfcExtensions}`)
  }
  return []
  })(),
 
- nuxt.options.dir.layouts && r(`${nuxt.options.dir.layouts}/**/*${sfcExtensions}`),
- ...([true, undefined].includes(nuxt.options.pages) ? [r(`${nuxt.options.dir.pages}/**/*${sfcExtensions}`)] : []),
+ nuxtOptions.dir.layouts && r(`${nuxtOptions.dir.layouts}/**/*${sfcExtensions}`),
+ ...([true, undefined].includes(nuxtOptions.pages) ? [r(`${nuxtOptions.dir.pages}/**/*${sfcExtensions}`)] : []),
 
- nuxt.options.dir.plugins && r(`${nuxt.options.dir.plugins}/**/*${defaultExtensions}`),
+ nuxtOptions.dir.plugins && r(`${nuxtOptions.dir.plugins}/**/*${defaultExtensions}`),
  ...importDirs.map(d => `${d}/**/*${defaultExtensions}`),
 
  r(`{A,a}pp${sfcExtensions}`),
@@ -63,27 +62,32 @@ export const resolveContentPaths = (srcDir: string, nuxt = useNuxt()) => {
  * @param nuxt
  * @returns [configuration paths, default resolved content paths]
  */
-export const resolveModulePaths = async (configPath: ModuleOptions['configPath'], nuxt = useNuxt()): Promise<[string[], string[]]> => (
- (nuxt.options._layers && nuxt.options._layers.length > 1)
- // Support `extends` directories
- ? (await Promise.all(
- // nuxt.options._layers is from rootDir to nested level
- // We need to reverse the order to give the deepest tailwind.config the lowest priority
- nuxt.options._layers.slice().reverse().map(async (layer) => ([
+export const resolveModulePaths = async (configPath: ModuleOptions['configPath'], nuxt = useNuxt()) => {
+ const mainPaths: [string[], string[]] = [await resolveConfigPath(configPath), resolveContentPaths(nuxt.options.srcDir, nuxt.options)]
+
+ if (Array.isArray(nuxt.options._layers) && nuxt.options._layers.length > 1) {
+ const layerPaths = await Promise.all(
+ nuxt.options._layers.slice(1).reverse().map(async (layer): Promise<[string[], string[]]> => ([
  await resolveConfigPath(layer?.config?.tailwindcss?.configPath || join(layer.cwd, 'tailwind.config')),
- resolveContentPaths(layer?.config?.srcDir || layer.cwd)
+ resolveContentPaths(layer?.config?.srcDir || layer.cwd, defu(layer.config, nuxt.options) as typeof nuxt.options)
  ])))
- ).reduce((prev, curr) => prev.map((p, i) => p.concat(curr[i]))) as any
- : [await resolveConfigPath(configPath), resolveContentPaths(nuxt.options.srcDir)]
-)
+
+ layerPaths.forEach(([configPaths, contentPaths]) => {
+ mainPaths[0].push(...configPaths)
+ mainPaths[1].push(...contentPaths)
+ })
+ }
+
+ return mainPaths
+}
 
 /**
  *
  * @param cssPath
  * @param nuxt
  * @returns [resolvedCss, loggerMessage]
  */
-export async function resolveCSSPath (cssPath: Exclude<ModuleOptions['cssPath'], Array<any>>, nuxt = useNuxt()): Promise<[string | false, string]> {
+export async function resolveCSSPath(cssPath: Exclude<ModuleOptions['cssPath'], Array<any>>, nuxt = useNuxt()): Promise<[string | false, string]> {
  if (typeof cssPath === 'string') {
  return existsSync(cssPath)
  ? [cssPath, `Using Tailwind CSS from ~/${relative(nuxt.options.srcDir, cssPath)}`]
@@ -117,7 +121,7 @@ export const resolveEditorSupportConfig = (config: ModuleOptions['editorSupport'
  *
  * @returns index in the css array
  */
-export function resolveInjectPosition (css: string[], position: InjectPosition = 'first') {
+export function resolveInjectPosition(css: string[], position: InjectPosition = 'first') {
  if (typeof (position) === 'number') {
  return ~~Math.min(position, css.length + 1)
  }