"use strict";
// 基类
const Hook = require("./Hook");
const HookCodeFactory = require("./HookCodeFactory");

class SyncHookCodeFactory extends HookCodeFactory {
	content({ onError, onResult, onDone, rethrowIfPossible }) {
		return this.callTapsSeries({
			onError: (i, err) => onError(err),
			onDone,
			rethrowIfPossible
		});
	}
}

const factory = new SyncHookCodeFactory();

class SyncHook extends Hook {
    // 未提供的方法直接抛出异常提示
	tapAsync() {
		throw new Error("tapAsync is not supported on a SyncHook");
	}

	tapPromise() {
		throw new Error("tapPromise is not supported on a SyncHook");
	}
    // 为调用方法call、callAsync、promise提供依赖
	compile(options) {
		factory.setup(this, options);
		return factory.create(options);
	}
}

module.exports = SyncHook;

"use strict";

const util = require("util");
//  抛出警告
const deprecateContext = util.deprecate(() => {},
"Hook.context is deprecated and will be removed");

class Hook {
	constructor(args = []) {
        // 参数们
		this._args = args;
        // 类似监听模式下的队列
		this.taps = [];
        // 拦截器
		this.interceptors = [];
        // 初始化相关调用方法
		this.call = this._call;
		this.promise = this._promise;
		this.callAsync = this._callAsync;
        // 自定义的方法队列
		this._x = undefined;
	}

	compile(options) {
        // 必须重写compile方法
		throw new Error("Abstract: should be overriden");
	}
    // 用于创建相关调用方法的私有方法
	_createCall(type) {
        // 被重写的compile方法
		return this.compile({
			taps: this.taps,
			interceptors: this.interceptors,
			args: this._args,
			type: type
		});
	}

	_tap(type, options, fn) {
        //   参数处理
		if (typeof options === "string") {
			options = {
				name: options
			};
		} else if (typeof options !== "object" || options === null) {
			throw new Error("Invalid tap options");
		}
		if (typeof options.name !== "string" || options.name === "") {
			throw new Error("Missing name for tap");
		}
		if (typeof options.context !== "undefined") {
			deprecateContext();
		}
		options = Object.assign({ type, fn }, options);
        // 拦截器
		options = this._runRegisterInterceptors(options);
		this._insert(options);
	}

	tap(options, fn) {
		this._tap("sync", options, fn);
	}

	tapAsync(options, fn) {
		this._tap("async", options, fn);
	}

	tapPromise(options, fn) {
		this._tap("promise", options, fn);
	}
    // 拦截器
	_runRegisterInterceptors(options) {
		for (const interceptor of this.interceptors) {
			if (interceptor.register) {
				const newOptions = interceptor.register(options);
				if (newOptions !== undefined) {
					options = newOptions;
				}
			}
		}
		return options;
	}

	withOptions(options) {
		const mergeOptions = opt =>
			Object.assign({}, options, typeof opt === "string" ? { name: opt } : opt);

		// Prevent creating endless prototype chains
		options = Object.assign({}, options, this._withOptions);
		const base = this._withOptionsBase || this;
		const newHook = Object.create(base);

		newHook.tap = (opt, fn) => base.tap(mergeOptions(opt), fn);
		newHook.tapAsync = (opt, fn) => base.tapAsync(mergeOptions(opt), fn);
		newHook.tapPromise = (opt, fn) => base.tapPromise(mergeOptions(opt), fn);
		newHook._withOptions = options;
		newHook._withOptionsBase = base;
		return newHook;
	}

	isUsed() {
		return this.taps.length > 0 || this.interceptors.length > 0;
	}

	intercept(interceptor) {
		this._resetCompilation();
		this.interceptors.push(Object.assign({}, interceptor));
		if (interceptor.register) {
			for (let i = 0; i < this.taps.length; i++) {
				this.taps[i] = interceptor.register(this.taps[i]);
			}
		}
	}

	_resetCompilation() {
		this.call = this._call;
		this.callAsync = this._callAsync;
		this.promise = this._promise;
	}

