feat(index): support posthtml.config.js && result.messages

Author: michael-ciniawsky

lib/Error.js

@@ -0,0 +1,15 @@
+classLoaderErrorextendsError{
+constructor(err){
+super(err);
+
+this.name='PostHTML Loader';
+this.message=`\n\n${err.message}\n`;
+
+// TODO(michael-ciniawsky)
+// add 'SyntaxError', 'PluginError', 'PluginWarning'
+
+Error.captureStackTrace(this,this.constructor);
+}
+}
+
+module.exports=LoaderError;

lib/index.js

@@ -1,58 +1,163 @@
+'use strict'
+
+constpath=require('path')
+
 constloaderUtils=require('loader-utils')
+constvalidateOptions=require('schema-utils')
+
+constschema=require('./options.json')
+
 constposthtml=require('posthtml')
+constposthtmlrc=require('posthtml-load-config')
 
-module.exports=function(source){
-if(this.cacheable)this.cacheable()
+constparseOptions=require('./options')
 
-// configure options
-constqs=loaderUtils.parseQuery(this.query)
+constLoaderError=require('./Error')
+/**
+ * PostHTML Loader
+ *
+ * @author Michael Ciniawsky <michael.ciniawsky@gmail.com> (@michael-ciniawsky)
+ * @license MIT
+ *
+ * @version 1.0.0
+ *
+ * @requires loader-utils
+ * @requires schema-utils
+ *
+ * @requires posthtml
+ * @requires posthtml-load-config
+ *
+ * @method posthtml-loader
+ *
+ * @param {String} html HTML
+ *
+ * @return {String} html HTML
+ */
+module.exports=functionloader(html,map,meta){
+// Loader Options
+constoptions=loaderUtils.getOptions(this)||{}
+
+validateOptions(schema,options,'PostHTML Loader')
+
+// Make the loader async
 constcb=this.async()
-letconfig
-try{
-config=parseOptions.call(this,this.options.posthtml,qs)
-}catch(err){
-returncb(err)
-}
-
-// configure custom parser argument if necessary
-constprocessArgs=[source.toString()]
-if(config.parser){processArgs.push({parser: config.parser})}
-
-// run posthtml
-constph=posthtml(config.plugins)
-ph.process.apply(ph,processArgs)
-.then((result)=>cb(null,result.html),cb)
-}
+constfile=this.resourcePath
 
-functionparseOptions(config=[],qs={}){
-constres={}
+Promise.resolve().then(()=>{
+constlength=Object.keys(options)
+.filter((option)=>{
+switch(option){
+case'ident':
+case'config':
+return
+default:
+returnoption
+}
+})
+.length
 
-// if we have a function, run it
-if(typeofconfig==='function'){config=config.call(this,this)}
+if(length){
+returnparseOptions.call(this,options)
+}
 
-// if it's not an object at this point, error
-if(typeofconfig!=='object'){
-thrownewError('Configuration must return an array or object')
-}
+constrc={
+path: path.dirname(file),
+ctx: {
+file: {
+extname: path.extname(file),
+dirname: path.dirname(file),
+basename: path.basename(file)
+},
+options: {}
+}
+}
 
-// if we now have an array, that represents the plugins directly
-if(Array.isArray(config)){
-res.plugins=config
-// if not, it's an object. if a plugin pack is being used, use it.
-// otherwise, use default plugins
-}else{
-res.plugins=qs.pack ? config[qs.pack] : config.plugins
-}
+if(options.config){
+if(options.config.path){
+rc.path=path.resolve(options.config.path)
+}
 
-// load in the custom parser if there is one
-if(config.parser){res.parser=config.parser}
+if(options.config.ctx){
+rc.ctx.options=options.config.ctx
+}
+}
 
-// try loading custom parser from query
-if(qs.parser){
-res.parser=require(qs.parser)
-}
+returnposthtmlrc(rc.ctx,rc.path,{argv: false})
+})
+.then((config)=>{
+if(!config)config={}
 
-returnres
-}
+if(config.file)this.addDependency(config.file)
+
+if(config.options){
+// Disable overriding `options.to` (`posthtml.config.js`)
+if(config.options.to)deleteconfig.options.to
+// Disable overriding `options.from` (`posthtml.config.js`)
+if(config.options.from)deleteconfig.options.from
+}
+
+letplugins=config.plugins||[]
+letoptions=Object.assign(
+{from: file,to: file},
+config.options
+)
+
+if(typeofoptions.parser==='string'){
+options.parser=require(options.parser)()
+}
+
+// TODO(michael-ciniawsky) enable if when custom renderer available
+// if (typeof options.render === 'string') {
+// options.render = require(options.render)()
+// }
+
+returnposthtml(plugins)
+.process(html,options)
+.then((result)=>{
+if(result.messages){
+result.messages.forEach((msg)=>{
+switch(msg.type){
+case'error':
+this.emitError(msg.message)
 
-module.exports.parseOptions=parseOptions
+break
+case'warning':
+this.emitWarning(msg.message)
+
+break
+case'dependency':
+this.addDependency(msg.file)
+
+break
+default:
+break
+}
+})
+}
+
+html=result.html
+
+if(this.loaderIndex===0){
+html=`export default \`${html}\``
+
+cb(null,html)
+
+returnnull
+}
+
+if(!meta)meta={}
+
+meta.ast={type: 'posthtml',root: result.tree}
+meta.messages=result.messages
+
+cb(null,html,map,meta)
+
+returnnull
+})
+})
+.catch((err)=>{
+cb(newLoaderError(err))
+
+returnnull
+})
+}

lib/options.js

@@ -0,0 +1,22 @@
+'use strict'
+
+module.exports=functionparseOptions(params){
+if(typeofparams.plugins==='function'){
+params.plugins=params.plugins.call(this,this)
+}
+
+letplugins
+
+if(typeofparams.plugins==='undefined')plugins=[]
+elseif(Array.isArray(params.plugins))plugins=params.plugins
+elseplugins=[params.plugins]
+
+constoptions={}
+
+if(typeofparams!=='undefined'){
+options.parser=params.parser
+// options.render = params.render
+}
+
+returnPromise.resolve({options: options,plugins: plugins})
+}