fix: fix resolving nested themes

src/cli/build.ts

@@ -5,7 +5,7 @@ import chalk from 'chalk'
 
 import { loadConfig } from '../core/config'
 import { build } from '../core/build'
-import { loadTheme } from '../core/load-theme'
+import { loadTheme } from '../core/loadTheme'
 import { debounce, flatten } from '../core/utils'
 
 type Flags = {

src/core/build.ts

@@ -7,7 +7,7 @@ import { Api, InternalApi } from '../index'
 import { createStyleDictionaryConfig } from './style-dictionary-config'
 import { variablesWithPrefix } from './variablesWithPrefix'
 import { loadMappers } from './mappers'
-import { loadTheme } from './load-theme'
+import { loadTheme } from './loadTheme'
 import { dedupeProps } from './dedupe-props'
 import { loadSources } from './load-sources'
 import { Config } from './config'

src/core/loadTheme.ts

@@ -0,0 +1,70 @@
+import { join, resolve, dirname } from 'path'
+import { readJSON, existsSync } from 'fs-extra'
+import merge from 'deepmerge'
+
+import { resolveFrom } from '../resolveFrom'
+import { findPackageRoot } from '../findPackageRoot'
+import { Platforms } from './platforms'
+
+export async function loadTheme(
+  source: string,
+  root: string = process.cwd(),
+): Promise<OutputTheme> {
+  let derivedTheme: OutputTheme = {
+    mappers: [],
+    sources: [],
+    whitepaper: {},
+    platforms: ['common'],
+  }
+  const theme: InputTheme = await readJSON(source)
+
+  // In case with node_modules in cwd need resolve all sources from package root.
+  root = root.match(/node_modules/) === null ? root : findPackageRoot(root)
+
+  if (theme.extends !== undefined) {
+    const parentThemePath = resolveFrom(root, theme.extends)
+    if (parentThemePath && existsSync(parentThemePath)) {
+      const parentThemeCwd = dirname(parentThemePath)
+      const parentTheme = await loadTheme(parentThemePath, parentThemeCwd)
+      // Platforms should be defined at project theme.
+      derivedTheme = merge(derivedTheme, { ...parentTheme, platforms: [] })
+    } else {
+      throw new Error(`Cannot load theme: "${theme.extends}".`)
+    }
+  }
+
+  if (theme.platforms !== undefined) {
+    derivedTheme.platforms = theme.platforms
+  }
+
+  if (theme.mappers !== undefined) {
+    derivedTheme.mappers.push(...theme.mappers.map((filePath) => join(root, filePath)))
+  }
+
+  if (theme.whitepaper !== undefined) {
+    derivedTheme.whitepaper = { ...derivedTheme.whitepaper, ...theme.whitepaper }
+  }
+
+  for (const source of theme.sources) {
+    // Makes array of arrays with each source for save order after glob.
+    derivedTheme.sources.push([resolve(root, source)])
+  }
+
+  return derivedTheme
+}
+
+type InputTheme = {
+  mappers: string[]
+  sources: string[]
+  whitepaper: Record<string, string>
+  platforms: Platforms[]
+  extends?: string
+}
+
+type OutputTheme = {
+  mappers: string[]
+  // Uses nested array with paths, cuz glob not save orders with using patterns for path.
+  sources: string[][]
+  whitepaper: Record<string, string>
+  platforms: Platforms[]
+}

src/core/utils.ts

@@ -2,10 +2,6 @@ import normalize from 'normalize-path'
 
 import { Platforms } from '../core/platforms'
 
-export function throwError(messag: string): void {
-  throw new Error(messag)
-}
-
 export function getPlatformFromFilePath(filePath: string): Platforms {
   const matched = filePath.match(/@([\w|-]+)+\./)
   return matched === null ? 'common' : (matched[1] as Platforms)

src/findPackageRoot.ts

@@ -0,0 +1,14 @@
+import { dirname, join } from 'path'
+import readPkgUp from 'read-pkg-up'
+
+export function findPackageRoot(path: string): string {
+  const data = readPkgUp.sync({ cwd: path })
+  if (data === undefined) {
+    throw new Error('Cannot find package root, please check exists package.json.')
+  }
+  if (data.packageJson.version !== '' && data.packageJson.name !== '') {
+    return dirname(data.path)
+  }
+  const prevDir = join(dirname(data.path), '..')
+  return findPackageRoot(prevDir)
+}

src/resolveFrom.ts

@@ -0,0 +1,30 @@
+import Module from 'module'
+import path from 'path'
+import fs from 'fs'
+
+export function resolveFrom(fromDirectory: string, moduleId: string): string | undefined {
+  try {
+    fromDirectory = fs.realpathSync(fromDirectory)
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      fromDirectory = path.resolve(fromDirectory)
+    } else {
+      return
+    }
+  }
+
+  const fromFile = path.join(fromDirectory, 'noop.js')
+
+  const resolveFileName = () =>
+    (Module as any)._resolveFilename(moduleId, {
+      id: fromFile,
+      filename: fromFile,
+      paths: (Module as any)._nodeModulePaths(fromDirectory),
+    })
+
+  try {
+    return resolveFileName()
+  } catch (error) {
+    return
+  }
+}