You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
72 lines
2.6 KiB
72 lines
2.6 KiB
// Type definitions for @babel/template 7.0
|
|
// Project: https://github.com/babel/babel/tree/master/packages/babel-template, https://babeljs.io
|
|
// Definitions by: Troy Gerwien <https://github.com/yortus>
|
|
// Marvin Hagemeister <https://github.com/marvinhagemeister>
|
|
// Melvin Groenhoff <https://github.com/mgroenhoff>
|
|
// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
|
|
// TypeScript Version: 2.9
|
|
|
|
import { ParserOptions } from "@babel/parser";
|
|
import { Expression, File, Program, Statement } from "@babel/types";
|
|
|
|
export interface TemplateBuilderOptions extends ParserOptions {
|
|
/**
|
|
* A set of placeholder names to automatically accept. Items in this list do not need to match the given placeholder pattern.
|
|
*/
|
|
placeholderWhitelist?: Set<string>;
|
|
|
|
/**
|
|
* A pattern to search for when looking for Identifier and StringLiteral nodes that should be considered placeholders. `false` will
|
|
* disable placeholder searching entirely, leaving only the `placeholderWhitelist` value to find placeholders.
|
|
*/
|
|
placeholderPattern?: RegExp | false;
|
|
|
|
/**
|
|
* Set this to `true` to preserve any comments from the `code` parameter.
|
|
*/
|
|
preserveComments?: boolean;
|
|
}
|
|
|
|
export interface TemplateBuilder<T> {
|
|
/**
|
|
* Build a new builder, merging the given options with the previous ones.
|
|
*/
|
|
(opts: TemplateBuilderOptions): TemplateBuilder<T>;
|
|
|
|
/**
|
|
* Building from a string produces an AST builder function by default.
|
|
*/
|
|
(code: string, opts?: TemplateBuilderOptions): (arg?: PublicReplacements) => T;
|
|
|
|
/**
|
|
* Building from a template literal produces an AST builder function by default.
|
|
*/
|
|
(tpl: TemplateStringsArray, ...args: any[]): (arg?: PublicReplacements) => T;
|
|
|
|
// Allow users to explicitly create templates that produce ASTs, skipping the need for an intermediate function.
|
|
ast: {
|
|
(tpl: string, opts?: TemplateBuilderOptions): T;
|
|
(tpl: TemplateStringsArray, ...args: any[]): T;
|
|
};
|
|
}
|
|
|
|
export type PublicReplacements = { [index: string]: any; } | any[];
|
|
|
|
export const smart: TemplateBuilder<Statement | Statement[]>;
|
|
export const statement: TemplateBuilder<Statement>;
|
|
export const statements: TemplateBuilder<Statement[]>;
|
|
export const expression: TemplateBuilder<Expression>;
|
|
export const program: TemplateBuilder<Program>;
|
|
|
|
type DefaultTemplateBuilder = typeof smart & {
|
|
smart: typeof smart;
|
|
statement: typeof statement;
|
|
statements: typeof statements;
|
|
expression: typeof expression;
|
|
program: typeof program;
|
|
ast: typeof smart.ast;
|
|
};
|
|
|
|
declare const templateBuilder: DefaultTemplateBuilder;
|
|
|
|
export default templateBuilder;
|
|
|