tsondb 0.7.12 → 0.8.1

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

@@ -1,7 +1,7 @@
-import { type Decl } from "../index.ts";
+import { type Decl, type EnumDecl, type TypeAliasDecl, type TypeParameter } from "../index.ts";
 import type { BaseNode } from "../Node.ts";
 import type { ArrayType } from "./generic/ArrayType.ts";
-import type { EnumType } from "./generic/EnumType.ts";
+import type { EnumCaseDecl, EnumType } from "./generic/EnumType.ts";
 import type { MemberDecl, ObjectType } from "./generic/ObjectType.ts";
 import type { BooleanType } from "./primitives/BooleanType.ts";
 import type { DateType } from "./primitives/DateType.ts";
@@ -17,9 +17,23 @@ export interface BaseType extends BaseNode {
 }
 export type Type = BooleanType | DateType | FloatType | IntegerType | StringType | ArrayType | ObjectType | TypeArgumentType | ReferenceIdentifierType | IncludeIdentifierType | NestedEntityMapType | EnumType | ChildEntitiesType;
 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;
+} & {
+    [AV in Case]: AsType<T>;
+} : {
+    kind: Case;
+};
+export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
+} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsType<TA> : Decl extends EnumDecl<string, infer EC> ? AsType<EnumType<EC>> : unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+    [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
+}[keyof EC] : never : never;
 export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
     [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : never;
+} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+    [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
+}[keyof EC] : never : never;
 export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, unknown> ? ObjectType<{
     [K in keyof T]: T[K] extends MemberDecl ? T[K] : T extends null | undefined ? MemberDecl<AsNode<NonNullable<T[K]>>, false> : MemberDecl<AsNode<T[K]>, true>;
 }> : T extends string ? StringType : T extends number ? FloatType : T extends boolean ? BooleanType : T extends Date ? DateType : never;
