tsondb 0.11.2 → 0.11.4

package/dist/src/bin/tsondb.js

@@ -13,6 +13,7 @@ import { join } from "node:path";
 import { cwd } from "node:process";
 import { pathToFileURL } from "node:url";
 import { parseArguments } from "simple-cli-args";
+import { validateConfigForFormatting, validateConfigForGeneration, validateConfigForServer, validateConfigForTesting, } from "../node/config.js";
 import { format, generateOutputs, serve, validate } from "../node/index.js";
 const debug = Debug("tsondb:cli");
 const passedArguments = parseArguments({
@@ -80,14 +81,17 @@ if (passedArguments.command === undefined) {
 switch (passedArguments.command.name) {
     case "generate":
         debug(`running command: generate`);
+        validateConfigForGeneration(config);
         await generateOutputs(config.schema, config.outputs);
         break;
     case "serve":
         debug(`running command: serve`);
+        validateConfigForServer(config);
         await serve(config.schema, config.dataRootPath, config.defaultLocales, config.homeLayoutSections, config.serverOptions, config.customStylesheetPath);
         break;
     case "validate":
         debug(`running command: validate`);
+        validateConfigForTesting(config);
         if (passedArguments.command.options?.checkReferentialIntegrity !== undefined) {
             debug(`check referential integrity: ${passedArguments.command.options.checkReferentialIntegrity ? "yes" : "no"}`);
         }
@@ -102,6 +106,7 @@ switch (passedArguments.command.name) {
         break;
     case "format":
         debug(`running command: format`);
+        validateConfigForFormatting(config);
         await format(config.schema, config.dataRootPath);
         break;
 }

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

@@ -1,12 +1,15 @@
 import type { Output } from "../shared/output.ts";
 import type { EntityDecl } from "./schema/index.ts";
 import type { Schema } from "./schema/Schema.ts";
+/**
+ * The main configuration type for TSONDB.
+ */
 export type Config = {
     serverOptions?: ServerOptions;
     schema: Schema;
-    outputs: Output[];
-    defaultLocales: string[];
-    dataRootPath: string;
+    outputs?: Output[];
+    defaultLocales?: string[];
+    dataRootPath?: string;
     homeLayoutSections?: HomeLayoutSection[];
     customStylesheetPath?: string;
 };
@@ -18,4 +21,30 @@ export type HomeLayoutSection = {
     comment?: string;
     entities: EntityDecl[];
 };
-export declare const validateConfig: (config: Config) => void;
+/**
+ * The configuration type required for generation commands.
+ */
+export type GenerationConfig = {
+    schema: Schema;
+    outputs: Output[];
+};
+export declare const validateConfigForGeneration: (config: Config) => asserts config is GenerationConfig;
+/**
+ * The configuration type required for any commands that need to read data stored in the database.
+ */
+export type DataConfig = {
+    schema: Schema;
+    dataRootPath: string;
+};
+/**
+ * The configuration type required for running the server for the editor.
+ */
+export type ServerConfig = DataConfig & {
+    serverOptions?: ServerOptions;
+    defaultLocales: string[];
+    homeLayoutSections?: HomeLayoutSection[];
+    customStylesheetPath?: string;
+};
+export declare const validateConfigForServer: (config: Config) => asserts config is ServerConfig;
+export declare const validateConfigForTesting: (config: Config) => asserts config is DataConfig;
+export declare const validateConfigForFormatting: (config: Config) => asserts config is DataConfig;

package/dist/src/node/config.js

@@ -1,5 +1,23 @@
-export const validateConfig = (config) => {
-    if (config.defaultLocales.length === 0) {
+export const validateConfigForGeneration = config => {
+    if ((config.outputs?.length ?? 0) === 0) {
+        throw new Error("At least one output must be specified in the config.");
+    }
+};
+export const validateConfigForServer = config => {
+    if ((config.defaultLocales?.length ?? 0) === 0) {
         throw new Error("At least one default locale must be specified in the config.");
     }
+    if (config.dataRootPath === undefined) {
+        throw new Error("A data root path must be specified in the config.");
+    }
+};
+export const validateConfigForTesting = config => {
+    if (config.dataRootPath === undefined) {
+        throw new Error("A data root path must be specified in the config.");
+    }
+};
+export const validateConfigForFormatting = config => {
+    if (config.dataRootPath === undefined) {
+        throw new Error("A data root path must be specified in the config.");
+    }
 };

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

@@ -228,6 +228,7 @@ gitApi.post("/pull", async (req, res) => {
         const status = await req.git.status();
         const remotes = await req.git.getRemotes();
         await req.git.pull(remotes[0]?.name, status.current ?? undefined);
+        await reinit(req);
         res.set("Content-Type", "text/plain");
         res.status(200).send("Pull successful");
     }

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

@@ -0,0 +1,2 @@
+export declare const detectIndentation: (text: string, excludeFirstLineForDetection?: boolean) => number;
+export declare const removeIndentation: (text: string, excludeFirstLineForDetection?: boolean, fixedIndentation?: number) => string;

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

@@ -0,0 +1,14 @@
+const emptyLinePattern = /^ *$$/;
+export const detectIndentation = (text, excludeFirstLineForDetection) => {
+    const nonEmptyLines = text.split("\n").filter(line => !emptyLinePattern.test(line));
+    return nonEmptyLines[excludeFirstLineForDetection ? 1 : 0]?.match(/^ +/)?.[0].length ?? 0;
+};
+const mapLines = (text, lineMapper) => text.split("\n").map(lineMapper).join("\n");
+export const removeIndentation = (text, excludeFirstLineForDetection, fixedIndentation) => {
+    const indentation = fixedIndentation ?? detectIndentation(text, excludeFirstLineForDetection);
+    if (indentation < 1) {
+        return text;
+    }
+    const regex = new RegExp(`^ {${indentation.toString()}}`);
+    return mapLines(text, line => line.replace(regex, ""));
+};

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

@@ -53,7 +53,8 @@ export type ListBlockNode = {
 };
 export type ListItemNode = {
     kind: "listItem";
-    content: InlineMarkdownNode[];
+    inlineLabel?: InlineMarkdownNode[];
+    content: BlockMarkdownNode[];
 };
 export type TableBlockNode = {
     kind: "table";

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

@@ -1,4 +1,5 @@
 import { chunk } from "./array.js";
+import { detectIndentation, removeIndentation } from "./markdown/indentation.js";
 import { omitUndefinedKeys } from "./object.js";
 import { assertExhaustive } from "./typeSafety.js";
 const codeRule = {
@@ -229,26 +230,56 @@ const nodesForTrailingWhitespace = (text) => {
     return trailingWhitespace.length === 0 ? [] : [textNode(trailingWhitespace)];
 };
 const listRule = {
-    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",
-            content: parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, "")),
-        })),
-    }),
-    mapHighlighting: result => [
-        ...(result[1] ?? "").split("\n").flatMap((item, index, array) => [
-            {
-                kind: "listItemMarker",
-                content: /^(\d+\. |[-*] )/.exec(item)?.[1] ?? "",
-            },
-            ...parseInlineMarkdownForSyntaxHighlighting(item.replace(/^\d+\. |[-*] /, "")),
-            ...(index < array.length - 1 ? [textNode("\n")] : []),
-        ]),
-        ...nodesForTrailingWhitespace(result[2]),
-    ],
+    // pattern: /^((?:(?:\d+\.|[-*]) [^\n]+?)(?:\n(?:\d+\.|[-*]) [^\n]+?)*)(\n{2,}|\s*$)/,
+    pattern: /^((?:(?:\d+\. +[^\n]+(?:\n\d+\. +[^\n]+|\n {2,}[^\n]+|\n)*)|(?:- +[^\n]+(?:\n- +[^\n]+|\n {2,}[^\n]+|\n)*)))(\n{2,}|\s*$)/,
+    map: result => {
+        const listItemPairs = (result[1] ?? "").split(/(?:^|\n)(?:\d+\.|-)/).slice(1);
+        const listItems = listItemPairs.map((itemText) => {
+            const [primaryContent = "", _separator, ...additionalContents] = itemText.split(/(\n *\n|\n(?= +(?:\d+\.|-) ))/);
+            const additionalContent = additionalContents.join("");
+            const primaryContentNodes = parseInlineMarkdown(primaryContent.trim());
+            const additionalContentNodes = additionalContent
+                ? parseBlockMarkdown(removeIndentation(additionalContent))
+                : [];
+            if (additionalContentNodes.length < 2 &&
+                (additionalContentNodes[0] === undefined || additionalContentNodes[0].kind === "list")) {
+                return omitUndefinedKeys({
+                    kind: "listItem",
+                    inlineLabel: primaryContentNodes,
+                    content: [additionalContentNodes[0]].filter(element => element !== undefined),
+                });
+            }
+            else {
+                return omitUndefinedKeys({
+                    kind: "listItem",
+                    content: additionalContentNodes,
+                });
+            }
+        });
+        return {
+            kind: "list",
+            ordered: /^\d+\. /.test(result[0]),
+            content: listItems,
+        };
+    },
+    mapHighlighting: result => {
+        const listItemPairs = chunk((result[1] ?? "").split(/(?:^|\n)(\d+\.|-)/).slice(1), 2);
+        const listItems = listItemPairs.flatMap(([marker = "", itemText = ""], itemIndex, itemArray) => {
+            const [primaryContent = "", separator, ...additionalContents] = itemText.split(/(\n *\n|\n(?= +(?:\d+\.|-) ))/);
+            const additionalContent = additionalContents.join("");
+            return [
+                {
+                    kind: "listItemMarker",
+                    content: marker,
+                },
+                ...parseInlineMarkdownForSyntaxHighlighting(primaryContent),
+                ...(separator ? [textNode(separator)] : []),
+                ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(additionalContent)), detectIndentation(additionalContent)),
+                ...(itemIndex < itemArray.length - 1 ? [textNode("\n")] : []),
+            ];
+        });
+        return [...listItems, ...nodesForTrailingWhitespace(result[2])];
+    },
 };
 const paragraphRule = {
     pattern: /^((?:[^\n]+?)(?:\n[^\n]+?)*)(\n{2,}|\s*$)/,
@@ -444,10 +475,6 @@ const containerRule = {
         ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
-const removeIndentation = (text) => text
-    .split("\n")
-    .map(line => line.replace(/^ {2}/, ""))
-    .join("\n");
 export const syntaxNodeToString = (node) => {
     switch (node.kind) {
         case "bold":
@@ -471,7 +498,7 @@ export const syntaxNodeToString = (node) => {
             return assertExhaustive(node);
     }
 };
-const addIndentationToSyntax = (nodes, nextUpperNode) => nodes.reduce((accNodes, currentNode, index) => {
+const addIndentationToSyntax = (nodes, indentation, excludeFirstLine = false) => nodes.reduce((accNodes, currentNode) => {
     switch (currentNode.kind) {
         case "bold":
         case "italic":
@@ -482,7 +509,7 @@ const addIndentationToSyntax = (nodes, nextUpperNode) => nodes.reduce((accNodes,
                 ...accNodes,
                 {
                     ...currentNode,
-                    content: addIndentationToSyntax(currentNode.content, nodes[index + 1] ?? nextUpperNode),
+                    content: addIndentationToSyntax(currentNode.content, indentation, excludeFirstLine),
                 },
             ];
         case "text":
@@ -493,15 +520,12 @@ const addIndentationToSyntax = (nodes, nextUpperNode) => nodes.reduce((accNodes,
         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") },
+                {
+                    ...currentNode,
+                    content: currentNode.content.replace(/\n(?!\n)/g, "\n" + " ".repeat(indentation)),
+                },
             ];
         }
         case "footnoteRef":
@@ -509,18 +533,18 @@ const addIndentationToSyntax = (nodes, nextUpperNode) => nodes.reduce((accNodes,
         default:
             return assertExhaustive(currentNode);
     }
-}, []);
+}, excludeFirstLine ? [] : [textNode(" ".repeat(indentation))]);
 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)),
+        content: parseBlockMarkdown(removeIndentation(content, true)),
     }),
     mapHighlighting: ([_match, label = "", content = "", trailingWhitespace,]) => [
         { kind: "footnoteMarker", content: `[^${label}]:` },
         textNode(" "),
-        ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(content))),
+        ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(content, true)), detectIndentation(content, true), true),
         ...nodesForTrailingWhitespace(trailingWhitespace),
     ],
 };
