tsondb 0.12.0 → 0.12.1

package/dist/src/node/renderers/jsonschema/render.js

@@ -6,6 +6,7 @@ import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl,
 import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
 import { ArrayType } from "../../schema/types/generic/ArrayType.js";
+import { getTypeOfKey } from "../../schema/types/generic/TranslationObjectType.js";
 import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
@@ -104,6 +105,17 @@ const renderEnumType = (options, type) => ({
     })),
 });
 const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));
+const renderTranslationObjectType = (options, type) => ({
+    type: "object",
+    properties: Object.fromEntries(Object.entries(type.properties).map(([name, config]) => [
+        name,
+        {
+            ...renderType(options, getTypeOfKey(config, type)),
+        },
+    ])),
+    required: type.allKeysAreRequired ? Object.keys(type.properties) : undefined,
+    additionalProperties: false,
+});
 const renderType = (options, type) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -132,6 +144,8 @@ const renderType = (options, type) => {
             return renderEnumType(options, type);
         case NodeKind.ChildEntitiesType:
             return renderChildEntitiesType(options, type);
+        case NodeKind.TranslationObjectType:
+            return renderTranslationObjectType(options, type);
         default:
             return assertExhaustive(type, "Unknown type");
     }

package/dist/src/node/renderers/ts/render.js

@@ -10,6 +10,7 @@ import { TypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { flatMapAuxiliaryDecls, NodeKind } from "../../schema/Node.js";
 import { ArrayType } from "../../schema/types/generic/ArrayType.js";
 import { isObjectType } from "../../schema/types/generic/ObjectType.js";
+import { getTypeOfKey } from "../../schema/types/generic/TranslationObjectType.js";
 import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
@@ -61,6 +62,9 @@ const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.va
     ? ""
     : syntax `${EOL}${caseName}: ${renderType(options, caseDef.type)}`}`)}${EOL}}`)));
 const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));
