mirror of
https://github.com/clusterio/clusterio.git
synced 2026-11-17 07:30:41 +09:00
Refactor away the config group concept and simplyfy the way config fields are defined. Fields are defined directly as properties of the static field fieldDefinitions on the class itself with a separate interface to declare the types of fields. This makes it possible to easily make accessing the config fields type checked in a way that lets plugins extend the interfaces with their own config options by adding additional fields to the interface via declation merging.
327 lines
8.4 KiB
TypeScript
327 lines
8.4 KiB
TypeScript
import * as lib from "@clusterio/lib";
|
|
|
|
import React, { useEffect, useState } from "react";
|
|
import { Button, Card, Checkbox, Form, Input, InputNumber, Space, Spin, Tooltip, Tree, Typography } from "antd";
|
|
import ReloadOutlined from "@ant-design/icons/ReloadOutlined";
|
|
|
|
const { Title } = Typography;
|
|
|
|
function getInitialValues(config: lib.Config<any>, props: BaseConfigTreeProps) {
|
|
let initialValues: any = {};
|
|
for (let [name, def] of Object.entries(config.constructor.fieldDefinitions)) {
|
|
if (!config.canAccess(name)) {
|
|
continue;
|
|
}
|
|
|
|
let value = config.get(name) as any;
|
|
if (def.type === "object") {
|
|
for (let prop of Object.keys(value)) {
|
|
initialValues[`${name}.${prop}`] = JSON.stringify(value[prop]);
|
|
}
|
|
} else {
|
|
initialValues[name] = value;
|
|
}
|
|
}
|
|
return initialValues;
|
|
}
|
|
|
|
type BaseConfigTreeProps = {
|
|
ConfigClass: typeof lib.ControllerConfig | typeof lib.InstanceConfig;
|
|
retrieveConfig: () => Promise<lib.ConfigSchema>;
|
|
setField: (field:string, value:any) => Promise<void>;
|
|
setProp: (field:string, prop:string, value:any) => Promise<void>;
|
|
id?: number;
|
|
onApply?: () => void;
|
|
};
|
|
export default function BaseConfigTree(props: BaseConfigTreeProps) {
|
|
let [config, setConfig] = useState<lib.Config<any>|null>(null);
|
|
let [form] = Form.useForm();
|
|
let [changedFields, setChangedFields] = useState<Set<string>>(new Set());
|
|
let [errorFields, setErrorFields] = useState(new Map());
|
|
let [applying, setApplying] = useState(false);
|
|
|
|
async function updateConfig() {
|
|
let serializedConfig = await props.retrieveConfig();
|
|
const newConfig = props.ConfigClass.fromJSON(serializedConfig, "control");
|
|
setConfig(newConfig);
|
|
return newConfig;
|
|
}
|
|
useEffect(() => {
|
|
updateConfig().then(updatedConfig => {
|
|
form.setFieldsValue(getInitialValues(updatedConfig, props));
|
|
});
|
|
}, [props.id]);
|
|
|
|
function renderInput(def: lib.FieldDefinition) {
|
|
if (def.type === "boolean") {
|
|
return <Checkbox/>;
|
|
}
|
|
if (def.type === "string") {
|
|
return <Input/>;
|
|
}
|
|
if (def.type === "number") {
|
|
return <InputNumber/>;
|
|
}
|
|
|
|
return `Unknown type ${def.type}`;
|
|
}
|
|
|
|
if (config === null) {
|
|
return <Spin/>;
|
|
}
|
|
|
|
let initialValues: any = {};
|
|
function onValuesChange(changedValues: object) {
|
|
let newChangedFields = new Set(changedFields);
|
|
let changed = false;
|
|
for (let [key, value] of Object.entries(changedValues)) {
|
|
if (key.endsWith(":add.name") || key.endsWith(":add.value")) {
|
|
continue;
|
|
}
|
|
if (initialValues[key] === value) {
|
|
changed = newChangedFields.delete(key) || changed;
|
|
} else {
|
|
changed = !newChangedFields.has(key) || changed;
|
|
newChangedFields.add(key);
|
|
}
|
|
}
|
|
|
|
if (changed) {
|
|
setChangedFields(newChangedFields);
|
|
}
|
|
}
|
|
|
|
let restartTip = <Tooltip
|
|
className="ant-form-item-tooltip"
|
|
title="A restart is required for this setting to take effect"
|
|
><ReloadOutlined/></Tooltip>;
|
|
|
|
|
|
type ChildNode = {
|
|
key: string;
|
|
children: any[];
|
|
title?: React.ReactElement;
|
|
};
|
|
type TreeNode = {
|
|
key: string;
|
|
title: string;
|
|
children: ChildNode[];
|
|
};
|
|
|
|
let treeData = [];
|
|
let propsMap = new Map();
|
|
const groups = new Map<string, { [name: string]: lib.FieldDefinition }>();
|
|
for (let [fieldName, def] of Object.entries(props.ConfigClass.fieldDefinitions)) {
|
|
const [groupName, field] = lib.splitOn(".", fieldName);
|
|
let group = groups.get(groupName);
|
|
if (!group) {
|
|
group = {};
|
|
groups.set(groupName, group);
|
|
}
|
|
group[field] = def;
|
|
}
|
|
for (let [groupName, groupDefs] of groups) {
|
|
let treeNode: TreeNode = {
|
|
key: groupName,
|
|
title: groupName,
|
|
children: [],
|
|
};
|
|
|
|
for (let [field, def] of Object.entries(groupDefs)) {
|
|
if (!config.canAccess(`${groupName}.${field}`)) {
|
|
continue;
|
|
}
|
|
|
|
let fieldName = `${groupName}.${field}`;
|
|
let value = config.get(fieldName) as any;
|
|
let childNode: ChildNode = {
|
|
key: fieldName,
|
|
children: [],
|
|
};
|
|
|
|
if (def.type === "object") {
|
|
let restartRequiredProps = new Set(def.restartRequiredProps || []);
|
|
childNode.title = <Form.Item
|
|
label={<>
|
|
{def.title || field}
|
|
{!def.restartRequiredProps && def.restartRequired && restartTip}
|
|
</>}
|
|
tooltip={def.description}
|
|
/>;
|
|
for (let prop of Object.keys(value)) {
|
|
let propPath = `${groupName}.${field}.${prop}`;
|
|
let restart = Boolean(
|
|
def.restartRequiredProps && Number(def.restartRequired) ^ Number(restartRequiredProps.has(prop))
|
|
);
|
|
childNode.children.push({
|
|
key: propPath,
|
|
title: <Form.Item
|
|
name={propPath}
|
|
label={<>
|
|
{`"${prop}"`}
|
|
{restart && restartTip}
|
|
</>}
|
|
rules={[{ validator: (_, fieldValue) => {
|
|
if (!fieldValue.length) {
|
|
return Promise.reject(new Error("Will be removed"));
|
|
}
|
|
try {
|
|
JSON.parse(fieldValue);
|
|
} catch (err) {
|
|
return Promise.reject(new Error("Must be valid json"));
|
|
}
|
|
return Promise.resolve();
|
|
}}]}
|
|
>
|
|
<Input className="json-input" />
|
|
</Form.Item>,
|
|
});
|
|
|
|
initialValues[propPath] = JSON.stringify(value[prop]);
|
|
propsMap.set(propPath, [fieldName, prop]);
|
|
}
|
|
|
|
let newPropPath = `${groupName}.${field}:add`;
|
|
childNode.children.push({
|
|
key: newPropPath,
|
|
title: <Space>
|
|
<Form.Item
|
|
name={`${newPropPath}.name`}
|
|
noStyle={true}
|
|
>
|
|
<Input />
|
|
</Form.Item>:
|
|
<Form.Item
|
|
name={`${newPropPath}.value`}
|
|
noStyle={true}
|
|
>
|
|
<Input className="json-input" />
|
|
</Form.Item>
|
|
<Button
|
|
size="small"
|
|
onClick={() => {
|
|
let propName = form.getFieldValue(`${newPropPath}.name`);
|
|
let propValue = form.getFieldValue(`${newPropPath}.value`);
|
|
if (!Object.prototype.hasOwnProperty.call(value, propName)) {
|
|
let newConfig = props.ConfigClass.fromJSON(config!.toJSON(), "control");
|
|
(newConfig as lib.Config<any>).setProp(fieldName, propName, null);
|
|
setConfig(newConfig);
|
|
}
|
|
|
|
let propPath = `${groupName}.${field}.${propName}`;
|
|
form.setFieldsValue({
|
|
[`${newPropPath}.name`]: "",
|
|
[`${newPropPath}.value`]: "",
|
|
[propPath]: propValue,
|
|
});
|
|
form.validateFields([propPath]);
|
|
onValuesChange({ [propPath]: propValue });
|
|
}}
|
|
>
|
|
Add
|
|
</Button>
|
|
</Space>,
|
|
});
|
|
|
|
} else {
|
|
childNode.title = <Form.Item
|
|
name={fieldName}
|
|
label={<>
|
|
{def.title || field}
|
|
{def.restartRequired && restartTip}
|
|
</>}
|
|
validateStatus={errorFields.has(fieldName) ? "error" : undefined}
|
|
help={errorFields.get(fieldName)}
|
|
tooltip={def.description}
|
|
valuePropName={def.type === "boolean" ? "checked" : "value"}
|
|
>
|
|
{renderInput(def)}
|
|
</Form.Item>;
|
|
initialValues[fieldName] = value;
|
|
}
|
|
|
|
treeNode.children.push(childNode);
|
|
}
|
|
|
|
treeData.push(treeNode);
|
|
}
|
|
|
|
return <>
|
|
<Title level={5} style={{ marginTop: 16 }}>
|
|
Config
|
|
<Space style={{ float: "right" }}>
|
|
<Button
|
|
type="primary"
|
|
size="small"
|
|
loading={applying}
|
|
onClick={async () => {
|
|
setApplying(true);
|
|
for (let field of changedFields) {
|
|
let value = form.getFieldValue(field);
|
|
let request;
|
|
if (propsMap.has(field)) {
|
|
let [fieldName, prop] = propsMap.get(field);
|
|
request = props.setProp(fieldName, prop, value);
|
|
|
|
} else {
|
|
request = props.setField(field, value === null ? "" : String(value));
|
|
}
|
|
|
|
try {
|
|
await request;
|
|
setChangedFields(changed => {
|
|
let newChanged = new Set(changed);
|
|
newChanged.delete(field);
|
|
return newChanged;
|
|
});
|
|
|
|
} catch (err: any) {
|
|
setErrorFields(errors => {
|
|
let newErrors = new Map(errors);
|
|
newErrors.set(field, err.message);
|
|
return newErrors;
|
|
});
|
|
}
|
|
}
|
|
|
|
await updateConfig();
|
|
setApplying(false);
|
|
|
|
if (props.onApply) {
|
|
props.onApply();
|
|
}
|
|
}}
|
|
disabled={changedFields.size === 0}
|
|
>
|
|
Apply
|
|
</Button>
|
|
<Button
|
|
size="small"
|
|
onClick={() => {
|
|
form.resetFields();
|
|
setChangedFields(new Set());
|
|
setErrorFields(new Map());
|
|
}}
|
|
>
|
|
Revert
|
|
</Button>
|
|
</Space>
|
|
</Title>
|
|
<Card size="small" className="config-container">
|
|
<Form
|
|
size="small"
|
|
form={form}
|
|
initialValues={initialValues}
|
|
onValuesChange={onValuesChange}
|
|
>
|
|
<Tree
|
|
treeData={treeData}
|
|
selectable={false}
|
|
defaultExpandAll={true}
|
|
filterTreeNode={(node) => changedFields.has(node.key)}
|
|
/>
|
|
</Form>
|
|
</Card>
|
|
</>;
|
|
}
|