libmodulor 0.23.0 → 0.25.0

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

@@ -0,0 +1,10 @@
+export function pre(val) {
+    if (!val) {
+        return '-';
+    }
+    return `\`${val}\``;
+}
+export function thead(cols) {
+    return `|#|${cols.join('|')}|
+|---|${cols.map(() => '---').join('|')}|`;
+}

package/dist/esm/testing/impl/SimpleAppDocsEmitter/sequence-diagram.d.ts

@@ -0,0 +1,2 @@
+import type { OutputItem } from '../../UCDefASTParser.js';
+export declare function ucSequenceDiagram(item: OutputItem): string;

package/dist/esm/testing/impl/SimpleAppDocsEmitter/sequence-diagram.js

@@ -0,0 +1,92 @@
+import { UC_MAIN_STEP_PREFIX_REGULAR } from '../../../convention.js';
+const CHECK_POLICY = '🔐 Check policy';
+const CHECK_POLICY_COND = 'when any validation fails';
+const CHECK_POLICY_COND_ACTION = 'show failure';
+const CLIENT_CONFIRM_N_COND = 'when does not confirm';
+const CLIENT_CONFIRM_N_COND_ACTION = 'stop everything';
+const CLIENT_CONFIRM_Q = '❓ Sure';
+const CLIENT_CONFIRM_Y = 'Yes';
+const FILL = '✏️ Fill';
+const LB = '<br/>';
+const OK = '👍 OK';
+const SEND = '📤 Send';
+const SUBMIT = '↩️ Submit';
+const TRIGGER = '⤴️ Trigger';
+export function ucSequenceDiagram(item) {
+    // Debugger : https://mermaid.live/edit
+    // Messages : https://mermaid.js.org/syntax/sequenceDiagram.html#messages
+    const client = 'Client';
+    const server = 'Server';
+    const user = 'User';
+    const lines = [`actor ${user}`];
+    const { ioIFields, ioOPI0Fields, ioOPI1Fields, lifecycleClientPolicy, lifecycleClientSteps, lifecycleServerPolicy, lifecycleServerSteps, metadataSensitive, } = item;
+    let req = TRIGGER;
+    if (ioIFields && ioIFields.length > 0) {
+        // TODO : Include only fields to fill manually ?
+        // Not sure though, as for CLI for example (i.e. noContext), one needs to provide all of them
+        req = `${FILL}${LB}${fields(item.ioIFields)}`;
+    }
+    lines.push(`${user}->>+${client}: ${req}`);
+    lines.push(`${user}->>${client}: ${SUBMIT}`);
+    if (metadataSensitive?.value) {
+        lines.push(...clientConfirm(client, user));
+    }
+    if (lifecycleClientPolicy) {
+        lines.push(...policy(client, user, lifecycleClientPolicy));
+    }
+    if (lifecycleClientSteps) {
+        lines.push(...mainSteps(client, lifecycleClientSteps));
+    }
+    // This is an approximation. Might need to improve it.
+    const hasServer = item.lifecycleServerPolicy?.value;
+    if (hasServer) {
+        req = SEND;
+        if (ioIFields && ioIFields.length > 0) {
+            req = `${req}${LB}${fields(item.ioIFields)}`;
+        }
+        lines.push(`${client}->>+${server}: ${req}`);
+        if (lifecycleServerPolicy) {
+            lines.push(...policy(server, user, lifecycleServerPolicy));
+        }
+        if (lifecycleServerSteps) {
+            lines.push(...mainSteps(server, lifecycleServerSteps));
+        }
+        let res = '';
+        if (ioOPI0Fields && ioOPI0Fields.length > 0) {
+            res += `${res}${LB}${fields(item.ioOPI0Fields)}`;
+        }
+        if (ioOPI1Fields && ioOPI1Fields?.length > 0) {
+            res += `${res}${LB}${fields(item.ioOPI1Fields)}`;
+        }
+        lines.push(`${server}-->>-${client}: ${OK}${res}`);
+    }
+    lines.push(`${client}-->>-${user}: ${OK}`);
+    return `\`\`\`mermaid
+sequenceDiagram
+    ${lines.join('\n    ')}
+\`\`\``;
+}
+function clientConfirm(participant, caller) {
+    return [
+        `${participant}->>${caller}: ${CLIENT_CONFIRM_Q}`,
+        `${caller}->>${participant}: ${CLIENT_CONFIRM_Y}`,
+        `break ${CLIENT_CONFIRM_N_COND}`,
+        `    ${participant}-->${caller}: ${CLIENT_CONFIRM_N_COND_ACTION}`,
+        'end',
+    ];
+}
+function fields(fields) {
+    return (fields?.map((f) => `${f.value.name}: ${f.value.dataType}`).join(LB) ||
+        '');
+}
+function mainSteps(participant, field) {
+    return field.map((f) => `${participant}->>${participant}: ${f.value.replace(UC_MAIN_STEP_PREFIX_REGULAR, '').trim()}`);
+}
+function policy(participant, caller, lifecyclePolicyField) {
+    return [
+        `${participant}->>${participant}: ${CHECK_POLICY} "${lifecyclePolicyField.value}"`,
+        `break ${CHECK_POLICY_COND}`,
+        `    ${participant}-->${caller}: ${CHECK_POLICY_COND_ACTION}`,
+        'end',
+    ];
+}