@@ -31,3 +45,4 @@ export declare const findTypeAtPath: (type: Type, path: string[], options?: {
  */
 export type StructureFormatter<T extends Type> = (type: T, value: unknown) => unknown;
 export declare const formatValue: StructureFormatter<Type>;
+export {};

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

@@ -1,5 +1,5 @@
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
-import { isTypeAliasDecl } from "../index.js";
+import { isTypeAliasDecl, } from "../index.js";
 import { NodeKind } from "../Node.js";
 import { formatArrayValue, isArrayType } from "./generic/ArrayType.js";
 import { formatEnumType } from "./generic/EnumType.js";

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

@@ -2,13 +2,13 @@ import type { GetInstanceById } from "../../node/server/index.ts";
 import { type DisplayNameResult } from "../../shared/utils/displayName.ts";
 import type { InstanceContainer } from "../../shared/utils/instances.ts";
 import { type EntityDecl } from "../schema/declarations/EntityDecl.ts";
-import type { AsType, Type } from "../schema/types/Type.ts";
+import type { AsDeepType, Type } from "../schema/types/Type.ts";
 export type GetChildInstancesForInstanceId = (parentEntityName: string, parentId: string, childEntityName: string) => {
     id: string;
     content: unknown;
 }[];
 export type DisplayNameCustomizer<T extends Type> = (params: {
-    instance: AsType<T>;
+    instance: AsDeepType<T>;
     instanceId: string;
     instanceDisplayName: string;
     instanceDisplayNameLocaleId: string | undefined;

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

@@ -22,3 +22,10 @@ export declare const unique: <T>(arr: T[], equalityCheck?: (a: T, b: T) => boole
  * Moves an element from one position to another within the array.
  */
 export declare const reorder: <T>(arr: T[], sourceIndex: number, targetIndex: number) => T[];
+/**
+ * Splits an array into chunks of a specified size.
+ * @param arr The array to be chunked.
+ * @param size The size of each chunk.
+ * @returns An array of chunks, where each chunk is an array of elements. The last chunk may be smaller than the specified size if there are not enough elements left.
+ */
+export declare const chunk: <T>(arr: T[], size: number) => T[][];

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

@@ -59,3 +59,19 @@ export const reorder = (arr, sourceIndex, targetIndex) => {
         ...arr.slice(sourceIndex + 1),
     ];
 };
+/**
+ * Splits an array into chunks of a specified size.
+ * @param arr The array to be chunked.
+ * @param size The size of each chunk.
+ * @returns An array of chunks, where each chunk is an array of elements. The last chunk may be smaller than the specified size if there are not enough elements left.
+ */
+export const chunk = (arr, size) => {
+    if (size <= 0) {
+        throw new RangeError(`size must be a positive integer, got ${size.toString()}`);
+    }
+    return arr.reduce((chunks, item, index) => {
+        const chunkIndex = Math.floor(index / size);
+        (chunks[chunkIndex] ??= []).push(item);
+        return chunks;
+    }, []);
+};

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

@@ -24,45 +24,96 @@ type AttributedStringMarkdownNode = {
     attributes: Record<string, string | number | boolean>;
     content: InlineMarkdownNode[];
 };
-export type InlineMarkdownNode = BoldMarkdownNode | ItalicMarkdownNode | CodeMarkdownNode | LinkMarkdownNode | AttributedStringMarkdownNode | TextNode;
-type ParagraphBlockNode = {
+type FootnoteRefInlineNode = {
+    kind: "footnoteRef";
+    label: string;
+};
+export type InlineMarkdownNode = BoldMarkdownNode | ItalicMarkdownNode | CodeMarkdownNode | LinkMarkdownNode | AttributedStringMarkdownNode | TextNode | FootnoteRefInlineNode;
+export declare const checkTableRowsAreSections: (rows: TableRowBlockNode[] | TableSectionBlockNode[]) => rows is TableSectionBlockNode[];
+export declare const syntaxNodeToString: (node: BlockSyntaxMarkdownNode) => string;
+export type ParagraphBlockNode = {
     kind: "paragraph";
     content: InlineMarkdownNode[];
 };
-type HeadingBlockNode = {
+export type HeadingBlockNode = {
     kind: "heading";
     level: number;
     content: InlineMarkdownNode[];
 };
-type ListBlockNode = {
+export type ListBlockNode = {
     kind: "list";
     ordered: boolean;
     content: ListItemNode[];
 };
-type ListItemNode = {
-    kind: "listitem";
+export type ListItemNode = {
+    kind: "listItem";
     content: InlineMarkdownNode[];
 };
-type TableBlockNode = {
+export type TableBlockNode = {
     kind: "table";
     caption?: InlineMarkdownNode[];
-    header: InlineMarkdownNode[][];
-    rows: InlineMarkdownNode[][][];
+    header: TableCellBlockNode[];
+    rows: TableRowBlockNode[] | TableSectionBlockNode[];
+};
+export type TableSectionBlockNode = {
+    kind: "tableSection";
+    header?: TableCellBlockNode[];
+    rows: TableRowBlockNode[];
+};
+export type TableRowBlockNode = {
+    kind: "tableRow";
+    cells: TableCellBlockNode[];
+};
+export type TableCellBlockNode = {
+    kind: "tableCell";
+    colSpan?: number;
+    content: InlineMarkdownNode[];
+};
+export type SectionBlockNode = {
+    kind: "container";
+    name?: string;
+    content: BlockMarkdownNode[];
+};
+export type FootnoteBlockNode = {
+    kind: "footnote";
+    label: string;
+    content: BlockMarkdownNode[];
+};
+export type DefinitionListBlockNode = {
+    kind: "definitionList";
+    content: DefinitionListItemBlockNode[];
 };
-export type BlockMarkdownNode = ParagraphBlockNode | HeadingBlockNode | ListBlockNode | TableBlockNode;
+export type DefinitionListItemBlockNode = {
+    kind: "definitionListItem";
+    terms: InlineMarkdownNode[][];
+    definitions: BlockMarkdownNode[][];
+};
+export type BlockMarkdownNode = ParagraphBlockNode | HeadingBlockNode | ListBlockNode | TableBlockNode | SectionBlockNode | FootnoteBlockNode | DefinitionListBlockNode;
 type ListItemMarkerSyntaxNode = {
-    kind: "listitemmarker";
+    kind: "listItemMarker";
     content: string;
 };
 type TableMarkerSyntaxNode = {
-    kind: "tablemarker";
+    kind: "tableMarker";
     content: string;
 };
 type HeadingMarkerSyntaxNode = {
-    kind: "headingmarker";
+    kind: "headingMarker";
+    content: string;
+};
+type SectionMarkerSyntaxNode = {
+    kind: "sectionMarker";
+    content: string;
+};
+type FootnoteMarkerSyntaxNode = {
+    kind: "footnoteMarker";
+    content: string;
+};
+type DefinitionMarkerSyntaxNode = {
+    kind: "definitionMarker";
     content: string;
 };
-type SyntaxNode = ListItemMarkerSyntaxNode | TableMarkerSyntaxNode | HeadingMarkerSyntaxNode;
+type SyntaxNode = ListItemMarkerSyntaxNode | TableMarkerSyntaxNode | HeadingMarkerSyntaxNode | SectionMarkerSyntaxNode | FootnoteMarkerSyntaxNode | DefinitionMarkerSyntaxNode;
 export type BlockSyntaxMarkdownNode = InlineMarkdownNode | SyntaxNode;
 export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
 export declare const parseBlockMarkdownForSyntaxHighlighting: (text: string) => BlockSyntaxMarkdownNode[];

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

@@ -1,3 +1,4 @@
+import { chunk } from "./array.js";
 import { omitUndefinedKeys } from "./object.js";
 import { assertExhaustive } from "./typeSafety.js";
 const codeRule = {
@@ -12,7 +13,7 @@ const codeRule = {
     }),
 };
 const boldWithItalicRule = {
-    pattern: /(?<!\\)\*\*((.*?[^\\*])?\*(?!\*).*?[^\\*]\*.*?)(?<!\\)\*\*/,
+    pattern: /(?<!\\|\*\*.*)\*\*(([^\\*]*)?\*(?!\*).*?[^\\*]\*.*?)(?<!\\)\*\*/,
     map: (result, parseInside) => ({
         kind: "bold",
         content: parseInside(result[1] ?? ""),
@@ -23,7 +24,7 @@ const boldWithItalicRule = {
     }),
 };
 const italicWithBoldRule = {
-    pattern: /(?<![\\*])\*(?=\*\*|[^*])(.*?\*\*.*?\*\*.*?)(?<=[^\\*]|[^\\]\*\*)\*(?!\*)/,
+    pattern: /(?<![\\*]|[\\*]\*.*)\*(?=\*\*|[^*])([^*]*?\*\*[^*]*?\*\*[^*]*?)(?<=[^\\*]|[^\\]\*\*)\*(?!\*)/,
     map: (result, parseInside) => ({
         kind: "italic",
         content: parseInside(result[1] ?? ""),
@@ -149,6 +150,17 @@ const attributedRule = {
         };
     },
 };
+const footnoteRefRule = {
+    pattern: /(?<!\\)\[\^([a-zA-Z0-9*]+?)\]/,
+    map: ([_match, label = ""]) => ({
+        kind: "footnoteRef",
+        label,
+    }),
+    mapHighlighting: ([match]) => ({
+        kind: "footnoteRef",
+        label: match,
+    }),
+};
 const textNode = (content) => ({
     kind: "text",
     content: content,
@@ -173,6 +185,7 @@ const inlineRules = [
     italicWithBoldRule,
     boldRule,
     italicRule,
+    footnoteRefRule,
     textRule,
 ];
 const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
@@ -203,19 +216,19 @@ const nodesForTrailingWhitespace = (text) => {
     return trailingWhitespace.length === 0 ? [] : [textNode(trailingWhitespace)];
 };
 const listRule = {
-    pattern: /^((?:(?:\d+\.|[-*]) [^\n]+?)(?:\n(?:\d+\.|[-*]) [^\n]+?)*)(\n{2,}|$)/,
+    pattern: /^((?:(?:\d+\.|[-*]) [^\n]+?)(?:\n(?:\d+\.|[-*]) [^\n]+?)*)(\n{2,}|\s*$)/,
     map: result => ({
         kind: "list",
         ordered: /^\d+\. /.test(result[0]),
         content: (result[1] ?? "").split("\n").map(item => ({
-            kind: "listitem",
+            kind: "listItem",
             content: parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), false),
         })),
     }),
     mapHighlighting: result => [
         ...(result[1] ?? "").split("\n").flatMap((item, index, array) => [
             {
-                kind: "listitemmarker",
+                kind: "listItemMarker",
                 content: /^(\d+\. |[-*] )/.exec(item)?.[1] ?? "",
             },
             ...parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), true),
@@ -243,28 +256,111 @@ const headingRule = {
         content: parseInlineMarkdown(result[3] ?? "", false),
     }),
     mapHighlighting: result => [
-        { kind: "headingmarker", content: (result[1] ?? "") + (result[2] ?? "") },
+        { kind: "headingMarker", content: (result[1] ?? "") + (result[2] ?? "") },
         ...parseInlineMarkdown(result[3] ?? "", true),
         ...nodesForTrailingWhitespace(result[4]),
     ],
 };
-const removeSurroundingPipes = (text) => text.replace(/^\|/, "").replace(/\|$/, "");
 const tableMarker = (text) => ({
-    kind: "tablemarker",
+    kind: "tableMarker",
     content: text,
 });
+const sectionSeparatorPattern = /^\|? *-{3,} *(?:\| *-{3,} *)+\|?$|^\|? *={3,} *(?:\| *={3,} *)+\|?$/;
+const sectionWithHeaderSeparatorPattern = /^\|? *={3,} *(?:\| *={3,} *)+\|?$/;
+export const checkTableRowsAreSections = (rows) => rows.every(row => row.kind === "tableSection");
+const parseContentRow = (row) => row
+    .replace(/^\|/, "")
+    .split(/(\|+)/)
+    .reduce((acc, segment, index, arr) => {
+    if (index % 2 === 0 && segment.trim() !== "") {
+        const colSpan = arr[index + 1]?.length;
+        return [
+            ...acc,
+            omitUndefinedKeys({
+                kind: "tableCell",
+                colSpan: colSpan !== undefined && colSpan > 1 ? colSpan : undefined,
+                content: parseInlineMarkdown(segment.trim(), false),
+            }),
+        ];
+    }
+    return acc;
+}, []);
+const parseContentRowForSyntaxHighlighting = (row) => row.split(/(\|+)/).reduce((acc, segment, index) => {
+    if (index % 2 === 0) {
+        return [...acc, ...parseInlineMarkdown(segment, true)];
+    }
+    else {
+        return [...acc, tableMarker(segment)];
+    }
+}, []);
 const tableRule = {
-    pattern: /^(?:(\|#)(.+?)(#\|)\n)?(\|)?(.+?(?:(?<!\\)\|.+?)+)((?<!\\)\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|?.+?(?:(?<!\\)\|.+?)*(?<!\\)\|?)+)(\n{2,}|$)/,
+    pattern: /^(?:(\|#)(.+?)(#\|)\n)?(\|)?(.+?(?:(?<!\\)\|.+?)+)((?<!\\)\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|?.+?(?:(?<!\\)\|+.+?)*(?:(?<!\\)\|+)?)+)(\n{2,}|$)/,
     map: ([_res, _captionMarkerStart, caption, _captionMarkerEnd, _headerMarkerStart, headers, _headerMarkerEnd, _bodySeparators, body, _trailingWhitespace,]) => omitUndefinedKeys({
         kind: "table",
         caption: caption !== undefined ? parseInlineMarkdown(caption.trim(), false) : undefined,
-        header: headers?.split("|").map(th => parseInlineMarkdown(th.trim(), false)) ?? [],
+        header: headers ? parseContentRow(headers) : [],
         rows: body
             ?.split("\n")
-            .slice(1)
-            .map(tr => removeSurroundingPipes(tr)
-            .split("|")
-            .map(tc => parseInlineMarkdown(tc.trim(), false))) ?? [],
+            .slice(1) // leading newline due to regex
+            .reduce((accRows, row) => {
+            if (sectionSeparatorPattern.test(row)) {
+                const hasHeader = sectionWithHeaderSeparatorPattern.test(row);
+                const newSection = omitUndefinedKeys({
+                    kind: "tableSection",
+                    header: hasHeader ? [] : undefined,
+                    rows: [],
+                });
+                if (accRows[0] === undefined) {
+                    return [newSection];
+                }
+                if (checkTableRowsAreSections(accRows)) {
+                    return [...accRows, newSection];
+                }
+                return [{ kind: "tableSection", rows: accRows }, newSection];
+            }
+            const lastRow = accRows[accRows.length - 1];
+            const rowContent = parseContentRow(row);
+            if (lastRow === undefined) {
+                return [
+                    {
+                        kind: "tableRow",
+                        cells: rowContent,
+                    },
+                ];
+            }
+            if (checkTableRowsAreSections(accRows)) {
+                const lastSection = lastRow;
+                if (lastSection.header !== undefined && lastSection.header.length === 0) {
+                    return [
+                        ...accRows.slice(0, -1),
+                        {
+                            ...lastSection,
+                            header: rowContent,
+                        },
+                    ];
+                }
+                return [
+                    ...accRows.slice(0, -1),
+                    {
+                        ...lastSection,
+                        rows: [
+                            ...lastSection.rows,
+                            {
+                                kind: "tableRow",
+                                cells: rowContent,
+                            },
+                        ],
+                    },
+                ];
+            }
+            return [
+                ...accRows,
+                {
+                    kind: "tableRow",
+                    cells: rowContent,
+                },
+            ];
+        }, []) ?? [],
     }),
     mapHighlighting: ([_res, captionMarkerStart, caption, captionMarkerEnd, headerMarkerStart, headers, headerMarkerEnd, bodySeparators, body, trailingWhitespace,]) => [
         ...(caption !== undefined
@@ -281,22 +377,170 @@ const tableRule = {
             .flatMap((th, i) => i === 0
             ? parseInlineMarkdown(th, true)
             : [tableMarker("|"), ...parseInlineMarkdown(th, true)]) ?? []),
-        tableMarker((headerMarkerEnd ?? "") + "\n" + (bodySeparators ?? "")),
+        tableMarker(headerMarkerEnd ?? ""),
+        textNode("\n"),
+        tableMarker(bodySeparators ?? ""),
         ...(body
             ?.split("\n")
             .slice(1)
             .flatMap((tr) => [
             textNode("\n"),
-            ...tr
-                .split("|")
-                .flatMap((tc, i) => i === 0
-                ? parseInlineMarkdown(tc, true)
-                : [tableMarker("|"), ...parseInlineMarkdown(tc, true)]),
+            ...(sectionSeparatorPattern.test(tr)
+                ? [tableMarker(tr)]
+                : parseContentRowForSyntaxHighlighting(tr)),
         ]) ?? []),
         ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
-const blockRules = [headingRule, tableRule, listRule, paragraphRule];
+const containerRule = {
+    pattern: /^::: ([\w-_]+)?(\n+)(.+?)\n:::(\n{2,}|\s*$)/s,
+    map: ([_match, name, _leadingContentWhitespace, content, _trailingWhitespace,]) => ({
+        kind: "container",
+        name: name ?? undefined,
+        content: parseBlockMarkdown(content ?? ""),
+    }),
+    mapHighlighting: ([_match, name, leadingContentWhitespace = "", content, trailingWhitespace,]) => [
+        { kind: "sectionMarker", content: `::: ${name ?? ""}` },
+        textNode(leadingContentWhitespace),
+        ...parseBlockMarkdownForSyntaxHighlighting(content ?? ""),
+        textNode("\n"),
+        { kind: "sectionMarker", content: ":::" },
+        ...nodesForTrailingWhitespace(trailingWhitespace),
+    ],
+};
+const removeIndentation = (text) => text
+    .split("\n")
+    .map(line => line.replace(/^ {2}/, ""))
+    .join("\n");
+export const syntaxNodeToString = (node) => {
+    switch (node.kind) {
+        case "bold":
+        case "italic":
+        case "link":
+        case "attributed":
+            return node.content.map(syntaxNodeToString).join("");
+        case "text":
+        case "code":
+        case "listItemMarker":
+        case "tableMarker":
+        case "headingMarker":
+        case "sectionMarker":
+        case "footnoteMarker":
+        case "definitionMarker":
+            return node.content;
+        case "footnoteRef":
+            return node.label;
+        default:
+            return assertExhaustive(node);
+    }
+};
+const addIndentationToSyntax = (nodes, nextUpperNode) => nodes.reduce((accNodes, currentNode, index) => {
+    switch (currentNode.kind) {
+        case "bold":
+        case "italic":
+        case "link":
+        case "attributed":
+            return [
+                ...accNodes,
+                {
+                    ...currentNode,
+                    content: addIndentationToSyntax(currentNode.content, nodes[index + 1] ?? nextUpperNode),
+                },
+            ];
+        case "text":
+        case "code":
+        case "listItemMarker":
+        case "tableMarker":
+        case "headingMarker":
+        case "sectionMarker":
+        case "footnoteMarker":
+        case "definitionMarker": {
+            const nextNode = nodes[index + 1] ?? nextUpperNode;
+            const currentContent = currentNode.content.endsWith("\n") &&
+                nextNode &&
+                /^[^\n]*?\S+?/.test(syntaxNodeToString(nextNode))
+                ? currentNode.content + "  "
+                : currentNode.content;
+            return [
+                ...accNodes,
+                { ...currentNode, content: currentContent.replace(/\n([^\n]*?\S+?)/g, "\n  $1") },
+            ];
+        }
+        case "footnoteRef":
+            return [...accNodes, currentNode];
+        default:
+            return assertExhaustive(currentNode);
+    }
+}, []);
+const footnoteRule = {
+    pattern: /^\[\^([a-zA-Z0-9*]+?)\]: (.+?(?:\n(?: {2}.+)?)*)(\n{2,}|\s*$)/,
+    map: ([_match, label = "", content = "", _trailingWhitespace]) => ({
+        kind: "footnote",
+        label: label,
+        content: parseBlockMarkdown(removeIndentation(content)),
+    }),
+    mapHighlighting: ([_match, label = "", content = "", trailingWhitespace,]) => [
+        { kind: "footnoteMarker", content: `[^${label}]:` },
+        textNode(" "),
+        ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(content))),
+        ...nodesForTrailingWhitespace(trailingWhitespace),
+    ],
+};
+const definitionListItemSeparatorPattern = /(^.+?(?=\n:)|\n\n[^: ].*?(?=\n:))/s;
+const definitionListRule = {
+    pattern: /((?:[^\n]+?(?:\n[^\n]+?)*)(?:\n: .+?(?:\n {2}.+?)*)+(?:\n\n(?:[^\n]+?(?:\n[^\n]+?)*)(?:\n: .+?(?:\n(?=\n)|\n {2}.+?)*))*)(\n{2,}|\s*$)/,
+    map: ([_res, content = "", _trailingWhitespace]) => {
+        const definitionItemPairs = chunk(content.split(definitionListItemSeparatorPattern).slice(1), 2);
+        const items = definitionItemPairs.map(([termsText = "", definitionsText = ""]) => {
+            const terms = termsText
+                .trim()
+                .split("\n")
+                .map(term => parseInlineMarkdown(term.trim(), false));
+            const definitions = definitionsText
+                .split("\n:")
+                .slice(1)
+                .map(definition => parseBlockMarkdown(removeIndentation(definition.trim())));
+            return {
+                kind: "definitionListItem",
+                terms,
+                definitions,
+            };
+        });
+        return {
+            kind: "definitionList",
+            content: items,
+        };
+    },
+    mapHighlighting: ([_res, content = "", trailingWhitespace]) => {
+        const items = chunk(content.split(definitionListItemSeparatorPattern).slice(1), 2).flatMap(([termsText = "", definitionsText = ""]) => {
+            const terms = termsText
+                .split("\n")
+                .flatMap((term, index, termArray) => [
+                ...parseInlineMarkdown(term, true),
+                ...(index < termArray.length - 1 ? [textNode("\n")] : []),
+            ]);
+            const definitions = definitionsText
+                .split("\n:")
+                .slice(1)
+                .flatMap((definition, defIndex, defArray) => [
+                { kind: "definitionMarker", content: ":" },
+                ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(definition))),
+                ...(defIndex < defArray.length - 1 ? [textNode("\n")] : []),
+            ]);
+            return [...terms, textNode("\n"), ...definitions];
+        });
+        return [...items, ...nodesForTrailingWhitespace(trailingWhitespace)];
+    },
+};
+const blockRules = [
+    containerRule,
+    headingRule,
+    footnoteRule,
+    tableRule,
+    listRule,
+    definitionListRule,
+    paragraphRule,
+];
 const parseActiveBlockRule = (rule, res) => [
     rule.map(res),
 ];
@@ -336,14 +580,18 @@ const reduceSyntaxNode = (node) => {
     switch (node.kind) {
         case "bold":
         case "italic":
+        case "link":
             return { ...node, content: reduceSyntaxNodes(node.content) };
         case "code":
-        case "link":
         case "attributed":
         case "text":
-        case "listitemmarker":
-        case "tablemarker":
-        case "headingmarker":
+        case "listItemMarker":
+        case "tableMarker":
+        case "headingMarker":
+        case "sectionMarker":
+        case "footnoteMarker":
+        case "footnoteRef":
+        case "definitionMarker":
             return node;
         default:
             return assertExhaustive(node);
@@ -354,9 +602,13 @@ const syntaxNodeMergeRules = {
     italic: (a, b) => ({ ...a, content: [...a.content, ...b.content] }),
     code: (a, b) => ({ ...a, content: a.content + b.content }),
     text: (a, b) => ({ ...a, content: a.content + b.content }),
-    listitemmarker: (a, b) => ({ ...a, content: a.content + b.content }),
-    tablemarker: (a, b) => ({ ...a, content: a.content + b.content }),
-    headingmarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    listItemMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    tableMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    headingMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    sectionMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    footnoteMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    definitionMarker: (a, b) => ({ ...a, content: a.content + b.content }),
+    footnoteRef: null,
     link: null,
     attributed: null,
 };

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

@@ -1,6 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { useLocation, useRoute } from "preact-iso";
-import { useCallback, useContext, useEffect, useState } from "preact/hooks";
+import { useCallback, useContext, useEffect, useMemo, useState } from "preact/hooks";
 import { removeAt } from "../../shared/utils/array.js";
 import { deepEqual } from "../../shared/utils/compare.js";
 import { getSerializedDisplayNameFromEntityInstance } from "../../shared/utils/displayName.js";
@@ -37,17 +37,18 @@ export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSub
     const [customId, setCustomId] = useState("");
     const client = useContext(GitClientContext);
     const { route } = useLocation();
+    const hasUnsavedChanges = useMemo(() => !deepEqual(instanceContent, savedInstanceContent), [instanceContent, savedInstanceContent]);
     useEffect(() => {
-        if (deepEqual(instanceContent, savedInstanceContent)) {
-            window.removeEventListener("beforeunload", onBeforeUnload);
+        if (hasUnsavedChanges) {
+            window.addEventListener("beforeunload", onBeforeUnload);
         }
         else {
-            window.addEventListener("beforeunload", onBeforeUnload);
+            window.removeEventListener("beforeunload", onBeforeUnload);
         }
         return () => {
             window.removeEventListener("beforeunload", onBeforeUnload);
         };
-    }, [instanceContent, savedInstanceContent]);
+    }, [hasUnsavedChanges]);
     useEffect(() => {
         document.title =
             (entity && titleBuilder({ locales, entity, instanceContent, instanceId: id })) ??
@@ -147,5 +148,5 @@ export const InstanceRouteSkeleton = ({ mode, buttons, init, titleBuilder, onSub
                             }
                         }, children: "Delete" }))] }), !id && isLocaleEntity && (_jsxs("div", { class: "field field--id", children: [_jsx("label", { htmlFor: "id", children: "ID" }), _jsx("p", { className: "comment", children: "The instance\u2019s identifier. An IETF language tag (BCP47)." }), _jsx("input", { type: "text", id: "id", value: customId, required: true, pattern: "[a-z]{2,3}(-[A-Z]{2,3})?", placeholder: "en-US, de-DE, \u2026", onInput: event => {
                             setCustomId(event.currentTarget.value);
-                        }, "aria-invalid": idErrors.length > 0 }), _jsx(ValidationErrors, { errors: idErrors })] })), _jsxs("form", { onSubmit: handleSubmit, children: [_jsx(TypeInput, { type: entity.type, value: instanceContent, path: undefined, instanceNamesByEntity: instanceNamesByEntity, childInstances: childInstances, getDeclFromDeclName: getDeclFromDeclName, onChange: setInstanceContent, onChildChange: handleOnChildChange, onChildAdd: handleOnChildAdd, onChildRemove: handleOnChildRemove, checkIsLocaleEntity: checkIsLocaleEntity }), _jsx("div", { class: "form-footer btns", children: buttons.map(button => (_jsx("button", { type: "submit", name: button.name, class: button.primary ? "primary" : undefined, children: button.label }, button.name))) })] })] }));
+                        }, "aria-invalid": idErrors.length > 0 }), _jsx(ValidationErrors, { errors: idErrors })] })), _jsxs("form", { onSubmit: handleSubmit, children: [_jsx(TypeInput, { type: entity.type, value: instanceContent, path: undefined, instanceNamesByEntity: instanceNamesByEntity, childInstances: childInstances, getDeclFromDeclName: getDeclFromDeclName, onChange: setInstanceContent, onChildChange: handleOnChildChange, onChildAdd: handleOnChildAdd, onChildRemove: handleOnChildRemove, checkIsLocaleEntity: checkIsLocaleEntity }), _jsx("div", { class: "form-footer btns", children: buttons.map(button => (_jsx("button", { type: "submit", name: button.name, class: button.primary ? "primary" : undefined, disabled: !hasUnsavedChanges, children: button.label }, button.name))) })] })] }));
 };