	_insert(item) {
		this._resetCompilation();
		let before;
		if (typeof item.before === "string") {
			before = new Set([item.before]);
		} else if (Array.isArray(item.before)) {
			before = new Set(item.before);
		}
		let stage = 0;
		if (typeof item.stage === "number") {
			stage = item.stage;
		}
		let i = this.taps.length;
		while (i > 0) {
			i--;
			const x = this.taps[i];
			this.taps[i + 1] = x;
			const xStage = x.stage || 0;
			if (before) {
				if (before.has(x.name)) {
					before.delete(x.name);
					continue;
				}
				if (before.size > 0) {
					continue;
				}
			}
			if (xStage > stage) {
				continue;
			}
			i++;
			break;
		}
		this.taps[i] = item;
	}
}

function createCompileDelegate(name, type) {
	return function lazyCompileHook(...args) {
		this[name] = this._createCall(type);
		return this[name](...args);
	};
}

Object.defineProperties(Hook.prototype, {
	_call: {
		value: createCompileDelegate("call", "sync"),
		configurable: true,
		writable: true
	},
	_callAsync: {
		value: createCompileDelegate("callAsync", "async"),
		configurable: true,
		writable: true
	},
	_promise: {
		value: createCompileDelegate("promise", "promise"),
		configurable: true,
		writable: true
	}
});

module.exports = Hook;

"use strict";

class HookCodeFactory {
	constructor(config) {
		this.config = config;
		this.options = undefined;
		this._args = undefined;
	}
    // 创建相关的方法体，对不同的type进行判断
    // Fcuntion接受任意个参数，除最后一个，之前的都是函数的形参
	create(options) {
		this.init(options);
		let fn;
		switch (this.options.type) {
			case "sync":
				fn = new Function(
					this.args(),
					'"use strict";\n' +
						this.header() +
						this.content({
							onError: err => `throw ${err};\n`,
							onResult: result => `return ${result};\n`,
							onDone: () => {
								console.log('完成函数');
							},
							rethrowIfPossible: true
						})
				);
				break;
			case "async":
				fn = new Function(
					this.args({
						after: "_callback"
					}),
					'"use strict";\n' +
						this.header() +
						this.content({
							onError: err => `_callback(${err});\n`,
							onResult: result => `_callback(null, ${result});\n`,
							onDone: () => "_callback();\n"
						})
				);
				break;
			case "promise":
				let code = "";
				code += '"use strict";\n';
				code += "return new Promise((_resolve, _reject) => {\n";
				code += "var _sync = true;\n";
				code += this.header();
				code += this.content({
					onError: err => {
						let code = "";
						code += "if(_sync)\n";
						code += `_resolve(Promise.resolve().then(() => { throw ${err}; }));\n`;
						code += "else\n";
						code += `_reject(${err});\n`;
						return code;
					},
					onResult: result => `_resolve(${result});\n`,
					onDone: () => "_resolve();\n"
				});
				code += "_sync = false;\n";
				code += "});\n";
				fn = new Function(this.args(), code);
				break;
		}
		this.deinit();
		return fn;
	}
    // 设置Hook中的_x变量
	setup(instance, options) {
		instance._x = options.taps.map(t => t.fn);
	}

	/**
	 * @param {{ type: "sync" | "promise" | "async", taps: Array<Tap>, interceptors: Array<Interceptor> }} options
	 */
	init(options) {
		this.options = options;
		this._args = options.args.slice();
	}

	deinit() {
		this.options = undefined;
		this._args = undefined;
	}
    // 创建函数顶部内容
	header() {
		let code = "";
		if (this.needContext()) {
			code += "var _context = {};\n";
		} else {
			code += "var _context;\n";
		}
		code += "var _x = this._x;\n";
		if (this.options.interceptors.length > 0) {
			code += "var _taps = this.taps;\n";
			code += "var _interceptors = this.interceptors;\n";
		}
		for (let i = 0; i < this.options.interceptors.length; i++) {
			const interceptor = this.options.interceptors[i];
			if (interceptor.call) {
				code += `${this.getInterceptor(i)}.call(${this.args({
					before: interceptor.context ? "_context" : undefined
				})});\n`;
			}
		}
		return code;
	}

	needContext() {
		for (const tap of this.options.taps) if (tap.context) return true;
		return false;
	}