package/dist/esm/testing/impl/SimpleAppDocsEmitter/tech-summary.d.ts

@@ -0,0 +1,2 @@
+import { type OutputItem } from '../../UCDefASTParser.js';
+export declare function techSummary(items: OutputItem[]): string;

package/dist/esm/testing/impl/SimpleAppDocsEmitter/tech-summary.js

@@ -0,0 +1,27 @@
+import { OUTPUT_ITEM_FIELDS, } from '../../UCDefASTParser.js';
+import { thead } from './markdown.js';
+export function techSummary(items) {
+    return `${thead(OUTPUT_ITEM_FIELDS)}
+${items
+        .map((item, idx) => ['', idx + 1, ...OUTPUT_ITEM_FIELDS.map((f) => val(item[f])), ''].join('|'))
+        .join('\n')}`;
+}
+function val(value) {
+    if (!value) {
+        return '';
+    }
+    const values = Array.isArray(value) ? value : [value];
+    // NOTE : <br> won't work for every markdown renderer.
+    // See https://stackoverflow.com/questions/11700487/how-do-i-add-a-newline-in-a-markdown-table
+    return values.map(fmtVal).join('<br>');
+}
+function fmtVal(field) {
+    const { err, value } = field;
+    let res = (typeof value === 'string' ? value : value.raw) ?? '';
+    if (err) {
+        res += `❌ ${err}`;
+    }
+    res = res.replace(/[\u00A0-\u9999<>&]/g, (i) => `&#${i.charCodeAt(0)};`); // TS generics considered as HTML
+    res = res.replaceAll('|', '\\|'); // TS intersection vs Markdown table column
+    return res;
+}

package/dist/esm/testing/impl/SimpleAppDocsEmitter/uc-summary.d.ts

@@ -0,0 +1,2 @@
+import type { OutputItem } from '../../UCDefASTParser.js';
+export declare function ucSummary(item: OutputItem): string;

package/dist/esm/testing/impl/SimpleAppDocsEmitter/uc-summary.js

