libmodulor 0.1.0 → 0.2.0

package/dist/esm/target/react-web-pure/UCForm.js

@@ -0,0 +1,17 @@
+import React, { useRef } from 'react';
+import { UCFormField } from './UCFormField.js';
+import { UCFormSubmitControl } from './UCFormSubmitControl.js';
+export function UCForm({ clearAfterExec, disabled, execState, onChange, onSubmit: onSubmitBase, uc, }) {
+    const formRef = useRef(null);
+    const onSubmit = async (e) => {
+        e.preventDefault();
+        const succeeded = await onSubmitBase();
+        if (succeeded && clearAfterExec) {
+            formRef.current?.reset();
+        }
+    };
+    return (React.createElement("form", { onSubmit: onSubmit, ref: formRef },
+        uc.inputFieldsForForm().map((f) => (React.createElement("div", { key: f.key },
+            React.createElement(UCFormField, { disabled: disabled, execState: execState, field: f, onChange: onChange })))),
+        React.createElement(UCFormSubmitControl, { execState: execState, disabled: disabled, uc: uc })));
+}

package/dist/esm/target/react-web-pure/UCFormField.d.ts

@@ -0,0 +1,11 @@
+import { type ReactElement } from 'react';
+import type { DataType } from '../../dt/index.js';
+import { type Props as FormFieldControlProps } from './UCFormFieldControl.js';
+import { type Props as FormFieldLabelProps } from './UCFormFieldLabel.js';
+declare const ELEMENTS: readonly ["control", "desc", "err", "label"];
+type Element = (typeof ELEMENTS)[number];
+type Props<T extends DataType> = FormFieldControlProps<T> & FormFieldLabelProps<T> & {
+    only?: Element[];
+};
+export declare function UCFormField<T extends DataType>({ disabled, execState, field, onChange: onChangeBase, only, }: Props<T>): ReactElement;
+export {};

package/dist/esm/target/react-web-pure/UCFormField.js

@@ -0,0 +1,32 @@
+import React, { useState } from 'react';
+import { useDIContext } from '../lib/react/DIContextProvider.js';
+import { UCFormFieldControl, } from './UCFormFieldControl.js';
+import { UCFormFieldDesc } from './UCFormFieldDesc.js';
+import { UCFormFieldErr } from './UCFormFieldErr.js';
+import { UCFormFieldLabel, } from './UCFormFieldLabel.js';
+const ELEMENTS = ['control', 'desc', 'err', 'label'];
+export function UCFormField({ disabled, execState, field, onChange: onChangeBase, only, }) {
+    const { i18nManager } = useDIContext();
+    const { type } = field.def;
+    const [errMsg, setErrMsg] = useState(null);
+    const elements = only ?? ELEMENTS;
+    const onChange = (f, op, v) => {
+        setErrMsg(null);
+        const vArr = Array.isArray(v) ? v : [v];
+        for (const vv of vArr) {
+            const validation = type.assign(vv).validate();
+            const violation = validation.get();
+            if (violation) {
+                const [key, expected] = violation;
+                setErrMsg(i18nManager.t(key, { vars: { expected } }));
+                break;
+            }
+        }
+        onChangeBase(f, op, v);
+    };
+    return (React.createElement(React.Fragment, null,
+        elements.includes('label') && React.createElement(UCFormFieldLabel, { field: field }),
+        elements.includes('control') && (React.createElement(UCFormFieldControl, { disabled: disabled, execState: execState, field: field, onChange: onChange })),
+        elements.includes('err') && errMsg && (React.createElement(UCFormFieldErr, { errMsg: errMsg })),
+        elements.includes('desc') && React.createElement(UCFormFieldDesc, { field: field })));
+}

package/dist/esm/target/react-web-pure/UCFormFieldControl.d.ts

@@ -0,0 +1,11 @@
+import { type ReactElement } from 'react';
+import type { DataType, ErrorMessage } from '../../dt/index.js';
+import { type UCInputField } from '../../uc/index.js';
+import type { UCFormFieldControlOnChange } from '../lib/react/form.js';
+import type { UCPanelState } from '../lib/react/panel.js';
+export type Props<T extends DataType> = UCPanelState & {
+    errMsg?: ErrorMessage | null;
+    field: UCInputField<T>;
+    onChange: UCFormFieldControlOnChange<T>;
+};
+export declare function UCFormFieldControl<T extends DataType>({ disabled, errMsg, execState, field, onChange: onChangeBase, }: Props<T>): ReactElement;

