libmodulor 0.1.0 → 0.3.0

package/dist/esm/uc/impl/KnexUCDataStore.js

@@ -0,0 +1,237 @@
+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 knex, {} from 'knex';
+const FILTERS_MAPPING = new Map([
+    ['aggregateId', 'aggregate_id'],
+    ['appName', 'app_name'],
+    ['name', 'name'],
+    ['organizationId', 'organization_id'],
+    ['userId', 'user_id'],
+]);
+let KnexUCDataStore = class KnexUCDataStore {
+    settingsManager;
+    config;
+    client;
+    constructor(settingsManager) {
+        this.settingsManager = settingsManager;
+        this.config = {};
+        this.fillConfig();
+        this.client = knex(this.config);
+    }
+    s() {
+        return {
+            knex_uc_data_store_conn_string: this.settingsManager.get()('knex_uc_data_store_conn_string'),
+            knex_uc_data_store_file_path: this.settingsManager.get()('knex_uc_data_store_file_path'),
+            knex_uc_data_store_pool_max: this.settingsManager.get()('knex_uc_data_store_pool_max'),
+            knex_uc_data_store_pool_min: this.settingsManager.get()('knex_uc_data_store_pool_min'),
+            knex_uc_data_store_type: this.settingsManager.get()('knex_uc_data_store_type'),
+            uc_data_store_ucs_dataset_name: this.settingsManager.get()('uc_data_store_ucs_dataset_name'),
+        };
+    }
+    async clear() {
+        await this.client
+            .table(this.s().uc_data_store_ucs_dataset_name)
+            .truncate();
+    }
+    async destroy() {
+        await this.client.schema.dropTableIfExists(this.s().uc_data_store_ucs_dataset_name);
+    }
+    async exists() {
+        return this.client.schema.hasTable(this.s().uc_data_store_ucs_dataset_name);
+    }
+    async initTx() {
+        return this.client.transaction();
+    }
+    async install() {
+        await this.migration001CreateMainTable();
+    }
+    async read(opts) {
+        const query = this.client(this.s().uc_data_store_ucs_dataset_name);
+        if (opts?.filters) {
+            const { aggregateId, appName, idWithinInput, name, organizationId, userId, } = opts.filters;
+            this.filter(query, aggregateId, 'aggregateId');
+            this.filter(query, appName, 'appName');
+            this.filter(query, name, 'name');
+            this.filter(query, organizationId, 'organizationId');
+            this.filter(query, userId, 'userId');
+            if (idWithinInput !== undefined) {
+                for (const [k, v] of Object.entries(idWithinInput)) {
+                    query.whereJsonPath('input', `$.${k}`, '=', v);
+                }
+            }
+        }
+        query.orderBy('created_at', 'asc');
+        const records = (await query).map((r) => this.mapRowToRecord(r));
+        return {
+            records,
+        };
+    }
+    async readProjection(name, opts) {
+        const query = this.client(name);
+        if (opts?.orderBy) {
+            for (const [k, v] of Object.entries(opts.orderBy)) {
+                query.orderBy(k, v);
+            }
+        }
+        if (opts?.limit) {
+            query.limit(opts.limit);
+        }
+        const records = await query;
+        return records;
+    }
+    supportedSpecificBindings() {
+        const type = this.s().knex_uc_data_store_type;
+        switch (type) {
+            case 'pg':
+                return ['to_tsvector(?)'];
+            case 'sqlite3':
+                return [];
+            default:
+                ((_) => { })(type);
+                return [];
+        }
+    }
+    async testKey(_encryptionKey) {
+        throw new Error('Not available for this implementation.');
+    }
+    async write(record, opts) {
+        await this.writeBulk([record], opts);
+    }
+    async writeBulk(records, opts) {
+        const query = this.client(this.s().uc_data_store_ucs_dataset_name).insert(records.map((r) => this.mapRecordToRow(r)));
+        if (opts?.tx) {
+            query.transacting(opts.tx.ref);
+        }
+        await query;
+    }
+    async writeProjection(name, data, opts) {
+        const dataToInsert = {};
+        for (const [k, v] of Object.entries(data)) {
+            const specificBinding = opts?.specificBindings?.[k];
+            dataToInsert[k] =
+                specificBinding &&
+                    this.supportedSpecificBindings().includes(specificBinding)
+                    ? this.client.raw(specificBinding, [v])
+                    : v;
+        }
+        const query = this.client(name).insert(dataToInsert);
+        if (opts?.tx) {
+            query.transacting(opts.tx.ref);
+        }
+        await query;
+    }
+    fillConfig() {
+        const type = this.s().knex_uc_data_store_type;
+        this.config.client = type;
+        switch (type) {
+            case 'pg':
+                this.fillConfigForPG();
+                break;
+            case 'sqlite3':
+                this.fillConfigForSQLite3();
+                break;
+            default:
+                ((_) => { })(type);
+        }
+    }
+    fillConfigForPG() {
+        this.config.connection = {
+            connectionString: this.s().knex_uc_data_store_conn_string,
+        };
+        this.config.pool = {
+            max: this.s().knex_uc_data_store_pool_max,
+            min: this.s().knex_uc_data_store_pool_min,
+        };
+    }
+    fillConfigForSQLite3() {
+        this.config.useNullAsDefault = true;
+        this.config.connection = {
+            filename: this.s().knex_uc_data_store_file_path,
+        };
+    }
+    filter(query, value, field) {
+        if (value === undefined) {
+            return;
+        }
+        const col = FILTERS_MAPPING.get(field);
+        if (!col) {
+            return;
+        }
+        Array.isArray(value)
+            ? query.whereIn(col, value)
+            : query.where(col, value);
+    }
+    mapRecordToRow(record) {
+        return {
+            aggregate_id: record.aggregateId,
+            app_name: record.appName,
+            created_at: record.createdAt,
+            data: record.data,
+            execution_mode: record.executionMode,
+            id: record.id,
+            input: record.input,
+            name: record.name,
+            organization_id: record.organizationId,
+            user_id: record.userId,
+        };
+    }
+    mapRowToRecord(row) {
+        return {
+            aggregateId: row.aggregate_id,
+            appName: row.app_name,
+            createdAt: row.created_at,
+            data: this.parseJSONColIfNecessary(row.data),
+            executionMode: row.execution_mode,
+            id: row.id,
+            input: this.parseJSONColIfNecessary(row.input),
+            name: row.name,
+            organizationId: row.organization_id,
+            userId: row.user_id,
+        };
+    }
+    parseJSONColIfNecessary(value) {
+        return typeof value === 'string' ? JSON.parse(value) : value;
+    }
+    async migration001CreateMainTable() {
+        const exists = await this.client.schema.hasTable(this.s().uc_data_store_ucs_dataset_name);
+        if (exists) {
+            return;
+        }
+        await this.client.schema.createTable(this.s().uc_data_store_ucs_dataset_name, (table) => {
+            table.uuid('aggregate_id').notNullable();
+            table.string('app_name').notNullable();
+            table
+                .dateTime('created_at')
+                .notNullable()
+                .defaultTo(this.client.fn.now());
+            table.jsonb('data');
+            table.string('execution_mode').notNullable();
+            table.uuid('id').notNullable().primary();
+            table.jsonb('input');
+            table.string('name').notNullable();
+            table.uuid('organization_id');
+            table.uuid('user_id');
+            table.index('aggregate_id');
+            table.index('name');
+            table.index('organization_id');
+            table.index('user_id');
+        });
+    }
+};
+KnexUCDataStore = __decorate([
+    injectable(),
+    __param(0, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object])
+], KnexUCDataStore);
+export { KnexUCDataStore };