@@ -537,7 +561,7 @@ const definitionListRule = {
             const definitions = definitionsText
                 .split("\n:")
                 .slice(1)
-                .map(definition => parseBlockMarkdown(removeIndentation(definition.trim())));
+                .map(definition => parseBlockMarkdown(removeIndentation(definition.trim(), true)));
             return {
                 kind: "definitionListItem",
                 terms,
@@ -562,7 +586,7 @@ const definitionListRule = {
                 .slice(1)
                 .flatMap((definition, defIndex, defArray) => [
                 { kind: "definitionMarker", content: ":" },
-                ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(definition))),
+                ...addIndentationToSyntax(parseBlockMarkdownForSyntaxHighlighting(removeIndentation(definition, true)), detectIndentation(definition, true), true),
                 ...(defIndex < defArray.length - 1 ? [textNode("\n")] : []),
             ]);
             return [...terms, textNode("\n"), ...definitions];

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

@@ -11,13 +11,12 @@ export const BlockMarkdown = ({ node, outerHeadingLevel = 0, insertBefore, footn
         case "heading":
             const Tag = `h${(node.level + outerHeadingLevel).toString()}`;
             return (_jsxs(Tag, { children: [insertBefore, node.content.map((inline, ii) => (_jsx(InlineMarkdown, { node: inline }, ii)))] }));
-        case "list":
-            if (node.ordered) {
-                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 (_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 "list": {
+            const Tag = node.ordered ? "ol" : "ul";
+            return (_jsxs(_Fragment, { children: [insertBefore, _jsx(Tag, { children: node.content.map((item, ii) => (_jsxs("li", { children: [item.inlineLabel && item.inlineLabel.length > 0
+                                    ? item.inlineLabel.map((inline, iii) => (_jsx(InlineMarkdown, { node: inline }, iii)))
+                                    : null, item.content.map((content, iii) => (_jsx(BlockMarkdown, { node: content }, iii)))] }, ii))) })] }));
+        }
         case "table":
             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, { columns: node.columns, cells: node.header, cellType: "th" }) }), checkTableRowsAreSections(node.rows) ? (node.rows.map((section, si) => (_jsxs("tbody", { children: [section.header && (_jsx(TableRow, { columns: node.columns, cells: section.header, cellType: "th" })), section.rows.map((row, ri) => (_jsx(TableRow, { columns: node.columns, cells: row.cells }, ri)))] }, si)))) : (_jsx("tbody", { children: node.rows.map((row, ri) => (_jsx(TableRow, { columns: node.columns, cells: row.cells }, ri))) }))] })] }));
         case "container":

package/package.json

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