libmodulor 0.24.0 → 0.26.0

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

@@ -0,0 +1,59 @@
+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 { inject, injectable } from 'inversify';
+import { APP_DOCS_FILE_NAME } from '../../../convention.js';
+import { techSummary } from './tech-summary.js';
+import { ucSummary } from './uc-summary.js';
+let SimpleAppDocsEmitter = class SimpleAppDocsEmitter {
+    fsManager;
+    constructor(fsManager) {
+        this.fsManager = fsManager;
+    }
+    async exec({ appPath, ucDefSourcesCheckerOutput, }) {
+        const outPath = this.fsManager.path(appPath, APP_DOCS_FILE_NAME);
+        const tpl = template(ucDefSourcesCheckerOutput.items);
+        await this.fsManager.touch(outPath, tpl);
+        return {
+            outPath,
+        };
+    }
+};
+SimpleAppDocsEmitter = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __metadata("design:paramtypes", [Object])
+], SimpleAppDocsEmitter);
+export { SimpleAppDocsEmitter };
+// For now, we can have it here. When it becomes harder to maintain, we can introduce some kind of template engine.
+// Be aware that this will introduce complexities on building the lib.
+// We'll need to include these templates in the build and make them accessible via package.json "exports" or any other mechanism.
+// Hence the choice to keep it simple for now.
+// Defined it as function in case we need to pass args.
+// Using --- for the comment to make it compatible with pandoc
+// See https://stackoverflow.com/a/4829998/1259118
+const template = (items) => `<!---
+    All this code has been auto generated.
+    DO NOT EDIT.
+    Or be prepared to see all your changes erased at the next generation.
+-->
+
+# App
+
+## Use Cases
+
+${items.map(ucSummary).join('\n\n')}
+
+## Technical Summary
+
+${techSummary(items)}
+`;

package/dist/esm/testing/impl/SimpleAppDocsEmitter/markdown.d.ts

@@ -0,0 +1,2 @@
+export declare function pre(val: string | null | undefined): string;
+export declare function thead(cols: string[]): string;

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/VitestAppTestSuiteEmitter.d.ts

@@ -4,4 +4,6 @@ export declare class VitestAppTestSuiteEmitter implements AppTestSuiteEmitter {
     private fsManager;
     constructor(fsManager: FSManager);
     exec({ appPath, depsMapping, idx, monkeyTestingTimeoutInMs, serverPortRangeStart, }: Input): Promise<Output>;
+    private createConfiguratorIfNotExists;
+    private mapDeps;
 }