package/dist/esm/uc/impl/PromptUCClientConfirmManager.d.ts

@@ -0,0 +1,16 @@
+import { WordingManager } from '../../i18n/index.js';
+import type { PromptManager } from '../../std/index.js';
+import type { UCClientConfirmManager } from '../client.js';
+import type { UCDef } from '../def.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+export declare class PromptUCClientConfirmManager implements UCClientConfirmManager {
+    private promptManager;
+    private wordingManager;
+    private static N_ANSWERS;
+    private static Y_ANSWERS;
+    constructor(promptManager: PromptManager, wordingManager: WordingManager);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>): Promise<boolean>;
+    private isNo;
+    private isYes;
+}

package/dist/esm/uc/impl/PromptUCClientConfirmManager.js

@@ -0,0 +1,51 @@
+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); }
+};
+var PromptUCClientConfirmManager_1;
+import { inject, injectable } from 'inversify';
+import { WordingManager } from '../../i18n/index.js';
+let PromptUCClientConfirmManager = class PromptUCClientConfirmManager {
+    static { PromptUCClientConfirmManager_1 = this; }
+    promptManager;
+    wordingManager;
+    static N_ANSWERS = ['N', 'n'];
+    static Y_ANSWERS = ['Y', 'y'];
+    constructor(promptManager, wordingManager) {
+        this.promptManager = promptManager;
+        this.wordingManager = wordingManager;
+    }
+    async exec(ucd) {
+        const { cancel, confirm, message, title } = this.wordingManager.ucClientConfirm(ucd);
+        let invite = title;
+        if (message) {
+            invite = `${invite} (${message})`;
+        }
+        invite = `${invite} [${PromptUCClientConfirmManager_1.Y_ANSWERS.join()} = ${confirm} / ${PromptUCClientConfirmManager_1.N_ANSWERS} = ${cancel}]`;
+        const res = await this.promptManager.prompt(invite, {
+            validate: async (v) => this.isNo(v) || this.isYes(v),
+        });
+        return this.isYes(res);
+    }
+    isNo(res) {
+        return PromptUCClientConfirmManager_1.N_ANSWERS.includes(res);
+    }
+    isYes(res) {
+        return PromptUCClientConfirmManager_1.Y_ANSWERS.includes(res);
+    }
+};
+PromptUCClientConfirmManager = PromptUCClientConfirmManager_1 = __decorate([
+    injectable(),
+    __param(0, inject('PromptManager')),
+    __param(1, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, WordingManager])
+], PromptUCClientConfirmManager);
+export { PromptUCClientConfirmManager };

