@shzlx/ui-default 4.58.2

package/README.md

@@ -0,0 +1,5 @@
+# Hydro-UI-Default
+
+Based on Vijos-UI-Framework  
+
+See [vijos/vj4/vj4/ui/README.md](https://github.com/vijos/vj4/blob/master/vj4/ui/README.md)  

package/api.ts

@@ -0,0 +1,61 @@
+/* eslint-disable import/first */
+export * from './components/dialog';
+export { default as loadMonaco } from './components/monaco/loader';
+export { default as Notification } from './components/notification';
+export { default as Rotator } from './components/rotator';
+export { default as selectUser } from './components/selectUser';
+export { default as Socket } from './components/socket/index';
+export { default as uploadFiles } from './components/upload';
+export * from './components/zipDownloader';
+export { default as download } from './components/zipDownloader';
+export { Context, ctx, Service } from './context';
+export { initPageLoader } from './hydro';
+export * from './lazyload';
+export * from './misc/Page';
+export * from './utils';
+export * from '@hydrooj/utils/lib/common';
+export { AnsiUp } from 'ansi_up';
+export { default as $ } from 'jquery';
+export { default as _ } from 'lodash';
+export { default as React } from 'react';
+export * as redux from 'react-redux';
+export { default as jsxRuntime } from 'react/jsx-runtime';
+import ReactDOMMain from 'react-dom';
+import ReactDOMClient from 'react-dom/client';
+import { load } from './lazyload';
+
+Object.assign(ReactDOMMain, ReactDOMClient);
+
+export const ReactDOM = ReactDOMMain as typeof ReactDOMMain & typeof ReactDOMClient;
+export default load;
+export interface EventMap { }
+
+import AutoComplete from './components/autocomplete';
+import AssignSelectAutoComplete from './components/autocomplete/AssignSelectAutoComplete';
+import CustomSelectAutoComplete from './components/autocomplete/CustomSelectAutoComplete';
+import DomainSelectAutoComplete from './components/autocomplete/DomainSelectAutoComplete';
+import ProblemSelectAutoComplete from './components/autocomplete/ProblemSelectAutoComplete';
+import UserSelectAutoComplete from './components/autocomplete/UserSelectAutoComplete';
+
+export {
+  AssignSelectAutoComplete, AutoComplete, CustomSelectAutoComplete, DomainSelectAutoComplete, ProblemSelectAutoComplete, UserSelectAutoComplete,
+};
+export function addPage(page: import('./misc/Page').Page | (() => Promise<void> | void)) {
+  window.Hydro.extraPages.push(page);
+}
+
+declare global {
+  interface Window {
+    LANGS: Record<string, any>;
+    lazyloadMetadata: Record<string, string>;
+    lazyModuleResolver: Record<string, any>;
+  }
+
+  let UserContext: Record<string, any>; // eslint-disable-line
+  let UiContext: Record<string, any>; // eslint-disable-line
+}
+
+// Below are old version api compat
+import $ from 'jquery';
+
+Object.assign(window, { $, jQuery: $ });

package/backendlib/builder.ts

@@ -0,0 +1,182 @@
+import { tmpdir } from 'os';
+import {
+  basename, join, relative, resolve,
+} from 'path';
+import {
+  Context, fs, Handler, Logger, NotFoundError, param, SettingModel, sha1,
+  size, SystemModel, Types, UiContextBase,
+} from 'hydrooj';
+import esbuild from 'esbuild';
+
+declare module 'hydrooj' {
+  interface UI {
+    esbuildPlugins?: esbuild.Plugin[];
+  }
+  interface SystemKeys {
+    'ui-default.nav_logo_dark': string;
+  }
+  interface UiContextBase {
+    constantVersion?: string;
+  }
+}
+
+const vfs: Record<string, string> = {};
+const hashes: Record<string, string> = {};
+const logger = new Logger('ui');
+const tmp = tmpdir();
+
+const federationPlugin: esbuild.Plugin = {
+  name: 'federation',
+  setup(b) {
+    const packages = {
+      'react/jsx-runtime': 'jsxRuntime',
+      react: 'React',
+      'react-dom/client': 'ReactDOM',
+      'react-dom': 'ReactDOM',
+      jquery: '$',
+    };
+    b.onResolve({ filter: /^@hydrooj\/ui-default/ }, () => ({
+      path: 'api',
+      namespace: 'ui-default',
+    }));
+    for (const key in packages) {
+      b.onResolve({ filter: new RegExp(`^${key}$`) }, () => ({
+        path: packages[key],
+        namespace: 'ui-default',
+      }));
+    }
+    b.onLoad({ filter: /.*/, namespace: 'ui-default' }, (args) => {
+      if (args.path === 'api') {
+        return {
+          contents: 'module.exports = window.HydroExports;',
+          loader: 'tsx',
+        };
+      }
+      return {
+        contents: `module.exports = window.HydroExports['${args.path}'];`,
+        loader: 'tsx',
+      };
+    });
+  },
+};
+
+const build = async (contents: string) => {
+  const res = await esbuild.build({
+    tsconfigRaw: '{"compilerOptions":{"experimentalDecorators":true}}',
+    format: 'iife' as 'iife',
+    bundle: true,
+    outdir: tmp,
+    sourcemap: SystemModel.get('ui-default.nosourcemap') ? false : 'external',
+    splitting: false,
+    write: false,
+    target: ['chrome65'],
+    plugins: [
+      ...(global.Hydro.ui.esbuildPlugins || []),
+      federationPlugin,
+    ],
+    minify: !process.env.DEV,
+    stdin: {
+      contents,
+      sourcefile: 'stdin.ts',
+      resolveDir: tmp,
+      loader: 'ts',
+    },
+  });
+  if (res.errors.length) console.error(res.errors);
+  if (res.warnings.length) console.warn(res.warnings);
+  return res;
+};
+
+const applyCss = (css: string) => `
+  const style = document.createElement('style');
+  style.textContent = ${JSON.stringify(css)};
+  document.head.appendChild(style);
+`;
+
+export async function buildUI() {
+  const start = Date.now();
+  let totalSize = 0;
+  const entryPoints: string[] = [];
+  const lazyModules: string[] = [];
+  const newFiles = ['entry.js'];
+  for (const addon of Object.values(global.addons) as string[]) {
+    let publicPath = resolve(addon, 'frontend');
+    if (!fs.existsSync(publicPath)) publicPath = resolve(addon, 'public');
+    if (!fs.existsSync(publicPath)) continue;
+    const targets = fs.readdirSync(publicPath);
+    for (const target of targets) {
+      if (/\.page\.[jt]sx?$/.test(target)) entryPoints.push(join(publicPath, target));
+      if (/\.lazy\.[jt]sx?$/.test(target)) lazyModules.push(join(publicPath, target));
+    }
+  }
+  function addFile(name: string, content: string) {
+    vfs[name] = content;
+    hashes[name] = sha1(content).substring(0, 8);
+    logger.info('+ %s-%s: %s', name, hashes[name].substring(0, 6), size(content.length));
+    newFiles.push(name);
+    totalSize += content.length;
+  }
+  for (const m of lazyModules) {
+    const name = basename(m).split('.')[0];
+    const { outputFiles } = await build(`window.lazyModuleResolver['${name}'](require('${relative(tmp, m).replace(/\\/g, '\\\\')}'))`);
+    const css = outputFiles.filter((i) => i.path.endsWith('.css')).map((i) => i.text).join('\n');
+    for (const file of outputFiles) {
+      if (file.path.endsWith('.css')) continue;
+      addFile(basename(m).replace(/\.[tj]sx?$/, '.js'), (css ? applyCss(css) : '') + file.text);
+    }
+  }
+  for (const lang in global.Hydro.locales) {
+    if (!/^[a-zA-Z_]+$/.test(lang)) continue;
+    if (!global.Hydro.locales[lang].__interface) continue;
+    const str = `window.LOCALES=${JSON.stringify(global.Hydro.locales[lang][Symbol.for('iterate')])};`;
+    addFile(`lang-${lang}.js`, str);
+  }
+  const entry = await build([
+    `window.lazyloadMetadata = ${JSON.stringify(hashes)};`,
+    `window.LANGS=${JSON.stringify(SettingModel.langs)};`,
+    ...entryPoints.map((i) => `import '${relative(tmp, i).replace(/\\/g, '\\\\')}';`),
+  ].join('\n'));
+  const pages = entry.outputFiles.filter((i) => i.path.endsWith('.js')).map((i) => i.text);
+  const css = entry.outputFiles.filter((i) => i.path.endsWith('.css')).map((i) => i.text);
+  addFile('entry.js', `window._hydroLoad=()=>{
+    ${css.length ? applyCss(css.join('\n')) : ''}
+    ${pages.join('\n')}
+  };`);
+  UiContextBase.constantVersion = hashes['entry.js'];
+  for (const key in vfs) {
+    if (newFiles.includes(key)) continue;
+    delete vfs[key];
+    delete hashes[key];
+  }
+  logger.success('UI addons built in %d ms (%s)', Date.now() - start, size(totalSize));
+}
+
+class UiConstantsHandler extends Handler {
+  noCheckPermView = true;
+
+  @param('name', Types.Filename)
+  async all(domainId: string, name: string) {
+    this.response.type = 'application/javascript';
+    if (!vfs[name]) throw new NotFoundError(name);
+    this.response.addHeader('ETag', hashes[name]);
+    this.response.body = vfs[name];
+    this.response.addHeader('Cache-Control', 'public, max-age=86400');
+  }
+}
+
+export async function apply(ctx: Context) {
+  ctx.Route('constant', '/lazy/:version/:name', UiConstantsHandler);
+  ctx.Route('constant', '/resource/:version/:name', UiConstantsHandler);
+  ctx.on('app/started', buildUI);
+  const debouncedBuildUI = ctx.debounce(buildUI, 2000);
+  const triggerHotUpdate = (path?: string) => {
+    if (path && !path.includes('/ui-default/') && !path.includes('/public/') && !path.includes('/frontend/')) return;
+    debouncedBuildUI();
+  };
+  ctx.on('system/setting', () => triggerHotUpdate());
+  ctx.on('system/setting-loaded', () => triggerHotUpdate());
+  ctx.on('app/watch/change', triggerHotUpdate);
+  ctx.on('app/watch/unlink', triggerHotUpdate);
+  ctx.on('app/i18n/update', debouncedBuildUI);
+  debouncedBuildUI();
+}

package/backendlib/markdown-it-imsize.ts

@@ -0,0 +1,235 @@
+// Process ![test]( x =100x200)
+//                    ^^^^^^^^ this size specification
+function parseNextNumber(str, pos, max) {
+  const start = pos;
+  const result = {
+    ok: false,
+    pos,
+    value: '',
+  };
+  let code = str.charCodeAt(pos);
+  while (pos < max && ((code >= 0x30 /* 0 */ && code <= 0x39 /* 9 */) || code === 0x25 /* % */)) {
+    code = str.charCodeAt(++pos);
+  }
+  result.ok = true;
+  result.pos = pos;
+  result.value = str.slice(start, pos);
+  return result;
+}
+
+function parseImageSize(str, pos, max) {
+  const result = {
+    ok: false,
+    pos: 0,
+    width: '',
+    height: '',
+  };
+  if (pos >= max) return result;
+  let code = str.charCodeAt(pos);
+  if (code !== 0x3D /* = */) return result;
+  pos++;
+  code = str.charCodeAt(pos);
+  if (code !== 0x78 /* x */ && (code < 0x30 || code > 0x39) /* [0-9] */) {
+    return result;
+  }
+  // parse width
+  const resultW = parseNextNumber(str, pos, max);
+  pos = resultW.pos;
+  // next charactor must be 'x'
+  code = str.charCodeAt(pos);
+  if (code !== 0x78 /* x */) { return result; }
+  pos++;
+  // parse height
+  const resultH = parseNextNumber(str, pos, max);
+  pos = resultH.pos;
+  result.width = resultW.value;
+  result.height = resultH.value;
+  result.pos = pos;
+  result.ok = true;
+  return result;
+}
+
+export default function plugin(md) {
+  md.inline.ruler.before('emphasis', 'image', (state, silent) => {
+    let attrs;
+    let code;
+    let label;
+    let pos;
+    let ref;
+    let res;
+    let title;
+    let width = '';
+    let height = '';
+    let token;
+    let tokens;
+    let start;
+    let href = '';
+    const oldPos = state.pos;
+    const max = state.posMax;
+
+    if (state.src.charCodeAt(state.pos) !== 0x21/* ! */) return false;
+    if (state.src.charCodeAt(state.pos + 1) !== 0x5B/* [ */) return false;
+
+    const labelStart = state.pos + 2;
+    const labelEnd = md.helpers.parseLinkLabel(state, state.pos + 1, false);
+
+    // parser failed to find ']', so it's not a valid link
+    if (labelEnd < 0) return false;
+
+    pos = labelEnd + 1;
+    if (pos < max && state.src.charCodeAt(pos) === 0x28/* ( */) {
+      //
+      // Inline link
+      //
+
+      // [link](  <href>  "title"  )
+      //        ^^ skipping these spaces
+      pos++;
+      for (; pos < max; pos++) {
+        code = state.src.charCodeAt(pos);
+        if (code !== 0x20 && code !== 0x0A) { break; }
+      }
+      if (pos >= max) return false;
+
+      // [link](  <href>  "title"  )
+      //          ^^^^^^ parsing link destination
+      start = pos;
+      res = md.helpers.parseLinkDestination(state.src, pos, state.posMax);
+      if (res.ok) {
+        href = state.md.normalizeLink(res.str);
+        if (state.md.validateLink(href)) {
+          pos = res.pos;
+        } else {
+          href = '';
+        }
+      }
+
+      // [link](  <href>  "title"  )
+      //                ^^ skipping these spaces
+      start = pos;
+      for (; pos < max; pos++) {
+        code = state.src.charCodeAt(pos);
+        if (code !== 0x20 && code !== 0x0A) { break; }
+      }
+
+      // [link](  <href>  "title"  )
+      //                  ^^^^^^^ parsing link title
+      res = md.helpers.parseLinkTitle(state.src, pos, state.posMax);
+      if (pos < max && start !== pos && res.ok) {
+        title = res.str;
+        pos = res.pos;
+
+        // [link](  <href>  "title"  )
+        //                         ^^ skipping these spaces
+        for (; pos < max; pos++) {
+          code = state.src.charCodeAt(pos);
+          if (code !== 0x20 && code !== 0x0A) { break; }
+        }
+      } else {
+        title = '';
+      }
+
+      // [link](  <href>  "title" =WxH  )
+      //                          ^^^^ parsing image size
+      if (pos - 1 >= 0) {
+        code = state.src.charCodeAt(pos - 1);
+
+        // there must be at least one white spaces
+        // between previous field and the size
+        if (code === 0x20) {
+          res = parseImageSize(state.src, pos, state.posMax);
+          if (res.ok) {
+            width = res.width;
+            height = res.height;
+            pos = res.pos;
+
+            // [link](  <href>  "title" =WxH  )
+            //                              ^^ skipping these spaces
+            for (; pos < max; pos++) {
+              code = state.src.charCodeAt(pos);
+              if (code !== 0x20 && code !== 0x0A) { break; }
+            }
+          }
+        }
+      }
+
+      if (pos >= max || state.src.charCodeAt(pos) !== 0x29/* ) */) {
+        state.pos = oldPos;
+        return false;
+      }
+      pos++;
+    } else {
+      //
+      // Link reference
+      //
+      if (typeof state.env.references === 'undefined') return false;
+
+      // [foo]  [bar]
+      //      ^^ optional whitespace (can include newlines)
+      for (; pos < max; pos++) {
+        code = state.src.charCodeAt(pos);
+        if (code !== 0x20 && code !== 0x0A) { break; }
+      }
+
+      if (pos < max && state.src.charCodeAt(pos) === 0x5B/* [ */) {
+        start = pos + 1;
+        pos = md.helpers.parseLinkLabel(state, pos);
+        if (pos >= 0) {
+          label = state.src.slice(start, pos++);
+        } else {
+          pos = labelEnd + 1;
+        }
+      } else {
+        pos = labelEnd + 1;
+      }
+
+      // covers label === '' and label === undefined
+      // (collapsed reference link and shortcut reference link respectively)
+      label ||= state.src.slice(labelStart, labelEnd);
+
+      ref = state.env.references[md.utils.normalizeReference(label)];
+      if (!ref) {
+        state.pos = oldPos;
+        return false;
+      }
+      href = ref.href;
+      title = ref.title;
+    }
+
+    //
+    // We found the end of the link, and know for a fact it's a valid link;
+    // so all that's left to do is to call tokenizer.
+    //
+    if (!silent) {
+      state.pos = labelStart;
+      state.posMax = labelEnd;
+
+      const newState = new state.md.inline.State(
+        state.src.slice(labelStart, labelEnd),
+        state.md,
+        state.env,
+        tokens = [],
+      );
+      newState.md.inline.tokenize(newState);
+      token = state.push('image', 'img', 0);
+      token.attrs = attrs = [['src', href],
+        ['alt', '']];
+      token.children = tokens;
+      if (title) {
+        attrs.push(['title', title]);
+      }
+
+      if (width !== '') {
+        attrs.push(['width', width]);
+      }
+
+      if (height !== '') {
+        attrs.push(['height', height]);
+      }
+    }
+
+    state.pos = pos;
+    state.posMax = max;
+    return true;
+  });
+}

package/backendlib/markdown-it-katex.ts

@@ -0,0 +1,139 @@
+// https://github.com/waylonflinn/markdown-it-katex/blob/master/index.js
+import katex from 'katex';
+
+const limit = (typeof process !== 'undefined' && process.versions && process.versions.node) ? 50 : 1000;
+
+function isValidDelim(state, pos) {
+  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 === 0x09
+    ||/* \t */ (nextChar >= 0x30/* "0" */ && nextChar <= 0x39/* "9" */)) canClose = false;
+  if (nextChar === 0x09/* \t */) canOpen = false;
+  return {
+    canOpen,
+    canClose,
+  };
+}
+
+function inline(state, silent) {
+  let pos;
+  if (state.src[state.pos] !== '$') return false;
+  let res = isValidDelim(state, state.pos);
+  if (!res.canOpen) {
+    if (!silent) state.pending += '$';
+    state.pos += 1;
+    return true;
+  }
+  const start = state.pos + 1;
+  let 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) 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.canClose) {
+    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 escapeHtml(unsafe) {
+  return unsafe
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#039;');
+}
+
+function block(state, start, end, silent) {
+  let lastLine;
+  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;
+  }
+  let next = start;
+  while (!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) {
+  const options = { throwOnError: false, strict: 'ignore' as 'ignore', displayMode: false };
+  const render = (latex: string, displayMode = false) => {
+    options.displayMode = displayMode;
+    try {
+      latex = latex.replace(/\\def\{\\([a-zA-Z0-9]+)\}/g, '\\def\\$1');
+      return katex.renderToString(latex, options);
+    } catch (error) {
+      if (options.throwOnError) console.error(error);
+      return `<p class='${displayMode ? 'katex-block ' : ''}katex-error' title='${escapeHtml(error.toString())}'>${escapeHtml(latex)}</p>`;
+    }
+  };
+  const inlineRenderer = function (tokens, idx) {
+    if (tokens[idx].content.length > limit) return `$${escapeHtml(tokens[idx].content.trim())}$`;
+    return render(tokens[idx].content);
+  };
+
+  const blockRenderer = function (tokens, idx) {
+    if (tokens[idx].content.length > limit) return `$$${escapeHtml(tokens[idx].content.trim())}$$`;
+    return `${render(tokens[idx].content, true)}\n`;
+  };
+  md.inline.ruler.after('escape', 'math_inline', inline);
+  md.block.ruler.after('blockquote', 'math_block', block, {
+    alt: ['paragraph', 'reference', 'blockquote', 'list'],
+  });
+  md.renderer.rules.math_inline = inlineRenderer;
+  md.renderer.rules.math_block = blockRenderer;
+}