tsondb 0.19.18 → 0.20.1

package/dist/src/node/schema/dsl/types/StringType.d.ts

@@ -1,17 +1,18 @@
 import { NodeKind } from "../../../../shared/schema/Node.js";
+import type { MarkdownStringOption } from "../../../../shared/schema/types/StringType.ts";
 import type { StringConstraints } from "../../../../shared/validation/string.ts";
 import type { Node } from "../index.ts";
 import type { BaseType } from "./Type.ts";
 export interface StringType extends BaseType, StringConstraints {
     kind: NodeKind["StringType"];
     pattern?: RegExp;
-    isMarkdown?: boolean;
+    markdown?: MarkdownStringOption;
 }
 export declare const StringType: (options?: {
     minLength?: number;
     maxLength?: number;
     pattern?: RegExp;
-    isMarkdown?: boolean;
+    markdown?: MarkdownStringOption;
 }) => StringType;
 export { StringType as String };
 export declare const isStringType: (node: Node) => node is StringType;

package/dist/src/node/schema/treeOperations/format.js

@@ -1,8 +1,7 @@
-import { sortObjectKeys, sortObjectKeysByIndex } from "@elyukai/utils/object";
+import { mapObject, sortObjectKeys, sortObjectKeysByIndex } from "@elyukai/utils/object";
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { ENUM_DISCRIMINATOR_KEY } from "../../../shared/schema/declarations/EnumDecl.js";
 import { NodeKind } from "../../../shared/schema/Node.js";
