@shzlx/ui-default 4.58.2

package/utils/base64.js

@@ -0,0 +1,104 @@
+const Base64 = {
+  _keyStr: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+
+  encode(input) {
+    let output = '';
+    let chr1;
+    let chr2;
+    let chr3;
+    let enc1;
+    let enc2;
+    let enc3;
+    let enc4;
+    let i = 0;
+    input = Base64._utf8Encode(input);
+    while (i < input.length) {
+      chr1 = input.charCodeAt(i++);
+      chr2 = input.charCodeAt(i++);
+      chr3 = input.charCodeAt(i++);
+      enc1 = chr1 >> 2;
+      enc2 = ((chr1 & 3) << 4) | (chr2 >> 4);
+      enc3 = ((chr2 & 15) << 2) | (chr3 >> 6);
+      enc4 = chr3 & 63;
+      if (Number.isNaN(chr2)) enc3 = enc4 = 64;
+      else if (Number.isNaN(chr3)) enc4 = 64;
+      output = output
+        + this._keyStr.charAt(enc1) + this._keyStr.charAt(enc2)
+        + this._keyStr.charAt(enc3) + this._keyStr.charAt(enc4);
+    }
+    return output;
+  },
+
+  decode(input) {
+    let output = '';
+    let chr1;
+    let chr2;
+    let chr3;
+    let enc1;
+    let enc2;
+    let enc3;
+    let enc4;
+    let i = 0;
+    input = input.replace(/[^A-Za-z0-9+/=]/g, '');
+    while (i < input.length) {
+      enc1 = this._keyStr.indexOf(input.charAt(i++));
+      enc2 = this._keyStr.indexOf(input.charAt(i++));
+      enc3 = this._keyStr.indexOf(input.charAt(i++));
+      enc4 = this._keyStr.indexOf(input.charAt(i++));
+      chr1 = (enc1 << 2) | (enc2 >> 4);
+      chr2 = ((enc2 & 15) << 4) | (enc3 >> 2);
+      chr3 = ((enc3 & 3) << 6) | enc4;
+      output += String.fromCharCode(chr1);
+      if (enc3 !== 64) output += String.fromCharCode(chr2);
+      if (enc4 !== 64) output += String.fromCharCode(chr3);
+    }
+    output = Base64._utf8Decode(output);
+    return output;
+  },
+
+  _utf8Encode(string) {
+    string = string.replace(/\r\n/g, '\n');
+    let utftext = '';
+    for (let n = 0; n < string.length; n++) {
+      const c = string.charCodeAt(n);
+      if (c < 128) {
+        utftext += String.fromCharCode(c);
+      } else if ((c > 127) && (c < 2048)) {
+        utftext += String.fromCharCode((c >> 6) | 192);
+        utftext += String.fromCharCode((c & 63) | 128);
+      } else {
+        utftext += String.fromCharCode((c >> 12) | 224);
+        utftext += String.fromCharCode(((c >> 6) & 63) | 128);
+        utftext += String.fromCharCode((c & 63) | 128);
+      }
+    }
+    return utftext;
+  },
+
+  _utf8Decode(utftext) {
+    let string = '';
+    let i = 0;
+    let c = 0;
+    let c2 = 0;
+    let c3 = 0;
+    while (i < utftext.length) {
+      c = utftext.charCodeAt(i);
+      if (c < 128) {
+        string += String.fromCharCode(c);
+        i++;
+      } else if ((c > 191) && (c < 224)) {
+        c2 = utftext.charCodeAt(i + 1);
+        string += String.fromCharCode(((c & 31) << 6) | (c2 & 63));
+        i += 2;
+      } else {
+        c2 = utftext.charCodeAt(i + 1);
+        c3 = utftext.charCodeAt(i + 2);
+        string += String.fromCharCode(((c & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63));
+        i += 3;
+      }
+    }
+    return string;
+  },
+};
+
+export default Base64;

package/utils/db.ts

@@ -0,0 +1,32 @@
+import { openDB as _open } from 'idb';
+import { alert } from 'vj/components/dialog';
+
+export const openDB = _open('hydro', 1, {
+  upgrade(db, oldVersion) {
+    if (oldVersion < 1) {
+      const solutionStore = db.createObjectStore('solutions', { keyPath: 'id' });
+      db.createObjectStore('scoreboard-star', { keyPath: 'id' });
+      const keys = Object.keys(localStorage);
+      for (const key of keys) {
+        if (key.endsWith('#objective')) {
+          const value = localStorage.getItem(key);
+          if (value) solutionStore.put({ id: key, value });
+          localStorage.removeItem(key);
+        }
+        if (key.startsWith('scoreboard-star/')) localStorage.removeItem(key);
+        if (/^0\.\d+$/.test(key)) localStorage.removeItem(key);
+      }
+    }
+  },
+  blocked(currentVersion, blockedVersion) {
+    console.error('IDB Blocked by version', blockedVersion, 'want', currentVersion);
+    alert('Some other opened tabs locked the database. Please close them.');
+  },
+  blocking(currentVersion, blockedVersion) {
+    console.error('IDB Blocking version', blockedVersion);
+    alert('Please close or refresh this tab to perform the upgrade.');
+  },
+  terminated() {
+    console.error('IDB Terminated');
+  },
+});

package/utils/index.ts

@@ -0,0 +1,73 @@
+import 'streamsaver/examples/zip-stream';
+
+import { request } from './base';
+
+export async function api(method: string, args: Record<string, any>, projection: any) {
+  const res = await request.post(`/d/${UiContext.domainId}/api/${encodeURIComponent(method)}`, { args, projection });
+  if (res.error) throw new Error(res.error);
+  return res;
+}
+
+export function getAvailableLangs(langsList?: string[]) {
+  const prefixes = new Set(Object.keys(window.LANGS).filter((i) => i.includes('.')).map((i) => i.split('.')[0]));
+  const Langs = {};
+  for (const key in window.LANGS) {
+    if (prefixes.has(key)) continue;
+    if ((langsList instanceof Array) && !langsList.includes(key)) continue;
+    if (window.LANGS[key].hidden && !langsList?.includes(key)) continue;
+    if (window.LANGS[key].disabled) continue;
+    Langs[key] = window.LANGS[key];
+  }
+  return Langs;
+}
+
+export const createZipStream = (window as any).ZIP;
+
+export function createZipBlob(underlyingSource) {
+  return new Response(createZipStream(underlyingSource)).blob();
+}
+
+export async function pipeStream(read, write, abort) {
+  if (window.WritableStream && read.pipeTo) {
+    const abortController = new AbortController();
+    if (abort) abort.abort = abortController.abort.bind(abortController);
+    await read.pipeTo(write, abortController);
+  } else {
+    const writer = write.getWriter();
+    if (abort) abort.abort = writer.abort.bind(writer);
+    const reader = read.getReader();
+    while (1) {
+      const readResult = await reader.read();
+      if (readResult.done) {
+        writer.close();
+        break;
+      } else writer.write(readResult.value);
+    }
+  }
+}
+
+// https://github.com/andrasq/node-mongoid-js/blob/master/mongoid.js
+export function mongoId(idstring: string) {
+  if (typeof idstring !== 'string') idstring = String(idstring);
+  return {
+    timestamp: Number.parseInt(idstring.slice(0, 0 + 8), 16),
+    machineid: Number.parseInt(idstring.slice(8, 8 + 6), 16),
+    pid: Number.parseInt(idstring.slice(14, 14 + 4), 16),
+    sequence: Number.parseInt(idstring.slice(18, 18 + 6), 16),
+  };
+}
+
+export function emulateAnchorClick(ev: KeyboardEvent, targetUrl: string, alwaysOpenInNewWindow = false) {
+  let openInNewWindow;
+  if (alwaysOpenInNewWindow) openInNewWindow = true;
+  else openInNewWindow = (ev.ctrlKey || ev.shiftKey || ev.metaKey);
+  if (openInNewWindow) window.open(targetUrl);
+  else window.location.href = targetUrl;
+}
+
+export * from './base';
+export { default as base64 } from './base64';
+export { default as loadReactRedux } from './loadReactRedux';
+export * as mediaQuery from './mediaQuery';
+export { default as pjax } from './pjax';
+export * from './slide';

package/utils/loadReactRedux.ts

@@ -0,0 +1,32 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import type { Action, Reducer, UnknownAction } from 'redux';
+
+export default async function loadReactRedux<S, A extends Action = UnknownAction>(storeReducer: Reducer<S, A>) {
+  const [{ Provider }, { createStore, applyMiddleware }, { thunk: reduxThunk }, { default: reduxPromise }] = await Promise.all([
+    import('react-redux'),
+    import('redux'),
+    import('redux-thunk'),
+    import('redux-promise-middleware'),
+  ]);
+  const reduxMiddlewares = [];
+  reduxMiddlewares.push(reduxThunk);
+  reduxMiddlewares.push(reduxPromise);
+
+  if (process.env.NODE_ENV !== 'production') {
+    const { createLogger } = await import('redux-logger');
+    reduxMiddlewares.push(createLogger({
+      collapsed: true,
+      duration: true,
+    }));
+  }
+
+  const store = createStore(storeReducer, applyMiddleware(...reduxMiddlewares));
+
+  return {
+    React,
+    createRoot,
+    Provider,
+    store,
+  };
+}

package/utils/mediaQuery.ts

@@ -0,0 +1,13 @@
+export function isAbove(width) {
+  if (window.matchMedia) {
+    return window.matchMedia(`(min-width: ${width}px)`).matches;
+  }
+  return window.innerWidth >= width;
+}
+
+export function isBelow(width) {
+  if (window.matchMedia) {
+    return window.matchMedia(`(max-width: ${width}px)`).matches;
+  }
+  return window.innerWidth <= width;
+}

package/utils/pjax.js

@@ -0,0 +1,148 @@
+// Modified from jquery-pjax to support multiple fragments and jQuery 3.0
+// https://github.com/defunkt/jquery-pjax/blob/master/jquery.pjax.js
+
+import $ from 'jquery';
+import { nanoid } from 'nanoid';
+import NProgress from 'nprogress';
+import Notification from 'vj/components/notification';
+import { request, withTransitionCallback } from './base';
+
+const pjax = {};
+
+let currentState = null;
+let currentXHR = null;
+let inProgress = 0;
+
+function cancelLastXHR() {
+  if (currentXHR && currentXHR.readyState < 4) {
+    currentXHR.abort();
+    currentXHR = null;
+  }
+}
+
+function canonicalizeUrl(url) {
+  const a = document.createElement('a');
+  a.href = url;
+  return a.href;
+}
+
+function extractMetaData(requestOption, response) {
+  const metaData = {
+    title: response.title ? response.title : document.title,
+    url: response.url ? response.url : requestOption.url,
+  };
+  metaData.url = canonicalizeUrl(metaData.url);
+  return metaData;
+}
+
+function incProgress() {
+  inProgress++;
+  NProgress.done();
+  NProgress.start();
+}
+
+function decProgress() {
+  inProgress--;
+  if (inProgress === 0) {
+    NProgress.done();
+  }
+}
+
+pjax.request = async (opt) => {
+  if (typeof opt === 'string') opt = { url: opt };
+  const options = {
+    method: 'get',
+    push: true,
+    ...opt,
+  };
+  if (!currentState) {
+    // create initial state
+    currentState = {
+      id: nanoid(),
+      options: {
+        url: window.location.href,
+      },
+    };
+    window.history.replaceState(currentState, null);
+  }
+  cancelLastXHR();
+  if (options.push) {
+    // in popstate, options.push === false
+    window.history.pushState(null, null, options.url);
+  }
+  incProgress();
+  try {
+    const params = {
+      beforeSend(xhr) {
+        currentXHR = xhr;
+      },
+      ...options,
+    };
+    if (params.url && params.url.includes('?')) params.url += '&pjax=1';
+    else params.url = `${params.url || ''}?pjax=1`;
+    const data = await request.ajax(params);
+    const meta = extractMetaData(options, data);
+    currentState = {
+      id: nanoid(),
+      options: opt,
+    };
+    if (options.push) {
+      window.history.replaceState(currentState, null, meta.url);
+    }
+    if (meta.title) document.title = meta.title;
+    for (const fragment of data.fragments) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (fragment.html === undefined) {
+          throw new Error("Fragement should contain 'html'");
+        }
+      }
+      const $el = $(fragment.html.trim());
+      if (process.env.NODE_ENV !== 'production') {
+        if ($el.length === 0) {
+          throw new Error("Unable to build elements from fragment 'html'");
+        }
+      }
+      const fragmentId = $el.attr('data-fragment-id');
+      if (process.env.NODE_ENV !== 'production') {
+        if (!fragmentId) {
+          throw new Error("Unable to extract fragment id from fragment 'html'");
+        }
+      }
+      const $target = $(`[data-fragment-id="${fragmentId}"]`);
+      if (process.env.NODE_ENV !== 'production') {
+        if ($target.length === 0) {
+          throw new Error('Unable to get target fragment from fragment id');
+        }
+      }
+      $target.trigger('vjContentRemove');
+      await withTransitionCallback(() => {
+        $target.replaceWith($el);
+        $el.trigger('vjContentNew');
+      });
+    }
+  } catch (err) {
+    if (!err.aborted) {
+      Notification.error(err.message);
+      console.error(err);
+    }
+  } finally {
+    decProgress();
+  }
+};
+
+function handlePopState(ev) {
+  if (!ev.originalEvent) return;
+  const { state } = ev.originalEvent;
+  if (!state) return;
+  if (!state.id || (currentState && state.id === currentState.id)) {
+    return;
+  }
+  pjax.request({
+    ...state.options,
+    push: false,
+  });
+}
+
+$(window).on('popstate', handlePopState);
+
+export default pjax;

