1
import type { CommentConfig } from "../types/config";
2

3
export const commentConfig: CommentConfig = {
4
  type: 'none', // 当前启用的评论系统类型: none, twikoo, waline, giscus, disqus，默认为none，即不启用评论系统。
5
  type: 'giscus', // 当前启用的评论系统类型: none, twikoo, waline, giscus, disqus，默认为none，即不启用评论系统。
6
  // ...
7
  //giscus评论系统配置（还未测试）
8
  giscus: {
9
    repo: 'CuteLeaf/Firefly', // 设置 Giscus 评论系统仓库
10
    repoId: 'R_kgD2gfdFGd', // 设置 Giscus 评论系统仓库ID
11
    category: 'General', // 设置 Giscus 评论系统分类
12
    categoryId: 'DIC_kwDOKy9HOc4CegmW', // 设置 Giscus 评论系统分类ID
13
    repo: 'xpfxzxc/xpfxzxc.github.io', // 设置 Giscus 评论系统仓库
14
    repoId: 'R_kgDOQIvG_Q', // 设置 Giscus 评论系统仓库ID
15
    category: 'Announcements', // 设置 Giscus 评论系统分类
16
    categoryId: 'DIC_kwDOQIvG_c4Cxnv0', // 设置 Giscus 评论系统分类ID
17
    mapping: 'title', // 设置 Giscus 评论系统映射方式
18
    strict: '0', // 设置 Giscus 评论系统严格模式
19
    reactionsEnabled: '1', // 设置 Giscus 评论系统反应功能
20
    emitMetadata: '1', // 设置 Giscus 评论系统元数据
21
    inputPosition: 'top', // 设置 Giscus 评论系统输入位置
22
    theme: 'light', // 设置 Giscus 评论系统主题
23
    lang: 'zh-CN', // 设置 Giscus 评论系统语言
24
    loading: 'lazy', // 设置 Giscus 评论系统加载方式
25
  },
26
  // ...
27
};

1
import type { NextApiRequest, NextApiResponse } from 'next';
2
import { encodeState } from '../../../lib/oauth/state';
3
import { env } from '../../../lib/variables';
4

5
const GITHUB_OAUTH_AUTHORIZE_URL = 'https://github.com/login/oauth/authorize';
6

7
export default async function OAuthAuthorizeApi(req: NextApiRequest, res: NextApiResponse) {
8
  const appReturnUrl = req.query.redirect_uri as string;
9

10
  if (!appReturnUrl) {
11
    res.status(400).json({ error: '`redirect_uri` is required.' });
12
    return;
13
  }
14

15
  const { client_id } = env;
16
  const proto = req.headers['x-forwarded-proto'] || 'http';
17
  const redirect_uri = `${proto}://${req.headers.host}/api/oauth/authorized`;
18
  const state = await encodeState(appReturnUrl, env.encryption_password);
19

20
  const oauthParams = new URLSearchParams({ client_id, redirect_uri, state });
21
  res.redirect(302, `${GITHUB_OAUTH_AUTHORIZE_URL}?${oauthParams}`);
22
}

1
import type { NextApiRequest, NextApiResponse } from 'next';
2
import { encodeState, decodeState } from '../../../lib/oauth/state';
3
import { env } from '../../../lib/variables';
4

5
const GITHUB_OAUTH_ACCESS_TOKEN_URL = 'https://github.com/login/oauth/access_token';
6
const TOKEN_VALIDITY_PERIOD = 1000 * 60 * 60 * 24 * 365; // 1 year;
7

8
export default async function OAuthAuthorizedApi(req: NextApiRequest, res: NextApiResponse) {
9
  const code = req.query.code as string;
10
  const state = req.query.state as string;
11
  const error = req.query.error as string;
12

13
  const { client_id, client_secret, encryption_password } = env;
14

15
  let appReturnUrl: string;
16
  try {
17
    appReturnUrl = await decodeState(state, encryption_password);
18
  } catch (err) {
19
    res.status(400).json({ error: err.message });
20
    return;
21
  }
22

23
  const returnUrl = new URL(appReturnUrl);
24

25
  if (error && error === 'access_denied') {
26
    res.redirect(302, returnUrl.href);
27
    return;
28
  }
29

30
  if (!code || !state) {
31
    res.status(400).json({ error: '`code` and `state` are required.' });
32
    return;
33
  }
34

35
  const init = {
36
    method: 'POST',
37
    body: new URLSearchParams({ client_id, client_secret, code, state }),
38
    headers: {
39
      Accept: 'application/json',
40
      'User-Agent': 'giscus',
41
    },
42
  };
43

44
  let accessToken: string;
45
  try {
46
    const response = await fetch(GITHUB_OAUTH_ACCESS_TOKEN_URL, init);
47
    if (response.ok) {
48
      const data = await response.json();
49
      accessToken = data.access_token;
50
    } else {
51
      throw new Error(`Access token response had status ${response.status}.`);
52
    }
53
  } catch (err) {
54
    res.status(503).json({ error: err.message });
55
    return;
56
  }
57

58
  const session = await encodeState(
59
    accessToken,
60
    encryption_password,
61
    Date.now() + TOKEN_VALIDITY_PERIOD,
62
  );
63
  returnUrl.searchParams.set('giscus', session);
64

65
  res.redirect(302, returnUrl.href);
66
}

