// Type definitions for Grunt 0.4.x // Project: http://gruntjs.com // Definitions by: Jeff May , Basarat Ali Syed // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped /// /** * {@link https://github.com/marak/colors.js/} */ interface String { yellow: string; cyan: string; white: string; magenta: string; green: string; red: string; grey: string; blue: string; } declare namespace node { /** * {@link http://npmjs.org/doc/json.html} */ interface NodePackage { name: string; version: string; description?: string | undefined; keywords?: string[] | undefined; homepage?: string | undefined; } } /** * {@link https://github.com/isaacs/minimatch} */ declare namespace minimatch { /** * A minimal matching utility options. * * This is the matching library used internally by npm. * Eventually, it will replace the C binding in node-glob. * It works by converting glob expressions into JavaScript RegExp objects. */ interface IMinimatchOptions { /* All options are false by default. */ /** * Dump a ton of stuff to stderr. */ debug?: boolean | undefined; /** * Do not expand {a,b} and {1..3} brace sets. */ nobrace?: boolean | undefined; /** * Disable ** matching against multiple folder names. */ noglobstar?: boolean | undefined; /** * Allow patterns to match filenames starting with a period, * even if the pattern does not explicitly have a period in that spot. */ // Note that by default, a/**\/b will not match a/.d/b, unless dot is set. dot?: boolean | undefined; /** * Disable "extglob" style patterns like +(a|b). */ noext?: boolean | undefined; /** * Perform a case-insensitive match. */ nocase?: boolean | undefined; /** * When a match is not found by minimatch.match, return a list containing the pattern itself. * When set, an empty list is returned if there are no matches. */ nonull?: boolean | undefined; /** * If set, then patterns without slashes will be matched against the basename of the path if it contains slashes. * For example, a?b would match the path /xyz/123/acb, but not /xyz/acb/123. */ matchBase?: boolean | undefined; /** * Suppress the behavior of treating # at the start of a pattern as a comment. */ nocomment?: boolean | undefined; /** * Suppress the behavior of treating a leading ! character as negation. */ nonegate?: boolean | undefined; /** * Returns from negate expressions the same as if they were not negated. (Ie, true on a hit, false on a miss.) */ flipNegate?: boolean | undefined; } } /* GRUNT CONFIGURATION *********************/ declare namespace grunt { namespace config { /** * {@link http://gruntjs.com/sample-gruntfile} */ interface IProjectConfig{ [plugin: string]: any; } /** * {@link http://gruntjs.com/api/grunt.config} */ interface ConfigModule { /** * Get or set a value from the project's Grunt configuration. * This method serves as an alias to other methods; * if two arguments are passed, grunt.config.set is called, * otherwise grunt.config.get is called. */ (prop: string, value: any): any; (prop: string): any; /** * Initialize a configuration object for the current project. * The specified configObject is used by tasks and can be accessed using the grunt.config method. * Nearly every project's Gruntfile will call this method. */ init(config: IProjectConfig): void; /** * Get a value from the project's Grunt configuration. * If prop is specified, that property's value is returned, or null if that property is not defined. * If prop isn't specified, a copy of the entire config object is returned. * Templates strings will be recursively processed using the grunt.config.process method. * * @note Although this accepts a generic type, you may still get the wrong typed value. */ get(prop: string): T; get(): ConfigModule; /** * Process a value, recursively expanding <% %> templates (via the grunt.template.process method) * in the context of the Grunt config, as they are encountered. * this method is called automatically by grunt.config.get but not by grunt.config.getRaw. * * If any retrieved value is entirely a single '<%= foo %>' or '<%= foo.bar %>' template string, * and the specified foo or foo.bar property is a non-string (and not null or undefined) value, * it will be expanded to the actual value. That, combined with grunt's task system automatically * flattening arrays, can be extremely useful. */ process(value: string): T; /** * Get a raw value from the project's Grunt configuration, without processing <% %> template strings. * If prop is specified, that property's value is returned, or null if that property is not defined. * If prop isn't specified, a copy of the entire config object is returned. */ getRaw(prop: string): T; /** * Set a value into the project's Grunt configuration. * @note any specified <% %> template strings will only be processed when config data is retrieved. */ set(prop: string, value: T): T; /** * Escape '.' dots in the given propString. This should be used for property names that contain dots. */ escape(propString: string): string; /** * Fail the current task if one or more required config properties is missing, null or undefined. * One or more string or array config properties may be specified. */ requires(prop: string, ...andProps: string[]): void; requires(prop: string[], ...andProps: string[][]): void; /** * Recursively merges properties of the specified configObject into the current project configuration. * You can use this method to append configuration options, targets, etc., to already defined tasks. */ merge(configObject: T): void; } } namespace event { /** * {@link https://github.com/hij1nx/EventEmitter2} */ interface EventModule { /** * Adds a listener to the end of the listeners array for the specified event. */ addListener(event: string, listener: Function): EventModule; on(event: string, listener: Function): EventModule; /** * Adds a listener that will be fired when any event is emitted. */ onAny(listener: Function): EventModule; /** * Removes the listener that will be fired when any event is emitted. */ offAny(listener: Function): EventModule; /** * Adds a one time listener for the event. * The listener is invoked only the first time the event is fired, after which it is removed. */ once(event: string, listener: Function): EventModule; /** * Adds a listener that will execute n times for the event before being removed. * The listener is invoked only the first time the event is fired, after which it is removed. */ many(event: string, timesToListen: number, listener: Function): EventModule; /** * Remove a listener from the listener array for the specified event. * Caution: changes array indices in the listener array behind the listener. */ removeListener(event: string, listener: Function): EventModule; off(event: string, listener: Function): EventModule; /** * Removes all listeners, or those of the specified event. */ removeAllListeners(event: string): EventModule; /** * By default EventEmitters will print a warning if more than 10 listeners are added to it. * This is a useful default which helps finding memory leaks. Obviously not all Emitters * should be limited to 10. This function allows that to be increased. * * Set to zero for unlimited. */ setMaxListener(n: number): void; /** * Returns an array of listeners for the specified event. * This array can be manipulated, e.g. to remove listeners. */ listeners(event: string): Function[]; /** * Returns an array of listeners that are listening for any event that is specified. * This array can be manipulated, e.g. to remove listeners. */ listenersAny(): Function[]; /** * Execute each of the listeners that may be listening for the specified event name * in order with the list of arguments. */ emit(event: string, ...args: any[]): any; } } namespace fail { enum ErrorCode { NoError = 0, Fatal = 1, MissingGruntfile = 2, Task = 3, Template = 4, Autocomplete = 5, Warning = 6, } interface FailModule { /** * Display a warning and abort Grunt immediately. * Grunt will continue processing tasks if the --force command-line option was specified. */ warn(error: string, errorCode?: ErrorCode): void; warn(error: Error, errorCode?: ErrorCode): void; /** * Display a warning and abort Grunt immediately. */ fatal(error: string, errorCode?: ErrorCode): void; fatal(error: Error, errorCode?: ErrorCode): void; } } namespace file { /** * {@link http://gruntjs.com/api/grunt.file#grunt.file.defaultencoding} */ interface IFileEncodedOption { encoding: string; } /** * {@link http://gruntjs.com/api/grunt.file#grunt.file.copy} * * @see IFileWriteBufferOption * @see IFileWriteStringOption */ interface IFileWriteOptions extends grunt.file.IFileEncodedOption { /** * These optional globbing patterns will be matched against the filepath * (not the filename) using grunt.file.isMatch. If any specified globbing * pattern matches, the file won't be processed via the `process` function. * If `true` is specified, processing will be prevented. */ // noProcess?: string[] // noProcess?: boolean noProcess?: any; } /** * @see IFileWriteOptions */ interface IFileWriteBufferOption extends grunt.file.IFileWriteOptions { /** * The source file contents and file path are passed into this function, * whose return value will be used as the destination file's contents. If * this function returns `false`, the file copy will be aborted. */ process?: ((buffer: Buffer) => boolean) | undefined; } /** * @see IFileWriteOptions */ interface IFileWriteStringOption extends grunt.file.IFileWriteOptions { /** * The source file contents, source file path, and destination file path * are passed into this function, whose return value will be used as the * destination file's contents. * If this function returns 'false', the file copy will be aborted. * @example ```ts const copyOptions: grunt.file.IFileWriteStringOption = { encoding: options.encoding, process: (contents: string, srcpath: string, destpath: string): string | boolean => { // some other code // return the content to be written or return false to cancel return contents; }, noProcess: options.noProcess, }; ``` */ process?: ((contents: string, srcpath: string, destpath: string) => (string | boolean)) | undefined; } /** * {@link http://gruntjs.com/api/grunt.file} */ interface FileModule { /** * Set this property to change the default encoding used by all grunt.file methods. * Defaults to 'utf8'. * * If you do have to change this value, it's recommended that you change * it as early as possible inside your Gruntfile. */ defaultEncoding: string; /** * Read and return a file's contents. * Returns a string, unless options.encoding is null in which case it returns a Buffer. */ read(filepath: string): string; read(filepath: string, options: IFileEncodedOption): Buffer; /** * Read a file's contents, parsing the data as JSON and returning the result. * @see FileModule.read for a list of supported options. */ readJSON(filepath: string): any; readJSON(filepath: string, options: IFileEncodedOption): Buffer; /** * Read a file's contents, parsing the data as YAML and returning the result. * @see FileModule.read for a list of supported options. */ readYAML(filepath: string): any; readYAML(filepath: string, options: IFileEncodedOption): Buffer; /** * Write the specified contents to a file, creating intermediate directories if necessary. * Strings will be encoded using the specified character encoding, Buffers will be written to disk as-specified. * * @param contents If `contents` is a Buffer, encoding is ignored. * @param options If an encoding is not specified, default to grunt.file.defaultEncoding. */ write(filepath: string, contents: string, options?: IFileEncodedOption): void; write(filepath: string, contents: Buffer): void; /** * Copy a source file to a destination path, creating intermediate directories if necessary. */ copy(srcpath: string, destpath: string): void; copy(srcpath: string, destpath: string, options: IFileWriteStringOption): void; copy(srcpath: string, destpath: string, options: IFileWriteBufferOption): void; /** * Delete the specified filepath. Will delete files and folders recursively. * * @return true if the files could be deleted, otherwise false. */ delete(filepath: string, options?: { force?: boolean | undefined }): boolean; /** * Works like mkdir -p. Create a directory along with any intermediate directories. * If mode isn't specified, it defaults to 0777 & (~process.umask()). */ mkdir(dirpath: string, mode?: string): void; /** * Recurse into a directory, executing callback for each file. * * Callback args: * abspath - The full path to the current file, * which is nothing more than the rootdir + subdir + filename arguments, joined. * rootdir - The root director, as originally specified. * subdir - The current file's directory, relative to rootdir. * filename - The filename of the current file, without any directory parts. */ recurse( rootdir: string, callback: (abspath: string, rootdir: string, subdir: string, filename: string) => void ): void; /** * Return a unique array of all file or directory paths that match the given globbing pattern(s). * This method accepts either comma separated globbing patterns or an array of globbing patterns. * Paths matching patterns that begin with ! will be excluded from the returned array. * Patterns are processed in order, so inclusion and exclusion order is significant. * * File paths are relative to the Gruntfile unless the current working directory is changed with * grunt.file.setBase or the --base command-line option. */ expand(patterns: string | string[]): string[]; expand(options: IFilesConfig, patterns: string | string[]): string[]; /** * Returns an array of src-dest file mapping objects. * For each source file matched by a specified pattern, join that file path to the specified dest. * This file path may be flattened or renamed, depending on the options specified. * * @see FileModule.expand method documentation for an explanation of how the patterns * and options arguments may be specified. */ expandMapping(patterns: string[], dest: string, options: IExpandedFilesConfig): Array; /** * Match one or more globbing patterns against one or more file paths. * Returns a uniqued array of all file paths that match any of the specified globbing patterns. * Both the patterns and filepaths argument can be a single string or array of strings. * Paths matching patterns that begin with ! will be excluded from the returned array. * Patterns are processed in order, so inclusion and exclusion order is significant. */ match(pattern: string, filepath: string): string[]; match(pattern: string, filepaths: string[]): string[]; match(patterns: string[], filepath: string): string[]; match(patterns: string[], filepaths: string[]): string[]; match(options: minimatch.IMinimatchOptions, pattern: string, filepath: string): string[]; match(options: minimatch.IMinimatchOptions, pattern: string, filepaths: string[]): string[]; match(options: minimatch.IMinimatchOptions, patterns: string[], filepath: string): string[]; match(options: minimatch.IMinimatchOptions, patterns: string[], filepaths: string[]): string[]; /** * This method contains the same signature and logic as the grunt.file.match method, * but simply returns true if any files were matched, otherwise false. * * @see FileModule.match */ isMatch(pattern: string, filepath: string): boolean; isMatch(pattern: string, filepaths: string[]): boolean; isMatch(patterns: string[], filepath: string): boolean; isMatch(patterns: string[], filepaths: string[]): boolean; isMatch(options: minimatch.IMinimatchOptions, pattern: string, filepath: string): boolean; isMatch(options: minimatch.IMinimatchOptions, pattern: string, filepaths: string[]): boolean; isMatch(options: minimatch.IMinimatchOptions, patterns: string[], filepath: string): boolean; isMatch(options: minimatch.IMinimatchOptions, patterns: string[], filepaths: string[]): boolean; /* * Like the Node.js path.join method, the methods below will * join all arguments together and normalize the resulting path. */ /** * Does the given path exist? */ exists(path: string, ...append: string[]): boolean; /** * Is the given path a symbolic link? */ isLink(path: string, ...append: string[]): boolean; /** * Is the given path a symbolic link? */ isDir(path: string, ...append: string[]): boolean; /** * Is the given path a file? */ isFile(path: string, ...append: string[]): boolean; /** * Is a given file path absolute? */ isPathAbsolute(path: string, ...append: string[]): boolean; /** * Do all the specified paths refer to the same path? */ arePathsEquivalent(path: string, ...append: string[]): boolean; /** * Are all descendant path(s) contained within the specified ancestor path? */ doesPathContain(ancestorPath: string, decendantPaths: string[]): boolean; /** * Is a given file path the current working directory (CWD)? */ isPathCwd(path: string, ...append: string[]): boolean; /** * Change grunt's current working directory (CWD). * By default, all file paths are relative to the Gruntfile. * This works just like the --base command-line option. */ setBase(path: string, ...append: string[]): void; // External libraries // TODO: Create declarations glob: any; minimatch: any; findup: any; } /** * A convenience type. * * {@link http://gruntjs.com/configuring-tasks#files} */ interface IFilesArray extends Array {} /** * {@link http://gruntjs.com/configuring-tasks#files} */ interface IFilesConfig extends minimatch.IMinimatchOptions { /** * Pattern(s) to match, relative to the {@link IExpandedFilesConfig.cwd}. */ src?: string[] | undefined; /** * Destination path prefix. */ dest?: string | undefined; /** * Process a dynamic src-dest file mapping, * @see {@link http://gruntjs.com/configuring-tasks#building-the-files-object-dynamically for more information. */ expand?: boolean | undefined; // = false /** * Either a valid fs.Stats method name: * - isFile * - isDirectory * - isBlockDevice * - isCharacterDevice * - isSymbolicLink * - isFIFO * - isSocket * * or a function that is passed the matched src filepath and returns true or false. * * string * (src: string) => boolean */ // filter?: string // filter?: (src: string) => boolean filter?: any; /** * Patterns will be matched relative to this path, and all returned filepaths will * also be relative to this path. */ cwd?: string | undefined; } /** * These are valid for compact-format */ interface IExpandedFilesConfig extends IFilesConfig { /** * Enables the following options */ expand?: boolean | undefined; // = true /** * All {@link IExpandedFilesConfig.src} matches are relative to (but don't include) this path. */ cwd?: string | undefined; /** * Replace any existing extension with this value in generated {@link IExpandedFilesConfig.dest} paths. */ ext?: string | undefined; /** * Remove all path parts from generated {@link IExpandedFilesConfig.dest} paths. */ flatten?: boolean | undefined; /** * This function is called for each matched src file, (after extension renaming and flattening). * The {@link IExpandedFilesConfig.dest} and matched {@link IExpandedFilesConfig.src} path are passed in, * and this function must return a new dest value. * If the same dest is returned more than once, each src which used it will be added to an array of sources for it. */ rename?: Function | undefined; } /** * @see {@link http://gruntjs.com/configuring-tasks#files-array-format} */ interface IFileMap { /** * source filenames. */ src: string[]; /** * destination filename. */ dest: string; } } namespace log { /** * Grunt output should look consistent, and maybe even pretty. * As such, there is a plethora of logging methods, and a few useful patterns. * All of the methods that actually log something are chainable. */ interface CommonLogging { /** * Log the specified msg string, with no trailing newline. */ write(msg: string): T; /** * Log the specified msg string, with trailing newline. */ writeln(msg: string): T; /** * If msg string is omitted, logs ERROR in red, * otherwise logs >> msg, with trailing newline. */ error(msg: string): T; /** * Log an error with grunt.log.error, wrapping text to 80 columns using grunt.log.wraptext. */ errorlns(msg: string): T; /** * If msg string is omitted, logs OK in green, otherwise logs >> msg, with trailing newline. */ ok(msg: string): T; /** * Log an ok message with grunt.log.ok, wrapping text to 80 columns using grunt.log.wraptext. */ oklns(msg: string): T; /** * Log the specified msg string in bold, with trailing newline. */ subhead(msg: string): T; /** * Log a list of obj properties (good for debugging flags). */ writeflags(obj: any): T; /** * Log an warning with grunt.log.warn */ warn(msg: string): T; } /** * @note all methods available under grunt.verbose work exactly like grunt.log methods, * but only log if the --verbose command-line option was specified. */ interface VerboseLogModule extends CommonLogging { or: NotVerboseLogModule; } /** * @note all methods available under grunt.verbose work exactly like grunt.log methods, * but only log if the --verbose command-line option was not specified. */ interface NotVerboseLogModule extends CommonLogging { or: VerboseLogModule; } /** * {@link http://gruntjs.com/api/grunt.log} */ interface LogModule extends CommonLogging { verbose: VerboseLogModule; notverbose: NotVerboseLogModule; } } namespace option { /** * {@link http://gruntjs.com/api/grunt.option} */ interface OptionModule { /** * Gets or sets an option. * Boolean options can be negated by prepending no- onto the key. For example: * * grunt.option('staging', false); * var isDev = grunt.option('no-staging'); * assert(isDev === true) */ (key: string, value: T): void; (key: string): T; /** * Initialize grunt.option. * If initObject is omitted option will be initialized to an empty object * otherwise will be set to initObject. */ init(initObject?: any): void; /** * Returns the options as an array of command line parameters. */ flags: grunt.IFlag[]; } } namespace task { /** * {@link http://gruntjs.com/api/grunt.task} */ interface CommonTaskModule { /** * If a task list is specified, the new task will be an alias for one or more other tasks. * Whenever this "alias task" is run, every specified task in taskList will be run, in the order specified. * The taskList argument must be an array of tasks. */ registerTask(taskName: string, taskList: string[]): void; registerTask(taskName: string, description: string, taskList: string[]): void; /** * If a description and taskFunction are passed, the specified function will be executed * whenever the task is run. * * In addition, the specified description will be shown when grunt --help is run. * Task-specific properties and methods are available inside the task function as properties * of the this object. The task function can return false to indicate that the task has failed. * * @note taskFunction.apply(scope: grunt.task.ITask, args: any[]) */ registerTask(taskName: string, taskFunction: (this: ITask, ...args: any[]) => void): void; registerTask(taskName: string, description: string, taskFunction: (this: ITask, ...args: any[]) => void): void; /** * Register a "multi task." A multi task is a task that implicitly iterates over all of its * named sub-properties (AKA targets) if no target was specified. * In addition to the default properties and methods, extra multi task-specific properties * are available inside the task function as properties of the this object. * * @note taskFunction.apply(scope: grunt.task.IMultiTask, args: any[]) */ registerMultiTask(taskName: string, taskFunction: (this: IMultiTask, ...args: any[]) => void): void; registerMultiTask(taskName: string, taskDescription: string, taskFunction: (this: IMultiTask, ...args: any[]) => void): void; /** * Check with the name, if a task exists in the registered tasks. * @param name The task name to check. * @since 0.4.5 */ exists(name: string): boolean; /** * Rename a task. This might be useful if you want to override the default behavior of a task, while retaining the old name. * Note that if a task has been renamed, the this.name and this.nameArgs properties will change accordingly. * @see ITask * @param oldname The previous name of the task. * @param newname The new name for the task. */ renameTask(oldname: string, newname: string): void; } /** * {@link http://gruntjs.com/api/grunt.task#queueing-tasks} */ interface TaskModule extends CommonTaskModule { /** * Enqueue one or more tasks. * Every specified task in taskList will be run immediately after the current task completes, * in the order specified. The task list can be an array of tasks or individual task arguments. */ run(tasks: string[]): void; run(task: string, ...thenTasks: string[]): void; /** * Empty the task queue completely. Unless additional tasks are enqueued, no more tasks will be run. */ clearQueue(): void; /** * Normalizes a task target configuration object into an array of src-dest file mappings. * This method is used internally by the multi task system this.files / grunt.task.current.files property. */ normalizeMultiTaskFiles(data: grunt.config.IProjectConfig, targetname?: string): Array; /** * The currently running task or multitask. * @see http://gruntjs.com/api/inside-tasks */ current: grunt.task.IMultiTask; } interface AsyncResultCatcher { /** * Either false or an Error object may be passed to the done function * to instruct Grunt that the task has failed. */ (success: boolean): void; (error: Error): void; (result: any): void; (): void; } /** * @link http://gruntjs.com/inside-tasks * * Grunt version 0.4.x */ interface ITask { /** * If a task is asynchronous, this method must be invoked to instruct Grunt to wait. * It returns a handle to a "done" function that should be called when the task has completed. * * // Tell Grunt this task is asynchronous. * var done = this.async(); * // Your async code. * setTimeout(function() { * // Let's simulate an error, sometimes. * var success = Math.random() > 0.5; * // All done! * done(success); * }, 1000); */ async(): AsyncResultCatcher; /** * If one task depends on the successful completion of another task (or tasks), * this method can be used to force Grunt to abort if the other task didn't run, * or if the other task failed. * * @param tasks an array of task names or individual task names, as arguments. * @note that this won't actually run the specified task(s), * it will just fail the current task if they haven't already run successfully. */ requires(tasks: string[]): void requires(tasks: string, ...otherTasks: string[]): void requires(tasks: string[], ...otherTasks: string[][]): void /** * Fail the current task if one or more required config properties is missing. * One or more string or array config properties may be specified. * this.requiresConfig(prop [, prop [, ...]]) */ requiresConfig(prop: string, ...andProps: string[]): void; /** * The name of the task, as defined in grunt.registerTask. * For example, if a "sample" task was run as grunt sample or grunt sample:foo, * inside the task function, this.name would be "sample". */ name: string; /** * The name of the task, including any colon-separated arguments or flags specified on the command-line. * For example, if a "sample" task was run as grunt sample:foo, * inside the task function, this.nameArgs would be "sample:foo". */ nameArgs: string; /** * An array of arguments passed to the task. * For example, if a "sample" task was run as grunt sample:foo:bar, * inside the task function, this.args would be ["foo", "bar"]. */ args: string[]; /** * An object generated from the arguments passed to the task. * For example, if a "sample" task was run as grunt sample:foo:bar, * inside the task function, this.flags would be {foo: true, bar: true}. */ flags: grunt.IFlag[]; /** * The number of grunt.log.error calls that occurred during this task. * This can be used to fail a task if errors were logged during the task. */ errorCount: number; /** * Returns an options object. * Properties of the optional defaultsObj argument will be overridden by any task-level options * object properties, which will be further overridden in multi tasks by any target-level * options object properties. */ options(defaultsObj: T): T; options(defaultsObj: any): ITaskOptions; } /** * {@link http://gruntjs.com/inside-tasks#inside-multi-tasks} */ interface IMultiTask extends ITask { /** * In a multi task, this property contains the name of the target currently being iterated over. * For example, if a "sample" multi task was run as grunt sample:foo with the config data * {sample: {foo: "bar"}}, inside the task function, this.target would be "foo". */ target: string; /** * In a multi task, all files specified using any Grunt-supported file formats and options, * globbing patterns or dynamic mappings will automatically be normalized into a single format: * the Files Array file format. * * What this means is that tasks don't need to contain a ton of boilerplate for explicitly * handling custom file formats, globbing patterns, mapping source files to destination files * or filtering out files or directories. A task user can just specify files per the Configuring * tasks guide, and Grunt will handle all the details. * * Your task should iterate over the this.files array, utilizing the src and dest properties of * each object in that array. The this.files property will always be an array. * The src property will also always be an array, in case your task cares about multiple source * files per destination file. * * @note it's possible that nonexistent files might be included in src values, * so you may want to explicitly test that source files exist before using them. */ files: grunt.file.IFilesArray; /** * In a multi task, all src files files specified via any file format are reduced to a single array. * If your task is "read only" and doesn't care about destination filepaths, * use this array instead of this.files. */ filesSrc: string[]; /** * In a multi task, this is the actual data stored in the Grunt config object for the given target. * For example, if a "sample" multi task was run as grunt sample:foo with the config data * {sample: {foo: "bar"}}, inside the task function, this.data would be "bar". * * @note It is recommended that this.options this.files and this.filesSrc are used instead of this.data, * as their values are normalized. */ data: T; } /** * {@link http://gruntjs.com/configuring-tasks} * * A TaskConfig can be either be a full config or a compacted files config. * @see ITaskCompactOptions */ interface ITaskOptions { options?: any; // files?: grunt.file.IFilesArray // files?: grunt.file.IFilesMap files?: any; } /** * @see ITaskOptions */ interface ITaskCompactOptions extends grunt.task.ITaskOptions, grunt.file.IFilesConfig {} } namespace template { interface TemplateModule { /** * Process a Lo-Dash template string. * * The template argument will be processed recursively until there are no more templates to process. * * The default data object is the entire config object, but if options.data is set, that object will * be used instead. The default template delimiters are <% %> but if options.delimiters is set to a * custom delimiter name, those template delimiters will be used instead. * * Inside templates, the grunt object is exposed so that you can do things like: * <%= grunt.template.today('yyyy') %> * * @note if the data object already has a grunt property, the grunt API will not be accessible in templates. */ process(template: string): (options: any) => string; process(template: string, options: any): string; /** * Set the Lo-Dash template delimiters to a predefined set in case you grunt.util._.template * needs to be called manually. * * The config delimiters <% %> are included by default. */ setDelimiters(name: string): void; /** * Add a named set of Lo-Dash template delimiters. * * You probably won't need to use this method, because the built-in delimiters should be sufficient, * but you could always add {% %} or [% %] style delimiters. */ addDelimiters(name: string, opener: string, closer: string): void; /** * Format a date using the dateformat library. * {@link https://github.com/felixge/node-dateformat} * * @note if you don't include the mask argument, dateFormat.masks.default is used */ date(date?: Date, format?: string): string; date(date?: number, format?: string): string; date(date?: string, format?: string): string; /** * Format today's date using the dateformat library using the current date and time. * {@link https://github.com/felixge/node-dateformat} * * @note if you don't include the mask argument, dateFormat.masks.default is used */ today(format?: string): string; } } namespace util { /** * {@link http://gruntjs.com/api/grunt.util} */ interface UtilModule { /** * Return the "kind" of a value. Like typeof but returns the internal [Class](Class/) value. * Possible results are "number", "string", "boolean", "function", "regexp", "array", "date", * "error", "null", "undefined" and the catch-all "object". */ kindOf(value: any): string; /** * Return a new Error instance (that can be thrown) with the appropriate message. * If an Error object is specified instead of message that object will be returned. * Also, if an Error object is specified for origError and Grunt was run with the --debug 9 option, * the original Error stack will be dumped. */ error(message: string, origError?: Error): Error; error(error: Error, origError?: Error): Error; error(error: any, origError?: Error): Error; /** * The linefeed character, normalized for the current operating system. * (\r\n on Windows, \n otherwise) */ linefeed: string; /** * Given a string, return a new string with all the linefeeds normalized for the current operating system. * (\r\n on Windows, \n otherwise) */ normalizelf(str: string): string; /** * Recurse through nested objects and arrays, executing callbackFunction for each non-object value. * If continueFunction returns false, a given object or value will be skipped. */ recurse(object: any, callbackFunction: (value: any) => void, continueFunction: (objOrValue: any) => boolean): void; /** * Return string str repeated n times. */ repeat(n: number, str: string): string; /** * Given str of "a/b", If n is 1, return "a" otherwise "b". * You can specify a custom separator if '/' doesn't work for you. */ pluralize(n: number, str: string, separator?: string): string; /** * Spawn a child process, keeping track of its stdout, stderr and exit code. * The method returns a reference to the spawned child. * When the child exits, the done function is called. * * @param done a function with arguments: * error - If the exit code was non-zero and a fallback wasn't specified, * an Error object, otherwise null. * result - The result object is an * code - The numeric exit code. */ spawn(options: ISpawnOptions, done: (error: Error, result: ISpawnResult, code: number) => void): ISpawnedChild; /** * Given an array or array-like object, return an array. * Great for converting arguments objects into arrays. */ toArray(arrayLikeObject: any): T[]; /** * Normalizes both "returns a value" and "passes result to a callback" functions to always * pass a result to the specified callback. If the original function returns a value, * that value will now be passed to the callback, which is specified as the last argument, * after all other predefined arguments. If the original function passed a value to a callback, * it will continue to do so. */ callbackify(syncOrAsyncFunction: () => R): (callback: (result: R) => void) => void; callbackify(syncOrAsyncFunction: (a: A) => R): (a: A, callback: (result: R) => void) => void; callbackify(syncOrAsyncFunction: (a: A, b: B) => R): (a: A, b: B, callback: (result: R) => void) => void; callbackify(syncOrAsyncFunction: (a: A, b: B, c: C) => R): (a: A, b: B, c: C, callback: (result: R) => void) => void; callbackify(syncOrAsyncFunction: (a: A, b: B, c: C, d: D) => R): (a: A, b: B, c: C, d: D, callback: (result: R) => void) => void; // Internal libraries namespace: any task: any } /** * {@link http://gruntjs.com/api/grunt.util#grunt.util.spawn} */ interface ISpawnOptions { /** * The command to execute. It should be in the system path. */ cmd?: string | undefined; /** * If specified, the same grunt bin that is currently running will be * spawned as the child command, instead of the "cmd" option. * Defaults to false. */ grunt?: boolean | undefined; /** * An array of arguments to pass to the command. */ args?: string[] | undefined; /** * Additional options for the Node.js child_process spawn method. */ opts?: { cwd?: string | undefined; stdio?: any; custom?: any; env?: any; detached?: boolean | undefined; } | undefined /** * If this value is set and an error occurs, it will be used as the value * and null will be passed as the error value. */ fallback?: any; } /** * @note When result is coerced to a string, the value is stdout if the exit code * was zero, the fallback if the exit code was non-zero and a fallback was * specified, or stderr if the exit code was non-zero and a fallback was * not specified. */ interface ISpawnResult { stdout: string; stderr: string; code: number; } /** * {@link https://github.com/snbartell/node-spawn} */ interface ISpawnedChild { /** * Start the cmd with the options provided. */ start(): void; /** * Convenience function. Overrides options. restarts to 0. * Runs command exactly once no matter the options passed into the constructor. */ once(): void; /** * Convenience function. Overrides options.restarts to -1. * Runs command indefinitely no matter the options passed into the constructor. */ forever(): void; /** * Shut down the child and don't let it restart. */ kill(): void; } } /* * Common interfaces */ interface IFlag { [flag: string]: boolean; } /* * Grunt module mixins. */ interface IConfigComponents extends grunt.config.ConfigModule { /** * An alias * @see grunt.config.ConfigModule.init */ initConfig(config: grunt.config.IProjectConfig): void; } interface ITaskComponents extends grunt.task.CommonTaskModule { /** * Load task-related files from the specified directory, relative to the Gruntfile. * This method can be used to load task-related files from a local Grunt plugin by * specifying the path to that plugin's "tasks" subdirectory. */ loadTasks(tasksPath: string): void; /** * Load tasks from the specified Grunt plugin. * This plugin must be installed locally via npm, and must be relative to the Gruntfile. * Grunt plugins can be created by using the grunt-init gruntplugin template: grunt init:gruntplugin. */ loadNpmTasks(pluginName: string): void; } } /* GRUNT MODULE **************/ /** * The main Grunt module. * * {@link http://gruntjs.com/api/grunt} */ interface IGrunt extends grunt.IConfigComponents, grunt.fail.FailModule, grunt.ITaskComponents { config: grunt.config.ConfigModule; event: grunt.event.EventModule; fail: grunt.fail.FailModule; file: grunt.file.FileModule; log: grunt.log.LogModule; option: grunt.option.OptionModule; task: grunt.task.TaskModule; template: grunt.template.TemplateModule; util: grunt.util.UtilModule; /** * The current Grunt package.json metadata, as an object. */ package: node.NodePackage; /** * The current Grunt version, as a string. This is just a shortcut to the grunt.package.version property. */ version: string } // NodeJS Support declare module 'grunt' { var grunt: IGrunt; export = grunt; }