tsondb 0.5.19 → 0.6.1

package/dist/src/web/components/typeInputs/EnumTypeInput.js

@@ -1,11 +1,16 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { discriminatorKey } from "../../../shared/enum.js";
 import { toTitleCase } from "../../../shared/utils/string.js";
+import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
+import { useSetting } from "../../hooks/useSettings.js";
+import { Markdown } from "../../utils/Markdown.js";
 import { createTypeSkeleton } from "../../utils/typeSkeleton.js";
 import { Select } from "../Select.js";
 import { TypeInput } from "./TypeInput.js";
 import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
-export const EnumTypeInput = ({ type, path, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+export const EnumTypeInput = props => {
+    const { type, path, value, disabled, getDeclFromDeclName, onChange } = props;
+    const [enumDisplay] = useSetting("enumDisplay");
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
@@ -13,26 +18,54 @@ export const EnumTypeInput = ({ type, path, value, instanceNamesByEntity, getDec
         typeof value[discriminatorKey] !== "string") {
         return _jsx(MismatchingTypeError, { expected: "enumeration value", actual: value });
     }
-    const enumValues = Object.keys(type.values);
+    const enumValues = Object.entries(type.values);
     const activeEnumCase = value[discriminatorKey];
-    const caseMember = type.values[activeEnumCase];
-    return (_jsxs("div", { class: "field field--enum", children: [_jsx(Select, { value: activeEnumCase, onInput: event => {
-                    const caseMember = type.values[event.currentTarget.value];
-                    if (caseMember?.type == null) {
-                        onChange({
-                            [discriminatorKey]: event.currentTarget.value,
-                        });
-                    }
-                    else {
-                        onChange({
-                            [discriminatorKey]: event.currentTarget.value,
-                            [event.currentTarget.value]: createTypeSkeleton(getDeclFromDeclName, caseMember.type),
-                        });
-                    }
-                }, children: enumValues.map(enumValue => (_jsx("option", { value: enumValue, selected: enumValue === activeEnumCase, children: toTitleCase(enumValue) }, enumValue))) }), caseMember?.type == null ? null : (_jsx("div", { className: "associated-type", children: _jsx(TypeInput, { type: caseMember.type, path: path === undefined ? `{${activeEnumCase}}` : `${path}.{${activeEnumCase}}`, value: value[activeEnumCase], instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newValue => {
-                        onChange({
-                            [discriminatorKey]: activeEnumCase,
-                            [activeEnumCase]: newValue,
-                        });
-                    } }) }))] }));
+    const activeCaseMember = type.values[activeEnumCase];
+    switch (enumDisplay) {
+        case "select":
+            return (_jsxs("div", { class: "field field--enum", children: [_jsx(Select, { value: activeEnumCase, onInput: event => {
+                            const caseMember = type.values[event.currentTarget.value];
+                            if (caseMember?.type == null) {
+                                onChange({
+                                    [discriminatorKey]: event.currentTarget.value,
+                                });
+                            }
+                            else {
+                                onChange({
+                                    [discriminatorKey]: event.currentTarget.value,
+                                    [event.currentTarget.value]: createTypeSkeleton(getDeclFromDeclName, caseMember.type),
+                                });
+                            }
+                        }, disabled: disabled, children: enumValues.map(([enumValue]) => (_jsx("option", { value: enumValue, selected: enumValue === activeEnumCase, children: toTitleCase(enumValue) }, enumValue))) }), activeCaseMember?.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: activeCaseMember.comment })), activeCaseMember?.type == null ? null : (_jsx("div", { className: "associated-type", children: _jsx(TypeInput, { ...props, parentKey: undefined, type: activeCaseMember.type, path: path === undefined ? `{${activeEnumCase}}` : `${path}.{${activeEnumCase}}`, value: value[activeEnumCase], onChange: newValue => {
+                                onChange({
+                                    [discriminatorKey]: activeEnumCase,
+                                    [activeEnumCase]: newValue,
+                                });
+                            } }) }))] }));
+        case "radio":
+            return (_jsx("div", { class: "field field--enum", children: enumValues.map(([enumValue, caseMember]) => (_jsxs("div", { class: "field--option", children: [_jsx("input", { type: "radio", name: path, value: enumValue, id: path === undefined ? enumValue : `${path}-${enumValue}`, checked: enumValue === activeEnumCase, onInput: () => {
+                                if (caseMember.type == null) {
+                                    onChange({
+                                        [discriminatorKey]: enumValue,
+                                    });
+                                }
+                                else {
+                                    onChange({
+                                        [discriminatorKey]: enumValue,
+                                        [enumValue]: createTypeSkeleton(getDeclFromDeclName, caseMember.type),
+                                    });
+                                }
+                            }, disabled: disabled }), _jsxs("div", { children: [_jsx("label", { htmlFor: path === undefined ? enumValue : `${path}-${enumValue}`, children: toTitleCase(enumValue) }), caseMember.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: caseMember.comment })), caseMember.type == null ? null : (_jsx("div", { className: "associated-type", children: _jsx(TypeInput, { ...props, parentKey: undefined, type: caseMember.type, path: path === undefined ? `{${activeEnumCase}}` : `${path}.{${activeEnumCase}}`, value: enumValue === activeEnumCase
+                                            ? value[activeEnumCase]
+                                            : createTypeSkeleton(getDeclFromDeclName, caseMember.type), disabled: disabled || enumValue !== activeEnumCase, onChange: disabled
+                                            ? () => { }
+                                            : newValue => {
+                                                onChange({
+                                                    [discriminatorKey]: activeEnumCase,
+                                                    [activeEnumCase]: newValue,
+                                                });
+                                            } }) }))] })] }, enumValue))) }));
+        default:
+            return assertExhaustive(enumDisplay);
+    }
 };