1
// Set up session and clear the session param on load
2
const url = new URL(location.href);
3
let session = url.searchParams.get('giscus') || '';
4
const savedSession = localStorage.getItem(GISCUS_SESSION_KEY);
5
url.searchParams.delete('giscus');
6
url.hash = '';
7
const cleanedLocation = url.toString();
8

9
if (session) {
10
  localStorage.setItem(GISCUS_SESSION_KEY, JSON.stringify(session));
11
  history.replaceState(undefined, document.title, cleanedLocation);
12
} else if (savedSession) {
13
  try {
14
    session = JSON.parse(savedSession);
15
  } catch (e) {
16
    localStorage.removeItem(GISCUS_SESSION_KEY);
17
    console.warn(`${formatError(e?.message)} Session has been cleared.`);
18
  }
19
}

1
const attributes = script.dataset;
2
const params: Record<string, string> = {};
3

4
params.origin = cleanedLocation;
5
params.session = session as string;
6
params.theme = attributes.theme as string;
7
params.reactionsEnabled = attributes.reactionsEnabled || '1';
8
params.emitMetadata = attributes.emitMetadata || '0';
9
params.inputPosition = attributes.inputPosition || 'bottom';
10
params.repo = attributes.repo as string;
11
params.repoId = attributes.repoId as string;
12
params.category = attributes.category || '';
13
params.categoryId = attributes.categoryId as string;
14
params.strict = attributes.strict || '0';
15
params.description = getMetaContent('description', true);
16
params.backLink = getMetaContent('giscus:backlink') || cleanedLocation;
17

18
switch (attributes.mapping) {
19
  case 'url':
20
    params.term = cleanedLocation;
21
    break;
22
  case 'title':
23
    params.term = document.title;
24
    break;
25
  case 'og:title':
26
    params.term = getMetaContent('title', true);
27
    break;
28
  case 'specific':
29
    params.term = attributes.term as string;
30
    break;
31
  case 'number':
32
    params.number = attributes.term as string;
33
    break;
34
  case 'pathname':
35
  default:
36
    params.term =
37
      location.pathname.length < 2
38
        ? 'index'
39
        : location.pathname.substring(1).replace(/\.\w+$/, '');
40
    break;
41
}
42

43
// Check anchor of the existing container and append it to origin URL
44
const existingContainer = document.querySelector('.giscus');
45
const id = existingContainer && existingContainer.id;
46
if (id) {
47
  params.origin = `${cleanedLocation}#${id}`;
48
}
49

50
// Set up iframe src and loading attribute
51
const locale = attributes.lang ? `/${attributes.lang}` : '';
52
const src = `${giscusOrigin}${locale}/widget?${new URLSearchParams(params)}`;
53
const loading = attributes.loading === 'lazy' ? 'lazy' : undefined;

1
// Set up iframe element
2
const iframeElement = document.createElement('iframe');
3
const iframeAttributes = {
4
  class: 'giscus-frame giscus-frame--loading',
5
  title: 'Comments',
6
  scrolling: 'no',
7
  allow: 'clipboard-write',
8
  src,
9
  loading,
10
};
11
Object.entries(iframeAttributes).forEach(
12
  ([key, value]) => value && iframeElement.setAttribute(key, value),
13
);

1
const session = (query.session as string) || '';
2
const repo = (query.repo as string) || '';
3
// ... 接收其他参数

1
const { encryption_password } = env;
2
const token = await decodeState(session, encryption_password)
3
  .catch(() => getAppAccessToken(repo))
4
  .catch(() => '');

1
// Listen to messages
2
window.addEventListener('message', (event) => {
3
  if (event.origin !== giscusOrigin) return;
4

5
  const { data } = event;
6
  if (!(typeof data === 'object' && data.giscus)) return;
7

8
  if (data.giscus.resizeHeight) {
9
    iframeElement.style.height = `${data.giscus.resizeHeight}px`;
10
  }
11

12
  if (data.giscus.signOut) {
13
    localStorage.removeItem(GISCUS_SESSION_KEY);
14
    console.log(`[giscus] User has logged out. Session has been cleared.`);
15
    signOut();
16
    return;
17
  }
18
  // ...
19
})

1
function signOut() {
2
  delete params.session;
3
  const src = `${giscusOrigin}${locale}/widget?${new URLSearchParams(params)}`;
4
  iframeElement.src = src; // Force reload
5
}