libmodulor 0.22.0 → 0.24.0

package/dist/esm/std/impl/SimpleMapI18nManager.js

@@ -12,20 +12,34 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 var SimpleMapI18nManager_1;
 import { inject, injectable } from 'inversify';
-import { I18N_DEFAULT_LANG, } from '../../i18n/index.js';
 let SimpleMapI18nManager = class SimpleMapI18nManager {
     static { SimpleMapI18nManager_1 = this; }
     i18n;
     logger;
     static PLACEHOLDERS_REGEX = /{{([A-Z-a-z0-9]+)}}/g; // Note the 'g' so it can be used with `matchAll`
+    langs;
     entries;
+    currentLang;
     constructor(i18n, logger) {
         this.i18n = i18n;
         this.logger = logger;
+        this.langs = Object.keys(i18n);
+        if (this.langs.length === 0) {
+            throw new Error('I18n must define at least one lang');
+        }
         this.entries = new Map();
+        // biome-ignore lint/style/noNonNullAssertion: we want it
+        this.currentLang = this.langs[0];
     }
     async add(key, value) {
-        this.entries.set(key, value);
+        this.current().set(key, value);
+    }
+    availableLangs() {
+        return this.langs;
+    }
+    async changeLang(lang) {
+        this.currentLang = lang;
+        this.initCommon();
     }
     async init() {
         this.initCommon();
@@ -34,10 +48,10 @@ let SimpleMapI18nManager = class SimpleMapI18nManager {
         this.initCommon();
     }
     l() {
-        return I18N_DEFAULT_LANG;
+        return this.currentLang;
     }
     t(key, opts) {
-        const v = this.entries.get(key);
+        const v = this.current().get(key);
         if (v) {
             return this.replacePlaceholders(v, opts);
         }
@@ -47,17 +61,32 @@ let SimpleMapI18nManager = class SimpleMapI18nManager {
         return key; // Mimic the behavior of some common libraries like i18next
     }
     initCommon() {
-        const translations = this.i18n[this.l()];
-        this.logger.trace('Initializing I18nManager', { translations });
-        if (!translations) {
-            return;
-        }
-        for (const [k, v] of Object.entries(translations)) {
-            this.entries.set(k, v);
+        for (const lang of this.langs) {
+            const translations = this.i18n[lang];
+            this.logger.trace('Initializing I18nManager', {
+                lang,
+                translations,
+            });
+            if (!translations) {
+                return;
+            }
+            if (!this.entries.has(lang)) {
+                this.entries.set(lang, new Map());
+            }
+            for (const [k, v] of Object.entries(translations)) {
+                this.entries.get(lang)?.set(k, v);
+            }
         }
     }
     tOrNull(key, _opts) {
-        return this.entries.get(key) || null;
+        return this.current().get(key) || null;
+    }
+    current() {
+        const entry = this.entries.get(this.currentLang);
+        if (!entry) {
+            throw new Error(`I18nManager must contain an entry for lang : ${this.currentLang}`);
+        }
+        return entry;
     }
     replacePlaceholders(v, opts) {
         // DO NOT USE THIS IN PRODUCTION

package/dist/esm/target/lib/client/consts.js

@@ -2,6 +2,7 @@
  * @see TARGET_DEFAULT_SERVER_MANAGER_SETTINGS
  */
 export const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS = {
+    server_cookies_name_auth: 'auth',
     server_public_api_key: 'PublicApiKeyToBeChangedWhenDeploying',
     server_public_api_key_header_name: 'X-API-Key',
     server_public_url: 'http://localhost:7443',

package/dist/esm/target/lib/react/UCPanel.d.ts

@@ -6,17 +6,16 @@ import type { RenderUCForm } from './form.js';
 import type { RenderUCAutoExecLoader } from './loader.js';
 import type { UCPanelCtx, UCPanelOnDone, UCPanelOnError, UCPanelOnInit, UCPanelOnStartSubmitting } from './panel.js';
 import type { RenderUCExecTouchable } from './touchable.js';
-type Props<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Pick<UCPanelCtx<I, OPI0, OPI1>, 'clearAfterExec' | 'uc'> & {
-    autoExec?: boolean;
-    onDone?: UCPanelOnDone<I, OPI0, OPI1>;
-    onInit?: UCPanelOnInit<I, OPI0, OPI1>;
-    onError?: UCPanelOnError;
-    onStartSubmitting?: UCPanelOnStartSubmitting;
+export type Props<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Pick<UCPanelCtx<I, OPI0, OPI1>, 'clearAfterExec' | 'uc'> & {
+    autoExec?: boolean | undefined;
+    onDone?: UCPanelOnDone<I, OPI0, OPI1> | undefined;
+    onInit?: UCPanelOnInit<I, OPI0, OPI1> | undefined;
+    onError?: UCPanelOnError | undefined;
+    onStartSubmitting?: UCPanelOnStartSubmitting | undefined;
     renderAutoExecLoader: RenderUCAutoExecLoader;
     renderExecTouchable: RenderUCExecTouchable<I, OPI0, OPI1>;
     renderForm: RenderUCForm<I, OPI0, OPI1>;
-    sleepInMs?: UIntDuration;
+    sleepInMs?: UIntDuration | undefined;
     stream?: StreamConfig<UCOutputReader<I, OPI0, OPI1>> | undefined;
 };
 export declare function UCPanel<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ autoExec, clearAfterExec, onDone, onError, onInit, onStartSubmitting, renderAutoExecLoader, renderForm, renderExecTouchable, sleepInMs, stream, uc, }: Props<I, OPI0, OPI1>): ReactElement;
-export {};

package/dist/esm/target/lib/react/useUC.js

@@ -1,4 +1,4 @@
-import { useState } from 'react';
+import { useEffect, useState } from 'react';
 import { UC, } from '../../../uc/index.js';
 /**
  * This hook provides utilities to init a use case and perform actions on it in a React way
@@ -21,6 +21,16 @@ export function useUC(appManifest, def, auth, opts) {
         }
         return v;
     });
+    // biome-ignore lint/correctness/useExhaustiveDependencies(appManifest): avoid infinite re-rendering
+    // biome-ignore lint/correctness/useExhaustiveDependencies(def): avoid infinite re-rendering
+    // biome-ignore lint/correctness/useExhaustiveDependencies(opts?.fillWith): avoid infinite re-rendering
+    useEffect(() => {
+        const v = new UC(appManifest, def, auth);
+        if (opts?.fillWith) {
+            v.fill(opts?.fillWith);
+        }
+        setUC(v);
+    }, [auth]);
     /**
      * Get a new `UC` based on the initial one
      * @param i

package/dist/esm/target/lib/server/AuthenticationChecker.js

@@ -80,7 +80,7 @@ let AuthenticationChecker = class AuthenticationChecker {
                     }
                     break;
                 default:
-                    ((_) => { })(authType);
+                    authType;
             }
             uc.auth = output.auth;
             const { allowed } = await policy.exec({ uc });

package/dist/esm/target/lib/server/PublicApiKeyChecker.js

@@ -39,7 +39,7 @@ let PublicApiKeyChecker = class PublicApiKeyChecker {
                 }
                 break;
             default:
-                ((_) => { })(checkType);
+                checkType;
         }
         if (!allowed) {
             throw new UnauthorizedError();

package/dist/esm/target/lib/server/ServerManager.d.ts

@@ -27,6 +27,7 @@ export interface ServerManagerSettings extends ServerManagerAuthSettings, Settin
     server_ssl_fullchain_path: FilePath | null;
     server_ssl_key_path: FilePath | null;
     server_static_dir_path: DirPath | null;
+    server_stop_mode: 'aggressive' | 'patient';
     server_tmp_path: FilePath;
 }
 export interface ServerManager extends Initializable {

package/dist/esm/target/lib/server/ServerRequestHandler.js

@@ -127,7 +127,7 @@ let ServerRequestHandler = class ServerRequestHandler {
                 uc.fill((await req.bodyFromQueryParams()));
                 break;
             default:
-                ((_) => { })(envelope);
+                envelope;
         }
     }
     async applySideEffects(res, ucd, output) {
@@ -154,7 +154,7 @@ let ServerRequestHandler = class ServerRequestHandler {
                     await this.applySetAuthSideEffect(res, item);
                     break;
                 default:
-                    ((_) => { })(type);
+                    (type);
             }
         }
         return { status: undefined };

package/dist/esm/target/lib/server/consts.js

@@ -19,5 +19,6 @@ export const TARGET_DEFAULT_SERVER_MANAGER_SETTINGS = {
     server_ssl_fullchain_path: null,
     server_ssl_key_path: null,
     server_static_dir_path: null,
+    server_stop_mode: 'patient',
     server_tmp_path: 'tmp',
 };

package/dist/esm/target/lib/server-express/funcs.js

@@ -14,7 +14,9 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
             case 'stream': {
                 execOpts = {
                     stream: {
-                        onClose: async () => { },
+                        onClose: async () => {
+                            throw new Error('execOpts.stream.onClose needs to be set in the UC ServerMain');
+                        },
                         onData: async (output) => {
                             if (!output) {
                                 return;
@@ -31,13 +33,12 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 }
                 res.flushHeaders();
                 res.on('close', async () => {
-                    res.end();
                     await execOpts?.stream?.onClose();
                 });
                 break;
             }
             default:
-                ((_) => { })(transportType);
+                transportType;
         }
         const { body, status } = await serverRequestHandler.exec({
             appManifest,
@@ -66,7 +67,7 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 return;
             }
             default:
-                ((_) => { })(transportType);
+                transportType;
         }
     };
     return handler;

package/dist/esm/target/lib/server-hono/funcs.js

@@ -51,7 +51,7 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 break;
             }
             default:
-                ((_) => { })(transportType);
+                transportType;
         }
         const { body, status } = await serverRequestHandler.exec({
             appManifest,
@@ -80,7 +80,7 @@ export function buildHandler(appManifest, ucd, contract, serverRequestHandler, u
                 });
             }
             default:
-                ((_) => { })(transportType);
+                transportType;
         }
         return c.json(body, status);
     };

package/dist/esm/target/lib/server-node/funcs.d.ts

@@ -1,5 +1,5 @@
 import type { Logger, SettingsManager } from '../../../std/index.js';
 import type { EntrypointsBuilder } from '../server/EntrypointsBuilder.js';
-import type { ListenSettings, Server } from './types.js';
+import type { ListenSettings, Server, StopSettings } from './types.js';
 export declare function listen(server: Server, entrypointsBuilder: EntrypointsBuilder, logger: Logger, settingsManager: SettingsManager<ListenSettings>): void;
-export declare function stop(server: Server): Promise<void>;
+export declare function stop(server: Server, settingsManager: SettingsManager<StopSettings>): Promise<void>;

package/dist/esm/target/lib/server-node/funcs.js

@@ -5,16 +5,26 @@ export function listen(server, entrypointsBuilder, logger, settingsManager) {
         logger.info(`Listening on ${entrypointsBuilder.exec().http}`);
     });
 }
-export async function stop(server) {
+export async function stop(server, settingsManager) {
     if (!server?.listening) {
         return;
     }
+    const mode = settingsManager.get()('server_stop_mode');
     // As stated in the docs of `close`, only awaiting `.close` is not enough to make sure all the connections are closed.
     // Hence the wrapping in a promise, where the callback is called when the 'close' event is emitted.
     return new Promise((resolve, reject) => {
         if (!server) {
             return resolve();
         }
+        switch (mode) {
+            case 'aggressive':
+                server.closeAllConnections();
+                break;
+            case 'patient':
+                break;
+            default:
+                mode;
+        }
         server.close((err) => {
             if (err) {
                 return reject(err);

package/dist/esm/target/lib/server-node/types.d.ts

@@ -3,3 +3,4 @@ import type https from 'node:https';
 import type { ServerManagerSettings } from '../server/ServerManager.js';
 export type Server = http.Server | https.Server;
 export type ListenSettings = Pick<ServerManagerSettings, 'server_binding_host' | 'server_binding_port'>;
+export type StopSettings = Pick<ServerManagerSettings, 'server_stop_mode'>;

package/dist/esm/target/node-express-server/NodeExpressServerManager.d.ts

@@ -8,8 +8,8 @@ import type { ServerManager, ServerManagerSettings } from '../lib/server/ServerM
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
 import { HelmetMiddlewareBuilder } from '../lib/server-express/HelmetMiddlewareBuilder.js';
-import type { ListenSettings } from '../lib/server-node/types.js';
-type S = ListenSettings & Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_tmp_path'>;
+import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
+type S = ListenSettings & Pick<LoggerSettings, 'logger_level'> & Pick<ServerManagerSettings, 'server_tmp_path'> & StopSettings;
 export declare class NodeExpressServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;

package/dist/esm/target/node-express-server/NodeExpressServerManager.js

@@ -47,6 +47,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
             logger_level: this.settingsManager.get()('logger_level'),
             server_binding_host: this.settingsManager.get()('server_binding_host'),
             server_binding_port: this.settingsManager.get()('server_binding_port'),
+            server_stop_mode: this.settingsManager.get()('server_stop_mode'),
             server_tmp_path: this.settingsManager.get()('server_tmp_path'),
         };
     }
@@ -79,7 +80,7 @@ let NodeExpressServerManager = class NodeExpressServerManager {
         listen(this.server, this.entrypointsBuilder, this.logger, this.settingsManager);
     }
     async stop() {
-        await stop(this.server);
+        await stop(this.server, this.settingsManager);
     }
     async warmUp() {
         // Nothing to do

package/dist/esm/target/node-hono-server/NodeHonoServerManager.d.ts

@@ -7,8 +7,8 @@ import { EntrypointsBuilder } from '../lib/server/EntrypointsBuilder.js';
 import type { ServerManager } from '../lib/server/ServerManager.js';
 import { ServerRequestHandler } from '../lib/server/ServerRequestHandler.js';
 import { ServerSSLCertLoader } from '../lib/server/ServerSSLCertLoader.js';
-import type { ListenSettings } from '../lib/server-node/types.js';
-type S = ListenSettings;
+import type { ListenSettings, StopSettings } from '../lib/server-node/types.js';
+type S = ListenSettings & StopSettings;
 export declare class NodeHonoServerManager implements Configurable<S>, ServerManager {
     private entrypointsBuilder;
     protected environmentManager: EnvironmentManager;

package/dist/esm/target/node-hono-server/NodeHonoServerManager.js

@@ -44,6 +44,7 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         return {
             server_binding_host: this.settingsManager.get()('server_binding_host'),
             server_binding_port: this.settingsManager.get()('server_binding_port'),
+            server_stop_mode: this.settingsManager.get()('server_stop_mode'),
         };
     }
     getRuntime() {
@@ -75,7 +76,7 @@ let NodeHonoServerManager = class NodeHonoServerManager {
         listen(this.server, this.entrypointsBuilder, this.logger, this.settingsManager);
     }
     async stop() {
-        await stop(this.server);
+        await stop(this.server, this.settingsManager);
     }
     async warmUp() {
         // Nothing to do

package/dist/esm/target/node-stricli-cli/NodeStricliCLIManager.d.ts

@@ -0,0 +1,12 @@
+import { WordingManager } from '../../i18n/index.js';
+import { type ProductManifest, ProductUCsLoader } from '../../product/index.js';
+import type { CLIManager, Input, Output } from '../lib/cli/CLIManager.js';
+import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
+export declare class NodeStricliCLIManager implements CLIManager {
+    private commandExecutor;
+    private productManifest;
+    private productUCsLoader;
+    private wordingManager;
+    constructor(commandExecutor: CommandExecutor, productManifest: ProductManifest, productUCsLoader: ProductUCsLoader, wordingManager: WordingManager);
+    handleCommand({ appsRootPath, srcImporter, }: Input): Promise<Output>;
+}

package/dist/esm/target/node-stricli-cli/NodeStricliCLIManager.js

@@ -0,0 +1,118 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { buildApplication, buildCommand, buildRouteMap, run, } from '@stricli/core';
+import { inject, injectable } from 'inversify';
+import { WordingManager } from '../../i18n/index.js';
+import { ProductUCsLoader } from '../../product/index.js';
+import { ucifHint, ucifIsMandatory, ucifRepeatability, ucMountingPoint, } from '../../uc/index.js';
+import { CommandExecutor } from '../lib/cli/CommandExecutor.js';
+let NodeStricliCLIManager = class NodeStricliCLIManager {
+    commandExecutor;
+    productManifest;
+    productUCsLoader;
+    wordingManager;
+    constructor(commandExecutor, productManifest, productUCsLoader, wordingManager) {
+        this.commandExecutor = commandExecutor;
+        this.productManifest = productManifest;
+        this.productUCsLoader = productUCsLoader;
+        this.wordingManager = wordingManager;
+    }
+    async handleCommand({ appsRootPath, srcImporter, }) {
+        const ucs = await this.productUCsLoader.exec({
+            appsRootPath,
+            srcImporter,
+        });
+        const routes = {};
+        for (const uc of ucs) {
+            const mountingPoint = uc.def.ext?.cmd?.mountAt ?? ucMountingPoint(uc);
+            routes[mountingPoint] = buildCommand({
+                docs: {
+                    brief: this.wordingManager.uc(uc.def).desc ?? '',
+                },
+                func: async (flags) => {
+                    uc.fill(flags);
+                    await this.commandExecutor.exec({ uc });
+                },
+                parameters: {
+                    flags: {},
+                },
+            });
+            const { flags } = routes[mountingPoint].parameters;
+            if (!flags) {
+                throw new Error('Init the flags first');
+            }
+            for (const f of this.commandExecutor.fieldsForFlags(uc)) {
+                const { def } = f;
+                const { desc, label } = this.wordingManager.ucif(f);
+                const brief = desc ?? label;
+                const defaultValue = def.type.getDefaultValue();
+                const [isRepeatable, _max] = ucifRepeatability(def);
+                const options = def.type.getOptions();
+                const hasOptions = options && options.length > 0;
+                const hint = ucifHint(def);
+                const common = {
+                    brief,
+                    default: defaultValue,
+                    optional: !ucifIsMandatory(def),
+                    placeholder: hint ?? '',
+                    variadic: isRepeatable,
+                };
+                if (hasOptions) {
+                    flags[f.key] = {
+                        ...common,
+                        kind: 'enum',
+                        values: options?.map((o) => o.value),
+                    };
+                }
+                else {
+                    flags[f.key] = {
+                        ...common,
+                        kind: 'parsed',
+                        parse: (raw) => {
+                            def.type.assign(raw);
+                            const val = def.type.val();
+                            def.type.clear();
+                            return val;
+                        },
+                    };
+                }
+            }
+        }
+        const { desc, slogan } = this.wordingManager.p();
+        const root = buildRouteMap({
+            docs: {
+                brief: desc ?? slogan ?? '',
+            },
+            routes,
+        });
+        const app = buildApplication(root, {
+            name: this.productManifest.name,
+            versionInfo: {
+                currentVersion: await this.commandExecutor.version(),
+            },
+        });
+        await run(app, process.argv.slice(2), {
+            process: process,
+        });
+    }
+};
+NodeStricliCLIManager = __decorate([
+    injectable(),
+    __param(0, inject(CommandExecutor)),
+    __param(1, inject('ProductManifest')),
+    __param(2, inject(ProductUCsLoader)),
+    __param(3, inject(WordingManager)),
+    __metadata("design:paramtypes", [CommandExecutor, Object, ProductUCsLoader,
+        WordingManager])
+], NodeStricliCLIManager);
+export { NodeStricliCLIManager };

package/dist/esm/testing/AppTester.js

@@ -12,7 +12,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 };
 import { inject, injectable } from 'inversify';
 import { I18nEN } from '../i18n/locales/en.js';
-import { I18nFR } from '../i18n/locales/fr.js';
 import { FAKE_USER_ADMIN, UCBuilder, ucHTTPContract, } from '../uc/index.js';
 // We inject directly the implementation because we'll generate all the reports and not only the one that is bound to the interface.
 // We can plan a setting à la Vitest where we specify the types of reports to generate though.
@@ -88,9 +87,13 @@ let AppTester = class AppTester {
         }
     }
     async checkAppI18n() {
+        if (!this.ucDefSourcesCheckerOutput) {
+            throw new Error('checkUCDSources must be called before checkAppI18n');
+        }
         const { errors } = await this.appI18nChecker.exec({
             appI18n: this.ctx.appI18n,
             appManifest: this.ctx.appManifest,
+            ucDefSourcesCheckerOutput: this.ucDefSourcesCheckerOutput,
         });
         if (errors.length > 0) {
             throw new Error(errors[0]);
@@ -302,15 +305,11 @@ let AppTester = class AppTester {
         const appLangCodes = Object.keys(appI18n);
         const coreI18n = {
             en: I18nEN,
-            fr: I18nFR,
         };
         const productI18n = {
             en: {
                 ...I18nEN,
             },
-            fr: {
-                ...I18nFR,
-            },
         };
         for (const l of appLangCodes) {
             if (!(l in coreI18n)) {

package/dist/esm/testing/UCDefASTParser.d.ts

@@ -1,21 +1,39 @@
 import type { ErrorMessage, FilePath } from '../dt/index.js';
 import type { UCDefLifecycle, UCMetadata, UCOutputPartIdx } from '../uc/index.js';
 import type { AppTesterOptsAllSet } from './opts.js';
-export interface OutputItemField<T extends string = string> {
+export interface OutputItemField<T = string> {
     err: ErrorMessage | null;
     value: T;
 }
+export type OutputItemFieldIOField = OutputItemField<{
+    /**
+     * @example `FreeTextShort`
+     */
+    dataType: string | null;
+    /**
+     * @example `name`
+     */
+    name: string | null;
+    /**
+     * @example `name: UCInputField<FreeTextShort>`
+     */
+    raw: string | null;
+    /**
+     * @example `UCInputField<FreeTextShort>`
+     */
+    type: string | null;
+}>;
 export interface OutputItem {
     constName: OutputItemField | null;
     externalImports: OutputItemField[] | null;
     filePath: OutputItemField | null;
     internalImports: OutputItemField[] | null;
     ioI: OutputItemField | null;
-    ioIFields: OutputItemField[] | null;
+    ioIFields: OutputItemFieldIOField[] | null;
     ioOPI0: OutputItemField | null;
-    ioOPI0Fields: OutputItemField[] | null;
+    ioOPI0Fields: OutputItemFieldIOField[] | null;
     ioOPI1: OutputItemField | null;
-    ioOPI1Fields: OutputItemField[] | null;
+    ioOPI1Fields: OutputItemFieldIOField[] | null;
     lifecycleClientPolicy: OutputItemField | null;
     lifecycleClientSteps: OutputItemField[] | null;
     lifecycleServerPolicy: OutputItemField | null;
@@ -29,10 +47,10 @@ export interface OutputItem {
 }
 export declare const OUTPUT_ITEM_FIELDS: (keyof OutputItem)[];
 export type OnImport = (name: string) => void;
-export type OnInputType = (name: string, fields: OutputItemField[]) => void;
+export type OnInputType = (name: string, fields: OutputItemFieldIOField[]) => void;
 export type OnMainStep = (lifecycle: UCDefLifecycle, step: string) => void;
 export type OnMetadata = (metadata: UCMetadata) => void;
-export type OnOPIType = (name: string, fields: OutputItemField[], idx: UCOutputPartIdx) => void;
+export type OnOPIType = (name: string, fields: OutputItemFieldIOField[], idx: UCOutputPartIdx) => void;
 export type OnPolicy = (lifecycle: UCDefLifecycle, name: string) => void;
 export type OnVariable = (name: string) => void;
 export interface UCDefASTParser {

package/dist/esm/testing/impl/SimpleAppDocsEmitter.js

@@ -11,7 +11,7 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import { APP_DOCS_FILE_NAME, UC_INPUT_FIELD_PATTERN, UC_MAIN_STEP_PREFIX_REGULAR, } from '../../convention.js';
+import { APP_DOCS_FILE_NAME, UC_MAIN_STEP_PREFIX_REGULAR, } from '../../convention.js';
 import { OUTPUT_ITEM_FIELDS, } from '../UCDefASTParser.js';
 let SimpleAppDocsEmitter = class SimpleAppDocsEmitter {
     fsManager;
@@ -142,9 +142,8 @@ function diagramUCClientConfirm(participant, caller) {
     ];
 }
 function diagramUCFields(fields) {
-    return (fields
-        ?.map((f) => f.value.replace(new RegExp(UC_INPUT_FIELD_PATTERN.slice(1)), '$1'))
-        .join(LB) || '');
+    return (fields?.map((f) => `${f.value.name}: ${f.value.dataType}`).join(LB) ||
+        '');
 }
 function diagramUCMainSteps(participant, field) {
     return field.map((f) => `${participant}->>${participant}: ${f.value.replace(UC_MAIN_STEP_PREFIX_REGULAR, '').trim()}`);
@@ -171,7 +170,7 @@ function fmtTechSummaryField(field) {
 }
 function fmtTechSummaryFieldVal(field) {
     const { err, value } = field;
-    let res = value;
+    let res = (typeof value === 'string' ? value : value.raw) ?? '';
     if (err) {
         res += `❌ ${err}`;
     }