@shzlx/ui-default 4.58.2

package/components/messagepad/MessagePadInputContainer.jsx

@@ -0,0 +1,100 @@
+import classNames from 'classnames';
+import PropTypes from 'prop-types';
+import React from 'react';
+import { connect } from 'react-redux';
+import Icon from 'vj/components/react/IconComponent';
+import { request } from 'vj/utils';
+
+const mapStateToProps = (state) => ({
+  activeId: state.activeId,
+  isPosting: state.activeId !== null
+    ? state.isPosting[state.activeId]
+    : false,
+  inputValue: state.activeId !== null
+    ? state.inputs[state.activeId]
+    : '',
+});
+
+const mapDispatchToProps = (dispatch) => ({
+  handleChange(id, value) {
+    if (id === null) return;
+    dispatch({
+      type: 'DIALOGUES_INPUT_CHANGED',
+      payload: value,
+      meta: {
+        dialogueId: id,
+      },
+    });
+  },
+  postSend(uid, value) {
+    const req = request.post('', {
+      operation: 'send',
+      uid,
+      content: value,
+    });
+    dispatch({
+      type: 'DIALOGUES_POST_SEND',
+      payload: req,
+      meta: {
+        dialogueId: uid,
+      },
+    });
+  },
+});
+
+export default connect(mapStateToProps, mapDispatchToProps)(class MessagePadInputContainer extends React.PureComponent {
+  static contextTypes = {
+    store: PropTypes.object,
+  };
+
+  componentDidUpdate(prevProps) {
+    this.focusInput = (
+      this.props.activeId !== prevProps.activeId
+      || (prevProps.isPosting !== this.props.isPosting && this.props.isPosting === false)
+    );
+    if (this.focusInput) {
+      const { scrollX, scrollY } = window;
+      this.state.ref?.focus();
+      window.scrollTo(scrollX, scrollY);
+    }
+  }
+
+  handleKeyDown(ev) {
+    if (ev.keyCode === 13 && (ev.ctrlKey || ev.metaKey)) {
+      this.submit();
+    }
+  }
+
+  submit() {
+    this.props.postSend(
+      this.props.activeId,
+      this.props.inputValue,
+    );
+  }
+
+  render() {
+    const cn = classNames('messagepad__input', {
+      visible: this.props.activeId !== null,
+    });
+    return (
+      <div className={cn}>
+        <div className="messagepad__textarea-container">
+          <textarea
+            ref={(ref) => this.setState({ ...this.state, ref })}
+            data-markdown
+            disabled={this.props.isPosting}
+            value={this.props.inputValue}
+            onKeyDown={(ev) => this.handleKeyDown(ev)}
+            onChange={(ev) => this.props.handleChange(this.props.activeId, ev.target.value)}
+          />
+        </div>
+        <button
+          disabled={!this.props.inputValue.trim().length || this.props.isPosting}
+          onClick={() => this.submit()}
+        >
+          <Icon name="send" />
+        </button>
+      </div>
+    );
+  }
+});

package/components/messagepad/index.jsx

@@ -0,0 +1,49 @@
+import PropTypes from 'prop-types';
+import React from 'react';
+import { connect } from 'react-redux';
+import Icon from 'vj/components/react/IconComponent';
+import { i18n, request } from 'vj/utils';
+import MessagePadDialogueContent from './MessagePadDialogueContentContainer';
+import MessagePadDialogueList from './MessagePadDialogueListContainer';
+import MessagePadInput from './MessagePadInputContainer';
+
+const mapDispatchToProps = (dispatch) => ({
+  loadDialogues() {
+    dispatch({
+      type: 'DIALOGUES_LOAD_DIALOGUES',
+      payload: request.get('', { _: Date.now() }),
+    });
+  },
+});
+
+export default connect(null, mapDispatchToProps)(class MessagePadContainer extends React.PureComponent {
+  static propTypes = {
+    onAdd: PropTypes.func.isRequired,
+  };
+
+  componentDidMount() {
+    this.props.loadDialogues();
+  }
+
+  render() {
+    return (
+      <div className="messagepad clearfix">
+        <div className="messagepad__sidebar">
+          <div className="section__header">
+            <button
+              onClick={() => this.props.onAdd()}
+              className="primary rounded button"
+            >
+              <Icon name="add" />
+              {' '}
+              {i18n('New')}
+            </button>
+          </div>
+          <MessagePadDialogueList />
+        </div>
+        <MessagePadDialogueContent />
+        <MessagePadInput />
+      </div>
+    );
+  }
+});