	callTap(tapIndex, { onError, onResult, onDone, rethrowIfPossible }) {
		let code = "";
		let hasTapCached = false;
		for (let i = 0; i < this.options.interceptors.length; i++) {
			const interceptor = this.options.interceptors[i];
			if (interceptor.tap) {
				if (!hasTapCached) {
					code += `var _tap${tapIndex} = ${this.getTap(tapIndex)};\n`;
					hasTapCached = true;
				}
				code += `${this.getInterceptor(i)}.tap(${
					interceptor.context ? "_context, " : ""
				}_tap${tapIndex});\n`;
			}
		}
		code += `var _fn${tapIndex} = ${this.getTapFn(tapIndex)};\n`;
		const tap = this.options.taps[tapIndex];
		switch (tap.type) {
			case "sync":
				if (!rethrowIfPossible) {
					code += `var _hasError${tapIndex} = false;\n`;
					code += "try {\n";
				}
				if (onResult) {
					code += `var _result${tapIndex} = _fn${tapIndex}(${this.args({
						before: tap.context ? "_context" : undefined
					})});\n`;
				} else {
					code += `_fn${tapIndex}(${this.args({
						before: tap.context ? "_context" : undefined
					})});\n`;
				}
				if (!rethrowIfPossible) {
					code += "} catch(_err) {\n";
					code += `_hasError${tapIndex} = true;\n`;
					code += onError("_err");
					code += "}\n";
					code += `if(!_hasError${tapIndex}) {\n`;
				}
				if (onResult) {
					code += onResult(`_result${tapIndex}`);
				}
				if (onDone && onDone()) {
					code += onDone();
				}
				if (!rethrowIfPossible) {
					code += "}\n";
				}
				break;
			case "async":
				let cbCode = "";
				if (onResult) cbCode += `(_err${tapIndex}, _result${tapIndex}) => {\n`;
				else cbCode += `_err${tapIndex} => {\n`;
				cbCode += `if(_err${tapIndex}) {\n`;
				cbCode += onError(`_err${tapIndex}`);
				cbCode += "} else {\n";
				if (onResult) {
					cbCode += onResult(`_result${tapIndex}`);
				}
				if (onDone) {
					cbCode += onDone();
				}
				cbCode += "}\n";
				cbCode += "}";
				code += `_fn${tapIndex}(${this.args({
					before: tap.context ? "_context" : undefined,
					after: cbCode
				})});\n`;
				break;
			case "promise":
				code += `var _hasResult${tapIndex} = false;\n`;
				code += `var _promise${tapIndex} = _fn${tapIndex}(${this.args({
					before: tap.context ? "_context" : undefined
				})});\n`;
				code += `if (!_promise${tapIndex} || !_promise${tapIndex}.then)\n`;
				code += `  throw new Error('Tap function (tapPromise) did not return promise (returned ' + _promise${tapIndex} + ')');\n`;
				code += `_promise${tapIndex}.then(_result${tapIndex} => {\n`;
				code += `_hasResult${tapIndex} = true;\n`;
				if (onResult) {
					code += onResult(`_result${tapIndex}`);
				}
				if (onDone) {
					code += onDone();
				}
				code += `}, _err${tapIndex} => {\n`;
				code += `if(_hasResult${tapIndex}) throw _err${tapIndex};\n`;
				code += onError(`_err${tapIndex}`);
				code += "});\n";
				break;
		}
		return code;
	}
    // 创建call函数内容
	callTapsSeries({ onError, onResult, onDone, rethrowIfPossible }) {
		if (this.options.taps.length === 0) return onDone();
		const firstAsync = this.options.taps.findIndex(t => t.type !== "sync");
		const next = i => {
			if (i >= this.options.taps.length) {
				return onDone();
			}
			const done = () => next(i + 1);
			const doneBreak = skipDone => {
				if (skipDone) return "";
				return onDone();
			};
			return this.callTap(i, {
				onError: error => onError(i, error, done, doneBreak),
				onResult:
					onResult &&
					(result => {
						return onResult(i, result, done, doneBreak);
					}),
				onDone:
					!onResult &&
					(() => {
						return done();
					}),
				rethrowIfPossible:
					rethrowIfPossible && (firstAsync < 0 || i < firstAsync)
			});
		};
		return next(0);
	}


	args({ before, after } = {}) {
		let allArgs = this._args;
		if (before) allArgs = [before].concat(allArgs);
		if (after) allArgs = allArgs.concat(after);
		if (allArgs.length === 0) {
			return "";
		} else {
			return allArgs.join(", ");
		}
	}

	getTapFn(idx) {
		return `_x[${idx}]`;
	}

	getTap(idx) {
		return `_taps[${idx}]`;
	}