package/utils/slide.ts

@@ -0,0 +1,57 @@
+import 'jquery.easing';
+
+export async function slideDown($element, duration, fromCss = {}, toCss = {}) {
+  const originalStyl = $element.attr('style') || '';
+  $element.css({
+    position: 'absolute',
+    visibility: 'none',
+    display: 'block',
+  });
+  const height = $element.outerHeight();
+  $element.attr('style', originalStyl);
+  $element.css({
+    height: 0,
+    overflow: 'hidden',
+    display: 'block',
+    ...fromCss,
+  });
+  $element.height();
+  await $element
+    .transition({
+      height,
+      ...toCss,
+    }, {
+      duration,
+      easing: 'easeOutCubic',
+    })
+    .promise();
+  $element.attr('style', originalStyl);
+  $element.css({
+    display: 'block',
+  });
+}
+
+export async function slideUp($element, duration, fromCss = {}, toCss = {}) {
+  const originalStyl = $element.attr('style') || '';
+  const height = $element.outerHeight();
+  $element.css({
+    height,
+    overflow: 'hidden',
+    display: 'block',
+    ...fromCss,
+  });
+  $element.height();
+  await $element
+    .transition({
+      height: 0,
+      ...toCss,
+    }, {
+      duration,
+      easing: 'easeOutCubic',
+    })
+    .promise();
+  $element.attr('style', originalStyl);
+  $element.css({
+    display: 'none',
+  });
+}