package/dist/src/web/routes/CreateInstance.js

@@ -24,6 +24,7 @@ const onSubmit = async ({ locales, entity, buttonName, instanceContent, isLocale
             switch (buttonName) {
                 case "saveandcontinue": {
                     route(`/entities/${entity.name}/instances/${createdInstance.instance.id}`);
+                    setInstanceContent(createdInstance.instance.content);
                     break;
                 }
                 case "saveandaddanother": {

package/dist/src/web/routes/Instance.js

@@ -21,7 +21,7 @@ const titleBuilder = ({ locales, entity, instanceId, instanceContent, }) => {
     }
     return undefined;
 };
-const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonName, childInstances, route, updateLocalGitState, }) => {
+const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonName, childInstances, route, updateLocalGitState, setInstanceContent, }) => {
     try {
         if (instanceId && buttonName) {
             await updateInstanceByEntityNameAndId(locales, entity.name, instanceId, {
@@ -33,6 +33,7 @@ const onSubmit = async ({ locales, entity, instanceId, instanceContent, buttonNa
             await updateLocalGitState?.();
             switch (buttonName) {
                 case "saveandcontinue": {
+                    setInstanceContent(instanceContent);
                     break;
                 }
                 case "save": {

package/dist/src/web/utils/BlockMarkdown.d.ts

@@ -1,8 +1,9 @@
 import type { FunctionalComponent } from "preact";
-import type { BlockMarkdownNode } from "../../shared/utils/markdown.ts";
+import { type BlockMarkdownNode } from "../../shared/utils/markdown.ts";
 type Props = {
     node: BlockMarkdownNode;
     outerHeadingLevel?: number;
+    insertBefore?: preact.ComponentChildren;
 };
 export declare const BlockMarkdown: FunctionalComponent<Props>;
 export {};

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

@@ -1,22 +1,36 @@
-import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "preact/jsx-runtime";
+import { checkTableRowsAreSections, } from "../../shared/utils/markdown.js";
+import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 import { InlineMarkdown } from "./InlineMarkdown.js";
-export const BlockMarkdown = ({ node, outerHeadingLevel = 0 }) => {
+export const BlockMarkdown = ({ node, outerHeadingLevel = 0, insertBefore, }) => {
     switch (node.kind) {
         case "paragraph":
-            return (_jsx("p", { children: node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii))) }));
+            return (_jsxs("p", { children: [insertBefore, node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii)))] }));
         case "heading":
             const Tag = `h${(node.level + outerHeadingLevel).toString()}`;
-            return (_jsx(Tag, { children: node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii))) }));
+            return (_jsxs(Tag, { children: [insertBefore, 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))) }));
+                return (_jsxs(_Fragment, { children: [insertBefore, _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))) }));
+                return (_jsxs(_Fragment, { children: [insertBefore, _jsx("ul", { children: node.content.map((item, ii) => (_jsx("li", { children: item.content.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ii))) })] }));
             }
         case "table":