package/components/messagepad/reducers/activeId.ts

@@ -0,0 +1,36 @@
+import 'jquery.easing';
+
+import $ from 'jquery';
+
+function scrollToViewport() {
+  const BOUND_TOP = 60;
+  const BOUND_BOTTOM = 20;
+  const node = $('.messagepad')[0];
+  if (node.offsetHeight + BOUND_TOP + BOUND_BOTTOM < window.innerHeight) {
+    const rect = node.getBoundingClientRect();
+    const rectBody = document.body.getBoundingClientRect();
+    let targetScrollTop = null;
+    if (rect.top < BOUND_TOP) {
+      targetScrollTop = rect.top - rectBody.top - BOUND_TOP;
+    } else if (rect.top + node.offsetHeight > window.innerHeight) {
+      targetScrollTop = rect.top - rectBody.top + node.offsetHeight + BOUND_BOTTOM - window.innerHeight;
+    }
+    if (targetScrollTop !== null) {
+      $('html, body').stop().animate({ scrollTop: targetScrollTop }, 200, 'easeOutCubic');
+    }
+  }
+}
+
+export default function reducer(state = null, action: any = {}) {
+  switch (action.type) {
+    case 'DIALOGUES_SWITCH_TO': {
+      scrollToViewport();
+      return action.payload;
+    }
+    case 'DIALOGUES_POST_SEND_FULFILLED': {
+      return action.meta.dialogueId;
+    }
+    default:
+      return state;
+  }
+}

package/components/messagepad/reducers/dialogues.js

@@ -0,0 +1,53 @@
+import _ from 'lodash';
+
+export default function reducer(state = {}, action = {}) {
+  switch (action.type) {
+    case 'DIALOGUES_LOAD_DIALOGUES_FULFILLED': {
+      const { messages } = action.payload;
+      return { ...state, ..._.keyBy(messages, 'udoc._id') };
+    }
+    case 'DIALOGUES_CREATE': {
+      const { user } = action.payload;
+      if (state[user._id]) return state;
+      return {
+        ...state,
+        [user._id]: {
+          _id: user._id,
+          udoc: { ...user },
+          messages: [],
+        },
+      };
+    }
+    case 'DIALOGUES_POST_SEND_FULFILLED': {
+      const id = action.meta.dialogueId;
+      const { mdoc } = action.payload;
+      return {
+        ...state,
+        [id]: {
+          ...state[id],
+          messages: [
+            ...state[id].messages,
+            mdoc,
+          ],
+        },
+      };
+    }
+    case 'DIALOGUES_MESSAGE_PUSH': {
+      const { mdoc, udoc } = action.payload;
+      const to = mdoc.from === UserContext._id ? mdoc.to : mdoc.from;
+      return {
+        ...state,
+        [to]: {
+          ...state[to],
+          udoc,
+          messages: [
+            ...state[to]?.messages || [],
+            mdoc,
+          ],
+        },
+      };
+    }
+    default:
+      return state;
+  }
+}

package/components/messagepad/reducers/index.ts

@@ -0,0 +1,14 @@
+import { combineReducers } from 'redux';
+import activeId from './activeId';
+import dialogues from './dialogues';
+import inputs from './inputs';
+import isPosting from './isPosting';
+
+const reducer = combineReducers({
+  activeId,
+  dialogues,
+  inputs,
+  isPosting,
+});
+
+export default reducer;

package/components/messagepad/reducers/inputs.js