package/dist/esm/uc/impl/SimpleUCManager.d.ts

@@ -0,0 +1,39 @@
+import { type interfaces } from 'inversify';
+import type { ClockManager, CryptoManager, Logger } from '../../std/index.js';
+import type { UC } from '../UC.js';
+import type { UCClientConfirmManager } from '../client.js';
+import type { UCDataStore, UCDataStoreRecord } from '../data-store.js';
+import type { UCData } from '../data.js';
+import { UCOutputReader } from '../helpers/UCOutputReader.js';
+import type { UCInit } from '../init.js';
+import type { UCInput } from '../input.js';
+import type { UCMain } from '../main.js';
+import type { UCManager, UCManagerPersistOpts } from '../manager.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCOutputOrNothing } from '../output.js';
+import { UCExecChecker } from '../workers/UCExecChecker.js';
+import { UCInputFilesProcessor } from '../workers/UCInputFilesProcessor.js';
+import { UCInputValidator } from '../workers/UCInputValidator.js';
+export declare class SimpleUCManager implements UCManager {
+    private ucClientConfirmManager;
+    private clockManager;
+    private cryptoManager;
+    private logger;
+    private ucDataStore;
+    private ucExecChecker;
+    private ucInputFilesProcessor;
+    private ucInputValidator;
+    private ucInitProvider;
+    private ucMainProvider;
+    private tx?;
+    constructor(ucClientConfirmManager: UCClientConfirmManager, clockManager: ClockManager, cryptoManager: CryptoManager, logger: Logger, ucDataStore: UCDataStore, ucExecChecker: UCExecChecker, ucInputFilesProcessor: UCInputFilesProcessor, ucInputValidator: UCInputValidator, ucInitProvider: interfaces.Provider<UCInit>, ucMainProvider: interfaces.Provider<UCMain>);
+    commitTx(): Promise<void>;
+    confirmClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<boolean>;
+    execClient<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputReader<I, OPI0, OPI1>>;
+    execServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<UCOutputOrNothing<OPI0, OPI1>>;
+    initServer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>): Promise<void>;
+    initTx(): Promise<void>;
+    persist<I extends UCInput | undefined = undefined, D extends UCData | null = null, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(uc: UC<I, OPI0, OPI1>, data?: D, opts?: UCManagerPersistOpts): Promise<UCDataStoreRecord<I, D>>;
+    persistProjection<T extends object>(name: string, data: T): Promise<void>;
+    rollbackTx(): Promise<void>;
+}

