@mix-space-lts/api-client 2.4.2 → 2.4.3

package/dist/index.cjs

@@ -0,0 +1,1340 @@
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: 'Module' } });
+
+//#region utils/index.ts
+const isPlainObject = (obj) => isObject(obj) && Object.prototype.toString.call(obj) === "[object Object]" && Object.getPrototypeOf(obj) === Object.prototype;
+const sortOrderToNumber = (order) => {
+	return {
+		asc: 1,
+		desc: -1
+	}[order] || 1;
+};
+const isObject = (obj) => obj && typeof obj === "object";
+const destructureData = (payload) => {
+	if (typeof payload !== "object") return payload;
+	if (payload === null) return payload;
+	const data = payload.data;
+	if (isPlainObject(data) && Object.keys(payload).length === 1) {
+		const d = Object.assign({}, data);
+		attachRawFromOneToAnthor(payload, d);
+		return d;
+	}
+	return payload;
+};
+const attachRawFromOneToAnthor = (from, to) => {
+	if (!from || !isObject(to)) return;
+	[
+		"$raw",
+		"$request",
+		"$serialized"
+	].forEach((key) => {
+		from[key] && Object.defineProperty(to, key, {
+			get() {
+				return from[key];
+			},
+			enumerable: false
+		});
+	});
+};
+
+//#endregion
+//#region utils/camelcase-keys.ts
+/**
+* A simple camelCase function that only handles strings, but not handling symbol, date, or other complex case.
+* If you need to handle more complex cases, please use camelcase-keys package.
+*/
+const camelcaseKeys = (obj) => {
+	if (Array.isArray(obj)) return obj.map((x) => camelcaseKeys(x));
+	if (isPlainObject(obj)) return Object.keys(obj).reduce((result, key) => {
+		const nextKey = isMongoId(key) ? key : camelcase(key);
+		result[nextKey] = camelcaseKeys(obj[key]);
+		return result;
+	}, {});
+	return obj;
+};
+function camelcase(str) {
+	return str.replace(/^_+/, "").replaceAll(/([_-][a-z])/gi, ($1) => {
+		return $1.toUpperCase().replace("-", "").replace("_", "");
+	});
+}
+const isMongoId = (id) => id.length === 24 && /^[\dA-F]{24}$/i.test(id);
+
+//#endregion
+//#region utils/path.ts
+const resolveFullPath = (endpoint, path) => {
+	if (!path.startsWith("/")) path = `/${path}`;
+	return `${endpoint}${path}`;
+};
+
+//#endregion
+//#region utils/auto-bind.ts
+const getAllProperties = (object) => {
+	const properties = /* @__PURE__ */ 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;
+}
+
+//#endregion
+//#region controllers/ack.ts
+/**
+* @support core >= 4.4.0
+*/
+var AckController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "ack";
+		this.name = "ack";
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	read(type, id) {
+		return this.proxy.post({ data: {
+			type: "read",
+			payload: {
+				type,
+				id
+			}
+		} });
+	}
+};
+
+//#endregion
+//#region controllers/activity.ts
+/**
+* @support core >= 4.3.0
+*/
+var ActivityController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "activity";
+		this.name = "activity";
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	likeIt(type, id) {
+		return this.proxy.like.post({ data: {
+			type: type.toLowerCase(),
+			id
+		} });
+	}
+	/**
+	*
+	* @support core >= 5.0.0
+	*/
+	getPresence(roomName) {
+		return this.proxy.presence.get({ params: { room_name: roomName } });
+	}
+	/**
+	*
+	* @support core >= 5.0.0
+	*/
+	updatePresence({ identity, position, roomName, sid, ts, displayName, readerId }) {
+		return this.proxy.presence.update.post({ data: {
+			identity,
+			position,
+			ts: ts || Date.now(),
+			roomName,
+			sid,
+			readerId,
+			displayName
+		} });
+	}
+	async getRoomsInfo() {
+		return this.proxy.rooms.get();
+	}
+	async getRecentActivities() {
+		return this.proxy.recent.get();
+	}
+	async getLastYearPublication() {
+		return this.proxy(`last-year`).publication.get();
+	}
+};
+
+//#endregion
+//#region controllers/aggregate.ts
+var AggregateController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "aggregate";
+		this.name = "aggregate";
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	/**
+	* 获取聚合数据
+	*/
+	getAggregateData(theme) {
+		return this.proxy.get({ params: { theme } });
+	}
+	/**
+	* 获取最新发布的内容
+	*/
+	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
+		} });
+	}
+	getLatest(options) {
+		const { limit, types, combined } = options || {};
+		return this.proxy.latest.get({ params: {
+			limit,
+			types: types?.join(","),
+			combined
+		} });
+	}
+	/**
+	* 获取聚合数据统计
+	*/
+	getStat() {
+		return this.proxy.stat.get();
+	}
+};
+
+//#endregion
+//#region controllers/ai.ts
+/**
+* @support core >= 5.6.0
+*/
+var AIController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "ai";
+		this.name = "ai";
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	async getSummary({ articleId, lang = "zh-CN", onlyDb }) {
+		return this.proxy.summaries.article(articleId).get({ params: {
+			lang,
+			onlyDb
+		} });
+	}
+	async generateSummary(articleId, lang = "zh-CN", token = "") {
+		return this.proxy.summaries.generate.post({
+			params: { token },
+			data: {
+				lang,
+				refId: articleId
+			}
+		});
+	}
+	/**
+	* Core >= 8.3.0
+	* @param articleId
+	*/
+	async getDeepReading(articleId) {
+		return this.proxy("deep-readings").article(articleId).get();
+	}
+	/**
+	* Get translation for an article
+	* @support core >= 9.4.0
+	*/
+	async getTranslation({ articleId, lang }) {
+		return this.proxy.translations.article(articleId).get({ params: { lang } });
+	}
+	/**
+	* Get available translation languages for an article
+	* @support core >= 9.4.0
+	*/
+	async getAvailableLanguages(articleId) {
+		return this.proxy.translations.article(articleId).languages.get();
+	}
+	/**
+	* Get URL for streaming summary generation (SSE)
+	*
+	* @see AISummaryStreamEvent for event types
+	* @support core >= 9.4.0
+	*/
+	getSummaryGenerateUrl({ articleId, lang }) {
+		const baseUrl = this.client.endpoint;
+		const params = new URLSearchParams();
+		if (lang) params.set("lang", lang);
+		const query = params.toString();
+		return `${baseUrl}/${this.base}/summaries/article/${articleId}/generate${query ? `?${query}` : ""}`;
+	}
+	/**
+	* Stream summary generation using fetch
+	*
+	* @see AISummaryStreamEvent for event types
+	* @support core >= 9.4.0
+	*/
+	async streamSummaryGenerate({ articleId, lang }, fetchOptions) {
+		const url = this.getSummaryGenerateUrl({
+			articleId,
+			lang
+		});
+		return fetch(url, {
+			...fetchOptions,
+			headers: {
+				Accept: "text/event-stream",
+				...fetchOptions?.headers
+			}
+		});
+	}
+	/**
+	* Get URL for streaming translation generation (SSE)
+	*
+	* @see AITranslationStreamEvent for event types
+	* @support core >= 9.4.0
+	*/
+	getTranslationGenerateUrl({ articleId, lang }) {
+		const baseUrl = this.client.endpoint;
+		const params = new URLSearchParams();
+		params.set("lang", lang);
+		return `${baseUrl}/${this.base}/translations/article/${articleId}/generate?${params.toString()}`;
+	}
+	/**
+	* Stream translation generation using fetch
+	*
+	* @see AITranslationStreamEvent for event types
+	* @support core >= 9.4.0
+	*/
+	async streamTranslationGenerate({ articleId, lang }, fetchOptions) {
+		const url = this.getTranslationGenerateUrl({
+			articleId,
+			lang
+		});
+		return fetch(url, {
+			...fetchOptions,
+			headers: {
+				Accept: "text/event-stream",
+				...fetchOptions?.headers
+			}
+		});
+	}
+};
+
+//#endregion
+//#region core/error.ts
+var RequestError = class extends Error {
+	constructor(message, status, path, raw) {
+		super(message);
+		this.status = status;
+		this.path = path;
+		this.raw = raw;
+	}
+};
+
+//#endregion
+//#region models/category.ts
+let CategoryType = /* @__PURE__ */ function(CategoryType) {
+	CategoryType[CategoryType["Category"] = 0] = "Category";
+	CategoryType[CategoryType["Tag"] = 1] = "Tag";
+	return CategoryType;
+}({});
+
+//#endregion
+//#region controllers/category.ts
+var CategoryController = class {
+	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 } });
+			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?.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) {
+		return destructureData(await this.proxy(idOrSlug).get());
+	}
+	async getTagByName(name) {
+		return await this.proxy(name).get({ params: { tag: 1 } });
+	}
+};
+
+//#endregion
+//#region controllers/comment.ts
+var CommentController = class {
+	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
+		} });
+	}
+	getThreadReplies(rootCommentId, params = {}) {
+		return this.proxy.thread(rootCommentId).get({ params });
+	}
+	/**
+	* 评论
+	*/
+	guestComment(refId, data) {
+		return this.proxy.guest(refId).post({ data });
+	}
+	/**
+	* 回复评论
+	*/
+	guestReply(commentId, data) {
+		return this.proxy.guest.reply(commentId).post({ data });
+	}
+	readerComment(refId, data) {
+		return this.proxy.reader(refId).post({ data });
+	}
+	readerReply(commentId, data) {
+		return this.proxy.reader.reply(commentId).post({ data });
+	}
+};
+
+//#endregion
+//#region controllers/base.ts
+var BaseCrudController = class {
+	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, sortOption) {
+		return this.proxy.get({ params: {
+			page,
+			size: perPage,
+			...sortOption
+		} });
+	}
+};
+
+//#endregion
+//#region controllers/link.ts
+var LinkController = class extends BaseCrudController {
+	constructor(client) {
+		super(client);
+		this.client = client;
+		this.name = ["link", "friend"];
+		this.base = "links";
+		autoBind(this);
+	}
+	async canApplyLink() {
+		const { can } = await this.proxy.audit.get();
+		return can;
+	}
+	async applyLink(data) {
+		return await this.proxy.audit.post({ data });
+	}
+};
+
+//#endregion
+//#region controllers/note.ts
+var NoteController = class {
+	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();
+	}
+	getNoteById(...rest) {
+		const [id, password = void 0, singleResult = false] = rest;
+		if (typeof id === "number") return this.proxy.nid(id.toString()).get({ params: {
+			password,
+			single: singleResult ? "1" : void 0
+		} });
+		else return this.proxy(id).get();
+	}
+	/**
+	* 根据 nid 获取日记，支持翻译参数
+	* @param nid 日记编号
+	* @param options 可选参数：password, single, lang
+	*/
+	getNoteByNid(nid, options) {
+		const { password, single, lang, prefer } = options || {};
+		return this.proxy.nid(nid.toString()).get({ params: {
+			password,
+			single: single ? "1" : void 0,
+			lang,
+			prefer
+		} });
+	}
+	getNoteBySlugDate(year, month, day, slug, options) {
+		const { password, single, lang, prefer } = options || {};
+		return this.proxy(year.toString())(month.toString())(day.toString())(slug).get({ params: {
+			password,
+			single: single ? "1" : void 0,
+			lang,
+			prefer
+		} });
+	}
+	/**
+	* 日记列表分页
+	*/
+	getList(page = 1, perPage = 10, options = {}) {
+		const { select, sortBy, sortOrder, year, lang, withSummary } = options;
+		return this.proxy.get({ params: {
+			page,
+			size: perPage,
+			select: select?.join(" "),
+			sortBy,
+			sortOrder,
+			year,
+			lang,
+			withSummary: withSummary ? "1" : void 0
+		} });
+	}
+	/**
+	* 获取当前日记的上下各 n / 2 篇日记
+	* @param id 当前日记 ID
+	* @param size 返回数量，默认 5
+	* @param options 可选参数，包含 lang 用于获取翻译版本
+	*/
+	getMiddleList(id, size = 5, options) {
+		const { lang } = options || {};
+		return this.proxy.list(id).get({ params: {
+			size,
+			lang
+		} });
+	}
+	/**
+	* 获取专栏内的所有日记
+	* @param topicId 专栏 ID
+	* @param page 页码，默认 1
+	* @param size 每页数量，默认 10
+	* @param options 可选参数，包含排序选项和 lang 用于获取翻译版本
+	*/
+	getNoteByTopicId(topicId, page = 1, size = 10, options = {}) {
+		const { lang, ...sortOptions } = options;
+		return this.proxy.topics(topicId).get({ params: {
+			page,
+			size,
+			lang,
+			...sortOptions
+		} });
+	}
+};
+
+//#endregion
+//#region controllers/owner.ts
+var UserController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "owner";
+		this.name = ["owner"];
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	get authProxy() {
+		return this.client.proxy("auth");
+	}
+	normalizeToken(token) {
+		const normalized = token?.trim();
+		if (!normalized) return;
+		return normalized.replace(/^bearer\s+/i, "");
+	}
+	/**
+	* @deprecated Use `getOwnerInfo()` instead.
+	*/
+	getMasterInfo() {
+		return this.getOwnerInfo();
+	}
+	getOwnerInfo() {
+		return this.proxy.get();
+	}
+	login(username, password, options) {
+		return this.authProxy("sign-in").username.post({ data: {
+			username,
+			password,
+			...options
+		} });
+	}
+	logout() {
+		return this.authProxy("sign-out").post();
+	}
+	/**
+	* Better Auth raw session (`/auth/get-session`).
+	*/
+	getAuthSession(options) {
+		return this.authProxy("get-session").get({ params: options });
+	}
+	/**
+	* Core session summary (`/auth/session`).
+	*/
+	getSession() {
+		return this.authProxy.session.get();
+	}
+	getProviders() {
+		return this.authProxy.providers.get();
+	}
+	getAllowLoginMethods() {
+		return this.proxy("allow-login").get();
+	}
+	listSessions() {
+		return this.authProxy("list-sessions").get();
+	}
+	revokeSession(token) {
+		return this.authProxy("revoke-session").post({ data: { token } });
+	}
+	revokeSessions() {
+		return this.authProxy("revoke-sessions").post();
+	}
+	revokeOtherSessions() {
+		return this.authProxy("revoke-other-sessions").post();
+	}
+	checkTokenValid(token) {
+		const normalized = this.normalizeToken(token);
+		return this.proxy.check_logged.get({ params: normalized ? { token: normalized } : void 0 });
+	}
+};
+
+//#endregion
+//#region controllers/page.ts
+var PageController = class {
+	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?.join(" "),
+			sortBy,
+			sortOrder
+		} });
+	}
+	/**
+	* 页面详情
+	*/
+	getById(id) {
+		return this.proxy(id).get();
+	}
+	/**
+	* 根据路径获取页面
+	* @param slug 路径
+	* @returns
+	*/
+	getBySlug(slug, options) {
+		return this.proxy.slug(slug).get({ params: options?.prefer ? { prefer: options.prefer } : void 0 });
+	}
+};
+
+//#endregion
+//#region controllers/post.ts
+var PostController = class {
+	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
+	* @param options 可选参数，包含 lang 用于获取翻译版本
+	* @returns 当传入 lang 时，返回的文章可能包含 isTranslated 和 translationMeta 字段
+	*/
+	getList(page = 1, perPage = 10, options = {}) {
+		const { select, sortBy, sortOrder, year, truncate, lang } = options;
+		return this.proxy.get({ params: {
+			page,
+			size: perPage,
+			select: select?.join(" "),
+			sortBy,
+			sortOrder,
+			year,
+			truncate,
+			lang
+		} });
+	}
+	getPost(idOrCategoryName, slug, options) {
+		if (arguments.length == 1) return this.proxy(idOrCategoryName).get();
+		else {
+			const params = {};
+			if (options?.lang) params.lang = options.lang;
+			if (options?.prefer) params.prefer = options.prefer;
+			return this.proxy(idOrCategoryName)(slug).get({ params: Object.keys(params).length ? params : void 0 });
+		}
+	}
+	/**
+	* 获取最新的文章
+	*/
+	getLatest() {
+		return this.proxy.latest.get();
+	}
+	getFullUrl(slug) {
+		return this.proxy("get-url")(slug).get();
+	}
+};
+
+//#endregion
+//#region controllers/project.ts
+var ProjectController = class extends BaseCrudController {
+	constructor(client) {
+		super(client);
+		this.client = client;
+		this.base = "projects";
+		this.name = "project";
+		autoBind(this);
+	}
+};
+
+//#endregion
+//#region controllers/recently.ts
+let RecentlyAttitudeResultEnum = /* @__PURE__ */ function(RecentlyAttitudeResultEnum) {
+	RecentlyAttitudeResultEnum[RecentlyAttitudeResultEnum["Inc"] = 1] = "Inc";
+	RecentlyAttitudeResultEnum[RecentlyAttitudeResultEnum["Dec"] = -1] = "Dec";
+	return RecentlyAttitudeResultEnum;
+}({});
+let RecentlyAttitudeEnum = /* @__PURE__ */ function(RecentlyAttitudeEnum) {
+	RecentlyAttitudeEnum[RecentlyAttitudeEnum["Up"] = 0] = "Up";
+	RecentlyAttitudeEnum[RecentlyAttitudeEnum["Down"] = 1] = "Down";
+	return RecentlyAttitudeEnum;
+}({});
+var RecentlyController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "recently";
+		this.name = ["recently", "shorthand"];
+		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 } = {}) {
+		return this.proxy.get({ params: {
+			before,
+			after,
+			size
+		} });
+	}
+	getById(id) {
+		return this.proxy(id).get();
+	}
+	/**  表态：点赞，点踩 */
+	attitude(id, attitude) {
+		return this.proxy.attitude(id).get({ params: { attitude } });
+	}
+};
+
+//#endregion
+//#region controllers/say.ts
+var SayController = class 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();
+	}
+};
+
+//#endregion
+//#region controllers/search.ts
+var SearchController = class {
+	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: {
+			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: {
+			keyword,
+			...options
+		} });
+	}
+};
+
+//#endregion
+//#region controllers/severless.ts
+var ServerlessController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "serverless";
+		this.name = "serverless";
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	getByReferenceAndName(reference, name) {
+		return this.proxy(reference)(name).get();
+	}
+};
+
+//#endregion
+//#region controllers/snippet.ts
+var SnippetController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "snippets";
+		this.name = "snippet";
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	getByReferenceAndName(reference, name) {
+		return this.proxy(reference)(name).get();
+	}
+};
+
+//#endregion
+//#region controllers/subscribe.ts
+var SubscribeController = class {
+	constructor(client) {
+		this.client = client;
+		this.base = "subscribe";
+		this.name = "subscribe";
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	/**
+	* 检查开启状态
+	*/
+	check() {
+		return this.proxy.status.get();
+	}
+	subscribe(email, types) {
+		return this.proxy.post({ data: {
+			email,
+			types
+		} });
+	}
+	unsubscribe(email, cancelToken) {
+		return this.proxy.unsubscribe.get({ params: {
+			email,
+			cancelToken
+		} });
+	}
+};
+
+//#endregion
+//#region controllers/topic.ts
+var TopicController = class extends BaseCrudController {
+	constructor(client) {
+		super(client);
+		this.client = client;
+		this.base = "topics";
+		this.name = "topic";
+		autoBind(this);
+	}
+	get proxy() {
+		return this.client.proxy(this.base);
+	}
+	getTopicBySlug(slug) {
+		return this.proxy.slug(slug).get();
+	}
+};
+
+//#endregion
+//#region controllers/index.ts
+const allControllers = [
+	AckController,
+	ActivityController,
+	AggregateController,
+	AIController,
+	CategoryController,
+	CommentController,
+	LinkController,
+	NoteController,
+	PageController,
+	PostController,
+	ProjectController,
+	RecentlyController,
+	SayController,
+	SearchController,
+	ServerlessController,
+	SnippetController,
+	SubscribeController,
+	TopicController,
+	UserController
+];
+const allControllerNames = [
+	"ai",
+	"ack",
+	"activity",
+	"aggregate",
+	"category",
+	"comment",
+	"link",
+	"note",
+	"page",
+	"post",
+	"project",
+	"topic",
+	"recently",
+	"say",
+	"search",
+	"snippet",
+	"serverless",
+	"subscribe",
+	"owner",
+	"friend",
+	"shorthand"
+];
+
+//#endregion
+//#region core/attach-request.ts
+function attachRequestMethod(target) {
+	Object.defineProperty(target, "$$get", { value(url, options) {
+		const { params = {}, ...rest } = options;
+		const qs = handleSearchParams(params);
+		return target.instance.get(`${url}${qs ? String(`?${qs}`) : ""}`, rest);
+	} });
+	[
+		"put",
+		"post",
+		"patch",
+		"delete"
+	].forEach((method) => {
+		Object.defineProperty(target, `$$${method}`, { value(path, options) {
+			return target.instance[method](path, options);
+		} });
+	});
+}
+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();
+}
+
+//#endregion
+//#region core/client.ts
+const methodPrefix = "_$";
+var HTTPClient = class {
+	constructor(_endpoint, _adaptor, options = {}) {
+		this._endpoint = _endpoint;
+		this._adaptor = _adaptor;
+		this.options = options;
+		this._endpoint = _endpoint.replace(/\/*$/, "");
+		this._proxy = this.buildRoute(this)();
+		options.transformResponse || (options.transformResponse = (data) => camelcaseKeys(data));
+		options.getDataFromResponse || (options.getDataFromResponse = (res) => res.data);
+		this.initGetClient();
+		attachRequestMethod(this);
+	}
+	initGetClient() {
+		for (const name of allControllerNames) Object.defineProperty(this, name, {
+			get() {
+				const client = Reflect.get(this, `${methodPrefix}${name}`);
+				if (!client) throw new ReferenceError(`${name.charAt(0).toUpperCase() + name.slice(1)} Client not inject yet, please inject with client.injectClients(...)`);
+				return client;
+			},
+			configurable: false,
+			enumerable: false
+		});
+	}
+	injectControllers(Controller, ...rest) {
+		Controller = Array.isArray(Controller) ? Controller : [Controller, ...rest];
+		for (const Client of Controller) {
+			const cl = new Client(this);
+			if (Array.isArray(cl.name)) for (const name of cl.name) attach.call(this, name, cl);
+			else attach.call(this, cl.name, cl);
+		}
+		function attach(name, cl) {
+			Object.defineProperty(this, `${methodPrefix}${name.toLowerCase()}`, {
+				get() {
+					return cl;
+				},
+				enumerable: false,
+				configurable: false
+			});
+		}
+	}
+	get endpoint() {
+		return this._endpoint;
+	}
+	get instance() {
+		return this._adaptor;
+	}
+	request(options) {
+		return this[`$$${String(options.method || "get").toLowerCase()}`](options.url, options);
+	}
+	get proxy() {
+		return this._proxy;
+	}
+	buildRoute(manager) {
+		const noop = () => {};
+		const methods = [
+			"get",
+			"post",
+			"delete",
+			"patch",
+			"put"
+		];
+		const reflectors = [
+			"toString",
+			"valueOf",
+			"inspect",
+			"constructor",
+			Symbol.toPrimitive
+		];
+		const that = this;
+		return () => {
+			const route = [""];
+			const handler = {
+				get(target, name) {
+					if (reflectors.includes(name)) return (withBase) => {
+						if (withBase) {
+							const path = resolveFullPath(that.endpoint, route.join("/"));
+							route.length = 0;
+							return path;
+						} else {
+							const path = route.join("/");
+							route.length = 0;
+							return path.startsWith("/") ? path : `/${path}`;
+						}
+					};
+					if (methods.includes(name)) return async (options) => {
+						const url = resolveFullPath(that.endpoint, route.join("/"));
+						route.length = 0;
+						let res;
+						try {
+							res = await manager.request({
+								method: name,
+								...options,
+								url
+							});
+						} catch (error) {
+							let message = error.message;
+							let code = error.code || error.status || error.statusCode || error.response?.status || error.response?.statusCode || error.response?.code || 500;
+							if (that.options.getCodeMessageFromException) {
+								const errorInfo = that.options.getCodeMessageFromException(error);
+								message = errorInfo.message || message;
+								code = errorInfo.code || code;
+							}
+							throw that.options.customThrowResponseError ? that.options.customThrowResponseError(error) : new RequestError(message, code, url, error);
+						}
+						const data = that.options.getDataFromResponse(res);
+						if (!data) return null;
+						const cameledObject = (Array.isArray(data) || isPlainObject(data)) && that.options.transformResponse ? that.options.transformResponse(data) : data;
+						let nextObject = cameledObject;
+						if (cameledObject && typeof cameledObject === "object") {
+							nextObject = Array.isArray(cameledObject) ? [...cameledObject] : { ...cameledObject };
+							Object.defineProperty(nextObject, "$raw", {
+								get() {
+									return res;
+								},
+								enumerable: false,
+								configurable: false
+							});
+							Object.defineProperty(nextObject, "$request", {
+								get() {
+									return {
+										url,
+										method: name,
+										options
+									};
+								},
+								enumerable: false
+							});
+							Object.defineProperty(nextObject, "$serialized", { get() {
+								return cameledObject;
+							} });
+						}
+						return nextObject;
+					};
+					route.push(name);
+					return new Proxy(noop, handler);
+				},
+				apply(target, _, args) {
+					route.push(...args.filter((x) => x !== null));
+					return new Proxy(noop, handler);
+				}
+			};
+			return new Proxy(noop, handler);
+		};
+	}
+};
+function createClient(adapter) {
+	return (endpoint, options) => {
+		const client = new HTTPClient(endpoint, adapter, options);
+		const { controllers } = options || {};
+		if (controllers) client.injectControllers(controllers);
+		return client;
+	};
+}
+
+//#endregion
+//#region models/aggregate.ts
+let TimelineType = /* @__PURE__ */ function(TimelineType) {
+	TimelineType[TimelineType["Post"] = 0] = "Post";
+	TimelineType[TimelineType["Note"] = 1] = "Note";
+	return TimelineType;
+}({});
+
+//#endregion
+//#region ../../apps/core/src/constants/db.constant.ts
+const NOTE_COLLECTION_NAME = "notes";
+const PAGE_COLLECTION_NAME = "pages";
+const POST_COLLECTION_NAME = "posts";
+const RECENTLY_COLLECTION_NAME = "recentlies";
+let CollectionRefTypes = /* @__PURE__ */ function(CollectionRefTypes) {
+	CollectionRefTypes[CollectionRefTypes["Post"] = POST_COLLECTION_NAME] = "Post";
+	CollectionRefTypes[CollectionRefTypes["Note"] = NOTE_COLLECTION_NAME] = "Note";
+	CollectionRefTypes[CollectionRefTypes["Page"] = PAGE_COLLECTION_NAME] = "Page";
+	CollectionRefTypes[CollectionRefTypes["Recently"] = RECENTLY_COLLECTION_NAME] = "Recently";
+	return CollectionRefTypes;
+}({});
+
+//#endregion
+//#region models/comment.ts
+let CommentState = /* @__PURE__ */ function(CommentState) {
+	CommentState[CommentState["Unread"] = 0] = "Unread";
+	CommentState[CommentState["Read"] = 1] = "Read";
+	CommentState[CommentState["Junk"] = 2] = "Junk";
+	return CommentState;
+}({});
+
+//#endregion
+//#region models/link.ts
+let LinkType = /* @__PURE__ */ function(LinkType) {
+	LinkType[LinkType["Friend"] = 0] = "Friend";
+	LinkType[LinkType["Collection"] = 1] = "Collection";
+	return LinkType;
+}({});
+let LinkState = /* @__PURE__ */ function(LinkState) {
+	LinkState[LinkState["Pass"] = 0] = "Pass";
+	LinkState[LinkState["Audit"] = 1] = "Audit";
+	LinkState[LinkState["Outdate"] = 2] = "Outdate";
+	LinkState[LinkState["Banned"] = 3] = "Banned";
+	LinkState[LinkState["Reject"] = 4] = "Reject";
+	return LinkState;
+}({});
+
+//#endregion
+//#region models/page.ts
+let EnumPageType = /* @__PURE__ */ function(EnumPageType) {
+	EnumPageType["md"] = "md";
+	EnumPageType["html"] = "html";
+	EnumPageType["frame"] = "frame";
+	return EnumPageType;
+}({});
+
+//#endregion
+//#region models/recently.ts
+let RecentlyRefTypes = /* @__PURE__ */ function(RecentlyRefTypes) {
+	RecentlyRefTypes["Post"] = "Post";
+	RecentlyRefTypes["Note"] = "Note";
+	RecentlyRefTypes["Page"] = "Page";
+	return RecentlyRefTypes;
+}({});
+let RecentlyTypeEnum = /* @__PURE__ */ function(RecentlyTypeEnum) {
+	RecentlyTypeEnum["Text"] = "text";
+	RecentlyTypeEnum["Book"] = "book";
+	RecentlyTypeEnum["Media"] = "media";
+	RecentlyTypeEnum["Music"] = "music";
+	RecentlyTypeEnum["Github"] = "github";
+	RecentlyTypeEnum["Link"] = "link";
+	RecentlyTypeEnum["Academic"] = "academic";
+	RecentlyTypeEnum["Code"] = "code";
+	return RecentlyTypeEnum;
+}({});
+
+//#endregion
+//#region models/snippet.ts
+let SnippetType = /* @__PURE__ */ function(SnippetType) {
+	SnippetType["JSON"] = "json";
+	SnippetType["Function"] = "function";
+	SnippetType["Text"] = "text";
+	SnippetType["YAML"] = "yaml";
+	return SnippetType;
+}({});
+
+//#endregion
+//#region ../../apps/core/src/modules/subscribe/subscribe.constant.ts
+const SubscribePostCreateBit = 1;
+const SubscribeNoteCreateBit = 2;
+const SubscribeSayCreateBit = 4;
+const SubscribeRecentCreateBit = 8;
+const SubscribeAllBit = 15;
+const SubscribeTypeToBitMap = {
+	post_c: SubscribePostCreateBit,
+	note_c: SubscribeNoteCreateBit,
+	say_c: SubscribeSayCreateBit,
+	recently_c: SubscribeRecentCreateBit,
+	all: SubscribeAllBit
+};
+
+//#endregion
+//#region index.ts
+var api_client_default = createClient;
+
+//#endregion
+exports.AIController = AIController;
+exports.AckController = AckController;
+exports.ActivityController = ActivityController;
+exports.AggregateController = AggregateController;
+exports.CategoryController = CategoryController;
+exports.CategoryType = CategoryType;
+exports.CollectionRefTypes = CollectionRefTypes;
+exports.CommentController = CommentController;
+exports.CommentState = CommentState;
+exports.EnumPageType = EnumPageType;
+exports.LinkController = LinkController;
+exports.LinkState = LinkState;
+exports.LinkType = LinkType;
+exports.NoteController = NoteController;
+exports.PageController = PageController;
+exports.PostController = PostController;
+exports.ProjectController = ProjectController;
+exports.RecentlyAttitudeEnum = RecentlyAttitudeEnum;
+exports.RecentlyAttitudeResultEnum = RecentlyAttitudeResultEnum;
+exports.RecentlyController = RecentlyController;
+exports.RecentlyRefTypes = RecentlyRefTypes;
+exports.RecentlyTypeEnum = RecentlyTypeEnum;
+exports.RequestError = RequestError;
+exports.SayController = SayController;
+exports.SearchController = SearchController;
+exports.ServerlessController = ServerlessController;
+exports.SnippetController = SnippetController;
+exports.SnippetType = SnippetType;
+exports.SubscribeAllBit = SubscribeAllBit;
+exports.SubscribeController = SubscribeController;
+exports.SubscribeNoteCreateBit = SubscribeNoteCreateBit;
+exports.SubscribePostCreateBit = SubscribePostCreateBit;
+exports.SubscribeRecentCreateBit = SubscribeRecentCreateBit;
+exports.SubscribeSayCreateBit = SubscribeSayCreateBit;
+exports.SubscribeTypeToBitMap = SubscribeTypeToBitMap;
+exports.TimelineType = TimelineType;
+exports.TopicController = TopicController;
+exports.UserController = UserController;
+exports.allControllerNames = allControllerNames;
+exports.allControllers = allControllers;
+exports.createClient = createClient;
+exports.default = api_client_default;
+exports.simpleCamelcaseKeys = camelcaseKeys;