@@ -0,0 +1,43 @@
+import _ from 'lodash';
+
+export default function reducer(state = {}, action = {}) {
+  switch (action.type) {
+    case 'DIALOGUES_LOAD_DIALOGUES_FULFILLED': {
+      const dialogues = action.payload.messages;
+      return { ...state, ..._.fromPairs(_.map(dialogues, (d) => [d._id, ''])) };
+    }
+    case 'DIALOGUES_CREATE': {
+      const { user } = action.payload;
+      return {
+        ...state,
+        [user._id]: '',
+      };
+    }
+    case 'DIALOGUES_INPUT_CHANGED': {
+      const id = action.meta.dialogueId;
+      return {
+        ...state,
+        [id]: action.payload,
+      };
+    }
+    case 'DIALOGUES_POST_SEND_FULFILLED': {
+      const id = action.meta.dialogueId;
+      return {
+        ...state,
+        [id]: '',
+      };
+    }
+    case 'DIALOGUES_MESSAGE_PUSH': {
+      const { udoc } = action.payload;
+      if (!state[udoc._id]) {
+        return {
+          ...state,
+          [udoc._id]: '',
+        };
+      }
+      return state;
+    }
+    default:
+      return state;
+  }
+}

package/components/messagepad/reducers/isPosting.ts

@@ -0,0 +1,49 @@
+import _ from 'lodash';
+import Notification from 'vj/components/notification';
+
+export default function reducer(state = {}, action: any = {}) {
+  switch (action.type) {
+    case 'DIALOGUES_LOAD_DIALOGUES_FULFILLED': {
+      const dialogues = action.payload.messages;
+      return { ...state, ..._.fromPairs(_.map(dialogues, (d) => [d._id, false])) };
+    }
+    case 'DIALOGUES_CREATE': {
+      const { user } = action.payload;
+      return {
+        ...state,
+        [user._id]: false,
+      };
+    }
+    case 'DIALOGUES_POST_SEND_PENDING': {
+      const id = action.meta.dialogueId;
+      return {
+        ...state,
+        [id]: true,
+      };
+    }
+    case 'DIALOGUES_POST_SEND_REJECTED': {
+      Notification.error(action.payload.message);
+      const id = action.meta.dialogueId;
+      return {
+        ...state,
+        [id]: false,
+      };
+    }
+    case 'DIALOGUES_POST_SEND_FULFILLED': {
+      const id = action.meta.dialogueId;
+      return {
+        ...state,
+        [id]: false,
+      };
+    }
+    case 'DIALOGUES_MESSAGE_PUSH': {
+      const { udoc } = action.payload;
+      return {
+        ...state,
+        [udoc._id]: false,
+      };
+    }
+    default:
+      return state;
+  }
+}

package/components/monaco/index.ts

