tsondb 0.5.1 → 0.5.3

package/lib/node/Schema.js

@@ -1,6 +1,7 @@
-import { getNestedDeclarations, getParameterNames } from "./schema/declarations/Declaration.js";
+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";
 const checkDuplicateIdentifier = (existingDecls, decl) => {
@@ -14,9 +15,11 @@ const checkDuplicateIdentifier = (existingDecls, decl) => {
 const checkParameterNamesShadowing = (decls) => {
     for (const decl of decls) {
         for (const param of getParameterNames(decl)) {
-            if (decls.values().some(decl => decl.name === param)) {
-                throw new Error(`Parameter name "${param}" shadows declaration name.`);
-            }
+            walkNodeTree(node => {
+                if (isIncludeIdentifierType(node) && node.reference.name === param) {
+                    throw new Error(`Parameter name "${param}" shadows declaration name in declaration "${decl.name}".`);
+                }
+            }, decl);
         }
     }
 };

package/lib/node/index.js

@@ -21,7 +21,9 @@ export const generateOutputs = async (schema, outputs) => {
     }
 };
 const _validate = (dataRootPath, entities, instancesByEntityName) => {
-    const errors = entities.flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file "${join(dataRootPath, entity.name, instance.fileName)}"`, validateEntityDecl(createValidators(instancesByEntityName), entity, instance.content))) ?? []));
+    const errors = entities
+        .flatMap(entity => parallelizeErrors(instancesByEntityName[entity.name]?.map(instance => wrapErrorsIfAny(`in file "${join(dataRootPath, entity.name, instance.fileName)}"`, validateEntityDecl(createValidators(instancesByEntityName), entity, instance.content))) ?? []))
+        .toSorted((a, b) => a.message.localeCompare(b.message));
     if (errors.length === 0) {
         debug("All entities are valid");
     }

package/lib/node/schema/declarations/Declaration.d.ts

@@ -1,7 +1,7 @@
 import type { BaseNode, GetReferences, Node, Serializer } from "../Node.js";
 import type { SerializedTypeParameter, TypeParameter } from "../TypeParameter.js";
 import type { EnumCaseDecl, SerializedEnumCaseDecl } from "../types/generic/EnumType.js";
-import type { SerializedType, Type } from "../types/Type.js";
+import { type SerializedType, type Type } from "../types/Type.js";
 import type { ValidatorHelpers } from "../validation/type.js";
 import type { EntityDecl, SerializedEntityDecl } from "./EntityDecl.js";
 import type { EnumDecl, SerializedEnumDecl } from "./EnumDecl.js";
@@ -40,6 +40,7 @@ export declare const validateDeclName: (name: string) => void;
 export declare const resolveTypeArgumentsInDecl: <Params extends TypeParameter[]>(decl: DeclP<Params>, args: TypeArguments<Params>) => DeclP<[]>;
 export declare const isDeclWithoutTypeParameters: (decl: Decl) => decl is DeclP<[]>;
 export declare const resolveTypeArgumentsInDecls: (decls: readonly Decl[]) => DeclP<[]>[];
+export declare function walkNodeTree(callbackFn: (node: Node) => void, decl: Decl): void;
 export declare const serializeDecl: Serializer<Decl, SerializedDecl>;
 export declare const getReferencesForDecl: GetReferences<Decl>;
 export declare const groupDeclarationsBySourceUrl: (decls: readonly Decl[]) => Partial<Record<string, Decl[]>>;

package/lib/node/schema/declarations/Declaration.js

@@ -6,6 +6,7 @@ import { getNestedDeclarationsInObjectType } from "../types/generic/ObjectType.j
 import { getNestedDeclarationsInIncludeIdentifierType } from "../types/references/IncludeIdentifierType.js";
 import { getNestedDeclarationsInNestedEntityMapType } from "../types/references/NestedEntityMapType.js";
 import { getNestedDeclarationsInReferenceIdentifierType } from "../types/references/ReferenceIdentifierType.js";
+import { walkTypeNodeTree } from "../types/Type.js";
 import { getNestedDeclarationsInEntityDecl, getReferencesForEntityDecl, isEntityDecl, resolveTypeArgumentsInEntityDecl, serializeEntityDecl, validateEntityDecl, } from "./EntityDecl.js";
 import { getNestedDeclarationsInEnumDecl, getReferencesForEnumDecl, isEnumDecl, resolveTypeArgumentsInEnumDecl, serializeEnumDecl, validateEnumDecl, } from "./EnumDecl.js";
 import { getNestedDeclarationsInTypeAliasDecl, getReferencesForTypeAliasDecl, isTypeAliasDecl, resolveTypeArgumentsInTypeAliasDecl, serializeTypeAliasDecl, validateTypeAliasDecl, } from "./TypeAliasDecl.js";
@@ -77,6 +78,27 @@ export const resolveTypeArgumentsInDecl = (decl, args) => {
 };
 export const isDeclWithoutTypeParameters = (decl) => decl.parameters.length === 0;
 export const resolveTypeArgumentsInDecls = (decls) => decls.filter(isDeclWithoutTypeParameters).map(decl => resolveTypeArgumentsInDecl(decl, []));
+export function walkNodeTree(callbackFn, decl) {
+    switch (decl.kind) {
+        case NodeKind.EntityDecl: {
+            callbackFn(decl);
+            walkTypeNodeTree(callbackFn, decl.type.value);
+            return;
+        }
+        case NodeKind.EnumDecl: {
+            callbackFn(decl);
+            walkTypeNodeTree(callbackFn, decl.type.value);
+            return;
+        }
+        case NodeKind.TypeAliasDecl: {
+            callbackFn(decl);
+            walkTypeNodeTree(callbackFn, decl.type.value);
+            return;
+        }
+        default:
+            return assertExhaustive(decl);
+    }
+}
 export const serializeDecl = decl => {
     switch (decl.kind) {
         case NodeKind.EntityDecl:

package/lib/node/schema/types/Type.js

@@ -71,47 +71,49 @@ export const resolveTypeArgumentsInType = (args, type) => {
 };
 export function walkTypeNodeTree(callbackFn, type) {
     switch (type.kind) {
-        case NodeKind.ArrayType:
+        case NodeKind.ArrayType: {
             callbackFn(type);
-            {
-                walkTypeNodeTree(callbackFn, type.items);
-                return;
-            }
-        case NodeKind.ObjectType:
+            walkTypeNodeTree(callbackFn, type.items);
+            return;
+        }
+        case NodeKind.ObjectType: {
             callbackFn(type);
-            {
-                Object.values(type.properties).forEach(prop => {
-                    walkTypeNodeTree(callbackFn, prop.type);
-                });
-                return;
-            }
-        case NodeKind.NestedEntityMapType:
+            Object.values(type.properties).forEach(prop => {
+                walkTypeNodeTree(callbackFn, prop.type);
+            });
+            return;
+        }
+        case NodeKind.NestedEntityMapType: {
             callbackFn(type);
-            {
-                walkTypeNodeTree(callbackFn, type.type.value);
-                return;
-            }
+            walkTypeNodeTree(callbackFn, type.type.value);
+            return;
+        }
         case NodeKind.BooleanType:
         case NodeKind.DateType:
         case NodeKind.FloatType:
         case NodeKind.IntegerType:
         case NodeKind.StringType:
         case NodeKind.TypeArgumentType:
-        case NodeKind.ReferenceIdentifierType:
+        case NodeKind.ReferenceIdentifierType: {
+            callbackFn(type);
+            return;
+        }
         case NodeKind.IncludeIdentifierType: {
             callbackFn(type);
+            type.args.forEach(arg => {
+                walkTypeNodeTree(callbackFn, arg);
+            });
             return;
         }
-        case NodeKind.EnumType:
+        case NodeKind.EnumType: {
             callbackFn(type);
-            {
-                Object.values(type.values).forEach(value => {
-                    if (value.type) {
-                        walkTypeNodeTree(callbackFn, value.type);
-                    }
-                });
-                return;
-            }
+            Object.values(type.values).forEach(value => {
+                if (value.type) {
+                    walkTypeNodeTree(callbackFn, value.type);
+                }
+            });
+            return;
+        }
         default:
             return assertExhaustive(type);
     }

package/lib/node/schema/types/references/IncludeIdentifierType.js

@@ -15,9 +15,9 @@ export const IncludeIdentifierType = (reference) => ({
 });
 export { IncludeIdentifierType as IncludeIdentifier };
 export const isIncludeIdentifierType = (node) => node.kind === NodeKind.IncludeIdentifierType;
-export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) => addedDecls.includes(type.reference)
+export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) => type.args.reduce((accAddedDecls, arg) => getNestedDeclarations(accAddedDecls, arg), addedDecls.includes(type.reference)
     ? addedDecls
-    : getNestedDeclarations([type.reference, ...addedDecls], type.reference);
+    : getNestedDeclarations([type.reference, ...addedDecls], type.reference));
 export const validateIncludeIdentifierType = (helpers, type, value) => validateDecl(helpers, type.reference, type.args, value);
 export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => type.args.length === 0
     ? type

package/lib/shared/utils/markdown.d.ts

@@ -5,10 +5,20 @@ type TextNode = {
 export type InlineMarkdownNode = {
     kind: "bold" | "italic";
     content: InlineMarkdownNode[];
+} | {
+    kind: "code";
+    content: string;
 } | TextNode;
 export type BlockMarkdownNode = {
     kind: "paragraph";
     content: InlineMarkdownNode[];
+} | {
+    kind: "list";
+    ordered: boolean;
+    content: {
+        kind: "listitem";
+        content: InlineMarkdownNode[];
+    }[];
 } | TextNode;
 export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
 export {};

package/lib/shared/utils/markdown.js

@@ -1,3 +1,7 @@
+const codeRule = {
+    pattern: /`(.*?)`/,
+    map: result => ({ kind: "code", content: result[1] ?? "" }),
+};
 const boldWithItalicRule = {
     pattern: /\*\*(.*?\*.+?\*.*?)\*\*/,
     map: (result, parseInside) => ({ kind: "bold", content: parseInside(result[1] ?? "") }),
@@ -14,9 +18,14 @@ const italicRule = {
     pattern: /\*(.+?)\*/,
     map: (result, parseInside) => ({ kind: "italic", content: parseInside(result[1] ?? "") }),
 };
-const rules = [boldWithItalicRule, italicWithBoldRule, boldRule, italicRule];
-export const parseBlockMarkdown = (text) => text.split(/\n{2,}/).map(par => ({ kind: "paragraph", content: parseInlineMarkdown(par) }));
-const parseForRules = (rules, text) => {
+const inlineRules = [
+    codeRule,
+    boldWithItalicRule,
+    italicWithBoldRule,
+    boldRule,
+    italicRule,
+];
+const parseForInlineRules = (rules, text) => {
     if (text.length === 0) {
         return [];
     }
@@ -30,13 +39,48 @@ const parseForRules = (rules, text) => {
         const before = text.slice(0, index);
         const after = text.slice(index + res[0].length);
         return [
-            ...(before.length > 0 ? parseForRules(rules.slice(1), before) : []),
-            activeRule.map(res, text => parseForRules(rules.slice(1), text)),
-            ...(after.length > 0 ? parseForRules(rules, after) : []),
+            ...(before.length > 0 ? parseForInlineRules(rules.slice(1), before) : []),
+            activeRule.map(res, text => parseForInlineRules(rules.slice(1), text)),
+            ...(after.length > 0 ? parseForInlineRules(rules, after) : []),
         ];
     }
     else {
-        return parseForRules(rules.slice(1), text);
+        return parseForInlineRules(rules.slice(1), text);
+    }
+};
+const parseInlineMarkdown = (text) => parseForInlineRules(inlineRules, text);
+const listRule = {
+    pattern: /^((?:(?:\d+\.|[-*]) [^\n]+?)(?:\n(?:\d+\.|[-*]) [^\n]+?)*)(?:\n{2,}|$)/,
+    map: result => ({
+        kind: "list",
+        ordered: /^\d+\. /.test(result[0]),
+        content: (result[1] ?? "").split("\n").map(item => ({
+            kind: "listitem",
+            content: parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, "")),
+        })),
+    }),
+};
+const paragraphRule = {
+    pattern: /^((?:[^\n]+?)(?:\n[^\n]+?)*)(?:\n{2,}|$)/,
+    map: result => ({ kind: "paragraph", content: parseInlineMarkdown(result[1] ?? "") }),
+};
+const blockRules = [listRule, paragraphRule];
+const parseForBlockRules = (rules, text, remainingRules = rules) => {
+    if (text.length === 0) {
+        return [];
+    }
+    const activeRule = remainingRules[0];
+    if (activeRule === undefined) {
+        return [{ kind: "paragraph", content: [{ kind: "text", content: text }] }];
+    }
+    const res = activeRule.pattern.exec(text);
+    if (res && (activeRule.predicate?.(res) ?? true)) {
+        const { index } = res;
+        const after = text.slice(index + res[0].length);
+        return [activeRule.map(res), ...(after.length > 0 ? parseForBlockRules(rules, after) : [])];
+    }
+    else {
+        return parseForBlockRules(rules, text, remainingRules.slice(1));
     }
 };
-const parseInlineMarkdown = (text) => parseForRules(rules, text);
+export const parseBlockMarkdown = (text) => parseForBlockRules(blockRules, text);

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

@@ -2,12 +2,13 @@ import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { sortObjectKeys } from "../../../shared/utils/object.js";
 import { toTitleCase } from "../../../shared/utils/string.js";
 import { validateObjectConstraints } from "../../../shared/validation/object.js";
+import { Markdown } from "../../utils/Markdown.js";
 import { createTypeSkeleton } from "../../utils/typeSkeleton.js";
 import { TypeInput } from "./TypeInput.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
 export const ObjectTypeInput = ({ type, value, instanceNamesByEntity, getDeclFromDeclName, onChange, }) => {
     const errors = validateObjectConstraints(type, Object.keys(type.properties), value);
-    return (_jsxs("div", { class: "field field--container field--object", children: [_jsx("ul", { children: Object.entries(type.properties).map(([key, memberDecl]) => (_jsxs("li", { class: "container-item object-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [_jsx("strong", { children: toTitleCase(key) }), memberDecl.comment === undefined ? null : (_jsx("p", { class: "comment", children: memberDecl.comment }))] }), memberDecl.isRequired ? null : value[key] === undefined ? (_jsx("button", { onClick: () => {
+    return (_jsxs("div", { class: "field field--container field--object", children: [_jsx("ul", { children: Object.entries(type.properties).map(([key, memberDecl]) => (_jsxs("li", { class: "container-item object-item", children: [_jsxs("div", { className: "container-item-header", children: [_jsxs("div", { className: "container-item-title", children: [_jsx("strong", { children: toTitleCase(key) }), memberDecl.comment === undefined ? null : (_jsx(Markdown, { class: "comment", string: memberDecl.comment }))] }), memberDecl.isRequired ? null : value[key] === undefined ? (_jsx("button", { onClick: () => {
                                         onChange(sortObjectKeys({
                                             ...value,
                                             [key]: createTypeSkeleton(getDeclFromDeclName, memberDecl.type),

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-runtime";
 import { validateStringConstraints } from "../../../shared/validation/string.js";
-import { Markdown } from "./utils/Markdown.js";
+import { Markdown } from "../../utils/Markdown.js";
 import { ValidationErrors } from "./utils/ValidationErrors.js";
 export const StringTypeInput = ({ type, value, onChange }) => {
     const { minLength, maxLength, pattern, isMarkdown } = type;

package/lib/web/routes/Entity.js

@@ -6,6 +6,7 @@ import { deleteInstanceByEntityNameAndId, getEntityByName, getInstancesByEntityN
 import { Layout } from "../components/Layout.js";
 import { useAPIResource } from "../hooks/useAPIResource.js";
 import { useMappedAPIResource } from "../hooks/useMappedAPIResource.js";
+import { Markdown } from "../utils/Markdown.js";
 import { NotFound } from "./NotFound.js";
 const mapInstances = (data) => data.instances;
 export const Entity = () => {
@@ -26,7 +27,7 @@ export const Entity = () => {
     if (!entity || !instances) {
         return (_jsxs("div", { children: [_jsx("h1", { children: name }), _jsx("p", { className: "loading", children: "Loading \u2026" })] }));
     }
-    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: "Home" }], children: [_jsxs("div", { class: "header-with-btns", children: [_jsx("h1", { children: name }), _jsx("a", { class: "btn btn--primary", href: `/entities/${entity.declaration.name}/instances/create`, children: "Add" })] }), entity.declaration.comment && _jsx("p", { className: "description", children: entity.declaration.comment }), _jsxs("p", { children: [instances.length, " instance", instances.length === 1 ? "" : "s"] }), _jsx("ul", { class: "instances", children: instances.map(instance => {
+    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: "Home" }], children: [_jsxs("div", { class: "header-with-btns", children: [_jsx("h1", { children: name }), _jsx("a", { class: "btn btn--primary", href: `/entities/${entity.declaration.name}/instances/create`, children: "Add" })] }), entity.declaration.comment && (_jsx(Markdown, { class: "description", string: entity.declaration.comment })), _jsxs("p", { children: [instances.length, " instance", instances.length === 1 ? "" : "s"] }), _jsx("ul", { class: "instances", children: instances.map(instance => {
                     const gitStatusForDisplay = getGitStatusForDisplay(instance.gitStatus);
                     return (_jsxs("li", { id: `instance-${instance.id}`, class: `instance-item ${created === instance.id ? "instance-item--created" : ""} ${gitStatusForDisplay === undefined ? "" : `git-status--${gitStatusForDisplay}`}`, children: [_jsx("h2", { children: instance.displayName }), _jsx("p", { "aria-hidden": true, class: "id", children: instance.id }), gitStatusForDisplay !== undefined && (_jsx("p", { class: `git-status git-status--${gitStatusForDisplay}`, title: getLabelForGitStatus(gitStatusForDisplay), children: gitStatusForDisplay })), _jsxs("div", { className: "btns", children: [_jsx("a", { href: `/entities/${entity.declaration.name}/instances/${instance.id}`, class: "btn", children: "Edit" }), _jsx("button", { class: "destructive", onClick: () => {
                                             if (confirm("Are you sure you want to delete this instance?")) {

package/lib/web/routes/Home.js

@@ -3,8 +3,9 @@ import { toTitleCase } from "../../shared/utils/string.js";
 import { getAllEntities } from "../api.js";
 import { Layout } from "../components/Layout.js";
 import { useMappedAPIResource } from "../hooks/useMappedAPIResource.js";
+import { Markdown } from "../utils/Markdown.js";
 const mapEntities = (data) => data.declarations.sort((a, b) => a.declaration.name.localeCompare(b.declaration.name));
 export const Home = () => {
     const [entities] = useMappedAPIResource(getAllEntities, mapEntities);
-    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: "Home" }], children: [_jsx("h1", { children: "Entities" }), _jsx("ul", { class: "entities", children: (entities ?? []).map(entity => (_jsxs("li", { class: "entity-item", children: [_jsxs("div", { className: "title", children: [_jsx("h2", { children: toTitleCase(entity.declaration.name) }), entity.declaration.comment && _jsx("p", { children: entity.declaration.comment })] }), _jsxs("p", { class: "meta", children: [entity.instanceCount, " instance", entity.instanceCount === 1 ? "" : "s"] }), _jsx("div", { className: "btns", children: _jsx("a", { href: `/entities/${entity.declaration.name}`, class: "btn", children: "View" }) })] }, entity.declaration.name))) })] }));
+    return (_jsxs(Layout, { breadcrumbs: [{ url: "/", label: "Home" }], children: [_jsx("h1", { children: "Entities" }), _jsx("ul", { class: "entities", children: (entities ?? []).map(entity => (_jsxs("li", { class: "entity-item", children: [_jsxs("div", { className: "title", children: [_jsx("h2", { children: toTitleCase(entity.declaration.name) }), entity.declaration.comment && (_jsx(Markdown, { class: "description", string: entity.declaration.comment }))] }), _jsxs("p", { class: "meta", children: [entity.instanceCount, " instance", entity.instanceCount === 1 ? "" : "s"] }), _jsx("div", { className: "btns", children: _jsx("a", { href: `/entities/${entity.declaration.name}`, class: "btn", children: "View" }) })] }, entity.declaration.name))) })] }));
 };

package/lib/web/{components/typeInputs/utils → utils}/Markdown.d.ts

@@ -1,5 +1,6 @@
 import type { FunctionalComponent } from "preact";
 type Props = {
+    class?: string;
     string: string;
 };
 export declare const Markdown: FunctionalComponent<Props>;

package/lib/web/utils/Markdown.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, Fragment as _Fragment } from "preact/jsx-runtime";
+import { parseBlockMarkdown } from "../../shared/utils/markdown.js";
+export const Markdown = ({ class: className, string }) => {
+    const blocks = parseBlockMarkdown(string);
+    const blockElements = blocks.map((block, i) => (_jsx(BlockMarkdown, { node: block }, `md-block-${i.toString()}`)));
+    if (className) {
+        return _jsx("div", { class: className, children: blockElements });
+    }
+    return _jsx(_Fragment, { children: blockElements });
+};
+const BlockMarkdown = ({ node }) => {
+    switch (node.kind) {
+        case "paragraph":
+            return (_jsx("p", { children: node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii))) }));
+        case "list":
+            if (node.ordered) {
+                return (_jsx("ol", { children: node.content.map((item, ii) => (_jsx("li", { children: item.content.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ii))) }));
+            }
+            else {
+                return (_jsx("ul", { children: node.content.map((item, ii) => (_jsx("li", { children: item.content.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ii))) }));
+            }
+        case "text":
+            return node.content;
+        default:
+            return null;
+    }
+};
+const InlineMarkdown = ({ node }) => {
+    switch (node.kind) {
+        case "code":
+            return _jsx("code", { children: node.content });
+        case "bold":
+            return (_jsx("strong", { children: node.content.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))) }));
+        case "italic":
+            return (_jsx("em", { children: node.content.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))) }));
+        case "text":
+            return node.content;
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.5.1",
+  "version": "0.5.3",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -32,12 +32,12 @@
     "release:sign": "commit-and-tag-version --sign --signoff"
   },
   "devDependencies": {
-    "@eslint/js": "^9.30.1",
+    "@eslint/js": "^9.31.0",
     "@types/debug": "^4.1.12",
     "@types/express": "^5.0.3",
-    "@types/node": "^24.0.12",
+    "@types/node": "^24.0.13",
     "commit-and-tag-version": "^12.5.1",
-    "eslint": "^9.30.1",
+    "eslint": "^9.31.0",
     "eslint-plugin-react": "^7.37.5",
     "eslint-plugin-react-hooks": "^5.2.0",
     "globals": "^16.3.0",

package/public/css/styles.css

@@ -15,7 +15,7 @@
   --separator-color: #e9e5eb;
   --secondary-color: #7e7f87;
   --tertiary-color: #bcbdc2;
-  --input-border-color: #black;
+  --input-border-color: black;
   --button-background: #c7cad0;
   --button-background-hover: #dedfe4;
   --button-background-primary: black;
@@ -436,29 +436,29 @@ form > .field--container {
   border: none;
 }
 
-.field--container ul,
-.field--container ol {
+.field--container > ul,
+.field--container > ol {
   margin: 0;
   padding: 0;
   list-style-type: " ";
 }
 
-.field--container ul li,
-.field--container ol li {
+.field--container > ul > li,
+.field--container > ol > li {
   padding-top: 0.5rem;
   padding-bottom: 0.75rem;
   border-top: 1px solid var(--separator-color);
   display: block;
 }
 
-.field--container ul li:first-child,
-.field--container ol li:first-child {
+.field--container > ul > li:first-child,
+.field--container > ol > li:first-child {
   padding-top: 0;
   border-top: none;
 }
 
-.field--container ul li:last-child,
-.field--container ol li:last-child {
+.field--container > ul > li:last-child,
+.field--container > ol > li:last-child {
   padding-bottom: 0;
 }
 
@@ -539,8 +539,20 @@ button[type="submit"] {
 
 .comment {
   font-size: 0.8rem;
+  line-height: 1.4;
   color: var(--secondary-color);
   margin: 0.5rem 0 0;
+  max-width: 55em;
+}
+
+.comment p {
+  margin: 0.35rem 0 0;
+}
+
+.comment ul {
+  list-style-type: disc;
+  padding-left: 1.5rem;
+  margin: 0.35rem 0 0;
 }
 
 .git-status {

package/lib/web/components/typeInputs/utils/Markdown.js

@@ -1,26 +0,0 @@
-import { jsx as _jsx } from "preact/jsx-runtime";
-import { parseBlockMarkdown } from "../../../../shared/utils/markdown.js";
-export const Markdown = ({ string }) => {
-    const blocks = parseBlockMarkdown(string);
-    return blocks.map((block, i) => _jsx(BlockMarkdown, { node: block }, `md-block-${i.toString()}`));
-};
-const BlockMarkdown = ({ node }) => {
-    switch (node.kind) {
-        case "paragraph":
-            return (_jsx("p", { children: node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii))) }));
-        case "text":
-            return node.content;
-        default:
-            return null;
-    }
-};
-const InlineMarkdown = ({ node }) => {
-    switch (node.kind) {
-        case "bold":
-            return (_jsx("strong", { children: node.content.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))) }));
-        case "italic":
-            return (_jsx("em", { children: node.content.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))) }));
-        case "text":
-            return node.content;
-    }
-};