@shzlx/ui-default 4.58.2

package/components/monaco/loader.ts

@@ -0,0 +1,96 @@
+import { getFeatures, load as loadModule } from '../../lazyload';
+
+let loaded;
+
+const val: Record<string, any> = {};
+/** @deprecated */
+export async function legacyLoadExternalModule(target: string) {
+  if (val[target]) return val[target];
+  const ele = document.createElement('script');
+  ele.src = target;
+  await new Promise((resolve, reject) => {
+    ele.onload = resolve;
+    ele.onerror = reject;
+    document.head.appendChild(ele);
+  });
+  val[target] = window.exports;
+  return val[target];
+}
+
+const loaders = {
+  i18n: async () => {
+    const { setLocaleData } = await import('./nls');
+    let resource;
+    const lang = UserContext.viewLang;
+    if (lang === 'zh') {
+      resource = await import('monaco-editor-nls/locale/zh-hans.json');
+    } else if (lang === 'zh_TW') {
+      resource = await import('monaco-editor-nls/locale/zh-hant.json');
+    } else if (lang === 'ko') {
+      resource = await import('monaco-editor-nls/locale/ko.json');
+    }
+    if (resource) setLocaleData(resource);
+  },
+  markdown: () => import('./languages/markdown'),
+  typescript: () => import('./languages/typescript').then((m) => m.loadTypes()),
+  yaml: () => import('./languages/yaml'),
+  external: async (monaco, feat) => {
+    for (const item of await getFeatures(`monaco-${feat}`)) {
+      let apply = typeof item === 'function'
+        ? item
+        : (item.startsWith('http') || item.startsWith('/'))
+          ? await legacyLoadExternalModule(item)
+          : (await loadModule(item)).apply;
+      if (typeof apply !== 'function') apply = apply.default || apply.apply;
+      if (typeof apply === 'function') await apply(monaco);
+    }
+  },
+};
+
+let loadPromise = Promise.resolve();
+
+export async function load(features = ['markdown']) {
+  let s = Date.now();
+  await loadPromise;
+  let resolve;
+  loadPromise = new Promise((r) => { resolve = r; });
+  if (!loaded) {
+    await loaders.i18n();
+    console.log('Loading monaco editor');
+  }
+  const res = await import('./index');
+  if (!loaded) {
+    console.log('Loaded monaco editor in', Date.now() - s, 'ms');
+    loaded = [];
+  }
+  for (const feat of features) {
+    if (loaded.includes(feat)) continue;
+    if (!loaders[feat]) {
+      const items = await getFeatures(`monaco-${feat}`);
+      if (!items.length) {
+        console.warn('Unknown monaco feature:', feat);
+        continue;
+      }
+    }
+    s = Date.now();
+    console.log('Loading monaco feature:', feat);
+    try {
+      if (loaders[feat]) await loaders[feat]();
+      else await loaders.external(res.default, feat);
+      console.log('Loaded monaco feature:', feat, 'in', Date.now() - s, 'ms');
+      loaded.push(feat);
+    } catch (e) {
+      console.log('Monaco feat', feat, 'failed to load:', e);
+    }
+  }
+  await res.loadThemePromise;
+  resolve();
+  return {
+    monaco: res.default,
+    registerAction: res.registerAction,
+    customOptions: res.customOptions,
+    renderMarkdown: res.renderMarkdown,
+  };
+}
+
+export default load;

package/components/monaco/monaco.styl

@@ -0,0 +1,30 @@
+[data-mode-id="markdown"] > .monaco-editor
+  [widgetid="editor.widget.suggestWidget"]
+    width: 250px !important;
+
+  [widgetid="suggest.details"], .suggest-details.no-type
+    width: 64px !important;
+    height: 64px !important;
+    .codicon-close, .scrollbar
+      display: none;
+    .docs.markdown-docs > div
+      padding: 0 !important;
+    img
+      z-index: 100;
+      width: 64px;
+      height: 64px;
+      position: absolute;
+    a[title="#loader"]
+      text-indent: -9999em
+      z-index: 99;
+      border: rem(5px) solid rgba($primary-color, .2)
+      border-left: rem(5px) solid $primary-color
+      animation: load8 1.1s infinite linear
+      border-radius: 50%
+      width: rem(50px)
+      height: rem(50px)
+      margin-left: rem(-25px)
+      margin-top: rem(-25px)
+      left: 50%
+      top: 50%
+      position: absolute