	getInterceptor(idx) {
		return `_interceptors[${idx}]`;
	}
}

module.exports = HookCodeFactory;

// math.js
export function add(a, b) {
    console.log("add");
    return a + b;
}

export function minus(a, b) {
    console.log("minus");
    return a - b;
}

export function multiply(a, b) {
    console.log("multiply");
    return a * b;
}

export function divide(a, b) {
    console.log("divide");
    return a / b;
}

// index.js
import { add } from "./math";

add(1, 2);

var myDynamicModule;

if (condition) {
    myDynamicModule = require("foo");
} else {
    myDynamicModule = require("bar");
}

// not work
if (condition) {
    import foo from "foo";
} else {
    import bar from "bar";
}

import foo from "foo";
import bar from "bar";

if (condition) {
    // do stuff with foo
} else {
    // do stuff with bar
}

import { add, multiply } from "./mathUtils";

add(1, 2);

// myInfo.js
export const myInfo = {
    name: "Ire Aderinokun",
    birthday: "2 March"
}

import { myInfo } from "./myInfo.js";

console.log(myInfo.name);

// myClass.js
class MyClass {}

MyClass.prototype.saySome = function () {} // 副作用

// 扩展数据的方法
Array.prototype.unique = function () {}

export default MyClass

import MyClass from './myClass';

console.log('index');

let a = 'a';
a += 'rr';
a += 'ay';

module.exports = {
    ...,
    mode: "production",
    ...,
};

<picture>
    <source type="image/webp" srcset="image.webp">
    <source type="image/jpeg" srcset="image.jpg">
    <img src="image.jpg" alt="My Image">
</picture>

var isSupportWebp = !![].map && document.createElement('canvas').toDataURL('image/webp').indexOf('data:image/webp') == 0;

console.log(isSupportWebp);