package/dist/esm/uc/impl/SimpleUCManager.js

@@ -0,0 +1,163 @@
+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 { ForbiddenError } from '../../error/index.js';
+import { UCExecMode } from '../exec.js';
+import { UCOutputReader } from '../helpers/UCOutputReader.js';
+import { rInput } from '../utils/rInput.js';
+import { UCExecChecker } from '../workers/UCExecChecker.js';
+import { UCInputFilesProcessor } from '../workers/UCInputFilesProcessor.js';
+import { UCInputValidator } from '../workers/UCInputValidator.js';
+let SimpleUCManager = class SimpleUCManager {
+    ucClientConfirmManager;
+    clockManager;
+    cryptoManager;
+    logger;
+    ucDataStore;
+    ucExecChecker;
+    ucInputFilesProcessor;
+    ucInputValidator;
+    ucInitProvider;
+    ucMainProvider;
+    tx;
+    constructor(ucClientConfirmManager, clockManager, cryptoManager, logger, ucDataStore, ucExecChecker, ucInputFilesProcessor, ucInputValidator, ucInitProvider, ucMainProvider) {
+        this.ucClientConfirmManager = ucClientConfirmManager;
+        this.clockManager = clockManager;
+        this.cryptoManager = cryptoManager;
+        this.logger = logger;
+        this.ucDataStore = ucDataStore;
+        this.ucExecChecker = ucExecChecker;
+        this.ucInputFilesProcessor = ucInputFilesProcessor;
+        this.ucInputValidator = ucInputValidator;
+        this.ucInitProvider = ucInitProvider;
+        this.ucMainProvider = ucMainProvider;
+        this.tx = undefined;
+    }
+    async commitTx() {
+        if (!this.tx) {
+            throw new Error('The tx is not defined, therefore it cannot be committed');
+        }
+        await this.tx.ref.commit();
+        this.tx = undefined;
+    }
+    async confirmClient(uc) {
+        const { def } = uc;
+        const { metadata: { sensitive }, } = def;
+        if (!sensitive) {
+            return true;
+        }
+        return this.ucClientConfirmManager.exec(def);
+    }
+    async execClient(uc) {
+        const { lifecycle, metadata } = uc.def;
+        const { client, server } = lifecycle;
+        if (!client) {
+            throw new Error(`The use case ${metadata.name} has no client lifecycle`);
+        }
+        const { allowed } = await this.ucExecChecker.exec({
+            lifecycle: 'client',
+            uc,
+        });
+        if (!allowed) {
+            throw new ForbiddenError();
+        }
+        this.ucInputValidator.exec({ uc });
+        if (server === undefined) {
+            await this.ucInputFilesProcessor.exec({ uc });
+        }
+        const main = (await this.ucMainProvider(client.main));
+        const output = await main.exec({ uc });
+        return new UCOutputReader(uc.def, output ?? undefined);
+    }
+    async execServer(uc) {
+        const { lifecycle, metadata } = uc.def;
+        const { server } = lifecycle;
+        if (typeof server !== 'object') {
+            throw new Error(`The use case ${metadata.name} has no server lifecycle`);
+        }
+        const { allowed } = await this.ucExecChecker.exec({
+            lifecycle: 'server',
+            uc,
+        });
+        if (!allowed) {
+            throw new ForbiddenError();
+        }
+        this.ucInputValidator.exec({ uc });
+        await this.ucInputFilesProcessor.exec({ uc });
+        const main = (await this.ucMainProvider(server.main));
+        return main.exec({ uc });
+    }
+    async initServer(uc) {
+        const { lifecycle, metadata } = uc.def;
+        const { server } = lifecycle;
+        if (typeof server !== 'object') {
+            return;
+        }
+        if (!server.init) {
+            return;
+        }
+        this.logger.info('Initializing ucd', { name: metadata.name });
+        const init = (await this.ucInitProvider(server.init));
+        await init.exec();
+    }
+    async initTx() {
+        this.tx = {
+            ref: await this.ucDataStore.initTx(),
+        };
+    }
+    async persist(uc, data, opts) {
+        const record = {
+            aggregateId: opts?.aggregateId || this.cryptoManager.randomUUID(),
+            appName: uc.appManifest.name,
+            createdAt: this.clockManager.now(),
+            data: data || null,
+            executionMode: opts?.executionMode || UCExecMode.USER,
+            id: this.cryptoManager.randomUUID(),
+            input: rInput(uc, { ignoreTransient: true }),
+            name: uc.def.metadata.name,
+            organizationId: opts?.organizationId || uc.auth?.organization.id || null,
+            userId: uc.auth?.user.id || null,
+        };
+        await this.ucDataStore.write(record, { tx: this.tx });
+        return record;
+    }
+    async persistProjection(name, data) {
+        return this.ucDataStore.writeProjection(name, data, {
+            tx: this.tx,
+        });
+    }
+    async rollbackTx() {
+        if (!this.tx) {
+            throw new Error('The tx is not defined, therefore it cannot be rollbacked');
+        }
+        await this.tx.ref.rollback();
+        this.tx = undefined;
+    }
+};
+SimpleUCManager = __decorate([
+    injectable(),
+    __param(0, inject('UCClientConfirmManager')),
+    __param(1, inject('ClockManager')),
+    __param(2, inject('CryptoManager')),
+    __param(3, inject('Logger')),
+    __param(4, inject('UCDataStore')),
+    __param(5, inject(UCExecChecker)),
+    __param(6, inject(UCInputFilesProcessor)),
+    __param(7, inject(UCInputValidator)),
+    __param(8, inject('Provider<UCInit>')),
+    __param(9, inject('Provider<UCMain>')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, UCExecChecker,
+        UCInputFilesProcessor,
+        UCInputValidator, Function, Function])
+], SimpleUCManager);
+export { SimpleUCManager };