package/dist/esm/testing/impl/VitestAppTestSuiteEmitter.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_I18N_NAME, APP_INDEX_NAME, APP_MANIFEST_NAME, APP_TEST_DIR_NAME, APP_TEST_MAIN_FILE_NAME, } from '../../convention.js';
+import { APP_I18N_NAME, APP_INDEX_NAME, APP_MANIFEST_NAME, APP_TEST_CONFIGURATOR_FILE_NAME, APP_TEST_CONFIGURATOR_NAME, APP_TEST_DIR_NAME, APP_TEST_MAIN_FILE_NAME, } from '../../convention.js';
 let VitestAppTestSuiteEmitter = class VitestAppTestSuiteEmitter {
     fsManager;
     constructor(fsManager) {
@@ -21,16 +21,29 @@ let VitestAppTestSuiteEmitter = class VitestAppTestSuiteEmitter {
         const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
         // Since we're using 'recursive: true', there will be no error if the directory already exists
         await this.fsManager.mkdir(testPath, { recursive: true });
-        const outPath = this.fsManager.path(testPath, APP_TEST_MAIN_FILE_NAME);
-        let tpl = template(serverPortRangeStart, idx, monkeyTestingTimeoutInMs);
-        depsMapping?.forEach((to, from) => {
-            tpl = tpl.replaceAll(`from '${from}'`, `from '${to}'`);
-        });
-        await this.fsManager.touch(outPath, tpl);
+        await this.createConfiguratorIfNotExists(testPath, depsMapping);
+        const testFilePath = this.fsManager.path(testPath, APP_TEST_MAIN_FILE_NAME);
+        const tpl = this.mapDeps(depsMapping, template(serverPortRangeStart, idx, monkeyTestingTimeoutInMs));
+        await this.fsManager.touch(testFilePath, tpl);
         return {
-            outPath,
+            outPath: testFilePath,
         };
     }
+    async createConfiguratorIfNotExists(testPath, depsMapping) {
+        const filePath = this.fsManager.path(testPath, APP_TEST_CONFIGURATOR_FILE_NAME);
+        if (await this.fsManager.exists(filePath)) {
+            return;
+        }
+        const tpl = this.mapDeps(depsMapping, CONFIGURATOR_TS);
+        await this.fsManager.touch(filePath, tpl);
+    }
+    mapDeps(depsMapping, tpl) {
+        let res = tpl;
+        depsMapping?.forEach((to, from) => {
+            res = res.replaceAll(`from '${from}'`, `from '${to}'`);
+        });
+        return res;
+    }
 };
 VitestAppTestSuiteEmitter = __decorate([
     injectable(),
@@ -38,6 +51,10 @@ VitestAppTestSuiteEmitter = __decorate([
     __metadata("design:paramtypes", [Object])
 ], VitestAppTestSuiteEmitter);
 export { VitestAppTestSuiteEmitter };
+const CONFIGURATOR_TS = `import { NodeAppTesterConfigurator } from 'libmodulor/node-test';
+
+export class ${APP_TEST_CONFIGURATOR_NAME} extends NodeAppTesterConfigurator {}
+`;
 // For now, we can have it here. When it becomes harder to maintain, we can introduce some kind of template engine.
 // Be aware that this will introduce complexities on building the lib.
 // We'll need to include these templates in the build and make them accessible via package.json "exports" or any other mechanism.
@@ -72,10 +89,10 @@ import {
 import { newNodeAppTester } from 'libmodulor/node-test';
 import { afterAll, afterEach, beforeAll, describe, expect, test } from 'vitest';
 
-import { Configurator } from './Configurator.js';
+import { ${APP_TEST_CONFIGURATOR_NAME} } from './${APP_TEST_CONFIGURATOR_NAME}.js';
 
 const appPath = join(import.meta.dirname, '..');
-const configurator = new Configurator();
+const configurator = new ${APP_TEST_CONFIGURATOR_NAME}();
 const runner = await newNodeAppTester(${serverPortRangeStart}, ${idx}, {
     appPath,
     configurator,

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

@@ -5,12 +5,12 @@ import { TARGET_DEFAULT_SERVER_MANAGER_SETTINGS } from '../../target/lib/server/
 import { NodeExpressServerManager } from '../../target/node-express-server/NodeExpressServerManager.js';
 import { FAKE_USER_ADMIN, FAKE_USER_REGULAR } from '../../uc/index.js';
 import { CONTAINER_OPTS } from '../../utils/index.js';
-import { bindCommon } from '../../utils/ioc/bindCommon.js';
+import { bindCommon, updateSettings } from '../../utils/ioc/bindCommon.js';
 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;
@@ -18,8 +18,6 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
     const settings = {
         ...STD_DEFAULT_JWT_MANAGER_SETTINGS,
         ...TARGET_DEFAULT_SERVER_MANAGER_SETTINGS,
-        jwt_manager_audience: 'libmodulor-test',
-        jwt_manager_issuer: 'libmodulor-test',
         jwt_manager_secret: new TPassword().example(),
         logger_level,
         server_basic_auth_entries: {
@@ -31,7 +29,8 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
         server_stop_mode: 'aggressive',
     };
     const container = new Container(CONTAINER_OPTS);
-    bindCommon(container, () => settings);
+    bindCommon(container);
+    updateSettings(container, settings);
     bindNodeCore(container);
     bindServer(container);
     container.bind('AppDocsEmitter').to(SimpleAppDocsEmitter);

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

@@ -43,7 +43,7 @@ export type AppTesterOpts = Partial<Pick<LoggerSettings, 'logger_level'>> & {
                  */
                 aliasPrefix?: AppTesterOptsAliasPrefix;
                 /**
-                 * @defaultValue ['fik-sdk', 'inversify']
+                 * @defaultValue ['libmodulor', 'inversify']
                  */
                 allowed?: AppTesterOptsImportsList;
             };

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/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

package/dist/esm/uc/exec.js

@@ -1,20 +1,55 @@
 /**
  * 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 var UCExecMode;
-(function (UCExecMode) {
+export const UCExecMode = {
     /**
      * The use case has been executed programmatically
      */
-    UCExecMode["AUTO"] = "auto";
+    AUTO: 'auto',
     /**
      * The use case has been executed explicitly by a user
      */
-    UCExecMode["USER"] = "user";
-})(UCExecMode || (UCExecMode = {}));
+    USER: 'user',
+};
+/**
+ * Result of execution of a use case
+ */
+export const UCExecRes = {
+    /**
+     * The user aborted the exec (e.g. by not confirming)
+     */
+    ABORTED: 'aborted',
+    /**
+     * The execution failed
+     */
+    FAILED: 'failed',
+    /**
+     * The execution succeeded
+     */
+    SUCCEEDED: 'succeeded',
+};
+/**
+ * State of execution of a use case
+ * It applies to a form, but it can be applied and generalized to any other interaction mechanism (i.e. cli, voice...).
+ */
+export const UCExecState = {
+    /**
+     * An action triggered a change, fields should be disabled
+     */
+    CHANGING: 'changing',
+    /**
+     * It can be touched and filled by the user
+     */
+    IDLE: 'idle',
+    /**
+     * It's initializing in some way, fields should be disabled
+     */
+    INITIALIZING: 'initializing',
+    /**
+     * It's submitting, fields should be disabled and some indicator should show the processing
+     */
+    SUBMITTING: 'submitting',
+};
 /**
  * Check whether the execution corresponds to a "disabled" state
  *
@@ -24,19 +59,19 @@ export var UCExecMode;
  * @returns
  */
 export function ucIsDisabled(execState) {
-    return execState !== 'idle';
+    return execState !== UCExecState.IDLE;
 }
 /**
  * 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
  */
 export function ucIsLoading(execState) {
-    return execState === 'submitting';
+    return execState === UCExecState.SUBMITTING;
 }
 /**
  * Check whether the execution corresponds to an "error" result
@@ -45,5 +80,5 @@ export function ucIsLoading(execState) {
  * @returns
  */
 export function ucIsOnErr(execRes) {
-    return execRes === 'failed';
+    return execRes === UCExecRes.FAILED;
 }

package/dist/esm/uc/input-field.d.ts

@@ -1,16 +1,18 @@
 import type { DataType, TBase, UIntQuantity } from '../dt/index.js';
+import type { EnumOf } from '../utils/index.js';
 import type { UCFieldKey } from './def.js';
 import type { Value } from './value.js';
-export declare enum UCInputFieldFillingMode {
+export declare const UCInputFieldFillingMode: {
     /**
      * Set programmatically on behalf of the user (e.g. a foreign key id for a given object)
      */
-    AUTO_PRE = "AUTO_PRE",
+    readonly AUTO_PRE: "AUTO_PRE";
     /**
      * Set manually by the user (e.g. a form field, a cli flag, etc.)
      */
-    MANUAL = "MANUAL"
-}
+    readonly MANUAL: "MANUAL";
+};
+export type UCInputFieldFillingMode = EnumOf<typeof UCInputFieldFillingMode>;
 export interface UCInputFieldDefCardinality {
     max?: UIntQuantity;
     min?: UIntQuantity;

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

@@ -1,14 +1,13 @@
-export var UCInputFieldFillingMode;
-(function (UCInputFieldFillingMode) {
+export const UCInputFieldFillingMode = {
     /**
      * Set programmatically on behalf of the user (e.g. a foreign key id for a given object)
      */
-    UCInputFieldFillingMode["AUTO_PRE"] = "AUTO_PRE";
+    AUTO_PRE: 'AUTO_PRE',
     /**
      * Set manually by the user (e.g. a form field, a cli flag, etc.)
      */
-    UCInputFieldFillingMode["MANUAL"] = "MANUAL";
-})(UCInputFieldFillingMode || (UCInputFieldFillingMode = {}));
+    MANUAL: 'MANUAL',
+};
 export function ucifExamples(def) {
     const { type } = def;
     const examples = type.getExamples();