window.isSupportWebp = false;//是否支持
(function() {
    var img = new Image(); 
    function getResult(event) {
        //如果进入加载且图片宽度为1(通过图片宽度值判断图片是否可以显示)
        window.isSupportWebp = event && event.type === 'load' ? img.width == 1 : false;
    }
    img.onerror = getResult;
    img.onload = getResult;
    // 如果可以在那么则支持
    img.src = 'data:image/webp;base64,UklGRiQAAABXRUJQVlA4IBgAAAAwAQCdASoBAAEAAwA0JaQAA3AA/vuUAAA=';

  (function(modules) {
    // 缓存对象
    var installedModules = {};

    // require方法
    function __webpack_require__(moduleId) {
        // 是否命中缓存
        if (installedModules[moduleId]) {
            return installedModules[moduleId].exports;
        }
        // 新建 + 缓存
        var module = (installedModules[moduleId] = {
            i: moduleId,
            l: false,
            exports: {}
        });

        // 执行module方法
        modules[moduleId].call(
            module.exports,
            module,
            module.exports,
            __webpack_require__
        );

        // 标志是否已加载模块，之后缓存里会走
        module.l = true;

        return module.exports;
    }

    // expose the modules object (__webpack_modules__)
    __webpack_require__.m = modules;

    // expose the module cache
    __webpack_require__.c = installedModules;


    // 设置commonjs导出的对象上的a的值
    __webpack_require__.d = function(exports, name, getter) {
        if (!__webpack_require__._hasOwnProperty(exports, name)) {
            // 利用 getter 可以通过a获取到module的值
            Object.defineProperty(exports, name, {
                enumerable: true,
                get: getter
            });
        }
    };

    // 定义 __esModule 标志
    __webpack_require__.r = function(exports) {
        if (typeof Symbol !== 'undefined' && Symbol.toStringTag) {
            Object.defineProperty(exports, Symbol.toStringTag, {
                value: 'Module'
            });
        }
        Object.defineProperty(exports, '__esModule', {value: true});
    };

    // 适配commonjs规范
    // 导出的为 require.a => 执行 getter函数 获得导出的内容
    __webpack_require__.n = function(module) {
        var getter =
            module && module.__esModule
                ? function getDefault() {
                      return module['default'];
                  }
                : function getModuleExports() {
                      return module;
                  };
        __webpack_require__.d(getter, 'a', getter);
        return getter;
    };

    // Object.prototype.hasOwnProperty.call
    __webpack_require__._hasOwnProperty = function(object, property) {
        return Object.prototype.hasOwnProperty.call(object, property);
    };
})({})

// es6.js
export default {
    type: 'esjs'
}

// commonjs.js
module.exports = {
    type: 'commonjs'
}

// index.js
import es6 from './es6';
import conmon from './commonjs';

console.log(require('./es6'));
console.log(es6, 'import来的');

console.log(require('./commonjs'));
console.log(conmon, 'import来的');

// bundle.js

(function(modules){
// ******
// 巴拉巴拉
// ******
    // Load entry module and return exports
    return __webpack_require__((__webpack_require__.s = './index.js'));
})({
    './commonjs.js': function(module, exports) {
        module.exports = {type: 'commonjs'};
    },
    './es6.js': function(module, __webpack_exports__, __webpack_require__) {
        __webpack_require__.r(__webpack_exports__);
        
        // 相当于 module.exports.default，这就是为什么我们require的时候，需要加上 .default
        __webpack_exports__['default'] = {
            type: 'esjs'
        };
    },
    './index.js': function(module, __webpack_exports__, __webpack_require__) {
        __webpack_require__.r(__webpack_exports__);
        var es6FromImport = __webpack_require__('./es6.js');
        var commonjsFromImport = __webpack_require__(
            './commonjs.js'
        );
        var commonjsFromImport_default = __webpack_require__.n(
            commonjsFromImport
        );
        console.log(__webpack_require__('./es6.js'));
        console.log(es6FromImport['default'], 'import来的');

        console.log(__webpack_require__('./commonjs.js'));
        console.log(
            commonjsFromImport_default.a,
            'import来的'
        );
    }
})

// 新建
var module = (installedModules[moduleId] = {
    i: moduleId,
    l: false,
    exports: {} 
});

// 赋值
modules[moduleId].call(
    module.exports,
    module,
    module.exports,
    __webpack_require__
);

// 导出
return module.exports;

// 赋值 __esModule
__webpack_require__.r(__webpack_exports__);
__webpack_exports__['default'] = {
    type: 'esjs'
};

module.exports = { type: 'commonjs' }

// require
var commonjsFromImport = __webpack_require__('./commonjs.js');
// 设置getter
var commonjsFromImport_default = __webpack_require__.n(commonjsFromImport);

console.log(commonjsFromImport_default.a, 'import来的');

const Koa = require('koa');
const KoaBody = require('koa-body');
const fs = require('fs');
const path = require('path');
const glob = require('glob');

const baseDate = {
    visitCount: 1,
    date: undefined,
    info: ''
};

const app = new Koa();

app.use(KoaBody());

app.use(async ctx => {
    // 更新资源
    if (ctx.req.url === '/updateInfo' && ctx.req.method === 'POST') {
        const session = require('./session.json');
        session.info = ctx.request.body.info;
        await writeFile('session.json', JSON.stringify(session));
        ctx.body = {
            code: 1
        };
    }

    const imgType = glob
        .sync('*.+(jpg|png)')
        .map(file => path.resolve('/', file));

    if ((fileIndex = imgType.indexOf(ctx.req.url)) !== -1) {
        const res = ctx.response;
        const req = ctx.req;
        res.type = path.extname(imgType[fileIndex]).slice(1);
        const filePath = path.join('./', imgType[fileIndex]);
        res.set('cache-control', 'public, max-age=0');

        let session;
        try {
            session = require('./session.json');
        } catch (e) {
            session = {...baseDate};
            session.date = new Date().toLocaleString();
            await writeFile('session.json', JSON.stringify(session));
        } finally {
            // use force refresh to clear etag, because if serve set etag,
            // browser will carry if-none-match field in request header. and we can use if-none-match to judge somethine
            // etag 大文件一般用文件大小 + 修改时间 来生成，而不是读取文件内容
            md5 = convertMd5(JSON.stringify(session));
            res.etag = md5;
            if (req.headers['if-none-match']) {
                // console.log('缓存');
                session.visitCount = +session.visitCount + 1;
                session.date = new Date().toLocaleString();
                await writeFile('./session.json', JSON.stringify(session));
                res.status = 304;
            } else {
                // console.log('清除缓存');
                session.visitCount = 1;
                session.date = new Date().toLocaleString();
                session.info = '';
                await writeFile('./session.json', JSON.stringify(session));
                ctx.body = fs.createReadStream(filePath);
            }
        }
    }
});

app.listen(3000);