tsondb 0.5.8 → 0.5.12

package/dist/src/bin/tsondb.d.ts

@@ -1,10 +1,2 @@
 #!/usr/bin/env node
-import type { Output } from "../node/renderers/Output.ts";
-import type { Schema } from "../node/Schema.ts";
-import type { ServerOptions } from "../node/server/index.ts";
-export type Config = {
-    serverOptions?: ServerOptions;
-    schema: Schema;
-    outputs: Output[];
-    dataRootPath: string;
-};
+export {};

package/dist/src/bin/tsondb.js

@@ -88,6 +88,13 @@ switch (passedArguments.command.name) {
         break;
     case "validate":
         debug(`running command: validate`);
+        if (passedArguments.command.options?.checkReferentialIntegrity !== undefined) {
+            debug(`check referential integrity: ${passedArguments.command.options.checkReferentialIntegrity ? "yes" : "no"}`);
+        }
+        if (passedArguments.command.options?.entities !== undefined) {
+            const entities = passedArguments.command.options.entities;
+            debug(`only check the following entities: ${entities.join(", ")}`);
+        }
         await validate(config.schema, config.dataRootPath, {
             checkReferentialIntegrity: passedArguments.command.options?.checkReferentialIntegrity,
             checkOnlyEntities: passedArguments.command.options?.entities,

package/dist/src/index.d.ts

@@ -1,2 +1,2 @@
-export type { Config } from "./bin/tsondb.ts";
 export * from "./node/index.ts";
+export type { Config } from "./shared/config.ts";

package/dist/src/node/index.d.ts

@@ -1,5 +1,5 @@
-import type { Output } from "./renderers/Output.ts";
-import type { Schema } from "./Schema.ts";
+import type { Output } from "../shared/output.ts";
+import { type Schema } from "./schema/Schema.ts";
 import type { ServerOptions } from "./server/index.ts";
 export declare const generateOutputs: (schema: Schema, outputs: Output[]) => Promise<void>;
 type ValidationOptions = {

package/dist/src/node/index.js

@@ -3,8 +3,9 @@ import { mkdir, writeFile } from "fs/promises";
 import { join, sep } from "path";
 import { styleText } from "util";
 import { parallelizeErrors } from "../shared/utils/validation.js";
-import { getEntities } from "./Schema.js";
-import { createValidators, validateEntityDecl } from "./schema/index.js";
+import { validateEntityDecl } from "./schema/declarations/EntityDecl.js";
+import { createValidators } from "./schema/Node.js";
+import { getEntities } from "./schema/Schema.js";
 import { createServer } from "./server/index.js";
 import { countErrors, getErrorMessageForDisplay, wrapErrorsIfAny } from "./utils/error.js";
 import { formatInstance, getInstancesByEntityName } from "./utils/instances.js";
@@ -23,6 +24,11 @@ export const generateOutputs = async (schema, outputs) => {
 };
 const _validate = (dataRootPath, entities, instancesByEntityName, options = {}) => {
     const { checkReferentialIntegrity = false, checkOnlyEntities = [] } = options;
+    for (const onlyEntity of checkOnlyEntities) {
+        if (!entities.find(entity => entity.name === onlyEntity)) {
+            throw new Error(`Entity "${onlyEntity}" not found in schema`);
+        }
+    }
     const errors = (checkOnlyEntities.length > 0
         ? entities.filter(entity => checkOnlyEntities.includes(entity.name))
         : entities)

package/dist/src/node/renderers/jsonschema/index.d.ts

@@ -1,4 +1,4 @@
-import type { Output } from "../Output.ts";
+import type { Output } from "../../../shared/output.ts";
 import type { JsonSchemaRendererOptions } from "./render.ts";
 export declare const JsonSchemaOutput: (options: {
     targetPath: string;

package/dist/src/node/renderers/ts/index.d.ts

@@ -1,4 +1,4 @@
-import type { Output } from "../Output.ts";
+import type { Output } from "../../../shared/output.ts";
 import type { TypeScriptRendererOptions } from "./render.ts";
 export declare const TypeScriptOutput: (options: {
     targetPath: string;

package/dist/src/node/{Schema.d.ts → schema/Schema.d.ts}

@@ -1,5 +1,5 @@
-import type { Decl } from "./schema/declarations/Declaration.ts";
-import type { EntityDecl } from "./schema/declarations/EntityDecl.ts";
+import type { Decl } from "./declarations/Declaration.ts";
+import type { EntityDecl } from "./declarations/EntityDecl.ts";
 export interface Schema {
     declarations: readonly Decl[];
     localeEntity?: EntityDecl;

package/dist/src/node/{Schema.js → schema/Schema.js}

@@ -1,9 +1,9 @@
-import { getNestedDeclarations, getParameterNames, walkNodeTree, } from "./schema/declarations/Declaration.js";
-import { isEntityDecl } from "./schema/declarations/EntityDecl.js";
-import { isStringType } from "./schema/types/primitives/StringType.js";
-import { isIncludeIdentifierType } from "./schema/types/references/IncludeIdentifierType.js";
-import { isNestedEntityMapType } from "./schema/types/references/NestedEntityMapType.js";
-import { findTypeAtPath } from "./schema/types/Type.js";
+import { getNestedDeclarations, getParameterNames, walkNodeTree, } from "./declarations/Declaration.js";
+import { isEntityDecl } from "./declarations/EntityDecl.js";
+import { isStringType } from "./types/primitives/StringType.js";
+import { isIncludeIdentifierType } from "./types/references/IncludeIdentifierType.js";
+import { isNestedEntityMapType } from "./types/references/NestedEntityMapType.js";
+import { findTypeAtPath } from "./types/Type.js";
 const checkDuplicateIdentifier = (existingDecls, decl) => {
     const existingDeclWithSameName = existingDecls
         .values()
@@ -27,7 +27,10 @@ const checkEntityDisplayNamePaths = (decls, localeEntity) => {
     for (const decl of decls) {
         if (isEntityDecl(decl) && decl.displayName !== null) {
             const displayName = decl.displayName ?? "name";
-            if (typeof displayName === "object") {
+            if (typeof displayName === "function") {
+                continue;
+            }
+            else if (typeof displayName === "object") {
                 const pathToLocaleMap = displayName.pathToLocaleMap ?? "translations";
                 const pathInLocaleMap = displayName.pathInLocaleMap ?? "name";
                 if (localeEntity === undefined) {

package/dist/src/node/schema/declarations/EntityDecl.d.ts

@@ -8,6 +8,32 @@ import type { AsType, SerializedAsType } from "../types/Type.ts";
 import type { ValidatorHelpers } from "../validation/type.ts";
 import type { BaseDecl, GetNestedDeclarations, SerializedBaseDecl } from "./Declaration.ts";
 import { TypeAliasDecl } from "./TypeAliasDecl.ts";
+export type GenericDisplayNameFn = (instance: unknown, instanceDisplayName: string, getInstanceById: (id: string) => unknown, getDisplayNameForInstanceId: (id: string) => string | undefined, locales: string[] | undefined) => string;
+export type GenericEntityDisplayName = string | {
+    pathToLocaleMap?: string;
+    pathInLocaleMap?: string;
+} | null;
+export type DisplayNameFn<T extends ObjectType = ObjectType> = (instance: AsType<T>, instanceDisplayName: string, getInstanceById: (id: string) => unknown, getDisplayNameForInstanceId: (id: string) => string | undefined, locales: string[] | undefined) => string;
+export type EntityDisplayName<T extends ObjectType> = Leaves<AsType<T>> | {
+    /**
+     * @default "translations"
+     */
+    pathToLocaleMap?: Leaves<AsType<T>>;
+    /**
+     * @default "name"
+     */
+    pathInLocaleMap?: string;
+} | null;
+export type SerializedEntityDisplayName<T extends SerializedObjectType> = Leaves<SerializedAsType<T>> | {
+    /**
+     * @default "translations"
+     */
+    pathToLocaleMap?: Leaves<SerializedAsType<T>>;
+    /**
+     * @default "name"
+     */
+    pathInLocaleMap?: string;
+} | null;
 export interface EntityDecl<Name extends string = string, T extends ObjectType = ObjectType> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
@@ -15,16 +41,8 @@ export interface EntityDecl<Name extends string = string, T extends ObjectType =
     /**
      * @default "name"
      */
-    displayName?: Leaves<AsType<T>> | {
-        /**
-         * @default "translations"
-         */
-        pathToLocaleMap?: Leaves<AsType<T>>;
-        /**
-         * @default "name"
-         */
-        pathInLocaleMap?: string;
-    } | null;
+    displayName?: EntityDisplayName<T>;
+    displayNameCustomizer?: DisplayNameFn<T>;
     isDeprecated?: boolean;
 }
 export interface SerializedEntityDecl<Name extends string = string, T extends SerializedObjectType = SerializedObjectType> extends SerializedBaseDecl<Name, []> {
@@ -34,16 +52,7 @@ export interface SerializedEntityDecl<Name extends string = string, T extends Se
     /**
      * @default "name"
      */
-    displayName?: Leaves<SerializedAsType<T>> | {
-        /**
-         * @default "translations"
-         */
-        pathToLocaleMap?: Leaves<SerializedAsType<T>>;
-        /**
-         * @default "name"
-         */
-        pathInLocaleMap?: string;
-    } | null;
+    displayName?: SerializedEntityDisplayName<T>;
     isDeprecated?: boolean;
 }
 export declare const EntityDecl: <Name extends string, T extends ObjectType>(sourceUrl: string, options: {
@@ -54,16 +63,8 @@ export declare const EntityDecl: <Name extends string, T extends ObjectType>(sou
     /**
      * @default "name"
      */
-    displayName?: Leaves<AsType<T>> | {
-        /**
-         * @default "translations"
-         */
-        pathToLocaleMap?: Leaves<AsType<T>>;
-        /**
-         * @default "name"
-         */
-        pathInLocaleMap?: string;
-    } | null;
+    displayName?: EntityDisplayName<T>;
+    displayNameCustomizer?: DisplayNameFn<T>;
     isDeprecated?: boolean;
 }) => EntityDecl<Name, T>;
 export { EntityDecl as Entity };

package/dist/src/node/schema/declarations/EntityDecl.js

@@ -52,5 +52,6 @@ export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sou
 export const serializeEntityDecl = type => ({
     ...type,
     type: serializeObjectType(type.type.value),
+    displayName: typeof type.displayName === "function" ? null : type.displayName,
 });
 export const getReferencesForEntityDecl = (decl, value) => getReferencesForObjectType(decl.type.value, value);

package/dist/src/node/server/api/declarations.js

@@ -3,7 +3,7 @@ import express from "express";
 import { getInstanceContainerOverview } from "../../../shared/utils/instances.js";
 import { isOk } from "../../../shared/utils/result.js";
 import { serializeDecl } from "../../schema/declarations/Declaration.js";
-import { isEntityDecl, serializeEntityDecl } from "../../schema/declarations/EntityDecl.js";
+import { isEntityDecl } from "../../schema/declarations/EntityDecl.js";
 import { isEnumDecl } from "../../schema/declarations/EnumDecl.js";
 import { isTypeAliasDecl } from "../../schema/declarations/TypeAliasDecl.js";
 import { createInstance, deleteInstance, updateInstance } from "./instanceOperations.js";
@@ -60,11 +60,10 @@ declarationsApi.get("/:name/instances", (req, res) => {
         res.status(400).send(`Declaration "${decl.name}" is not an entity`);
         return;
     }
-    const serializedEntityDecl = serializeEntityDecl(decl);
     const body = {
         instances: req.instancesByEntityName[req.params.name]
-            ?.map(instanceContainer => getInstanceContainerOverview(serializedEntityDecl, instanceContainer, req.locales))
-            .toSorted((a, b) => a.displayName.localeCompare(b.displayName)) ?? [],
+            ?.map(instanceContainer => getInstanceContainerOverview(decl, instanceContainer, req.getInstanceById, req.locales))
+            .toSorted((a, b) => a.displayName.localeCompare(b.displayName, undefined, { numeric: true })) ?? [],
         isLocaleEntity: decl === req.localeEntity,
     };
     res.json(body);

package/dist/src/node/server/api/git.js

@@ -3,7 +3,6 @@ import express, {} from "express";
 import { join } from "node:path";
 import { hasFileChanges } from "../../../shared/utils/git.js";
 import { getInstanceContainerOverview } from "../../../shared/utils/instances.js";
-import { serializeEntityDecl } from "../../schema/index.js";
 import { attachGitStatusToInstancesByEntityName } from "../../utils/instances.js";
 import { reinit } from "../init.js";
 const debug = Debug("tsondb:server:api:git");
@@ -30,7 +29,7 @@ gitApi.get("/status", async (req, res) => {
                 .filter(instance => hasFileChanges(instance.gitStatus))
                 .map(instance => getInstanceContainerOverview(
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            serializeEntityDecl(req.entitiesByName[entityName]), instance, req.locales)),
+            req.entitiesByName[entityName], instance, req.getInstanceById, req.locales)),
         ])),
     };
     res.json(body);

package/dist/src/node/server/api/instances.js

@@ -1,7 +1,6 @@
 import Debug from "debug";
 import express from "express";
-import { getDisplayNameFromEntityInstance } from "../../../shared/utils/displayName.js";
-import { serializeEntityDecl } from "../../schema/declarations/EntityDecl.js";
+import { getDisplayNameFromEntityInstance } from "../../utils/displayName.js";
 const debug = Debug("tsondb:server:api:instances");
 export const instancesApi = express.Router();
 instancesApi.use((req, _res, next) => {
@@ -19,7 +18,7 @@ instancesApi.get("/", (req, res) => {
                 id: instance.id,
                 name: getDisplayNameFromEntityInstance(
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                serializeEntityDecl(req.entitiesByName[entityName]), instance.content, instance.id, locales),
+                req.entitiesByName[entityName], instance.content, req.getInstanceById, locales),
             })),
         ])),
     };

package/dist/src/node/server/index.d.ts

@@ -1,8 +1,8 @@
 import type { SimpleGit } from "simple-git";
-import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
-import type { Schema } from "../Schema.ts";
+import type { InstanceContainer, InstancesByEntityName } from "../../shared/utils/instances.ts";
 import type { Decl } from "../schema/declarations/Declaration.ts";
 import type { EntityDecl } from "../schema/declarations/EntityDecl.ts";
+import type { Schema } from "../schema/Schema.ts";
 import type { ReferencesToInstances } from "../utils/references.ts";
 export type ServerOptions = {
     port: number;
@@ -18,7 +18,12 @@ export interface TSONDBRequestLocals {
     localeEntity?: EntityDecl;
     referencesToInstances: ReferencesToInstances;
     locales: string[];
+    getInstanceById: GetInstanceById;
 }
+export type GetInstanceById = (id: string) => {
+    entity: EntityDecl;
+    instance: InstanceContainer;
+} | undefined;
 declare global {
     namespace Express {
         interface Request extends TSONDBRequestLocals {

package/dist/src/node/server/index.js

@@ -31,6 +31,15 @@ export const createServer = async (schema, dataRootPath, instancesByEntityName,
         next();
     });
     app.use("/api", api);
+    const importMap = JSON.stringify({
+        imports: {
+            preact: "/js/node_modules/preact/dist/preact.module.js",
+            "preact/hooks": "/js/node_modules/preact/hooks/dist/hooks.module.js",
+            "preact/compat": "/js/node_modules/preact/compat/dist/compat.module.js",
+            "preact/jsx-runtime": "/js/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js",
+            "preact-iso": "/js/node_modules/preact-iso/src/index.js",
+        },
+    }, null, 2);
     app.get(/^\/.*/, (_req, res) => {
         res.send(`<!DOCTYPE html>
 <html lang="en">
@@ -39,16 +48,7 @@ export const createServer = async (schema, dataRootPath, instancesByEntityName,
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>TSONDB</title>
   <link rel="stylesheet" href="/css/styles.css">
-  <script type="importmap">
-    {
-      "imports": {
-        "preact": "/js/node_modules/preact/dist/preact.module.js",
-        "preact/hooks": "/js/node_modules/preact/hooks/dist/hooks.module.js",
-        "preact/jsx-runtime": "/js/node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js",
-        "preact-iso": "/js/node_modules/preact-iso/src/index.js"
-      }
-    }
-  </script>
+  <script type="importmap">${importMap}</script>
 </head>
 <body>
   <div id="app"></div>

package/dist/src/node/server/init.d.ts

@@ -1,5 +1,5 @@
 import type { InstancesByEntityName } from "../../shared/utils/instances.ts";
-import type { Schema } from "../Schema.ts";
+import type { Schema } from "../schema/Schema.ts";
 import type { TSONDBRequestLocals } from "./index.ts";
 export declare const init: (schema: Schema, dataRootPath: string, instancesByEntityName: InstancesByEntityName) => Promise<TSONDBRequestLocals>;
 export declare const reinit: (locals: TSONDBRequestLocals) => Promise<void>;

package/dist/src/node/server/init.js

@@ -29,6 +29,15 @@ export const init = async (schema, dataRootPath, instancesByEntityName) => {
     if (gitStatus) {
         attachGitStatusToInstancesByEntityName(instancesByEntityName, dataRootPath, gitRoot, gitStatus);
     }
+    const getInstanceById = id => {
+        for (const entityName in instancesByEntityNameInMemory) {
+            const instance = instancesByEntityNameInMemory[entityName]?.find(i => i.id === id);
+            if (instance && entitiesByName[entityName]) {
+                return { entity: entitiesByName[entityName], instance };
+            }
+        }
+        return undefined;
+    };
     const requestLocals = {
         git: git,
         gitRoot: gitRoot,
@@ -38,6 +47,7 @@ export const init = async (schema, dataRootPath, instancesByEntityName) => {
         instancesByEntityName: instancesByEntityNameInMemory,
         entitiesByName: entitiesByName,
         localeEntity: schema.localeEntity,
+        getInstanceById,
         referencesToInstances,
         locales: ["de-DE", "en-US"], // TODO: Make this configurable
     };

package/dist/src/node/utils/displayName.d.ts

@@ -0,0 +1,3 @@
+import { type EntityDecl } from "../../node/schema/index.ts";
+import type { GetInstanceById } from "../../node/server/index.ts";
+export declare const getDisplayNameFromEntityInstance: (entity: EntityDecl, instance: unknown, getInstanceById: GetInstanceById, locales?: string[], defaultName?: string, useCustomizer?: boolean) => string;

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

@@ -0,0 +1,19 @@
+import { serializeEntityDecl } from "../../node/schema/index.js";
+import { getSerializedDisplayNameFromEntityInstance } from "../../shared/utils/displayName.js";
+export const getDisplayNameFromEntityInstance = (entity, instance, getInstanceById, locales = [], defaultName = "", useCustomizer = true) => {
+    if (useCustomizer && entity.displayNameCustomizer) {
+        return entity.displayNameCustomizer(instance, getDisplayNameFromEntityInstance(entity, instance, getInstanceById, locales, defaultName, false), id => getInstanceById(id)?.instance.content, id => {
+            const result = getInstanceById(id);
+            if (result) {
+                const { entity, instance } = result;
+                return getDisplayNameFromEntityInstance(entity, instance.content, getInstanceById, locales, id);
+            }
+            else {
+                return undefined;
+            }
+        }, locales);
+    }
+    else {
+        return getSerializedDisplayNameFromEntityInstance(serializeEntityDecl(entity), instance, defaultName, locales);
+    }
+};

package/dist/src/shared/config.d.ts

@@ -0,0 +1,11 @@
+import type { Schema } from "../node/schema/Schema.ts";
+import type { Output } from "./output.ts";
+export type Config = {
+    serverOptions?: ServerOptions;
+    schema: Schema;
+    outputs: Output[];
+    dataRootPath: string;
+};
+export type ServerOptions = {
+    port: number;
+};

package/dist/src/{node/renderers/Output.d.ts → shared/output.d.ts}

@@ -1,4 +1,4 @@
-import type { Schema } from "../Schema.ts";
+import type { Schema } from "../node/schema/Schema.ts";
 export interface Output {
     run: (schema: Schema) => Promise<void>;
 }

package/dist/src/shared/output.js

@@ -0,0 +1 @@
+export {};

package/dist/src/shared/utils/compare.js

@@ -18,7 +18,12 @@ export const deepEqual = (a, b) => {
         if (keys.length !== Object.keys(b).length) {
             return false;
         }
-        return keys.every(key => key in b && deepEqual(a[key], b[key]));
+        for (const key of keys) {
+            if (!(key in b) || !deepEqual(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
     }
     return false;
 };

package/dist/src/shared/utils/displayName.d.ts

@@ -1,2 +1,2 @@
 import type { SerializedEntityDecl } from "../../node/schema/index.ts";
-export declare const getDisplayNameFromEntityInstance: (entity: SerializedEntityDecl, instance: unknown, defaultName: string, locales?: string[]) => string;
+export declare const getSerializedDisplayNameFromEntityInstance: (entity: SerializedEntityDecl, instance: unknown, defaultName: string, locales?: string[]) => string;

package/dist/src/shared/utils/displayName.js

@@ -11,7 +11,7 @@ const getValueAtPath = (value, path) => {
     }
     return current;
 };
-export const getDisplayNameFromEntityInstance = (entity, instance, defaultName, locales = []) => {
+export const getSerializedDisplayNameFromEntityInstance = (entity, instance, defaultName, locales = []) => {
     if (entity.displayName === null) {
         return defaultName;
     }

package/dist/src/shared/utils/instances.d.ts

@@ -1,4 +1,5 @@
-import type { SerializedEntityDecl } from "../../node/schema/index.ts";
+import type { EntityDecl } from "../../node/schema/index.ts";
+import type { GetInstanceById } from "../../node/server/index.ts";
 import type { GitFileStatus } from "./git.ts";
 export interface InstanceContainer {
     fileName: string;
@@ -12,5 +13,5 @@ export interface InstanceContainerOverview {
     gitStatus?: GitFileStatus;
     displayName: string;
 }
-export declare const getInstanceContainerOverview: (entity: SerializedEntityDecl, instanceContainer: InstanceContainer, locales?: string[]) => InstanceContainerOverview;
+export declare const getInstanceContainerOverview: (entity: EntityDecl, instanceContainer: InstanceContainer, getInstanceById: GetInstanceById, locales?: string[]) => InstanceContainerOverview;
 export type InstancesByEntityName = Record<string, InstanceContainer[]>;

package/dist/src/shared/utils/instances.js

@@ -1,8 +1,8 @@
-import { getDisplayNameFromEntityInstance } from "./displayName.js";
-export const getInstanceContainerOverview = (entity, instanceContainer, locales) => {
+import { getDisplayNameFromEntityInstance } from "../../node/utils/displayName.js";
+export const getInstanceContainerOverview = (entity, instanceContainer, getInstanceById, locales) => {
     const { content: _, ...rest } = instanceContainer;
     return {
         ...rest,
-        displayName: getDisplayNameFromEntityInstance(entity, instanceContainer.content, instanceContainer.id, locales),
+        displayName: getDisplayNameFromEntityInstance(entity, instanceContainer.content, getInstanceById, locales),
     };
 };

package/dist/src/shared/utils/markdown.js

@@ -61,7 +61,7 @@ const listRule = {
     }),
 };
 const paragraphRule = {
-    pattern: /^((?:[^\n]+?)(?:\n[^\n]+?)*)(?:\n{2,}|$)/,
+    pattern: /^((?:[^\n]+?)(?:\n[^\n]+?)*)(?:\n{2,}|\s*$)/,
     map: result => ({ kind: "paragraph", content: parseInlineMarkdown(result[1] ?? "") }),
 };
 const blockRules = [listRule, paragraphRule];

package/dist/src/web/components/Git.js

@@ -8,7 +8,7 @@ const filterFilesForDisplay = (predicate, entities, data) => Object.entries(data
     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)),
+        .sort((a, b) => a.displayName.localeCompare(b.displayName, undefined, { numeric: true })),
 ])
     .filter(([_1, _2, instances]) => instances.length > 0)
     .sort((a, b) => a[1].localeCompare(b[1]));

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

@@ -4,7 +4,8 @@ import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity
 import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.ts";
 type Props = {
     type: SerializedArrayType;
-    value: unknown[];
+    path: string | undefined;
+    value: unknown;
     instanceNamesByEntity: InstanceNamesByEntity;
     getDeclFromDeclName: GetDeclFromDeclName;
     onChange: (value: unknown[]) => void;

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

@@ -1,17 +1,21 @@
-import { jsxs as _jsxs, jsx as _jsx } from "preact/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } 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";
+import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
-export const ArrayTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+export const ArrayTypeInput = ({ type, path, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
+    if (!Array.isArray(value)) {
+        return _jsx(MismatchingTypeError, { expected: "array", actual: value });
+    }
     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: () => {
+    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, "."] }), _jsxs("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 => {
+                                    }, disabled: type.minItems !== undefined && value.length <= type.minItems, children: ["Delete Item #", i + 1] })] })), _jsx(TypeInput, { type: type.items, path: path === undefined ? `[${i.toString()}]` : `${path}[${i.toString()}]`, 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: () => {
+                            } })] }, i))) })), isTuple ? null : (_jsx("div", { class: "add-item-container", children: _jsxs("button", { onClick: () => {
                         onChange([...value, createTypeSkeleton(getDeclFromDeclName, type.items)]);
-                    }, disabled: type.maxItems !== undefined && value.length >= type.maxItems, children: "Add Item" }) })), _jsx(ValidationErrors, { errors: errors })] }));
+                    }, disabled: type.maxItems !== undefined && value.length >= type.maxItems, children: ["Add Item #", value.length + 1] }) })), _jsx(ValidationErrors, { errors: errors })] }));
 };

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

@@ -2,7 +2,7 @@ import type { FunctionComponent } from "preact";
 import type { SerializedBooleanType } from "../../../node/schema/types/primitives/BooleanType.ts";
 type Props = {
     type: SerializedBooleanType;
-    value: boolean;
+    value: unknown;
     onChange: (value: boolean) => void;
 };
 export declare const BooleanTypeInput: FunctionComponent<Props>;

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

@@ -1,5 +1,9 @@
 import { jsx as _jsx } from "preact/jsx-runtime";
+import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 export const BooleanTypeInput = ({ value, onChange }) => {
+    if (typeof value !== "boolean") {
+        return _jsx(MismatchingTypeError, { expected: "boolean", actual: value });
+    }
     return (_jsx("div", { class: "field", children: _jsx("input", { type: "checkbox", checked: value, onInput: event => {
                 onChange(event.currentTarget.checked);
             } }) }));

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

@@ -2,7 +2,7 @@ import type { FunctionComponent } from "preact";
 import type { SerializedDateType } from "../../../node/schema/types/primitives/DateType.ts";
 type Props = {
     type: SerializedDateType;
-    value: string;
+    value: unknown;
     onChange: (value: string) => void;
 };
 export declare const DateTypeInput: FunctionComponent<Props>;

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

@@ -1,7 +1,11 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { validateDateConstraints } from "../../../shared/validation/date.js";
+import { MismatchingTypeError } from "./utils/MismatchingTypeError.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
 export const DateTypeInput = ({ type, value, onChange }) => {
+    if (typeof value !== "string") {
+        return _jsx(MismatchingTypeError, { expected: "date string", actual: value });
+    }
     const errors = validateDateConstraints(type, value);
     return (_jsxs("div", { class: "field", children: [_jsx("input", { type: "date", value: value, onInput: event => {
                     onChange(event.currentTarget.value);

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

@@ -4,6 +4,7 @@ import type { InstanceNamesByEntity } from "../../hooks/useInstanceNamesByEntity
 import type { GetDeclFromDeclName } from "../../hooks/useSecondaryDeclarations.ts";
 type Props = {
     type: SerializedEnumType;
+    path: string | undefined;
     value: unknown;
     instanceNamesByEntity: InstanceNamesByEntity;
     getDeclFromDeclName: GetDeclFromDeclName;

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

@@ -5,7 +5,7 @@ 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, }) => {
+export const EnumTypeInput = ({ type, path, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
     if (typeof value !== "object" ||
         value === null ||
         Array.isArray(value) ||
@@ -29,7 +29,7 @@ export const EnumTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromD
                             [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, 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, path: path === undefined ? `{${activeEnumCase}}` : `${path}.{${activeEnumCase}}`, value: value[activeEnumCase], instanceNamesByEntity: instanceNamesByEntity, getDeclFromDeclName: getDeclFromDeclName, onChange: newValue => {
                         onChange({
                             [discriminatorKey]: activeEnumCase,
                             [activeEnumCase]: newValue,

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

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