package/components/monaco/nls.js

@@ -0,0 +1,31 @@
+export { getNLSLanguage, getNLSMessages } from 'monaco-editor/esm/vs/nls.messages';
+
+function format(message, args) {
+  let result;
+  if (!args.length) result = message;
+  else {
+    result = String(message).replace(/\{(\d+)\}/g, (match, rest) => {
+      const index = rest[0];
+      return typeof args[index] !== 'undefined' ? args[index] : match;
+    });
+  }
+  return result;
+}
+
+let CURRENT_LOCALE_DATA = {}; // eslint-disable-line ts/naming-convention
+
+export function localize(path, message, ...args) {
+  return format(CURRENT_LOCALE_DATA[path.key || path] || CURRENT_LOCALE_DATA[message] || message, args);
+}
+
+export function localize2(data, message, ...args) {
+  const original = localize(data, message, args);
+  return {
+    value: original,
+    original,
+  };
+}
+
+export function setLocaleData(data) {
+  CURRENT_LOCALE_DATA = Object.assign(...Object.values(data));
+}

package/components/monaco/schema/problemconfig.ts

@@ -0,0 +1,123 @@
+import type { JSONSchema7 } from 'json-schema';
+
+export const testlibCheckers = [
+  'acmp', 'caseicmp', 'casencmp', 'casewcmp', 'dcmp', 'fcmp', 'hcmp',
+  'icmp', 'lcmp', 'ncmp', 'nyesno', 'pointscmp', 'pointsinfo',
+  'rcmp', 'rcmp4', 'rcmp6', 'rcmp9', 'rncmp', 'uncmp', 'wcmp', 'yesno',
+];
+
+const problemConfigSchema: JSONSchema7 = {
+  type: 'object',
+  definitions: {
+    cases: { type: 'array', items: { $ref: '#/definitions/case' } },
+    case: {
+      type: 'object',
+      properties: {
+        input: { type: 'string' },
+        output: { type: 'string' },
+        time: { $ref: '#/definitions/time' },
+        memory: { $ref: '#/definitions/memory' },
+        score: { $ref: '#/definitions/score', description: 'score' },
+      },
+      required: ['input'],
+      additionalProperties: false,
+    },
+    subtask: {
+      description: 'Subtask Info',
+      type: 'object',
+      properties: {
+        type: { enum: ['min', 'max', 'sum'] },
+        time: { $ref: '#/definitions/time' },
+        memory: { $ref: '#/definitions/memory' },
+        score: { $ref: '#/definitions/score', description: 'score' },
+        cases: { $ref: '#/definitions/cases' },
+        if: { type: 'array', items: { type: 'integer' } },
+        id: { type: 'integer' },
+      },
+      required: ['score'],
+      additionalProperties: false,
+    },
+    time: { type: 'string', pattern: '^([1-9][0-9]*(?:\\.[0-9]+)?|0\\.[0-9]*[1-9][0-9]*)([mu]?)s?$' },
+    memory: { type: 'string', pattern: '^([1-9][0-9]*(?:\\.[0-9]+)?|0\\.[0-9]*[1-9][0-9]*)([kKmMgG])[bB]?$' },
+    score: { type: 'integer', maximum: 100, minimum: 1 },
+    rateConfig: {
+      type: 'object',
+      patternProperties: {
+        '^.+$': {
+          type: 'number',
+        },
+      },
+    },
+    compilableFile: {
+      oneOf: [
+        { type: 'string', pattern: '\\.' },
+        {
+          type: 'object',
+          properties: {
+            file: { type: 'string', pattern: '\\.' },
+            lang: { type: 'string' },
+          },
+          required: ['file', 'lang'],
+          additionalProperties: false,
+        },
+      ],
+    },
+  },
+  properties: {
+    redirect: { type: 'string', pattern: '[0-9a-zA-Z_-]+\\/[0-9]+' },
+    key: { type: 'string', pattern: '[0-9a-f]{32}' },
+    type: { enum: ['default', 'interactive', 'communication', 'submit_answer', 'objective', 'remote_judge'] },
+    subType: { type: 'string' },
+    langs: { type: 'array', items: { type: 'string' } },
+    target: { type: 'string' },
+    checker_type: { enum: ['default', 'lemon', 'syzoj', 'hustoj', 'testlib', 'strict', 'qduoj', 'kattis'] },
+    checker: {
+      oneOf: [
+        { type: 'string', enum: testlibCheckers },
+        { $ref: '#/definitions/compilableFile' },
+      ],
+    },
+    interactor: { $ref: '#/definitions/compilableFile' },
+    manager: { $ref: '#/definitions/compilableFile' },
+    num_processes: { type: 'integer', maximum: 5, minimum: 1 },
+    multi_pass: { type: 'integer', maximum: 20, minimum: 2 },
+    validator: { $ref: '#/definitions/compilableFile' },
+    user_extra_files: { type: 'array', items: { type: 'string' } },
+    judge_extra_files: { type: 'array', items: { type: 'string' } },
+    cases: { $ref: '#/definitions/cases' },
+    subtasks: { type: 'array', items: { $ref: '#/definitions/subtask' } },
+    filename: { type: 'string' },
+    detail: { type: 'string', enum: ['full', 'case', 'none'] },
+    time: { $ref: '#/definitions/time' },
+    memory: { $ref: '#/definitions/memory' },
+    score: { $ref: '#/definitions/score' },
+    template: {
+      type: 'object',
+      patternProperties: {
+        '^.*$': {
+          type: 'array',
+          minLength: 2,
+          maxLength: 2,
+          items: { type: 'string' },
+        },
+      },
+      additionalProperties: false,
+    },
+    answers: {
+      type: 'object',
+      patternProperties: {
+        '^\\d+(-\\d+)?$': {
+          type: 'array',
+          minLength: 2,
+          maxLength: 2,
+        },
+      },
+      additionalProperties: false,
+    },
+    time_limit_rate: { $ref: '#/definitions/rateConfig' },
+    memory_limit_rate: { $ref: '#/definitions/rateConfig' },
+  },
+  additionalProperties: false,
+};
+
+export default problemConfigSchema;

