@mx-space/api-client 0.3.6 → 0.4.2

package/build/index.esm.js

@@ -1,946 +1,998 @@
-var mapObj$1 = {exports: {}};
-
-const isObject$1 = value => typeof value === 'object' && value !== null;
-const mapObjectSkip = Symbol('skip');
-
-// Customized for this use-case
-const isObjectCustom = value =>
-	isObject$1(value) &&
-	!(value instanceof RegExp) &&
-	!(value instanceof Error) &&
-	!(value instanceof Date);
-
-const mapObject = (object, mapper, options, isSeen = new WeakMap()) => {
-	options = {
-		deep: false,
-		target: {},
-		...options
-	};
-
-	if (isSeen.has(object)) {
-		return isSeen.get(object);
-	}
-
-	isSeen.set(object, options.target);
-
-	const {target} = options;
-	delete options.target;
-
-	const mapArray = array => array.map(element => isObjectCustom(element) ? mapObject(element, mapper, options, isSeen) : element);
-	if (Array.isArray(object)) {
-		return mapArray(object);
-	}
-
-	for (const [key, value] of Object.entries(object)) {
-		const mapResult = mapper(key, value, object);
-
-		if (mapResult === mapObjectSkip) {
-			continue;
-		}
-
-		let [newKey, newValue, {shouldRecurse = true} = {}] = mapResult;
-
-		// Drop `__proto__` keys.
-		if (newKey === '__proto__') {
-			continue;
-		}
-
-		if (options.deep && shouldRecurse && isObjectCustom(newValue)) {
-			newValue = Array.isArray(newValue) ?
-				mapArray(newValue) :
-				mapObject(newValue, mapper, options, isSeen);
-		}
-
-		target[newKey] = newValue;
-	}
-
-	return target;
-};
-
-mapObj$1.exports = (object, mapper, options) => {
-	if (!isObject$1(object)) {
-		throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
-	}
-
-	return mapObject(object, mapper, options);
+const isPlainObject = (obj) => typeof obj === 'object' &&
+    Object.prototype.toString.call(obj) === '[object Object]';
+const sortOrderToNumber = (order) => {
+    return ({
+        asc: 1,
+        desc: -1,
+    }[order] || 1);
 };
-
-mapObj$1.exports.mapObjectSkip = mapObjectSkip;
-
-var camelcase = {exports: {}};
-
-const preserveCamelCase = (string, locale) => {
-	let isLastCharLower = false;
-	let isLastCharUpper = false;
-	let isLastLastCharUpper = false;
-
-	for (let i = 0; i < string.length; i++) {
-		const character = string[i];
-
-		if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
-			string = string.slice(0, i) + '-' + string.slice(i);
-			isLastCharLower = false;
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper = true;
-			i++;
-		} else if (isLastCharUpper && isLastLastCharUpper && /[\p{Ll}]/u.test(character)) {
-			string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper = false;
-			isLastCharLower = true;
-		} else {
-			isLastCharLower = character.toLocaleLowerCase(locale) === character && character.toLocaleUpperCase(locale) !== character;
-			isLastLastCharUpper = isLastCharUpper;
-			isLastCharUpper = character.toLocaleUpperCase(locale) === character && character.toLocaleLowerCase(locale) !== character;
-		}
-	}
-
-	return string;
+const destructureData = (payload) => {
+    if (typeof payload !== 'object') {
+        return payload;
+    }
+    if (payload === null) {
+        return payload;
+    }
+    const data = payload.data;
+    const dataIsPlainObject = Object.prototype.toString.call(data) === '[object Object]';
+    if (dataIsPlainObject && Object.keys(payload).length === 1) {
+        const d = Object.assign({}, data);
+        // attach raw onto new data
+        attachRawFromOneToAnthor(payload, d);
+        return d;
+    }
+    return payload;
 };
-
-const preserveConsecutiveUppercase = input => {
-	return input.replace(/^[\p{Lu}](?![\p{Lu}])/gu, m1 => m1.toLowerCase());
+const attachRawFromOneToAnthor = (from, to) => {
+    if (!from) {
+        return;
+    }
+    from.$raw &&
+        Object.defineProperty(to, '$raw', {
+            value: Object.assign({}, from.$raw),
+            enumerable: false,
+        });
+    from.$request &&
+        Object.defineProperty(to, '$request', {
+            value: Object.assign({}, from.$request),
+            enumerable: false,
+        });
 };
 
-const postProcess = (input, options) => {
-	return input.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toLocaleUpperCase(options.locale))
-		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toLocaleUpperCase(options.locale));
+// @ts-nocheck
+// @copy: https://github.com/sindresorhus/auto-bind/blob/main/index.js
+// Gets all non-builtin properties up the prototype chain.
+const getAllProperties = (object) => {
+    const properties = new Set();
+    do {
+        for (const key of Reflect.ownKeys(object)) {
+            properties.add([object, key]);
+        }
+    } while ((object = Reflect.getPrototypeOf(object)) &&
+        object !== Object.prototype);
+    return properties;
 };
+function autoBind(self, { include, exclude } = {}) {
+    const filter = (key) => {
+        const match = (pattern) => typeof pattern === 'string' ? key === pattern : pattern.test(key);
+        if (include) {
+            return include.some(match);
+        }
+        if (exclude) {
+            return !exclude.some(match);
+        }
+        return true;
+    };
+    for (const [object, key] of getAllProperties(self.constructor.prototype)) {
+        if (key === 'constructor' || !filter(key)) {
+            continue;
+        }
+        const descriptor = Reflect.getOwnPropertyDescriptor(object, key);
+        if (descriptor && typeof descriptor.value === 'function') {
+            self[key] = self[key].bind(self);
+        }
+    }
+    return self;
+}
 
-const camelCase$1 = (input, options) => {
-	if (!(typeof input === 'string' || Array.isArray(input))) {
-		throw new TypeError('Expected the input to be `string | string[]`');
-	}
-
-	options = {
-		pascalCase: false,
-		preserveConsecutiveUppercase: false,
-		...options
-	};
-
-	if (Array.isArray(input)) {
-		input = input.map(x => x.trim())
-			.filter(x => x.length)
-			.join('-');
-	} else {
-		input = input.trim();
-	}
-
-	if (input.length === 0) {
-		return '';
-	}
-
-	if (input.length === 1) {
-		return options.pascalCase ? input.toLocaleUpperCase(options.locale) : input.toLocaleLowerCase(options.locale);
-	}
-
-	const hasUpperCase = input !== input.toLocaleLowerCase(options.locale);
-
-	if (hasUpperCase) {
-		input = preserveCamelCase(input, options.locale);
-	}
-
-	input = input.replace(/^[_.\- ]+/, '');
-
-	if (options.preserveConsecutiveUppercase) {
-		input = preserveConsecutiveUppercase(input);
-	} else {
-		input = input.toLocaleLowerCase();
-	}
-
-	if (options.pascalCase) {
-		input = input.charAt(0).toLocaleUpperCase(options.locale) + input.slice(1);
-	}
-
-	return postProcess(input, options);
-};
+class AggregateController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'aggregate';
+        this.name = 'aggregate';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    /**
+     * 获取聚合数据
+     */
+    getAggregateData() {
+        return this.proxy.get();
+    }
+    /**
+     * 获取最新发布的内容
+     */
+    getTop(size = 5) {
+        return this.proxy.top.get({ params: { size } });
+    }
+    getTimeline(options) {
+        const { sort, type, year } = options || {};
+        return this.proxy.timeline.get({
+            params: {
+                sort: sort && sortOrderToNumber(sort),
+                type,
+                year,
+            },
+        });
+    }
+    /**
+     * 获取聚合数据统计
+     */
+    getStat() {
+        return this.proxy.stat.get();
+    }
+}
 
