1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

import type { TextDocuments, Connection, Range, SymbolInformation } from 'vscode-languageserver'
import type { TextDocument } from 'vscode-languageserver-textdocument'
import type { Postcss } from 'postcss'
import { KeywordColor } from './color'
import * as culori from 'culori'

export type ClassNamesTree = {
  [key: string]: ClassNamesTree
}

export type ClassNamesContext = {
  [key: string]: string[]
}

export type ClassNames = {
  context: ClassNamesContext
  classNames: ClassNamesTree
}

export type EditorState = {
  connection: Connection
  folder: string
  documents: TextDocuments<TextDocument>
  userLanguages: Record<string, string>
  capabilities: {
    configuration: boolean
    diagnosticRelatedInformation: boolean
  }
  getConfiguration: (uri?: string) => Promise<Settings>
  getDocumentSymbols: (uri: string) => Promise<SymbolInformation[]>
  readDirectory: (
    document: TextDocument,
    directory: string
  ) => Promise<Array<[string, { isDirectory: boolean }]>>
}

type DiagnosticSeveritySetting = 'ignore' | 'warning' | 'error'

export type EditorSettings = {
  tabSize: number
}

export type TailwindCssSettings = {
  emmetCompletions: boolean
  includeLanguages: Record<string, string>
  classAttributes: string[]
  suggestions: boolean
  hovers: boolean
  codeActions: boolean
  validate: boolean
  showPixelEquivalents: boolean
  rootFontSize: number
  colorDecorators: boolean
  lint: {
    cssConflict: DiagnosticSeveritySetting
    invalidApply: DiagnosticSeveritySetting
    invalidScreen: DiagnosticSeveritySetting
    invalidVariant: DiagnosticSeveritySetting
    invalidConfigPath: DiagnosticSeveritySetting
    invalidTailwindDirective: DiagnosticSeveritySetting
    recommendedVariantOrder: DiagnosticSeveritySetting
  }
  experimental: {
    classRegex: string[]
    configFile: string | Record<string, string | string[]>
  }
  files: {
    exclude: string[]
  }
}

export type Settings = {
  editor: EditorSettings
  tailwindCSS: TailwindCssSettings
}

export interface FeatureFlags {
  future: string[]
  experimental: string[]
}

export interface Variant {
  name: string
  values: string[]
  isArbitrary: boolean
  hasDash: boolean
  selectors: (params?: { value?: string; label?: string }) => string[]
}

export interface State {
  enabled: boolean
  configPath?: string
  configId?: string
  config?: any
  version?: string
  separator?: string
  dependencies?: string[]
  plugins?: any
  screens?: string[]
  variants?: Variant[]
  corePlugins?: string[]
  modules?: {
    tailwindcss?: { version: string; module: any }
    postcss?: { version: string; module: Postcss }
    postcssSelectorParser?: { module: any }
    resolveConfig?: { module: any }
    jit?: {
      generateRules: { module: any }
      createContext: { module: any }
      expandApplyAtRules: { module: any }
    }
  }
  browserslist?: string[]
  featureFlags?: FeatureFlags
  classNames?: ClassNames
  editor?: EditorState
  jit?: boolean
  jitContext?: any
  classList?: Array<[string, { color: culori.Color | KeywordColor | null }]>
  pluginVersions?: string
  // postcssPlugins?: { before: any[]; after: any[] }
}

export type DocumentClassList = {
  classList: string
  range: Range
  important?: boolean
}

export type DocumentClassName = {
  className: string
  range: Range
  relativeRange: Range
  classList: DocumentClassList
}

export type DocumentHelperFunction = {
  helper: 'theme' | 'config'
  path: string
  ranges: {
    full: Range
    path: Range
  }
}

export type ClassNameMeta = {
  source: 'base' | 'components' | 'utilities'
  pseudo: string[]
  scope: string[]
  context: string[]
}