package/dist/esm/target/react-web-pure/UCFormFieldControl.js

@@ -0,0 +1,34 @@
+import React, {} from 'react';
+import { UCInputFieldChangeOperator, ucifRepeatability, } from '../../uc/index.js';
+import { htmlInputDef } from '../lib/web/input.js';
+const CHECKED_FIELD_TYPES = ['checkbox', 'radio'];
+const FILE_FIELD_TYPES = ['file'];
+const MULTIPLE_VALUES_SEPARATOR = ',';
+export function UCFormFieldControl({ disabled, errMsg = null, execState, field, onChange: onChangeBase, }) {
+    const attrs = htmlInputDef(field, execState, errMsg);
+    const onChange = (e) => {
+        const target = e.currentTarget;
+        const type = target.type;
+        let value = target.value;
+        if (CHECKED_FIELD_TYPES.includes(type) && 'checked' in target) {
+            value = target.checked;
+        }
+        else if (FILE_FIELD_TYPES.includes(type) && 'files' in target) {
+            value = target.files?.item(0);
+        }
+        const [isRepeatable] = ucifRepeatability(field.def);
+        if (isRepeatable && typeof value === 'string') {
+            const valueArr = value
+                .split(MULTIPLE_VALUES_SEPARATOR)
+                .map((v) => v.trim());
+            onChangeBase(field, UCInputFieldChangeOperator.SET, valueArr);
+        }
+        else {
+            onChangeBase(field, UCInputFieldChangeOperator.SET, value);
+        }
+    };
+    if (attrs.internal?.multiline) {
+        return (React.createElement("textarea", { ...attrs.spec, disabled: disabled, onChange: onChange }));
+    }
+    return React.createElement("input", { ...attrs.spec, disabled: disabled, onChange: onChange });
+}

package/dist/esm/target/react-web-pure/UCFormFieldDesc.d.ts

@@ -0,0 +1,7 @@
+import { type ReactElement } from 'react';
+import type { DataType } from '../../dt/index.js';
+import type { UCInputField } from '../../uc/index.js';
+export interface Props<T extends DataType> {
+    field: UCInputField<T>;
+}
+export declare function UCFormFieldDesc<T extends DataType>({ field, }: Props<T>): ReactElement | null;

package/dist/esm/target/react-web-pure/UCFormFieldDesc.js

@@ -0,0 +1,10 @@
+import React, {} from 'react';
+import { useDIContext } from '../lib/react/DIContextProvider.js';
+export function UCFormFieldDesc({ field, }) {
+    const { wordingManager } = useDIContext();
+    const { desc } = wordingManager.ucif(field);
+    if (!desc) {
+        return null;
+    }
+    return React.createElement("div", null, desc);
+}

package/dist/esm/target/react-web-pure/UCFormFieldErr.d.ts

@@ -0,0 +1,7 @@
+import { type ReactElement } from 'react';
+import type { ErrorMessage } from '../../dt/index.js';
+interface Props {
+    errMsg: ErrorMessage;
+}
+export declare function UCFormFieldErr({ errMsg }: Props): ReactElement;
+export {};

package/dist/esm/target/react-web-pure/UCFormFieldErr.js

@@ -0,0 +1,4 @@
+import React, {} from 'react';
+export function UCFormFieldErr({ errMsg }) {
+    return React.createElement("div", null, errMsg);
+}

package/dist/esm/target/react-web-pure/UCFormFieldLabel.d.ts

@@ -0,0 +1,7 @@
+import { type ReactElement } from 'react';
+import type { DataType } from '../../dt/index.js';
+import { type UCInputField } from '../../uc/index.js';
+export interface Props<T extends DataType> {
+    field: UCInputField<T>;
+}
+export declare function UCFormFieldLabel<T extends DataType>({ field, }: Props<T>): ReactElement;