@@ -0,0 +1,178 @@
+import './monaco.styl';
+
+import $ from 'jquery';
+import { EditorAction, registerEditorAction } from 'monaco-editor/esm/vs/editor/browser/editorExtensions';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { IQuickInputService } from 'monaco-editor/esm/vs/platform/quickinput/common/quickInput';
+import list from 'monaco-themes/themes/themelist.json';
+import { nanoid } from 'nanoid';
+import { i18n, request } from 'vj/utils';
+
+export { renderMarkdown } from 'monaco-editor/esm/vs/base/browser/markdownRenderer';
+
+export default monaco;
+export const customOptions: monaco.editor.IStandaloneDiffEditorConstructionOptions = JSON.parse(localStorage.getItem('editor.config') || '{}');
+export function saveCustomOptions() {
+  localStorage.setItem('editor.config', JSON.stringify(customOptions));
+}
+
+const loaded = {};
+async function fetchTheme(id: string, label: string) {
+  if (loaded[id]) return;
+  const res = await fetch(`${UiContext.cdn_prefix}monaco/themes/${label}.json`);
+  const data = await res.json();
+  monaco.editor.defineTheme(id, data);
+  loaded[id] = true;
+}
+export const loadThemePromise = customOptions.theme
+  ? fetchTheme(customOptions.theme, list[customOptions.theme])
+  : Promise.resolve();
+
+// 这破烂 monaco 能不能给个 typings 啊
+// 我翻源码真的很累的好吧
+class ChangeThemeAction extends EditorAction {
+  constructor() {
+    super({
+      id: 'hydro.changeEditorTheme',
+      label: i18n('Change Theme'),
+      alias: 'Change Theme',
+    });
+  }
+
+  async run(accessor, editor: monaco.editor.IStandaloneCodeEditor) {
+    const items = Object.keys(list).map((key) => ({
+      label: list[key],
+      command: key,
+    }));
+    const quickInputService = accessor.get(IQuickInputService);
+    const oldTheme = (editor as any)._themeService._theme;
+    let focus = '';
+    const selected = await quickInputService.pick(items, {
+      canPickMany: false,
+      async onDidFocus(item) {
+        focus = item.command;
+        await fetchTheme(item.command, item.label);
+        if (focus === item.command) monaco.editor.setTheme(item.command);
+      },
+    });
+    if (!selected) {
+      const themeId = oldTheme.type ? `${oldTheme.base}-${oldTheme.type}` : oldTheme.id;
+      return monaco.editor.setTheme(themeId);
+    }
+    await fetchTheme(selected.command, selected.label);
+    customOptions.theme = selected.command;
+    saveCustomOptions();
+    return monaco.editor.setTheme(selected.command);
+  }
+}
+
+registerEditorAction(ChangeThemeAction);
+
+const pagename = document.documentElement.getAttribute('data-page');
+const isProblemPage = ['problem_create', 'problem_edit'].includes(pagename);
+const isProblemEdit = pagename === 'problem_edit';
+function handlePasteEvent(editor: monaco.editor.IStandaloneCodeEditor) {
+  window.addEventListener('paste', (ev: ClipboardEvent) => {
+    if (!editor.hasTextFocus()) return;
+    const selection = editor.getSelection();
+    const { items } = ev.clipboardData;
+    let wrapper = ['', ''];
+    let ext;
+    const matches = items[0].type.match(/^image\/(png|jpg|jpeg|gif)$/i);
+    if (matches) {
+      wrapper = ['![image](', ')'];
+      [, ext] = matches;
+    } else if (items[0].type === 'application/x-zip-compressed') {
+      wrapper = ['[file](', ')'];
+      ext = 'zip';
+    }
+    if (!ext) return;
+    ev.preventDefault();
+    ev.stopPropagation();
+    const filename = `${nanoid()}.${ext}`;
+    const data = new FormData();
+    data.append('filename', filename);
+    data.append('file', items[0].getAsFile());
+    data.append('operation', 'upload_file');
+    if (isProblemEdit) data.append('type', 'additional_file');
+    let range: monaco.Range = null;
+    editor.executeEdits('', [{
+      range: new monaco.Range(selection.endLineNumber, selection.endColumn, selection.endLineNumber, selection.endColumn),
+      text: `![image](${i18n('Preparing Upload...')}) `,
+    }], (inverseOp) => { range = inverseOp[0].range; return null; });
+    editor.setPosition(editor.getSelection().getEndPosition());
+
+    function updateText(text: string) {
+      const pos = editor.getSelection();
+      const rangeBefore = range;
+      editor.executeEdits('', [{ range, text: `${wrapper[0]}${text}${wrapper[1]} ` }], (inverseOp) => {
+        range = inverseOp[0].range;
+        if (pos.endLineNumber !== pos.startLineNumber || pos.endLineNumber !== range.endLineNumber) return null;
+        const delta = rangeBefore.endColumn - range.endColumn;
+        editor.setPosition(new monaco.Position(pos.endLineNumber, pos.endColumn - delta));
+        return null;
+      });
+    }
+    let progress = 0;
+    request.postFile(isProblemEdit ? './files' : '/file', data, {
+      xhr() {
+        const xhr = new XMLHttpRequest();
+        xhr.upload.addEventListener('loadstart', () => updateText(i18n('Uploading...')));
+        xhr.upload.addEventListener('progress', (e) => {
+          if (!e.lengthComputable) return;
+          const percentComplete = Math.round((e.loaded / e.total) * 100);
+          if (percentComplete === progress) return;
+          progress = percentComplete;
+          updateText(`${i18n('Uploading...')} ${percentComplete}%`);
+        }, false);
+        return xhr;
+      },
+    })
+      .then(() => updateText(`${isProblemPage ? 'file://' : `/file/${UserContext._id}/`}${filename}`))
+      .catch((e) => {
+        console.error(e);
+        updateText(`${i18n('Upload Failed')}: ${e.message}`);
+      });
+  }, { capture: true });
+}
+
+export function registerAction(
+  editor: monaco.editor.IStandaloneCodeEditor,
+  model: monaco.editor.IModel,
+  element?,
+) {
+  if (element) {
+    editor.addAction({
+      id: 'hydro.submitForm',
+      label: 'Submit',
+      keybindings: [
+        monaco.KeyMod.CtrlCmd | monaco.KeyCode.Enter,
+        monaco.KeyMod.WinCtrl | monaco.KeyCode.Enter,
+      ],
+      run: () => {
+        const form = $(element).closest('form');
+        if (form.find('[data-default-submit]').length) form.find('[data-default-submit]').click();
+        else form.submit();
+      },
+    });
+  }
+  editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyMod.Shift | monaco.KeyCode.KeyP, () => {
+    editor.getAction('editor.action.quickCommand').run();
+  });
+  editor.addCommand(monaco.KeyMod.Alt | monaco.KeyMod.Shift | monaco.KeyCode.KeyF, () => {
+    const action = editor.getAction('editor.action.format') || editor.getAction('editor.action.formatDocument');
+    if (action) action.run();
+  });
+  editor.onDidChangeConfiguration(() => {
+    const current = editor.getOption(monaco.editor.EditorOptions.fontSize.id);
+    customOptions.fontSize = current;
+    saveCustomOptions();
+  });
+  if (model.getLanguageId() === 'markdown') {
+    const suggestWidget = (editor.getContribution('editor.contrib.suggestController') as any).widget?.value;
+    if (suggestWidget?._setDetailsVisible) suggestWidget._setDetailsVisible(true);
+    handlePasteEvent(editor);
+  }
+  if (!customOptions.theme) return null;
+  return loadThemePromise.then(() => editor.updateOptions({ theme: customOptions.theme }));
+}

