)<[^<]*)*<\/script>/gi,
+ scriptTypeRE = /^(?:text|application)\/javascript/i,
+ xmlTypeRE = /^(?:text|application)\/xml/i,
+ jsonType = 'application/json',
+ htmlType = 'text/html',
+ blankRE = /^\s*$/,
+ originAnchor = document.createElement('a')
+
+ originAnchor.href = window.location.href
+
+ // trigger a custom event and return false if it was cancelled
+ function triggerAndReturn(context, eventName, data) {
+ var event = $.Event(eventName)
+ $(context).trigger(event, data)
+ return !event.isDefaultPrevented()
+ }
+
+ // trigger an Ajax "global" event
+ function triggerGlobal(settings, context, eventName, data) {
+ if (settings.global) return triggerAndReturn(context || document, eventName, data)
+ }
+
+ // Number of active Ajax requests
+ $.active = 0
+
+ function ajaxStart(settings) {
+ if (settings.global && $.active++ === 0) triggerGlobal(settings, null, 'ajaxStart')
+ }
+ function ajaxStop(settings) {
+ if (settings.global && !(--$.active)) triggerGlobal(settings, null, 'ajaxStop')
+ }
+
+ // triggers an extra global event "ajaxBeforeSend" that's like "ajaxSend" but cancelable
+ function ajaxBeforeSend(xhr, settings) {
+ var context = settings.context
+ if (settings.beforeSend.call(context, xhr, settings) === false ||
+ triggerGlobal(settings, context, 'ajaxBeforeSend', [xhr, settings]) === false)
+ return false
+
+ triggerGlobal(settings, context, 'ajaxSend', [xhr, settings])
+ }
+ function ajaxSuccess(data, xhr, settings, deferred) {
+ var context = settings.context, status = 'success'
+ settings.success.call(context, data, status, xhr)
+ if (deferred) deferred.resolveWith(context, [data, status, xhr])
+ triggerGlobal(settings, context, 'ajaxSuccess', [xhr, settings, data])
+ ajaxComplete(status, xhr, settings)
+ }
+ // type: "timeout", "error", "abort", "parsererror"
+ function ajaxError(error, type, xhr, settings, deferred) {
+ var context = settings.context
+ settings.error.call(context, xhr, type, error)
+ if (deferred) deferred.rejectWith(context, [xhr, type, error])
+ triggerGlobal(settings, context, 'ajaxError', [xhr, settings, error || type])
+ ajaxComplete(type, xhr, settings)
+ }
+ // status: "success", "notmodified", "error", "timeout", "abort", "parsererror"
+ function ajaxComplete(status, xhr, settings) {
+ var context = settings.context
+ settings.complete.call(context, xhr, status)
+ triggerGlobal(settings, context, 'ajaxComplete', [xhr, settings])
+ ajaxStop(settings)
+ }
+
+ // Empty function, used as default callback
+ function empty() {}
+
+ $.ajaxJSONP = function(options, deferred){
+ if (!('type' in options)) return $.ajax(options)
+
+ var _callbackName = options.jsonpCallback,
+ callbackName = ($.isFunction(_callbackName) ?
+ _callbackName() : _callbackName) || ('jsonp' + (++jsonpID)),
+ script = document.createElement('script'),
+ originalCallback = window[callbackName],
+ responseData,
+ abort = function(errorType) {
+ $(script).triggerHandler('error', errorType || 'abort')
+ },
+ xhr = { abort: abort }, abortTimeout
+
+ if (deferred) deferred.promise(xhr)
+
+ $(script).on('load error', function(e, errorType){
+ clearTimeout(abortTimeout)
+ $(script).off().remove()
+
+ if (e.type == 'error' || !responseData) {
+ ajaxError(null, errorType || 'error', xhr, options, deferred)
+ } else {
+ ajaxSuccess(responseData[0], xhr, options, deferred)
+ }
+
+ window[callbackName] = originalCallback
+ if (responseData && $.isFunction(originalCallback))
+ originalCallback(responseData[0])
+
+ originalCallback = responseData = undefined
+ })
+
+ if (ajaxBeforeSend(xhr, options) === false) {
+ abort('abort')
+ return xhr
+ }
+
+ window[callbackName] = function(){
+ responseData = arguments
+ }
+
+ script.src = options.url.replace(/\?(.+)=\?/, '?$1=' + callbackName)
+ document.head.appendChild(script)
+
+ if (options.timeout > 0) abortTimeout = setTimeout(function(){
+ abort('timeout')
+ }, options.timeout)
+
+ return xhr
+ }
+
+ $.ajaxSettings = {
+ // Default type of request
+ type: 'GET',
+ // Callback that is executed before request
+ beforeSend: empty,
+ // Callback that is executed if the request succeeds
+ success: empty,
+ // Callback that is executed the the server drops error
+ error: empty,
+ // Callback that is executed on request complete (both: error and success)
+ complete: empty,
+ // The context for the callbacks
+ context: null,
+ // Whether to trigger "global" Ajax events
+ global: true,
+ // Transport
+ xhr: function () {
+ return new window.XMLHttpRequest()
+ },
+ // MIME types mapping
+ // IIS returns Javascript as "application/x-javascript"
+ accepts: {
+ script: 'text/javascript, application/javascript, application/x-javascript',
+ json: jsonType,
+ xml: 'application/xml, text/xml',
+ html: htmlType,
+ text: 'text/plain'
+ },
+ // Whether the request is to another domain
+ crossDomain: false,
+ // Default timeout
+ timeout: 0,
+ // Whether data should be serialized to string
+ processData: true,
+ // Whether the browser should be allowed to cache GET responses
+ cache: true
+ }
+
+ function mimeToDataType(mime) {
+ if (mime) mime = mime.split(';', 2)[0]
+ return mime && ( mime == htmlType ? 'html' :
+ mime == jsonType ? 'json' :
+ scriptTypeRE.test(mime) ? 'script' :
+ xmlTypeRE.test(mime) && 'xml' ) || 'text'
+ }
+
+ function appendQuery(url, query) {
+ if (query == '') return url
+ return (url + '&' + query).replace(/[&?]{1,2}/, '?')
+ }
+
+ // serialize payload and append it to the URL for GET requests
+ function serializeData(options) {
+ if (options.processData && options.data && $.type(options.data) != "string")
+ options.data = $.param(options.data, options.traditional)
+ if (options.data && (!options.type || options.type.toUpperCase() == 'GET'))
+ options.url = appendQuery(options.url, options.data), options.data = undefined
+ }
+
+ $.ajax = function(options){
+ var settings = $.extend({}, options || {}),
+ deferred = $.Deferred && $.Deferred(),
+ urlAnchor
+ for (key in $.ajaxSettings) if (settings[key] === undefined) settings[key] = $.ajaxSettings[key]
+
+ ajaxStart(settings)
+
+ if (!settings.crossDomain) {
+ urlAnchor = document.createElement('a')
+ urlAnchor.href = settings.url
+ urlAnchor.href = urlAnchor.href
+ settings.crossDomain = (originAnchor.protocol + '//' + originAnchor.host) !== (urlAnchor.protocol + '//' + urlAnchor.host)
+ }
+
+ if (!settings.url) settings.url = window.location.toString()
+ serializeData(settings)
+
+ var dataType = settings.dataType, hasPlaceholder = /\?.+=\?/.test(settings.url)
+ if (hasPlaceholder) dataType = 'jsonp'
+
+ if (settings.cache === false || (
+ (!options || options.cache !== true) &&
+ ('script' == dataType || 'jsonp' == dataType)
+ ))
+ settings.url = appendQuery(settings.url, '_=' + Date.now())
+
+ if ('jsonp' == dataType) {
+ if (!hasPlaceholder)
+ settings.url = appendQuery(settings.url,
+ settings.jsonp ? (settings.jsonp + '=?') : settings.jsonp === false ? '' : 'callback=?')
+ return $.ajaxJSONP(settings, deferred)
+ }
+
+ var mime = settings.accepts[dataType],
+ headers = { },
+ setHeader = function(name, value) { headers[name.toLowerCase()] = [name, value] },
+ protocol = /^([\w-]+:)\/\//.test(settings.url) ? RegExp.$1 : window.location.protocol,
+ xhr = settings.xhr(),
+ nativeSetHeader = xhr.setRequestHeader,
+ abortTimeout
+
+ if (deferred) deferred.promise(xhr)
+
+ if (!settings.crossDomain) setHeader('X-Requested-With', 'XMLHttpRequest')
+ setHeader('Accept', mime || '*/*')
+ if (mime = settings.mimeType || mime) {
+ if (mime.indexOf(',') > -1) mime = mime.split(',', 2)[0]
+ xhr.overrideMimeType && xhr.overrideMimeType(mime)
+ }
+ if (settings.contentType || (settings.contentType !== false && settings.data && settings.type.toUpperCase() != 'GET'))
+ setHeader('Content-Type', settings.contentType || 'application/x-www-form-urlencoded')
+
+ if (settings.headers) for (name in settings.headers) setHeader(name, settings.headers[name])
+ xhr.setRequestHeader = setHeader
+
+ xhr.onreadystatechange = function(){
+ if (xhr.readyState == 4) {
+ xhr.onreadystatechange = empty
+ clearTimeout(abortTimeout)
+ var result, error = false
+ if ((xhr.status >= 200 && xhr.status < 300) || xhr.status == 304 || (xhr.status == 0 && protocol == 'file:')) {
+ dataType = dataType || mimeToDataType(settings.mimeType || xhr.getResponseHeader('content-type'))
+ result = xhr.responseText
+
+ try {
+ // http://perfectionkills.com/global-eval-what-are-the-options/
+ if (dataType == 'script') (1,eval)(result)
+ else if (dataType == 'xml') result = xhr.responseXML
+ else if (dataType == 'json') result = blankRE.test(result) ? null : $.parseJSON(result)
+ } catch (e) { error = e }
+
+ if (error) ajaxError(error, 'parsererror', xhr, settings, deferred)
+ else ajaxSuccess(result, xhr, settings, deferred)
+ } else {
+ ajaxError(xhr.statusText || null, xhr.status ? 'error' : 'abort', xhr, settings, deferred)
+ }
+ }
+ }
+
+ if (ajaxBeforeSend(xhr, settings) === false) {
+ xhr.abort()
+ ajaxError(null, 'abort', xhr, settings, deferred)
+ return xhr
+ }
+
+ if (settings.xhrFields) for (name in settings.xhrFields) xhr[name] = settings.xhrFields[name]
+
+ var async = 'async' in settings ? settings.async : true
+ xhr.open(settings.type, settings.url, async, settings.username, settings.password)
+
+ for (name in headers) nativeSetHeader.apply(xhr, headers[name])
+
+ if (settings.timeout > 0) abortTimeout = setTimeout(function(){
+ xhr.onreadystatechange = empty
+ xhr.abort()
+ ajaxError(null, 'timeout', xhr, settings, deferred)
+ }, settings.timeout)
+
+ // avoid sending empty string (#319)
+ xhr.send(settings.data ? settings.data : null)
+ return xhr
+ }
+
+ // handle optional data/success arguments
+ function parseArguments(url, data, success, dataType) {
+ if ($.isFunction(data)) dataType = success, success = data, data = undefined
+ if (!$.isFunction(success)) dataType = success, success = undefined
+ return {
+ url: url
+ , data: data
+ , success: success
+ , dataType: dataType
+ }
+ }
+
+ $.get = function(/* url, data, success, dataType */){
+ return $.ajax(parseArguments.apply(null, arguments))
+ }
+
+ $.post = function(/* url, data, success, dataType */){
+ var options = parseArguments.apply(null, arguments)
+ options.type = 'POST'
+ return $.ajax(options)
+ }
+
+ $.getJSON = function(/* url, data, success */){
+ var options = parseArguments.apply(null, arguments)
+ options.dataType = 'json'
+ return $.ajax(options)
+ }
+
+ $.fn.load = function(url, data, success){
+ if (!this.length) return this
+ var self = this, parts = url.split(/\s/), selector,
+ options = parseArguments(url, data, success),
+ callback = options.success
+ if (parts.length > 1) options.url = parts[0], selector = parts[1]
+ options.success = function(response){
+ self.html(selector ?
+ $('').html(response.replace(rscript, "")).find(selector)
+ : response)
+ callback && callback.apply(self, arguments)
+ }
+ $.ajax(options)
+ return this
+ }
+
+ var escape = encodeURIComponent
+
+ function serialize(params, obj, traditional, scope){
+ var type, array = $.isArray(obj), hash = $.isPlainObject(obj)
+ $.each(obj, function(key, value) {
+ type = $.type(value)
+ if (scope) key = traditional ? scope :
+ scope + '[' + (hash || type == 'object' || type == 'array' ? key : '') + ']'
+ // handle data in serializeArray() format
+ if (!scope && array) params.add(value.name, value.value)
+ // recurse into nested objects
+ else if (type == "array" || (!traditional && type == "object"))
+ serialize(params, value, traditional, key)
+ else params.add(key, value)
+ })
+ }
+
+ $.param = function(obj, traditional){
+ var params = []
+ params.add = function(key, value) {
+ if ($.isFunction(value)) value = value()
+ if (value == null) value = ""
+ this.push(escape(key) + '=' + escape(value))
+ }
+ serialize(params, obj, traditional)
+ return params.join('&').replace(/%20/g, '+')
+ }
+})(Zepto)
+
+;(function($){
+ $.fn.serializeArray = function() {
+ var name, type, result = [],
+ add = function(value) {
+ if (value.forEach) return value.forEach(add)
+ result.push({ name: name, value: value })
+ }
+ if (this[0]) $.each(this[0].elements, function(_, field){
+ type = field.type, name = field.name
+ if (name && field.nodeName.toLowerCase() != 'fieldset' &&
+ !field.disabled && type != 'submit' && type != 'reset' && type != 'button' && type != 'file' &&
+ ((type != 'radio' && type != 'checkbox') || field.checked))
+ add($(field).val())
+ })
+ return result
+ }
+
+ $.fn.serialize = function(){
+ var result = []
+ this.serializeArray().forEach(function(elm){
+ result.push(encodeURIComponent(elm.name) + '=' + encodeURIComponent(elm.value))
+ })
+ return result.join('&')
+ }
+
+ $.fn.submit = function(callback) {
+ if (0 in arguments) this.bind('submit', callback)
+ else if (this.length) {
+ var event = $.Event('submit')
+ this.eq(0).trigger(event)
+ if (!event.isDefaultPrevented()) this.get(0).submit()
+ }
+ return this
+ }
+
+})(Zepto)
+
+;(function($){
+ // __proto__ doesn't exist on IE<11, so redefine
+ // the Z function to use object extension instead
+ if (!('__proto__' in {})) {
+ $.extend($.zepto, {
+ Z: function(dom, selector){
+ dom = dom || []
+ $.extend(dom, $.fn)
+ dom.selector = selector || ''
+ dom.__Z = true
+ return dom
+ },
+ // this is a kludge but works
+ isZ: function(object){
+ return $.type(object) === 'array' && '__Z' in object
+ }
+ })
+ }
+
+ // getComputedStyle shouldn't freak out when called
+ // without a valid element as argument
+ try {
+ getComputedStyle(undefined)
+ } catch(e) {
+ var nativeGetComputedStyle = getComputedStyle;
+ window.getComputedStyle = function(element){
+ try {
+ return nativeGetComputedStyle(element)
+ } catch(e) {
+ return null
+ }
+ }
+ }
+})(Zepto)
diff --git a/project/src/slice/office/excel.png b/project/src/slice/office/excel.png
new file mode 100644
index 0000000..460e0e4
Binary files /dev/null and b/project/src/slice/office/excel.png differ
diff --git a/project/src/slice/office/excel@2x.png b/project/src/slice/office/excel@2x.png
new file mode 100644
index 0000000..8d3c890
Binary files /dev/null and b/project/src/slice/office/excel@2x.png differ
diff --git a/project/src/slice/office/project.png b/project/src/slice/office/project.png
new file mode 100644
index 0000000..b0a4437
Binary files /dev/null and b/project/src/slice/office/project.png differ
diff --git a/project/src/slice/office/project@2x.png b/project/src/slice/office/project@2x.png
new file mode 100644
index 0000000..b7d4831
Binary files /dev/null and b/project/src/slice/office/project@2x.png differ
diff --git a/project/src/slice/office/publisher.png b/project/src/slice/office/publisher.png
new file mode 100644
index 0000000..e48517e
Binary files /dev/null and b/project/src/slice/office/publisher.png differ
diff --git a/project/src/slice/office/publisher@2x.png b/project/src/slice/office/publisher@2x.png
new file mode 100644
index 0000000..b76ed78
Binary files /dev/null and b/project/src/slice/office/publisher@2x.png differ
diff --git a/project/src/slice/office/word.png b/project/src/slice/office/word.png
new file mode 100644
index 0000000..22509b9
Binary files /dev/null and b/project/src/slice/office/word.png differ
diff --git a/project/src/slice/office/word@2x.png b/project/src/slice/office/word@2x.png
new file mode 100644
index 0000000..e7cca70
Binary files /dev/null and b/project/src/slice/office/word@2x.png differ
diff --git a/tasks/common/replace.js b/tasks/common/replace.js
new file mode 100644
index 0000000..def32eb
--- /dev/null
+++ b/tasks/common/replace.js
@@ -0,0 +1,17 @@
+/**
+ * Created by littledu on 15/5/3.
+ */
+var gulp = require('gulp');
+var replace = require('gulp-replace');
+
+module.exports = function(src, path, cb){
+ gulp.src(src)
+ .pipe(replace('../css/', path + '/dist/css/'))
+ .pipe(replace('../js/', path + '/dist/js/'))
+ .pipe(replace('../img/', path + '/dist/img/'))
+ .pipe(replace('../media/', path + '/dist/media/'))
+ .pipe(gulp.dest('./dist/html'))
+ .on('end', function(){
+ cb();
+ });
+}
diff --git a/tasks/common/webp.js b/tasks/common/webp.js
new file mode 100644
index 0000000..858a5ae
--- /dev/null
+++ b/tasks/common/webp.js
@@ -0,0 +1,92 @@
+/**
+ * Created by littledu on 15/5/2.
+ */
+var rd = require('rd');
+var gulp = require('gulp');
+var path = require('path');
+var async = require('async');
+var webp = require('gulp-webp');
+var rename = require('gulp-rename');
+var replace = require('gulp-replace');
+var util = require('./../lib/util');
+var fs = require('fs');
+
+module.exports = function (config, cb) {
+
+ var webpScript = '';
+
+ var webp_map = {}; //为了筛选webp而构建的对象
+ var img_arr = []; //筛选出来需要转换成 webp 的图片
+ var img_map = {}; //返回给全局作 preload 判断使用{"img_name": 1, "img_name": 0} 1 为可优化成 webp
+ var reg = null;
+
+ function render_webp(src){
+ if(!fs.existsSync(src)) return;
+
+ rd.eachFileSync(src, function (file, stats) {
+ var extname = path.extname(file);
+ var basename = path.basename(file, extname);
+ if (!(basename in webp_map)) {
+ webp_map[basename] = {};
+ webp_map[basename]['size'] = stats.size;
+ webp_map[basename]['extname'] = extname;
+ } else {
+ if ((webp_map[basename]['size'] > stats.size) && (extname === '.webp')) {
+ img_arr.push(basename + webp_map[basename]['extname']);
+ img_map[basename + webp_map[basename]['extname']] = 1;
+ } else {
+ img_map[basename + webp_map[basename]['extname']] = 0;
+ }
+ }
+ });
+ }
+
+ async.series([
+ function (cb) {
+ gulp.src('./dist/sprite/**/*')
+ .pipe(webp())
+ .pipe(gulp.dest('./dist/sprite'))
+ .on('end', cb);
+ },
+ function (cb) {
+ gulp.src('./dist/img/**/*')
+ .pipe(webp())
+ .pipe(gulp.dest('./dist/img'))
+ .on('end', cb);
+ },
+ //智能寻找 webp
+ function (cb) {
+ render_webp('./dist/img');
+ cb();
+ },
+ function (cb) {
+ render_webp('./dist/sprite');
+ reg = eval('/(' + img_arr.join('|') + ')/ig');
+ cb();
+ },
+ function (cb) {
+ gulp.src(['./dist/css/**/*.css', '!./dist/css/**/*.webp.css'])
+ .pipe(rename({suffix: '.webp'}))
+ .pipe(replace(reg, function (match) {
+ return match.substring(0, match.lastIndexOf('.')) + '.webp';
+ }))
+ .pipe(gulp.dest('./dist/css'))
+ .on('end', cb);
+ },
+ function (cb) {
+ var preload_script = '';
+
+ gulp.src('./dist/html/**/*.html')
+ .pipe(replace('data-href', 'href'))
+ .pipe(replace(/(link.*?)href/ig, '$1data-href'))
+ .pipe(replace('', webpScript))
+ .pipe(replace('', preload_script))
+ .pipe(gulp.dest('./dist/html'))
+ .on('end', cb);
+ }
+
+ ], function () {
+ util.task_log('task_webp');
+ cb();
+ })
+}
diff --git a/tasks/index.js b/tasks/index.js
new file mode 100644
index 0000000..c0aa1b6
--- /dev/null
+++ b/tasks/index.js
@@ -0,0 +1,14 @@
+var fs = require('fs');
+var path = require('path');
+var config = require('rc')('tmtworkflow', {
+ projectName: process.cwd().split(path.sep).pop()
+});
+
+module.exports = function (gulp) {
+ fs.readdirSync(__dirname).filter(function (file) {
+ return (file.indexOf(".") !== 0) && (file.indexOf('task_') === 0);
+ }).forEach(function (file) {
+ var registerTask = require(path.join(__dirname, file));
+ registerTask(gulp, config);
+ });
+};
diff --git a/tasks/lib/util.js b/tasks/lib/util.js
new file mode 100644
index 0000000..f136191
--- /dev/null
+++ b/tasks/lib/util.js
@@ -0,0 +1,45 @@
+var async = require('async');
+var util = require('gulp-util');
+var path = require('path');
+var fs = require('fs');
+var config = require('rc')('tmtworkflow', {
+ projectName: process.cwd().split(path.sep).pop()
+});
+
+var tmt_util = {
+ log: function () {
+ util.log.apply(util, arguments);
+ },
+ task_log: function (task_name) {
+ this.log(util.colors.magenta(task_name), util.colors.green.bold('√'));
+ },
+ load_plugin: function (name, cb) {
+ name = name + '_after';
+
+ if (config['plugins'] && config['plugins'][name].length) {
+ var plugins = config['plugins'][name];
+
+ async.every(plugins, function (plugin, cb) {
+ if (plugin.indexOf('.js') === -1) {
+ plugin += '.js';
+ }
+
+ var filepath = path.resolve(__dirname, '../plugins', plugin);
+
+ if (fs.existsSync(filepath)) {
+ require(filepath)(config);
+ cb()
+ } else {
+ cb();
+ }
+ }, function () {
+ if(typeof cb === 'function'){
+ cb();
+ }
+ });
+ }
+ },
+ colors: util.colors
+};
+
+module.exports = tmt_util;
diff --git a/tasks/task_build_dev.js b/tasks/task_build_dev.js
new file mode 100644
index 0000000..4753867
--- /dev/null
+++ b/tasks/task_build_dev.js
@@ -0,0 +1,143 @@
+var async = require('async');
+var _ = require('lodash');
+var copy = require('gulp-copy');
+var less = require('gulp-less');
+var ejs = require('gulp-ejs');
+var watch = require('gulp-watch');
+var ejshelper = require('tmt-ejs-helper');
+var util = require('./lib/util');
+var bs = require('browser-sync').create();
+
+module.exports = function (gulp, config) {
+ gulp.task('build_dev', function () {
+ async.parallel([
+ function(cb){
+ task_img(cb);
+ },
+ function(cb){
+ task_slice(cb);
+ },
+ function(cb){
+ task_js(cb);
+ },
+ function(cb){
+ task_media(cb);
+ },
+ function(cb){
+ task_less(cb);
+ },
+ function(cb){
+ task_html(cb);
+ }
+ ], function(err){
+ if(err){
+ util.colors.red(err.message);
+ }else{
+ task_watch();
+
+ util.load_plugin('build_dev', function(){
+ if(config.livereload && config.livereload.available){
+ task_server();
+ }
+ });
+
+ }
+ });
+ });
+
+ function check_cb(cb){
+ if(typeof cb != 'function'){
+ cb = function(){};
+ }
+ return cb;
+ }
+
+ var task_img = function (cb) {
+ cb = check_cb(cb);
+ util.task_log('task_img');
+ gulp.src('./src/img/**/*').pipe(copy('./dev/', {prefix: 1})).on('end', cb);
+ };
+
+ var task_slice = function (cb) {
+ cb = check_cb(cb);
+ util.task_log('task_slice');
+ gulp.src('./src/slice/**/*').pipe(copy('./dev/', {prefix: 1})).on('end', cb);
+ };
+
+ var task_js = function (cb) {
+ cb = check_cb(cb);
+ util.task_log('task_js');
+ gulp.src('./src/js/**/*').pipe(copy('./dev/', {prefix: 1})).on('end', cb);
+ };
+
+ var task_media = function (cb) {
+ cb = check_cb(cb);
+ util.task_log('task_media');
+ gulp.src('./src/media/**/*').pipe(copy('./dev/', {prefix: 1})).on('end', cb);
+ };
+
+ var task_less = function (cb) {
+ cb = check_cb(cb);
+ util.task_log('task_less');
+ gulp.src('./src/css/style-*.less')
+ .pipe(less().on('error', function (error) {
+ util.log(util.colors.red(error.message));
+ }))
+ .pipe(gulp.dest('./dev/css/'))
+ .on('end', cb);
+ };
+
+ var task_html = function (cb) {
+ cb = check_cb(cb);
+ util.task_log('task_html');
+ gulp.src(['./src/html/**/*.html', '!./src/html/_*/**.html'])
+ .pipe(ejs(ejshelper()).on('error', function (error) {
+ util.log(util.colors.red(error.message));
+ }))
+ .pipe(gulp.dest('./dev/html/'))
+ .on('end', cb);
+ };
+
+ var task_server = function () {
+ bs.init({
+ server: './dev',
+ port: config['livereload']['port'] || 8080,
+ startPath: config['livereload']['startPath'] || '/html',
+ reloadDelay: 500,
+ files: ['./dev/css/style-*.css', './src/html/**/*.*']
+ });
+ };
+
+ var task_watch = function () {
+
+ watch('./src/img/**/*', {verbose: true}, function () {
+ task_img();
+ });
+
+ watch('./src/slice/**/*', {verbose: true}, function () {
+ task_slice();
+ });
+
+ watch('./src/js/**/*', {verbose: true}, function () {
+ task_js();
+ });
+
+ watch('./src/media/**/*', {verbose: true}, function () {
+ task_media();
+ });
+
+ watch('./src/css/**/*', {verbose: true}, function () {
+ task_less();
+ config.livereload && bs.reload();
+ });
+
+ watch('./src/html/**/*.html', {verbose: true}, function () {
+ task_html();
+ config.livereload && bs.reload();
+ });
+
+ util.log('Watching...');
+
+ };
+
+};
diff --git a/tasks/task_build_dist.js b/tasks/task_build_dist.js
new file mode 100644
index 0000000..8bee59c
--- /dev/null
+++ b/tasks/task_build_dist.js
@@ -0,0 +1,114 @@
+var async = require('async');
+var util = require('./lib/util');
+var copy = require('gulp-copy');
+var less = require('gulp-less');
+var ejs = require('gulp-ejs');
+var ejshelper = require('tmt-ejs-helper');
+var minifyCSS = require('gulp-minify-css');
+var tmtsprite = require('gulp-tmtsprite');
+var gulpif = require('gulp-if');
+var imagemin = require('gulp-imagemin');
+var usemin = require('gulp-usemin2');
+var uglify = require('gulp-uglify');
+var del = require('del');
+var webp = require('./common/webp');
+
+module.exports = function (gulp, config) {
+
+ //build_dist
+ gulp.task('build_dist', function (cb) {
+
+ async.series([
+ function (cb) {
+ del(['./dist'], cb);
+ },
+ function (cb) {
+
+ gulp.src('./src/css/style-*.less')
+ .pipe(less())
+ .pipe(minifyCSS({advanced: false}))
+ .pipe(tmtsprite())
+ .pipe(gulpif('*.png', gulp.dest('./dist/sprite/').on('end', function () {
+ end();
+ }), gulp.dest('./dist/css/').on('end', function () {
+ end();
+ })));
+
+ var i = 0;
+
+ function end() {
+ i++;
+ if (i >= 2) {
+ util.task_log('task_less');
+ util.task_log('task_sprite');
+ cb();
+ }
+ }
+
+ },
+ function (cb) {
+ gulp.src('./src/img/**/*')
+ .pipe(imagemin())
+ .pipe(gulp.dest('./dist/img'))
+ .on('end', function () {
+ util.task_log('task_imagemin');
+ cb();
+ })
+ },
+
+ function (cb) {
+ gulp.src('./dist/sprite/**/*')
+ .pipe(imagemin())
+ .pipe(gulp.dest('./dist/sprite'))
+ .on('end', function () {
+ util.task_log('task_spritemin');
+ cb();
+ });
+ },
+
+ function (cb) {
+ gulp.src('./src/media/**/*')
+ .pipe(copy('./dist/', {prefix: 1}))
+ .on('end', function () {
+ util.task_log('task_media');
+ cb();
+ });
+ },
+ function (cb) {
+ gulp.src('./src/js/**/*')
+ .pipe(uglify())
+ .pipe(gulp.dest('./dist/js'))
+ .on('end', function () {
+ util.task_log('task_js');
+ cb();
+ });
+ },
+ function (cb) {
+
+ gulp.src(['./src/html/**/*.html', '!./src/html/_*/**/*.html'])
+ .pipe(ejs(ejshelper()))
+ .pipe(usemin({
+ jsmin: uglify()
+ }))
+ .pipe(gulp.dest('./dist/html'))
+ .on('end', function () {
+ util.task_log('task_ejs');
+ util.task_log('task_jsmin');
+ cb();
+ });
+ },
+ function (cb) {
+ if (config['support_webp']) {
+ webp(config, cb);
+ } else {
+ cb();
+ }
+ }
+
+ ], function () {
+ util.load_plugin('build_dist');
+ cb(null);
+ })
+ });
+};
+
diff --git a/tasks/task_zip.js b/tasks/task_zip.js
new file mode 100644
index 0000000..2e822a2
--- /dev/null
+++ b/tasks/task_zip.js
@@ -0,0 +1,15 @@
+var zip = require('gulp-zip');
+var util = require('./lib/util');
+
+module.exports = function (gulp, config) {
+
+ gulp.task('zip', ['build_dist'], function (cb) {
+ gulp.src('./dist/**/*')
+ .pipe(zip('dist.zip'))
+ .pipe(gulp.dest('./'))
+ .on('end', function () {
+ util.load_plugin('zip');
+ cb();
+ });
+ });
+};
+