// Type definitions for postcss-selector-parser 2.2.3
|
// Definitions by: Chris Eppstein <chris@eppsteins.net>
|
|
/*~ Note that ES6 modules cannot directly export callable functions.
|
*~ This file should be imported using the CommonJS-style:
|
*~ import x = require('someLibrary');
|
*~
|
*~ Refer to the documentation to understand common
|
*~ workarounds for this limitation of ES6 modules.
|
*/
|
|
/*~ This declaration specifies that the function
|
*~ is the exported object from the file
|
*/
|
export = parser;
|
|
declare function parser(): parser.Processor<never>;
|
declare function parser<Transform extends any>(processor: parser.AsyncProcessor<Transform>): parser.Processor<Transform, never>;
|
declare function parser(processor: parser.AsyncProcessor): parser.Processor<never>;
|
declare function parser<Transform extends any>(processor: parser.SyncProcessor<Transform>): parser.Processor<Transform, never>;
|
declare function parser(processor: parser.SyncProcessor): parser.Processor<never>;
|
declare function parser<Transform>(processor?: parser.SyncProcessor<Transform> | parser.AsyncProcessor<Transform>): parser.Processor<Transform>;
|
|
/*~ If you want to expose types from your module as well, you can
|
*~ place them in this block. Often you will want to describe the
|
*~ shape of the return type of the function; that type should
|
*~ be declared in here, as this example shows.
|
*/
|
declare namespace parser {
|
/* copied from postcss -- so we don't need to add a dependency */
|
type ErrorOptions = {
|
plugin?: string;
|
word?: string;
|
index?: number
|
};
|
/* the bits we use of postcss.Rule, copied from postcss -- so we don't need to add a dependency */
|
type PostCSSRuleNode = {
|
selector: string
|
/**
|
* @returns postcss.CssSyntaxError but it's a complex object, caller
|
* should cast to it if they have a dependency on postcss.
|
*/
|
error(message: string, options?: ErrorOptions): Error;
|
};
|
/** Accepts a string */
|
type Selectors = string | PostCSSRuleNode
|
type SyncProcessor<Transform = void> = (root: parser.Root) => Transform
|
type AsyncProcessor<Transform = void> = (root: parser.Root) => Transform | PromiseLike<Transform>
|
|
const TAG: "tag";
|
const STRING: "string";
|
const SELECTOR: "selector";
|
const ROOT: "root";
|
const PSEUDO: "pseudo";
|
const NESTING: "nesting";
|
const ID: "id";
|
const COMMENT: "comment";
|
const COMBINATOR: "combinator";
|
const CLASS: "class";
|
const ATTRIBUTE: "attribute";
|
const UNIVERSAL: "universal";
|
|
interface NodeTypes {
|
tag: Tag,
|
string: String,
|
selector: Selector,
|
root: Root,
|
pseudo: Pseudo,
|
nesting: Nesting,
|
id: Identifier,
|
comment: Comment,
|
combinator: Combinator,
|
class: ClassName,
|
attribute: Attribute,
|
universal: Universal
|
}
|
|
type Node = NodeTypes[keyof NodeTypes];
|
|
function isNode(node: any): node is Node;
|
|
interface Options {
|
/**
|
* Preserve whitespace when true. Default: false;
|
*/
|
lossless: boolean;
|
/**
|
* When true and a postcss.Rule is passed, set the result of
|
* processing back onto the rule when done. Default: false.
|
*/
|
updateSelector: boolean;
|
}
|
class Processor<
|
TransformType = never,
|
SyncSelectorsType extends Selectors | never = Selectors
|
> {
|
res: Root;
|
readonly result: String;
|
ast(selectors: Selectors, options?: Partial<Options>): Promise<Root>;
|
astSync(selectors: SyncSelectorsType, options?: Partial<Options>): Root;
|
transform(selectors: Selectors, options?: Partial<Options>): Promise<TransformType>;
|
transformSync(selectors: SyncSelectorsType, options?: Partial<Options>): TransformType;
|
process(selectors: Selectors, options?: Partial<Options>): Promise<string>;
|
processSync(selectors: SyncSelectorsType, options?: Partial<Options>): string;
|
}
|
interface ParserOptions {
|
css: string;
|
error: (message: string, options: ErrorOptions) => Error;
|
options: Options;
|
}
|
class Parser {
|
input: ParserOptions;
|
lossy: boolean;
|
position: number;
|
root: Root;
|
selectors: string;
|
current: Selector;
|
constructor(input: ParserOptions);
|
/**
|
* Raises an error, if the processor is invoked on
|
* a postcss Rule node, a better error message is raised.
|
*/
|
error(message: string, options?: ErrorOptions): void;
|
}
|
interface NodeSource {
|
start?: {
|
line: number,
|
column: number
|
},
|
end?: {
|
line: number,
|
column: number
|
}
|
}
|
interface SpaceAround {
|
before: string;
|
after: string;
|
}
|
interface Spaces extends SpaceAround {
|
[spaceType: string]: string | Partial<SpaceAround> | undefined;
|
}
|
interface NodeOptions<Value = string> {
|
value: Value;
|
spaces?: Partial<Spaces>;
|
source?: NodeSource;
|
sourceIndex?: number;
|
}
|
interface Base<
|
Value extends string | undefined = string,
|
ParentType extends Container | undefined = Container | undefined
|
> {
|
type: keyof NodeTypes;
|
parent: ParentType;
|
value: Value;
|
spaces: Spaces;
|
source?: NodeSource;
|
sourceIndex: number;
|
remove(): Node;
|
replaceWith(...nodes: Node[]): Node;
|
next(): Node;
|
prev(): Node;
|
clone(opts: {[override: string]:any}): Node;
|
toString(): string;
|
}
|
interface ContainerOptions extends NodeOptions {
|
nodes?: Array<Node>;
|
}
|
interface Container<Value extends string | undefined = string> extends Base<Value> {
|
nodes: Array<Node>;
|
append(selector: Selector): Container;
|
prepend(selector: Selector): Container;
|
at(index: number): Node;
|
index(child: Node): number;
|
readonly first: Node;
|
readonly last: Node;
|
readonly length: number;
|
removeChild(child: Node): Container;
|
removeAll(): Container;
|
empty(): Container;
|
insertAfter(oldNode: Node, newNode: Node): Container;
|
insertBefore(oldNode: Node, newNode: Node): Container;
|
each(callback: (node: Node) => boolean | void): boolean | undefined;
|
walk(callback: (node: Node) => boolean | void): boolean | undefined;
|
walkAttributes(callback: (node: Node) => boolean | void): boolean | undefined;
|
walkClasses(callback: (node: Node) => boolean | void): boolean | undefined;
|
walkCombinators(callback: (node: Node) => boolean | void): boolean | undefined;
|
walkComments(callback: (node: Node) => boolean | void): boolean | undefined;
|
walkIds(callback: (node: Node) => boolean | void): boolean | undefined;
|
walkNesting(callback: (node: Node) => boolean | void): boolean | undefined;
|
walkPseudos(callback: (node: Node) => boolean | void): boolean | undefined;
|
walkTags(callback: (node: Node) => boolean | void): boolean | undefined;
|
split(callback: (node: Node) => boolean): [Node[], Node[]];
|
map(callback: (node: Node) => Node): Node[];
|
reduce<T>(callback: (node: Node) => Node, memo: T): T;
|
every(callback: (node: Node) => boolean): boolean;
|
some(callback: (node: Node) => boolean): boolean;
|
filter(callback: (node: Node) => boolean): Node[];
|
sort(callback: (nodeA: Node, nodeB: Node) => number): Node[];
|
toString(): string;
|
}
|
function isContainer(node: any): node is Root | Selector | Pseudo;
|
|
interface NamespaceOptions<Value extends string | undefined = string> extends NodeOptions<Value> {
|
namespace?: string | true;
|
}
|
interface Namespace<Value extends string | undefined = string> extends Base<Value> {
|
/** alias for namespace */
|
ns: string | true;
|
/**
|
* namespace prefix.
|
*/
|
namespace: string | true;
|
/**
|
* If a namespace exists, prefix the value provided with it, separated by |.
|
*/
|
qualifiedName(value: string): string;
|
/**
|
* A string representing the namespace suitable for output.
|
*/
|
readonly namespaceString: string;
|
}
|
function isNamespace(node: any): node is ClassName | Attribute | Tag;
|
|
interface Root extends Container<undefined> {
|
type: "root";
|
/**
|
* Raises an error, if the processor is invoked on
|
* a postcss Rule node, a better error message is raised.
|
*/
|
error(message: string, options?: ErrorOptions): Error;
|
}
|
function root(opts: ContainerOptions): Root;
|
function isRoot(node: any): node is Root;
|
|
interface Selector extends Container {
|
type: "selector";
|
}
|
function selector(opts: ContainerOptions): Selector;
|
function isSelector(node: any): node is Selector;
|
|
interface Combinator extends Base {
|
type: "combinator"
|
}
|
function combinator(opts: NodeOptions): Combinator;
|
function isCombinator(node: any): node is Combinator;
|
|
interface ClassName extends Namespace {
|
type: "class";
|
}
|
function className(opts: NamespaceOptions): ClassName;
|
function isClassName(node: any): node is ClassName;
|
|
type AttributeOperator = "=" | "~=" | "|=" | "^=" | "$=" | "*=";
|
interface AttributeOptions extends NamespaceOptions<string | undefined> {
|
attribute: string;
|
operator?: AttributeOperator;
|
insensitive?: boolean;
|
quoted?: boolean;
|
spaces?: {
|
before?: string;
|
after?: string;
|
attribute?: Partial<SpaceAround>;
|
operator?: Partial<SpaceAround>;
|
value?: Partial<SpaceAround>;
|
insensitive?: Partial<SpaceAround>;
|
}
|
raws: {
|
unquoted?: string;
|
attribute?: string;
|
operator?: string;
|
value?: string;
|
insensitive?: string;
|
spaces?: {
|
attribute?: Partial<Spaces>;
|
operator?: Partial<Spaces>;
|
value?: Partial<Spaces>;
|
insensitive?: Partial<Spaces>;
|
}
|
};
|
}
|
interface Attribute extends Namespace<string | undefined> {
|
type: "attribute";
|
attribute: string;
|
operator?: AttributeOperator;
|
insensitive?: boolean;
|
quoted?: boolean;
|
spaces: {
|
before: string;
|
after: string;
|
attribute?: Partial<Spaces>;
|
operator?: Partial<Spaces>;
|
value?: Partial<Spaces>;
|
insensitive?: Partial<Spaces>;
|
}
|
raws: {
|
unquoted?: string;
|
attribute?: string;
|
operator?: string;
|
value?: string;
|
insensitive?: string;
|
spaces?: {
|
attribute?: Partial<Spaces>;
|
operator?: Partial<Spaces>;
|
value?: Partial<Spaces>;
|
insensitive?: Partial<Spaces>;
|
}
|
};
|
/**
|
* The attribute name after having been qualified with a namespace.
|
*/
|
readonly qualifiedAttribute: string;
|
/**
|
* returns the offset of the attribute part specified relative to the
|
* start of the node of the output string.
|
*
|
* * "ns" - alias for "namespace"
|
* * "namespace" - the namespace if it exists.
|
* * "attribute" - the attribute name
|
* * "attributeNS" - the start of the attribute or its namespace
|
* * "operator" - the match operator of the attribute
|
* * "value" - The value (string or identifier)
|
* * "insensitive" - the case insensitivity flag;
|
* @param part One of the possible values inside an attribute.
|
* @returns -1 if the name is invalid or the value doesn't exist in this attribute.
|
*/
|
offsetOf(part: "ns" | "namespace" | "attribute" | "attributeNS" | "operator" | "value" | "insensitive"): number;
|
}
|
function attribute(opts: AttributeOptions): Attribute;
|
function isAttribute(node: any): node is Attribute;
|
|
interface Pseudo extends Container {
|
type: "pseudo";
|
}
|
function pseudo(opts: ContainerOptions): Pseudo;
|
/**
|
* Checks wether the node is the Psuedo subtype of node.
|
*/
|
function isPseudo(node: any): node is Pseudo;
|
|
/**
|
* Checks wether the node is, specifically, a pseudo element instead of
|
* pseudo class.
|
*/
|
function isPseudoElement(node: any): node is Pseudo;
|
|
/**
|
* Checks wether the node is, specifically, a pseudo class instead of
|
* pseudo element.
|
*/
|
function isPseudoClass(node: any): node is Pseudo;
|
|
|
interface Tag extends Namespace {
|
type: "tag";
|
}
|
function tag(opts: NamespaceOptions): Tag;
|
function isTag(node: any): node is Tag;
|
|
interface Comment extends Base {
|
type: "comment";
|
}
|
function comment(opts: NodeOptions): Comment;
|
function isComment(node: any): node is Comment;
|
|
interface Identifier extends Base {
|
type: "id";
|
}
|
function id(opts: any): any;
|
function isIdentifier(node: any): node is Identifier;
|
|
interface Nesting extends Base {
|
type: "nesting";
|
}
|
function nesting(opts: any): any;
|
function isNesting(node: any): node is Nesting;
|
|
interface String extends Base {
|
type: "string";
|
}
|
function string(opts: NodeOptions): String;
|
function isString(node: any): node is String;
|
|
interface Universal extends Base {
|
type: "universal";
|
}
|
function universal(opts?: NamespaceOptions): any;
|
function isUniversal(node: any): node is Universal;
|
}
|