+const renderTranslationObjectType = (options, type) => {
+    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}`), EOL));
+};
 const renderType = (options, type) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
@@ -89,6 +93,8 @@ const renderType = (options, type) => {
             return renderEnumType(options, type);
         case NodeKind.ChildEntitiesType:
             return renderChildEntitiesType(options, type);
+        case NodeKind.TranslationObjectType:
+            return renderTranslationObjectType(options, type);
         default:
             return assertExhaustive(type, "Unknown type");
     }

package/dist/src/node/schema/Node.d.ts

@@ -15,6 +15,7 @@ import type { SerializedNestedEntityMapType } from "../../shared/schema/types/Ne
 import type { SerializedMemberDecl, SerializedObjectType } from "../../shared/schema/types/ObjectType.ts";
 import type { SerializedReferenceIdentifierType } from "../../shared/schema/types/ReferenceIdentifierType.ts";
 import type { SerializedStringType } from "../../shared/schema/types/StringType.ts";
+import type { SerializedTranslationObjectType } from "../../shared/schema/types/TranslationObjectType.ts";
 import type { SerializedTypeArgumentType } from "../../shared/schema/types/TypeArgumentType.ts";
 import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
 import { type Decl, type IncludableDeclP } from "./declarations/Declaration.ts";
@@ -25,6 +26,7 @@ import { type TypeParameter } from "./TypeParameter.ts";
 import { type ArrayType } from "./types/generic/ArrayType.ts";
 import { type EnumCaseDecl, type EnumType } from "./types/generic/EnumType.ts";
 import { type MemberDecl, type ObjectType } from "./types/generic/ObjectType.ts";
+import { type TranslationObjectType } from "./types/generic/TranslationObjectType.ts";
 import { type BooleanType } from "./types/primitives/BooleanType.ts";
 import { type DateType } from "./types/primitives/DateType.ts";
 import { type FloatType } from "./types/primitives/FloatType.ts";
@@ -68,7 +70,7 @@ export type Validator<T extends Node = Node> = (helpers: Validators, inDecls: De
 export type ValidatorOfParamDecl<T extends Node = Node> = (helpers: Validators, inDecls: Decl[], node: T, typeArgs: Type[], value: unknown) => Error[];
 export declare const validateDecl: ValidatorOfParamDecl<Decl>;
 export declare const validateType: Validator<Type>;
-export type NodeWithResolvedTypeArguments<T extends Node | null> = T extends BooleanType | DateType | FloatType | IntegerType | StringType | ReferenceIdentifierType ? T : T extends EntityDecl<infer N, infer P, infer FK> ? EntityDecl<N, {
+export type NodeWithResolvedTypeArguments<T extends Node | null> = T extends BooleanType | DateType | FloatType | IntegerType | StringType | ReferenceIdentifierType | ChildEntitiesType | TranslationObjectType ? T : T extends EntityDecl<infer N, infer P, infer FK> ? EntityDecl<N, {
     [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
 }, FK> : T extends EnumDecl<infer N, infer V, TypeParameter[]> ? EnumDecl<N, {
     [K in keyof V]: V[K] extends EnumCaseDecl<infer CT> ? EnumCaseDecl<NodeWithResolvedTypeArguments<CT>> : never;
@@ -79,7 +81,7 @@ export type NodeWithResolvedTypeArguments<T extends Node | null> = T extends Boo
     [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
 }> : T extends TypeArgumentType ? Type : T extends IncludeIdentifierType<[], IncludableDeclP<[]>> ? T : T extends IncludeIdentifierType ? Type : T extends NestedEntityMapType<infer N, infer P> ? NestedEntityMapType<N, {
     [K in keyof P]: P[K] extends MemberDecl<infer PT, infer R> ? MemberDecl<NodeWithResolvedTypeArguments<PT>, R> : never;
-}> : T extends TypeParameter<infer N, infer C> ? TypeParameter<N, NodeWithResolvedTypeArguments<C>> : T extends ChildEntitiesType<infer E> ? ChildEntitiesType<E> : T extends null ? null : never;
+}> : T extends TypeParameter<infer N, infer C> ? TypeParameter<N, NodeWithResolvedTypeArguments<C>> : T extends null ? null : never;
 export type TypeArgumentsResolver<T extends Node = Node> = (args: Record<string, Type>, node: T, inDecl: Decl[]) => NodeWithResolvedTypeArguments<T>;
 export declare const resolveTypeArguments: <T extends Node = Node>(args: Record<string, Type>, node: T, inDecl: Decl[]) => NodeWithResolvedTypeArguments<T>;
 export type SerializedNodeMap = {
@@ -100,6 +102,7 @@ export type SerializedNodeMap = {
     [NodeKind.EnumType]: [EnumType, SerializedEnumType];
     [NodeKind.TypeParameter]: [TypeParameter, SerializedTypeParameter];
     [NodeKind.ChildEntitiesType]: [ChildEntitiesType, SerializedChildEntitiesType];
+    [NodeKind.TranslationObjectType]: [TranslationObjectType, SerializedTranslationObjectType];
 };
 export type SerializedTypeParameters<T extends TypeParameter[]> = {
     [K in keyof T]: T[K] extends TypeParameter<infer N, infer C> ? SerializedTypeParameter<N, C extends Type ? Serialized<C> : undefined> : never;
@@ -110,7 +113,7 @@ export type SerializedMemberDeclObject<T extends Record<string, MemberDecl>> = {
 export type SerializedEnumCaseDeclObject<T extends Record<string, EnumCaseDecl>> = {
     [K in keyof T]: T[K] extends EnumCaseDecl<infer CT> ? SerializedEnumCaseDecl<CT extends Type ? Serialized<CT> : null> : never;
 };
-export type Serialized<T extends Node> = T extends EntityDecl<infer Name, infer T, infer FK> ? SerializedEntityDecl<Name, SerializedMemberDeclObject<T>, FK> : T extends EnumDecl<infer Name, infer T, infer Params> ? SerializedEnumDecl<Name, SerializedEnumCaseDeclObject<T>, SerializedTypeParameters<Params>> : T extends TypeAliasDecl<infer Name, infer T, infer Params> ? SerializedTypeAliasDecl<Name, Serialized<T>, SerializedTypeParameters<Params>> : T extends ArrayType<infer T> ? SerializedArrayType<Serialized<T>> : T extends ObjectType<infer T> ? SerializedObjectType<SerializedMemberDeclObject<T>> : T extends BooleanType ? SerializedBooleanType : T extends DateType ? SerializedDateType : T extends FloatType ? SerializedFloatType : T extends IntegerType ? SerializedIntegerType : T extends StringType ? SerializedStringType : T extends TypeArgumentType<infer T> ? SerializedTypeArgumentType<Serialized<T>> : T extends ReferenceIdentifierType ? SerializedReferenceIdentifierType : T extends IncludeIdentifierType<infer Params> ? SerializedIncludeIdentifierType<SerializedTypeParameters<Params>> : T extends NestedEntityMapType<infer Name, infer T> ? SerializedNestedEntityMapType<Name, SerializedMemberDeclObject<T>> : T extends EnumType<infer T> ? SerializedEnumType<SerializedEnumCaseDeclObject<T>> : T extends TypeParameter<infer N, infer C> ? SerializedTypeParameter<N, C extends Type ? Serialized<C> : undefined> : T extends ChildEntitiesType ? SerializedChildEntitiesType : never;
+export type Serialized<T extends Node> = T extends EntityDecl<infer Name, infer T, infer FK> ? SerializedEntityDecl<Name, SerializedMemberDeclObject<T>, FK> : T extends EnumDecl<infer Name, infer T, infer Params> ? SerializedEnumDecl<Name, SerializedEnumCaseDeclObject<T>, SerializedTypeParameters<Params>> : T extends TypeAliasDecl<infer Name, infer T, infer Params> ? SerializedTypeAliasDecl<Name, Serialized<T>, SerializedTypeParameters<Params>> : T extends ArrayType<infer T> ? SerializedArrayType<Serialized<T>> : T extends ObjectType<infer T> ? SerializedObjectType<SerializedMemberDeclObject<T>> : T extends BooleanType ? SerializedBooleanType : T extends DateType ? SerializedDateType : T extends FloatType ? SerializedFloatType : T extends IntegerType ? SerializedIntegerType : T extends StringType ? SerializedStringType : T extends TypeArgumentType<infer T> ? SerializedTypeArgumentType<Serialized<T>> : T extends ReferenceIdentifierType ? SerializedReferenceIdentifierType : T extends IncludeIdentifierType<infer Params> ? SerializedIncludeIdentifierType<SerializedTypeParameters<Params>> : T extends NestedEntityMapType<infer Name, infer T> ? SerializedNestedEntityMapType<Name, SerializedMemberDeclObject<T>> : T extends EnumType<infer T> ? SerializedEnumType<SerializedEnumCaseDeclObject<T>> : T extends TypeParameter<infer N, infer C> ? SerializedTypeParameter<N, C extends Type ? Serialized<C> : undefined> : T extends ChildEntitiesType ? SerializedChildEntitiesType : T extends TranslationObjectType<infer E> ? SerializedTranslationObjectType<E> : never;
 export type SerializedOf<T extends Node> = SerializedNodeMap[T["kind"]][1];
 export type Serializer<T extends Node = Node> = (node: T) => Serialized<T>;
 export declare const serializeNode: <T extends Node>(node: T) => Serialized<T>;

package/dist/src/node/schema/Node.js

@@ -9,6 +9,7 @@ import { getNestedDeclarationsInTypeParameter, getReferencesForTypeParameter, re
 import { getNestedDeclarationsInArrayType, getReferencesForArrayType, resolveTypeArgumentsInArrayType, serializeArrayType, validateArrayType, } from "./types/generic/ArrayType.js";
 import { getNestedDeclarationsInEnumType, getReferencesForEnumType, resolveTypeArgumentsInEnumType, serializeEnumType, validateEnumType, } from "./types/generic/EnumType.js";
 import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "./types/generic/ObjectType.js";
+import { getNestedDeclarationsInTranslationObjectType, getReferencesForTranslationObjectType, resolveTypeArgumentsInTranslationObjectType, serializeTranslationObjectType, validateTranslationObjectType, } from "./types/generic/TranslationObjectType.js";
 import { getNestedDeclarationsInBooleanType, getReferencesForBooleanType, resolveTypeArgumentsInBooleanType, serializeBooleanType, validateBooleanType, } from "./types/primitives/BooleanType.js";
 import { getNestedDeclarationsInDateType, getReferencesForDateType, resolveTypeArgumentsInDateType, serializeDateType, validateDateType, } from "./types/primitives/DateType.js";
 import { getNestedDeclarationsInFloatType, getReferencesForFloatType, resolveTypeArgumentsInFloatType, serializeFloatType, validateFloatType, } from "./types/primitives/FloatType.js";
@@ -59,6 +60,7 @@ export const reduceNodes = (reducer, nodes, options = {}) => {
             case NodeKind.ReferenceIdentifierType:
             case NodeKind.NestedEntityMapType:
             case NodeKind.TypeParameter:
+            case NodeKind.TranslationObjectType:
                 return { results: reducer(parentNodes, node, collectedResults), reducedDecls };
             default:
                 return assertExhaustive(node);
@@ -143,6 +145,8 @@ export const getNestedDeclarations = (addedDecls, node, parentDecl) => {
             return getNestedDeclarationsInTypeParameter(addedDecls, node, parentDecl);
         case NodeKind.ChildEntitiesType:
             return getNestedDeclarationsInChildEntitiesType(addedDecls, node, parentDecl);
+        case NodeKind.TranslationObjectType:
+            return getNestedDeclarationsInTranslationObjectType(addedDecls, node, parentDecl);
         default:
             return assertExhaustive(node);
     }
@@ -187,6 +191,8 @@ export const validateType = (helpers, inDecls, type, value) => {
             return validateEnumType(helpers, inDecls, type, value);
         case NodeKind.ChildEntitiesType:
             return validateChildEntitiesType(helpers, inDecls, type, value);
+        case NodeKind.TranslationObjectType:
+            return validateTranslationObjectType(helpers, inDecls, type, value);
         default:
             return assertExhaustive(type);
     }
@@ -227,6 +233,8 @@ export const resolveTypeArguments = (args, node, inDecl) => {
             return resolveTypeArgumentsInTypeParameter(args, node, inDecl);
         case NodeKind.ChildEntitiesType:
             return resolveTypeArgumentsInChildEntitiesType(args, node, inDecl);
+        case NodeKind.TranslationObjectType:
+            return resolveTypeArgumentsInTranslationObjectType(args, node, inDecl);
         default:
             return assertExhaustive(node);
     }
@@ -267,6 +275,8 @@ export const serializeNode = (node) => {
             return serializeTypeParameter(node);
         case NodeKind.ChildEntitiesType:
             return serializeChildEntitiesType(node);
+        case NodeKind.TranslationObjectType:
+            return serializeTranslationObjectType(node);
         default:
             return assertExhaustive(node);
     }
@@ -307,6 +317,8 @@ export const getReferences = (node, value, inDecl) => {
             return getReferencesForTypeParameter(node, value, inDecl);
         case NodeKind.ChildEntitiesType:
             return getReferencesForChildEntitiesType(node, value, inDecl);
+        case NodeKind.TranslationObjectType:
+            return getReferencesForTranslationObjectType(node, value, inDecl);
         default:
             return assertExhaustive(node);
     }

package/dist/src/node/schema/Schema.js

@@ -172,6 +172,7 @@ const isDeclarationRecursive = (declToCheck) => {
             case NodeKind.ReferenceIdentifierType:
             case NodeKind.TypeParameter:
             case NodeKind.ChildEntitiesType:
+            case NodeKind.TranslationObjectType:
                 return false;
             case NodeKind.ArrayType:
                 return isDeclarationIncludedInNode(visitedDecls, node.items);

package/dist/src/node/schema/types/Type.d.ts

@@ -3,6 +3,7 @@ import type { BaseNode } from "../Node.ts";
 import type { ArrayType } from "./generic/ArrayType.ts";
 import type { EnumCaseDecl, EnumType } from "./generic/EnumType.ts";
 import type { MemberDecl, ObjectType } from "./generic/ObjectType.ts";
+import { type TranslationObjectType } from "./generic/TranslationObjectType.ts";
 import type { BooleanType } from "./primitives/BooleanType.ts";
 import type { DateType } from "./primitives/DateType.ts";
 import type { FloatType } from "./primitives/FloatType.ts";
@@ -15,7 +16,7 @@ import type { ReferenceIdentifierType } from "./references/ReferenceIdentifierTy
 import type { TypeArgumentType } from "./references/TypeArgumentType.ts";
 export interface BaseType extends BaseNode {
 }
-export type Type = BooleanType | DateType | FloatType | IntegerType | StringType | ArrayType | ObjectType | TypeArgumentType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType | EnumType | ChildEntitiesType;
+export type Type = BooleanType | DateType | FloatType | IntegerType | StringType | ArrayType | ObjectType | TypeArgumentType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType | EnumType | ChildEntitiesType | TranslationObjectType;
 export declare function walkTypeNodeTree(callbackFn: (type: Type, parentTypes: Type[], parentDecl: Decl) => void, type: Type, parentTypes: Type[], parentDecl: Decl): void;
 type EnumCaseTypeAsType<Case extends string, T extends Type | null> = T extends object ? {
     kind: Case;

package/dist/src/node/schema/types/Type.js

@@ -4,6 +4,7 @@ import { NodeKind } from "../Node.js";
 import { formatArrayValue, isArrayType } from "./generic/ArrayType.js";
 import { formatEnumType } from "./generic/EnumType.js";
 import { formatObjectValue, isObjectType } from "./generic/ObjectType.js";
+import { formatTranslationObjectValue, } from "./generic/TranslationObjectType.js";
 import { formatBooleanValue } from "./primitives/BooleanType.js";
 import { formatDateValue } from "./primitives/DateType.js";
 import { formatFloatValue } from "./primitives/FloatType.js";
@@ -40,7 +41,8 @@ export function walkTypeNodeTree(callbackFn, type, parentTypes, parentDecl) {
         case NodeKind.StringType:
         case NodeKind.TypeArgumentType:
         case NodeKind.ReferenceIdentifierType:
-        case NodeKind.ChildEntitiesType: {
+        case NodeKind.ChildEntitiesType:
+        case NodeKind.TranslationObjectType: {
             callbackFn(type, parentTypes, parentDecl);
             return;
         }
@@ -113,6 +115,8 @@ export const formatValue = (type, value) => {
             return formatEnumType(type, value);
         case NodeKind.ChildEntitiesType:
             return formatChildEntitiesValue(type, value);
+        case NodeKind.TranslationObjectType:
+            return formatTranslationObjectValue(type, value);
         default:
             return assertExhaustive(type);
     }

package/dist/src/node/schema/types/generic/TranslationObjectType.d.ts

@@ -0,0 +1,25 @@
+import type { GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../../Node.ts";
+import { NodeKind } from "../../Node.ts";
+import type { StringType } from "../primitives/StringType.ts";
+import type { BaseType, StructureFormatter } from "../Type.ts";
+type TConstraint = {
+    [key: string]: null | TConstraint;
+};
+export type { TConstraint as TranslationObjectTypeConstraint };
+export interface TranslationObjectType<T extends TConstraint = TConstraint> extends BaseType {
+    kind: NodeKind["TranslationObjectType"];
+    properties: T;
+    allKeysAreRequired: boolean;
+}
+export declare const TranslationObjectType: <T extends TConstraint>(properties: T, options?: {
+    allKeysAreRequired?: boolean;
+}) => TranslationObjectType<T>;
+export { TranslationObjectType as TranslationObject };
+export declare const isTranslationObjectType: Predicate<TranslationObjectType>;
+export declare const getNestedDeclarationsInTranslationObjectType: GetNestedDeclarations<TranslationObjectType>;
+export declare const validateTranslationObjectType: Validator<TranslationObjectType>;
+export declare const resolveTypeArgumentsInTranslationObjectType: TypeArgumentsResolver<TranslationObjectType>;
+export declare const serializeTranslationObjectType: <P extends TConstraint>(type: TranslationObjectType<P>) => Serialized<TranslationObjectType<P>>;
+export declare const getReferencesForTranslationObjectType: GetReferences<TranslationObjectType>;
+export declare const formatTranslationObjectValue: StructureFormatter<TranslationObjectType>;
+export declare const getTypeOfKey: <T extends TConstraint>(keyValue: null | T, parentType?: TranslationObjectType) => StringType | TranslationObjectType<T>;

package/dist/src/node/schema/types/generic/TranslationObjectType.js

@@ -0,0 +1,66 @@
+import { sortObjectKeys } from "../../../../shared/utils/object.js";
+import { parallelizeErrors } from "../../../../shared/utils/validation.js";
+import { validateUnknownKeys } from "../../../../shared/validation/object.js";
+import { wrapErrorsIfAny } from "../../../utils/error.js";
+import { json, key as keyColor } from "../../../utils/errorFormatting.js";
+import { NodeKind } from "../../Node.js";
+export const TranslationObjectType = (properties, options = {}) => {
+    const type = {
+        allKeysAreRequired: false,
+        ...options,
+        kind: NodeKind.TranslationObjectType,
+        properties,
+    };
+    return type;
+};
+export { TranslationObjectType as TranslationObject };
+export const isTranslationObjectType = node => node.kind === NodeKind.TranslationObjectType;
+export const getNestedDeclarationsInTranslationObjectType = addedDecls => addedDecls;
+const validateRecursively = (helpers, allKeysAreRequired, type, value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
+    }
+    const expectedKeys = Object.keys(type).filter(key => type[key] !== undefined);
+    return parallelizeErrors([
+        ...validateUnknownKeys(expectedKeys, Object.keys(value)),
+        ...expectedKeys.map(key => {
+            const propType = type[key];
+            const propValue = value[key];
+            if (allKeysAreRequired && propValue === undefined) {
+                return TypeError(`missing required translation ${keyColor(`"${key}"`, helpers.useStyling)}`);
+            }
+            if (propType === null && propValue !== undefined && typeof propValue !== "string") {
+                return TypeError(`expected a string at translation key ${keyColor(`"${key}"`, helpers.useStyling)}, but got ${json(propValue, helpers.useStyling)}`);
+            }
+            if (propType === null &&
+                typeof propValue === "string" &&
+                allKeysAreRequired &&
+                propValue.length === 0) {
+                return TypeError(`expected a non-empty string at translation key ${keyColor(`"${key}"`, helpers.useStyling)}`);
+            }
+            if (propType !== null && propValue !== undefined) {
+                return wrapErrorsIfAny(`at translation object key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateRecursively(helpers, allKeysAreRequired, propType, propValue));
+            }
+            return undefined;
+        }),
+    ]);
+};
+export const validateTranslationObjectType = (helpers, _inDecls, type, value) => validateRecursively(helpers, type.allKeysAreRequired, type.properties, value);
+export const resolveTypeArgumentsInTranslationObjectType = (_args, type, _inDecl) => type;
+export const serializeTranslationObjectType = (type) => type;
+export const getReferencesForTranslationObjectType = () => [];
+const formatRecursively = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
+    ? sortObjectKeys(Object.fromEntries(Object.entries(value).map(([key, item]) => [
+        key,
+        type[key] ? formatRecursively(type[key], item) : item,
+    ])), Object.keys(type))
+    : value;
+export const formatTranslationObjectValue = (type, value) => formatRecursively(type.properties, value);
+export const getTypeOfKey = (keyValue, parentType) => keyValue === null
+    ? { kind: "StringType" }
+    : {
+        kind: "TranslationObjectType",
+        allKeysAreRequired: false,
+        ...parentType,
+        properties: keyValue,
+    };

