tsondb 0.12.6 → 0.12.8

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

@@ -5,5 +5,11 @@ export type TypeScriptRendererOptions = {
     preserveFiles: boolean;
     generateEntityMapType: boolean;
     addIdentifierToEntities: boolean;
+    /**
+     * Infer translation parameter types from the message strings in a {@link TranslationObjectType TranslationObject} as branded types.
+     */
+    inferTranslationParameters?: {
+        format: "mf2";
+    };
 };
 export declare const render: (options: Partial<TypeScriptRendererOptions> | undefined, declarations: readonly Decl[]) => string;

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

@@ -3,6 +3,7 @@ import { dirname, relative } from "node:path";
 import { discriminatorKey } from "../../../shared/enum.js";
 import { unique } from "../../../shared/utils/array.js";
 import { toCamelCase } from "../../../shared/utils/string.js";
+import { extractParameterTypeNamesFromMessage, mapParameterTypeNames, } from "../../../shared/utils/translation.js";
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { asDecl } from "../../schema/declarations/Declaration.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
@@ -14,7 +15,7 @@ import { getTypeOfKey } from "../../schema/types/generic/TranslationObjectType.j
 import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
-import { combineSyntaxes, emptyRenderResult, indent, prefixLines, syntax, } from "../../utils/render.js";
+import { combineSyntaxes, emptyRenderResult, getIndentation, indent, prefixLines, syntax, } from "../../utils/render.js";
 const defaultOptions = {
     indentation: 2,
     objectTypeKeyword: "interface",
@@ -62,8 +63,34 @@ const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.va
     ? ""
     : syntax `${EOL}${caseName}: ${renderType(options, caseDef.type)}`}`)}${EOL}}`)));
 const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));