package/dist/esm/target/react-web-pure/UCFormFieldLabel.js

@@ -0,0 +1,8 @@
+import React, {} from 'react';
+import { ucifId } from '../../uc/index.js';
+import { useDIContext } from '../lib/react/DIContextProvider.js';
+export function UCFormFieldLabel({ field, }) {
+    const { wordingManager } = useDIContext();
+    const { label } = wordingManager.ucif(field);
+    return React.createElement("label", { htmlFor: ucifId(field.key) }, label);
+}

package/dist/esm/target/react-web-pure/UCFormSubmitControl.d.ts

@@ -0,0 +1,6 @@
+import { type ReactElement } from 'react';
+import type { UCInput, UCOPIBase } from '../../uc/index.js';
+import type { UCPanelCtx } from '../lib/react/panel.js';
+type Props<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCPanelCtx<I, OPI0, OPI1>;
+export declare function UCFormSubmitControl<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ execState, disabled, uc }: Props<I, OPI0, OPI1>): ReactElement;
+export {};

package/dist/esm/target/react-web-pure/UCFormSubmitControl.js

@@ -0,0 +1,6 @@
+import React, {} from 'react';
+import { useDIContext } from '../lib/react/DIContextProvider.js';
+export function UCFormSubmitControl({ execState, disabled, uc }) {
+    const { wordingManager } = useDIContext();
+    return (React.createElement("input", { disabled: disabled, type: "submit", value: wordingManager.ucISubmit(uc.def, execState) }));
+}

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

@@ -0,0 +1,67 @@
+import type { FilePath } from '../dt/index.js';
+import type { ServerClientManagerSettings } from '../target/lib/client/ServerClientManager.js';
+import type { ServerManager } from '../target/lib/server/ServerManager.js';
+import { type UCAuth, UCBuilder, type UCDef, type UCInput, type UCOPIBase } from '../uc/index.js';
+import type { SrcImporter } from '../utils/index.js';
+import type { AppTesterConfigurator } from './AppTesterConfigurator.js';
+import type { AppTesterCtx, AppTesterUCDRef } from './ctx.js';
+import type { AppTesterFlow, AppTesterFlowExecOutput } from './flow.js';
+import { SimpleHTMLAppTestReportEmitter } from './impl/SimpleHTMLAppTestReportEmitter.js';
+import { type UCInputFiller } from './uc-input.js';
+import type { AppDocsEmitter } from './workers/AppDocsEmitter.js';
+import type { AppTestSuiteTestResult } from './workers/AppTestSuiteEmitter.js';
+import { AppTesterCtxInitializer } from './workers/AppTesterCtxInitializer.js';
+import { UCExecutor, type UCExecutorExecOutput, type Input as UCExecutorInput } from './workers/UCExecutor.js';
+import { AppI18nChecker } from './workers/checkers/AppI18nChecker.js';
+import { AppIndexChecker } from './workers/checkers/AppIndexChecker.js';
+import { AppManifestChecker } from './workers/checkers/AppManifestChecker.js';
+import { UCDefChecker } from './workers/checkers/UCDefChecker.js';
+import { UCDefSourcesChecker } from './workers/checkers/UCDefSourcesChecker.js';
+export interface AppTesterInitArgs {
+    appPath: FilePath;
+    configurator: AppTesterConfigurator;
+    serverClientSettings: ServerClientManagerSettings;
+    srcImporter: SrcImporter;
+}
+export interface AppTesterUCTestData<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    auth: UCAuth | null;
+    authName: string;
+    inputFiller: UCInputFiller<I, OPI0, OPI1>;
+    inputFillerName: string;
+}
+export declare class AppTester {
+    private appDocsEmitter;
+    private appI18nChecker;
+    private appIndexChecker;
+    private appManifestChecker;
+    private appTesterCtxInitializer;
+    private serverManager;
+    private simpleHTMLAppTestReportEmitter;
+    private ucBuilder;
+    private ucDefChecker;
+    private ucDefSourcesChecker;
+    private ucExecutor;
+    private configurator;
+    private ctx;
+    private safeSrcImporter;
+    private testResults;
+    private testSummary;
+    private ucDefSourcesCheckerOutput;
+    constructor(appDocsEmitter: AppDocsEmitter, appI18nChecker: AppI18nChecker, appIndexChecker: AppIndexChecker, appManifestChecker: AppManifestChecker, appTesterCtxInitializer: AppTesterCtxInitializer, serverManager: ServerManager, simpleHTMLAppTestReportEmitter: SimpleHTMLAppTestReportEmitter, ucBuilder: UCBuilder, ucDefChecker: UCDefChecker, ucDefSourcesChecker: UCDefSourcesChecker, ucExecutor: UCExecutor);
+    checkAppI18n(): Promise<void>;
+    checkAppIndex(): Promise<void>;
+    checkAppManifest(): Promise<void>;
+    checkUCDSources(): Promise<void>;
+    checkUC(ucdRef: AppTesterUCDRef): Promise<UCDef>;
+    execFlow(flow: AppTesterFlow): Promise<AppTesterFlowExecOutput>;
+    execMonkeyTest<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucd: UCDef<I, OPI0, OPI1>, input: I): Promise<UCExecutorExecOutput<I, OPI0, OPI1>>;
+    execUC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(input: Omit<UCExecutorInput<I, OPI0, OPI1>, 'appManifest'>, flow?: AppTesterFlow): Promise<AppTestSuiteTestResult<I, OPI0, OPI1>>;
+    finalize(): Promise<void>;
+    getCtx(): AppTesterCtx;
+    init({ appPath, configurator, serverClientSettings, srcImporter, }: AppTesterInitArgs): Promise<void>;
+    ucTestData(ucdRef: AppTesterUCDRef): Promise<AppTesterUCTestData[]>;
+    private bindI18n;
+    private bindServerClientSettings;
+    private initI18n;
+    private initServer;
+}