package/dist/src/web/components/typeInputs/FloatTypeInput.d.ts

@@ -1,9 +1,6 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedFloatType } from "../../../node/schema/types/primitives/FloatType.ts";
-type Props = {
-    type: SerializedFloatType;
-    value: unknown;
-    onChange: (value: number) => void;
-};
+import type { SerializedFloatType } from "../../../shared/schema/types/FloatType.ts";
+import type { TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedFloatType, number>;
 export declare const FloatTypeInput: FunctionComponent<Props>;
 export {};

package/dist/src/web/components/typeInputs/FloatTypeInput.js

@@ -3,7 +3,7 @@ import { useState } from "preact/hooks";
 import { validateNumberConstraints } from "../../../shared/validation/number.js";
 import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
-export const FloatTypeInput = ({ type, value, onChange }) => {
+export const FloatTypeInput = ({ type, value, disabled, onChange }) => {
     const [stringValue, setStringValue] = useState(typeof value === "number" ? value.toString() : "");
     if (typeof value !== "number") {
         return _jsx(MismatchingTypeError, { expected: "float", actual: value });
@@ -15,5 +15,5 @@ export const FloatTypeInput = ({ type, value, onChange }) => {
                     if (!Number.isNaN(numericValue)) {
                         onChange(numericValue);
                     }
-                }, step: 0.01, "aria-invalid": errors.length > 0 }), _jsx(ValidationErrors, { errors: errors })] }));
+                }, step: 0.01, "aria-invalid": errors.length > 0, disabled: disabled }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }));
 };

package/dist/src/web/components/typeInputs/GenericTypeArgumentIdentifierTypeInput.d.ts

