module.exports = function (source) { const SCRIPT = utils.stringifyRequest(this, scriptLoader).replace(/"/g, '') const STYLE = utils.stringifyRequest(this, styleLoader).replace(/"/g, '') const AFTER_LESS_STYLE = utils.stringifyRequest(this, afterLessLoader).replace(/"/g, '') const TEMPLATE = utils.stringifyRequest(this, templateLoader).replace(/"/g, '') const BEFORE_TEMPLATE_COMPILER = utils.stringifyRequest(this, beforeTemplateCompilerLoader).replace(/"/g, '') const variableMap = this.vuxVariableMap || utils.getLoaderConfig(this, 'vuxVariableMap') var query = this.query ? utils.parseQuery(this.query) : {} this.cacheable() if (!source) return source const config = this.vux || utils.getLoaderConfig(this, 'vux') if (!config) { return source } let variables = '' var themes = config.plugins.filter(function (plugin) { return plugin.name === 'less-theme' }) if (themes.length) { const themePath = path.join(config.options.projectRoot, themes[0].path) this.addDependency(themePath) variables = getLessVariables(themes[0].path) for (let i in variables) { if (variableMap[i]) { variables[variableMap[i]] = variables[i] if (i !== variableMap[i]) { delete variables[i] } } } } source = addScriptLoader(source, SCRIPT) source = addStyleLoader(source, STYLE, variables, AFTER_LESS_STYLE) source = addTemplateLoader(source, TEMPLATE, BEFORE_TEMPLATE_COMPILER) // fix style path in dev mode if (config.options.vuxDev) { source = source.replace(/vux\/src\/styles\/(.*?)/g, '../styles/$1') } return source }
module.exports = function (source) { this.cacheable() const _this = this const config = this.vux || utils.getLoaderConfig(this, 'vux') if (!config.plugins || !config.plugins.length) { return source } config.plugins.forEach(function (plugin) { // style-parser if (plugin.name === 'style-parser') { if (plugin.fn) { source = plugin.fn.call(_this, source) } } }) if (config.options.vuxDev) { if (/App\.vue$/.test(this.resourcePath)) { source = source.replace(/~vux\/src/g, '.') } else { if (config.options.resolveVuxDir) { // if (_this.resourcePath.includes('pages') && _this.resourcePath.includes('IconLoading') ) // source = source.replace(/~vux\/src/g, config.options.resolveVuxDir).replace('//', '/') // if (_this.resourcePath.includes('pages') && _this.resourcePath.includes('IconLoading') ) } else { source = source.replace(/~vux\/src/g, '..') } } } return source }
module.exports = function(content) { var callback = this.async(); this.cacheable && this.cacheable(); this.value = content; var config = Object.assign({ extensions: ['.css'], resolveUrls: true, context: this.context }, loaderUtils.getLoaderConfig(this, 'cssConcat')); var url = loaderUtils.interpolateName(this, '[path][name].[ext]', { context: this.context, content: content }); try { var result = parseImports(path.join(this.context, url), content, config); var cssAsString = JSON.stringify(result.css); cssAsString = cssAsString.replace(/___CSS_LOADER_URL___([0-9]+)___/g, function (match, id) { return 'url(\\"" + require("' + result.urls[id] + '") + "\\")'; }); callback(null, "module.exports = " + cssAsString); } catch (err) { callback(err); } };
module.exports = function(content) { this.cacheable && this.cacheable(); var config = loaderUtils.getLoaderConfig(this, "imageWebpackLoader"); var options = { interlaced: config.interlaced || false, progressive: config.progressive || false, optimizationLevel: config.optimizationLevel || 3, bypassOnDebug: config.bypassOnDebug || false, pngquant: config.pngquant || false, svgo: config.svgo || {} }; var callback = this.async(), called = false; if (this.debug === true && options.bypassOnDebug === true) { // Bypass processing while on watch mode return callback(null, content); } else { var imagemin = new Imagemin() .src(content) .use(Imagemin.gifsicle({ interlaced: options.interlaced })) .use(Imagemin.jpegtran({ progressive: options.progressive })) .use(Imagemin.svgo(options.svgo)); if (options.pngquant) { imagemin.use(imageminPngquant(options.pngquant)); } else { imagemin.use(Imagemin.optipng({ optimizationLevel: options.optimizationLevel })); } imagemin.run(function(err, files) { if (called) { console.log("something is very odd, it is being called twice"); return; } called = true; if (err) { callback(err); } else { callback(null, files[0].contents); } }); } };
module.exports = function(content) { this.cacheable && this.cacheable(); var config = loaderUtils.getLoaderConfig(this, "imageWebpackLoader"); var options = { interlaced: config.interlaced || false, optimizationLevel: config.optimizationLevel || 3, bypassOnDebug: config.bypassOnDebug || false, mozjpeg: config.mozjpeg || false, pngquant: config.pngquant || false, svgo: config.svgo || {} }; var callback = this.async(), called = false; if (this.debug === true && options.bypassOnDebug === true) { // Bypass processing while on watch mode return callback(null, content); } else { var plugins = []; plugins.push(imageminGifsicle({ interlaced: options.interlaced })); plugins.push(imageminMozjpeg(options.mozjpeg)); plugins.push(imageminSvgo(options.svgo)); plugins.push(imageminPngquant(options.pngquant)); plugins.push(imageminOptipng({ optimizationLevel: options.optimizationLevel })); imagemin .buffer(content, { plugins }) .then(data => { callback(null, data); }) .catch(err => { callback(err); }); } };
module.exports = function (source) { if (this.cacheable) this.cacheable() var callback = this.async() var config = loaderUtils.getLoaderConfig(this, 'uikitLoader') // Only act on uikit less imports by default var testPattern = config.test || /node_modules\/uikit\/.+less$/ if (!testPattern.test(this.resourcePath)) { return callback(null, source) } var themeName = config.theme if (!themeName) { return callback(new Error('No `theme` specified in the uikit-loader options! See: https://github.com/stipsan/uikit-loader#usage')) } var themePath = path.resolve(themeName) var themeExists = fs.existsSync(themePath) if (!themeExists) { return callback(new Error(`The path ${themePath} does not exist!`)) } this.addDependency(themePath) var prepend = config.prepend || false var relativePath = path.relative(this.context, themePath) var theme = `@import "${relativePath}";` var compiled = source if (prepend) { compiled = theme + '\n' + compiled } else { compiled = compiled + '\n' + theme } callback(null, compiled) }
module.exports = function (source) { this.cacheable() const _this = this const config = this.vux || utils.getLoaderConfig(this, 'vux') if (!config.plugins || !config.plugins.length) { return source } if (config.options.useVuxUI && source.indexOf('</x-icon>') > -1) { source = parseXIcon(source, config) } config.plugins.forEach(function (plugin) { // style-parser if (plugin.name === 'before-template-compiler-parser') { if (plugin.fn) { source = plugin.fn.call(_this, source) } } }) return source }
module.exports = function(source) { var self = this if (self.cacheable) self.cacheable() var configPaths = cloneDeep(loaderUtils.getLoaderConfig(self, "multiStylusLoader")).paths var context = self.context var done = self.async() getConfigs(configPaths).then(function(configs) { return mutliRender(source, configs) }).then(function (results) { var output = results done(null, output) }).catch(function (err) { done(err) }) function mutliRender (source, configs) { return Promise.all( Object.keys(configs).map(function(namespace, index) { var currentNamespace = namespace thisSource = '.' + namespace + '\n' + indentSource(source, 2) var config = configs[namespace] return renderPromise(thisSource, config) .then(function(result) { result = '\n/* ' + currentNamespace + ' */\n' + result return result }) }) ).then(function(results) { return results.join('\n\n') }) } function getConfigs (configPaths) { return Promise.all( Object.keys(configPaths).map(function(configName) { var configPath = configPaths[configName] // Asynchronously load import var configFileName return resolvePromise(context, configPath) .then(function(fileName) { self.addDependency && self.addDependency(fileName) configFileName = fileName return loadModulePromise('-!' + __dirname + '/identity.loader.js!' + fileName) }).then(function (results) { results = self.exec(results, configFileName) configPaths[configName] = results }).catch(function(err) { console.log('load module promise err', err) }) }) ).then(function () { return configPaths }) } function renderPromise (source, config, namespace) { return new Promise(function(resolve, reject) { var compiler = stylus(source) applyOptions(compiler, config) compiler.render(function(err, css) { if (err) reject(err) resolve(css) }) }) } function resolvePromise(context, request) { return new Promise(function (resolve, reject) { self.resolve(context, request, function(err, filename) { if (err) reject(err) resolve(filename) }) }) } function loadModulePromise(request) { return new Promise(function (resolve, reject) { self.loadModule(request, function(err, source) { if (err) reject(err) resolve(source) }) }) } function applyOptions(stylus, options) { ['set', 'include', 'import', 'define', 'use'].forEach(function(method) { var option = options[method] if (isArray(option)) { for (var i = 0; i < option.length; i++) { stylus[method](option[i]) if ('include' === method) { self.addContextDependency(option[i]) } } } else { for (var prop in option) stylus[method](prop, option[prop]) } }) } }
/** * Initialize the loader with web3 and config */ function init(loader) { var loaderConfig = loaderUtils.getLoaderConfig(loader, 'web3Loader'); web3 = require('./lib/web3')(loaderConfig.provider); config = mergeConfig(loaderConfig); isDebug = loader.debug; }
module.exports = function (source) { this.cacheable() const _this = this const config = this.vux || utils.getLoaderConfig(this, 'vux') if (!config.plugins || !config.plugins.length) { return source } let i18nPlugin const i18nPluginsMatch = config.plugins.filter(function (one) { return one.name === 'i18n' }) if (i18nPluginsMatch.length) { i18nPlugin = i18nPluginsMatch[0] } let isVuxVueFile = this.resourcePath.replace(/\\/g, '/').indexOf('vux/src/components') > -1 if (config.options.vuxDev && this.resourcePath.replace(/\\/g, '/').indexOf('src/components') > -1) { isVuxVueFile = true } const isVuxComponent = this.resourcePath.replace(/\\/g, '/').indexOf('/vux/src/components') > -1 if (config.plugins.length) { config.plugins.forEach(function (plugin) { // script-parser if (plugin.name === 'script-parser') { if (plugin.fn) { source = plugin.fn.call(_this, source) } } }) } if (config.options.useVuxUI && /}\s+from(.*?)('|")vux/.test(source)) { const maps = this.vuxMaps || utils.getLoaderConfig(this, 'vuxMaps') const parser = require('./libs/import-parser') source = parser(source, function (opts) { let str = '' opts.components.forEach(function (component) { let file = `vux/${maps[component.originalName]}` if (config.options.vuxDev) { if (/App\.vue/.test(_this.resourcePath)) { file = file.replace(/vux\/src/g, '.') } else { let relative = '..' // component file import other functions if (isVuxComponent && !/components/.test(file)) { relative = '../..' } if (/demos/.test(_this.resourcePath)) { const splits = _this.resourcePath.split('demos')[1].split(path.sep).length - 1 let dir = [] for (let i = 0; i < splits; i++) { dir.push('..') } relative = dir.join('/') } if (config.options.resolveVuxDir) { relative = config.options.resolveVuxDir } file = file.replace(/vux\/src/g, relative) } } str += `import ${component.newName} from '${file}'\n` }) return str }, 'vux') } if (config.options.vuxWriteFile === true) { fs.writeFileSync(this.resourcePath + '.vux.js', source) } if (i18nPlugin && !isVuxVueFile && source.indexOf(`$t('`) > -1 && i18nPlugin.staticReplace === true) { const rs = getI18nBlockWithLocale({ code: _this.resourcePath, isFile: true, locale: i18nPlugin.vuxLocale || 'zh-CN' }) source = i18nReplaceForScript(source, rs) } return source }
module.exports = function (content) { const isWebpack2 = !!this.remainingRequest; const callback = this.async(); const config = loaderUtils.getLoaderConfig(this, 'imageOptimizeLoader') || {}; const fileName = this.request.split('!').pop(); const fileHash = getHashOf(content); const fileExt = path.extname(fileName).replace(/^./, ''); let cacheKey = getHashOf(fileName); // extend default configs const settings = {}; settings.optimizer = Object.assign({}, defaultSettings.optimizer, config.optimizer || {}); settings.mozjpeg = Object.assign({}, settings.optimizer, defaultSettings.mozjpeg, config.mozjpeg || {}); settings.pngquant = Object.assign({}, settings.optimizer, defaultSettings.pngquant, config.pngquant || {}); settings.svgo = Object.assign({}, settings.optimizer, defaultSettings.svgo, config.svgo || {}); // add settings to cacheKey by extension switch (fileExt) { case 'png': cacheKey = getHashOf(JSON.stringify([cacheKey, settings.pngquant, isWebpack2])); break; case 'jpg': cacheKey = getHashOf(JSON.stringify([cacheKey, settings.mozjpeg])); break; case 'svg': cacheKey = getHashOf(JSON.stringify([cacheKey, settings.svgo])); break; default: break; } const promiseOptimizeImage = Q.defer(); const promisePrepareImage = Q.defer(); const checkCacheExists = Q.defer(); function startOptimization() { asyncQueue.addTask(function () { // concurrency++; // console.log(`\r optimize:start ${concurrency}`); const completePromise = Q.defer(); promisePrepareImage.resolve(completePromise); completePromise.promise.then(this.wrapCallback(() => { // concurrency--; // console.log(`\r optimize:finished ${concurrency}`); })) .catch(callback); }); } // ensure cache exists checkCacheExists.promise.then(() => { Q.all([ cache.has(cacheKey).catch(callback), cache.has(`${cacheKey}-checksum`).catch(callback), ]).then(checks => { // if cache is not found if (!checks[0] || !checks[1]) { startOptimization(); return; } // check is cache up to date cache.get(`${cacheKey}-checksum`).then(results => { const data = JSON.parse(results.value); // if file not changed, return cached value if (data.fileHash === fileHash) { cache.get(cacheKey).then(cacheEntry => { this.resource = data.resource; promisePrepareImage.reject(); return callback(null, cacheEntry.value); }).catch(callback); // cache is outdated, create new image } else { startOptimization(); } }).catch(callback); }).catch(callback); }).catch(callback); promisePrepareImage.promise.then((completePromise) => { if (settings.optimizer.covertPngToJpg && fileExt === 'png' && isWebpack2) { streamifier.createReadStream(content) .pipe(new PNG()) .on('metadata', data => { if (data.alpha) { return promiseOptimizeImage.resolve(completePromise); } // if alpha not found - convert buffer to jpg gm(content).toBuffer('JPG', (err, buffer) => { if (err) { return callback(err); } this.resource = this.resource.replace(/.png$/, '.jpg'); content = buffer; promiseOptimizeImage.resolve(completePromise); return false; }); return false; }); } else { promiseOptimizeImage.resolve(completePromise); } }).catch(callback); promiseOptimizeImage.promise.then((completePromise) => { imagemin.buffer(content, { plugins: [ imageminMozjpeg(settings.mozjpeg), imageminPngquant(settings.pngquant), imageminSvgo(settings.svgo), ], }).then(file => { cache.set(cacheKey, file); cache.set(`${cacheKey}-checksum`, JSON.stringify({ fileHash, resource: this.resource, })); completePromise.resolve(); callback(null, file); }).catch(callback); }).catch(callback); checkCacheExists.resolve(); };