From 96fce1045b77851763303abfaa37372d8aeff5c0 Mon Sep 17 00:00:00 2001 From: Philipp A Date: Tue, 9 May 2017 10:43:17 +0200 Subject: [PATCH] added typings for rollup --- types/rollup/index.d.ts | 154 +++++++++++++++++++++++++++++++++++ types/rollup/rollup-tests.ts | 23 ++++++ types/rollup/tsconfig.json | 19 +++++ types/rollup/tslint.json | 6 ++ 4 files changed, 202 insertions(+) create mode 100644 types/rollup/index.d.ts create mode 100644 types/rollup/rollup-tests.ts create mode 100644 types/rollup/tsconfig.json create mode 100644 types/rollup/tslint.json diff --git a/types/rollup/index.d.ts b/types/rollup/index.d.ts new file mode 100644 index 0000000000..35cd523e2c --- /dev/null +++ b/types/rollup/index.d.ts @@ -0,0 +1,154 @@ +// Type definitions for rollup 0.41 +// Project: https://github.com/rollup/rollup +// Definitions by: Philipp A. +// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped + +import { RawSourceMap } from 'source-map' +import * as acorn from 'acorn' + +export type Format = 'amd' | 'cjs' | 'es' | 'iife' | 'umd' + +export interface SourceMap extends RawSourceMap { + toString(): string + toUrl(): string +} + +// https://github.com/rollup/rollup/wiki/JavaScript-API +export interface Warning { + code: string + message: string + loc?: { file: string, line: number, column: number } + frame?: string +} + +export interface BundleOptions { + /** The format of the generated bundle. */ + format?: Format + /** What export mode to use. Defaults to auto, which guesses your intentions based on what the `entry` module exports. */ + exports?: 'auto' | 'default' | 'named' | 'none' + /** An ID to use for AMD/UMD bundles. */ + moduleId?: string + /** The name to use for the module for UMD/IIFE bundles (required for bundles with exports). */ + moduleName?: string + /** Mapping of IDs → global variable names. Used for UMD/IIFE bundles. */ + globals?: { [id: string]: string } + /** + * The indent string to use, for formats that require code to be indented (AMD, IIFE, UMD). + * Can also be false (no indent), or true (the default – auto-indent) + */ + indent?: string | boolean + /** + * Whether or not to add an 'interop block'. By default (interop: true). + * For safety's sake, Rollup will assign any external dependencies' default exports to a separate variable if it's necessary to distinguish between default and named exports. + * This generally only applies if your external dependencies were transpiled (for example with Babel) – if you're sure you don't need it, you can save a few bytes with interop: false. + */ + interop?: boolean + /** A string to prepend to the bundle. */ + banner?: string + /** A string to append to the bundle. */ + footer?: string + /** A string prepended to the code inside of the format-specific wrapper */ + intro?: string + /** A string appended to the code inside of the format-specific wrapper */ + outro?: string + /** + * Whether to include the 'use strict' pragma at the top of generated non-ES6 bundles. + * Strictly-speaking (geddit?), ES6 modules are always in strict mode, so you shouldn't disable this without good reason. + */ + useStrict?: boolean +} + +export interface GenerateOptions extends BundleOptions { + /** Whether to generate a sourcemap. If true, the return value from `bundle.generate(...)` will include a map property */ + sourceMap?: boolean + /** + * The location of the generated bundle. If this is an absolute path, all the sources paths in the sourcemap will be relative to it. + * The map.file property is the basename of sourceMapFile, as the location of the sourcemap is assumed to be adjacent to the bundle. + */ + sourceMapFile?: string +} + +export interface WriteOptions extends BundleOptions { + /** The file to write to. If `options.sourceMap === true`, two files will be created – `dest` and `dest + '.map`. */ + dest: string + /** If `true`, a separate sourcemap file will be created. If `'inline'`, the sourcemap will be appended to the resulting dest file as a data URI. */ + sourceMap?: boolean | 'inline' + /** This option is unnecessary, as it defaults to the value of dest. */ + sourceMapFile?: string +} + +export interface Bundle { + /** Generate bundled code as an object */ + generate(options: GenerateOptions): { code: string, map: SourceMap } + /** writes the file (and accompanying sourcemap file, if appropriate) to the file system. */ + write(options: WriteOptions): Promise +} + +export interface Options { + /** The bundle's entry point (e.g. your `main.js` or `app.js` or `index.js`) */ + entry: string + /** A previous bundle. Use it to speed up subsequent bundles :) */ + cache?: Bundle + /** + * Function that returns if an ID is external or array of IDs of modules that should remain external to the bundle. + * The IDs should be either the name of an external dependency or a resolved ID (like an absolute path to a file) + */ + external?: ((id: string) => boolean) | string[] + /** + * Function that takes an ID and returns a path, or Object of id: path pairs. + * Where supplied, these paths will be used in the generated bundle instead of the module ID, allowing you to (for example) load dependencies from a CDN. + */ + paths?: ((id: string) => string) | { [id: string]: string } + /** Function that will intercept warning messages. If not supplied, warnings will be deduplicated and printed to the console. */ + onwarn?(warning: Warning): void + /** Array of plugin objects or a single plugin object */ + plugins?: Plugin | Plugin[] + /** + * Whether or not to apply tree-shaking. (Default: true) + * It's recommended that you omit this option, unless you discover a bug caused by the tree-shaking algorithm in which case use treeshake: false once you've filed an issue! + */ + treeshake?: boolean + /** Any options that should be passed through to Acorn. */ + acorn?: acorn.Options + /** By default, the context of a module – i.e., the value of `this` at the top level – is `undefined`. In rare cases you might need to change this to something else, like `'window'`. */ + context?: any + /** Same as `options.context`, but per-module. */ + moduleContext?: ((id: string) => any) | { [id: string]: any } + /** Adds support for very old environments like IE8, at the cost of some extra code. */ + legacy?: boolean +} + +// https://github.com/rollup/rollup/wiki/Plugins#creating-plugins +export interface Plugin { + /** The name of the plugin, for use in error messages and warnings */ + name?: string + /** A function that replaces or manipulates the options object passed to rollup.rollup */ + options?(options: Options): Options + /** A custom loader. Returning null or undefined defers to other load functions (and eventually the default behavior of loading from the file system). */ + load?(id: string): string | null | undefined + /** + * Custom resolver (useful for e.g. locating third-party dependencies). + * Returning null or undefined defers to other resolveId functions (and eventually the default resolution behavior); + * returning any other falsy value signals that importee should be treated as an external module and not included in the bundle. + */ + resolveId?(importee: string, importer: string): string | null | undefined | false | 0 | '' + /** A module transformer function */ + transform?(source: string, id: string): string | { code: string, map: SourceMap } + /** A bundle transformer function */ + transformBundle?(source: string, options: { format: Format }): string | { code: string, map: SourceMap } + /** Function hook called when bundle.generate() is being executed. */ + ongenerate?(options: GenerateOptions, bundle: Bundle): void + /** Function hook called when bundle.write() is being executed, after the file has been written to disk. */ + onwrite?(options: WriteOptions, bundle: Bundle): void + /** A function for generating intro text */ + intro?(): string + /** A function for generating outro text */ + outro?(): string + /** Prepend to the bundle. */ + banner?: string | (() => string) + /** Apppend to the bundle. */ + footer?: string | (() => string) +} + +/** Returns a Promise that resolves with a bundle */ +export function rollup(options: Options): Promise diff --git a/types/rollup/rollup-tests.ts b/types/rollup/rollup-tests.ts new file mode 100644 index 0000000000..b600fe25ee --- /dev/null +++ b/types/rollup/rollup-tests.ts @@ -0,0 +1,23 @@ +import { rollup, Bundle } from 'rollup' + +let cache: Bundle | undefined + +async function main() { + const bundle = await rollup({ + entry: 'main.js', + cache, + }) + + const result = bundle.generate({ + format: 'cjs', + }) + + cache = bundle + + await bundle.write({ + format: 'cjs', + dest: 'bundle.js', + }) +} + +main() diff --git a/types/rollup/tsconfig.json b/types/rollup/tsconfig.json new file mode 100644 index 0000000000..7c7b4dd5c5 --- /dev/null +++ b/types/rollup/tsconfig.json @@ -0,0 +1,19 @@ +{ + "compilerOptions": { + "module": "commonjs", + "target": "es6", + "lib": ["es6"], + "noImplicitAny": true, + "noImplicitThis": true, + "strictNullChecks": true, + "baseUrl": "../", + "typeRoots": ["../"], + "types": [], + "noEmit": true, + "forceConsistentCasingInFileNames": true + }, + "files": [ + "index.d.ts", + "rollup-tests.ts" + ] +} diff --git a/types/rollup/tslint.json b/types/rollup/tslint.json new file mode 100644 index 0000000000..ba7f6bc7ae --- /dev/null +++ b/types/rollup/tslint.json @@ -0,0 +1,6 @@ +{ + "extends": "dtslint/dt.json", + "rules": { + "semicolon": [true, "never"] + } +}