@@ -1,7 +1,6 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedTypeArgumentType } from "../../../node/schema/types/references/TypeArgumentType.ts";
-type Props = {
-    type: SerializedTypeArgumentType;
-};
+import type { SerializedTypeArgumentType } from "../../../shared/schema/types/TypeArgumentType.ts";
+import type { TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedTypeArgumentType>;
 export declare const TypeArgumentTypeInput: FunctionComponent<Props>;
 export {};

package/dist/src/web/components/typeInputs/IncludeIdentifierTypeInput.d.ts

@@ -1,14 +1,6 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedIncludeIdentifierType } from "../../../node/schema/index.ts";
-import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.ts";
-import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.ts";
-type Props = {
-    type: SerializedIncludeIdentifierType;
-    path: string | undefined;
-    value: unknown;
-    instanceNamesByEntity: InstanceNamesByEntity;
-    getDeclFromDeclName: GetDeclFromDeclName;
-    onChange: (value: unknown) => void;
-};
+import type { SerializedIncludeIdentifierType } from "../../../shared/schema/types/IncludeIdentifierType.ts";
+import { type TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedIncludeIdentifierType>;
 export declare const IncludeIdentifierTypeInput: FunctionComponent<Props>;
 export {};

package/dist/src/web/components/typeInputs/IncludeIdentifierTypeInput.js

@@ -1,9 +1,10 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { TypeInput } from "./TypeInput.js";
-export const IncludeIdentifierTypeInput = ({ type, path, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+export const IncludeIdentifierTypeInput = props => {
+    const { type, getDeclFromDeclName } = props;
     const decl = getDeclFromDeclName(type.reference);
     if (decl === undefined) {
         return (_jsxs("div", { role: "alert", children: ["Unresolved declaration identifier ", _jsx("code", { children: type.reference })] }));
     }
-    return (_jsx(TypeInput, { type: decl.type, path: path, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+    return _jsx(TypeInput, { ...props, parentKey: undefined, type: decl.type });
 };

package/dist/src/web/components/typeInputs/IntegerTypeInput.d.ts

@@ -1,9 +1,6 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedIntegerType } from "../../../node/schema/types/primitives/IntegerType.ts";
-type Props = {
-    type: SerializedIntegerType;
-    value: unknown;
-    onChange: (value: number) => void;
-};
+import type { SerializedIntegerType } from "../../../shared/schema/types/IntegerType.ts";
+import type { TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedIntegerType, number>;
 export declare const IntegerTypeInput: FunctionComponent<Props>;
 export {};

package/dist/src/web/components/typeInputs/IntegerTypeInput.js

@@ -3,7 +3,7 @@ import { useState } from "preact/hooks";
 import { validateNumberConstraints } from "../../../shared/validation/number.js";
 import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
-export const IntegerTypeInput = ({ type, value, onChange }) => {
+export const IntegerTypeInput = ({ type, value, disabled, onChange }) => {
     const [stringValue, setStringValue] = useState(typeof value === "number" ? value.toString() : "");
     if (typeof value !== "number") {
         return _jsx(MismatchingTypeError, { expected: "float", actual: value });
@@ -15,5 +15,5 @@ export const IntegerTypeInput = ({ type, value, onChange }) => {
                     if (!Number.isNaN(numericValue)) {
                         onChange(numericValue);
                     }
-                }, step: 0.01, "aria-invalid": errors.length > 0 }), _jsx(ValidationErrors, { errors: errors })] }));
+                }, step: 0.01, "aria-invalid": errors.length > 0, disabled: disabled }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }));
 };

package/dist/src/web/components/typeInputs/NestedEntityMapTypeInput.d.ts

@@ -1,14 +1,6 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedNestedEntityMapType } from "../../../node/schema/types/references/NestedEntityMapType.ts";
-import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.ts";
-import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.ts";
-type Props = {
-    type: SerializedNestedEntityMapType;
-    path: string | undefined;
-    value: unknown;
-    instanceNamesByEntity: InstanceNamesByEntity;
-    getDeclFromDeclName: GetDeclFromDeclName;
-    onChange: (value: Record<string, unknown>) => void;
-};
+import type { SerializedNestedEntityMapType } from "../../../shared/schema/types/NestedEntityMapType.ts";
+import { type TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedNestedEntityMapType, Record<string, unknown>>;
 export declare const NestedEntityMapTypeInput: FunctionComponent<Props>;
 export {};

package/dist/src/web/components/typeInputs/NestedEntityMapTypeInput.js

@@ -6,7 +6,8 @@ import { createTypeSkeleton } from "../../utils/typeSkeleton.js";
 import { Select } from "../Select.js";
 import { TypeInput } from "./TypeInput.js";
 import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
-export const NestedEntityMapTypeInput = ({ type, path, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+export const NestedEntityMapTypeInput = props => {
+    const { type, path, value, instanceNamesByEntity, disabled, getDeclFromDeclName, onChange } = props;
     const [newKey, setNewKey] = useState("");
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return _jsx(MismatchingTypeError, { expected: "object", actual: value });
@@ -24,16 +25,16 @@ export const NestedEntityMapTypeInput = ({ type, path, value, instanceNamesByEnt
                                                 // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                                                 delete newObj[key];
                                                 onChange(newObj);
-                                            }, children: ["Delete ", name] }) })] }), _jsx(TypeInput, { type: type.type, path: path === undefined ? key : `${path}.${key}`, value: item, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => {
+                                            }, disabled: disabled, children: ["Delete ", name] }) })] }), _jsx(TypeInput, { ...props, parentKey: undefined, type: type.type, path: path === undefined ? key : `${path}.${key}`, value: item, onChange: newItem => {
                                     onChange(sortObjectKeysAlphabetically({ ...value, [key]: newItem }));
                                 } })] }, key));
                 }) })), _jsxs("div", { class: "add-item-container", children: [_jsxs(Select, { value: newKey, onInput: event => {
                             setNewKey(event.currentTarget.value);
-                        }, disabled: secondaryInstances.length === 0, children: [secondaryInstances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), secondaryInstances.map(instance => (_jsx("option", { value: instance.id, children: instance.name }, instance.id)))] }), _jsxs("button", { onClick: () => {
+                        }, disabled: disabled || secondaryInstances.length === 0, children: [secondaryInstances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), secondaryInstances.map(instance => (_jsx("option", { value: instance.id, children: instance.name }, instance.id)))] }), _jsxs("button", { onClick: () => {
                             onChange(sortObjectKeysAlphabetically({
                                 ...value,
                                 [newKey]: createTypeSkeleton(getDeclFromDeclName, type.type),
                             }));
                             setNewKey("");
-                        }, disabled: newKey === "", children: ["Add ", newKey === "" ? "Key" : toTitleCase(newKey)] })] })] }));
+                        }, disabled: disabled || newKey === "", children: ["Add ", newKey === "" ? "Key" : toTitleCase(newKey)] })] })] }));
 };