@@ -0,0 +1,63 @@
+import { humanize } from '../../../utils/index.js';
+import { pre, thead } from './markdown.js';
+import { ucSequenceDiagram } from './sequence-diagram.js';
+export function ucSummary(item) {
+    return `### ${item.metadataName?.value}
+
+${lifecycle(item)}
+
+${fields(item)}
+
+#### Sequence Diagram
+
+${ucSequenceDiagram(item)}`;
+}
+const UC_FIELDS_TABLES_COLS = ['name', 'humanized', 'dataType'];
+function fields(item) {
+    const { ioIFields, ioOPI0Fields, ioOPI1Fields } = item;
+    return `#### Input (I)
+
+${ucFieldsTable(ioIFields)}
+
+#### Output (O)
+
+##### Part 0 (OPI0)
+
+${ucFieldsTable(ioOPI0Fields)}
+
+##### Part 1 (OPI1)
+
+${ucFieldsTable(ioOPI1Fields)}`;
+}
+function ucFieldsTable(fields) {
+    if (!fields || fields.length === 0) {
+        return 'None';
+    }
+    return `${thead(UC_FIELDS_TABLES_COLS)}
+${fields
+        ?.map(({ value: { dataType, name } }, idx) => [
+        '',
+        idx + 1,
+        pre(name),
+        name ? humanize(name) : '',
+        pre(dataType),
+        '',
+    ].join('|'))
+        .join('\n')}`;
+}
+function lifecycle(item) {
+    const { lifecycleClientPolicy, lifecycleServerPolicy } = item;
+    return `- **Type** : ${pre(lifecycleType(item))}
+- **Client Policy** : ${pre(lifecycleClientPolicy?.value)}
+- **Server Policy** : ${pre(lifecycleServerPolicy?.value)}`;
+}
+function lifecycleType(item) {
+    const { lifecycleClientPolicy, lifecycleServerPolicy } = item;
+    if (lifecycleClientPolicy && lifecycleServerPolicy) {
+        return 'Client / Server';
+    }
+    if (lifecycleClientPolicy) {
+        return 'Client only';
+    }
+    return 'Server only';
+}

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}`;
     }

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

@@ -11,7 +11,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import typescript, { isClassDeclaration, isObjectLiteralExpression, isPropertyAssignment, } from 'typescript';
+import typescript, { isClassDeclaration, isObjectLiteralExpression, isPropertyAssignment, SyntaxKind, } from 'typescript';
+// https://ts-ast-viewer.com
 // To avoid the following error when used in a consumer :
 // SyntaxError: Named export 'ModuleKind' not found. The requested module 'typescript' is a CommonJS module, which may not support all module.exports as named exports.
 // CommonJS modules can always be imported via the default export
@@ -99,20 +100,46 @@ let TypeScriptLibUCDefASTParser = class TypeScriptLibUCDefASTParser {
     }
     getTypeFields(node) {
         const type = this.typeChecker.getTypeAtLocation(node);
-        const fields = type.getProperties().map((p) => {
+        const fields = type
+            .getProperties()
+            .map((p) => {
             const field = {
                 err: null,
-                value: p.getName(),
+                value: {
+                    dataType: null,
+                    name: null,
+                    raw: null,
+                    type: null,
+                },
             };
             const declarations = p.getDeclarations();
-            if (declarations) {
-                const [first] = declarations;
-                if (first && isPropertySignature(first)) {
-                    field.value = first
-                        .getText()
-                        .replaceAll('\n', '')
-                        .replaceAll(';', '');
-                }
+            if (!declarations) {
+                return field;
+            }
+            const [first] = declarations;
+            if (first && isPropertySignature(first)) {
+                field.value.raw = first
+                    .getText()
+                    .replaceAll('\n', '')
+                    .replaceAll(';', '')
+                    .replaceAll(/\s+/g, ' ');
+                first.forEachChild((node1) => {
+                    if (isIdentifier(node1)) {
+                        field.value.name = node1.getText();
+                    }
+                    else if (isTypeReferenceNode(node1)) {
+                        field.value.type = node1.getText();
+                        node1.forEachChild((node2) => {
+                            if (isIdentifier(node2) ||
+                                isTypeReferenceNode(node2) ||
+                                node2.kind === SyntaxKind.BooleanKeyword ||
+                                node2.kind === SyntaxKind.NumberKeyword ||
+                                node2.kind === SyntaxKind.StringKeyword) {
+                                field.value.dataType = node2.getText();
+                            }
+                        });
+                    }
+                });
             }
             return field;
         });

package/dist/esm/testing/impl/VitestAppTestSuiteRunner.d.ts

@@ -5,7 +5,7 @@ export declare class VitestAppTestSuiteRunner implements AppTestSuiteRunner {
     private fsManager;
     private shellCommandExecutor;
     constructor(fsManager: FSManager, shellCommandExecutor: ShellCommandExecutor);
-    exec({ appPath, skipCoverage, updateSnapshots, }: Input): Promise<void>;
+    exec({ appPath, only, skipCoverage, updateSnapshots, }: Input): Promise<void>;
     coverageReportEntrypointPath(appPath: FilePath): Promise<FilePath>;
     private coverageReportPath;
 }

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

@@ -19,18 +19,33 @@ let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
         this.fsManager = fsManager;
         this.shellCommandExecutor = shellCommandExecutor;
     }
-    async exec({ appPath, skipCoverage, updateSnapshots, }) {
+    async exec({ appPath, only, skipCoverage, updateSnapshots, }) {
         const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
         const args = [
             'run',
             '--color',
+            // https://vitest.dev/guide/cli.html#dir
             '--dir',
             appPath,
         ];
+        if (only) {
+            args.push(
+            // https://vitest.dev/guide/cli.html#testnamepattern
+            '--testNamePattern', only);
+        }
         if (!skipCoverage) {
-            args.push('--coverage.enabled', '--coverage.exclude', testPath, '--coverage.include', appPath, '--coverage.reportsDirectory', this.coverageReportPath(appPath));
+            args.push(
+            // https://vitest.dev/guide/cli.html#coverage-enabled
+            '--coverage.enabled', 
+            // https://vitest.dev/guide/cli.html#coverage-exclude
+            '--coverage.exclude', testPath, 
+            // https://vitest.dev/guide/cli.html#coverage-include
+            '--coverage.include', appPath, 
+            // https://vitest.dev/guide/cli.html#coverage-reportsdirectory
+            '--coverage.reportsDirectory', this.coverageReportPath(appPath));
         }
         if (updateSnapshots) {
+            // https://vitest.dev/guide/cli.html#update
             args.push('--update');
         }
         await this.shellCommandExecutor.exec({

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

@@ -10,7 +10,7 @@ import { bindNodeCore } from '../../utils/ioc/bindNodeCore.js';
 import { bindServer } from '../../utils/ioc/bindServer.js';
 import { AppTester } from '../AppTester.js';
 import { optsAllSet } from '../opts.js';
-import { SimpleAppDocsEmitter } from './SimpleAppDocsEmitter.js';
+import { SimpleAppDocsEmitter } from './SimpleAppDocsEmitter/SimpleAppDocsEmitter.js';
 import { TypeScriptLibUCDefASTParser } from './TypeScriptLibUCDefASTParser.js';
 export async function newNodeAppTester(serverPortRangeStart, idx, args) {
     const { configurator } = args;

package/dist/esm/testing/opts.js

@@ -4,7 +4,7 @@ export const DEFAULT_APP_TESTER_OPTS = {
         imports: {
             external: {
                 aliasPrefix: '@',
-                allowed: ['inversify', 'libmodulor'],
+                allowed: ['libmodulor', 'inversify'],
             },
             internal: {
                 maxDepth: '../../',

package/dist/esm/testing/uc-input.js

@@ -1,5 +1,6 @@
-import { TFile } from '../dt/index.js';
+import { TFile, TFilePath } from '../dt/index.js';
 import { ucifIsMandatory, ucifMustBeFilledManually, ucifRepeatability, } from '../uc/index.js';
+import { range } from '../utils/index.js';
 export const DEFAULT_UC_INPUT_FILLERS = [
     'ALL_WITH_EXAMPLES',
     'ONLY_MANDATORY_WITH_EXAMPLES',
@@ -39,7 +40,9 @@ function fillWithExample(f) {
     if (type instanceof TFile) {
         const example = type.getExamples()?.[0] ?? type.example();
         // TODO : Consider building a real file with real data (e.g. image, pdf, txt, etc.)
-        const val = new File(['01010101010101010101010101010101'], example.path, {
+        // A fake file filled with 0s and 1s
+        const blob = range(TFilePath.FILE_SIZE).map((i) => (i % 2).toString());
+        const val = new File(blob, example.uri, {
             type: example.type,
         });
         const [isRepeatable] = ucifRepeatability(f.def);

package/dist/esm/testing/workers/AppTestSuiteRunner.d.ts

@@ -1,7 +1,9 @@
 import type { FilePath } from '../../dt/index.js';
 import type { Worker } from '../../std/index.js';
+import type { UCName } from '../../uc/index.js';
 export interface Input {
     appPath: FilePath;
+    only: UCName | null;
     skipCoverage: boolean;
     updateSnapshots: boolean;
 }

package/dist/esm/testing/workers/UCExecutor.js

@@ -104,7 +104,7 @@ let UCExecutor = class UCExecutor {
                     break;
                 }
                 default:
-                    ((_) => { })(transportType);
+                    transportType;
             }
             if (!ucor) {
                 throw new Error(ERR_CLIENT_EXPECTED_UCOR(name));

package/dist/esm/testing/workers/checkers/AppI18nChecker.d.ts

@@ -1,10 +1,12 @@
 import type { AppManifest } from '../../../app/index.js';
 import type { ErrorMessage } from '../../../dt/index.js';
-import type { I18n } from '../../../i18n/index.js';
+import { type I18n } from '../../../i18n/index.js';
 import type { Worker } from '../../../std/index.js';
+import type { Output as UCDefSourcesCheckerOutput } from './UCDefSourcesChecker.js';
 export interface Input {
     appI18n: I18n;
     appManifest: Pick<AppManifest, 'languageCodes'>;
+    ucDefSourcesCheckerOutput: UCDefSourcesCheckerOutput;
 }
 export interface Output {
     errors: ErrorMessage[];
@@ -13,7 +15,11 @@ export declare class AppI18nChecker implements Worker<Input, Promise<Output>> {
     private static I18N_KEY_PATTERN;
     private output;
     constructor();
-    exec({ appI18n, appManifest }: Input): Promise<Output>;
+    exec({ appI18n, appManifest, ucDefSourcesCheckerOutput, }: Input): Promise<Output>;
     private makeSureLanguagesAreConsistent;
     private makeSureKeysAndLabelsAreValid;
+    private makeSureNonDefaultLanguagesAreFullyTranslated;
+    private checkUC;
+    private checkIOFields;
+    private checkKey;
 }

package/dist/esm/testing/workers/checkers/AppI18nChecker.js

@@ -9,9 +9,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 var AppI18nChecker_1;
 import { injectable } from 'inversify';
+import { I18N_DEFAULT_LANG, } from '../../../i18n/index.js';
 const ERR_I18N_MISMATCH = () => 'The languageCodes in app manifest must match with the keys in i18n';
 const ERR_I18N_KEY_INVALID = (key) => `The i18n key '${key}' must respect the i18n key pattern`;
-const ERR_I18N_LABEL_NO_DOT = (key) => `The i18n key '${key}' is a label, thus should not ends with a dot`;
+const ERR_I18N_LABEL_NO_DOT = (key) => `The i18n key '${key}' is a label, thus it should not end with a dot`;
+const ERR_I18N_MISSING_TRANS = (key, lang) => `The i18n key '${key}' is missing for lang '${lang}'`;
 let AppI18nChecker = class AppI18nChecker {
     static { AppI18nChecker_1 = this; }
     static I18N_KEY_PATTERN = /(dt_([A-Z][A-Za-z0-9]+)_([A-Za-z0-9]+)_(desc|label))|(err_([A-Za-z_]+))|(uc_([A-Z][A-Za-z0-9]+)_(client_confirm_(cancel|confirm|message|title)|desc|label|i_submit_(changing|idle|initializing|submitting)|op_(0|1)_(empty|label)))|(ucif_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(ucof_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(validation_([a-z]+)_([A-Z][A-Za-z0-9]+))/;
@@ -19,9 +21,10 @@ let AppI18nChecker = class AppI18nChecker {
     constructor() {
         this.output = { errors: [] };
     }
-    async exec({ appI18n, appManifest }) {
+    async exec({ appI18n, appManifest, ucDefSourcesCheckerOutput, }) {
         this.makeSureLanguagesAreConsistent(appI18n, appManifest);
         this.makeSureKeysAndLabelsAreValid(appI18n);
+        this.makeSureNonDefaultLanguagesAreFullyTranslated(appI18n, ucDefSourcesCheckerOutput);
         return this.output;
     }
     makeSureLanguagesAreConsistent(appI18n, appManifest) {
@@ -44,6 +47,45 @@ let AppI18nChecker = class AppI18nChecker {
             }
         }
     }
+    makeSureNonDefaultLanguagesAreFullyTranslated(i18n, ucDefSourcesCheckerOutput) {
+        for (const [lang, translations] of Object.entries(i18n)) {
+            if (lang === I18N_DEFAULT_LANG) {
+                // We assume the code is in English so it's fine not to have all the translations in this language.
+                // For instance, a field named "name" will be humanized as "Name", which is totally ok.
+                continue;
+            }
+            for (const { metadataName, ioIFields, ioOPI0Fields, ioOPI1Fields, } of ucDefSourcesCheckerOutput.items) {
+                this.checkUC(lang, translations, 'label', metadataName);
+                for (const [prefix, fields] of [
+                    ['ucif', ioIFields],
+                    ['ucof', ioOPI0Fields],
+                    ['ucof', ioOPI1Fields],
+                ]) {
+                    this.checkIOFields(lang, translations, prefix, 'label', fields);
+                }
+            }
+        }
+    }
+    checkUC(lang, translations, suffix, metadataName) {
+        if (!metadataName) {
+            return;
+        }
+        this.checkKey(lang, translations, `uc_${metadataName.value}_${suffix}`);
+    }
+    checkIOFields(lang, translations, prefix, suffix, fields) {
+        if (!fields) {
+            return;
+        }
+        for (const f of fields) {
+            this.checkKey(lang, translations, `${prefix}_${f.value.name}_${suffix}`);
+        }
+    }
+    checkKey(lang, translations, key) {
+        if (key in translations) {
+            return;
+        }
+        this.output.errors.push(ERR_I18N_MISSING_TRANS(key, lang));
+    }
 };
 AppI18nChecker = AppI18nChecker_1 = __decorate([
     injectable(),

package/dist/esm/testing/workers/checkers/UCDefSourcesChecker.js

@@ -18,7 +18,7 @@ const ERR_UCD_CONST_NAME = (name) => `The UCD const name '${name}' must follow t
 const ERR_UCD_FILE_SUFFIX = (fileName) => `The file '${fileName}' must end with ${UC_DEF_FILE_NAME_SUFFIX}`;
 const ERR_UCD_IMPORTS_EXTERNAL_ALLOWED = (aliasPrefix, allowed, text) => `External imports must be an alias '${aliasPrefix}*' or be one of ${allowed} (Got ${text})`;
 const ERR_UCD_IMPORTS_INTERNAL_MAX_DEPTH = (maxDepth) => `Internal imports must not be deeper than ${maxDepth}`;
