tsondb 0.5.16 → 0.5.18

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/node/schema/declarations/Declaration.d.ts

@@ -17,6 +17,7 @@ export declare const getTypeArgumentsRecord: <Params extends TypeParameter[]>(de
 export type Decl = EntityDecl | EnumDecl | TypeAliasDecl;
 export type SerializedDecl = SerializedEntityDecl | SerializedEnumDecl | SerializedTypeAliasDecl;
 export type DeclP<Params extends TypeParameter[] = TypeParameter[]> = EntityDecl | EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
+export type IncludableDeclP<Params extends TypeParameter[] = TypeParameter[]> = EnumDecl<string, Record<string, EnumCaseDecl>, Params> | TypeAliasDecl<string, Type, Params>;
 export type SerializedDeclP<Params extends SerializedTypeParameter[] = SerializedTypeParameter[]> = SerializedEntityDecl | SerializedEnumDecl<string, Record<string, SerializedEnumCaseDecl>, Params> | SerializedTypeAliasDecl<string, SerializedType, Params>;
 export type SecondaryDecl = EnumDecl | TypeAliasDecl;
 export type SerializedSecondaryDecl = SerializedEnumDecl | SerializedTypeAliasDecl;

package/dist/src/node/schema/types/references/IncludeIdentifierType.d.ts

@@ -1,4 +1,4 @@
-import type { GetNestedDeclarations, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.ts";
+import type { GetNestedDeclarations, IncludableDeclP, SerializedTypeArguments, TypeArguments } from "../../declarations/Declaration.ts";
 import type { EnumDecl } from "../../declarations/EnumDecl.ts";
 import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.ts";
 import type { GetReferences, Node, Serializer } from "../../Node.ts";
@@ -23,9 +23,10 @@ export { GenIncludeIdentifierType as GenIncludeIdentifier };
 export declare const IncludeIdentifierType: <T extends TConstraint<[]>>(reference: T) => IncludeIdentifierType<[], T>;
 export { IncludeIdentifierType as IncludeIdentifier };
 export declare const isIncludeIdentifierType: (node: Node) => node is IncludeIdentifierType;
+export declare const isNoGenericIncludeIdentifierType: (node: IncludeIdentifierType) => node is IncludeIdentifierType<[], IncludableDeclP<[]>>;
 export declare const getNestedDeclarationsInIncludeIdentifierType: GetNestedDeclarations<IncludeIdentifierType>;
 export declare const validateIncludeIdentifierType: Validator<IncludeIdentifierType>;
-export declare const resolveTypeArgumentsInIncludeIdentifierType: (args: Record<string, Type>, type: IncludeIdentifierType) => Type;
+export declare const resolveTypeArgumentsInIncludeIdentifierType: <T extends IncludeIdentifierType>(args: Record<string, Type>, type: T) => T extends IncludeIdentifierType<[], IncludableDeclP<[]>> ? T : Type;
 export declare const serializeIncludeIdentifierType: Serializer<IncludeIdentifierType, SerializedIncludeIdentifierType>;
 export declare const getReferencesForIncludeIdentifierType: GetReferences<IncludeIdentifierType>;
 export declare const formatIncludeIdentifierValue: StructureFormatter<IncludeIdentifierType>;

package/dist/src/node/schema/types/references/IncludeIdentifierType.js

@@ -15,13 +15,14 @@ export const IncludeIdentifierType = (reference) => ({
 });
 export { IncludeIdentifierType as IncludeIdentifier };
 export const isIncludeIdentifierType = (node) => node.kind === NodeKind.IncludeIdentifierType;
+export const isNoGenericIncludeIdentifierType = (node) => node.args.length === 0 && node.reference.parameters.length === 0;
 export const getNestedDeclarationsInIncludeIdentifierType = (addedDecls, type) => type.args.reduce((accAddedDecls, arg) => getNestedDeclarations(accAddedDecls, arg), addedDecls.includes(type.reference)
     ? addedDecls
     : 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
+export const resolveTypeArgumentsInIncludeIdentifierType = (args, type) => (isNoGenericIncludeIdentifierType(type)
     ? type
-    : resolveTypeArgumentsInDecl(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg))).type.value;
+    : resolveTypeArgumentsInDecl(type.reference, type.args.map(arg => resolveTypeArgumentsInType(args, arg))).type.value);
 export const serializeIncludeIdentifierType = type => ({
     ...removeParentKey(type),
     reference: type.reference.name,

package/dist/src/node/schema/types/references/NestedEntityMapType.d.ts

@@ -1,18 +1,21 @@
 import { Lazy } from "../../../../shared/utils/lazy.ts";
-import type { GetNestedDeclarations } from "../../declarations/Declaration.ts";
+import { type GetNestedDeclarations } from "../../declarations/Declaration.ts";
 import type { EntityDecl } from "../../declarations/EntityDecl.ts";
+import type { TypeAliasDecl } from "../../declarations/TypeAliasDecl.ts";
 import type { GetReferences, Node, Serializer } from "../../Node.ts";
 import { NodeKind } from "../../Node.ts";
 import type { Validator } from "../../validation/type.ts";
 import type { MemberDecl, ObjectType, SerializedMemberDecl, SerializedObjectType } from "../generic/ObjectType.ts";
 import type { BaseType, SerializedBaseType, StructureFormatter, Type } from "../Type.ts";
+import { type IncludeIdentifier, type SerializedIncludeIdentifierType } from "./IncludeIdentifierType.ts";
 type TConstraint = Record<string, MemberDecl>;
+type PossibleType<T extends TConstraint> = ObjectType<T> | IncludeIdentifier<[], TypeAliasDecl<string, ObjectType<T>, []>>;
 export interface NestedEntityMapType<Name extends string = string, T extends TConstraint = TConstraint> extends BaseType {
     kind: NodeKind["NestedEntityMapType"];
     name: Name;
     comment?: string;
     secondaryEntity: EntityDecl;
-    type: Lazy<ObjectType<T>>;
+    type: Lazy<PossibleType<T>>;
 }
 type TSerializedConstraint = Record<string, SerializedMemberDecl>;
 export interface SerializedNestedEntityMapType<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint> extends SerializedBaseType {
@@ -20,13 +23,13 @@ export interface SerializedNestedEntityMapType<Name extends string = string, T e
     name: Name;
     comment?: string;
     secondaryEntity: string;
-    type: SerializedObjectType<T>;
+    type: SerializedObjectType<T> | SerializedIncludeIdentifierType;
 }
 export declare const NestedEntityMapType: <Name extends string, T extends TConstraint>(options: {
     name: Name;
     comment?: string;
     secondaryEntity: EntityDecl;
-    type: ObjectType<T>;
+    type: PossibleType<T>;
 }) => NestedEntityMapType<Name, T>;
 export { NestedEntityMapType as NestedEntityMap };
 export declare const isNestedEntityMapType: (node: Node) => node is NestedEntityMapType;

package/dist/src/node/schema/types/references/NestedEntityMapType.js

@@ -3,9 +3,11 @@ import { sortObjectKeysAlphabetically } from "../../../../shared/utils/object.js
 import { parallelizeErrors } from "../../../../shared/utils/validation.js";
 import { wrapErrorsIfAny } from "../../../utils/error.js";
 import { entity, json, key as keyColor } from "../../../utils/errorFormatting.js";
+import { getNestedDeclarations, } from "../../declarations/Declaration.js";
 import { NodeKind } from "../../Node.js";
-import { getNestedDeclarationsInObjectType, getReferencesForObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, validateObjectType, } from "../generic/ObjectType.js";
-import { formatValue, removeParentKey, setParent } from "../Type.js";
+import { getReferencesForObjectType, isObjectType, resolveTypeArgumentsInObjectType, serializeObjectType, } from "../generic/ObjectType.js";
+import { formatValue, removeParentKey, setParent, validate } from "../Type.js";
+import { formatIncludeIdentifierValue, getReferencesForIncludeIdentifierType, resolveTypeArgumentsInIncludeIdentifierType, serializeIncludeIdentifierType, } from "./IncludeIdentifierType.js";
 export const NestedEntityMapType = (options) => {
     const nestedEntityMapType = {
         ...options,
@@ -24,30 +26,38 @@ const _NestedEntityMapType = (options) => {
     return nestedEntityMapType;
 };
 export const isNestedEntityMapType = (node) => node.kind === NodeKind.NestedEntityMapType;
-export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type) => getNestedDeclarationsInObjectType(addedDecls.includes(type.secondaryEntity) ? addedDecls : [type.secondaryEntity, ...addedDecls], type.type.value);
+export const getNestedDeclarationsInNestedEntityMapType = (addedDecls, type) => getNestedDeclarations(addedDecls.includes(type.secondaryEntity) ? addedDecls : [type.secondaryEntity, ...addedDecls], type.type.value);
 export const validateNestedEntityMapType = (helpers, type, value) => {
     if (typeof value !== "object" || value === null || Array.isArray(value)) {
         return [TypeError(`expected an object, but got ${json(value, helpers.useStyling)}`)];
     }
-    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${keyColor(`"${key}"`, helpers.useStyling)}`, validateObjectType(helpers, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
+    return parallelizeErrors(Object.keys(value).map(key => wrapErrorsIfAny(`at nested entity map ${entity(`"${type.name}"`, helpers.useStyling)} at key ${keyColor(`"${key}"`, helpers.useStyling)}`, validate(helpers, type.type.value, value[key]).concat(helpers.checkReferentialIntegrity({
         name: type.secondaryEntity.name,
         value: key,
     })))));
 };
 export const resolveTypeArgumentsInNestedEntityMapType = (args, type) => _NestedEntityMapType({
     ...type,
-    type: () => resolveTypeArgumentsInObjectType(args, type.type.value),
+    type: () => isObjectType(type.type.value)
+        ? resolveTypeArgumentsInObjectType(args, type.type.value)
+        : resolveTypeArgumentsInIncludeIdentifierType(args, type.type.value),
 });
 export const serializeNestedEntityMapType = type => ({
     ...removeParentKey(type),
     secondaryEntity: type.secondaryEntity.name,
-    type: serializeObjectType(type.type.value),
+    type: isObjectType(type.type.value)
+        ? serializeObjectType(type.type.value)
+        : serializeIncludeIdentifierType(type.type.value),
 });
 export const getReferencesForNestedEntityMapType = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
     ? Object.values(value)
-        .flatMap(item => getReferencesForObjectType(type.type.value, item))
+        .flatMap(item => isObjectType(type.type.value)
+        ? getReferencesForObjectType(type.type.value, item)
+        : getReferencesForIncludeIdentifierType(type.type.value, item))
         .concat(Object.keys(value))
     : [];
-export const formatNestedEntityMapValue = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
-    ? sortObjectKeysAlphabetically(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, formatValue(type.type.value, item)])))
-    : value;
+export const formatNestedEntityMapValue = (type, value) => isObjectType(type.type.value)
+    ? typeof value === "object" && value !== null && !Array.isArray(value)
+        ? sortObjectKeysAlphabetically(Object.fromEntries(Object.entries(value).map(([key, item]) => [key, formatValue(type.type.value, item)])))
+        : value
+    : formatIncludeIdentifierValue(type.type.value, value);

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

@@ -6,7 +6,7 @@ const codeRule = {
     }),
 };
 const boldWithItalicRule = {
-    pattern: /\*\*(.*?\*.+?\*.*?)\*\*/,
+    pattern: /(?<!\\)\*\*((.*?[^\\*])?\*(?!\*).*?[^\\*]\*.*?)(?<!\\)\*\*/,
     map: (result, parseInside, forSyntaxHighlighting) => ({
         kind: "bold",
         content: forSyntaxHighlighting
@@ -19,7 +19,7 @@ const boldWithItalicRule = {
     }),
 };
 const italicWithBoldRule = {
-    pattern: /\*(.*?\*\*.+?\*\*.*?)\*/,
+    pattern: /(?<![\\*])\*(?=\*\*|[^*])(.*?\*\*.*?\*\*.*?)(?<=[^\\*]|[^\\]\*\*)\*(?!\*)/,
     map: (result, parseInside, forSyntaxHighlighting) => ({
         kind: "italic",
         content: forSyntaxHighlighting
@@ -32,7 +32,7 @@ const italicWithBoldRule = {
     }),
 };
 const boldRule = {
-    pattern: /\*\*(.+?)\*\*/,
+    pattern: /(?<!\\)\*\*(.*?[^\\*])\*\*/,
     map: (result, parseInside, forSyntaxHighlighting) => ({
         kind: "bold",
         content: forSyntaxHighlighting
@@ -45,7 +45,7 @@ const boldRule = {
     }),
 };
 const italicRule = {
-    pattern: /\*(.+?)\*/,
+    pattern: /(?<!\\)\*(.*?[^\\*])\*/,
     map: (result, parseInside, forSyntaxHighlighting) => ({
         kind: "italic",
         content: forSyntaxHighlighting
@@ -57,8 +57,23 @@ const italicRule = {
             : parseInside(result[1] ?? ""),
     }),
 };
+const linkRule = {
+    pattern: /(?<!\\)\[(.*?[^\\])\]\((.*?[^\\])\)/,
+    map: (result, parseInside, forSyntaxHighlighting) => ({
+        kind: "link",
+        href: result[2] ?? "",
+        content: forSyntaxHighlighting
+            ? [
+                { kind: "text", content: "[" },
+                ...parseInside(result[1] ?? ""),
+                { kind: "text", content: `](${result[2] ?? ""})` },
+            ]
+            : parseInside(result[1] ?? ""),
+    }),
+};
 const inlineRules = [
     codeRule,
+    linkRule,
     boldWithItalicRule,
     italicWithBoldRule,
     boldRule,
@@ -123,7 +138,62 @@ const paragraphRule = {
         { kind: "text", content: result[2] ?? "" },
     ],
 };
-const blockRules = [listRule, paragraphRule];
+const removeSurroundingPipes = (text) => text.replace(/^\|/, "").replace(/\|$/, "");
+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 => [
+        {
+            kind: "tablemarker",
+            content: result[1] ?? "",
+        },
+        ...(result[2]?.split("|").flatMap((th, i) => i === 0
+            ? parseInlineMarkdown(th, true)
+            : [
+                {
+                    kind: "tablemarker",
+                    content: "|",
+                },
+                ...parseInlineMarkdown(th, true),
+            ]) ?? []),
+        {
+            kind: "tablemarker",
+            content: (result[3] ?? "") + "\n" + (result[4] ?? ""),
+        },
+        ...(result[5]
+            ?.split("\n")
+            .slice(1)
+            .flatMap((tr) => [
+            {
+                kind: "text",
+                content: "\n",
+            },
+            ...tr.split("|").flatMap((tc, i) => i === 0
+                ? parseInlineMarkdown(tc, true)
+                : [
+                    {
+                        kind: "tablemarker",
+                        content: "|",
+                    },
+                    ...parseInlineMarkdown(tc, true),
+                ]),
+        ]) ?? []),
+        {
+            kind: "text",
+            content: result[6] ?? "",
+        },
+    ],
+};
+const blockRules = [tableRule, listRule, paragraphRule];
 const parseForBlockRules = (rules, text, remainingRules = rules) => {
     if (text.length === 0) {
         return [];

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.16",
+  "version": "0.5.18",
   "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;
 }