package/dist/src/web/components/typeInputs/ObjectTypeInput.d.ts

@@ -1,14 +1,6 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedObjectType } from "../../../node/schema/types/generic/ObjectType.ts";
-import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.ts";
-import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.ts";
-type Props = {
-    type: SerializedObjectType;
-    path: string | undefined;
-    value: unknown;
-    instanceNamesByEntity: InstanceNamesByEntity;
-    getDeclFromDeclName: GetDeclFromDeclName;
-    onChange: (value: Record<string, unknown>) => void;
-};
+import type { SerializedObjectType } from "../../../shared/schema/types/ObjectType.ts";
+import { type TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedObjectType, Record<string, unknown>>;
 export declare const ObjectTypeInput: FunctionComponent<Props>;
 export {};

package/dist/src/web/components/typeInputs/ObjectTypeInput.js

@@ -7,23 +7,26 @@ import { createTypeSkeleton } from "../../utils/typeSkeleton.js";
 import { TypeInput } from "./TypeInput.js";
 import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
-export const ObjectTypeInput = ({ type, path, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+export const ObjectTypeInput = props => {
+    const { type, path, value, parentKey, disabled, getDeclFromDeclName, onChange } = props;
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return _jsx(MismatchingTypeError, { expected: "object", actual: value });
     }
     const errors = validateObjectConstraints(type, Object.keys(type.properties), value);
-    return (_jsxs("div", { class: "field field--container field--object", children: [_jsx("ul", { children: Object.entries(type.properties).map(([key, memberDecl]) => (_jsxs("li", { class: "container-item object-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [_jsx("strong", { children: toTitleCase(key) }), memberDecl.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: memberDecl.comment }))] }), memberDecl.isRequired ? null : value[key] ===
+    return (_jsxs("div", { class: "field field--container field--object" + (disabled ? " field--disabled" : ""), children: [_jsx("ul", { children: Object.entries(type.properties)
+                    .filter(([key]) => key !== parentKey)
+                    .map(([key, memberDecl]) => (_jsxs("li", { class: "container-item object-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [_jsx("strong", { children: toTitleCase(key) }), memberDecl.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: memberDecl.comment }))] }), memberDecl.isRequired ? null : value[key] ===
                                     undefined ? (_jsxs("button", { onClick: () => {
                                         onChange(sortObjectKeys({
                                             ...value,
                                             [key]: createTypeSkeleton(getDeclFromDeclName, memberDecl.type),
                                         }, Object.keys(type.properties)));
-                                    }, children: ["Add ", toTitleCase(key)] })) : (_jsxs("button", { class: "destructive", onClick: () => {
+                                    }, disabled: disabled, children: ["Add ", toTitleCase(key)] })) : (_jsxs("button", { class: "destructive", onClick: () => {
                                         const newObj = { ...value };
                                         // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                                         delete newObj[key];
                                         onChange(newObj);
-                                    }, children: ["Remove ", toTitleCase(key)] }))] }), memberDecl.isRequired || value[key] !== undefined ? (_jsx(TypeInput, { type: memberDecl.type, path: path === undefined ? key : `${path}.${key}`, value: value[key], instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => {
+                                    }, disabled: disabled, children: ["Remove ", toTitleCase(key)] }))] }), memberDecl.isRequired || value[key] !== undefined ? (_jsx(TypeInput, { ...props, parentKey: undefined, type: memberDecl.type, path: path === undefined ? key : `${path}.${key}`, value: value[key], onChange: newItem => {
                                 onChange(sortObjectKeys({ ...value, [key]: newItem }, Object.keys(type.properties)));
-                            } })) : null] }, key))) }), _jsx(ValidationErrors, { errors: errors })] }));
+                            } })) : null] }, key))) }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }));
 };