-camelcase.exports = camelCase$1;
-// TODO: Remove this for the next major release
-camelcase.exports.default = camelCase$1;
+class RequestError extends Error {
+    constructor(message, status, path, raw) {
+        super(message);
+        this.status = status;
+        this.path = path;
+        this.raw = raw;
+    }
+}
 
-class QuickLRU {
-	constructor(options = {}) {
-		if (!(options.maxSize && options.maxSize > 0)) {
-			throw new TypeError('`maxSize` must be a number greater than 0');
-		}
+var CategoryType;
+(function (CategoryType) {
+    CategoryType[CategoryType["Category"] = 0] = "Category";
+    CategoryType[CategoryType["Tag"] = 1] = "Tag";
+})(CategoryType || (CategoryType = {}));
 
-		this.maxSize = options.maxSize;
-		this.onEviction = options.onEviction;
-		this.cache = new Map();
-		this.oldCache = new Map();
-		this._size = 0;
-	}
+class CategoryController {
+    constructor(client) {
+        this.client = client;
+        this.name = 'category';
+        this.base = 'categories';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    getAllCategories() {
+        return this.proxy.get({
+            params: {
+                type: CategoryType.Category,
+            },
+        });
+    }
+    getAllTags() {
+        return this.proxy.get({
+            params: {
+                type: CategoryType.Tag,
+            },
+        });
+    }
+    async getCategoryDetail(ids) {
+        if (typeof ids === 'string') {
+            const data = await this.proxy.get({
+                params: {
+                    ids: ids,
+                },
+            });
+            const result = Object.values(data.entries)[0];
+            attachRawFromOneToAnthor(data, result);
+            return result;
+        }
+        else if (Array.isArray(ids)) {
+            const data = await this.proxy.get({
+                params: {
+                    ids: ids.join(','),
+                },
+            });
+            const entries = data === null || data === void 0 ? void 0 : data.entries;
+            if (!entries) {
+                throw new RequestError('data structure error', 500, data.$request.path, data);
+            }
+            const map = new Map(Object.entries(entries).map(([id, value]) => [id.toLowerCase(), value]));
+            attachRawFromOneToAnthor(data, map);
+            return map;
+        }
+    }
+    async getCategoryByIdOrSlug(idOrSlug) {
+        const res = await this.proxy(idOrSlug).get();
+        return destructureData(res);
+    }
+    async getTagByName(name) {
+        const res = await this.proxy(name).get({
+            params: {
+                tag: 1,
+            },
+        });
+        return res;
+    }
+}
 
-	_set(key, value) {
-		this.cache.set(key, value);
-		this._size++;
+class CommentController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'comments';
+        this.name = 'comment';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    /**
+     * 根据 comment id 获取评论, 包括子评论
+     */
+    getById(id) {
+        return this.proxy(id).get();
+    }
+    /**
+     * 获取文章的评论列表
+     * @param refId 文章 Id
+     */
+    getByRefId(refId, pagination = {}) {
+        const { page, size } = pagination;
+        return this.proxy.ref(refId).get({
+            params: { page: page || 1, size: size || 10 },
+        });
+    }
+    /**
+     * 评论
+     */
+    comment(refId, data) {
+        return this.proxy(refId).post({
+            data,
+        });
+    }
+    /**
+     * 回复评论
+     */
+    reply(commentId, data) {
+        return this.proxy.reply(commentId).post({
+            data,
+        });
+    }
+}
+
+class BaseCrudController {
+    constructor(client) {
+        this.client = client;
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    getById(id) {
+        return this.proxy(id).get();
+    }
+    getAll() {
+        return this.proxy.all.get();
+    }
+    /**
+     * 带分页的查询
+     * @param page
+     * @param perPage
+     */
+    getAllPaginated(page, perPage) {
+        return this.proxy.get({
+            params: { page, size: perPage },
+        });
+    }
+}
+
+class LinkController extends BaseCrudController {
+    constructor(client) {
+        super(client);
+        this.client = client;
+        this.name = 'link';
+        this.base = 'links';
+        autoBind(this);
+    }
+}
+
+class NoteController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'notes';
+        this.name = 'note';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    /**
+     * 最新日记
+     */
+    getLatest() {
+        return this.proxy.latest.get();
+    }
+    /**
+     * 获取一篇日记
+     * @param id id | nid
+     * @param password 访问密码
+     */
+    getNoteById(id, password) {
+        if (typeof id === 'number') {
+            return this.proxy.nid(id.toString()).get({
+                params: { password },
+            });
+        }
+        else {
+            return this.proxy(id).get({ params: { password } });
+        }
+    }
+    /**
+     * 日记列表分页
+     */
+    getList(page = 1, perPage = 10, options = {}) {
+        const { select, sortBy, sortOrder, year } = options;
+        return this.proxy.get({
+            params: {
+                page,
+                size: perPage,
+                select: select === null || select === void 0 ? void 0 : select.join(' '),
+                sortBy,
+                sortOrder,
+                year,
+            },
+        });
+    }
+    /**
+     * 获取当前日记的上下各 n / 2 篇日记
+     */
+    getMiddleList(id, size = 5) {
+        return this.proxy.list(id).get({
+            params: { size },
+        });
+    }
+    /**
+     * 喜欢这篇日记
+     */
+    likeIt(id) {
+        return this.proxy.like(id).get();
+    }
+}
+
+class PageController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'pages';
+        this.name = 'page';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    /**
+     * 页面列表
+     */
+    getList(page = 1, perPage = 10, options = {}) {
+        const { select, sortBy, sortOrder } = options;
+        return this.proxy.get({
+            params: {
+                page,
+                size: perPage,
+                select: select === null || select === void 0 ? void 0 : select.join(' '),
+                sortBy,
+                sortOrder,
+            },
+        });
+    }
+    /**
+     * 页面详情
+     */
+    getById(id) {
+        return this.proxy(id).get();
+    }
+    /**
+     * 根据路径获取页面
+     * @param slug 路径
+     * @returns
+     */
+    getBySlug(slug) {
+        return this.proxy.slug(slug).get({});
+    }
+}
+
+class PostController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'posts';
+        this.name = 'post';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    /**
+     * 获取文章列表分页
+     * @param page
+     * @param perPage
+     * @returns
+     */
+    getList(page = 1, perPage = 10, options = {}) {
+        const { select, sortBy, sortOrder, year } = options;
+        return this.proxy.get({
+            params: {
+                page,
+                size: perPage,
+                select: select === null || select === void 0 ? void 0 : select.join(' '),
+                sortBy,
+                sortOrder,
+                year,
+            },
+        });
+    }
+    getPost(idOrCategoryName, slug) {
+        if (arguments.length == 1) {
+            return this.proxy(idOrCategoryName).get();
+        }
+        else {
+            return this.proxy(idOrCategoryName)(slug).get();
+        }
+    }
+    /**
+     * 获取最新的文章
+     */
+    getLatest() {
+        return this.proxy.latest.get();
+    }
+    /**
+     * 点赞
+     */
+    thumbsUp(id) {
+        return this.proxy('_thumbs-up').get({ params: { id } });
+    }
+}
+
+class ProjectController extends BaseCrudController {
+    constructor(client) {
+        super(client);
+        this.client = client;
+        this.base = 'projects';
+        this.name = 'project';
+        autoBind(this);
+    }
+}
+
+class RecentlyController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'recently';
+        this.name = 'recently';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    /**
+     * 获取最新一条
+     */
+    getLatestOne() {
+        return this.proxy.latest.get();
+    }
+    getAll() {
+        return this.proxy.all.get();
+    }
+    getList(before, after, size) {
+        if (!before && !after) {
+            throw new Error('you can only choose `before` or `after`');
+        }
+        return this.proxy.get({
+            params: {
+                before,
+                after,
+                size,
+            },
+        });
+    }
+}
+
+class SayController extends BaseCrudController {
+    constructor(client) {
+        super(client);
+        this.client = client;
+        this.base = 'says';
+        this.name = 'say';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    /**
+     * 获取随机一条
+     */
+    getRandom() {
+        return this.proxy.random.get();
+    }
+}
+
+class SearchController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'search';
+        this.name = 'search';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    search(type, keyword, options = {}) {
+        return this.proxy(type).get({
+            params: Object.assign({ keyword }, options),
+        });
+    }
+    /**
+     * 从 algolya 搜索
+     * https://www.algolia.com/doc/api-reference/api-methods/search/
+     * @param keyword
+     * @param options
+     * @returns
+     */
+    searchByAlgolia(keyword, options) {
+        return this.proxy('algolia').get({ params: Object.assign({ keyword }, options) });
+    }
+}
+
+class SnippetController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'snippets';
+        this.name = 'snippet';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    getById(id) {
+        return this.proxy(id).get();
+    }
+    getByReferenceAndName(reference, name) {
+        return this.proxy(reference)(name).get();
+    }
+}
+
+class UserController {
+    constructor(client) {
+        this.client = client;
+        this.base = 'master';
+        this.name = 'user';
+        autoBind(this);
+    }
+    get proxy() {
+        return this.client.proxy(this.base);
+    }
+    getMasterInfo() {
+        return this.proxy.get();
+    }
+    login(username, password) {
+        return this.proxy.login.post({
+            data: {
+                username,
+                password,
+            },
+        });
+    }
+    checkTokenValid(token) {
+        return this.proxy.check_logged.get({
+            params: {
+                token,
+            },
+        });
+    }
+}
+
+const allControllers = [
+    AggregateController,
+    CategoryController,
+    CommentController,
+    LinkController,
+    NoteController,
+    PageController,
+    PostController,
+    ProjectController,
+    RecentlyController,
+    SayController,
+    SearchController,
+    SnippetController,
+    UserController,
+];
+const allContollerNames = [
+    'aggregate',
+    'category',
+    'comment',
+    'link',
+    'note',
+    'page',
+    'post',
+    'project',
+    'recently',
+    'say',
+    'search',
+    'snippet',
+    'user',
+];
 