package/dist/esm/testing/AppTester.js

@@ -0,0 +1,343 @@
+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 { I18nEN } from '../i18n/locales/en.js';
+import { I18nFR } from '../i18n/locales/fr.js';
+import { FAKE_USER_ADMIN, UCBuilder, UCInputFieldChangeOperator, ucHTTPContract, } from '../uc/index.js';
+import { SimpleHTMLAppTestReportEmitter } from './impl/SimpleHTMLAppTestReportEmitter.js';
+import { optsAllSet } from './opts.js';
+import { defaultUCAuthSetters } from './uc-auth.js';
+import { allWithExamples, defaultUCInputFillers, } from './uc-input.js';
+import { awaitForSrcImport } from './utils.js';
+import { AppTesterCtxInitializer } from './workers/AppTesterCtxInitializer.js';
+import { UCExecutor, } from './workers/UCExecutor.js';
+import { AppI18nChecker } from './workers/checkers/AppI18nChecker.js';
+import { AppIndexChecker } from './workers/checkers/AppIndexChecker.js';
+import { AppManifestChecker } from './workers/checkers/AppManifestChecker.js';
+import { UCDefChecker } from './workers/checkers/UCDefChecker.js';
+import { UCDefSourcesChecker, } from './workers/checkers/UCDefSourcesChecker.js';
+let AppTester = class AppTester {
+    appDocsEmitter;
+    appI18nChecker;
+    appIndexChecker;
+    appManifestChecker;
+    appTesterCtxInitializer;
+    serverManager;
+    simpleHTMLAppTestReportEmitter;
+    ucBuilder;
+    ucDefChecker;
+    ucDefSourcesChecker;
+    ucExecutor;
+    configurator;
+    ctx;
+    safeSrcImporter;
+    testResults;
+    testSummary;
+    ucDefSourcesCheckerOutput;
+    constructor(appDocsEmitter, appI18nChecker, appIndexChecker, appManifestChecker, appTesterCtxInitializer, serverManager, simpleHTMLAppTestReportEmitter, ucBuilder, ucDefChecker, ucDefSourcesChecker, ucExecutor) {
+        this.appDocsEmitter = appDocsEmitter;
+        this.appI18nChecker = appI18nChecker;
+        this.appIndexChecker = appIndexChecker;
+        this.appManifestChecker = appManifestChecker;
+        this.appTesterCtxInitializer = appTesterCtxInitializer;
+        this.serverManager = serverManager;
+        this.simpleHTMLAppTestReportEmitter = simpleHTMLAppTestReportEmitter;
+        this.ucBuilder = ucBuilder;
+        this.ucDefChecker = ucDefChecker;
+        this.ucDefSourcesChecker = ucDefSourcesChecker;
+        this.ucExecutor = ucExecutor;
+        this.testResults = [];
+        this.testSummary = {
+            counts: {
+                danger: 0,
+                success: 0,
+                warning: 0,
+            },
+        };
+    }
+    async checkAppI18n() {
+        const { errors } = await this.appI18nChecker.exec({
+            appManifest: this.ctx.appManifest,
+            appI18n: this.ctx.appI18n,
+        });
+        if (errors.length > 0) {
+            throw new Error(errors[0]);
+        }
+    }
+    async checkAppIndex() {
+        const { errors } = await this.appIndexChecker.exec({
+            appPath: this.ctx.appPath,
+        });
+        if (errors.length > 0) {
+            throw new Error(errors[0]);
+        }
+    }
+    async checkAppManifest() {
+        const { errors } = await this.appManifestChecker.exec({
+            appManifest: this.ctx.appManifest,
+            ucdRefs: this.ctx.ucdRefs,
+        });
+        if (errors.length > 0) {
+            throw new Error(errors[0]);
+        }
+    }
+    async checkUCDSources() {
+        this.ucDefSourcesCheckerOutput = await this.ucDefSourcesChecker.exec({
+            ctx: this.ctx,
+        });
+    }
+    async checkUC(ucdRef) {
+        const { errors } = await this.ucDefChecker.exec({ ucdRef });
+        if (errors.length > 0) {
+            throw new Error(errors[0]);
+        }
+        const { source } = ucdRef;
+        const ucd = source[`${Object.keys(source)[0]}`];
+        return ucd;
+    }
+    async execFlow(flow) {
+        const output = [];
+        const { auth, authName, setup, steps } = flow;
+        await setup?.(this.ctx);
+        for await (const [ucd, inputOverride] of steps) {
+            const inputFiller = (uc) => {
+                allWithExamples(uc);
+                if (inputOverride) {
+                    const inputOverrides = inputOverride(output);
+                    for (const [k, v] of Object.entries(inputOverrides)) {
+                        uc.inputField(k).setValue(UCInputFieldChangeOperator.SET, v);
+                    }
+                }
+            };
+            const { out } = await this.execUC({
+                auth: auth ?? FAKE_USER_ADMIN,
+                authName: authName ?? 'ADMIN',
+                inputFiller,
+                inputFillerName: 'FLOW',
+                ucd,
+            }, flow);
+            output.push(out);
+        }
+        return output;
+    }
+    async execMonkeyTest(ucd, input) {
+        const inputFiller = (uc) => {
+            uc.fill(input);
+        };
+        const { out } = await this.execUC({
+            auth: FAKE_USER_ADMIN,
+            authName: 'ADMIN',
+            inputFiller,
+            inputFillerName: 'ANY_FIELD_AS_ANYTHING',
+            ucd,
+        });
+        return out;
+    }
+    async execUC(input, flow) {
+        const { out } = await this.ucExecutor.exec({
+            ...input,
+            appManifest: this.ctx.appManifest,
+        });
+        let status = 'warning';
+        if (!out.err) {
+            status = 'success';
+        }
+        else {
+            const { name } = out.err;
+            switch (name) {
+                case 'CustomError':
+                    break;
+                case 'Error':
+                case 'TypeError':
+                    status = 'danger';
+                    break;
+                default:
+                    break;
+            }
+        }
+        let name = input.ucd.metadata.name;
+        let sideEffects = await this.configurator.sideEffects(this.ctx);
+        if (flow) {
+            name = `${flow.name} > ${name}`;
+            if (sideEffects) {
+                const snapshot = JSON.parse(JSON.stringify(Array.from(sideEffects.entries())));
+                sideEffects = new Map(snapshot);
+            }
+        }
+        const testResult = {
+            name,
+            out,
+            sideEffects,
+            status,
+        };
+        this.testResults.push(testResult);
+        this.testSummary.counts[status] += 1;
+        return testResult;
+    }
+    async finalize() {
+        await this.serverManager.stop();
+        const { appPath } = this.ctx;
+        if (this.ucDefSourcesCheckerOutput) {
+            await this.appDocsEmitter.exec({
+                appPath,
+                ucDefSourcesCheckerOutput: this.ucDefSourcesCheckerOutput,
+            });
+        }
+        await this.simpleHTMLAppTestReportEmitter.exec({
+            appPath,
+            testResults: this.testResults,
+            testSummary: this.testSummary,
+        });
+    }
+    getCtx() {
+        return this.ctx;
+    }
+    async init({ appPath, configurator, serverClientSettings, srcImporter, }) {
+        this.configurator = configurator;
+        this.safeSrcImporter = (path) => Promise.race([
+            awaitForSrcImport(path),
+            srcImporter(path),
+        ]);
+        const { ctx } = await this.appTesterCtxInitializer.exec({
+            appPath,
+            srcImporter: this.safeSrcImporter,
+        });
+        this.ctx = ctx;
+        this.ctx.opts = await configurator.opts();
+        await this.configurator.bindImplementations(this.ctx);
+        await this.configurator.seed(this.ctx);
+        await this.bindI18n();
+        await this.bindServerClientSettings(serverClientSettings);
+        await this.initI18n();
+        await this.initServer();
+    }
+    async ucTestData(ucdRef) {
+        const defaultASs = defaultUCAuthSetters();
+        let asEntries = Object.entries(defaultASs);
+        const asConfig = await this.configurator.authSettersConfig();
+        if (asConfig) {
+            const { add, exclude } = asConfig;
+            if (exclude) {
+                for (const asName of exclude) {
+                    asEntries = asEntries.filter(([name]) => name !== asName);
+                }
+            }
+            if (add) {
+                asEntries.push(...Object.entries(add));
+            }
+        }
+        const defaultIFs = defaultUCInputFillers();
+        const ifEntries = Object.entries(defaultIFs);
+        const specificIFs = await this.configurator.inputFillers();
+        const specificIFsForUC = specificIFs?.get(ucdRef.name);
+        if (specificIFsForUC) {
+            ifEntries.push(...Object.entries(specificIFsForUC));
+        }
+        const data = [];
+        for (const [authName, auth] of asEntries) {
+            for (const [inputFillerName, inputFiller] of ifEntries) {
+                data.push({
+                    auth,
+                    authName,
+                    inputFiller,
+                    inputFillerName,
+                });
+            }
+        }
+        return data;
+    }
+    async bindI18n() {
+        const { appI18n, container } = this.ctx;
+        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)) {
+                continue;
+            }
+            productI18n[l] = {
+                ...productI18n[l],
+                ...appI18n[l],
+            };
+        }
+        container.rebind('I18n').toConstantValue(productI18n);
+    }
+    async bindServerClientSettings(serverClientSettings) {
+        const { container } = this.ctx;
+        const opts = optsAllSet(this.ctx.opts);
+        const existingSettings = container.get('Settings');
+        container.rebind('Settings').toConstantValue({
+            ...existingSettings,
+            ...serverClientSettings,
+            logger_level: opts.logger_level,
+        });
+    }
+    async initI18n() {
+        await this.ctx.container.get('I18nManager').init();
+    }
+    async initServer() {
+        const ucManager = this.ctx.container.get('UCManager');
+        this.serverManager.overrideUCManager(ucManager);
+        this.ucExecutor.overrideUCManager(ucManager);
+        await this.serverManager.init();
+        for await (const { source } of this.ctx.ucdRefs) {
+            const keys = Object.keys(source);
+            const [ucdKey] = keys;
+            if (!ucdKey) {
+                continue;
+            }
+            const ucd = source[ucdKey];
+            const uc = this.ucBuilder.exec({
+                appManifest: this.ctx.appManifest,
+                auth: null,
+                def: ucd,
+            });
+            await this.serverManager.mount(uc.appManifest, ucd, ucHTTPContract(uc));
+        }
+        await this.serverManager.warmUp();
+        await this.serverManager.start();
+    }
+};
+AppTester = __decorate([
+    injectable(),
+    __param(0, inject('AppDocsEmitter')),
+    __param(1, inject(AppI18nChecker)),
+    __param(2, inject(AppIndexChecker)),
+    __param(3, inject(AppManifestChecker)),
+    __param(4, inject(AppTesterCtxInitializer)),
+    __param(5, inject('ServerManager')),
+    __param(6, inject(SimpleHTMLAppTestReportEmitter)),
+    __param(7, inject(UCBuilder)),
+    __param(8, inject(UCDefChecker)),
+    __param(9, inject(UCDefSourcesChecker)),
+    __param(10, inject(UCExecutor)),
+    __metadata("design:paramtypes", [Object, AppI18nChecker,
+        AppIndexChecker,
+        AppManifestChecker,
+        AppTesterCtxInitializer, Object, SimpleHTMLAppTestReportEmitter,
+        UCBuilder,
+        UCDefChecker,
+        UCDefSourcesChecker,
+        UCExecutor])
+], AppTester);
+export { AppTester };

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

