@culur/prettier-plugin-tailwindcss-group 1.1.0

package/dist/index.d.mts

@@ -0,0 +1,673 @@
+import { Plugin } from "prettier";
+//#region src/prettier.d.ts
+/**
+ * Ambient type augmentation for Prettier Options.
+ *
+ * NOTE: These type definitions correspond directly to the runtime options defined in:
+ * @see {@link ./options.ts}
+ */
+declare module 'prettier' {
+  interface Options {
+    classNameThreshold?: number;
+    modifierThreshold?: number;
+    tailwindFunctions?: string[];
+  }
+}
+//#endregion
+//#region src/options.d.ts
+/**
+ * Runtime Prettier plugin options configuration.
+ *
+ * NOTE: TypeScript type augmentation for Prettier's `Options` interface is declared in:
+ * @see {@link ./prettier.d.ts}
+ */
+declare const options: {
+  classNameThreshold: {
+    type: "int";
+    category: string;
+    default: number;
+    description: string;
+  };
+  modifierThreshold: {
+    type: "int";
+    category: string;
+    default: number;
+    description: string;
+  };
+  tailwindFunctions: {
+    type: "string";
+    array: true;
+    category: string;
+    default: {
+      value: string[];
+    }[];
+    description: string;
+  };
+};
+//#endregion
+//#region ../../node_modules/.pnpm/@types+estree@1.0.9/node_modules/@types/estree/index.d.ts
+// This definition file follows a somewhat unusual format. ESTree allows
+// runtime type checks based on the `type` parameter. In order to explain this
+// to typescript we want to use discriminated union types:
+// https://github.com/Microsoft/TypeScript/pull/9163
+//
+// For ESTree this is a bit tricky because the high level interfaces like
+// Node or Function are pulling double duty. We want to pass common fields down
+// to the interfaces that extend them (like Identifier or
+// ArrowFunctionExpression), but you can't extend a type union or enforce
+// common fields on them. So we've split the high level interfaces into two
+// types, a base type which passes down inherited fields, and a type union of
+// all types which extend the base type. Only the type union is exported, and
+// the union is how other types refer to the collection of inheriting types.
+//
+// This makes the definitions file here somewhat more difficult to maintain,
+// but it has the notable advantage of making ESTree much easier to use as
+// an end user.
+interface BaseNodeWithoutComments {
+  // Every leaf interface that extends BaseNode must specify a type property.
+  // The type property should be a string literal. For example, Identifier
+  // has: `type: "Identifier"`
+  type: string;
+  loc?: SourceLocation | null | undefined;
+  range?: [number, number] | undefined;
+}
+interface BaseNode extends BaseNodeWithoutComments {
+  leadingComments?: Comment[] | undefined;
+  trailingComments?: Comment[] | undefined;
+}
+interface NodeMap {
+  AssignmentProperty: AssignmentProperty;
+  CatchClause: CatchClause;
+  Class: Class;
+  ClassBody: ClassBody;
+  Expression: Expression;
+  Function: Function;
+  Identifier: Identifier;
+  Literal: Literal;
+  MethodDefinition: MethodDefinition;
+  ModuleDeclaration: ModuleDeclaration;
+  ModuleSpecifier: ModuleSpecifier;
+  Pattern: Pattern;
+  PrivateIdentifier: PrivateIdentifier;
+  Program: Program;
+  Property: Property;
+  PropertyDefinition: PropertyDefinition;
+  SpreadElement: SpreadElement;
+  Statement: Statement;
+  Super: Super;
+  SwitchCase: SwitchCase;
+  TemplateElement: TemplateElement;
+  VariableDeclarator: VariableDeclarator;
+}
+type Node = NodeMap[keyof NodeMap];
+interface Comment extends BaseNodeWithoutComments {
+  type: "Line" | "Block";
+  value: string;
+}
+interface SourceLocation {
+  source?: string | null | undefined;
+  start: Position;
+  end: Position;
+}
+interface Position {
+  /** >= 1 */
+  line: number;
+  /** >= 0 */
+  column: number;
+}
+interface Program extends BaseNode {
+  type: "Program";
+  sourceType: "script" | "module";
+  body: Array<Directive | Statement | ModuleDeclaration>;
+  comments?: Comment[] | undefined;
+}
+interface Directive extends BaseNode {
+  type: "ExpressionStatement";
+  expression: Literal;
+  directive: string;
+}
+interface BaseFunction extends BaseNode {
+  params: Pattern[];
+  generator?: boolean | undefined;
+  async?: boolean | undefined;
+  // The body is either BlockStatement or Expression because arrow functions
+  // can have a body that's either. FunctionDeclarations and
+  // FunctionExpressions have only BlockStatement bodies.
+  body: BlockStatement | Expression;
+}
+type Function = FunctionDeclaration | FunctionExpression | ArrowFunctionExpression;
+type Statement = ExpressionStatement | BlockStatement | StaticBlock | EmptyStatement | DebuggerStatement | WithStatement | ReturnStatement | LabeledStatement | BreakStatement | ContinueStatement | IfStatement | SwitchStatement | ThrowStatement | TryStatement | WhileStatement | DoWhileStatement | ForStatement | ForInStatement | ForOfStatement | Declaration;
+interface BaseStatement extends BaseNode {}
+interface EmptyStatement extends BaseStatement {
+  type: "EmptyStatement";
+}
+interface BlockStatement extends BaseStatement {
+  type: "BlockStatement";
+  body: Statement[];
+  innerComments?: Comment[] | undefined;
+}
+interface StaticBlock extends Omit<BlockStatement, "type"> {
+  type: "StaticBlock";
+}
+interface ExpressionStatement extends BaseStatement {
+  type: "ExpressionStatement";
+  expression: Expression;
+}
+interface IfStatement extends BaseStatement {
+  type: "IfStatement";
+  test: Expression;
+  consequent: Statement;
+  alternate?: Statement | null | undefined;
+}
+interface LabeledStatement extends BaseStatement {
+  type: "LabeledStatement";
+  label: Identifier;
+  body: Statement;
+}
+interface BreakStatement extends BaseStatement {
+  type: "BreakStatement";
+  label?: Identifier | null | undefined;
+}
+interface ContinueStatement extends BaseStatement {
+  type: "ContinueStatement";
+  label?: Identifier | null | undefined;
+}
+interface WithStatement extends BaseStatement {
+  type: "WithStatement";
+  object: Expression;
+  body: Statement;
+}
+interface SwitchStatement extends BaseStatement {
+  type: "SwitchStatement";
+  discriminant: Expression;
+  cases: SwitchCase[];
+}
+interface ReturnStatement extends BaseStatement {
+  type: "ReturnStatement";
+  argument?: Expression | null | undefined;
+}
+interface ThrowStatement extends BaseStatement {
+  type: "ThrowStatement";
+  argument: Expression;
+}
+interface TryStatement extends BaseStatement {
+  type: "TryStatement";
+  block: BlockStatement;
+  handler?: CatchClause | null | undefined;
+  finalizer?: BlockStatement | null | undefined;
+}
+interface WhileStatement extends BaseStatement {
+  type: "WhileStatement";
+  test: Expression;
+  body: Statement;
+}
+interface DoWhileStatement extends BaseStatement {
+  type: "DoWhileStatement";
+  body: Statement;
+  test: Expression;
+}
+interface ForStatement extends BaseStatement {
+  type: "ForStatement";
+  init?: VariableDeclaration | Expression | null | undefined;
+  test?: Expression | null | undefined;
+  update?: Expression | null | undefined;
+  body: Statement;
+}
+interface BaseForXStatement extends BaseStatement {
+  left: VariableDeclaration | Pattern;
+  right: Expression;
+  body: Statement;
+}
+interface ForInStatement extends BaseForXStatement {
+  type: "ForInStatement";
+}
+interface DebuggerStatement extends BaseStatement {
+  type: "DebuggerStatement";
+}
+type Declaration = FunctionDeclaration | VariableDeclaration | ClassDeclaration;
+interface BaseDeclaration extends BaseStatement {}
+interface MaybeNamedFunctionDeclaration extends BaseFunction, BaseDeclaration {
+  type: "FunctionDeclaration";
+  /** It is null when a function declaration is a part of the `export default function` statement */
+  id: Identifier | null;
+  body: BlockStatement;
+}
+interface FunctionDeclaration extends MaybeNamedFunctionDeclaration {
+  id: Identifier;
+}
+interface VariableDeclaration extends BaseDeclaration {
+  type: "VariableDeclaration";
+  declarations: VariableDeclarator[];
+  kind: "var" | "let" | "const" | "using" | "await using";
+}
+interface VariableDeclarator extends BaseNode {
+  type: "VariableDeclarator";
+  id: Pattern;
+  init?: Expression | null | undefined;
+}
+interface ExpressionMap {
+  ArrayExpression: ArrayExpression;
+  ArrowFunctionExpression: ArrowFunctionExpression;
+  AssignmentExpression: AssignmentExpression;
+  AwaitExpression: AwaitExpression;
+  BinaryExpression: BinaryExpression;
+  CallExpression: CallExpression;
+  ChainExpression: ChainExpression;
+  ClassExpression: ClassExpression;
+  ConditionalExpression: ConditionalExpression;
+  FunctionExpression: FunctionExpression;
+  Identifier: Identifier;
+  ImportExpression: ImportExpression;
+  Literal: Literal;
+  LogicalExpression: LogicalExpression;
+  MemberExpression: MemberExpression;
+  MetaProperty: MetaProperty;
+  NewExpression: NewExpression;
+  ObjectExpression: ObjectExpression;
+  SequenceExpression: SequenceExpression;
+  TaggedTemplateExpression: TaggedTemplateExpression;
+  TemplateLiteral: TemplateLiteral;
+  ThisExpression: ThisExpression;
+  UnaryExpression: UnaryExpression;
+  UpdateExpression: UpdateExpression;
+  YieldExpression: YieldExpression;
+}
+type Expression = ExpressionMap[keyof ExpressionMap];
+interface BaseExpression extends BaseNode {}
+type ChainElement = SimpleCallExpression | MemberExpression;
+interface ChainExpression extends BaseExpression {
+  type: "ChainExpression";
+  expression: ChainElement;
+}
+interface ThisExpression extends BaseExpression {
+  type: "ThisExpression";
+}
+interface ArrayExpression extends BaseExpression {
+  type: "ArrayExpression";
+  elements: Array<Expression | SpreadElement | null>;
+}
+interface ObjectExpression extends BaseExpression {
+  type: "ObjectExpression";
+  properties: Array<Property | SpreadElement>;
+}
+interface PrivateIdentifier extends BaseNode {
+  type: "PrivateIdentifier";
+  name: string;
+}
+interface Property extends BaseNode {
+  type: "Property";
+  key: Expression;
+  value: Expression | Pattern; // Could be an AssignmentProperty
+  kind: "init" | "get" | "set";
+  method: boolean;
+  shorthand: boolean;
+  computed: boolean;
+}
+interface PropertyDefinition extends BaseNode {
+  type: "PropertyDefinition";
+  key: Expression | PrivateIdentifier;
+  value?: Expression | null | undefined;
+  computed: boolean;
+  static: boolean;
+}
+interface FunctionExpression extends BaseFunction, BaseExpression {
+  id?: Identifier | null | undefined;
+  type: "FunctionExpression";
+  body: BlockStatement;
+}
+interface SequenceExpression extends BaseExpression {
+  type: "SequenceExpression";
+  expressions: Expression[];
+}
+interface UnaryExpression extends BaseExpression {
+  type: "UnaryExpression";
+  operator: UnaryOperator;
+  prefix: true;
+  argument: Expression;
+}
+interface BinaryExpression extends BaseExpression {
+  type: "BinaryExpression";
+  operator: BinaryOperator;
+  left: Expression | PrivateIdentifier;
+  right: Expression;
+}
+interface AssignmentExpression extends BaseExpression {
+  type: "AssignmentExpression";
+  operator: AssignmentOperator;
+  left: Pattern | MemberExpression;
+  right: Expression;
+}
+interface UpdateExpression extends BaseExpression {
+  type: "UpdateExpression";
+  operator: UpdateOperator;
+  argument: Expression;
+  prefix: boolean;
+}
+interface LogicalExpression extends BaseExpression {
+  type: "LogicalExpression";
+  operator: LogicalOperator;
+  left: Expression;
+  right: Expression;
+}
+interface ConditionalExpression extends BaseExpression {
+  type: "ConditionalExpression";
+  test: Expression;
+  alternate: Expression;
+  consequent: Expression;
+}
+interface BaseCallExpression extends BaseExpression {
+  callee: Expression | Super;
+  arguments: Array<Expression | SpreadElement>;
+}
+type CallExpression = SimpleCallExpression | NewExpression;
+interface SimpleCallExpression extends BaseCallExpression {
+  type: "CallExpression";
+  optional: boolean;
+}
+interface NewExpression extends BaseCallExpression {
+  type: "NewExpression";
+}
+interface MemberExpression extends BaseExpression, BasePattern {
+  type: "MemberExpression";
+  object: Expression | Super;
+  property: Expression | PrivateIdentifier;
+  computed: boolean;
+  optional: boolean;
+}
+type Pattern = Identifier | ObjectPattern | ArrayPattern | RestElement | AssignmentPattern | MemberExpression;
+interface BasePattern extends BaseNode {}
+interface SwitchCase extends BaseNode {
+  type: "SwitchCase";
+  test?: Expression | null | undefined;
+  consequent: Statement[];
+}
+interface CatchClause extends BaseNode {
+  type: "CatchClause";
+  param: Pattern | null;
+  body: BlockStatement;
+}
+interface Identifier extends BaseNode, BaseExpression, BasePattern {
+  type: "Identifier";
+  name: string;
+}
+type Literal = SimpleLiteral | RegExpLiteral | BigIntLiteral;
+interface SimpleLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value: string | boolean | number | null;
+  raw?: string | undefined;
+}
+interface RegExpLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: RegExp | null | undefined;
+  regex: {
+    pattern: string;
+    flags: string;
+  };
+  raw?: string | undefined;
+}
+interface BigIntLiteral extends BaseNode, BaseExpression {
+  type: "Literal";
+  value?: bigint | null | undefined;
+  bigint: string;
+  raw?: string | undefined;
+}
+type UnaryOperator = "-" | "+" | "!" | "~" | "typeof" | "void" | "delete";
+type BinaryOperator = "==" | "!=" | "===" | "!==" | "<" | "<=" | ">" | ">=" | "<<" | ">>" | ">>>" | "+" | "-" | "*" | "/" | "%" | "**" | "|" | "^" | "&" | "in" | "instanceof";
+type LogicalOperator = "||" | "&&" | "??";
+type AssignmentOperator = "=" | "+=" | "-=" | "*=" | "/=" | "%=" | "**=" | "<<=" | ">>=" | ">>>=" | "|=" | "^=" | "&=" | "||=" | "&&=" | "??=";
+type UpdateOperator = "++" | "--";
+interface ForOfStatement extends BaseForXStatement {
+  type: "ForOfStatement";
+  await: boolean;
+}
+interface Super extends BaseNode {
+  type: "Super";
+}
+interface SpreadElement extends BaseNode {
+  type: "SpreadElement";
+  argument: Expression;
+}
+interface ArrowFunctionExpression extends BaseExpression, BaseFunction {
+  type: "ArrowFunctionExpression";
+  expression: boolean;
+  body: BlockStatement | Expression;
+}
+interface YieldExpression extends BaseExpression {
+  type: "YieldExpression";
+  argument?: Expression | null | undefined;
+  delegate: boolean;
+}
+interface TemplateLiteral extends BaseExpression {
+  type: "TemplateLiteral";
+  quasis: TemplateElement[];
+  expressions: Expression[];
+}
+interface TaggedTemplateExpression extends BaseExpression {
+  type: "TaggedTemplateExpression";
+  tag: Expression;
+  quasi: TemplateLiteral;
+}
+interface TemplateElement extends BaseNode {
+  type: "TemplateElement";
+  tail: boolean;
+  value: {
+    /** It is null when the template literal is tagged and the text has an invalid escape (e.g. - tag`\unicode and \u{55}`) */
+    cooked?: string | null | undefined;
+    raw: string;
+  };
+}
+interface AssignmentProperty extends Property {
+  value: Pattern;
+  kind: "init";
+  method: boolean; // false
+}
+interface ObjectPattern extends BasePattern {
+  type: "ObjectPattern";
+  properties: Array<AssignmentProperty | RestElement>;
+}
+interface ArrayPattern extends BasePattern {
+  type: "ArrayPattern";
+  elements: Array<Pattern | null>;
+}
+interface RestElement extends BasePattern {
+  type: "RestElement";
+  argument: Pattern;
+}
+interface AssignmentPattern extends BasePattern {
+  type: "AssignmentPattern";
+  left: Pattern;
+  right: Expression;
+}
+type Class = ClassDeclaration | ClassExpression;
+interface BaseClass extends BaseNode {
+  superClass?: Expression | null | undefined;
+  body: ClassBody;
+}
+interface ClassBody extends BaseNode {
+  type: "ClassBody";
+  body: Array<MethodDefinition | PropertyDefinition | StaticBlock>;
+}
+interface MethodDefinition extends BaseNode {
+  type: "MethodDefinition";
+  key: Expression | PrivateIdentifier;
+  value: FunctionExpression;
+  kind: "constructor" | "method" | "get" | "set";
+  computed: boolean;
+  static: boolean;
+}
+interface MaybeNamedClassDeclaration extends BaseClass, BaseDeclaration {
+  type: "ClassDeclaration";
+  /** It is null when a class declaration is a part of the `export default class` statement */
+  id: Identifier | null;
+}
+interface ClassDeclaration extends MaybeNamedClassDeclaration {
+  id: Identifier;
+}
+interface ClassExpression extends BaseClass, BaseExpression {
+  type: "ClassExpression";
+  id?: Identifier | null | undefined;
+}
+interface MetaProperty extends BaseExpression {
+  type: "MetaProperty";
+  meta: Identifier;
+  property: Identifier;
+}
+type ModuleDeclaration = ImportDeclaration | ExportNamedDeclaration | ExportDefaultDeclaration | ExportAllDeclaration;
+interface BaseModuleDeclaration extends BaseNode {}
+type ModuleSpecifier = ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier | ExportSpecifier;
+interface BaseModuleSpecifier extends BaseNode {
+  local: Identifier;
+}
+interface ImportDeclaration extends BaseModuleDeclaration {
+  type: "ImportDeclaration";
+  specifiers: Array<ImportSpecifier | ImportDefaultSpecifier | ImportNamespaceSpecifier>;
+  attributes: ImportAttribute[];
+  source: Literal;
+}
+interface ImportSpecifier extends BaseModuleSpecifier {
+  type: "ImportSpecifier";
+  imported: Identifier | Literal;
+}
+interface ImportAttribute extends BaseNode {
+  type: "ImportAttribute";
+  key: Identifier | Literal;
+  value: Literal;
+}
+interface ImportExpression extends BaseExpression {
+  type: "ImportExpression";
+  source: Expression;
+  options?: Expression | null | undefined;
+}
+interface ImportDefaultSpecifier extends BaseModuleSpecifier {
+  type: "ImportDefaultSpecifier";
+}
+interface ImportNamespaceSpecifier extends BaseModuleSpecifier {
+  type: "ImportNamespaceSpecifier";
+}
+interface ExportNamedDeclaration extends BaseModuleDeclaration {
+  type: "ExportNamedDeclaration";
+  declaration?: Declaration | null | undefined;
+  specifiers: ExportSpecifier[];
+  attributes: ImportAttribute[];
+  source?: Literal | null | undefined;
+}
+interface ExportSpecifier extends Omit<BaseModuleSpecifier, "local"> {
+  type: "ExportSpecifier";
+  local: Identifier | Literal;
+  exported: Identifier | Literal;
+}
+interface ExportDefaultDeclaration extends BaseModuleDeclaration {
+  type: "ExportDefaultDeclaration";
+  declaration: MaybeNamedFunctionDeclaration | MaybeNamedClassDeclaration | Expression;
+}
+interface ExportAllDeclaration extends BaseModuleDeclaration {
+  type: "ExportAllDeclaration";
+  exported: Identifier | Literal | null;
+  attributes: ImportAttribute[];
+  source: Literal;
+}
+interface AwaitExpression extends BaseExpression {
+  type: "AwaitExpression";
+  argument: Expression;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/@types+estree-jsx@1.0.5/node_modules/@types/estree-jsx/index.d.ts
+declare module "estree" {
+  interface ExpressionMap {
+    JSXElement: JSXElement;
+    JSXFragment: JSXFragment;
+  }
+  interface NodeMap {
+    JSXIdentifier: JSXIdentifier;
+    JSXNamespacedName: JSXNamespacedName;
+    JSXMemberExpression: JSXMemberExpression;
+    JSXEmptyExpression: JSXEmptyExpression;
+    JSXExpressionContainer: JSXExpressionContainer;
+    JSXSpreadAttribute: JSXSpreadAttribute;
+    JSXAttribute: JSXAttribute;
+    JSXOpeningElement: JSXOpeningElement;
+    JSXOpeningFragment: JSXOpeningFragment;
+    JSXClosingElement: JSXClosingElement;
+    JSXClosingFragment: JSXClosingFragment;
+    JSXElement: JSXElement;
+    JSXFragment: JSXFragment;
+    JSXText: JSXText;
+  }
+}
+interface JSXIdentifier extends BaseNode {
+  type: "JSXIdentifier";
+  name: string;
+}
+interface JSXMemberExpression extends BaseExpression {
+  type: "JSXMemberExpression";
+  object: JSXMemberExpression | JSXIdentifier;
+  property: JSXIdentifier;
+}
+interface JSXNamespacedName extends BaseExpression {
+  type: "JSXNamespacedName";
+  namespace: JSXIdentifier;
+  name: JSXIdentifier;
+}
+interface JSXEmptyExpression extends BaseNode {
+  type: "JSXEmptyExpression";
+}
+interface JSXExpressionContainer extends BaseNode {
+  type: "JSXExpressionContainer";
+  expression: Expression | JSXEmptyExpression;
+}
+interface JSXSpreadChild extends BaseNode {
+  type: "JSXSpreadChild";
+  expression: Expression;
+}
+interface JSXBoundaryElement extends BaseNode {
+  name: JSXIdentifier | JSXMemberExpression | JSXNamespacedName;
+}
+interface JSXOpeningElement extends JSXBoundaryElement {
+  type: "JSXOpeningElement";
+  attributes: Array<JSXAttribute | JSXSpreadAttribute>;
+  selfClosing: boolean;
+}
+interface JSXClosingElement extends JSXBoundaryElement {
+  type: "JSXClosingElement";
+}
+interface JSXAttribute extends BaseNode {
+  type: "JSXAttribute";
+  name: JSXIdentifier | JSXNamespacedName;
+  value: Literal | JSXExpressionContainer | JSXElement | JSXFragment | null;
+}
+interface JSXSpreadAttribute extends BaseNode {
+  type: "JSXSpreadAttribute";
+  argument: Expression;
+}
+interface JSXText extends BaseNode {
+  type: "JSXText";
+  value: string;
+  raw: string;
+}
+interface JSXElement extends BaseExpression {
+  type: "JSXElement";
+  openingElement: JSXOpeningElement;
+  children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+  closingElement: JSXClosingElement | null;
+}
+interface JSXFragment extends BaseExpression {
+  type: "JSXFragment";
+  openingFragment: JSXOpeningFragment;
+  children: Array<JSXText | JSXExpressionContainer | JSXSpreadChild | JSXElement | JSXFragment>;
+  closingFragment: JSXClosingFragment;
+}
+interface JSXOpeningFragment extends BaseNode {
+  type: "JSXOpeningFragment";
+}
+interface JSXClosingFragment extends BaseNode {
+  type: "JSXClosingFragment";
+}
+//#endregion
+//#region src/printers.d.ts
+declare const printers: Plugin<Node>['printers'];
+//#endregion
+//#region src/index.d.ts
+declare const plugin: Plugin;
+//#endregion
+export { plugin as default, options, printers };
+//# sourceMappingURL=index.d.mts.map