-		if (this._size >= this.maxSize) {
-			this._size = 0;
+var mapObj$1 = {exports: {}};
 
-			if (typeof this.onEviction === 'function') {
-				for (const [key, value] of this.oldCache.entries()) {
-					this.onEviction(key, value);
-				}
-			}
+const isObject$1 = value => typeof value === 'object' && value !== null;
+const mapObjectSkip = Symbol('skip');
 
-			this.oldCache = this.cache;
-			this.cache = new Map();
-		}
-	}
+// Customized for this use-case
+const isObjectCustom = value =>
+	isObject$1(value) &&
+	!(value instanceof RegExp) &&
+	!(value instanceof Error) &&
+	!(value instanceof Date);
 
-	get(key) {
-		if (this.cache.has(key)) {
-			return this.cache.get(key);
-		}
+const mapObject = (object, mapper, options, isSeen = new WeakMap()) => {
+	options = {
+		deep: false,
+		target: {},
+		...options
+	};
 
-		if (this.oldCache.has(key)) {
-			const value = this.oldCache.get(key);
-			this.oldCache.delete(key);
-			this._set(key, value);
-			return value;
-		}
+	if (isSeen.has(object)) {
+		return isSeen.get(object);
 	}
 
-	set(key, value) {
-		if (this.cache.has(key)) {
-			this.cache.set(key, value);
-		} else {
-			this._set(key, value);
-		}
+	isSeen.set(object, options.target);
 
-		return this;
-	}
+	const {target} = options;
+	delete options.target;
 
-	has(key) {
-		return this.cache.has(key) || this.oldCache.has(key);
+	const mapArray = array => array.map(element => isObjectCustom(element) ? mapObject(element, mapper, options, isSeen) : element);
+	if (Array.isArray(object)) {
+		return mapArray(object);
 	}
 
-	peek(key) {
-		if (this.cache.has(key)) {
-			return this.cache.get(key);
-		}
-
-		if (this.oldCache.has(key)) {
-			return this.oldCache.get(key);
-		}
-	}
+	for (const [key, value] of Object.entries(object)) {
+		const mapResult = mapper(key, value, object);
 
-	delete(key) {
-		const deleted = this.cache.delete(key);
-		if (deleted) {
-			this._size--;
+		if (mapResult === mapObjectSkip) {
+			continue;
 		}
 
-		return this.oldCache.delete(key) || deleted;
-	}
-
-	clear() {
-		this.cache.clear();
-		this.oldCache.clear();
-		this._size = 0;
-	}
+		let [newKey, newValue, {shouldRecurse = true} = {}] = mapResult;
 
-	* keys() {
-		for (const [key] of this) {
-			yield key;
+		// Drop `__proto__` keys.
+		if (newKey === '__proto__') {
+			continue;
 		}
-	}
 
-	* values() {
-		for (const [, value] of this) {
-			yield value;
+		if (options.deep && shouldRecurse && isObjectCustom(newValue)) {
+			newValue = Array.isArray(newValue) ?
+				mapArray(newValue) :
+				mapObject(newValue, mapper, options, isSeen);
 		}
+
+		target[newKey] = newValue;
 	}
 
-	* [Symbol.iterator]() {
-		for (const item of this.cache) {
-			yield item;
-		}
+	return target;
+};
 
-		for (const item of this.oldCache) {
-			const [key] = item;
-			if (!this.cache.has(key)) {
-				yield item;
-			}
-		}
+mapObj$1.exports = (object, mapper, options) => {
+	if (!isObject$1(object)) {
+		throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
 	}
 
-	get size() {
-		let oldCacheSize = 0;
-		for (const key of this.oldCache.keys()) {
-			if (!this.cache.has(key)) {
-				oldCacheSize++;
-			}
-		}
+	return mapObject(object, mapper, options);
+};
 
-		return Math.min(this._size + oldCacheSize, this.maxSize);
-	}
-}
+mapObj$1.exports.mapObjectSkip = mapObjectSkip;
 
-var quickLru = QuickLRU;
+var camelcase = {exports: {}};
 
-const mapObj = mapObj$1.exports;
-const camelCase = camelcase.exports;
-const QuickLru = quickLru;
+const preserveCamelCase = (string, locale) => {
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
 
-const has = (array, key) => array.some(x => {
-	if (typeof x === 'string') {
-		return x === key;
+	for (let i = 0; i < string.length; i++) {
+		const character = string[i];
+
+		if (isLastCharLower && /[\p{Lu}]/u.test(character)) {
+			string = string.slice(0, i) + '-' + string.slice(i);
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			i++;
+		} else if (isLastCharUpper && isLastLastCharUpper && /[\p{Ll}]/u.test(character)) {
+			string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower = character.toLocaleLowerCase(locale) === character && character.toLocaleUpperCase(locale) !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = character.toLocaleUpperCase(locale) === character && character.toLocaleLowerCase(locale) !== character;
+		}
 	}
 
-	x.lastIndex = 0;
-	return x.test(key);
-});
+	return string;
+};
 
-const cache = new QuickLru({maxSize: 100000});
+const preserveConsecutiveUppercase = input => {
+	return input.replace(/^[\p{Lu}](?![\p{Lu}])/gu, m1 => m1.toLowerCase());
+};
 
-// Reproduces behavior from `map-obj`
-const isObject = value =>
-	typeof value === 'object' &&
-	value !== null &&
-	!(value instanceof RegExp) &&
-	!(value instanceof Error) &&
-	!(value instanceof Date);
+const postProcess = (input, options) => {
+	return input.replace(/[_.\- ]+([\p{Alpha}\p{N}_]|$)/gu, (_, p1) => p1.toLocaleUpperCase(options.locale))
+		.replace(/\d+([\p{Alpha}\p{N}_]|$)/gu, m => m.toLocaleUpperCase(options.locale));
+};
 
-const camelCaseConvert = (input, options) => {
-	if (!isObject(input)) {
-		return input;
+const camelCase$1 = (input, options) => {
+	if (!(typeof input === 'string' || Array.isArray(input))) {
+		throw new TypeError('Expected the input to be `string | string[]`');
 	}
 
 	options = {
-		deep: false,
 		pascalCase: false,
+		preserveConsecutiveUppercase: false,
 		...options
 	};
 
-	const {exclude, pascalCase, stopPaths, deep} = options;
+	if (Array.isArray(input)) {
+		input = input.map(x => x.trim())
+			.filter(x => x.length)
+			.join('-');
+	} else {
+		input = input.trim();
+	}
 
-	const stopPathsSet = new Set(stopPaths);
+	if (input.length === 0) {
+		return '';
+	}
 
-	const makeMapper = parentPath => (key, value) => {
-		if (deep && isObject(value)) {
-			const path = parentPath === undefined ? key : `${parentPath}.${key}`;
+	if (input.length === 1) {
+		return options.pascalCase ? input.toLocaleUpperCase(options.locale) : input.toLocaleLowerCase(options.locale);
+	}
 
-			if (!stopPathsSet.has(path)) {
-				value = mapObj(value, makeMapper(path));
-			}
+	const hasUpperCase = input !== input.toLocaleLowerCase(options.locale);
+
+	if (hasUpperCase) {
+		input = preserveCamelCase(input, options.locale);
+	}
+
+	input = input.replace(/^[_.\- ]+/, '');
+
+	if (options.preserveConsecutiveUppercase) {
+		input = preserveConsecutiveUppercase(input);
+	} else {
+		input = input.toLocaleLowerCase();
+	}
+
+	if (options.pascalCase) {
+		input = input.charAt(0).toLocaleUpperCase(options.locale) + input.slice(1);
+	}
+
+	return postProcess(input, options);
+};
+
+camelcase.exports = camelCase$1;
+// TODO: Remove this for the next major release
+camelcase.exports.default = camelCase$1;
+
+class QuickLRU {
+	constructor(options = {}) {
+		if (!(options.maxSize && options.maxSize > 0)) {
+			throw new TypeError('`maxSize` must be a number greater than 0');
 		}
 
-		if (!(exclude && has(exclude, key))) {
-			const cacheKey = pascalCase ? `${key}_` : key;
+		this.maxSize = options.maxSize;
+		this.onEviction = options.onEviction;
+		this.cache = new Map();
+		this.oldCache = new Map();
+		this._size = 0;
+	}
+
+	_set(key, value) {
+		this.cache.set(key, value);
+		this._size++;
 
-			if (cache.has(cacheKey)) {
-				key = cache.get(cacheKey);
-			} else {
-				const returnValue = camelCase(key, {pascalCase});
+		if (this._size >= this.maxSize) {
+			this._size = 0;
 
-				if (key.length < 100) { // Prevent abuse
-					cache.set(cacheKey, returnValue);
+			if (typeof this.onEviction === 'function') {
+				for (const [key, value] of this.oldCache.entries()) {
+					this.onEviction(key, value);
 				}
-
-				key = returnValue;
 			}
-		}
 
-		return [key, value];
-	};
+			this.oldCache = this.cache;
+			this.cache = new Map();
+		}
+	}
 
-	return mapObj(input, makeMapper(undefined));
-};
+	get(key) {
+		if (this.cache.has(key)) {
+			return this.cache.get(key);
+		}
 
-var camelcaseKeys = (input, options) => {
-	if (Array.isArray(input)) {
-		return Object.keys(input).map(key => camelCaseConvert(input[key], options));
+		if (this.oldCache.has(key)) {
+			const value = this.oldCache.get(key);
+			this.oldCache.delete(key);
+			this._set(key, value);
+			return value;
+		}
 	}
 
-	return camelCaseConvert(input, options);
-};
-
-const isPlainObject = (obj) => typeof obj === 'object' &&
-    Object.prototype.toString.call(obj) === '[object Object]';
-const sortOrderToNumber = (order) => {
-    return ({
-        asc: 1,
-        desc: -1,
-    }[order] || 1);
-};
-const destructureData = (payload) => {
-    if (typeof payload !== 'object') {
-        return payload;
-    }
-    if (payload === null) {
-        return payload;
-    }
-    const data = payload.data;
-    const dataIsPlainObject = Object.prototype.toString.call(data) === '[object Object]';
-    if (dataIsPlainObject && Object.keys(payload).length === 1) {
-        const d = Object.assign({}, data);
-        // attach raw onto new data
-        attachRawFromOneToAnthor(payload, d);
-        return d;
-    }
-    return payload;
-};
-const attachRawFromOneToAnthor = (from, to) => {
-    if (!from) {
-        return;
-    }
-    from.$raw &&
-        Object.defineProperty(to, '$raw', {
-            value: Object.assign({}, from.$raw),
-            enumerable: false,
-        });
-    from.$request &&
-        Object.defineProperty(to, '$request', {
-            value: Object.assign({}, from.$request),
-            enumerable: false,
-        });
-};
+	set(key, value) {
+		if (this.cache.has(key)) {
+			this.cache.set(key, value);
+		} else {
+			this._set(key, value);
+		}
 
-function attachRequestMethod(target) {
-    Object.defineProperty(target, '$$get', {
-        value: function (url, options) {
-            // HINT: method get only accept search params;
-            const { params = {} } = options;
-            const qs = handleSearchParams(params);
-            return target.instance.get(url + `${qs ? `${'?' + qs}` : ''}`);
-        },
-    });
-    Object.defineProperty(target, '$$post', {
-        value: function (path, options) {
-            return target.instance.post(path, options);
-        },
-    });
-}
-// FIXME: only support string value
-function handleSearchParams(obj) {
-    if (!obj && typeof obj !== 'object') {
-        throw new TypeError('params must be object.');
-    }
-    if (obj instanceof URLSearchParams) {
-        return obj.toString();
-    }
-    const search = new URLSearchParams();
-    Object.entries(obj).forEach(([k, v]) => {
-        if (typeof v === 'undefined' ||
-            Object.prototype.toString.call(v) === '[object Null]') {
-            return;
-        }
-        search.set(k, v);
-    });
-    return search.toString();
-}
+		return this;
+	}
 
-class AggregateController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'aggregate';
-        this.name = 'aggregate';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    /**
-     * 获取聚合数据
-     */
-    getAggregateData() {
-        return this.proxy.get();
-    }
-    /**
-     * 获取最新发布的内容
-     */
-    getTop(size = 5) {
-        return this.proxy.top.get({ params: { size } });
-    }
-    getTimeline(options) {
-        const { sort, type, year } = options || {};
-        return this.proxy.timeline.get({
-            params: {
-                sort: sort && sortOrderToNumber(sort),
-                type,
-                year,
-            },
-        });
-    }
-    /**
-     * 获取聚合数据统计
-     */
-    getStat() {
-        return this.proxy.stat.get();
-    }
-}
+	has(key) {
+		return this.cache.has(key) || this.oldCache.has(key);
+	}
 
-var CategoryType;
-(function (CategoryType) {
-    CategoryType[CategoryType["Category"] = 0] = "Category";
-    CategoryType[CategoryType["Tag"] = 1] = "Tag";
-})(CategoryType || (CategoryType = {}));
+	peek(key) {
+		if (this.cache.has(key)) {
+			return this.cache.get(key);
+		}
 
-class RequestError extends Error {
-    constructor(message, status, path, raw) {
-        super(message);
-        this.status = status;
-        this.path = path;
-        this.raw = raw;
-    }
-}
+		if (this.oldCache.has(key)) {
+			return this.oldCache.get(key);
+		}
+	}
 
-class CategoryController {
-    constructor(client) {
-        this.client = client;
-        this.name = 'category';
-        this.base = 'categories';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    getAllCategories() {
-        return this.proxy.get({
-            params: {
-                type: CategoryType.Category,
-            },
-        });
-    }
-    getAllTags() {
-        return this.proxy.get({
-            params: {
-                type: CategoryType.Tag,
-            },
-        });
-    }
-    async getCategoryDetail(ids) {
-        if (typeof ids === 'string') {
-            const data = await this.proxy.get({
-                params: {
-                    ids: ids,
-                },
-            });
-            const result = Object.values(data.entries)[0];
-            attachRawFromOneToAnthor(data, result);
-            return result;
-        }
-        else if (Array.isArray(ids)) {
-            const data = await this.proxy.get({
-                params: {
-                    ids: ids.join(','),
-                },
-            });
-            const entries = data === null || data === void 0 ? void 0 : data.entries;
-            if (!entries) {
-                throw new RequestError('data structure error', 500, data.$request.path, data);
-            }
-            const map = new Map(Object.entries(entries).map(([id, value]) => [id.toLowerCase(), value]));
-            attachRawFromOneToAnthor(data, map);
-            return map;
-        }
-    }
-    async getCategoryByIdOrSlug(idOrSlug) {
-        const res = await this.proxy(idOrSlug).get();
-        return destructureData(res);
-    }
-    async getTagByName(name) {
-        const res = await this.proxy(name).get({
-            params: {
-                tag: 1,
-            },
-        });
-        return res;
-    }
-}
+	delete(key) {
+		const deleted = this.cache.delete(key);
+		if (deleted) {
+			this._size--;
+		}
 
-class CommentController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'comments';
-        this.name = 'comment';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    /**
-     * 根据 comment id 获取评论, 包括子评论
-     */
-    getById(id) {
-        return this.proxy(id).get();
-    }
-    /**
-     * 获取文章的评论列表
-     * @param refId 文章 Id
-     */
-    getByRefId(refId, pagination = {}) {
-        const { page, size } = pagination;
-        return this.proxy.ref(refId).get({
-            params: { page: page || 1, size: size || 10 },
-        });
-    }
-    /**
-     * 评论
-     */
-    comment(refId, data) {
-        return this.proxy(refId).post({
-            data,
-        });
-    }
-    /**
-     * 回复评论
-     */
-    reply(commentId, data) {
-        return this.proxy.reply(commentId).post({
-            data,
-        });
-    }
-}
+		return this.oldCache.delete(key) || deleted;
+	}
 
-class BaseCrudController {
-    constructor(client) {
-        this.client = client;
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    getById(id) {
-        return this.proxy(id).get();
-    }
-    getAll() {
-        return this.proxy.all.get();
-    }
-    /**
-     * 带分页的查询
-     * @param page
-     * @param perPage
-     */
-    getAllPaginated(page, perPage) {
-        return this.proxy.get({
-            params: { page, size: perPage },
-        });
-    }
-}
+	clear() {
+		this.cache.clear();
+		this.oldCache.clear();
+		this._size = 0;
+	}
 
-class LinkController extends BaseCrudController {
-    constructor(client) {
-        super(client);
-        this.client = client;
-        this.name = 'link';
-        this.base = 'links';
-    }
-}
+	* keys() {
+		for (const [key] of this) {
+			yield key;
+		}
+	}
 
-class NoteController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'notes';
-        this.name = 'note';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    /**
-     * 最新日记
-     */
-    getLatest() {
-        return this.proxy.latest.get();
-    }
-    /**
-     * 获取一篇日记
-     * @param id id | nid
-     * @param password 访问密码
-     */
-    getNoteById(id, password) {
-        if (typeof id === 'number') {
-            return this.proxy.nid(id.toString()).get({
-                params: { password },
-            });
-        }
-        else {
-            return this.proxy(id).get({ params: { password } });
-        }
-    }
-    /**
-     * 日记列表分页
-     */
-    getList(page = 1, perPage = 10, options = {}) {
-        const { select, sortBy, sortOrder, year } = options;
-        return this.proxy.get({
-            params: {
-                page,
-                size: perPage,
-                select: select === null || select === void 0 ? void 0 : select.join(' '),
-                sortBy,
-                sortOrder,
-                year,
-            },
-        });
-    }
-    /**
-     * 获取当前日记的上下各 n / 2 篇日记
-     */
-    getMiddleList(id, size = 5) {
-        return this.proxy.list(id).get({
-            params: { size },
-        });
-    }
-    /**
-     * 喜欢这篇日记
-     */
-    likeIt(id) {
-        return this.proxy.like(id).get();
-    }
-}
+	* values() {
+		for (const [, value] of this) {
+			yield value;
+		}
+	}
 
-class PageController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'pages';
-        this.name = 'page';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    /**
-     * 页面列表
-     */
-    getList(page = 1, perPage = 10, options = {}) {
-        const { select, sortBy, sortOrder } = options;
-        return this.proxy.get({
-            params: {
-                page,
-                size: perPage,
-                select: select === null || select === void 0 ? void 0 : select.join(' '),
-                sortBy,
-                sortOrder,
-            },
-        });
-    }
-    /**
-     * 页面详情
-     */
-    getById(id) {
-        return this.proxy(id).get();
-    }
-    /**
-     * 根据路径获取页面
-     * @param slug 路径
-     * @returns
-     */
-    getBySlug(slug) {
-        return this.proxy.slug(slug).get({});
-    }
-}
+	* [Symbol.iterator]() {
+		for (const item of this.cache) {
+			yield item;
+		}
 
-class PostController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'posts';
-        this.name = 'post';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    /**
-     * 获取文章列表分页
-     * @param page
-     * @param perPage
-     * @returns
-     */
-    getList(page = 1, perPage = 10, options = {}) {
-        const { select, sortBy, sortOrder, year } = options;
-        return this.proxy.get({
-            params: {
-                page,
-                size: perPage,
-                select: select === null || select === void 0 ? void 0 : select.join(' '),
-                sortBy,
-                sortOrder,
-                year,
-            },
-        });
-    }
-    getPost(idOrCategoryName, slug) {
-        if (arguments.length == 1) {
-            return this.proxy(idOrCategoryName).get();
-        }
-        else {
-            return this.proxy(idOrCategoryName)(slug).get();
-        }
-    }
-    /**
-     * 获取最新的文章
-     */
-    getLatest() {
-        return this.proxy.latest.get();
-    }
-    /**
-     * 点赞
-     */
-    thumbsUp(id) {
-        return this.proxy('_thumbs-up').get({ params: { id } });
-    }
-}
+		for (const item of this.oldCache) {
+			const [key] = item;
+			if (!this.cache.has(key)) {
+				yield item;
+			}
+		}
+	}
+
+	get size() {
+		let oldCacheSize = 0;
+		for (const key of this.oldCache.keys()) {
+			if (!this.cache.has(key)) {
+				oldCacheSize++;
+			}
+		}
 
-class ProjectController extends BaseCrudController {
-    constructor(client) {
-        super(client);
-        this.client = client;
-        this.base = 'projects';
-        this.name = 'project';
-    }
+		return Math.min(this._size + oldCacheSize, this.maxSize);
+	}
 }
 
-class RecentlyController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'recently';
-        this.name = 'recently';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    /**
-     * 获取最新一条
-     */
-    getLatestOne() {
-        return this.proxy.latest.get();
-    }
-    getAll() {
-        return this.proxy.all.get();
-    }
-    getList(before, after, size) {
-        if (!before && !after) {
-            throw new Error('you can only choose `before` or `after`');
-        }
-        return this.proxy.get({
-            params: {
-                before,
-                after,
-                size,
-            },
-        });
-    }
-}
+var quickLru = QuickLRU;
 
-class SayController extends BaseCrudController {
-    constructor(client) {
-        super(client);
-        this.client = client;
-        this.base = 'says';
-        this.name = 'say';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    /**
-     * 获取随机一条
-     */
-    getRandom() {
-        return this.proxy.random.get();
-    }
-}
+const mapObj = mapObj$1.exports;
+const camelCase = camelcase.exports;
+const QuickLru = quickLru;
 
-class SearchController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'search';
-        this.name = 'search';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    search(type, keyword, options = {}) {
-        return this.proxy(type).get({
-            params: Object.assign({ keyword }, options),
-        });
-    }
-    /**
-     * 从 algolya 搜索
-     * https://www.algolia.com/doc/api-reference/api-methods/search/
-     * @param keyword
-     * @param options
-     * @returns
-     */
-    searchByAlgolia(keyword, options) {
-        return this.proxy('algolia').get({ params: Object.assign({ keyword }, options) });
-    }
-}
+const has = (array, key) => array.some(x => {
+	if (typeof x === 'string') {
+		return x === key;
+	}
 
-class SnippetController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'snippets';
-        this.name = 'snippet';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    getById(id) {
-        return this.proxy(id).get();
-    }
-    getByReferenceAndName(reference, name) {
-        return this.proxy(reference)(name).get();
-    }
-}
+	x.lastIndex = 0;
+	return x.test(key);
+});
 
-class UserController {
-    constructor(client) {
-        this.client = client;
-        this.base = 'master';
-        this.name = 'user';
-    }
-    get proxy() {
-        return this.client.proxy(this.base);
-    }
-    getMasterInfo() {
-        return this.proxy.get();
-    }
-    login(username, password) {
-        return this.proxy.login.post({
-            data: {
-                username,
-                password,
+const cache = new QuickLru({maxSize: 100000});
+
+// Reproduces behavior from `map-obj`
+const isObject = value =>
+	typeof value === 'object' &&
+	value !== null &&
+	!(value instanceof RegExp) &&
+	!(value instanceof Error) &&
+	!(value instanceof Date);
+
+const camelCaseConvert = (input, options) => {
+	if (!isObject(input)) {
+		return input;
+	}
+
+	options = {
+		deep: false,
+		pascalCase: false,
+		...options
+	};
+
+	const {exclude, pascalCase, stopPaths, deep} = options;
+
+	const stopPathsSet = new Set(stopPaths);
+
+	const makeMapper = parentPath => (key, value) => {
+		if (deep && isObject(value)) {
+			const path = parentPath === undefined ? key : `${parentPath}.${key}`;
+
+			if (!stopPathsSet.has(path)) {
+				value = mapObj(value, makeMapper(path));
+			}
+		}
+
+		if (!(exclude && has(exclude, key))) {
+			const cacheKey = pascalCase ? `${key}_` : key;
+
+			if (cache.has(cacheKey)) {
+				key = cache.get(cacheKey);
+			} else {
+				const returnValue = camelCase(key, {pascalCase});
+
+				if (key.length < 100) { // Prevent abuse
+					cache.set(cacheKey, returnValue);
+				}
+
+				key = returnValue;
+			}
+		}
+
+		return [key, value];
+	};
+
+	return mapObj(input, makeMapper(undefined));
+};
+
+var camelcaseKeys = (input, options) => {
+	if (Array.isArray(input)) {
+		return Object.keys(input).map(key => camelCaseConvert(input[key], options));
+	}
+
+	return camelCaseConvert(input, options);
+};
+
+function attachRequestMethod(target) {
+    Object.defineProperty(target, '$$get', {
+        value: function (url, options) {
+            // HINT: method get only accept search params;
+            const { params = {} } = options;
+            const qs = handleSearchParams(params);
+            return target.instance.get(url + `${qs ? `${'?' + qs}` : ''}`);
+        },
+    });
+    ['put', 'post', 'patch', 'delete'].forEach((method) => {
+        Object.defineProperty(target, '$$' + method, {
+            value: function (path, options) {
+                return target.instance[method](path, options);
             },
         });
+    });
+}
+// FIXME: only support string value
+function handleSearchParams(obj) {
+    if (!obj && typeof obj !== 'object') {
+        throw new TypeError('params must be object.');
     }
-    checkTokenValid(token) {
-        return this.proxy.check_logged.get({
-            params: {
-                token,
-            },
-        });
+    if (obj instanceof URLSearchParams) {
+        return obj.toString();
     }
+    const search = new URLSearchParams();
+    Object.entries(obj).forEach(([k, v]) => {
+        if (typeof v === 'undefined' ||
+            Object.prototype.toString.call(v) === '[object Null]') {
+            return;
+        }
+        search.set(k, v);
+    });
+    return search.toString();
 }
 
-const allControllers = [
-    AggregateController,
-    CategoryController,
-    CommentController,
-    LinkController,
-    NoteController,
-    PageController,
-    PostController,
-    ProjectController,
-    RecentlyController,
-    SayController,
-    SearchController,
-    SnippetController,
-    UserController,
-];
-const allContollerNames = [
-    'aggregate',
-    'category',
-    'comment',
-    'link',
-    'note',
-    'page',
-    'post',
-    'project',
-    'recently',
-    'say',
-    'search',
-    'snippet',
-    'user',
-];
-
 class HTTPControllerDefine {
     get master() {
         return this.user;
@@ -954,11 +1006,10 @@ class HTTPControllerDefine {
 }
 
 class HTTPClient extends HTTPControllerDefine {
-    // define all clients
-    constructor(_endpoint, _instance) {
+    constructor(_endpoint, _adaptor) {
         super();
         this._endpoint = _endpoint;
-        this._instance = _instance;
+        this._adaptor = _adaptor;
         this._endpoint = _endpoint
             .replace(/\/*$/, '')
             .replace('localhost', '127.0.0.1');
@@ -999,7 +1050,7 @@ class HTTPClient extends HTTPControllerDefine {
         return this._endpoint;
     }
     get instance() {
-        return this._instance;
+        return this._adaptor;
     }
     request(options) {
         return this['$$' + String(options.method || 'get').toLowerCase()](options.url, options);