+const mapTypeNameToType = (typeName) => {
+    switch (typeName) {
+        case "string":
+            return "string";
+        case "number":
+        case "integer":
+            return "number";
+        case "date":
+        case "datetime":
+        case "time":
+            return "Date";
+        case null:
+        default:
+            return "StringableTranslationParameter";
+    }
+};
+const renderTranslationParameterBrand = (options, params) => {
+    if (options.inferTranslationParameters === undefined) {
+        return emptyRenderResult;
+    }
+    const entries = Object.entries(params);
+    if (entries.length === 0) {
+        return emptyRenderResult;
+    }
+    return syntax ` & { __params: { ${entries.map(([name, type]) => `"${name}": ${type}`).join("; ")} } }`;
+};
 const renderTranslationObjectType = (options, type) => {
-    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}`), EOL));
+    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}${renderTranslationParameterBrand(options, mapParameterTypeNames(extractParameterTypeNamesFromMessage(name), mapTypeNameToType))}`), EOL));
 };
 const renderType = (options, type) => {
     switch (type.kind) {
@@ -135,6 +162,11 @@ const renderEntityMapType = (options, declarations) => syntax `export type Entit
     .filter(isEntityDecl)
     .sort((a, b) => a.name.localeCompare(b.name))
     .map(decl => syntax `${decl.name}: ${decl.name}`), EOL))}${EOL}}${EOL + EOL}`;
+const renderStringableTranslationParameterType = (options) => options.inferTranslationParameters?.format === "mf2"
+    ? "export type StringableTranslationParameter = {\n" +
+        prefixLines(getIndentation(options.indentation, 1), "toString(): string") +
+        "\n}\n\n"
+    : "";
 export const render = (options = defaultOptions, declarations) => {
     const finalOptions = { ...defaultOptions, ...options };
     const [_, entityMap] = finalOptions.generateEntityMapType
@@ -154,6 +186,7 @@ export const render = (options = defaultOptions, declarations) => {
         return undefined;
     }, declarations));
     return (entityMap +
+        renderStringableTranslationParameterType(finalOptions) +
         (finalOptions.preserveFiles
             ? (declarations[0] === undefined ? "" : renderImports(declarations[0].sourceUrl, imports)) +
                 content

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

@@ -20,6 +20,13 @@ const checkDuplicateIdentifier = (existingDecls, decl) => {
         throw new Error(`Duplicate declaration name "${decl.name}" in "${decl.sourceUrl}" and "${existingDeclWithSameName.sourceUrl}". Make sure declaration names are globally unique.`);
     }
 };
+// const checkReservedIdentifier = (decl: NestedDecl) => {
+//   if (RESERVED_DECLARATION_IDENTIFIER.includes(decl.name)) {
+//     throw new Error(
+//       `Declaration "${decl.name}" in "${decl.sourceUrl}" uses a reserved identifier name.`,
+//     )
+//   }
+// }
 const checkParameterNamesShadowing = (decls) => {
     for (const decl of decls) {
         for (const param of getParameterNames(decl)) {
@@ -219,9 +226,10 @@ export const Schema = (declarations, localeEntity) => {
     debug("collecting nested declarations ...");
     const allDecls = addDeclarations([], localeEntity ? declarations.concat(localeEntity) : declarations);
     debug("found %d nested declarations", allDecls.length);
-    debug("checking for duplicate identifiers ...");
+    debug("checking for duplicate identifiers ..."); // debug("checking for duplicate or reserved identifiers ...")
     allDecls.forEach((decl, declIndex) => {
         checkDuplicateIdentifier(allDecls.slice(0, declIndex), decl);
+        // checkReservedIdentifier(decl)
     });
     const allDeclsWithoutNestedEntities = allDecls.filter(decl => decl.kind !== "NestedEntity");
     debug("checking name shadowing ...");

package/dist/src/node/schema/declarations/EntityDecl.d.ts

@@ -1,28 +1,30 @@
 import { Lazy } from "../../../shared/utils/lazy.ts";
-import type { Leaves } from "../../../shared/utils/object.ts";
 import type { DisplayNameCustomizer } from "../../utils/displayName.ts";
-import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, Validator } from "../Node.ts";
+import type { GetNestedDeclarations, GetReferences, Predicate, Serialized, TypeArgumentsResolver, Validator } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
 import type { MemberDecl, ObjectType } from "../types/generic/ObjectType.ts";
 import { StringType } from "../types/primitives/StringType.ts";
-import type { AsType } from "../types/Type.ts";
+import type { NestedEntityMapType } from "../types/references/NestedEntityMapType.ts";
 import type { BaseDecl } from "./Declaration.ts";
 import { TypeAliasDecl } from "./TypeAliasDecl.ts";
 export type GenericEntityDisplayName = string | {
     pathToLocaleMap?: string;
     pathInLocaleMap?: string;
 } | null;
-export type EntityDisplayName<T extends TConstraint> = Leaves<AsType<ObjectType<T>>> | {
+export type EntityDisplayName<T extends TConstraint> = PathTo<T, StringType> | {
     /**
      * @default "translations"
      */
-    pathToLocaleMap?: Leaves<AsType<ObjectType<T>>>;
+    pathToLocaleMap?: PathTo<T, NestedEntityMapType>;
     /**
      * @default "name"
      */
     pathInLocaleMap?: string;
 } | null;
 type TConstraint = Record<string, MemberDecl>;
+type PathTo<T extends TConstraint, R> = {
+    [K in keyof T]: T[K] extends MemberDecl<infer V> ? V extends R ? K : R extends V ? string : T[K] extends ObjectType<infer P> ? `${Extract<K, string>}.${PathTo<P, R>}` : never : never;
+}[Extract<keyof T, string>];
 export interface EntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends BaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
@@ -31,7 +33,7 @@ export interface EntityDecl<Name extends string = string, T extends TConstraint
     /**
      * @default "name"
      */
-    displayName?: EntityDisplayName<T>;
+    displayName?: GenericEntityDisplayName;
     displayNameCustomizer?: DisplayNameCustomizer<ObjectType<T>>;
     isDeprecated?: boolean;
 }
@@ -75,5 +77,5 @@ export declare const addEphemeralUUIDToType: <T extends TConstraint>(decl: Entit
 }>;
 export declare const createEntityIdentifierType: () => StringType;
 export declare const createEntityIdentifierTypeAsDecl: <Name extends string>(decl: EntityDecl<Name>) => TypeAliasDecl<`${Name}_ID`, StringType, []>;
-export declare const serializeEntityDecl: Serializer<EntityDecl>;
+export declare const serializeEntityDecl: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(type: EntityDecl<Name, T, FK>) => Serialized<EntityDecl<Name, T, FK>>;
 export declare const getReferencesForEntityDecl: GetReferences<EntityDecl>;

package/dist/src/node/schema/declarations/EntityDecl.js

@@ -49,12 +49,12 @@ export const createEntityIdentifierTypeAsDecl = (decl) => TypeAliasDecl(decl.sou
     name: (decl.name + "_ID"),
     type: createEntityIdentifierType,
 });
-export const serializeEntityDecl = (type) => ({
+export const serializeEntityDecl = ((type) => ({
     ...type,
     type: serializeObjectType(type.type.value),
     displayName: typeof type.displayName === "function"
         ? null
         : type.displayName,
     displayNameCustomizer: type.displayNameCustomizer !== undefined,
-});
+}));
 export const getReferencesForEntityDecl = (decl, value, inDecl) => getReferencesForObjectType(decl.type.value, value, [...inDecl, decl]);

package/dist/src/node/schema/declarations/EnumDecl.d.ts

@@ -1,3 +1,4 @@
+import { type EnumValue } from "../../../shared/schema/declarations/EnumDecl.ts";
 import { Lazy } from "../../../shared/utils/lazy.ts";
 import type { GetNestedDeclarations, GetReferences, Predicate, Serializer, TypeArgumentsResolver, ValidatorOfParamDecl } from "../Node.ts";
 import { NodeKind } from "../Node.ts";
@@ -33,3 +34,4 @@ export declare const resolveTypeArgumentsInEnumDecl: TypeArgumentsResolver<EnumD
 export declare const serializeEnumDecl: Serializer<EnumDecl>;
 export declare const getReferencesForEnumDecl: GetReferences<EnumDecl>;
 export declare const cases: <T extends TConstraint>(decl: EnumDecl<string, T>) => EnumCaseDecl<T[keyof T]["type"]>[];
+export declare const getAnyEnumCaseValue: <K extends string, V>(enumValue: { [Key in K]: EnumValue<Key, V>; }[K]) => V;

package/dist/src/node/schema/declarations/EnumDecl.js

@@ -1,3 +1,4 @@
+import { ENUM_DISCRIMINATOR_KEY, } from "../../../shared/schema/declarations/EnumDecl.js";
 import { Lazy } from "../../../shared/utils/lazy.js";
 import { onlyKeys } from "../../../shared/utils/object.js";
 import { NodeKind } from "../Node.js";
@@ -46,3 +47,4 @@ export const serializeEnumDecl = decl => ({
 });
 export const getReferencesForEnumDecl = (decl, value, inDecl) => getReferencesForEnumType(decl.type.value, value, [...inDecl, decl]);
 export const cases = (decl) => Object.values(decl.type.value.values);
+export const getAnyEnumCaseValue = (enumValue) => enumValue[enumValue[ENUM_DISCRIMINATOR_KEY]];

package/dist/src/node/schema/types/Type.d.ts

@@ -25,14 +25,28 @@ type EnumCaseTypeAsType<Case extends string, T extends Type | null> = T extends
 } : {
     kind: Case;
 };
-export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
+type EnumCaseTypeAsDeepType<Case extends string, T extends Type | null> = T extends object ? {
+    kind: Case;
+} & {
+    [AV in Case]: AsDeepType<T>;
+} : {
+    kind: Case;
+};
+type MemberDeclsAsType<P extends Record<string, MemberDecl>> = {
     [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsType<TA> : Decl extends EnumDecl<string, infer EC> ? AsType<EnumType<EC>> : unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
-    [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
+};
+type MemberDeclsAsDeepType<P extends Record<string, MemberDecl>> = {
+    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsDeepType<P[K]["type"]> : // eslint-disable-next-line @typescript-eslint/no-redundant-type-constituents -- it does make a difference here
+    AsDeepType<P[K]["type"]> | undefined;
+};
+export type AsDeepType<T extends Type> = T extends ArrayType<infer I> ? AsDeepType<I>[] : T extends ObjectType<infer P> ? MemberDeclsAsDeepType<P> : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType<TypeParameter[], infer Decl> ? Decl extends TypeAliasDecl<string, infer TA> ? AsDeepType<TA> : Decl extends EnumDecl<string, infer EC> ? AsDeepType<EnumType<EC>> : unknown : T extends NestedEntityMapType<string, infer TC> ? {
+    [id: string]: MemberDeclsAsDeepType<TC>;
+} : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? never : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+    [Case in keyof EC]: EnumCaseTypeAsDeepType<Case & string, EC[Case]["type"]>;
 }[keyof EC] : never : never;
-export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? {
-    [K in keyof P]: P[K] extends MemberDecl<Type, true> ? AsType<P[K]["type"]> : AsType<P[K]["type"]> | undefined;
-} : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType ? unknown : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
+export type AsType<T extends Type> = T extends ArrayType<infer I> ? AsType<I>[] : T extends ObjectType<infer P> ? MemberDeclsAsType<P> : T extends BooleanType ? boolean : T extends DateType ? Date : T extends FloatType ? number : T extends IntegerType ? number : T extends StringType ? string : T extends TypeArgumentType ? unknown : T extends IncludeIdentifierType ? unknown : T extends NestedEntityMapType<string, infer TC> ? {
+    [id: string]: MemberDeclsAsType<TC>;
+} : T extends ReferenceIdentifierType ? string : T extends ChildEntitiesType ? string[] : T extends EnumType<infer EC> ? EC extends Record<string, EnumCaseDecl> ? {
     [Case in keyof EC]: EnumCaseTypeAsType<Case & string, EC[Case]["type"]>;
 }[keyof EC] : never : never;
 export type AsNode<T> = T extends (infer I)[] ? ArrayType<AsNode<I>> : T extends Record<string, unknown> ? ObjectType<{

package/dist/src/node/utils/displayName.js

@@ -4,6 +4,7 @@ export const getDisplayNameFromEntityInstance = (entity, instanceContainer, getI
     if (useCustomizer && entity.displayNameCustomizer) {
         const calculatedName = getDisplayNameFromEntityInstance(entity, instanceContainer, getInstanceById, getChildInstancesForInstanceId, locales, defaultName, false);
         return entity.displayNameCustomizer({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-assignment -- otherwise type instiatiation too deep
             instance: instanceContainer.content,
             instanceId: instanceContainer.id,
             instanceDisplayName: calculatedName.name,

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

@@ -7,4 +7,5 @@ export type RenderResult = [imports: {
 export declare const emptyRenderResult: RenderResult;
 export declare const combineSyntaxes: (syntaxes: (RenderResult | string | undefined)[], separator?: string) => RenderResult;
 export declare const syntax: (strings: TemplateStringsArray, ...values: (RenderResult | string | undefined)[]) => RenderResult;
+export declare const getIndentation: (spaces: number, indentLevel: number) => string;
 export declare const indent: (spaces: number, indentLevel: number, text: RenderResult) => RenderResult;

package/dist/src/node/utils/render.js

@@ -28,7 +28,8 @@ export const syntax = (strings, ...values) => strings.reduce((acc, str, i) => {
         return [acc[0], acc[1] + str.replace(/\n/g, EOL)];
     }
 }, emptyRenderResult);
+export const getIndentation = (spaces, indentLevel) => " ".repeat(spaces * indentLevel);
 export const indent = (spaces, indentLevel, text) => [
     text[0],
-    prefixLines(" ".repeat(spaces * indentLevel), text[1]),
+    prefixLines(getIndentation(spaces, indentLevel), text[1]),
 ];

package/dist/src/shared/schema/declarations/EntityDecl.d.ts

@@ -1,20 +1,24 @@
-import type { Leaves } from "../../../shared/utils/object.ts";
+import type { GenericEntityDisplayName } from "../../../node/schema/index.ts";
 import { NodeKind, type GetReferencesSerialized, type SerializedNode, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import type { SerializedNestedEntityMapType } from "../types/NestedEntityMapType.ts";
 import { type SerializedMemberDecl, type SerializedObjectType } from "../types/ObjectType.ts";
-import type { SerializedAsType } from "../types/Type.ts";
+import type { SerializedStringType } from "../types/StringType.ts";
 import type { SerializedBaseDecl } from "./Declaration.ts";
-export type SerializedEntityDisplayName<T extends SerializedObjectType> = Leaves<SerializedAsType<T>> | {
+export type SerializedEntityDisplayName<T extends TSerializedConstraint> = SerializedPathTo<T, SerializedStringType> | {
     /**
      * @default "translations"
      */
-    pathToLocaleMap?: Leaves<SerializedAsType<T>>;
+    pathToLocaleMap?: SerializedPathTo<T, SerializedNestedEntityMapType>;
     /**
      * @default "name"
      */
     pathInLocaleMap?: string;
 } | null;
-type TConstraint = Record<string, SerializedMemberDecl>;
-export interface SerializedEntityDecl<Name extends string = string, T extends TConstraint = TConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends SerializedBaseDecl<Name, []> {
+type TSerializedConstraint = Record<string, SerializedMemberDecl>;
+type SerializedPathTo<T extends TSerializedConstraint, R> = {
+    [K in keyof T]: T[K] extends SerializedMemberDecl<infer V> ? V extends R ? K : R extends V ? string : T[K] extends SerializedObjectType<infer P> ? `${Extract<K, string>}.${SerializedPathTo<P, R>}` : never : never;
+}[Extract<keyof T, string>];
+export interface SerializedEntityDecl<Name extends string = string, T extends TSerializedConstraint = TSerializedConstraint, FK extends Extract<keyof T, string> | undefined = Extract<keyof T, string> | undefined> extends SerializedBaseDecl<Name, []> {
     kind: NodeKind["EntityDecl"];
     namePlural: string;
     type: SerializedObjectType<T>;
@@ -22,13 +26,13 @@ export interface SerializedEntityDecl<Name extends string = string, T extends TC
     /**
      * @default "name"
      */
-    displayName?: SerializedEntityDisplayName<SerializedObjectType<T>>;
+    displayName?: GenericEntityDisplayName;
     displayNameCustomizer: boolean;
     isDeprecated?: boolean;
 }
 export declare const isSerializedEntityDecl: (node: SerializedNode) => node is SerializedEntityDecl;
-export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TConstraint, FK extends Extract<keyof T, string> | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
-export declare const isSerializedEntityDeclWithoutParentReference: <Name extends string, T extends TConstraint>(decl: SerializedEntityDecl<Name, T>) => decl is SerializedEntityDecl<Name, T, undefined>;
+export declare const isSerializedEntityDeclWithParentReference: <Name extends string, T extends TSerializedConstraint, FK extends Extract<keyof T, string> | undefined>(decl: SerializedEntityDecl<Name, T, FK>) => decl is SerializedEntityDecl<Name, T, NonNullable<FK>>;
+export declare const isSerializedEntityDeclWithoutParentReference: <Name extends string, T extends TSerializedConstraint>(decl: SerializedEntityDecl<Name, T>) => decl is SerializedEntityDecl<Name, T, undefined>;
 export declare const resolveTypeArgumentsInSerializedEntityDecl: SerializedTypeArgumentsResolver<SerializedEntityDecl>;
 export declare const getReferencesForSerializedEntityDecl: GetReferencesSerialized<SerializedEntityDecl>;
 export {};

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

@@ -2,7 +2,7 @@ export declare const sortObjectKeys: (obj: Record<string, unknown>, keys: string
 export declare const sortObjectKeysAlphabetically: (obj: Record<string, unknown>) => Record<string, unknown>;
 export declare const mergeObjects: <T>(obj1: Record<string, T>, obj2: Record<string, T>, solveConflict: (a: T, b: T) => T) => Record<string, T>;
 export type Leaves<T> = T extends object ? {
-    [K in keyof T]: T[K] extends unknown[] ? never : `${Exclude<K, symbol>}${Leaves<T[K]> extends never ? "" : `.${Leaves<T[K]>}`}`;
+    [K in keyof T]: T[K] extends unknown[] ? never : `${Extract<K, string>}${Leaves<T[K]> extends never ? "" : `.${Leaves<T[K]>}`}`;
 }[keyof T] : never;
 export declare const onlyKeys: <T extends object, K extends keyof T>(obj: T, ...keys: K[]) => Pick<T, K>;
 export declare const hasKey: <T extends object, K extends PropertyKey>(obj: T, key: K) => obj is T & { [k in K]: unknown; };

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

@@ -0,0 +1,2 @@
+export declare const extractParameterTypeNamesFromMessage: (message: string) => Record<string, string | null>;
+export declare const mapParameterTypeNames: <T>(typeMap: Record<string, string | null>, map: (typeName: string | null) => T) => Record<string, T>;

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

@@ -0,0 +1,66 @@
+import { MessageError, parseMessage } from "messageformat";
+import { assertExhaustive } from "./typeSafety.js";
+const mergeAssoc = (acc, key, value) => {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- if there is a previous value and the current result is null, keep the more specific one
+    return { ...acc, [key]: value ?? acc[key] };
+};
+const reduceMapAssoc = (map, acc, item) => {
+    const result = map(item);
+    if (result) {
+        return mergeAssoc(acc, result[0], result[1]);
+    }
+    return acc;
+};
+const reduceADT = (cases, acc, item) => {
+    const caseFn = cases[item.type];
+    return caseFn?.(acc, item) ?? acc;
+};
+const extractParameterFromDeclaration = (decl) => {
+    switch (decl.type) {
+        case "input":
+            return [decl.name, decl.value.functionRef?.name ?? null];
+        case "local":
+            return undefined;
+        default:
+            return assertExhaustive(decl);
+    }
+};
+const extractParametersFromDeclarations = (decls) => decls.reduce((acc, decl) => reduceMapAssoc(extractParameterFromDeclaration, acc, decl), {});
+const reduceParametersFromPattern = (acc, pattern) => pattern.reduce((acc, element) => {
+    if (typeof element === "string") {
+        return acc;
+    }
+    return reduceADT({
+        expression: (acc, element) => {
+            if (!element.arg) {
+                return acc;
+            }
+            return reduceADT({
+                variable: (acc, variable) => mergeAssoc(acc, variable.name, element.functionRef?.name ?? null),
+            }, acc, element.arg);
+        },
+    }, acc, element);
+}, acc);
+export const extractParameterTypeNamesFromMessage = (message) => {
+    try {
+        const dataModel = parseMessage(message);
+        switch (dataModel.type) {
+            case "message":
+                return reduceParametersFromPattern(extractParametersFromDeclarations(dataModel.declarations), dataModel.pattern);
+            case "select": {
+                return dataModel.selectors.reduce((acc, variable) => mergeAssoc(acc, variable.name, null), dataModel.variants.reduce((acc, variant) => reduceParametersFromPattern(acc, variant.value), extractParametersFromDeclarations(dataModel.declarations)));
+            }
+            default:
+                return assertExhaustive(dataModel);
+        }
+    }
+    catch (error) {
+        if (error instanceof MessageError) {
+            throw new MessageError(error.message, message);
+        }
+        else {
+            throw error;
+        }
+    }
+};
+export const mapParameterTypeNames = (typeMap, map) => Object.fromEntries(Object.entries(typeMap).map(([key, typeName]) => [key, map(typeName)]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.12.6",
+  "version": "0.12.8",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -50,6 +50,7 @@
     "@preact/signals": "^2.5.1",
     "debug": "^4.4.3",
     "express": "^5.1.0",
+    "messageformat": "^4.0.0",
     "preact": "^10.27.2",
     "preact-iso": "^2.11.0",
     "simple-cli-args": "^0.1.3",