tsondb 0.2.0 → 0.4.0

package/lib/web/api.js

@@ -0,0 +1,204 @@
+export const getAllDeclarations = async (kind) => {
+    const url = new URL("/api/declarations", window.location.origin);
+    if (kind) {
+        url.searchParams.append("kind", kind);
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getAllEntities = () => getAllDeclarations("Entity");
+export const getEntityByName = async (name) => {
+    const response = await fetch(`/api/declarations/${name}`);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getInstancesByEntityName = async (name) => {
+    const response = await fetch(`/api/declarations/${name}/instances`);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const createInstanceByEntityNameAndId = async (name, content, id) => {
+    const url = new URL(`/api/declarations/${name}/instances`, window.location.origin);
+    if (id) {
+        url.searchParams.append("id", id);
+    }
+    const response = await fetch(url, {
+        method: "POST",
+        body: JSON.stringify(content),
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getInstanceByEntityNameAndId = async (name, id) => {
+    const response = await fetch(`/api/declarations/${name}/instances/${id}`);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const updateInstanceByEntityNameAndId = async (name, id, content) => {
+    const response = await fetch(`/api/declarations/${name}/instances/${id}`, {
+        method: "PUT",
+        body: JSON.stringify(content),
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const deleteInstanceByEntityNameAndId = async (name, id) => {
+    const response = await fetch(`/api/declarations/${name}/instances/${id}`, {
+        method: "DELETE",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getAllInstances = async (locales) => {
+    const url = new URL("/api/instances", window.location.origin);
+    for (const locale of locales) {
+        url.searchParams.append("locales", locale);
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getGitStatus = async (locales) => {
+    const url = new URL("/api/git/status", window.location.origin);
+    for (const locale of locales) {
+        url.searchParams.append("locales", locale);
+    }
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const stageAllFiles = async () => {
+    const response = await fetch(`/api/git/stage`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+};
+export const stageAllFilesOfEntity = async (entityName) => {
+    const response = await fetch(`/api/git/stage/${entityName}`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+};
+export const stageFileOfEntity = async (entityName, id) => {
+    const response = await fetch(`/api/git/stage/${entityName}/${id}`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+};
+export const unstageAllFiles = async () => {
+    const response = await fetch(`/api/git/unstage`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+};
+export const unstageAllFilesOfEntity = async (entityName) => {
+    const response = await fetch(`/api/git/unstage/${entityName}`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+};
+export const unstageFileOfEntity = async (entityName, id) => {
+    const response = await fetch(`/api/git/unstage/${entityName}/${id}`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+};
+export const commitStagedFiles = async (message) => {
+    const body = { message };
+    const response = await fetch(`/api/git/commit`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const pushCommits = async () => {
+    const response = await fetch(`/api/git/push`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const pullCommits = async () => {
+    const response = await fetch(`/api/git/pull`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const getBranches = async () => {
+    const response = await fetch(`/api/git/branch`, {
+        method: "GET",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+    return response.json();
+};
+export const createBranch = async (branchName) => {
+    const body = { branchName };
+    const response = await fetch(`/api/git/branch`, {
+        method: "POST",
+        body: JSON.stringify(body),
+        headers: {
+            "Content-Type": "application/json",
+        },
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+};
+export const switchBranch = async (branchName) => {
+    const response = await fetch(`/api/git/branch/${branchName}`, {
+        method: "POST",
+    });
+    if (!response.ok) {
+        throw new Error(await response.text());
+    }
+};

package/lib/web/components/Git.d.ts

@@ -0,0 +1,2 @@
+import type { FunctionComponent } from "preact";
+export declare const Git: FunctionComponent;

package/lib/web/components/Git.js

@@ -0,0 +1,160 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { useEffect, useState } from "preact/hooks";
+import { getGitStatusForDisplay, getLabelForGitStatus, isChangedInIndex, isChangedInWorkingDir, } from "../../shared/utils/git.js";
+import { commitStagedFiles, createBranch, getAllEntities, getBranches, getGitStatus, pullCommits, pushCommits, stageAllFiles, stageFileOfEntity, switchBranch, unstageAllFiles, unstageFileOfEntity, } from "../api.js";
+const filterFilesForDisplay = (predicate, entities, data) => Object.entries(data.instances)
+    .map(([entityName, instances]) => [
+    entityName,
+    entities.find(entity => entity.name === entityName)?.namePlural ?? entityName,
+    instances
+        .filter(instance => instance.gitStatus !== undefined && predicate(instance.gitStatus))
+        .sort((a, b) => a.displayName.localeCompare(b.displayName)),
+])
+    .filter(([_1, _2, instances]) => instances.length > 0)
+    .sort((a, b) => a[1].localeCompare(b[1]));
+const GitFileList = ({ filesByEntity, onFile, isIndex = false }) => filesByEntity.length === 0 ? (_jsx("p", { class: "no-changes", children: "No changes" })) : (_jsx("ul", { class: "git-entity-list", children: filesByEntity.map(([entityName, entityNamePlural, instances]) => (_jsxs("li", { class: "git-entity-list-item", children: [_jsx("span", { class: "title", children: entityNamePlural }), _jsx("ul", { class: "git-instance-list", children: instances.map(instance => {
+                    const gitStatusForDisplay = getGitStatusForDisplay(instance.gitStatus);
+                    return (_jsxs("li", { class: "git-instance-list-item", children: [_jsx("span", { class: "title", children: instance.displayName }), _jsx("span", { class: `git-status git-status--${gitStatusForDisplay ?? ""}`, title: getLabelForGitStatus(gitStatusForDisplay), children: gitStatusForDisplay }), _jsx("button", { onClick: () => {
+                                    onFile(entityName, instance);
+                                }, children: isIndex ? "Unstage" : "Stage" })] }, instance.fileName));
+                }) })] }, entityName))) }));
+export const Git = () => {
+    const [isOpen, setIsOpen] = useState(false);
+    const [commitsAhead, setCommitsAhead] = useState(0);
+    const [commitsBehind, setCommitsBehind] = useState(0);
+    const [commitMessage, setCommitMessage] = useState("");
+    const [indexFiles, setIndexFiles] = useState([]);
+    const [workingTreeFiles, setWorkingTreeFiles] = useState([]);
+    const [entities, setEntities] = useState([]);
+    const [allBranches, setAllBranches] = useState([]);
+    const [currentBranch, setCurrentBranch] = useState("");
+    const updateGitStatus = (localEntities) => Promise.all([getGitStatus(["de-DE"]), getBranches()]).then(([statusData, branchesData]) => {
+        setIndexFiles(filterFilesForDisplay(isChangedInIndex, localEntities, statusData));
+        setWorkingTreeFiles(filterFilesForDisplay(isChangedInWorkingDir, localEntities, statusData));
+        setCommitsAhead(statusData.commitsAhead);
+        setCommitsBehind(statusData.commitsBehind);
+        setAllBranches(branchesData.allBranches);
+        setCurrentBranch(branchesData.currentBranch);
+    });
+    useEffect(() => {
+        getAllEntities()
+            .then(async (data) => {
+            const entitiesFromServer = data.declarations.map(decl => decl.declaration);
+            setEntities(entitiesFromServer);
+            return updateGitStatus(entitiesFromServer);
+        })
+            .catch((error) => {
+            if (error instanceof Error) {
+                console.error("Error fetching entities:", error.toString());
+            }
+        });
+    }, []);
+    const stage = (entityName, instance) => {
+        stageFileOfEntity(entityName, instance.id)
+            .then(() => updateGitStatus(entities))
+            .catch((error) => {
+            if (error instanceof Error) {
+                console.error("Error staging instance:", error.toString());
+            }
+        });
+    };
+    const stageAll = () => {
+        stageAllFiles()
+            .then(() => updateGitStatus(entities))
+            .catch((error) => {
+            if (error instanceof Error) {
+                console.error("Error staging all instances:", error.toString());
+            }
+        });
+    };
+    const unstage = (entityName, instance) => {
+        unstageFileOfEntity(entityName, instance.id)
+            .then(() => updateGitStatus(entities))
+            .catch((error) => {
+            if (error instanceof Error) {
+                console.error("Error unstaging instance:", error.toString());
+            }
+        });
+    };
+    const unstageAll = () => {
+        unstageAllFiles()
+            .then(() => updateGitStatus(entities))
+            .catch((error) => {
+            if (error instanceof Error) {
+                console.error("Error unstaging all instances:", error.toString());
+            }
+        });
+    };
+    const commit = () => {
+        if (commitMessage.length > 0 &&
+            indexFiles.length > 0 &&
+            confirm("Do you want to commit all staged files?")) {
+            commitStagedFiles(commitMessage)
+                .then(() => {
+                setCommitMessage("");
+                return updateGitStatus(entities);
+            })
+                .catch((error) => {
+                if (error instanceof Error) {
+                    console.error("Error committing instances:", error.toString());
+                }
+            });
+        }
+    };
+    const push = () => {
+        pushCommits()
+            .then(() => {
+            alert("Pushed commits successfully");
+            return updateGitStatus(entities);
+        })
+            .catch((error) => {
+            console.error("Error pushing commits:", error);
+        });
+    };
+    const pull = () => {
+        pullCommits()
+            .then(() => {
+            alert("Pulled commits successfully");
+            return updateGitStatus(entities);
+        })
+            .catch((error) => {
+            console.error("Error pulling commits:", error);
+        });
+    };
+    const onCreateBranch = () => {
+        const newBranchName = prompt("Enter new branch name:");
+        if (!newBranchName) {
+            alert("Branch name cannot be empty");
+            return;
+        }
+        if (allBranches.includes(newBranchName)) {
+            alert("Branch name already exists");
+            return;
+        }
+        createBranch(newBranchName)
+            .then(() => {
+            return updateGitStatus(entities);
+        })
+            .catch((error) => {
+            if (error instanceof Error) {
+                alert("Error switching branch:" + error.toString());
+            }
+        });
+    };
+    const onSwitchBranch = (event) => {
+        switchBranch(event.currentTarget.value)
+            .then(() => {
+            return updateGitStatus(entities);
+        })
+            .catch((error) => {
+            if (error instanceof Error) {
+                alert("Error switching branch: " + error.toString());
+            }
+        });
+    };
+    return (_jsxs("aside", { class: "git", children: [_jsx("h2", { class: "h1-faded", children: "Version Control" }), _jsx("button", { onClick: () => {
+                    setIsOpen(b => !b);
+                }, children: "File changes" }), _jsxs("div", { className: `git-overlay ${isOpen ? "git-overlay--open" : ""}`, children: [_jsxs("div", { class: "sync", children: [_jsxs("button", { onClick: push, children: ["Push", commitsAhead > 0 ? ` (${commitsAhead.toString()})` : ""] }), _jsxs("button", { onClick: pull, children: ["Pull", commitsBehind > 0 ? ` (${commitsBehind.toString()})` : ""] })] }), _jsxs("div", { className: "branch", children: [_jsx("div", { className: "select-wrapper", children: _jsx("select", { value: currentBranch, onInput: onSwitchBranch, children: allBranches.map(branch => (_jsx("option", { value: branch, children: branch }, branch))) }) }), _jsx("button", { onClick: onCreateBranch, children: "New branch" })] }), _jsxs("div", { class: "commit", children: [_jsx("input", { type: "text", value: commitMessage, onInput: event => {
+                                    setCommitMessage(event.currentTarget.value);
+                                }, placeholder: "added X to instance Y, \u2026" }), _jsx("button", { onClick: commit, disabled: commitMessage.length === 0 || indexFiles.length === 0, children: "Commit" })] }), _jsxs("div", { className: "git-section-title", children: [_jsx("h3", { children: "Files to be committed" }), _jsx("button", { onClick: unstageAll, children: "Unstage all" })] }), _jsx(GitFileList, { filesByEntity: indexFiles, isIndex: true, onFile: unstage }), _jsxs("div", { className: "git-section-title", children: [_jsx("h3", { children: "Working tree changes" }), _jsx("button", { onClick: stageAll, children: "Stage all" })] }), _jsx(GitFileList, { filesByEntity: workingTreeFiles, onFile: stage })] })] }));
+};

package/lib/{client → web}/components/Layout.d.ts

@@ -1,4 +1,4 @@
-import { ComponentChildren, FunctionComponent } from "preact";
+import type { ComponentChildren, FunctionComponent } from "preact";
 type Props = {
     breadcrumbs: {
         url: string;

package/lib/{client → web}/components/Layout.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "preact/jsx-runtime";
+import { Git } from "./Git.js";
 export const Layout = ({ breadcrumbs, children }) => {
-    return (_jsxs(_Fragment, { children: [_jsx("header", { children: _jsx("nav", { children: _jsx("ol", { children: breadcrumbs.map(({ url, label }) => (_jsx("li", { children: _jsx("a", { href: url, children: label }) }))) }) }) }), _jsx("main", { children: children })] }));
+    return (_jsxs(_Fragment, { children: [_jsx("header", { children: _jsx("nav", { children: _jsx("ol", { children: breadcrumbs.map(({ url, label }) => (_jsx("li", { children: _jsx("a", { href: url, children: label }) }, url))) }) }) }), _jsx(Git, {}), _jsx("main", { children: children })] }));
 };

package/lib/web/components/Select.d.ts

@@ -0,0 +1,3 @@
+import type { FunctionalComponent } from "preact";
+import type { SelectHTMLAttributes } from "preact/compat";
+export declare const Select: FunctionalComponent<SelectHTMLAttributes>;

package/lib/web/components/Select.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "preact/jsx-runtime";
+const isNullableString = (value) => {
+    return typeof value === "string" || value === undefined;
+};
+export const Select = props => (_jsx("div", { class: "select-wrapper", children: _jsx("select", { ...props, class: `${(isNullableString(props.class) ? props.class : props.class.value) ?? ""} ${(isNullableString(props.className) ? props.className : props.className.value) ?? ""} ${!props.value ? "no-selection" : ""}` }) }));

package/lib/web/components/typeInputs/ArrayTypeInput.d.ts

@@ -0,0 +1,13 @@
+import type { FunctionComponent } from "preact";
+import type { SerializedArrayType } from "../../../node/schema/types/generic/ArrayType.js";
+import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedArrayType;
+    value: unknown[];
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: unknown[]) => void;
+};
+export declare const ArrayTypeInput: FunctionComponent<Props>;
+export {};

package/lib/{client → web}/components/typeInputs/ArrayTypeInput.js

@@ -1,4 +1,5 @@
 import { jsxs as _jsxs, jsx as _jsx } from "preact/jsx-runtime";
+import { removeAt } from "../../../shared/utils/array.js";
 import { validateArrayConstraints } from "../../../shared/validation/array.js";
 import { createTypeSkeleton } from "../../utils/typeSkeleton.js";
 import { TypeInput } from "./TypeInput.js";
@@ -6,5 +7,11 @@ import { ValidationErrors } from "./utils/ValidationErrors.js";
 export const ArrayTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
     const errors = validateArrayConstraints(type, value);
     const isTuple = typeof type.minItems === "number" && type.minItems === type.maxItems;
-    return (_jsxs("div", { class: "field field--container field--array", children: [value.length > 0 && (_jsx("ol", { children: value.map((item, i) => (_jsxs("li", { class: "container-item array-item", children: [isTuple ? null : (_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [i + 1, "."] }), _jsx("button", { class: "destructive", onClick: () => onChange([...value.slice(0, i), ...value.slice(i + 1)]), disabled: type.minItems !== undefined && value.length <= type.minItems, children: "Delete Item" })] })), _jsx(TypeInput, { type: type.items, value: item, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => onChange([...value.slice(0, i), newItem, ...value.slice(i + 1)]) })] }, i))) })), isTuple ? null : (_jsx("div", { class: "add-item-container", children: _jsx("button", { onClick: () => onChange([...value, createTypeSkeleton(getDeclFromDeclName, type.items)]), disabled: type.maxItems !== undefined && value.length >= type.maxItems, children: "Add Item" }) })), _jsx(ValidationErrors, { errors: errors })] }));
+    return (_jsxs("div", { class: "field field--container field--array", children: [value.length > 0 && (_jsx("ol", { children: value.map((item, i) => (_jsxs("li", { class: "container-item array-item", children: [isTuple ? null : (_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [i + 1, "."] }), _jsx("button", { class: "destructive", onClick: () => {
+                                        onChange(removeAt(value, i));
+                                    }, disabled: type.minItems !== undefined && value.length <= type.minItems, children: "Delete Item" })] })), _jsx(TypeInput, { type: type.items, value: item, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => {
+                                onChange(value.with(i, newItem));
+                            } })] }, i))) })), isTuple ? null : (_jsx("div", { class: "add-item-container", children: _jsx("button", { onClick: () => {
+                        onChange([...value, createTypeSkeleton(getDeclFromDeclName, type.items)]);
+                    }, disabled: type.maxItems !== undefined && value.length >= type.maxItems, children: "Add Item" }) })), _jsx(ValidationErrors, { errors: errors })] }));
 };

package/lib/{client → web}/components/typeInputs/BooleanTypeInput.d.ts

@@ -1,5 +1,5 @@
-import { FunctionComponent } from "preact";
-import { SerializedBooleanType } from "../../../schema/types/primitives/BooleanType.js";
+import type { FunctionComponent } from "preact";
+import type { SerializedBooleanType } from "../../../node/schema/types/primitives/BooleanType.js";
 type Props = {
     type: SerializedBooleanType;
     value: boolean;

package/lib/{client → web}/components/typeInputs/DateTypeInput.d.ts

@@ -1,5 +1,5 @@
-import { FunctionComponent } from "preact";
-import { SerializedDateType } from "../../../schema/types/primitives/DateType.js";
+import type { FunctionComponent } from "preact";
+import type { SerializedDateType } from "../../../node/schema/types/primitives/DateType.js";
 type Props = {
     type: SerializedDateType;
     value: string;

package/lib/web/components/typeInputs/EnumTypeInput.d.ts

@@ -0,0 +1,13 @@
+import type { FunctionComponent } from "preact";
+import type { SerializedEnumType } from "../../../node/schema/types/generic/EnumType.js";
+import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedEnumType;
+    value: unknown;
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: unknown) => void;
+};
+export declare const EnumTypeInput: FunctionComponent<Props>;
+export {};

package/lib/{client/components/typeInputs/utils/EnumDeclField.js → web/components/typeInputs/EnumTypeInput.js}

@@ -1,11 +1,11 @@
 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 { createTypeSkeleton } from "../../../utils/typeSkeleton.js";
-import { Select } from "../../Select.js";
-import { TypeInput } from "../TypeInput.js";
-import { MismatchingTypeError } from "./MismatchingTypeError.js";
-export const EnumDeclField = ({ decl, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+import { discriminatorKey } from "../../../shared/enum.js";
+import { toTitleCase } from "../../../shared/utils/string.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, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
@@ -13,11 +13,11 @@ export const EnumDeclField = ({ decl, value, instanceNamesByEntity, getDeclFromD
         typeof value[discriminatorKey] !== "string") {
         return _jsx(MismatchingTypeError, { expected: "enumeration value", actual: value });
     }
-    const enumValues = Object.keys(decl.values);
+    const enumValues = Object.keys(type.values);
     const activeEnumCase = value[discriminatorKey];
-    const caseMember = decl.values[activeEnumCase];
+    const caseMember = type.values[activeEnumCase];
     return (_jsxs("div", { class: "field field--enum", children: [_jsx(Select, { value: activeEnumCase, onInput: event => {
-                    const caseMember = decl.values[event.currentTarget.value];
+                    const caseMember = type.values[event.currentTarget.value];
                     if (caseMember?.type == null) {
                         onChange({
                             [discriminatorKey]: event.currentTarget.value,
@@ -29,7 +29,7 @@ export const EnumDeclField = ({ decl, value, instanceNamesByEntity, getDeclFromD
                             [event.currentTarget.value]: createTypeSkeleton(getDeclFromDeclName, caseMember.type),
                         });
                     }
-                }, children: enumValues.map(enumValue => (_jsx("option", { value: enumValue, selected: enumValue === activeEnumCase, children: toTitleCase(enumValue) }))) }), caseMember?.type == null ? null : (_jsx("div", { className: "associated-type", children: _jsx(TypeInput, { type: caseMember.type, value: value[activeEnumCase], instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newValue => {
+                }, 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, value: value[activeEnumCase], instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newValue => {
                         onChange({
                             [discriminatorKey]: activeEnumCase,
                             [activeEnumCase]: newValue,

package/lib/{client → web}/components/typeInputs/FloatTypeInput.d.ts

@@ -1,5 +1,5 @@
-import { FunctionComponent } from "preact";
-import { SerializedFloatType } from "../../../schema/types/primitives/FloatType.js";
+import type { FunctionComponent } from "preact";
+import type { SerializedFloatType } from "../../../node/schema/types/primitives/FloatType.js";
 type Props = {
     type: SerializedFloatType;
     value: number;

package/lib/web/components/typeInputs/GenericTypeArgumentIdentifierTypeInput.d.ts

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

package/lib/{client → web}/components/typeInputs/GenericTypeArgumentIdentifierTypeInput.js

@@ -1,4 +1,4 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
-export const GenericArgumentIdentifierTypeInput = ({ type }) => {
+export const TypeArgumentTypeInput = ({ type }) => {
     return (_jsxs("div", { role: "alert", children: ["Unresolved type argument ", _jsx("code", { children: type.argument.name })] }));
 };

package/lib/web/components/typeInputs/IncludeIdentifierTypeInput.d.ts

@@ -0,0 +1,13 @@
+import type { FunctionComponent } from "preact";
+import type { SerializedIncludeIdentifierType } from "../../../node/schema/index.js";
+import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedIncludeIdentifierType;
+    value: unknown;
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: unknown) => void;
+};
+export declare const IncludeIdentifierTypeInput: FunctionComponent<Props>;
+export {};

package/lib/web/components/typeInputs/IncludeIdentifierTypeInput.js

@@ -0,0 +1,9 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { TypeInput } from "./TypeInput.js";
+export const IncludeIdentifierTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+    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, value: value, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: onChange }));
+};

package/lib/{client → web}/components/typeInputs/IntegerTypeInput.d.ts

@@ -1,5 +1,5 @@
-import { FunctionComponent } from "preact";
-import { SerializedIntegerType } from "../../../schema/types/primitives/IntegerType.js";
+import type { FunctionComponent } from "preact";
+import type { SerializedIntegerType } from "../../../node/schema/types/primitives/IntegerType.js";
 type Props = {
     type: SerializedIntegerType;
     value: number;

package/lib/web/components/typeInputs/NestedEntityMapTypeInput.d.ts

@@ -0,0 +1,13 @@
+import type { FunctionComponent } from "preact";
+import type { SerializedNestedEntityMapType } from "../../../node/schema/types/references/NestedEntityMapType.js";
+import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+type Props = {
+    type: SerializedNestedEntityMapType;
+    value: Record<string, unknown>;
+    instanceNamesByEntity: InstanceNamesByEntity;
+    getDeclFromDeclName: GetDeclFromDeclName;
+    onChange: (value: Record<string, unknown>) => void;
+};
+export declare const NestedEntityMapTypeInput: FunctionComponent<Props>;
+export {};

package/lib/{client → web}/components/typeInputs/NestedEntityMapTypeInput.js

@@ -11,11 +11,16 @@ export const NestedEntityMapTypeInput = ({ type, value, instanceNamesByEntity, g
         .slice()
         .filter(instance => !existingKeys.includes(instance.id))
         .sort((a, b) => a.name.localeCompare(b.name));
-    return (_jsxs("div", { class: "field field--container field--nestedentitymap", children: [existingKeys.length > 0 && (_jsx("ul", { children: Object.entries(value).map(([key, item]) => (_jsxs("li", { class: "container-item dict-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsx("div", { className: "container-item-title", children: _jsxs("span", { children: [_jsx("strong", { children: instanceNamesByEntity[type.secondaryEntity].find(instance => instance.id === key)?.name ?? key }), " ", _jsx("span", { className: "id", children: key })] }) }), _jsx("div", { className: "btns", children: _jsx("button", { class: "destructive", onClick: () => {
+    return (_jsxs("div", { class: "field field--container field--nestedentitymap", children: [existingKeys.length > 0 && (_jsx("ul", { children: Object.entries(value).map(([key, item]) => (_jsxs("li", { class: "container-item dict-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsx("div", { className: "container-item-title", children: _jsxs("span", { children: [_jsx("strong", { children: instanceNamesByEntity[type.secondaryEntity]?.find(instance => instance.id === key)?.name ?? key }), " ", _jsx("span", { className: "id", children: key })] }) }), _jsx("div", { className: "btns", children: _jsx("button", { class: "destructive", onClick: () => {
                                             const newObj = { ...value };
+                                            // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                                             delete newObj[key];
                                             onChange(newObj);
-                                        }, children: "Delete Key" }) })] }), _jsx(TypeInput, { type: type.type, value: item, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, 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 })))] }), _jsx("button", { onClick: () => {
+                                        }, children: "Delete Key" }) })] }), _jsx(TypeInput, { type: type.type, value: item, instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, 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)))] }), _jsx("button", { onClick: () => {
                             onChange(sortObjectKeysAlphabetically({
                                 ...value,
                                 [newKey]: createTypeSkeleton(getDeclFromDeclName, type.type),

package/lib/{client → web}/components/typeInputs/ObjectTypeInput.d.ts

@@ -1,7 +1,7 @@
-import { FunctionComponent } from "preact";
-import { SerializedObjectType } from "../../../schema/types/generic/ObjectType.js";
-import { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
-import { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
+import type { FunctionComponent } from "preact";
+import type { SerializedObjectType } from "../../../node/schema/types/generic/ObjectType.js";
+import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity.js";
+import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.js";
 type Props = {
     type: SerializedObjectType;
     value: Record<string, unknown>;

package/lib/{client → web}/components/typeInputs/ObjectTypeInput.js

@@ -14,7 +14,10 @@ export const ObjectTypeInput = ({ type, value, instanceNamesByEntity, getDeclFro
                                         }, Object.keys(type.properties)));
                                     }, children: "Add Property" })) : (_jsx("button", { class: "destructive", onClick: () => {
                                         const newObj = { ...value };
+                                        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
                                         delete newObj[key];
                                         onChange(newObj);
-                                    }, children: "Remove Property" }))] }), memberDecl.isRequired || value[key] !== undefined ? (_jsx(TypeInput, { type: memberDecl.type, value: value[key], instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => onChange(sortObjectKeys({ ...value, [key]: newItem }, Object.keys(type.properties))) })) : null] }, key))) }), _jsx(ValidationErrors, { errors: errors })] }));
+                                    }, children: "Remove Property" }))] }), memberDecl.isRequired || value[key] !== undefined ? (_jsx(TypeInput, { type: memberDecl.type, value: value[key], instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newItem => {
+                                onChange(sortObjectKeys({ ...value, [key]: newItem }, Object.keys(type.properties)));
+                            } })) : null] }, key))) }), _jsx(ValidationErrors, { errors: errors })] }));
 };