package/dist/src/web/components/typeInputs/ReferenceIdentifierTypeInput.d.ts

@@ -1,11 +1,6 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedReferenceIdentifierType } from "../../../node/schema/types/references/ReferenceIdentifierType.ts";
-import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.ts";
-type Props = {
-    type: SerializedReferenceIdentifierType;
-    value: unknown;
-    instanceNamesByEntity: InstanceNamesByEntity;
-    onChange: (value: string) => void;
-};
+import type { SerializedReferenceIdentifierType } from "../../../shared/schema/types/ReferenceIdentifierType.ts";
+import type { TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedReferenceIdentifierType, string>;
 export declare const ReferenceIdentifierTypeInput: FunctionComponent<Props>;
 export {};

package/dist/src/web/components/typeInputs/ReferenceIdentifierTypeInput.js

@@ -2,7 +2,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { Select } from "../Select.js";
 import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
-export const ReferenceIdentifierTypeInput = ({ type, value, instanceNamesByEntity, onChange, }) => {
+export const ReferenceIdentifierTypeInput = ({ type, value, instanceNamesByEntity, disabled, onChange, }) => {
     if (typeof value !== "string") {
         return _jsx(MismatchingTypeError, { expected: "string identifier", actual: value });
     }
@@ -11,5 +11,5 @@ export const ReferenceIdentifierTypeInput = ({ type, value, instanceNamesByEntit
         .sort((a, b) => a.name.localeCompare(b.name, undefined, { numeric: true }));
     return (_jsxs("div", { class: "field", children: [_jsxs(Select, { value: value, onInput: event => {
                     onChange(event.currentTarget.value);
-                }, disabled: instances.length === 0, "aria-invalid": !value, children: [instances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), instances.map(instance => (_jsx("option", { value: instance.id, children: instance.name }, instance.id)))] }), _jsx(ValidationErrors, { errors: !value ? [ReferenceError("no reference provided")] : [] })] }));
+                }, disabled: disabled || instances.length === 0, "aria-invalid": !value, children: [instances.length === 0 ? (_jsx("option", { value: "", disabled: true, children: "No instances available" })) : (_jsx("option", { value: "", disabled: true, children: "No selected instance" })), instances.map(instance => (_jsx("option", { value: instance.id, children: instance.name }, instance.id)))] }), _jsx(ValidationErrors, { disabled: disabled, errors: !value ? [ReferenceError("no reference provided")] : [] })] }));
 };

package/dist/src/web/components/typeInputs/StringTypeInput.d.ts