-            return (_jsxs("table", { children: [node.caption !== undefined && (_jsx("caption", { children: node.caption.map((inline, ci) => (_jsx(InlineMarkdown, { node: inline }, ci))) })), _jsx("thead", { children: _jsx("tr", { children: node.header.map((th, hi) => (_jsx("th", { children: th.map((inline, hii) => (_jsx(InlineMarkdown, { node: inline }, hii))) }, hi))) }) }), _jsx("tbody", { children: node.rows.map((tr, ri) => (_jsx("tr", { children: tr.map((tc, ci) => (_jsx("td", { children: tc.map((inline, cii) => (_jsx(InlineMarkdown, { node: inline }, cii))) }, ci))) }, ri))) })] }));
+            return (_jsxs(_Fragment, { children: [insertBefore, _jsxs("table", { children: [node.caption !== undefined && (_jsx("caption", { children: node.caption.map((inline, ci) => (_jsx(InlineMarkdown, { node: inline }, ci))) })), _jsx("thead", { children: _jsx(TableRow, { cells: node.header, cellType: "th" }) }), checkTableRowsAreSections(node.rows) ? (node.rows.map((section, si) => (_jsxs("tbody", { children: [section.header && _jsx(TableRow, { cells: section.header, cellType: "th" }), section.rows.map((row, ri) => (_jsx(TableRow, { cells: row.cells }, ri)))] }, si)))) : (_jsx("tbody", { children: node.rows.map((row, ri) => (_jsx(TableRow, { cells: row.cells }, ri))) }))] })] }));
+        case "container":
+            return (_jsxs("div", { class: node.name, children: [insertBefore, node.content.map((childNode, i) => (_jsx(BlockMarkdown, { node: childNode, outerHeadingLevel: outerHeadingLevel }, i)))] }));
+        case "footnote": {
+            const label = (_jsxs(_Fragment, { children: [_jsxs("span", { class: "footnote-label", children: [node.label, /^\*+$/.test(node.label) ? ")" : ":"] }), " "] }));
+            return (_jsxs("div", { role: "note", children: [insertBefore, node.content.map((n, i) => (_jsx(BlockMarkdown, { node: n, outerHeadingLevel: outerHeadingLevel, insertBefore: label }, i)))] }));
+        }
+        case "definitionList":
+            return (_jsxs(_Fragment, { children: [insertBefore, _jsx("dl", { children: node.content.map((item, ii) => (_jsxs("div", { children: [item.terms.map((term, ti) => (_jsx("dt", { children: term.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii))) }, ti))), item.definitions.map((definition, di) => (_jsx("dd", { children: definition.map((n, i) => (_jsx(BlockMarkdown, { node: n, outerHeadingLevel: outerHeadingLevel }, i))) }, di)))] }, ii))) })] }));
         default:
