tsondb 0.19.17 → 0.20.0

package/dist/src/node/renderers/ts/render.d.ts

@@ -20,7 +20,7 @@ export type TypeScriptRendererOptions = {
          * If `true` or a string, generates an object type with all names of the type aliases as the key and their corresponding generated type as their respective value. Uses `TypeAliasMap` as a default name when using `true` or the string if set to a string.
          */
         typeAliasMap: boolean | string;
-    }>;
+    }> | boolean;
     addIdentifierToEntities: boolean;
     /**
      * Infer translation parameter types from the message strings in a {@link TranslationObjectType TranslationObject} as branded types.

package/dist/src/node/renderers/ts/render.js

@@ -170,14 +170,19 @@ const renderImports = (currentUrl, imports) => {
         .join(EOL);
     return importsSyntax.length > 0 ? importsSyntax + EOL + EOL : "";
 };
-const renderMapHelperType = (options, declarations, key, defaultName, filterFn, renderKeyFn) => options.generateHelpers[key]
-    ? `export type ${options.generateHelpers[key] === true ? defaultName : options.generateHelpers[key]} = {${EOL}${prefixLines(getIndentation(options.indentation, 1), declarations
-        .filter(filterFn)
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .map(renderKeyFn ??
-        (decl => `${decl.name}: ${decl.name}${decl.parameters.length > 0 ? "<" + decl.parameters.map(param => (param.constraint ? renderType(options, param.constraint)[1] : "unknown")).join(", ") + ">" : ""}`))
-        .join(EOL))}${EOL}}${EOL + EOL}`
-    : "";
+const renderMapHelperType = (options, declarations, key, defaultName, filterFn, renderKeyFn) => {
+    const option = typeof options.generateHelpers === "boolean"
+        ? options.generateHelpers
+        : options.generateHelpers[key];
+    return option
+        ? `export type ${option === true ? defaultName : option} = {${EOL}${prefixLines(getIndentation(options.indentation, 1), declarations
+            .filter(filterFn)
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map(renderKeyFn ??
+            (decl => `${decl.name}: ${decl.name}${decl.parameters.length > 0 ? "<" + decl.parameters.map(param => (param.constraint ? renderType(options, param.constraint)[1] : "unknown")).join(", ") + ">" : ""}`))
+            .join(EOL))}${EOL}}${EOL + EOL}`
+        : "";
+};
 const renderEntityMapType = (options, declarations) => renderMapHelperType(options, declarations, "entityMap", "EntityMap", isEntityDecl);
 const renderChildEntityMapType = (options, declarations) => renderMapHelperType(options, declarations, "childEntityMap", "ChildEntityMap", decl => isEntityDecl(decl) && isEntityDeclWithParentReference(decl), decl => `${decl.name}: [${decl.name}, "${decl.parentReferenceKey}", ${decl.name}["${decl.parentReferenceKey}"]]`);
 const renderEnumMapType = (options, declarations) => renderMapHelperType(options, declarations, "enumMap", "EnumMap", isEnumDecl);

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){
@@ -3412,8 +3414,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 +3804,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 +3825,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 +3998,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 +4135,20 @@ 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 ? parseInlineMarkdown(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 +4517,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 +5494,8 @@ 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 ? parseInlineMarkdownForSyntaxHighlighting(string) : parseBlockMarkdownForSyntaxHighlighting(string);
     const blockElements = blocks.map((block, i)=>/*#__PURE__*/ jsxRuntime_module_u(BlockMarkdownHighlighting, {
             node: block
         }, `md-block-${i.toString()}`));
@@ -5494,13 +5507,20 @@ const MarkdownHighlighting = ({ class: className, string })=>{
         children: blockElements
     });
 };
+const TextInput = ({ type, ...props })=>"block" === type ? /*#__PURE__*/ jsxRuntime_module_u("textarea", {
+        ...props,
+        rows: 1
+    }) : /*#__PURE__*/ jsxRuntime_module_u("input", {
+        type: "text"
+    });
 const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject })=>{
     if ("string" != typeof value) return /*#__PURE__*/ jsxRuntime_module_u(MismatchingTypeError, {
         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 +5553,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",
@@ -5541,8 +5561,8 @@ const StringTypeInput = ({ type, value, disabled, onChange, inTranslationObject
                         /*#__PURE__*/ jsxRuntime_module_u("div", {
                             class: "textarea-grow-wrap",
                             children: [
-                                /*#__PURE__*/ jsxRuntime_module_u("textarea", {
-                                    rows: 1,
+                                /*#__PURE__*/ jsxRuntime_module_u(TextInput, {
+                                    type: markdown,
                                     value: value,
                                     minLength: minLength,
                                     maxLength: maxLength,
@@ -5555,7 +5575,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 +5588,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 +5603,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 +5616,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.17",
+  "version": "0.20.0",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",