-const ERR_UCD_INPUT_FIELD_PATTERN = () => `The input field def must match ${UC_INPUT_FIELD_PATTERN}`;
+const ERR_UCD_INPUT_FIELD_DECLARATION = (raw) => `The input field def must match 'name: UCInputFieldValue<DataType>' (Got '${raw}')`;
 const ERR_UCD_INPUT_TYPE_NAME = (ucName) => `The input type must be named ${ucName}${UC_INPUT_SUFFIX}`;
 const ERR_UCD_OPI_TYPE_NAME = (ucName, idx) => `The OPI must be named ${ucName}${UC_OPI_SUFFIX}${idx}`;
 // TODO : Improve the check* methods that look a little bit hacky
@@ -93,16 +93,16 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
         };
         item.ioIFields = fields;
         for (const f of item.ioIFields) {
-            const parts = f.value.split(':');
-            if (parts.length !== 2) {
-                continue;
+            const { dataType, name, raw, type } = f.value;
+            if (dataType &&
+                name &&
+                raw &&
+                type &&
+                type.match(new RegExp(UC_INPUT_FIELD_PATTERN)) !== null) {
+            }
+            else {
+                f.err = ERR_UCD_INPUT_FIELD_DECLARATION(raw);
             }
-            const [_name, type] = parts;
-            // trim because we process `name: Type` if the code is linted correctly
-            f.err =
-                type?.trim().match(new RegExp(UC_INPUT_FIELD_PATTERN)) !== null
-                    ? null
-                    : ERR_UCD_INPUT_FIELD_PATTERN();
         }
     }
     checkMainStep(lifecycle, step, item) {
@@ -120,7 +120,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
                 item.lifecycleServerSteps.push({ err: null, value: step });
                 break;
             default:
-                ((_) => { })(lifecycle);
+                lifecycle;
         }
     }
     checkMetadata(metadata, item) {
@@ -177,7 +177,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
                 };
                 break;
             default:
-                ((_) => { })(lifecycle);
+                lifecycle;
         }
     }
     async processFiles(appPath, paths) {

package/dist/esm/uc/exec.d.ts

@@ -1,38 +1,59 @@
+import type { EnumOf } from '../utils/index.js';
 /**
  * Mode of execution of a use case
- *
- * Unlike all the other enums, the values are lowercased for compatibility reasons.
- * Indeed, this value is persisted in the database so we need to support all existing deployments.
  */
-export declare enum UCExecMode {
+export declare const UCExecMode: {
     /**
      * The use case has been executed programmatically
      */
-    AUTO = "auto",
+    readonly AUTO: "auto";
     /**
      * The use case has been executed explicitly by a user
      */
-    USER = "user"
-}
+    readonly USER: "user";
+};
+export type UCExecMode = EnumOf<typeof UCExecMode>;
 /**
  * Result of execution of a use case
- *
- * - `aborted`      : The user aborted the exec (e.g. by not confirming)
- * - `failed`       : The exec failed
- * - `succeeded`    : The exec succeeded
  */
-export type UCExecRes = 'aborted' | 'failed' | 'succeeded';
+export declare const UCExecRes: {
+    /**
+     * The user aborted the exec (e.g. by not confirming)
+     */
+    readonly ABORTED: "aborted";
+    /**
+     * The execution failed
+     */
+    readonly FAILED: "failed";
+    /**
+     * The execution succeeded
+     */
+    readonly SUCCEEDED: "succeeded";
+};
+export type UCExecRes = EnumOf<typeof UCExecRes>;
 /**
  * State of execution of a use case
- *
- * - `changing`     : An action triggered a change, fields should be disabled
- * - `idle`         : It can be touched and filled by the user
- * - `initializing` : It's initializing in some way, fields should be disabled
- * - `submitting`   : It's submitting, fields should be disabled and some indicator should show the processing
- *
  * It applies to a form, but it can be applied and generalized to any other interaction mechanism (i.e. cli, voice...).
  */
-export type UCExecState = 'changing' | 'idle' | 'initializing' | 'submitting';
+export declare const UCExecState: {
+    /**
+     * An action triggered a change, fields should be disabled
+     */
+    readonly CHANGING: "changing";
+    /**
+     * It can be touched and filled by the user
+     */
+    readonly IDLE: "idle";
+    /**
+     * It's initializing in some way, fields should be disabled
+     */
+    readonly INITIALIZING: "initializing";
+    /**
+     * It's submitting, fields should be disabled and some indicator should show the processing
+     */
+    readonly SUBMITTING: "submitting";
+};
+export type UCExecState = EnumOf<typeof UCExecState>;
 /**
  * Check whether the execution corresponds to a "disabled" state
  *
@@ -45,8 +66,8 @@ export declare function ucIsDisabled(execState: UCExecState): boolean;
 /**
  * Check whether the execution corresponds to a "loading" state
  *
- * Typically, this is used to show a `loading` indicator. Thus, it's `true` when `execState === 'submitting'`.
- * Note that it's not for `changing` or `initializing` because these are not triggered by the user per sé.
+ * Typically, this is used to show a `loading` indicator. Thus, it's `true` when `execState === UCExecState.SUBMITTING`.
+ * Note that it's not for `UCExecState.CHANGING` or `UCExecState.INITIALIZING` because these are not triggered by the user per sé.
  *
  * @param execState
  * @returns