-            return null;
+            return assertExhaustive(node);
     }
 };
+const TableRow = ({ cells, cellType = "td", }) => {
+    const CellTag = cellType;
+    return (_jsx("tr", { children: cells.map((tc, ci) => (_jsx(CellTag, { scope: cellType === "th" && cells.length === 1 ? "colgroup" : undefined, colSpan: tc.colSpan, children: tc.content.map((inline, cii) => (_jsx(InlineMarkdown, { node: inline }, cii))) }, ci))) }));
+};

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

@@ -2,12 +2,20 @@ import { jsx as _jsx } from "preact/jsx-runtime";
 import { InlineMarkdown } from "./InlineMarkdown.js";
 export const BlockMarkdownHighlighting = ({ node }) => {
     switch (node.kind) {
-        case "listitemmarker":
+        case "listItemMarker":
             return _jsx("span", { class: "list-item-marker", children: node.content });
-        case "tablemarker":
+        case "tableMarker":
             return _jsx("span", { class: "table-marker", children: node.content });
-        case "headingmarker":
+        case "headingMarker":
             return _jsx("span", { class: "heading-marker", children: node.content });
+        case "sectionMarker":
+            return _jsx("span", { class: "section-marker", children: node.content });
+        case "footnoteMarker":
+            return _jsx("span", { class: "footnote-marker", children: node.content });
+        case "footnoteRef":
+            return _jsx("span", { class: "footnote-marker", children: node.label });
+        case "definitionMarker":
+            return _jsx("span", { class: "definition-description-marker", children: node.content });
         default:
             return _jsx(InlineMarkdown, { node: node });
     }

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

@@ -1,5 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { Fragment } from "preact";
+import { assertExhaustive } from "../../shared/utils/typeSafety.js";
 const emptyNode = { kind: "text", content: "" };
 export const InlineMarkdown = ({ node }) => {
     switch (node.kind) {
@@ -21,7 +22,11 @@ export const InlineMarkdown = ({ node }) => {
             const trailingNodes = node.content.slice(attributesEnd);
             return (_jsxs("span", { class: "attributed", ...Object.fromEntries(Object.entries(node.attributes).map(([k, v]) => [`data-${k}`, v.toString()])), children: [leadingNodes.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i))), Array.from({ length: count }, (_, i) => (_jsxs(Fragment, { children: [_jsx("span", { class: "attributed__name", children: _jsx(InlineMarkdown, { node: attributes[i * 4] ?? emptyNode }) }), _jsx("span", { class: "attributed__separator", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 1] ?? emptyNode }) }), _jsx("span", { class: "attributed__value", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 2] ?? emptyNode }) }), i < count - 1 && (_jsx("span", { class: "attributed__separator", children: _jsx(InlineMarkdown, { node: attributes[i * 4 + 3] ?? emptyNode }) }))] }, `attr-${(i + 1).toString()}`))), trailingNodes.map((inline, i) => (_jsx(InlineMarkdown, { node: inline }, i)))] }));
         }
