From 1441012075a2870ea2e346fd2bc5641e3cc1941d Mon Sep 17 00:00:00 2001 From: Mickael Jeanroy Date: Tue, 15 Jan 2019 00:23:10 +0100 Subject: [PATCH] release: release version --- dist/dependency.js | 153 ++++++++++++++ dist/eol.js | 26 +++ dist/generate-block-comment.js | 39 ++++ dist/index-rollup-legacy.js | 101 +++++++++ dist/index-rollup-stable.js | 74 +++++++ dist/index.js | 31 +++ dist/license-plugin.js | 364 +++++++++++++++++++++++++++++++++ dist/person.js | 115 +++++++++++ package.json | 2 +- 9 files changed, 904 insertions(+), 1 deletion(-) create mode 100644 dist/dependency.js create mode 100644 dist/eol.js create mode 100644 dist/generate-block-comment.js create mode 100644 dist/index-rollup-legacy.js create mode 100644 dist/index-rollup-stable.js create mode 100644 dist/index.js create mode 100644 dist/license-plugin.js create mode 100644 dist/person.js diff --git a/dist/dependency.js b/dist/dependency.js new file mode 100644 index 00000000..42c5a62c --- /dev/null +++ b/dist/dependency.js @@ -0,0 +1,153 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2016-2018 Mickael Jeanroy + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +'use strict'; + +function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); } + +function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); } + +function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); } + +function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } } + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var _ = require('lodash'); + +var EOL = require('./eol.js'); + +var Person = require('./person.js'); +/** + * Dependency structure. + */ + + +var Dependency = +/*#__PURE__*/ +function () { + /** + * Create new dependency from package description. + * + * @param {Object} pkg Package description. + * @constructor + */ + function Dependency(pkg) { + _classCallCheck(this, Dependency); + + var dependency = _.pick(pkg, ['name', 'author', 'contributors', 'maintainers', 'version', 'description', 'license', 'licenses', 'repository', 'homepage', 'private']); // Parse the author field to get an object. + + + if (dependency.author) { + dependency.author = new Person(dependency.author); + } // Parse the contributor array. + + + if (dependency.contributors) { + // Translate to an array if it is not already. + if (_.isString(dependency.contributors)) { + dependency.contributors = [dependency.contributors]; + } // Parse each contributor to produce a single object for each person. + + + dependency.contributors = _.map(dependency.contributors, function (contributor) { + return new Person(contributor); + }); + } // The `licenses` field is deprecated but may be used in some packages. + // Map it to a standard license field. + + + if (!dependency.license && dependency.licenses) { + // Map it to a valid license field. + // See: https://docs.npmjs.com/files/package.json#license + dependency.license = "(".concat(_.chain(dependency.licenses).map(function (license) { + return license.type || license; + }).join(' OR ').value(), ")"); // Remove it. + + delete dependency.licenses; + } + + _.extend(this, dependency); + } + /** + * Serialize dependency as a string. + * + * @param {string} prefix Optional prefix prepended to the output string. + * @param {suffix} suffix Optional suffix appended to the output string. + * @param {string} joiner Optional character used to join all the lines. + * @return {string} The dependency correctly formatted. + */ + + + _createClass(Dependency, [{ + key: "text", + value: function text() { + var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + var suffix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + var joiner = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : EOL; + var lines = []; + lines.push("".concat(prefix, "Name: ").concat(this.name).concat(suffix)); + lines.push("".concat(prefix, "Version: ").concat(this.version).concat(suffix)); + lines.push("".concat(prefix, "License: ").concat(this.license).concat(suffix)); + lines.push("".concat(prefix, "Private: ").concat(this.private || false).concat(suffix)); + + if (this.description) { + lines.push("".concat(prefix, "Description: ").concat(this.description || false).concat(suffix)); + } + + if (this.repository) { + lines.push("".concat(prefix, "Repository: ").concat(this.repository.url).concat(suffix)); + } + + if (this.homepage) { + lines.push("".concat(prefix, "Homepage: ").concat(this.homepage).concat(suffix)); + } + + if (this.author) { + lines.push("".concat(prefix, "Author: ").concat(this.author.text()).concat(suffix)); + } + + if (this.contributors) { + lines.push("".concat(prefix, "Contributors:").concat(suffix)); + + var allContributors = _.chain(this.contributors).map(function (contributor) { + return contributor.text(); + }).map(function (line) { + return "".concat(prefix, " ").concat(line).concat(suffix); + }).value(); + + lines.push.apply(lines, _toConsumableArray(allContributors)); + } + + return lines.join(joiner); + } + }]); + + return Dependency; +}(); + +module.exports = Dependency; \ No newline at end of file diff --git a/dist/eol.js b/dist/eol.js new file mode 100644 index 00000000..5d9f849a --- /dev/null +++ b/dist/eol.js @@ -0,0 +1,26 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2016-2018 Mickael Jeanroy + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +'use strict'; + +module.exports = '\n'; \ No newline at end of file diff --git a/dist/generate-block-comment.js b/dist/generate-block-comment.js new file mode 100644 index 00000000..a8520229 --- /dev/null +++ b/dist/generate-block-comment.js @@ -0,0 +1,39 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2016-2018 Mickael Jeanroy + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +'use strict'; + +var commenting = require('commenting'); +/** + * Generate block comment from given text content. + * + * @param {string} text Text content. + * @return {string} Block comment. + */ + + +module.exports = function generateBlockComment(text) { + return commenting(text.trim(), { + extension: '.js' + }); +}; \ No newline at end of file diff --git a/dist/index-rollup-legacy.js b/dist/index-rollup-legacy.js new file mode 100644 index 00000000..d24d9824 --- /dev/null +++ b/dist/index-rollup-legacy.js @@ -0,0 +1,101 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2016-2018 Mickael Jeanroy + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +'use strict'; + +var _ = require('lodash'); + +var LicensePlugin = require('./license-plugin.js'); + +module.exports = function () { + var _options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + var plugin = new LicensePlugin(_options); + return { + /** + * Name of the plugin, used automatically by rollup. + * @type {string} + */ + name: plugin.name, + + /** + * Function called by rollup when a JS file is loaded: it is used to scan + * third-party dependencies. + * + * @param {string} id JS file path. + * @return {void} + */ + load: function load(id) { + plugin.scanDependency(id); + }, + + /** + * Function called by rollup to read global options: if source map parameter + * is truthy, enable it on the plugin. + * + * @param {object} opts Rollup options. + * @return {void} + */ + options: function options(opts) { + if (!opts) { + return; + } + + if (_.has(_options, 'sourceMap') || _.has(_options, 'sourcemap')) { + // SourceMap has been set on the plugin itself. + return; + } // Rollup >= 0.48 replace `sourceMap` with `sourcemap`. + // If `sourcemap` is disabled globally, disable it on the plugin. + + + if (opts.sourceMap === false || opts.sourcemap === false) { + plugin.disableSourceMap(); + } + }, + + /** + * Function called by rollup when the final bundle is generated: it is used + * to prepend the banner file on the generated bundle. + * + * @param {string} code Bundle content. + * @param {Object} outputOptions The options for this output. + * @return {void} + */ + transformBundle: function transformBundle(code) { + var outputOptions = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}; + var sourcemap = outputOptions.sourcemap !== false || outputOptions.sourceMap !== false; + return plugin.prependBanner(code, sourcemap); + }, + + /** + * Function called by rollup when the final bundle will be written on disk: it + * is used to generate a file containing a summary of all third-party dependencies + * with license information. + * + * @return {void} + */ + ongenerate: function ongenerate() { + plugin.exportThirdParties(); + } + }; +}; \ No newline at end of file diff --git a/dist/index-rollup-stable.js b/dist/index-rollup-stable.js new file mode 100644 index 00000000..985025ef --- /dev/null +++ b/dist/index-rollup-stable.js @@ -0,0 +1,74 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2016-2018 Mickael Jeanroy + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +'use strict'; + +var LicensePlugin = require('./license-plugin.js'); + +module.exports = function () { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + var plugin = new LicensePlugin(options); + return { + /** + * Name of the plugin, used automatically by rollup. + * @type {string} + */ + name: plugin.name, + + /** + * Function called by rollup when a JS file is loaded: it is used to scan + * third-party dependencies. + * + * @param {string} id JS file path. + * @return {void} + */ + load: function load(id) { + plugin.scanDependency(id); + }, + + /** + * Function called by rollup when the final bundle is generated: it is used + * to prepend the banner file on the generated bundle. + * + * @param {string} code Bundle content. + * @param {Object} chunk The chunk being generated. + * @param {Object} outputOptions The options for the generated output. + * @return {void} + */ + renderChunk: function renderChunk(code, chunk) { + var outputOptions = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {}; + return plugin.prependBanner(code, outputOptions.sourcemap !== false); + }, + + /** + * Function called by rollup when the final bundle will be written on disk: it + * is used to generate a file containing a summary of all third-party dependencies + * with license information. + * + * @return {void} + */ + generateBundle: function generateBundle() { + plugin.exportThirdParties(); + } + }; +}; \ No newline at end of file diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 00000000..34ab5f99 --- /dev/null +++ b/dist/index.js @@ -0,0 +1,31 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2016-2018 Mickael Jeanroy + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +'use strict'; + +var rollup = require('rollup'); + +var VERSION = rollup.VERSION; +var MAJOR_VERSION = VERSION ? Number(VERSION.split('.')[0]) : 0; +var IS_ROLLUP_LEGACY = MAJOR_VERSION === 0; +module.exports = IS_ROLLUP_LEGACY ? require('./index-rollup-legacy') : require('./index-rollup-stable'); \ No newline at end of file diff --git a/dist/license-plugin.js b/dist/license-plugin.js new file mode 100644 index 00000000..41aac9c7 --- /dev/null +++ b/dist/license-plugin.js @@ -0,0 +1,364 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2016-2018 Mickael Jeanroy + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var fs = require('fs'); + +var path = require('path'); + +var mkdirp = require('mkdirp'); + +var _ = require('lodash'); + +var moment = require('moment'); + +var MagicString = require('magic-string'); + +var Dependency = require('./dependency.js'); + +var generateBlockComment = require('./generate-block-comment.js'); + +var EOL = require('./eol.js'); +/** + * The list of avaiilable options. + * @type {Array} + */ + + +var OPTIONS = ['cwd', 'debug', 'sourcemap', 'banner', 'thirdParty']; +/** + * The plugin name. + * @type {string} + */ + +var PLUGIN_NAME = 'rollup-plugin-license'; +/** + * Fix option object, replace `sourceMap` with `sourcemap` if needed. + * + * @param {Object} options Original option object. + * @return {Object} The new fixed option object. + */ + +function fixSourceMapOptions(options) { + // Rollup <= 0.48 used `sourceMap` in camelcase, so this plugin used + // this convention at the beginning. + // Now, the `sourcemap` key should be used, but legacy version should still + // be able to use the `sourceMap` key. + var newOptions = _.omitBy(options, function (value, key) { + return key === 'sourceMap'; + }); // If the old `sourceMap` key is used, set it to `sourcemap` key. + + + if (!_.hasIn(newOptions, 'sourcemap') && _.hasIn(options, 'sourceMap')) { + console.warn("[".concat(PLUGIN_NAME, "] sourceMap has been deprecated, please use sourcemap instead.")); + newOptions.sourcemap = options.sourceMap; + } + + return newOptions; +} +/** + * Rollup Plugin. + */ + + +var LicensePlugin = +/*#__PURE__*/ +function () { + /** + * Initialize plugin. + * + * @param {Object} options Plugin options. + */ + function LicensePlugin() { + var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}; + + _classCallCheck(this, LicensePlugin); + + // Plugin name, used by rollup. + this.name = PLUGIN_NAME; // Initialize main options. + + this._options = fixSourceMapOptions(options); + + this._validateOptions(); + + this._cwd = this._options.cwd || process.cwd(); + this._dependencies = {}; + this._pkg = require(path.join(this._cwd, 'package.json')); + this._debug = this._options.debug || false; // SourceMap can now be disable/enable on the plugin. + + this._sourcemap = this._options.sourcemap !== false; // This is a cache storing a directory path to associated package. + // This is an improvement to avoid looking for package information for + // already scanned directory. + + this._cache = {}; + } + /** + * Validate option object before being used, and print for warnings if + * needed. + * + * @return {void} + */ + + + _createClass(LicensePlugin, [{ + key: "_validateOptions", + value: function _validateOptions() { + var keys = _.keys(this._options); + + var notSupported = _.filter(keys, function (key) { + return _.indexOf(OPTIONS, key) < 0; + }); + + if (notSupported.length > 0) { + console.warn("[".concat(PLUGIN_NAME, "] Options ").concat(notSupported, " are not supported, use following options: ").concat(OPTIONS)); + } + } + /** + * Enable source map. + * + * @return {void} + */ + + }, { + key: "disableSourceMap", + value: function disableSourceMap() { + this._sourcemap = false; + } + /** + * Hook triggered by `rollup` to load code from given path file. + * + * This hook is used here to analyze a JavaScript file to extract + * associated `package.json` file and store the main information about + * it (license, author, etc.). + * + * This method is used to analyse all the files added to the final bundle + * to extract license informations. + * + * @param {string} id Module identifier. + * @return {void} + */ + + }, { + key: "scanDependency", + value: function scanDependency(id) { + var _this = this; + + this.debug("scanning ".concat(id)); // Look for the `package.json` file + + var dir = path.parse(id).dir; + var pkg = null; + var scannedDirs = []; + + while (dir && dir !== this._cwd) { + // Try the cache. + if (_.has(this._cache, dir)) { + pkg = this._cache[dir]; + + if (pkg) { + this.debug("found package.json in cache (package: ".concat(pkg.name, ")")); + this.addDependency(pkg); + } + + break; + } + + scannedDirs.push(dir); + var pkgPath = path.join(dir, 'package.json'); + var exists = fs.existsSync(pkgPath); + + if (exists) { + this.debug("found package.json at: ".concat(pkgPath, ", read it")); // Read `package.json` file + + pkg = require(pkgPath); // Add the new dependency to the set of third-party dependencies. + + this.addDependency(pkg); // We can stop now. + + break; + } // Go up in the directory tree. + + + dir = path.normalize(path.join(dir, '..')); + } // Update the cache + + + _.forEach(scannedDirs, function (scannedDir) { + _this._cache[scannedDir] = pkg; + }); + } + /** + * Hook triggered by `rollup` to transform the final generated bundle. + * This hook is used here to prepend the license banner to the final bundle. + * + * @param {string} code The bundle content. + * @param {boolean} sourcemap If sourcemap must be generated. + * @return {Object} The result containing the code and, optionnally, the source map + * if it has been enabled (using `enableSourceMap` method). + */ + + }, { + key: "prependBanner", + value: function prependBanner(code, sourcemap) { + // Create a magicString: do not manipulate the string directly since it + // will be used to generate the sourcemap. + var magicString = new MagicString(code); + var banner = this._options.banner; + var content; + + if (_.isString(banner)) { + this.debug('prepend banner from template'); + content = banner; + } else if (banner) { + var file = banner.file; + this.debug("prepend banner from file: ".concat(file)); + var filePath = path.resolve(file); + var exists = fs.existsSync(filePath); + + if (exists) { + var encoding = banner.encoding || 'utf-8'; + this.debug("use encoding: ".concat(encoding)); + content = fs.readFileSync(filePath, encoding); + } else { + this.debug('template file does not exist, skip.'); + } + } + + if (content) { + // Create the template function with lodash. + var tmpl = _.template(content); // Generate the banner. + + + var pkg = this._pkg; + + var dependencies = _.values(this._dependencies); + + var data = banner.data ? _.result(banner, 'data') : {}; + var text = tmpl({ + _: _, + moment: moment, + pkg: pkg, + dependencies: dependencies, + data: data + }); // Make a block comment if needed + + var trimmedBanner = text.trim(); + var start = trimmedBanner.slice(0, 3); + + if (start !== '/**' && start !== '/*!') { + text = generateBlockComment(text); + } // Prepend the banner. + + + magicString.prepend("".concat(text).concat(EOL)); + } + + var result = { + code: magicString.toString() + }; + + if (this._sourcemap !== false && sourcemap !== false) { + result.map = magicString.generateMap({ + hires: true + }); + } + + return result; + } + /** + * Add new dependency to the bundle descriptor. + * + * @param {Object} pkg Dependency package information. + * @return {void} + */ + + }, { + key: "addDependency", + value: function addDependency(pkg) { + var name = pkg.name; + + if (!_.has(this._dependencies, name)) { + this._dependencies[name] = new Dependency(pkg); + } + } + /** + * Generate third-party dependencies summary. + * + * @param {boolean} includePrivate Flag that can be used to include / exclude private dependencies. + * @return {void} + */ + + }, { + key: "exportThirdParties", + value: function exportThirdParties() { + var thirdParty = this._options.thirdParty; + + if (!thirdParty) { + return; + } + + var output = thirdParty.output; + + if (output) { + this.debug("exporting third-party summary to ".concat(output)); // Create directory if it does not already exist. + + mkdirp(path.parse(output).dir); + var includePrivate = thirdParty.includePrivate; + + var text = _.chain(this._dependencies).values().filter(function (dependency) { + return includePrivate || !dependency.private; + }).map(function (dependency) { + return dependency.text(); + }).join("".concat(EOL).concat(EOL, "---").concat(EOL).concat(EOL)).trim().value(); + + var encoding = thirdParty.encoding || 'utf-8'; + this.debug("use encoding: ".concat(encoding)); + fs.writeFileSync(output, text || 'No third parties dependencies', { + encoding: encoding + }); + } + } + /** + * Log debug message if debug mode is enabled. + * + * @param {string} msg Log message. + */ + + }, { + key: "debug", + value: function debug(msg) { + if (this._debug) { + console.log("[".concat(this.name, "] -- ").concat(msg)); + } + } + }]); + + return LicensePlugin; +}(); + +module.exports = LicensePlugin; \ No newline at end of file diff --git a/dist/person.js b/dist/person.js new file mode 100644 index 00000000..63b4db90 --- /dev/null +++ b/dist/person.js @@ -0,0 +1,115 @@ +/** + * The MIT License (MIT) + * + * Copyright (c) 2016-2018 Mickael Jeanroy + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +'use strict'; + +function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } + +function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } + +function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } + +var _ = require('lodash'); +/** + * Person, defined by: + * - A name. + * - An email (optional). + * - An URL (optional). + */ + + +var Person = +/*#__PURE__*/ +function () { + /** + * Create the person. + * + * If parameter is a string, it will be automatically parsed according to + * this format: NAME (URL) (where email and url are optional). + * + * @param {string|object} person The person identity. + * @constructor + */ + function Person(person) { + _classCallCheck(this, Person); + + if (_.isString(person)) { + var o = {}; + var current = 'name'; + + for (var i = 0, size = person.length; i < size; ++i) { + var character = person.charAt(i); + + if (character === '<') { + current = 'email'; + } else if (character === '(') { + current = 'url'; + } else if (character !== ')' && character !== '>') { + o[current] = (o[current] || '') + character; + } + } + + _.forEach(['name', 'email', 'url'], function (prop) { + if (_.has(o, prop)) { + o[prop] = _.trim(o[prop]); + } + }); + + person = o; + } + + _.extend(this, person); + } + /** + * Serialize the person to a string with the following format: + * NAME (URL) + * + * @param {string} prefix Optional prefix prepended to the output string. + * @param {string} suffix Optional suffix appended to the output string. + * @return {string} The person as a string. + */ + + + _createClass(Person, [{ + key: "text", + value: function text() { + var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ''; + var suffix = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ''; + var text = "".concat(this.name); + + if (this.email) { + text += " <".concat(this.email, ">"); + } + + if (this.url) { + text += " (".concat(this.url, ")"); + } + + return "".concat(prefix).concat(text).concat(suffix); + } + }]); + + return Person; +}(); + +module.exports = Person; \ No newline at end of file diff --git a/package.json b/package.json index e42fed32..9321eb04 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "rollup-plugin-license", - "version": "0.7.0", + "version": "0.8.0", "description": "Rollup plugin to add license banner to the final bundle and output third party licenses", "main": "dist/index.js", "scripts": {