-import { isObjectType } from "../dsl/types/ObjectType.js";
 const formatTranslationObjectValue = (type, value) => typeof value === "object" && value !== null && !Array.isArray(value)
     ? sortObjectKeysByIndex(Object.fromEntries(Object.entries(value).map(([key, item]) => [
         key,
@@ -18,36 +17,14 @@ export const formatValue = (type, value) => {
             return Array.isArray(value) ? value.map(item => formatValue(type.items, item)) : value;
         case NodeKind.ObjectType:
             return typeof value === "object" && value !== null && !Array.isArray(value)
-                ? sortObjectKeysByIndex(Object.fromEntries(Object.entries(value).map(([key, item]) => [
-                    key,
-                    type.properties[key] ? formatValue(type.properties[key].type, item) : item,
-                ])), Object.keys(type.properties))
+                ? sortObjectKeysByIndex(mapObject(value, (item, key) => type.properties[key] ? formatValue(type.properties[key].type, item) : item), Object.keys(type.properties))
                 : value;
-        case NodeKind.BooleanType:
-            return value;
-        case NodeKind.DateType:
-            return value;
-        case NodeKind.FloatType:
-            return value;
-        case NodeKind.IntegerType:
-            return value;
-        case NodeKind.StringType:
-            return value;
-        case NodeKind.TypeArgumentType:
-            return value;
         case NodeKind.IncludeIdentifierType:
             return formatValue(type.reference.type.value, value);
         case NodeKind.NestedEntityMapType:
-            return isObjectType(type.type.value)
-                ? typeof value === "object" && value !== null && !Array.isArray(value)
-                    ? sortObjectKeys(Object.fromEntries(Object.entries(value).map(([key, item]) => [
-                        key,
-                        formatValue(type.type.value, item),
-                    ])))
-                    : value
-                : formatValue(type.type.value, value);
-        case NodeKind.ReferenceIdentifierType:
-            return value;
+            return typeof value === "object" && value !== null && !Array.isArray(value)
+                ? sortObjectKeys(mapObject(value, item => formatValue(type.type.value, item)))
+                : value;
         case NodeKind.EnumType: {
             if (typeof value === "object" &&
                 value !== null &&
@@ -70,6 +47,14 @@ export const formatValue = (type, value) => {
             return Array.isArray(value) ? value.toSorted() : value;
         case NodeKind.TranslationObjectType:
             return formatTranslationObjectValue(type.properties, value);
+        case NodeKind.BooleanType:
+        case NodeKind.DateType:
+        case NodeKind.FloatType:
+        case NodeKind.IntegerType:
+        case NodeKind.StringType:
+        case NodeKind.TypeArgumentType:
+        case NodeKind.ReferenceIdentifierType:
+            return value;
         default:
             return assertExhaustive(type);
     }

package/dist/src/shared/schema/types/StringType.d.ts

@@ -1,10 +1,11 @@
 import type { StringConstraints } from "../../validation/string.ts";
 import type { GetReferencesSerialized, NodeKind, SerializedTypeArgumentsResolver } from "../Node.ts";
 import type { SerializedBaseType } from "./Type.ts";
+export type MarkdownStringOption = "block" | "inline";
 export interface SerializedStringType extends SerializedBaseType, StringConstraints {
     kind: NodeKind["StringType"];
     pattern?: string;
-    isMarkdown?: boolean;
+    markdown?: MarkdownStringOption;
 }
 export declare const resolveTypeArgumentsInSerializedStringType: SerializedTypeArgumentsResolver<SerializedStringType>;
 export declare const getReferencesForSerializedStringType: GetReferencesSerialized<SerializedStringType>;

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

@@ -23,7 +23,7 @@ export const isSinglularInputFieldType = (getDeclFromDeclName, type) => {
                 : false;
         }
         case "StringType":
-            return !(type.isMarkdown ?? false);
+            return !(type.markdown ?? false);
         default:
             return assertExhaustive(type);
     }

package/dist/src/web/488.js

@@ -2867,6 +2867,8 @@ const Layout = ({ breadcrumbs, children })=>{
         ]
     });
 };
+const isEmpty = (arr)=>0 === arr.length;
+const isNotEmpty = (arr)=>!isEmpty(arr);
 class Parser {
     #fn;
     constructor(fn){
@@ -3147,6 +3149,13 @@ const isNaturalNumber = (test)=>naturalNumberPattern.test(test);
 function typeSafety_assertExhaustive(_x, msg = "The switch is not exhaustive.") {
     throw new Error(msg);
 }
+const trySafe = (f, defaultValue)=>{
+    try {
+        return f();
+    } catch  {
+        return defaultValue;
+    }
+};
 const reduceSyntaxNodes = (nodes)=>nodes.reduce((reducedNodes, node, index)=>{
         const lastNode = index > 0 ? reducedNodes[reducedNodes.length - 1] : void 0;
         const newLastNode = lastNode ? mergeSyntaxNodes(lastNode, node) : null;
@@ -3412,8 +3421,18 @@ const inlineNode = combineParsers([
     leafParser(defaultInlineSyntaxStartSequences)
 ]);
 const inlineMarkdown = inlineNode.many();
-const isEmpty = (arr)=>0 === arr.length;
-const nonEmpty_isNotEmpty = (arr)=>!isEmpty(arr);
+const _parseInlineMarkdown = (syntax, keepSyntax = false)=>{
+    const results = inlineMarkdown.evalT({
+        indentation: 0,
+        keepSyntax
+    }).parse(syntax);
+    if (!isNotEmpty(results)) throw new Error("Failed to parse");
+    const [result, remaining] = results[0];
+    if (remaining.length > 0) throw new Error(`Failed to parse the entire string. Remaining: "${remaining}"`);
+    return result;
+};
+const parseInlineMarkdown = (syntax)=>_parseInlineMarkdown(syntax, false);
+const parseInlineMarkdownForSyntaxHighlighting = (syntax)=>_parseInlineMarkdown(syntax, true);
 const isNullish = (value)=>null == value;
 const isNotNullish = (value)=>!isNullish(value);
 const sortObjectKeysByIndex = (obj, keys)=>Object.fromEntries([
@@ -3792,7 +3811,7 @@ const parseBlockMarkdown = (syntax)=>{
         indentation: 0,
         keepSyntax: false
     }).parse(syntax);
-    if (!nonEmpty_isNotEmpty(results)) throw new Error("Failed to parse");
+    if (!isNotEmpty(results)) throw new Error("Failed to parse");
     const [result = [], remaining] = results[0];
     if (remaining.length > 0) return [
         ...result,
@@ -3813,7 +3832,7 @@ const parseBlockMarkdownForSyntaxHighlighting = (syntax)=>{
         indentation: 0,
         keepSyntax: true
     }).parse(syntax);
-    if (!nonEmpty_isNotEmpty(results)) throw new Error("Failed to parse");
+    if (!isNotEmpty(results)) throw new Error("Failed to parse");
     const [result, remaining] = results[0];
     if (remaining.length > 0) return [
         ...result,
@@ -3986,7 +4005,7 @@ const BlockMarkdown = ({ node, outerHeadingLevel = 0, insertBefore, footnoteLabe
                     insertBefore,
                     /*#__PURE__*/ jsxRuntime_module_u("table", {
                         children: [
-                            void 0 !== node.caption && nonEmpty_isNotEmpty(node.caption) && /*#__PURE__*/ jsxRuntime_module_u("caption", {
+                            void 0 !== node.caption && isNotEmpty(node.caption) && /*#__PURE__*/ jsxRuntime_module_u("caption", {
                                 children: node.caption.length > 1 ? node.caption.map((captionLine, cli)=>/*#__PURE__*/ jsxRuntime_module_u("div", {
                                         children: captionLine.map((inline, ci)=>/*#__PURE__*/ jsxRuntime_module_u(InlineMarkdown, {
                                                 node: inline
@@ -4123,19 +4142,25 @@ const TableRow = ({ columns, cells, cellType = "td" })=>{
         ])[0]
     });
 };
-const Markdown = ({ class: className, string, outerHeadingLevel, footnoteLabelSuffix })=>{
-    const blocks = parseBlockMarkdown(string);
-    const blockElements = blocks.map((block, i)=>/*#__PURE__*/ jsxRuntime_module_u(BlockMarkdown, {
-            node: block,
+const Markdown = ({ class: className, string, outerHeadingLevel, footnoteLabelSuffix, inline })=>{
+    const elements = inline ? trySafe(()=>parseInlineMarkdown(string), [
+        {
+            type: "text",
+            content: string
+        }
+    ]).map((node, i)=>/*#__PURE__*/ jsxRuntime_module_u(InlineMarkdown, {
+            node: node
+        }, `md-inline-${i.toString()}`)) : parseBlockMarkdown(string).map((node, i)=>/*#__PURE__*/ jsxRuntime_module_u(BlockMarkdown, {
+            node: node,
             outerHeadingLevel: outerHeadingLevel,
             footnoteLabelSuffix: footnoteLabelSuffix
         }, `md-block-${i.toString()}`));
     if (className) return /*#__PURE__*/ jsxRuntime_module_u("div", {
         class: className,
-        children: blockElements
+        children: elements
     });
     return /*#__PURE__*/ jsxRuntime_module_u(preact_module_k, {
-        children: blockElements
+        children: elements
     });
 };
 const homeTitle = "Entities";
@@ -4504,7 +4529,7 @@ const isSinglularInputFieldType = (getDeclFromDeclName, type)=>{
                 return secondaryDecl ? isSinglularInputFieldType(getDeclFromDeclName, secondaryDecl.type) : false;
             }
         case "StringType":
-            return !(type.isMarkdown ?? false);
+            return !(type.markdown ?? false);
         default:
             return typeSafety_assertExhaustive(type);
     }
@@ -5481,8 +5506,13 @@ const BlockMarkdownHighlighting = ({ node })=>{
             return typeSafety_assertExhaustive(node.blockType);
     }
 };
-const MarkdownHighlighting = ({ class: className, string })=>{
-    const blocks = parseBlockMarkdownForSyntaxHighlighting(string);
+const MarkdownHighlighting = ({ class: className, string, inline })=>{
+    const blocks = inline ? trySafe(()=>parseInlineMarkdownForSyntaxHighlighting(string), [
+        {
+            type: "text",
+            content: string
+        }
+    ]) : parseBlockMarkdownForSyntaxHighlighting(string);
     const blockElements = blocks.map((block, i)=>/*#__PURE__*/ jsxRuntime_module_u(BlockMarkdownHighlighting, {
             node: block
         }, `md-block-${i.toString()}`));
@@ -5499,8 +5529,9 @@ const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject
         expected: "string",
         actual: value
     });
-    const { minLength, maxLength, pattern, isMarkdown } = type;
+    const { minLength, maxLength, pattern, markdown } = type;
     const errors = validateStringConstraints(type, value);
+    const preparedPattern = void 0 === pattern ? void 0 : pattern.startsWith("^(?:") && pattern.endsWith(")$") ? pattern.slice(4, -2) : `.*${pattern}.*`;
     return /*#__PURE__*/ jsxRuntime_module_u("div", {
         class: "field field--string",
         children: inTranslationObject ? /*#__PURE__*/ jsxRuntime_module_u(preact_module_k, {
@@ -5533,7 +5564,7 @@ const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject
                     })
                 ]
             })
-        }) : isMarkdown ? /*#__PURE__*/ jsxRuntime_module_u(preact_module_k, {
+        }) : void 0 !== markdown ? /*#__PURE__*/ jsxRuntime_module_u(preact_module_k, {
             children: [
                 /*#__PURE__*/ jsxRuntime_module_u("div", {
                     class: "editor editor--markdown",
@@ -5555,7 +5586,7 @@ const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject
                                 /*#__PURE__*/ jsxRuntime_module_u("p", {
                                     class: "help",
                                     children: [
-                                        "This textarea supports",
+                                        "This text field supports",
                                         " ",
                                         /*#__PURE__*/ jsxRuntime_module_u("a", {
                                             href: "https://www.markdownguide.org/getting-started/",
@@ -5568,7 +5599,8 @@ const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject
                                 }),
                                 /*#__PURE__*/ jsxRuntime_module_u(MarkdownHighlighting, {
                                     class: "textarea-grow-wrap__mirror editor-highlighting",
-                                    string: value + " "
+                                    string: value + " ",
+                                    inline: "inline" === markdown
                                 })
                             ]
                         }),
@@ -5582,7 +5614,8 @@ const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject
                     class: "preview",
                     children: /*#__PURE__*/ jsxRuntime_module_u(Markdown, {
                         string: value,
-                        outerHeadingLevel: 2
+                        outerHeadingLevel: 2,
+                        inline: "inline" === markdown
                     })
                 })
             ]
@@ -5594,7 +5627,7 @@ const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject
                     value: value,
                     minLength: minLength,
                     maxLength: maxLength,
-                    pattern: void 0 === pattern ? void 0 : pattern.startsWith("^(?:") && pattern.endsWith(")$") ? pattern.slice(4, -2) : `.*${pattern}.*`,
+                    pattern: preparedPattern,
                     onInput: (event)=>{
                         onChange(event.currentTarget.value);
                     },

package/package.json

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