package/components/navigation/hamburgers.page.styl

@@ -0,0 +1,87 @@
+// extracted from:
+// https://github.com/jonsuh/hamburgers/blob/master/dist/hamburgers.css
+// copyright @jonsuh
+.hamburger
+  padding: 0px 0px
+  display: inline-block
+  cursor: pointer
+  transition-property: opacity, -webkit-filter
+  transition-property: opacity, filter
+  transition-property: opacity, filter, -webkit-filter
+  transition-duration: 0.15s
+  transition-timing-function: linear
+  font: inherit
+  color: inherit
+  text-transform: none
+  background-color: transparent
+  border: 0
+  margin: 0
+  overflow: visible
+
+.hamburger:hover
+  opacity: 0.7
+
+.hamburger-box
+  width: rem(18px)
+  height: rem(12px)
+  display: inline-block
+  position: relative
+
+.hamburger-inner
+  display: block
+  top: 50%
+  margin-top: rem(-1px)
+
+.hamburger-inner,
+.hamburger-inner::before,
+.hamburger-inner::after
+  width: rem(18px)
+  height: rem(2px)
+  background-color: #FFF
+  border-radius: 1px
+  position: absolute
+  transition-property: transform
+  transition-duration: 0.15s
+  transition-timing-function: ease
+
+.layout--immersive
+  .hamburger-inner,
+  .hamburger-inner::before,
+  .hamburger-inner::after
+    background-color: #FFF
+
+.hamburger-inner::before,
+.hamburger-inner::after
+  content: ""
+  display: block
+
+.hamburger-inner::before
+  top: rem(-5px)
+
+.hamburger-inner::after
+  bottom: rem(-5px)
+
+.hamburger--spin .hamburger-inner
+  transition-duration: 0.3s
+  transition-timing-function: ease-out-cubic
+
+.hamburger--spin .hamburger-inner::before
+  transition: top 0.1s 0.34s ease-in, opacity 0.1s ease-in
+
+.hamburger--spin .hamburger-inner::after
+  transition: bottom 0.1s 0.34s ease-in, transform 0.3s ease-in-cubic
+
+.hamburger--spin.is-active .hamburger-inner
+  transform: rotate(225deg)
+  transition-delay: 0.14s
+  transition-timing-function: cubic-bezier(0.215, 0.61, 0.355, 1)
+
+.hamburger--spin.is-active .hamburger-inner::before
+  top: 0
+  opacity: 0
+  transition: top 0.1s ease-out, opacity 0.1s 0.14s ease-out
+
+.hamburger--spin.is-active .hamburger-inner::after
+  bottom: 0
+  transform: rotate(-90deg)
+  transition: bottom 0.1s ease-out, transform 0.3s 0.14s ease-out-cubic