@@ -1,9 +1,6 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedStringType } from "../../../node/schema/types/primitives/StringType.ts";
-type Props = {
-    type: SerializedStringType;
-    value: unknown;
-    onChange: (value: string) => void;
-};
+import type { SerializedStringType } from "../../../shared/schema/types/StringType.ts";
+import type { TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedStringType, string>;
 export declare const StringTypeInput: FunctionComponent<Props>;
 export {};

package/dist/src/web/components/typeInputs/StringTypeInput.js

@@ -4,7 +4,7 @@ import { Markdown } from "../../utils/Markdown.js";
 import { MarkdownHighlighting } from "../../utils/MarkdownHighlighting.js";
 import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
-export const StringTypeInput = ({ type, value, onChange }) => {
+export const StringTypeInput = ({ type, value, disabled, onChange }) => {
     if (typeof value !== "string") {
         return _jsx(MismatchingTypeError, { expected: "string", actual: value });
     }
@@ -12,11 +12,11 @@ export const StringTypeInput = ({ type, value, onChange }) => {
     const errors = validateStringConstraints(type, value);
     return (_jsx("div", { class: "field field--string", children: isMarkdown ? (_jsxs(_Fragment, { children: [_jsxs("div", { class: "editor editor--markdown", children: [_jsxs("div", { class: "textarea-grow-wrap", children: [_jsx("textarea", { value: value, minLength: minLength, maxLength: maxLength, onInput: event => {
                                         onChange(event.currentTarget.value);
-                                    }, "aria-invalid": errors.length > 0 }), _jsxs("p", { class: "help", children: ["This textarea supports", " ", _jsx("a", { href: "https://www.markdownguide.org/getting-started/", target: "_blank", rel: "noreferrer", children: "Markdown" }), "."] }), _jsx(MarkdownHighlighting, { class: "textarea-grow-wrap__mirror editor-highlighting", string: value })] }), _jsx(ValidationErrors, { errors: errors })] }), _jsx("div", { class: "preview", children: _jsx(Markdown, { string: value }) })] })) : (_jsxs("div", { class: "editor", children: [_jsx("input", { type: "text", value: value, minLength: minLength, maxLength: maxLength, pattern: pattern === undefined
+                                    }, "aria-invalid": errors.length > 0, disabled: disabled }), _jsxs("p", { class: "help", children: ["This textarea supports", " ", _jsx("a", { href: "https://www.markdownguide.org/getting-started/", target: "_blank", rel: "noreferrer", children: "Markdown" }), "."] }), _jsx(MarkdownHighlighting, { class: "textarea-grow-wrap__mirror editor-highlighting", string: value })] }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }), _jsx("div", { class: "preview", children: _jsx(Markdown, { string: value }) })] })) : (_jsxs("div", { class: "editor", children: [_jsx("input", { type: "text", value: value, minLength: minLength, maxLength: maxLength, pattern: pattern === undefined
                         ? undefined
                         : pattern.startsWith("^(?:") && pattern.endsWith(")$")
                             ? pattern.slice(4, -2)
                             : `.*${pattern}.*`, onInput: event => {
                         onChange(event.currentTarget.value);
-                    }, "aria-invalid": errors.length > 0 }), _jsx(ValidationErrors, { errors: errors })] })) }));
+                    }, "aria-invalid": errors.length > 0, disabled: disabled }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] })) }));
 };

package/dist/src/web/components/typeInputs/TypeInput.d.ts

@@ -1,14 +1,22 @@
 import type { FunctionComponent } from "preact";
-import type { SerializedType } from "../../../node/schema/types/Type.ts";
+import type { UnsafeEntityTaggedInstanceContainerWithChildInstances } from "../../../node/utils/childInstances.ts";
+import type { SerializedType } from "../../../shared/schema/types/Type.ts";
 import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.ts";
 import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.ts";