package/components/monaco/languages/markdown.ts

@@ -0,0 +1,97 @@
+import keyword from 'emojis-keywords';
+import list from 'emojis-list';
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import qface from 'qface';
+import { api } from 'vj/utils';
+
+function emoji(range) {
+  return keyword.map((i, index) => ({
+    label: `${list[index]} ${i}`,
+    kind: monaco.languages.CompletionItemKind.Keyword,
+    documentation: i,
+    insertText: list[index],
+    range,
+  }));
+}
+
+function qqEmoji(range) {
+  return qface.data.flatMap((i) => {
+    const url = qface.getUrl(i.QSid, 'https://koishi.js.org/QFace');
+    return [i.QDes.substring(1), ...(i.Input || [])].map((input) => ({
+      label: `/${input}`,
+      kind: monaco.languages.CompletionItemKind.Keyword,
+      documentation: { value: `![${i.QDes}](${url})`, isTrusted: true },
+      insertText: `![${i.Input ? i.Input[0] : i.QDes.substring(1)}](${url} =32x32) `,
+      range,
+    }));
+  });
+}
+
+monaco.editor.registerCommand('hydro.openUserPage', (accesser, uid) => {
+  window.open(`/user/${uid}`);
+});
+
+monaco.languages.registerCodeLensProvider('markdown', {
+  async provideCodeLenses(model) {
+    const users = model.findMatches('\\[\\]\\(/user/(\\d+)\\)', true, true, true, null, true);
+    if (!users.length) {
+      return {
+        lenses: [],
+        dispose: () => { },
+      };
+    }
+    const data = await api('users', { ids: users.map((i) => +i.matches[1]) }, ['_id', 'uname']);
+    return {
+      lenses: users.map((i, index) => ({
+        range: i.range,
+        id: `${index}.${i.matches[1]}`,
+        command: {
+          id: 'hydro.openUserPage',
+          arguments: [i.matches[1]],
+          title: `@${data.find((doc) => doc._id.toString() === i.matches[1])?.uname || i.matches[1]}`,
+        },
+      })),
+      dispose: () => { },
+    };
+  },
+  resolveCodeLens(model, codeLens) {
+    return codeLens;
+  },
+});
+
+monaco.languages.registerCompletionItemProvider('markdown', {
+  async provideCompletionItems(model, position) {
+    const word = model.getWordAtPosition(position);
+    if (word.word.length < 2) return { suggestions: [] };
+    const prefix = model.getValueInRange({
+      startLineNumber: position.lineNumber,
+      endLineNumber: position.lineNumber,
+      startColumn: word.startColumn - 1,
+      endColumn: word.startColumn,
+    });
+    if (![':', '/', '@'].includes(prefix)) return { suggestions: [] };
+    const range = {
+      startLineNumber: position.lineNumber,
+      endLineNumber: position.lineNumber,
+      startColumn: word.startColumn - 1,
+      endColumn: word.endColumn,
+    };
+    if (prefix === '@') {
+      const users = await api('users', { search: word.word }, ['_id', 'uname']);
+      return {
+        suggestions: users.map((i) => ({
+          label: { label: `@${i.uname}`, description: `UID=${i._id}` },
+          kind: monaco.languages.CompletionItemKind.Property,
+          documentation: { value: `[](#loader) ![avatar](${new URL(i.avatarUrl, window.location.href)})`, isTrusted: true },
+          insertText: `@[](/user/${i._id}) `,
+          range,
+          sortText: i.priv === 0 ? '0' : '1',
+          tags: i.priv === 0 ? [1] : [],
+        })),
+      };
+    }
+    return {
+      suggestions: prefix === ':' ? emoji(range) : qqEmoji(range),
+    };
+  },
+});