package/components/navigation/navigation.page.js

@@ -0,0 +1,203 @@
+import $ from 'jquery';
+import responsiveCutoff from 'vj/breakpoints.json';
+import Notification from 'vj/components/notification';
+import selectUser from 'vj/components/selectUser';
+import { AutoloadPage } from 'vj/misc/Page';
+import { i18n, request, tpl } from 'vj/utils';
+
+function handleNavLogoutClick(ev) {
+  const $logoutLink = $(ev.currentTarget);
+  request
+    .post($logoutLink.attr('href'))
+    .then(() => window.location.reload());
+  ev.preventDefault();
+}
+
+async function handlerSwitchAccount(ev) {
+  ev.preventDefault();
+  const target = await selectUser('Hint::icon::switch_account');
+  if (!target) return;
+  try {
+    const res = await request.get(`/account/${target._id}`);
+    if (res.url) window.location.href = res.url;
+    else window.location.reload();
+  } catch (error) {
+    Notification.error(error.message);
+  }
+}
+
+let $trigger;
+let $menu;
+
+function handleNavbar() {
+  let fromHide = false;
+  if ($(document).width() <= responsiveCutoff.mobile) {
+    $menu.children().each(function () {
+      const $ele = $(this);
+      $ele.addClass('nav__list-item').removeClass('menu__item');
+      $ele.children('a').addClass('nav__item').removeClass('menu__link');
+      $ele.insertBefore($trigger, null);
+    });
+    $trigger.hide();
+    return;
+  }
+  $trigger.show();
+
+  const base = 70;
+
+  let navItems = $('.nav__list--main > .nav__list-item');
+  let navItem = navItems.length - 2;
+  while (navItem && $('#menu').children('div').height() > base) {
+    if (!$(navItems[navItem]).children('a').hasClass('nav--active')) {
+      $(navItems[navItem]).removeClass('nav__list-item').addClass('menu__item');
+      $(navItems[navItem]).children('a').removeClass('nav__item').addClass('menu__link');
+      $menu.prepend($(navItems[navItem]));
+    }
+    navItem--;
+    fromHide = true;
+  }
+
+  if (!fromHide && $menu.children().length) {
+    while ($('#menu').children('div').height() <= base && $menu.children().length) {
+      const $ele = $menu.children().first();
+      $ele.addClass('nav__list-item').removeClass('menu__item');
+      $ele.children('a').addClass('nav__item').removeClass('menu__link');
+      $ele.insertBefore($trigger, null);
+    }
+  }
+
+  navItems = $('.nav__list--main > .nav__list-item');
+  navItem = navItems.length - 2;
+  if ($('#menu').children('div').height() > base) {
+    while (navItem && $('#menu').children('div').height() > base) {
+      if (!$(navItems[navItem]).children('a').hasClass('nav--active')) {
+        $(navItems[navItem]).removeClass('nav__list-item').addClass('menu__item');
+        $(navItems[navItem]).children('a').removeClass('nav__item').addClass('menu__link');
+        $menu.prepend($(navItems[navItem]));
+      }
+      navItem--;
+    }
+  }
+
+  if (!$menu.children().length) $trigger.hide();
+}
+
+const navigationPage = new AutoloadPage('navigationPage', () => {
+  if (!document.getElementById('panel') || !document.getElementById('menu')) return;
+
+  $(document).on('click', '[name="nav_logout"]', handleNavLogoutClick);
+  $(document).on('click', '[name="nav_switch_account"]', handlerSwitchAccount);
+
+  let isOpen = false;
+  const panel = document.getElementById('panel');
+  const $slideoutOverlay = $('.slideout-overlay');
+  const $hamburger = $('.header__hamburger .hamburger');
+  const PADDING = 200;
+  const TOLERANCE = 70;
+
+  function isMobileLayout() {
+    return $(document).width() <= responsiveCutoff.mobile;
+  }
+
+  function setTranslateX(x) {
+    panel.style.transform = x ? `translateX(${x}px)` : '';
+  }
+
+  function open() {
+    if (!isMobileLayout()) return;
+    isOpen = true;
+    $('html').addClass('slideout-open');
+    setTranslateX(-PADDING);
+    $hamburger.addClass('is-active');
+    $slideoutOverlay.show();
+  }
+
+  // Touch swipe support
+  let touchStartX = 0;
+  let touchStartY = 0;
+  let touchCurrentX = 0;
+  let isSwiping = false;
+  let isScrolling = false;
+
+  function close() {
+    isOpen = false;
+    isSwiping = false;
+    isScrolling = false;
+    panel.style.transition = '';
+    setTranslateX(0);
+    $hamburger.removeClass('is-active');
+    $slideoutOverlay.hide();
+    $('html').removeClass('slideout-open');
+  }
+
+  panel.addEventListener('touchstart', (e) => {
+    if (!isMobileLayout() || e.target.closest('[data-slideout-ignore]')) return;
+    touchStartX = e.touches[0].clientX;
+    touchStartY = e.touches[0].clientY;
+    touchCurrentX = touchStartX;
+    isSwiping = false;
+    isScrolling = false;
+  }, { passive: true });
+
+  panel.addEventListener('touchmove', (e) => {
+    if (!isMobileLayout()) return;
+    touchCurrentX = e.touches[0].clientX;
+    const dx = touchStartX - touchCurrentX;
+    if (!isSwiping) {
+      if (isScrolling) return;
+      const dy = touchStartY - e.touches[0].clientY;
+      const absDx = Math.abs(dx);
+      const absDy = Math.abs(dy);
+      if (absDx < 10 && absDy < 10) return;
+      // Lock to scroll if vertical movement dominates
+      if (absDy > absDx) {
+        isScrolling = true;
+        return;
+      }
+      isSwiping = true;
+      if (!isOpen) $slideoutOverlay.show();
+      $('html').addClass('slideout-open');
+      panel.style.transition = 'none';
+    }
+    setTranslateX(isOpen
+      ? Math.max(-PADDING, Math.min(0, -PADDING - dx))
+      : Math.max(-PADDING, Math.min(0, -dx)));
+  }, { passive: true });
+
+  panel.addEventListener('touchend', () => {
+    if (!isMobileLayout() || !isSwiping) return;
+    panel.style.transition = '';
+    const dx = touchStartX - touchCurrentX;
+    if (isOpen) {
+      if (-dx > TOLERANCE) close();
+      else open();
+    } else {
+      if (dx > TOLERANCE) open();
+      else close();
+    }
+    isSwiping = false;
+  });
+
+  $slideoutOverlay.on('click', close);
+  $('.header__hamburger').on('click', () => (isOpen ? close() : open()));
+  $(window).on('resize', () => {
+    handleNavbar();
+    if (!isMobileLayout()) close();
+  });
+  setInterval(handleNavbar, 3000);
+}, () => {
+  $trigger = $(tpl`
+    <li class="nav__list-item nav_more" data-dropdown-pos="bottom right" data-dropdown-target="#menu-nav-more">
+      <a href="javascript:;" class="nav__item">
+        ${i18n('More')} <span class="icon icon-expand_more"></span>
+      </a>
+    </li>
+  `);
+  $menu = $('<ol class="dropdown-target menu menu_more" id="menu-nav-more">');
+  $trigger.append($menu);
+  $('.nav__list--main').append($trigger);
+
+  handleNavbar();
+});
+
+export default navigationPage;