package/dist/esm/uc/impl/StaticUCClientConfirmManager.d.ts

@@ -0,0 +1,12 @@
+import { WordingManager } from '../../i18n/index.js';
+import type { Logger } from '../../std/index.js';
+import type { UCClientConfirmManager } from '../client.js';
+import type { UCDef } from '../def.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+export declare class StaticUCClientConfirmManager implements UCClientConfirmManager {
+    private logger;
+    private wordingManager;
+    constructor(logger: Logger, wordingManager: WordingManager);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>): Promise<boolean>;
+}

package/dist/esm/uc/impl/StaticUCClientConfirmManager.js

@@ -0,0 +1,34 @@
+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 { WordingManager } from '../../i18n/index.js';
+let StaticUCClientConfirmManager = class StaticUCClientConfirmManager {
+    logger;
+    wordingManager;
+    constructor(logger, wordingManager) {
+        this.logger = logger;
+        this.wordingManager = wordingManager;
+    }
+    async exec(ucd) {
+        const config = this.wordingManager.ucClientConfirm(ucd);
+        this.logger.debug('Simulate client confirm (always true)', { config });
+        return true;
+    }
+};
+StaticUCClientConfirmManager = __decorate([
+    injectable(),
+    __param(0, inject('Logger')),
+    __param(1, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, WordingManager])
+], StaticUCClientConfirmManager);
+export { StaticUCClientConfirmManager };