package/dist/src/node/utils/errorFormatting.js

@@ -1,6 +1,6 @@
 import { styleText } from "node:util";
 export const json = (value, useStyling) => useStyling
-    ? styleText("blue", JSON.stringify(value, undefined, 2))
+    ? styleText("blue", value === undefined ? "undefined" : JSON.stringify(value, undefined, 2))
     : JSON.stringify(value, undefined, 2);
 export const key = (str, useStyling) => useStyling ? styleText(["yellow", "bold"], str) : str;
 export const entity = (str, useStyling) => useStyling ? styleText("green", str) : str;

package/dist/src/shared/schema/Node.d.ts

@@ -15,6 +15,7 @@ import { type SerializedNestedEntityMapType } from "./types/NestedEntityMapType.
 import { type SerializedMemberDecl, type SerializedObjectType } from "./types/ObjectType.ts";
 import { type SerializedReferenceIdentifierType } from "./types/ReferenceIdentifierType.ts";
 import { type SerializedStringType } from "./types/StringType.ts";
+import { type SerializedTranslationObjectType } from "./types/TranslationObjectType.ts";
 import type { SerializedType } from "./types/Type.ts";
 import { type SerializedTypeArgumentType } from "./types/TypeArgumentType.ts";
 export interface NodeKind {
@@ -38,13 +39,14 @@ export interface NodeKind {
     NestedEntityMapType: "NestedEntityMapType";
     EnumType: "EnumType";
     ChildEntitiesType: "ChildEntitiesType";
+    TranslationObjectType: "TranslationObjectType";
 }
 export declare const NodeKind: NodeKind;
 export interface BaseNode {
     kind: (typeof NodeKind)[keyof typeof NodeKind];
 }
 export type SerializedNode = SerializedDecl | SerializedType | SerializedTypeParameter;
-export type SerializedNodeWithResolvedTypeArguments<T extends SerializedNode | null> = T extends SerializedBooleanType | SerializedDateType | SerializedFloatType | SerializedIntegerType | SerializedStringType | SerializedReferenceIdentifierType ? T : T extends SerializedEntityDecl<infer N, infer P, infer FK> ? SerializedEntityDecl<N, {
+export type SerializedNodeWithResolvedTypeArguments<T extends SerializedNode | null> = T extends SerializedBooleanType | SerializedDateType | SerializedFloatType | SerializedIntegerType | SerializedStringType | SerializedReferenceIdentifierType | SerializedChildEntitiesType | SerializedTranslationObjectType ? T : T extends SerializedEntityDecl<infer N, infer P, infer FK> ? SerializedEntityDecl<N, {
     [K in keyof P]: P[K] extends SerializedMemberDecl<infer PT, infer R> ? SerializedMemberDecl<SerializedNodeWithResolvedTypeArguments<PT>, R> : never;
 }, FK> : T extends SerializedEnumDecl<infer N, infer V, SerializedTypeParameter[]> ? SerializedEnumDecl<N, {
     [K in keyof V]: V[K] extends SerializedEnumCaseDecl<infer CT> ? SerializedEnumCaseDecl<SerializedNodeWithResolvedTypeArguments<CT>> : never;
@@ -55,7 +57,7 @@ export type SerializedNodeWithResolvedTypeArguments<T extends SerializedNode | n
     [K in keyof P]: P[K] extends SerializedMemberDecl<infer PT, infer R> ? SerializedMemberDecl<SerializedNodeWithResolvedTypeArguments<PT>, R> : never;
 }> : T extends SerializedTypeArgumentType ? SerializedType : T extends SerializedIncludeIdentifierType<[]> ? T : T extends SerializedIncludeIdentifierType ? SerializedType : T extends SerializedNestedEntityMapType<infer N, infer P> ? SerializedNestedEntityMapType<N, {
     [K in keyof P]: P[K] extends SerializedMemberDecl<infer PT, infer R> ? SerializedMemberDecl<SerializedNodeWithResolvedTypeArguments<PT>, R> : never;
-}> : T extends SerializedTypeParameter<infer N, infer C> ? SerializedTypeParameter<N, SerializedNodeWithResolvedTypeArguments<C>> : T extends SerializedChildEntitiesType ? SerializedChildEntitiesType : T extends null ? null : never;
+}> : T extends SerializedTypeParameter<infer N, infer C> ? SerializedTypeParameter<N, SerializedNodeWithResolvedTypeArguments<C>> : T extends null ? null : never;
 export type SerializedTypeArgumentsResolver<T extends SerializedNode = SerializedNode> = (decls: Record<string, SerializedDecl>, args: Record<string, SerializedType>, node: T) => SerializedNodeWithResolvedTypeArguments<T>;
 export declare const resolveSerializedTypeArguments: <T extends SerializedNode = SerializedNode>(decls: Record<string, SerializedDecl>, args: Record<string, SerializedType>, node: T) => SerializedNodeWithResolvedTypeArguments<T>;
 export type GetReferencesSerialized<T extends SerializedNode = SerializedNode> = (decls: Record<string, SerializedDecl>, node: T, value: unknown) => string[];

package/dist/src/shared/schema/Node.js

@@ -16,6 +16,7 @@ import { getReferencesForSerializedNestedEntityMapType, resolveTypeArgumentsInSe
 import { getReferencesForSerializedObjectType, resolveTypeArgumentsInSerializedObjectType, } from "./types/ObjectType.js";
 import { getReferencesForSerializedReferenceIdentifierType, resolveTypeArgumentsInSerializedReferenceIdentifierType, } from "./types/ReferenceIdentifierType.js";
 import { getReferencesForSerializedStringType, resolveTypeArgumentsInSerializedStringType, } from "./types/StringType.js";
+import { getReferencesForSerializedTranslationObjectType, resolveTypeArgumentsInSerializedTranslationObjectType, } from "./types/TranslationObjectType.js";
 import { getReferencesForSerializedTypeArgumentType, resolveTypeArgumentsInSerializedTypeArgumentType, } from "./types/TypeArgumentType.js";
 export const NodeKind = enumOfObject({
     ChildEntityDecl: null,
@@ -38,6 +39,7 @@ export const NodeKind = enumOfObject({
     NestedEntityMapType: null,
     EnumType: null,
     ChildEntitiesType: null,
+    TranslationObjectType: null,
 });
 export const resolveSerializedTypeArguments = (decls, args, node) => {
     switch (node.kind) {
@@ -75,6 +77,8 @@ export const resolveSerializedTypeArguments = (decls, args, node) => {
             return resolveTypeArgumentsInSerializedTypeParameter(decls, args, node);
         case NodeKind.ChildEntitiesType:
             return resolveTypeArgumentsInSerializedChildEntitiesType(decls, args, node);
+        case NodeKind.TranslationObjectType:
+            return resolveTypeArgumentsInSerializedTranslationObjectType(decls, args, node);
         default:
             return assertExhaustive(node);
     }
@@ -115,6 +119,8 @@ export const getReferencesSerialized = (decls, node, value) => {
             return getReferencesForSerializedTypeParameter(decls, node, value);
         case NodeKind.ChildEntitiesType:
             return getReferencesForSerializedChildEntitiesType(decls, node, value);
+        case NodeKind.TranslationObjectType:
+            return getReferencesForSerializedTranslationObjectType(decls, node, value);
         default:
             return assertExhaustive(node);
     }

package/dist/src/shared/schema/types/TranslationObjectType.d.ts

@@ -0,0 +1,16 @@
+import { NodeKind, type GetReferencesSerialized, type SerializedNode, type SerializedTypeArgumentsResolver } from "../Node.js";
+import type { SerializedStringType } from "./StringType.ts";
+import type { SerializedBaseType } from "./Type.ts";
+type TSerializedConstraint = {
+    [key: string]: null | TSerializedConstraint;
+};
+export interface SerializedTranslationObjectType<T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
+    kind: NodeKind["TranslationObjectType"];
+    properties: T;
+    allKeysAreRequired: boolean;
+}
+export declare const isSerializedTranslationObjectType: (node: SerializedNode) => node is SerializedTranslationObjectType;
+export declare const resolveTypeArgumentsInSerializedTranslationObjectType: SerializedTypeArgumentsResolver<SerializedTranslationObjectType>;
+export declare const getReferencesForSerializedTranslationObjectType: GetReferencesSerialized<SerializedTranslationObjectType>;
+export declare const getSerializedTypeOfKey: <T extends TSerializedConstraint>(keyValue: null | T, parentType?: SerializedTranslationObjectType) => SerializedStringType | SerializedTranslationObjectType<T>;
+export {};

package/dist/src/shared/schema/types/TranslationObjectType.js

@@ -0,0 +1,12 @@
+import { NodeKind, } from "../Node.js";
+export const isSerializedTranslationObjectType = (node) => node.kind === NodeKind.TranslationObjectType;
+export const resolveTypeArgumentsInSerializedTranslationObjectType = (_decls, _args, type) => type;
+export const getReferencesForSerializedTranslationObjectType = () => [];
+export const getSerializedTypeOfKey = (keyValue, parentType) => keyValue === null
+    ? { kind: "StringType" }
+    : {
+        kind: "TranslationObjectType",
+        allKeysAreRequired: false,
+        ...parentType,
+        properties: keyValue,
+    };

package/dist/src/shared/schema/types/Type.d.ts

@@ -11,10 +11,11 @@ import type { SerializedNestedEntityMapType } from "./NestedEntityMapType.ts";
 import type { SerializedMemberDecl, SerializedObjectType } from "./ObjectType.ts";
 import type { SerializedReferenceIdentifierType } from "./ReferenceIdentifierType.ts";
 import type { SerializedStringType } from "./StringType.ts";
+import type { SerializedTranslationObjectType } from "./TranslationObjectType.ts";
 import type { SerializedTypeArgumentType } from "./TypeArgumentType.ts";
 export interface SerializedBaseType extends BaseNode {
 }
-export type SerializedType = SerializedBooleanType | SerializedDateType | SerializedFloatType | SerializedIntegerType | SerializedStringType | SerializedArrayType | SerializedObjectType | SerializedTypeArgumentType | SerializedReferenceIdentifierType | SerializedIncludeIdentifierType | SerializedNestedEntityMapType | SerializedEnumType | SerializedChildEntitiesType;
+export type SerializedType = SerializedBooleanType | SerializedDateType | SerializedFloatType | SerializedIntegerType | SerializedStringType | SerializedArrayType | SerializedObjectType | SerializedTypeArgumentType | SerializedReferenceIdentifierType | SerializedIncludeIdentifierType | SerializedNestedEntityMapType | SerializedEnumType | SerializedChildEntitiesType | SerializedTranslationObjectType;
 export type SerializedAsType<T extends SerializedType> = T extends SerializedArrayType<infer I> ? SerializedAsType<I>[] : T extends SerializedObjectType<infer P> ? {
     [K in keyof P]: P[K] extends SerializedMemberDecl<SerializedType, true> ? SerializedAsType<P[K]["type"]> : SerializedAsType<P[K]["type"]> | undefined;
-} : T extends SerializedBooleanType ? boolean : T extends SerializedDateType ? Date : T extends SerializedFloatType ? number : T extends SerializedIntegerType ? number : T extends SerializedStringType ? string : T extends SerializedTypeArgumentType ? unknown : T extends SerializedIncludeIdentifierType ? unknown : T extends SerializedNestedEntityMapType ? unknown : T extends SerializedReferenceIdentifierType ? unknown : T extends SerializedChildEntitiesType ? unknown : never;
+} : T extends SerializedBooleanType ? boolean : T extends SerializedDateType ? Date : T extends SerializedFloatType ? number : T extends SerializedIntegerType ? number : T extends SerializedStringType ? string : T extends SerializedTypeArgumentType ? unknown : T extends SerializedIncludeIdentifierType ? unknown : T extends SerializedNestedEntityMapType ? unknown : T extends SerializedReferenceIdentifierType ? unknown : T extends SerializedChildEntitiesType ? unknown : T extends SerializedTranslationObjectType ? unknown : never;

package/dist/src/shared/validation/object.d.ts

@@ -4,3 +4,4 @@ export interface ObjectConstraints {
     maxProperties?: number;
 }
 export declare const validateObjectConstraints: (constraints: ObjectConstraints, expectedKeys: string[], value: object) => Error[];
+export declare const validateUnknownKeys: (expectedKeys: string[], actualKeys: string[]) => TypeError[];

package/dist/src/shared/validation/object.js

@@ -6,9 +6,10 @@ export const validateObjectConstraints = (constraints, expectedKeys, value) => {
         validateLengthRangeBound("lower", label, constraints.minProperties, actualKeys),
         validateLengthRangeBound("upper", label, constraints.maxProperties, actualKeys),
         ...(constraints.additionalProperties !== true
-            ? actualKeys.flatMap(valueKey => expectedKeys.includes(valueKey)
-                ? []
-                : [TypeError(`object does not allow unknown keys and key "${valueKey}" is not known`)])
+            ? validateUnknownKeys(expectedKeys, actualKeys)
             : []),
     ]);
 };
+export const validateUnknownKeys = (expectedKeys, actualKeys) => actualKeys.flatMap(valueKey => expectedKeys.includes(valueKey)
+    ? []
+    : [TypeError(`object does not allow unknown keys and key "${valueKey}" is not known`)]);

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

@@ -4,13 +4,15 @@ 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, disabled, onChange }) => {
+export const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject, }) => {
     if (typeof value !== "string") {
         return _jsx(MismatchingTypeError, { expected: "string", actual: value });
     }
     const { minLength, maxLength, pattern, isMarkdown } = type;
     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 => {
+    return (_jsx("div", { class: "field field--string", children: inTranslationObject ? (_jsx(_Fragment, { children: _jsxs("div", { class: "editor editor--translation", children: [_jsxs("div", { class: "textarea-grow-wrap", children: [_jsx("textarea", { rows: 1, value: value, minLength: minLength, maxLength: maxLength, onInput: event => {
+                                    onChange(event.currentTarget.value);
+                                }, "aria-invalid": errors.length > 0, disabled: disabled }), _jsx("div", { class: "textarea-grow-wrap__mirror", children: value + " " })] }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }) })) : isMarkdown ? (_jsxs(_Fragment, { children: [_jsxs("div", { class: "editor editor--markdown", children: [_jsxs("div", { class: "textarea-grow-wrap", children: [_jsx("textarea", { rows: 1, value: value, minLength: minLength, maxLength: maxLength, onInput: event => {
                                         onChange(event.currentTarget.value);
                                     }, "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, outerHeadingLevel: 2 }) })] })) : (_jsxs("div", { class: "editor", children: [_jsx("input", { type: "text", value: value, minLength: minLength, maxLength: maxLength, pattern: pattern === undefined
                         ? undefined

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

@@ -0,0 +1,6 @@
+import type { FunctionComponent } from "preact";
+import { type SerializedTranslationObjectType } from "../../../shared/schema/types/TranslationObjectType.ts";
+import { type TypeInputProps } from "./TypeInput.tsx";
+type Props = TypeInputProps<SerializedTranslationObjectType, Record<string, unknown>>;
+export declare const TranslationObjectTypeInput: FunctionComponent<Props>;
+export {};

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

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { getSerializedTypeOfKey, } from "../../../shared/schema/types/TranslationObjectType.js";
+import { sortObjectKeys } from "../../../shared/utils/object.js";
+import { validateUnknownKeys } from "../../../shared/validation/object.js";
+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 TranslationObjectTypeInput = 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 = validateUnknownKeys(Object.keys(type.properties), Object.keys(value));
+    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]) => {
+                    const keyType = getSerializedTypeOfKey(memberDecl, type);
+                    return (_jsxs("li", { class: "container-item object-item object-item--translation" +
+                            (memberDecl === null ? "" : "object-item--translation-object"), children: [_jsx("div", { className: "container-item-title", children: key }), type.allKeysAreRequired ||
+                                value[key] !== undefined ? (_jsx(TypeInput, { ...props, inTranslationObject: true, parentKey: undefined, type: keyType, path: path === undefined ? key : `${path}.${key}`, value: value[key] ??
+                                    (type.allKeysAreRequired
+                                        ? createTypeSkeleton(getDeclFromDeclName, keyType)
+                                        : undefined), onChange: newItem => {
+                                    onChange(sortObjectKeys({ ...value, [key]: newItem }, Object.keys(type.properties)));
+                                } })) : null, type.allKeysAreRequired ? null : value[key] ===
+                                undefined ? (_jsx("button", { onClick: () => {
+                                    onChange(sortObjectKeys({
+                                        ...value,
+                                        [key]: createTypeSkeleton(getDeclFromDeclName, keyType),
+                                    }, Object.keys(type.properties)));
+                                }, disabled: disabled, children: "Add" })) : (_jsx("button", { class: "destructive", onClick: () => {
+                                    const newObj = { ...value };
+                                    // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+                                    delete newObj[key];
+                                    onChange(newObj);
+                                }, disabled: disabled, children: "Remove" }))] }, key));
+                }) }), _jsx(ValidationErrors, { disabled: disabled, errors: errors })] }));
+};

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

@@ -11,6 +11,7 @@ export type TypeInputProps<T, V = unknown> = {
     parentKey?: string;
     childInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[];
     disabled?: boolean;
+    inTranslationObject?: boolean;
     getDeclFromDeclName: GetDeclFromDeclName;
     onChange: (value: V) => void;
     setChildInstances: (newInstances: (oldInstances: UnsafeEntityTaggedInstanceContainerWithChildInstances[]) => UnsafeEntityTaggedInstanceContainerWithChildInstances[]) => void;

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

@@ -14,6 +14,7 @@ import { NestedEntityMapTypeInput } from "./NestedEntityMapTypeInput.js";
 import { ObjectTypeInput } from "./ObjectTypeInput.js";
 import { ReferenceIdentifierTypeInput } from "./ReferenceIdentifierTypeInput.js";
 import { StringTypeInput } from "./StringTypeInput.js";
+import { TranslationObjectTypeInput } from "./TranslationObjectTypeInput.js";
 const TypeInput = props => {
     // console.log("rendering node at path ", props.path ?? "<root>")
     switch (props.type.kind) {
@@ -43,6 +44,8 @@ const TypeInput = props => {
             return _jsx(EnumTypeInput, { ...props, type: props.type });
         case "ChildEntitiesType":
             return _jsx(ChildEntitiesTypeInput, { ...props, type: props.type });
+        case "TranslationObjectType":
+            return _jsx(TranslationObjectTypeInput, { ...props, type: props.type });
         default:
             return assertExhaustive(props.type);
     }

package/dist/src/web/utils/typeSkeleton.js

@@ -44,6 +44,13 @@ export const createTypeSkeleton = (getDeclFromDeclName, type) => {
         }
         case "ChildEntitiesType":
             return undefined;
+        case "TranslationObjectType": {
+            const createObject = (type) => Object.fromEntries(Object.entries(type).map(([key, propType]) => [
+                key,
+                propType === null ? "" : createObject(propType),
+            ]));
+            return createObject(type.properties);
+        }
         default:
             return assertExhaustive(type);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.12.0",
+  "version": "0.12.1",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -32,28 +32,28 @@
     "release:sign": "commit-and-tag-version --sign --signoff"
   },
   "devDependencies": {
-    "@eslint/js": "^9.37.0",
+    "@eslint/js": "^9.39.1",
     "@types/debug": "^4.1.12",
-    "@types/express": "^5.0.3",
-    "@types/node": "^24.8.1",
+    "@types/express": "^5.0.5",
+    "@types/node": "^24.10.1",
     "commit-and-tag-version": "^12.6.0",
-    "eslint": "^9.37.0",
+    "eslint": "^9.39.1",
     "eslint-plugin-react": "^7.37.5",
-    "eslint-plugin-react-hooks": "^7.0.0",
-    "globals": "^16.4.0",
+    "eslint-plugin-react-hooks": "^7.0.1",
+    "globals": "^16.5.0",
     "prettier": "^3.6.2",
     "tsx": "^4.20.6",
     "typescript": "^5.9.3",
-    "typescript-eslint": "^8.46.1"
+    "typescript-eslint": "^8.46.4"
   },
   "dependencies": {
-    "@preact/signals": "^2.3.2",
+    "@preact/signals": "^2.5.0",
     "debug": "^4.4.3",
     "express": "^5.1.0",
     "preact": "^10.27.2",
     "preact-iso": "^2.11.0",
     "simple-cli-args": "^0.1.3",
-    "simple-git": "^3.28.0"
+    "simple-git": "^3.30.0"
   },
   "repository": "github:elyukai/tsondb",
   "bugs": {

package/public/css/styles.css

@@ -704,9 +704,9 @@ form > .field--container {
   flex: 1 1 0;
 }
 
-.editor--markdown textarea,
-.editor--markdown input,
-.editor--markdown .textarea-grow-wrap__mirror {
+:is(.editor--markdown, .editor--translation) textarea,
+:is(.editor--markdown, .editor--translation) input,
+:is(.editor--markdown, .editor--translation) .textarea-grow-wrap__mirror {
   font-family: var(--font-mono);
   line-height: 1.5;
 }
@@ -1180,3 +1180,28 @@ dialog[open] > .loading-overlay--open {
 dialog[open]:has(> .loading-overlay--open)::backdrop {
   background: rgba(0, 0, 0, 0.75);
 }
+
+.field--container > ul > .object-item--translation {
+  display: flex;
+  gap: 1rem;
+  align-items: start;
+  justify-content: space-between;
+}
+
+.object-item--translation .container-item-title {
+  flex: none;
+  font-family: var(--font-mono);
+  line-height: 1.5;
+  max-width: 40%;
+  padding: calc(0.5rem + 1px) 0;
+  display: block;
+}
+
+.object-item--translation > .field {
+  margin-top: 0;
+  flex: 1 1 0;
+}
+
+.object-item--translation button {
+  align-self: center;
+}