tsondb 0.5.17 → 0.5.19

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

@@ -1,9 +1,11 @@
+import Debug from "debug";
 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 debug = Debug("tsondb:schema");
 const checkDuplicateIdentifier = (existingDecls, decl) => {
     const existingDeclWithSameName = existingDecls
         .values()
@@ -66,9 +68,14 @@ const addDeclarations = (existingDecls, declsToAdd, nested) => declsToAdd.reduce
     return accDecls;
 }, existingDecls);
 export const Schema = (declarations, localeEntity) => {
+    debug("creating schema from %d declarations", declarations.length);
+    debug("collecting nested declarations ...");
     const allDecls = addDeclarations([], localeEntity ? declarations.concat(localeEntity) : declarations, true);
+    debug("checking name shadowing ...");
     checkParameterNamesShadowing(allDecls);
+    debug("checking entity display name paths ...");
     checkEntityDisplayNamePaths(allDecls, localeEntity);
+    debug("created schema, no integrity violations found");
     return {
         declarations: allDecls,
         localeEntity,

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

@@ -8,6 +8,10 @@ export type InlineMarkdownNode = {
 } | {
     kind: "code";
     content: string;
+} | {
+    kind: "link";
+    href: string;
+    content: InlineMarkdownNode[];
 } | TextNode;
 export type BlockMarkdownNode = {
     kind: "paragraph";
@@ -19,10 +23,17 @@ export type BlockMarkdownNode = {
         kind: "listitem";
         content: InlineMarkdownNode[];
     }[];
+} | {
+    kind: "table";
+    header: InlineMarkdownNode[][];
+    rows: InlineMarkdownNode[][][];
 };
 export type BlockSyntaxMarkdownNode = InlineMarkdownNode | {
     kind: "listitemmarker";
     content: string;
+} | {
+    kind: "tablemarker";
+    content: string;
 };
 export declare const parseBlockMarkdown: (text: string) => BlockMarkdownNode[];
 export declare const parseBlockMarkdownForSyntaxHighlighting: (text: string) => BlockSyntaxMarkdownNode[];

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

@@ -1,77 +1,101 @@
 const codeRule = {
     pattern: /`(.*?)`/,
-    map: (result, _parseInside, forSyntaxHighlighting) => ({
+    map: result => ({
+        kind: "code",
+        content: result[1] ?? "",
+    }),
+    mapHighlighting: result => ({
         kind: "code",
-        content: forSyntaxHighlighting ? `\`${result[1] ?? ""}\`` : (result[1] ?? ""),
+        content: `\`${result[1] ?? ""}\``,
     }),
 };
 const boldWithItalicRule = {
-    pattern: /\*\*(.*?\*.+?\*.*?)\*\*/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    pattern: /(?<!\\)\*\*((.*?[^\\*])?\*(?!\*).*?[^\\*]\*.*?)(?<!\\)\*\*/,
+    map: (result, parseInside) => ({
+        kind: "bold",
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
         kind: "bold",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "**" },
-                ...parseInside(result[1] ?? ""),
-                { kind: "text", content: "**" },
-            ]
-            : parseInside(result[1] ?? ""),
+        content: [textNode("**"), ...parseInside(result[1] ?? ""), textNode("**")],
     }),
 };
 const italicWithBoldRule = {
-    pattern: /\*(.*?\*\*.+?\*\*.*?)\*/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    pattern: /(?<![\\*])\*(?=\*\*|[^*])(.*?\*\*.*?\*\*.*?)(?<=[^\\*]|[^\\]\*\*)\*(?!\*)/,
+    map: (result, parseInside) => ({
         kind: "italic",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "*" },
-                ...parseInside(result[1] ?? ""),
-                { kind: "text", content: "*" },
-            ]
-            : parseInside(result[1] ?? ""),
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
+        kind: "italic",
+        content: [textNode("*"), ...parseInside(result[1] ?? ""), textNode("*")],
     }),
 };
 const boldRule = {
-    pattern: /\*\*(.+?)\*\*/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    pattern: /(?<!\\)\*\*(.*?[^\\*])\*\*/,
+    map: (result, parseInside) => ({
+        kind: "bold",
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
         kind: "bold",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "**" },
-                ...parseInside(result[1] ?? ""),
-                { kind: "text", content: "**" },
-            ]
-            : parseInside(result[1] ?? ""),
+        content: [textNode("**"), ...parseInside(result[1] ?? ""), textNode("**")],
     }),
 };
 const italicRule = {
-    pattern: /\*(.+?)\*/,
-    map: (result, parseInside, forSyntaxHighlighting) => ({
+    pattern: /(?<!\\)\*(.*?[^\\*])\*/,
+    map: (result, parseInside) => ({
         kind: "italic",
-        content: forSyntaxHighlighting
-            ? [
-                { kind: "text", content: "*" },
-                ...parseInside(result[1] ?? ""),
-                { kind: "text", content: "*" },
-            ]
-            : parseInside(result[1] ?? ""),
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
+        kind: "italic",
+        content: [textNode("*"), ...parseInside(result[1] ?? ""), textNode("*")],
+    }),
+};
+const linkRule = {
+    pattern: /(?<!\\)\[(.*?[^\\])\]\((.*?[^\\])\)/,
+    map: (result, parseInside) => ({
+        kind: "link",
+        href: result[2] ?? "",
+        content: parseInside(result[1] ?? ""),
+    }),
+    mapHighlighting: (result, parseInside) => ({
+        kind: "link",
+        href: result[2] ?? "",
+        content: [textNode("["), ...parseInside(result[1] ?? ""), textNode(`](${result[2] ?? ""})`)],
+    }),
+};
+const textNode = (content) => ({
+    kind: "text",
+    content: content,
+});
+const parseEscapedCharacters = (text) => text.replace(/\\([*_`[\]()\\])/g, "$1");
+const textRule = {
+    pattern: /.+/,
+    map: result => ({
+        kind: "text",
+        content: parseEscapedCharacters(result[0]),
+    }),
+    mapHighlighting: result => ({
+        kind: "text",
+        content: result[0],
     }),
 };
 const inlineRules = [
     codeRule,
+    linkRule,
     boldWithItalicRule,
     italicWithBoldRule,
     boldRule,
     italicRule,
+    textRule,
 ];
 const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
-    if (text.length === 0) {
+    if (text.length === 0 || rules[0] === undefined) {
         return [];
     }
     const activeRule = rules[0];
-    if (activeRule === undefined) {
-        return [{ kind: "text", content: text }];
-    }
     const res = activeRule.pattern.exec(text);
     if (res && (activeRule.predicate?.(res) ?? true)) {
         const { index } = res;
@@ -81,7 +105,7 @@ const parseForInlineRules = (rules, text, forSyntaxHighlighting) => {
             ...(before.length > 0
                 ? parseForInlineRules(rules.slice(1), before, forSyntaxHighlighting)
                 : []),
-            activeRule.map(res, text => parseForInlineRules(rules.slice(1), text, forSyntaxHighlighting), forSyntaxHighlighting),
+            (forSyntaxHighlighting ? activeRule.mapHighlighting : activeRule.map)(res, text => parseForInlineRules(rules.slice(1), text, forSyntaxHighlighting)),
             ...(after.length > 0 ? parseForInlineRules(rules, after, forSyntaxHighlighting) : []),
         ];
     }
@@ -107,9 +131,9 @@ const listRule = {
                 content: /^(\d+\. |[-*] )/.exec(item)?.[1] ?? "",
             },
             ...parseInlineMarkdown(item.replace(/^\d+\. |[-*] /, ""), true),
-            ...(index < array.length - 1 ? [{ kind: "text", content: "\n" }] : []),
+            ...(index < array.length - 1 ? [textNode("\n")] : []),
         ]),
-        { kind: "text", content: result[2] ?? "" },
+        textNode(result[2] ?? ""),
     ],
 };
 const paragraphRule = {
@@ -120,48 +144,70 @@ const paragraphRule = {
     }),
     mapHighlighting: result => [
         ...parseInlineMarkdown(result[1] ?? "", true),
-        { kind: "text", content: result[2] ?? "" },
+        textNode(result[2] ?? ""),
     ],
 };
-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 removeSurroundingPipes = (text) => text.replace(/^\|/, "").replace(/\|$/, "");
+const tableMarker = (text) => ({
+    kind: "tablemarker",
+    content: text,
+});
+const tableRule = {
+    pattern: /^(\| *)?(.+?(?: *(?<!\\)\| *.+?)+)( *\|)?\n((?:\| *)?(?:-{3,}|:-{2,}|-{2,}:|:-+:)(?: *\| *(?:-{3,}|:-{2,}|-{2,}:|:-+:))*(?: *\|)?)((?:\n\|? *.+?(?: *(?<!\\)\| *.+?)* *(?<!\\)\|?)+)(\n{2,}|$)/,
+    map: result => ({
+        kind: "table",
+        header: result[2]?.split("|").map(th => parseInlineMarkdown(th.trim(), false)) ?? [],
+        rows: result[5]
+            ?.split("\n")
+            .slice(1)
+            .map(tr => removeSurroundingPipes(tr)
+            .split("|")
+            .map(tc => parseInlineMarkdown(tc.trim(), false))) ?? [],
+    }),
+    mapHighlighting: result => [
+        tableMarker(result[1] ?? ""),
+        ...(result[2]
+            ?.split("|")
+            .flatMap((th, i) => i === 0
+            ? parseInlineMarkdown(th, true)
+            : [tableMarker("|"), ...parseInlineMarkdown(th, true)]) ?? []),
+        tableMarker((result[3] ?? "") + "\n" + (result[4] ?? "")),
+        ...(result[5]
+            ?.split("\n")
+            .slice(1)
+            .flatMap((tr) => [
+            textNode("\n"),
+            ...tr
+                .split("|")
+                .flatMap((tc, i) => i === 0
+                ? parseInlineMarkdown(tc, true)
+                : [tableMarker("|"), ...parseInlineMarkdown(tc, true)]),
+        ]) ?? []),
+        textNode(result[6] ?? ""),
+    ],
 };
-const parseForBlockRulesSyntaxHighlighting = (rules, text, remainingRules = rules) => {
-    if (text.length === 0) {
+const blockRules = [tableRule, listRule, paragraphRule];
+const parseActiveBlockRule = (rule, res) => [
+    rule.map(res),
+];
+const parseActiveBlockSyntaxRule = (rule, res) => rule.mapHighlighting(res);
+const parseForBlockRules = (rules, text, ruleParser, remainingRules = rules) => {
+    if (text.length === 0 || remainingRules[0] === undefined) {
         return [];
     }
     const activeRule = remainingRules[0];
-    if (activeRule === undefined) {
-        return [{ 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.mapHighlighting(res),
-            ...(after.length > 0 ? parseForBlockRulesSyntaxHighlighting(rules, after) : []),
+            ...ruleParser(activeRule, res),
+            ...(after.length > 0 ? parseForBlockRules(rules, after, ruleParser) : []),
         ];
     }
     else {
-        return parseForBlockRulesSyntaxHighlighting(rules, text, remainingRules.slice(1));
+        return parseForBlockRules(rules, text, ruleParser, remainingRules.slice(1));
     }
 };
-export const parseBlockMarkdown = (text) => parseForBlockRules(blockRules, text);
-export const parseBlockMarkdownForSyntaxHighlighting = (text) => parseForBlockRulesSyntaxHighlighting(blockRules, text);
+export const parseBlockMarkdown = (text) => parseForBlockRules(blockRules, text, parseActiveBlockRule);
+export const parseBlockMarkdownForSyntaxHighlighting = (text) => parseForBlockRules(blockRules, text, parseActiveBlockSyntaxRule);

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

@@ -1,4 +1,4 @@
-import { jsx as _jsx } from "preact/jsx-runtime";
+import { jsx as _jsx, jsxs as _jsxs } from "preact/jsx-runtime";
 import { InlineMarkdown } from "./InlineMarkdown.js";
 export const BlockMarkdown = ({ node }) => {
     switch (node.kind) {
@@ -11,6 +11,8 @@ export const BlockMarkdown = ({ node }) => {
             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 "table":
+            return (_jsxs("table", { children: [_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))) })] }));
         default:
             return null;
     }

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

@@ -4,6 +4,8 @@ export const BlockMarkdownHighlighting = ({ node }) => {
     switch (node.kind) {
         case "listitemmarker":
             return _jsx("span", { class: "list-item-marker", children: node.content });
+        case "tablemarker":
+            return _jsx("span", { class: "table-marker", children: node.content });
         default:
             return _jsx(InlineMarkdown, { node: node });
     }

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

@@ -7,6 +7,8 @@ export const InlineMarkdown = ({ node }) => {
             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 "link":
+            return (_jsx("a", { href: node.href, 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.17",
+  "version": "0.5.19",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -23,7 +23,7 @@
   "scripts": {
     "build": "tsc -b",
     "watch": "tsc -b -w",
-    "test": "node --test",
+    "test": "node --import tsx --test",
     "lint": "eslint",
     "format": "prettier \"{src,test}/**/*.{ts,tsx}\" --write",
     "format:check": "prettier \"{src,test}/**/*.{ts,tsx}\" --check",
@@ -41,6 +41,7 @@
     "eslint-plugin-react-hooks": "^5.2.0",
     "globals": "^16.3.0",
     "prettier": "^3.6.2",
+    "tsx": "^4.20.5",
     "typescript": "^5.9.2",
     "typescript-eslint": "^8.43.0"
   },

package/public/css/styles.css

@@ -51,6 +51,7 @@
   --highlight-color-bold: rgb(205, 123, 43);
   --highlight-color-italic: rgb(41, 155, 96);
   --highlight-color-list-item-marker: rgb(195, 58, 237);
+  --highlight-color-table-marker: rgb(237, 58, 118);
 }
 
 @media (prefers-color-scheme: dark) {
@@ -82,6 +83,7 @@
     --highlight-color-bold: rgb(236, 170, 105);
     --highlight-color-italic: rgb(130, 230, 178);
     --highlight-color-list-item-marker: rgb(220, 133, 245);
+    --highlight-color-table-marker: rgb(244, 135, 171);
   }
 }
 
@@ -584,6 +586,10 @@ form > .field--container {
   color: var(--highlight-color-list-item-marker);
 }
 
+.editor-highlighting .table-marker {
+  color: var(--highlight-color-table-marker);
+}
+
 .help {
   font-size: 0.8rem;
   color: var(--secondary-color);
@@ -608,6 +614,28 @@ form > .field--container {
   margin-bottom: 0;
 }
 
+.field--string .preview table {
+  border-collapse: collapse;
+  margin: 0.5rem 0;
+}
+
+.field--string .preview table :is(th, td) {
+  vertical-align: top;
+  padding: 0.25rem 0.5rem;
+}
+
+.field--string .preview table :is(th, td):first-child {
+  padding-left: 0;
+}
+
+.field--string .preview table :is(th, td):last-child {
+  padding-right: 0;
+}
+
+.field--string .preview table tbody tr {
+  border-top: 1px solid var(--tertiary-color);
+}
+
 .container-item {
   container-type: inline-size;
 }