package/dist/esm/uc/impl/WebUCClientConfirmManager.d.ts

@@ -0,0 +1,10 @@
+import { WordingManager } from '../../i18n/index.js';
+import type { UCClientConfirmManager } from '../client.js';
+import type { UCDef } from '../def.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+export declare class WebUCClientConfirmManager implements UCClientConfirmManager {
+    private wordingManager;
+    constructor(wordingManager: WordingManager);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>): Promise<boolean>;
+}

package/dist/esm/uc/impl/WebUCClientConfirmManager.js

@@ -0,0 +1,34 @@
+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 { WordingManager } from '../../i18n/index.js';
+let WebUCClientConfirmManager = class WebUCClientConfirmManager {
+    wordingManager;
+    constructor(wordingManager) {
+        this.wordingManager = wordingManager;
+    }
+    async exec(ucd) {
+        const { message, title } = this.wordingManager.ucClientConfirm(ucd);
+        let m = title;
+        if (message) {
+            m = `\n${message}`;
+        }
+        return confirm(m);
+    }
+};
+WebUCClientConfirmManager = __decorate([
+    injectable(),
+    __param(0, inject(WordingManager)),
+    __metadata("design:paramtypes", [WordingManager])
+], WebUCClientConfirmManager);
+export { WebUCClientConfirmManager };

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

@@ -0,0 +1,62 @@
+export * from './auth/consts.js';
+export * from './helpers/UCOutputBuilder.js';
+export * from './helpers/UCOutputReader.js';
+export * from './io/input/AggregateInput.js';
+export * from './io/input/ListInput.js';
+export * from './io/output/AggregateOutput.js';
+export * from './lifecycle/client/IdleClientMain.js';
+export * from './lifecycle/client/SendClientMain.js';
+export * from './lifecycle/server/IdleServerMain.js';
+export * from './policies/AnonymousUCPolicy.js';
+export * from './policies/AuthenticatedUCPolicy.js';
+export * from './policies/EverybodyUCPolicy.js';
+export * from './policies/NobodyUCPolicy.js';
+export * from './policies/RoleAdminUCPolicy.js';
+export * from './policies/RoleRegularUCPolicy.js';
+export * from './sec/consts.js';
+export * from './settings/consts.js';
+export * from './utils/appendUCInputToURL.js';
+export * from './utils/fmtVal.js';
+export * from './utils/recIs.js';
+export * from './utils/rInput.js';
+export * from './utils/rVal.js';
+export * from './utils/stripUCDLifecycleServer.js';
+export * from './utils/ucHTTPContract.js';
+export * from './utils/ucMountingPoint.js';
+export * from './utils/ucifcoIsForArray.js';
+export * from './workers/SimpleAggregateFinder.js';
+export * from './workers/SimpleAggregateOwnershipChecker.js';
+export * from './workers/UCBuilder.js';
+export * from './workers/UCExecChecker.js';
+export * from './workers/UCInputFilesProcessor.js';
+export * from './workers/UCInputValidator.js';
+export * from './workers/UCOutputFilesProcessor.js';
+export * from './auth.js';
+export * from './client.js';
+export * from './data.js';
+export * from './data-store.js';
+export * from './def.js';
+export * from './exec.js';
+export * from './ext.js';
+export * from './file.js';
+export * from './init.js';
+export * from './input.js';
+export * from './input-field.js';
+export * from './main.js';
+export * from './manager.js';
+export * from './metadata.js';
+export * from './opi.js';
+export * from './opi-layout.js';
+export * from './output.js';
+export * from './output-field.js';
+export * from './output-part.js';
+export * from './side-effect.js';
+export * from './policy.js';
+export * from './sec.js';
+export * from './server.js';
+export * from './settings.js';
+export * from './transporter.js';
+export * from './UC.js';
+export * from './UCInputField.js';
+export * from './UCOutputField.js';
+export * from './value.js';