+        case "footnoteRef":
+            return /^\*+$/.test(node.label) ? (_jsx("span", { class: "footnote-ref", children: node.label })) : (_jsx("sup", { class: "footnote-ref", children: node.label }));
         case "text":
             return node.content;
+        default:
+            return assertExhaustive(node);
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.7.12",
+  "version": "0.8.1",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",

package/public/css/styles.css

@@ -63,6 +63,8 @@
   --color-syntax-table-marker: rgb(237, 58, 118);
   --color-syntax-attributed: rgb(48, 81, 228);
   --color-syntax-heading-marker: rgb(62, 189, 191);
+  --color-syntax-footnote: rgb(48, 126, 228);
+  --color-syntax-section: rgb(172, 147, 3);
 }
 
 @media (prefers-color-scheme: dark) {
@@ -105,6 +107,8 @@
     --color-syntax-table-marker: rgb(244, 135, 171);
     --color-syntax-attributed: rgb(137, 157, 244);
     --color-syntax-heading-marker: rgb(140, 229, 231);
+  --color-syntax-footnote: rgb(157, 199, 255);
+  --color-syntax-section: rgb(247, 231, 135);
   }
 }
 
@@ -704,6 +708,7 @@ form > .field--container {
 .editor--markdown input,
 .editor--markdown .textarea-grow-wrap__mirror {
   font-family: var(--font-mono);
+  line-height: 1.5;
 }
 
 .editor--markdown textarea {
@@ -720,7 +725,7 @@ form > .field--container {
   color: var(--color-syntax-italic);
 }
 
-.editor-highlighting .list-item-marker {
+.editor-highlighting :is(.list-item-marker, .definition-description-marker) {
   color: var(--color-syntax-list-item-marker);
 }
 
@@ -732,6 +737,14 @@ form > .field--container {
   color: var(--color-syntax-heading-marker);
 }
 
+.editor-highlighting .footnote-marker {
+  color: var(--color-syntax-footnote);
+}
+
+.editor-highlighting .section-marker {
+  color: var(--color-syntax-section);
+}
+
 .preview .attributed {
   text-decoration-line: underline;
   text-decoration-style: dashed;