-type Props = {
-    type: SerializedType;
+export type TypeInputProps<T, V = unknown> = {
+    type: T;
     path: string | undefined;
     value: unknown;
     instanceNamesByEntity: InstanceNamesByEntity;
+    parentKey?: string;
+    childInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[];
+    disabled?: boolean;
     getDeclFromDeclName: GetDeclFromDeclName;
-    onChange: (value: unknown) => void;
+    onChange: (value: V) => void;
+    onChildChange: (index: number, value: unknown) => void;
+    onChildAdd: (entityName: string, value: unknown) => void;
+    onChildRemove: (index: number) => void;
 };
+type Props = TypeInputProps<SerializedType>;
 declare const MemoizedTypeInput: FunctionComponent<Props>;
 export { MemoizedTypeInput as TypeInput };

package/dist/src/web/components/typeInputs/TypeInput.js

@@ -3,6 +3,7 @@ import { memo } from "preact/compat";
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { ArrayTypeInput } from "./ArrayTypeInput.js";
 import { BooleanTypeInput } from "./BooleanTypeInput.js";
+import { ChildEntitiesTypeInput } from "./ChildEntitiesTypeInput.js";
 import { DateTypeInput } from "./DateTypeInput.js";
 import { EnumTypeInput } from "./EnumTypeInput.js";
 import { FloatTypeInput } from "./FloatTypeInput.js";
@@ -13,36 +14,40 @@ import { NestedEntityMapTypeInput } from "./NestedEntityMapTypeInput.js";
 import { ObjectTypeInput } from "./ObjectTypeInput.js";
 import { ReferenceIdentifierTypeInput } from "./ReferenceIdentifierTypeInput.js";
 import { StringTypeInput } from "./StringTypeInput.js";
-const TypeInput = ({ type, path, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
-    // console.log("rendering node at path ", path ?? "<root>")
-    switch (type.kind) {
+const TypeInput = props => {
+    // console.log("rendering node at path ", props.path ?? "<root>")
+    switch (props.type.kind) {
         case "BooleanType":
-            return _jsx(BooleanTypeInput, { type: type, value: value, onChange: onChange });
+            return _jsx(BooleanTypeInput, { ...props, type: props.type });
         case "DateType":
-            return _jsx(DateTypeInput, { type: type, value: value, onChange: onChange });
+            return _jsx(DateTypeInput, { ...props, type: props.type });
         case "FloatType":
-            return _jsx(FloatTypeInput, { type: type, value: value, onChange: onChange });
+            return _jsx(FloatTypeInput, { ...props, type: props.type });
         case "IntegerType":
-            return _jsx(IntegerTypeInput, { type: type, value: value, onChange: onChange });
+            return _jsx(IntegerTypeInput, { ...props, type: props.type });
         case "StringType":
-            return _jsx(StringTypeInput, { type: type, value: value, onChange: onChange });
+            return _jsx(StringTypeInput, { ...props, type: props.type });
         case "ArrayType":
-            return (_jsx(ArrayTypeInput, { type: type, path: path, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+            return _jsx(ArrayTypeInput, { ...props, type: props.type });
         case "ObjectType":
-            return (_jsx(ObjectTypeInput, { type: type, path: path, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+            return _jsx(ObjectTypeInput, { ...props, type: props.type });
         case "TypeArgumentType":
-            return _jsx(TypeArgumentTypeInput, { type: type });
+            return _jsx(TypeArgumentTypeInput, { ...props, type: props.type });
         case "ReferenceIdentifierType":
-            return (_jsx(ReferenceIdentifierTypeInput, { type: type, value: value, instanceNamesByEntity: instanceNamesByEntity, onChange: onChange }));
+            return _jsx(ReferenceIdentifierTypeInput, { ...props, type: props.type });
         case "IncludeIdentifierType":
-            return (_jsx(IncludeIdentifierTypeInput, { type: type, path: path, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+            return _jsx(IncludeIdentifierTypeInput, { ...props, type: props.type });
         case "NestedEntityMapType":
-            return (_jsx(NestedEntityMapTypeInput, { type: type, path: path, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+            return _jsx(NestedEntityMapTypeInput, { ...props, type: props.type });
         case "EnumType":
-            return (_jsx(EnumTypeInput, { type: type, path: path, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+            return _jsx(EnumTypeInput, { ...props, type: props.type });
+        case "ChildEntitiesType":
+            return _jsx(ChildEntitiesTypeInput, { ...props, type: props.type });
         default:
-            return assertExhaustive(type);
+            return assertExhaustive(props.type);
     }
 };
-const MemoizedTypeInput = memo(TypeInput, (prevProps, nextProps) => prevProps.value === nextProps.value && prevProps.onChange === nextProps.onChange);
+const MemoizedTypeInput = memo(TypeInput, (prevProps, nextProps) => prevProps.value === nextProps.value &&
+    prevProps.onChange === nextProps.onChange &&
+    prevProps.childInstances === nextProps.childInstances);
 export { MemoizedTypeInput as TypeInput };

package/dist/src/web/components/typeInputs/utils/ValidationErrors.d.ts

@@ -1,5 +1,6 @@
 import type { FunctionComponent } from "preact";
 type Props = {
+    disabled?: boolean;
     errors: Error[];
 };
 export declare const ValidationErrors: FunctionComponent<Props>;

package/dist/src/web/components/typeInputs/utils/ValidationErrors.js

@@ -1,4 +1,2 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
-export const ValidationErrors = ({ errors }) => {
-    return errors.length === 0 ? null : (_jsx("div", { role: "alert", class: "validation-errors", children: _jsx("ul", { children: errors.map((error, i) => (_jsx("li", { children: error.message }, i))) }) }));
-};
+export const ValidationErrors = ({ disabled, errors }) => disabled || errors.length === 0 ? null : (_jsx("div", { role: "alert", class: "validation-errors", children: _jsx("ul", { children: errors.map((error, i) => (_jsx("li", { children: error.message }, i))) }) }));

package/dist/src/web/context/config.d.ts

@@ -0,0 +1,11 @@
+export type WebConfig = {
+    localeEntityName: string | undefined;
+    defaultLocales: string[];
+    homeLayoutSections?: {
+        title: string;
+        comment?: string;
+        entities: string[];
+    }[];
+};
+export declare const defaultWebConfig: WebConfig;
+export declare const ConfigContext: import("preact").Context<WebConfig>;

package/dist/src/web/context/config.js

@@ -0,0 +1,6 @@
+import { createContext } from "preact";
+export const defaultWebConfig = {
+    localeEntityName: undefined,
+    defaultLocales: [],
+};
+export const ConfigContext = createContext(defaultWebConfig);

package/dist/src/web/context/entities.d.ts

@@ -1,6 +1,9 @@
-import type { SerializedEntityDecl } from "../../node/schema/index.ts";
+import type { SerializedEntityDecl } from "../../shared/schema/declarations/EntityDecl.ts";
 export declare const EntitiesContext: import("preact").Context<{
-    declaration: SerializedEntityDecl;
-    instanceCount: number;
-    isLocaleEntity: boolean;
-}[]>;
+    entities: {
+        declaration: SerializedEntityDecl;
+        instanceCount: number;
+        isLocaleEntity: boolean;
+    }[];
+    reloadEntities: () => Promise<void>;
+}>;

package/dist/src/web/context/entities.js

@@ -1,2 +1,2 @@
 import { createContext } from "preact";
-export const EntitiesContext = createContext([]);
+export const EntitiesContext = createContext({ entities: [], reloadEntities: async () => { } });

package/dist/src/web/context/settings.d.ts

@@ -0,0 +1,8 @@
+import type { SetStateAction } from "preact/compat";
+import { type UserSettings } from "../hooks/useSettings.ts";
+export declare const defaultSettings: UserSettings;
+export type SettingsContext = {
+    settings: UserSettings;
+    setSetting: <K extends keyof UserSettings>(key: K, value: SetStateAction<UserSettings[K]>) => void;
+};
+export declare const SettingsContext: import("preact").Context<SettingsContext>;

package/dist/src/web/context/settings.js

@@ -0,0 +1,10 @@
+import { createContext } from "preact";
+import {} from "../hooks/useSettings.js";
+export const defaultSettings = {
+    displayedLocales: [],
+    enumDisplay: "select",
+};
+export const SettingsContext = createContext({
+    settings: defaultSettings,
+    setSetting: () => { },
+});

package/dist/src/web/hooks/useEntityFromRoute.d.ts

@@ -1,4 +1,4 @@
-import type { SerializedEntityDecl } from "../../node/schema/declarations/EntityDecl.ts";
+import type { SerializedEntityDecl } from "../../shared/schema/declarations/EntityDecl.ts";
 export declare const useEntityFromRoute: () => {
     declaration: SerializedEntityDecl;
     isLocaleEntity: boolean;

package/dist/src/web/hooks/useEntityFromRoute.js

@@ -3,7 +3,7 @@ import { useContext, useMemo } from "preact/hooks";
 import { EntitiesContext } from "../context/entities.js";
 export const useEntityFromRoute = () => {
     const { params: { name }, } = useRoute();
-    const entities = useContext(EntitiesContext);
-    const entityObj = useMemo(() => entities.find(e => e.declaration.name === name), [entities, name]);
+    const { entities } = useContext(EntitiesContext);
+    const entityObj = useMemo(() => entities.find(e => e.declaration.name === name && e.declaration.parentReferenceKey === undefined), [entities, name]);
     return entityObj;
 };

package/dist/src/web/hooks/useInstanceNamesByEntity.d.ts

@@ -1,3 +1,3 @@
 import type { GetAllInstancesResponseBody } from "../../shared/api.ts";
 export type InstanceNamesByEntity = GetAllInstancesResponseBody["instances"];
-export declare const useInstanceNamesByEntity: (locales?: string[]) => [InstanceNamesByEntity | undefined, () => void];
+export declare const useInstanceNamesByEntity: () => [InstanceNamesByEntity | undefined, () => void];

package/dist/src/web/hooks/useInstanceNamesByEntity.js

@@ -1,6 +1,8 @@
 import { useCallback, useEffect, useState } from "preact/hooks";
-import { getAllInstances } from "../api.js";
-export const useInstanceNamesByEntity = (locales = []) => {
+import { getAllInstances } from "../api/instances.js";
+import { useSetting } from "./useSettings.js";
+export const useInstanceNamesByEntity = () => {
+    const [locales] = useSetting("displayedLocales");
     const [instanceNamesByEntity, setInstanceNamesByEntity] = useState();
     const updateInstanceNamesByEntity = useCallback(() => {
         getAllInstances(locales)