www.aleph1.co.uk Git - yaffs-website/blob - node_modules/postcss/lib/lazy-result.js

   1 'use strict';
   2
   3 exports.__esModule = true;
   4
   5 var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
   6
   7 var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
   8
   9 var _mapGenerator = require('./map-generator');
  10
  11 var _mapGenerator2 = _interopRequireDefault(_mapGenerator);
  12
  13 var _stringify2 = require('./stringify');
  14
  15 var _stringify3 = _interopRequireDefault(_stringify2);
  16
  17 var _warnOnce = require('./warn-once');
  18
  19 var _warnOnce2 = _interopRequireDefault(_warnOnce);
  20
  21 var _result = require('./result');
  22
  23 var _result2 = _interopRequireDefault(_result);
  24
  25 var _parse = require('./parse');
  26
  27 var _parse2 = _interopRequireDefault(_parse);
  28
  29 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
  30
  31 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  32
  33 function isPromise(obj) {
  34     return (typeof obj === 'undefined' ? 'undefined' : _typeof(obj)) === 'object' && typeof obj.then === 'function';
  35 }
  36
  37 /**
  38  * A Promise proxy for the result of PostCSS transformations.
  39  *
  40  * A `LazyResult` instance is returned by {@link Processor#process}.
  41  *
  42  * @example
  43  * const lazy = postcss([cssnext]).process(css);
  44  */
  45
  46 var LazyResult = function () {
  47     function LazyResult(processor, css, opts) {
  48         _classCallCheck(this, LazyResult);
  49
  50         this.stringified = false;
  51         this.processed = false;
  52
  53         var root = void 0;
  54         if ((typeof css === 'undefined' ? 'undefined' : _typeof(css)) === 'object' && css.type === 'root') {
  55             root = css;
  56         } else if (css instanceof LazyResult || css instanceof _result2.default) {
  57             root = css.root;
  58             if (css.map) {
  59                 if (typeof opts.map === 'undefined') opts.map = {};
  60                 if (!opts.map.inline) opts.map.inline = false;
  61                 opts.map.prev = css.map;
  62             }
  63         } else {
  64             var parser = _parse2.default;
  65             if (opts.syntax) parser = opts.syntax.parse;
  66             if (opts.parser) parser = opts.parser;
  67             if (parser.parse) parser = parser.parse;
  68
  69             try {
  70                 root = parser(css, opts);
  71             } catch (error) {
  72                 this.error = error;
  73             }
  74         }
  75
  76         this.result = new _result2.default(processor, root, opts);
  77     }
  78
  79     /**
  80      * Returns a {@link Processor} instance, which will be used
  81      * for CSS transformations.
  82      * @type {Processor}
  83      */
  84
  85
  86     /**
  87      * Processes input CSS through synchronous plugins
  88      * and calls {@link Result#warnings()}.
  89      *
  90      * @return {Warning[]} warnings from plugins
  91      */
  92     LazyResult.prototype.warnings = function warnings() {
  93         return this.sync().warnings();
  94     };
  95
  96     /**
  97      * Alias for the {@link LazyResult#css} property.
  98      *
  99      * @example
 100      * lazy + '' === lazy.css;
 101      *
 102      * @return {string} output CSS
 103      */
 104
 105
 106     LazyResult.prototype.toString = function toString() {
 107         return this.css;
 108     };
 109
 110     /**
 111      * Processes input CSS through synchronous and asynchronous plugins
 112      * and calls `onFulfilled` with a Result instance. If a plugin throws
 113      * an error, the `onRejected` callback will be executed.
 114      *
 115      * It implements standard Promise API.
 116      *
 117      * @param {onFulfilled} onFulfilled - callback will be executed
 118      *                                    when all plugins will finish work
 119      * @param {onRejected}  onRejected  - callback will be executed on any error
 120      *
 121      * @return {Promise} Promise API to make queue
 122      *
 123      * @example
 124      * postcss([cssnext]).process(css).then(result => {
 125      *   console.log(result.css);
 126      * });
 127      */
 128
 129
 130     LazyResult.prototype.then = function then(onFulfilled, onRejected) {
 131         return this.async().then(onFulfilled, onRejected);
 132     };
 133
 134     /**
 135      * Processes input CSS through synchronous and asynchronous plugins
 136      * and calls onRejected for each error thrown in any plugin.
 137      *
 138      * It implements standard Promise API.
 139      *
 140      * @param {onRejected} onRejected - callback will be executed on any error
 141      *
 142      * @return {Promise} Promise API to make queue
 143      *
 144      * @example
 145      * postcss([cssnext]).process(css).then(result => {
 146      *   console.log(result.css);
 147      * }).catch(error => {
 148      *   console.error(error);
 149      * });
 150      */
 151
 152
 153     LazyResult.prototype.catch = function _catch(onRejected) {
 154         return this.async().catch(onRejected);
 155     };
 156
 157     LazyResult.prototype.handleError = function handleError(error, plugin) {
 158         try {
 159             this.error = error;
 160             if (error.name === 'CssSyntaxError' && !error.plugin) {
 161                 error.plugin = plugin.postcssPlugin;
 162                 error.setMessage();
 163             } else if (plugin.postcssVersion) {
 164                 var pluginName = plugin.postcssPlugin;
 165                 var pluginVer = plugin.postcssVersion;
 166                 var runtimeVer = this.result.processor.version;
 167                 var a = pluginVer.split('.');
 168                 var b = runtimeVer.split('.');
 169
 170                 if (a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1])) {
 171                     (0, _warnOnce2.default)('Your current PostCSS version ' + 'is ' + runtimeVer + ', but ' + pluginName + ' ' + 'uses ' + pluginVer + '. Perhaps this is ' + 'the source of the error below.');
 172                 }
 173             }
 174         } catch (err) {
 175             if (console && console.error) console.error(err);
 176         }
 177     };
 178
 179     LazyResult.prototype.asyncTick = function asyncTick(resolve, reject) {
 180         var _this = this;
 181
 182         if (this.plugin >= this.processor.plugins.length) {
 183             this.processed = true;
 184             return resolve();
 185         }
 186
 187         try {
 188             var plugin = this.processor.plugins[this.plugin];
 189             var promise = this.run(plugin);
 190             this.plugin += 1;
 191
 192             if (isPromise(promise)) {
 193                 promise.then(function () {
 194                     _this.asyncTick(resolve, reject);
 195                 }).catch(function (error) {
 196                     _this.handleError(error, plugin);
 197                     _this.processed = true;
 198                     reject(error);
 199                 });
 200             } else {
 201                 this.asyncTick(resolve, reject);
 202             }
 203         } catch (error) {
 204             this.processed = true;
 205             reject(error);
 206         }
 207     };
 208
 209     LazyResult.prototype.async = function async() {
 210         var _this2 = this;
 211
 212         if (this.processed) {
 213             return new Promise(function (resolve, reject) {
 214                 if (_this2.error) {
 215                     reject(_this2.error);
 216                 } else {
 217                     resolve(_this2.stringify());
 218                 }
 219             });
 220         }
 221         if (this.processing) {
 222             return this.processing;
 223         }
 224
 225         this.processing = new Promise(function (resolve, reject) {
 226             if (_this2.error) return reject(_this2.error);
 227             _this2.plugin = 0;
 228             _this2.asyncTick(resolve, reject);
 229         }).then(function () {
 230             _this2.processed = true;
 231             return _this2.stringify();
 232         });
 233
 234         return this.processing;
 235     };
 236
 237     LazyResult.prototype.sync = function sync() {
 238         if (this.processed) return this.result;
 239         this.processed = true;
 240
 241         if (this.processing) {
 242             throw new Error('Use process(css).then(cb) to work with async plugins');
 243         }
 244
 245         if (this.error) throw this.error;
 246
 247         for (var _iterator = this.result.processor.plugins, _isArray = Array.isArray(_iterator), _i = 0, _iterator = _isArray ? _iterator : _iterator[Symbol.iterator]();;) {
 248             var _ref;
 249
 250             if (_isArray) {
 251                 if (_i >= _iterator.length) break;
 252                 _ref = _iterator[_i++];
 253             } else {
 254                 _i = _iterator.next();
 255                 if (_i.done) break;
 256                 _ref = _i.value;
 257             }
 258
 259             var plugin = _ref;
 260
 261             var promise = this.run(plugin);
 262             if (isPromise(promise)) {
 263                 throw new Error('Use process(css).then(cb) to work with async plugins');
 264             }
 265         }
 266
 267         return this.result;
 268     };
 269
 270     LazyResult.prototype.run = function run(plugin) {
 271         this.result.lastPlugin = plugin;
 272
 273         try {
 274             return plugin(this.result.root, this.result);
 275         } catch (error) {
 276             this.handleError(error, plugin);
 277             throw error;
 278         }
 279     };
 280
 281     LazyResult.prototype.stringify = function stringify() {
 282         if (this.stringified) return this.result;
 283         this.stringified = true;
 284
 285         this.sync();
 286
 287         var opts = this.result.opts;
 288         var str = _stringify3.default;
 289         if (opts.syntax) str = opts.syntax.stringify;
 290         if (opts.stringifier) str = opts.stringifier;
 291         if (str.stringify) str = str.stringify;
 292
 293         var map = new _mapGenerator2.default(str, this.result.root, this.result.opts);
 294         var data = map.generate();
 295         this.result.css = data[0];
 296         this.result.map = data[1];
 297
 298         return this.result;
 299     };
 300
 301     _createClass(LazyResult, [{
 302         key: 'processor',
 303         get: function get() {
 304             return this.result.processor;
 305         }
 306
 307         /**
 308          * Options from the {@link Processor#process} call.
 309          * @type {processOptions}
 310          */
 311
 312     }, {
 313         key: 'opts',
 314         get: function get() {
 315             return this.result.opts;
 316         }
 317
 318         /**
 319          * Processes input CSS through synchronous plugins, converts `Root`
 320          * to a CSS string and returns {@link Result#css}.
 321          *
 322          * This property will only work with synchronous plugins.
 323          * If the processor contains any asynchronous plugins
 324          * it will throw an error. This is why this method is only
 325          * for debug purpose, you should always use {@link LazyResult#then}.
 326          *
 327          * @type {string}
 328          * @see Result#css
 329          */
 330
 331     }, {
 332         key: 'css',
 333         get: function get() {
 334             return this.stringify().css;
 335         }
 336
 337         /**
 338          * An alias for the `css` property. Use it with syntaxes
 339          * that generate non-CSS output.
 340          *
 341          * This property will only work with synchronous plugins.
 342          * If the processor contains any asynchronous plugins
 343          * it will throw an error. This is why this method is only
 344          * for debug purpose, you should always use {@link LazyResult#then}.
 345          *
 346          * @type {string}
 347          * @see Result#content
 348          */
 349
 350     }, {
 351         key: 'content',
 352         get: function get() {
 353             return this.stringify().content;
 354         }
 355
 356         /**
 357          * Processes input CSS through synchronous plugins
 358          * and returns {@link Result#map}.
 359          *
 360          * This property will only work with synchronous plugins.
 361          * If the processor contains any asynchronous plugins
 362          * it will throw an error. This is why this method is only
 363          * for debug purpose, you should always use {@link LazyResult#then}.
 364          *
 365          * @type {SourceMapGenerator}
 366          * @see Result#map
 367          */
 368
 369     }, {
 370         key: 'map',
 371         get: function get() {
 372             return this.stringify().map;
 373         }
 374
 375         /**
 376          * Processes input CSS through synchronous plugins
 377          * and returns {@link Result#root}.
 378          *
 379          * This property will only work with synchronous plugins. If the processor
 380          * contains any asynchronous plugins it will throw an error.
 381          *
 382          * This is why this method is only for debug purpose,
 383          * you should always use {@link LazyResult#then}.
 384          *
 385          * @type {Root}
 386          * @see Result#root
 387          */
 388
 389     }, {
 390         key: 'root',
 391         get: function get() {
 392             return this.sync().root;
 393         }
 394
 395         /**
 396          * Processes input CSS through synchronous plugins
 397          * and returns {@link Result#messages}.
 398          *
 399          * This property will only work with synchronous plugins. If the processor
 400          * contains any asynchronous plugins it will throw an error.
 401          *
 402          * This is why this method is only for debug purpose,
 403          * you should always use {@link LazyResult#then}.
 404          *
 405          * @type {Message[]}
 406          * @see Result#messages
 407          */
 408
 409     }, {
 410         key: 'messages',
 411         get: function get() {
 412             return this.sync().messages;
 413         }
 414     }]);
 415
 416     return LazyResult;
 417 }();
 418
 419 exports.default = LazyResult;
 420
 421 /**
 422  * @callback onFulfilled
 423  * @param {Result} result
 424  */
 425
 426 /**
 427  * @callback onRejected
 428  * @param {Error} error
 429  */
 430
 431 module.exports = exports['default'];
 432 //# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["lazy-result.es6"],"names":["isPromise","obj","then","LazyResult","processor","css","opts","stringified","processed","root","type","map","inline","prev","parser","syntax","parse","error","result","warnings","sync","toString","onFulfilled","onRejected","async","catch","handleError","plugin","name","postcssPlugin","setMessage","postcssVersion","pluginName","pluginVer","runtimeVer","version","a","split","b","parseInt","err","console","asyncTick","resolve","reject","plugins","length","promise","run","Promise","stringify","processing","Error","lastPlugin","str","stringifier","data","generate","content","messages"],"mappings":"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","file":"lazy-result.js","sourcesContent":["import MapGenerator from './map-generator';\nimport stringify    from './stringify';\nimport warnOnce     from './warn-once';\nimport Result       from './result';\nimport parse        from './parse';\n\nfunction isPromise(obj) {\n    return typeof obj === 'object' && typeof obj.then === 'function';\n}\n\n/**\n * A Promise proxy for the result of PostCSS transformations.\n *\n * A `LazyResult` instance is returned by {@link Processor#process}.\n *\n * @example\n * const lazy = postcss([cssnext]).process(css);\n */\nclass LazyResult {\n\n    constructor(processor, css, opts) {\n        this.stringified = false;\n        this.processed   = false;\n\n        let root;\n        if ( typeof css === 'object' && css.type === 'root' ) {\n            root = css;\n        } else if ( css instanceof LazyResult || css instanceof Result ) {\n            root = css.root;\n            if ( css.map ) {\n                if ( typeof opts.map === 'undefined' ) opts.map = { };\n                if ( !opts.map.inline ) opts.map.inline = false;\n                opts.map.prev = css.map;\n            }\n        } else {\n            let parser = parse;\n            if ( opts.syntax )  parser = opts.syntax.parse;\n            if ( opts.parser )  parser = opts.parser;\n            if ( parser.parse ) parser = parser.parse;\n\n            try {\n                root = parser(css, opts);\n            } catch (error) {\n                this.error = error;\n            }\n        }\n\n        this.result = new Result(processor, root, opts);\n    }\n\n    /**\n     * Returns a {@link Processor} instance, which will be used\n     * for CSS transformations.\n     * @type {Processor}\n     */\n    get processor() {\n        return this.result.processor;\n    }\n\n    /**\n     * Options from the {@link Processor#process} call.\n     * @type {processOptions}\n     */\n    get opts() {\n        return this.result.opts;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins, converts `Root`\n     * to a CSS string and returns {@link Result#css}.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {string}\n     * @see Result#css\n     */\n    get css() {\n        return this.stringify().css;\n    }\n\n    /**\n     * An alias for the `css` property. Use it with syntaxes\n     * that generate non-CSS output.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {string}\n     * @see Result#content\n     */\n    get content() {\n        return this.stringify().content;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#map}.\n     *\n     * This property will only work with synchronous plugins.\n     * If the processor contains any asynchronous plugins\n     * it will throw an error. This is why this method is only\n     * for debug purpose, you should always use {@link LazyResult#then}.\n     *\n     * @type {SourceMapGenerator}\n     * @see Result#map\n     */\n    get map() {\n        return this.stringify().map;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#root}.\n     *\n     * This property will only work with synchronous plugins. If the processor\n     * contains any asynchronous plugins it will throw an error.\n     *\n     * This is why this method is only for debug purpose,\n     * you should always use {@link LazyResult#then}.\n     *\n     * @type {Root}\n     * @see Result#root\n     */\n    get root() {\n        return this.sync().root;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and returns {@link Result#messages}.\n     *\n     * This property will only work with synchronous plugins. If the processor\n     * contains any asynchronous plugins it will throw an error.\n     *\n     * This is why this method is only for debug purpose,\n     * you should always use {@link LazyResult#then}.\n     *\n     * @type {Message[]}\n     * @see Result#messages\n     */\n    get messages() {\n        return this.sync().messages;\n    }\n\n    /**\n     * Processes input CSS through synchronous plugins\n     * and calls {@link Result#warnings()}.\n     *\n     * @return {Warning[]} warnings from plugins\n     */\n    warnings() {\n        return this.sync().warnings();\n    }\n\n    /**\n     * Alias for the {@link LazyResult#css} property.\n     *\n     * @example\n     * lazy + '' === lazy.css;\n     *\n     * @return {string} output CSS\n     */\n    toString() {\n        return this.css;\n    }\n\n    /**\n     * Processes input CSS through synchronous and asynchronous plugins\n     * and calls `onFulfilled` with a Result instance. If a plugin throws\n     * an error, the `onRejected` callback will be executed.\n     *\n     * It implements standard Promise API.\n     *\n     * @param {onFulfilled} onFulfilled - callback will be executed\n     *                                    when all plugins will finish work\n     * @param {onRejected}  onRejected  - callback will be executed on any error\n     *\n     * @return {Promise} Promise API to make queue\n     *\n     * @example\n     * postcss([cssnext]).process(css).then(result => {\n     *   console.log(result.css);\n     * });\n     */\n    then(onFulfilled, onRejected) {\n        return this.async().then(onFulfilled, onRejected);\n    }\n\n    /**\n     * Processes input CSS through synchronous and asynchronous plugins\n     * and calls onRejected for each error thrown in any plugin.\n     *\n     * It implements standard Promise API.\n     *\n     * @param {onRejected} onRejected - callback will be executed on any error\n     *\n     * @return {Promise} Promise API to make queue\n     *\n     * @example\n     * postcss([cssnext]).process(css).then(result => {\n     *   console.log(result.css);\n     * }).catch(error => {\n     *   console.error(error);\n     * });\n     */\n    catch(onRejected) {\n        return this.async().catch(onRejected);\n    }\n\n    handleError(error, plugin) {\n        try {\n            this.error = error;\n            if ( error.name === 'CssSyntaxError' && !error.plugin ) {\n                error.plugin = plugin.postcssPlugin;\n                error.setMessage();\n            } else if ( plugin.postcssVersion ) {\n                let pluginName = plugin.postcssPlugin;\n                let pluginVer  = plugin.postcssVersion;\n                let runtimeVer = this.result.processor.version;\n                let a = pluginVer.split('.');\n                let b = runtimeVer.split('.');\n\n                if ( a[0] !== b[0] || parseInt(a[1]) > parseInt(b[1]) ) {\n                    warnOnce('Your current PostCSS version ' +\n                             'is ' + runtimeVer + ', but ' + pluginName + ' ' +\n                             'uses ' + pluginVer + '. Perhaps this is ' +\n                             'the source of the error below.');\n                }\n            }\n        } catch (err) {\n            if ( console && console.error ) console.error(err);\n        }\n    }\n\n    asyncTick(resolve, reject) {\n        if ( this.plugin >= this.processor.plugins.length ) {\n            this.processed = true;\n            return resolve();\n        }\n\n        try {\n            let plugin  = this.processor.plugins[this.plugin];\n            let promise = this.run(plugin);\n            this.plugin += 1;\n\n            if ( isPromise(promise) ) {\n                promise.then( () => {\n                    this.asyncTick(resolve, reject);\n                }).catch( error => {\n                    this.handleError(error, plugin);\n                    this.processed = true;\n                    reject(error);\n                });\n            } else {\n                this.asyncTick(resolve, reject);\n            }\n\n        } catch (error) {\n            this.processed = true;\n            reject(error);\n        }\n    }\n\n    async() {\n        if ( this.processed ) {\n            return new Promise( (resolve, reject) => {\n                if ( this.error ) {\n                    reject(this.error);\n                } else {\n                    resolve(this.stringify());\n                }\n            });\n        }\n        if ( this.processing ) {\n            return this.processing;\n        }\n\n        this.processing = new Promise( (resolve, reject) => {\n            if ( this.error ) return reject(this.error);\n            this.plugin = 0;\n            this.asyncTick(resolve, reject);\n        }).then( () => {\n            this.processed = true;\n            return this.stringify();\n        });\n\n        return this.processing;\n    }\n\n    sync() {\n        if ( this.processed ) return this.result;\n        this.processed = true;\n\n        if ( this.processing ) {\n            throw new Error(\n                'Use process(css).then(cb) to work with async plugins');\n        }\n\n        if ( this.error ) throw this.error;\n\n        for ( let plugin of this.result.processor.plugins ) {\n            let promise = this.run(plugin);\n            if ( isPromise(promise) ) {\n                throw new Error(\n                    'Use process(css).then(cb) to work with async plugins');\n            }\n        }\n\n        return this.result;\n    }\n\n    run(plugin) {\n        this.result.lastPlugin = plugin;\n\n        try {\n            return plugin(this.result.root, this.result);\n        } catch (error) {\n            this.handleError(error, plugin);\n            throw error;\n        }\n    }\n\n    stringify() {\n        if ( this.stringified ) return this.result;\n        this.stringified = true;\n\n        this.sync();\n\n        let opts = this.result.opts;\n        let str  = stringify;\n        if ( opts.syntax )      str = opts.syntax.stringify;\n        if ( opts.stringifier ) str = opts.stringifier;\n        if ( str.stringify )    str = str.stringify;\n\n        let map  = new MapGenerator(str, this.result.root, this.result.opts);\n        let data = map.generate();\n        this.result.css = data[0];\n        this.result.map = data[1];\n\n        return this.result;\n    }\n\n}\n\nexport default LazyResult;\n\n/**\n * @callback onFulfilled\n * @param {Result} result\n */\n\n/**\n * @callback onRejected\n * @param {Error} error\n */\n"]}