package/components/monaco/languages/typescript.ts

@@ -0,0 +1,45 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+
+const types = require.context('@types/node/', true, /\.d\.ts$/, 'lazy-once');
+
+const diagnosticsOptions: monaco.languages.typescript.DiagnosticsOptions = {
+  noSemanticValidation: false,
+  noSyntaxValidation: false,
+  noSuggestionDiagnostics: true,
+};
+const compilerOptions: monaco.languages.typescript.CompilerOptions = {
+  target: monaco.languages.typescript.ScriptTarget.ES2020,
+  module: monaco.languages.typescript.ModuleKind.ESNext,
+  allowNonTsExtensions: true,
+};
+monaco.languages.typescript.javascriptDefaults.setDiagnosticsOptions(diagnosticsOptions);
+monaco.languages.typescript.typescriptDefaults.setDiagnosticsOptions(diagnosticsOptions);
+monaco.languages.typescript.javascriptDefaults.setCompilerOptions(compilerOptions);
+monaco.languages.typescript.typescriptDefaults.setCompilerOptions(compilerOptions);
+const libSource = [
+  'declare function readline(): string;',
+  'declare function print(content: string): void;',
+].join('\n');
+const libUri = 'ts:filename/basic.d.ts';
+monaco.languages.typescript.javascriptDefaults.addExtraLib(libSource, libUri);
+monaco.editor.createModel(libSource, 'typescript', monaco.Uri.parse(libUri));
+const modules = [];
+
+export async function loadTypes() {
+  for (const key of types.keys()) {
+    if (!key.startsWith('.')) continue;
+    const m = await types(key);
+    const val = m.replace('declare var require: NodeRequire;', '');
+    if (val.includes('declare module ')) {
+      modules.push(val.toString().split('declare module \'')[1].split('\'')[0]);
+    }
+    const uri = `ts:node/${key.split('./')[1]}`;
+    monaco.languages.typescript.javascriptDefaults.addExtraLib(val, uri);
+    monaco.editor.createModel(val, 'typescript', monaco.Uri.parse(uri));
+  }
+  let val = 'declare var require:';
+  for (const m of modules) val += `((id:'${m}')=>(typeof import('${m}')))&`;
+  val += '((id:string)=>any)';
+  monaco.languages.typescript.javascriptDefaults.addExtraLib(val, 'ts:node/require.d.ts');
+  monaco.editor.createModel(val, 'typescript', monaco.Uri.parse('ts:node/require.d.ts'));
+}

package/components/monaco/languages/yaml.ts

@@ -0,0 +1,22 @@
+import * as monaco from 'monaco-editor/esm/vs/editor/editor.api';
+import { configureMonacoYaml } from 'monaco-yaml';
+import problemConfigSchema from '../schema/problemconfig';
+
+configureMonacoYaml(monaco, {
+  validate: true,
+  enableSchemaRequest: true,
+  hover: true,
+  completion: true,
+  format: false,
+  schemas: [
+    {
+      uri: 'https://hydro.js.org/schema/problemConfig.json',
+      fileMatch: ['hydro://problem/file/config.yaml'],
+      schema: problemConfigSchema as any,
+    },
+    {
+      uri: new URL('/manage/config/schema.json', window.location.href).toString(),
+      fileMatch: ['hydro://system/setting.yaml'],
+    },
+  ],
+});