@@ -0,0 +1,26 @@
+import type { CryptoManagerHash } from '../std/index.js';
+import type { UCInput, UCName, UCOPIBase } from '../uc/index.js';
+import type { AppTesterCtx } from './ctx.js';
+import type { AppTesterFlow } from './flow.js';
+import type { DefaultUCAuthSetter, UCAuthSetterSet } from './uc-auth.js';
+import type { CustomUCInputFiller, UCInputFillerSet } from './uc-input.js';
+import type { UCExecutorAssertion } from './workers/UCExecutor.js';
+export type AppTesterConfiguratorAuthSettersConfig = {
+    add?: UCAuthSetterSet;
+    exclude?: Set<DefaultUCAuthSetter>;
+};
+export type AppTesterConfiguratorInputFillers<I extends UCInput = any, OPI0 extends UCOPIBase = any, OPI1 extends UCOPIBase = any> = Map<UCName, UCInputFillerSet<CustomUCInputFiller, I, OPI0, OPI1>>;
+export type AppTesterConfiguratorSideEffects = Map<string, any>;
+export type AppTesterConfiguratorSideEffectsSerialized = [string, any][];
+export type AppTesterConfiguratorSpecificAssertions<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = Map<CryptoManagerHash, UCExecutorAssertion<I, OPI0, OPI1>>;
+export interface AppTesterConfigurator {
+    authSettersConfig(): Promise<AppTesterConfiguratorAuthSettersConfig | undefined>;
+    bindImplementations(ctx: AppTesterCtx): Promise<void>;
+    clearExecution(ctx: AppTesterCtx): Promise<void>;
+    flows(): Promise<AppTesterFlow[]>;
+    inputFillers(): Promise<AppTesterConfiguratorInputFillers | undefined>;
+    opts(): Promise<AppTesterCtx['opts']>;
+    seed(ctx: AppTesterCtx): Promise<void>;
+    sideEffects(ctx: AppTesterCtx): Promise<AppTesterConfiguratorSideEffects | undefined>;
+    specificAssertions(): Promise<AppTesterConfiguratorSpecificAssertions | undefined>;
+}

package/dist/esm/testing/AppTesterConfigurator.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,25 @@
+import type { ClockManager, CryptoManager, Worker } from '../std/index.js';
+import { type UCDataStore } from '../uc/index.js';
+interface Input {
+    ucDataStore: UCDataStore;
+}
+export declare class UCDataStoreTester implements Worker<Input, Promise<void>> {
+    private clockManager;
+    private cryptoManager;
+    static PROJECTION_NAME_1: string;
+    private ucDataStore;
+    private skipProjectionTesting;
+    private entries;
+    private exists;
+    private filtersTestData;
+    private readRes;
+    constructor(clockManager: ClockManager, cryptoManager: CryptoManager);
+    exec({ ucDataStore }: Input): Promise<void>;
+    setSkipProjectionTesting(skipProjectionTesting: boolean): void;
+    private buildEntries;
+    private buildFiltersTestData;
+    private buildUCInput;
+    private expectXRecords;
+    private insertEntries;
+}
+export {};