upgrade katex to 0.12, wiki load

hydro/entry/common.ts

@@ -218,21 +218,22 @@ export async function wiki(pending: string[], fail: string[]) {
         const p = path.resolve(i, 'wiki');
         if (fs.existsSync(p) && fs.statSync(p).isDirectory() && !fail.includes(i)) {
             try {
-                const r = {};
                 const categories = fs.readdirSync(p);
                 for (const category of categories) {
+                    console.log('category', category);
                     if (!fs.statSync(p).isDirectory()) return;
                     const pages = fs.readdirSync(path.join(p, category));
-                    const res = {};
+                    if (!global.Hydro.wiki[category]) global.Hydro.wiki[category] = {};
+                    console.log(pages);
                     for (const page of pages) {
                         const c = fs.readFileSync(path.join(p, category, page)).toString().split('\n');
                         const pagename = page.split('.')[0];
-                        res[pagename] = [];
+                        global.Hydro.wiki[category][pagename] = [];
                         let content = null;
                         for (let j = 0; j < c.length; j++) {
                             const line = c[j];
                             if (line.startsWith('# ')) {
-                                if (content) res[pagename].push(content);
+                                if (content) global.Hydro.wiki[category][pagename].push(content);
                                 content = {};
                                 const t = line.split('# ')[1].split('|');
                                 [content.title, content.id] = t.map((q) => q.trim());
@@ -242,7 +243,6 @@ export async function wiki(pending: string[], fail: string[]) {
                             }
                         }
                     }
-                    r[category] = res;
                 }
                 console.log(`Wiki init: ${i}`);
             } catch (e) {

hydro/entry/unzip.ts

@@ -44,9 +44,6 @@ export async function load() {
             const files = fs.readdirSync(moduleRoot);
             for (const file of files) {
                 try {
-                    // This fixs a mistake.
-                    // Markdown-it-katex is not a hydro module but a dependency.
-                    if (file === 'markdown-it-katex') continue;
                     const modulePath = path.join(moduleRoot, file);
                     const packagejson = path.join(modulePath, 'package.json');
                     if (fs.statSync(modulePath).isFile() && file.endsWith('.hydro')) {

hydro/entry/worker.ts

@@ -56,7 +56,6 @@ export async function load() {
         }
     }
     for (const i of builtinScript) require(`../script/${i}`);
-    await wiki(pending, fail);
     await script(pending, fail, active);
     for (const postInit of global.Hydro.postInit) {
         await postInit();

hydro/handler/record.ts

@@ -35,9 +35,10 @@ class RecordListHandler extends RecordHandler {
             page,
             await system.get('RECORD_PER_PAGE'),
         );
+        const canViewProblemHidden = this.user.hasPerm(PERM.PERM_VIEW_PROBLEM_HIDDEN);
         const [udict, pdict] = await Promise.all([
             user.getList(domainId, rdocs.map((rdoc) => rdoc.uid)),
-            problem.getList(domainId, rdocs.map((rdoc) => rdoc.pid), false, false),
+            problem.getList(domainId, rdocs.map((rdoc) => rdoc.pid), canViewProblemHidden, false),
         ]);
         const path = [
             ['Hydro', 'homepage'],
@@ -100,7 +101,7 @@ class RecordRejudgeHandler extends Handler {
 const RecordConnectionHandler = contest.ContestHandlerMixin(ConnectionHandler);
 
 class RecordMainConnectionHandler extends RecordConnectionHandler {
-    @param('tid', Types.ObjectID)
+    @param('tid', Types.ObjectID, true)
     async prepare(domainId: string, tid: ObjectID) {
         this.domainId = domainId;
         if (tid) {

hydro/handler/wiki.ts

@@ -10,13 +10,14 @@ class WikiHandler extends Handler {
         if (!global.Hydro.wiki[category]) throw new NotFoundError(category);
         if (!global.Hydro.wiki[category][page]) throw new NotFoundError(category, page);
         const contents = global.Hydro.wiki[category][page];
+        const pages = Object.keys(global.Hydro.wiki[category]);
         const path = [
             ['Hydro', 'homepage'],
             [`wiki_${category}`, null],
             [`wiki_${category}_${page}`, null],
         ];
         this.response.body = {
-            path, contents, page_name: `wiki_${category}_${page}`,
+            path, contents, pages, page_name: `wiki_${category}_${page}`,
         };
         this.response.template = 'wiki.html';
     }

hydro/lib/markdown.ts

@@ -2,7 +2,6 @@ import MarkdownIt from 'markdown-it';
 import Prism from 'prismjs';
 
 // For math: $a\times b\eq 10$
-import katex from '@hydrooj/markdown-it-katex';
 // Specific image size: ![image](image.png =100x100)
 import Imsize from 'markdown-it-imsize';
 /* Footnote support.
@@ -25,6 +24,7 @@ import Container from 'markdown-it-container';
 import TOC from 'markdown-it-table-of-contents';
 
 import Anchor from 'markdown-it-anchor';
+import katex from '../markdown/katex';
 
 const md = MarkdownIt();
 

hydro/markdown/katex.ts

@@ -0,0 +1,137 @@
+// https://github.com/hydro-dev/markdown-it-katex/blob/master/index.js
+import katex from 'katex';
+import MarkdownIt from 'markdown-it';
+
+function isValidDelim(state, pos: number) {
+    const max = state.posMax;
+    const prevChar = pos > 0 ? state.src.charCodeAt(pos - 1) : -1;
+    const nextChar = pos + 1 <= max ? state.src.charCodeAt(pos + 1) : -1;
+    let canOpen = true;
+    let canClose = true;
+    if (prevChar === 0x20/* " " */ || prevChar === 0x09
+        ||/* \t */ (nextChar >= 0x30/* "0" */ && nextChar <= 0x39/* "9" */)) {
+        canClose = false;
+    }
+    if (nextChar === 0x20/* " " */ || nextChar === 0x09/* \t */) {
+        canOpen = false;
+    }
+    return { canOpen, canClose };
+}
+
+function mathInline(state, silent: boolean) {
+    let match;
+    let res;
+    let pos;
+    if (state.src[state.pos] !== '$') return false;
+    res = isValidDelim(state, state.pos);
+    if (!res.canOpen) {
+        if (!silent) state.pending += '$';
+        state.pos += 1;
+        return true;
+    }
+    const start = state.pos + 1;
+    match = start;
+    // eslint-disable-next-line no-cond-assign
+    while ((match = state.src.indexOf('$', match)) !== -1) {
+        pos = match - 1;
+        while (state.src[pos] === '\\') pos -= 1;
+        if (((match - pos) % 2) === 1) break;
+        match += 1;
+    }
+    if (match === -1) {
+        if (!silent) state.pending += '$';
+        state.pos = start;
+        return true;
+    }
+    if (match - start === 0) {
+        if (!silent) state.pending += '$$';
+        state.pos = start + 1;
+        return true;
+    }
+    res = isValidDelim(state, match);
+    if (!res.can_close) {
+        if (!silent) state.pending += '$';
+        state.pos = start;
+        return true;
+    }
+    if (!silent) {
+        const token = state.push('math_inline', 'math', 0);
+        token.markup = '$';
+        token.content = state.src.slice(start, match);
+    }
+    state.pos = match + 1;
+    return true;
+}
+
+function mathBlock(state, start, end, silent) {
+    let lastLine;
+    let next;
+    let lastPos;
+    let found = false;
+    let pos = state.bMarks[start] + state.tShift[start];
+    let max = state.eMarks[start];
+    if (pos + 2 > max) return false;
+    if (state.src.slice(pos, pos + 2) !== '$$') return false;
+    pos += 2;
+    let firstLine = state.src.slice(pos, max);
+    if (silent) return true;
+    if (firstLine.trim().slice(-2) === '$$') {
+        firstLine = firstLine.trim().slice(0, -2);
+        found = true;
+    }
+    for (next = start; !found;) {
+        next++;
+        if (next >= end) break;
+        pos = state.bMarks[next] + state.tShift[next];
+        max = state.eMarks[next];
+        if (pos < max && state.tShift[next] < state.blkIndent) break;
+        if (state.src.slice(pos, max).trim().slice(-2) === '$$') {
+            lastPos = state.src.slice(0, max).lastIndexOf('$$');
+            lastLine = state.src.slice(pos, lastPos);
+            found = true;
+        }
+    }
+    state.line = next + 1;
+    const token = state.push('math_block', 'math', 0);
+    token.block = true;
+    token.content = (firstLine && firstLine.trim() ? `${firstLine}\n` : '')
+        + state.getLines(start + 1, next, state.tShift[start], true)
+        + (lastLine && lastLine.trim() ? lastLine : '');
+    token.map = [start, state.line];
+    token.markup = '$$';
+    return true;
+}
+
+export default function plugin(md: MarkdownIt, options) {
+    options = options || {};
+    function katexInline(latex: string) {
+        options.displayMode = false;
+        try {
+            return katex.renderToString(latex, options);
+        } catch (error) {
+            if (options.throwOnError) console.log(error);
+            return latex;
+        }
+    }
+    function inlineRenderer(tokens, idx) {
+        return katexInline(tokens[idx].content);
+    }
+    function katexBlock(latex: string) {
+        options.displayMode = true;
+        try {
+            return `<p>${katex.renderToString(latex, options)}</p>`;
+        } catch (error) {
+            if (options.throwOnError) console.log(error);
+            return latex;
+        }
+    }
+    function blockRenderer(tokens, idx) {
+        return `${katexBlock(tokens[idx].content)}\n`;
+    }
+    md.inline.ruler.after('escape', 'math_inline', mathInline);
+    md.block.ruler.after('blockquote', 'math_block', mathBlock, {
+        alt: ['paragraph', 'reference', 'blockquote', 'list'],
+    });
+    md.renderer.rules.math_inline = inlineRenderer;
+    md.renderer.rules.math_block = blockRenderer;
+}