libmodulor 0.1.0 → 0.2.0

package/dist/esm/target/lib/cli/CommandExecutor.js

@@ -0,0 +1,118 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var CommandExecutor_1;
+import { inject, injectable } from 'inversify';
+import { WordingManager } from '../../../i18n/index.js';
+import { FSManagerItemInfoType, } from '../../../std/index.js';
+import { UCInputFieldChangeOperator, ucifMustBeFilledManually, } from '../../../uc/index.js';
+import { print, printError } from './renderer.js';
+let CommandExecutor = class CommandExecutor {
+    static { CommandExecutor_1 = this; }
+    fsManager;
+    i18nManager;
+    promptManager;
+    ucManager;
+    wordingManager;
+    static DEFAULT_VERSION = '0.0.0';
+    static VERSION_FILE_NAME = 'package.json';
+    static VERSION_FETCH_MAX_TRIES = 10;
+    static VERSION_FETCH_START_PATH = import.meta.dirname;
+    constructor(fsManager, i18nManager, promptManager, ucManager, wordingManager) {
+        this.fsManager = fsManager;
+        this.i18nManager = i18nManager;
+        this.promptManager = promptManager;
+        this.ucManager = ucManager;
+        this.wordingManager = wordingManager;
+    }
+    async exec({ uc }) {
+        try {
+            await this.promptForSensitiveFields(uc);
+            const confirmed = await this.ucManager.confirmClient(uc);
+            if (!confirmed) {
+                return;
+            }
+            const ucor = await this.ucManager.execClient(uc);
+            const output = ucor.output();
+            if (output) {
+                print(JSON.stringify(output));
+            }
+        }
+        catch (err) {
+            printError(err);
+        }
+    }
+    fieldsForFlags(uc) {
+        return uc.inputFieldsInsensitive();
+    }
+    async version() {
+        let i = 0;
+        let currentPath = CommandExecutor_1.VERSION_FETCH_START_PATH;
+        let file = undefined;
+        while (i < CommandExecutor_1.VERSION_FETCH_MAX_TRIES && !file) {
+            const items = await this.fsManager.ls(currentPath, {
+                withFullPath: true,
+            });
+            file = items.find((i) => i.type === FSManagerItemInfoType.FILE &&
+                i.path.endsWith(CommandExecutor_1.VERSION_FILE_NAME));
+            i += 1;
+            currentPath = this.fsManager.path(currentPath, '..');
+        }
+        if (!file) {
+            return CommandExecutor_1.DEFAULT_VERSION;
+        }
+        const contents = await this.fsManager.cat(file.path);
+        try {
+            const { version } = JSON.parse(contents);
+            return version;
+        }
+        catch (err) {
+            return CommandExecutor_1.DEFAULT_VERSION;
+        }
+    }
+    async promptForSensitiveFields(uc) {
+        const fields = uc
+            .inputFieldsSensitive()
+            .filter((f) => ucifMustBeFilledManually(f.def, { noContext: true }));
+        for (const f of fields) {
+            const { desc, label } = this.wordingManager.ucif(f);
+            const help = desc ? ` (${desc})` : '';
+            const invite = `${label}${help}`;
+            await this.promptManager.prompt(invite, {
+                validate: async (v) => {
+                    f.setValue(UCInputFieldChangeOperator.SET, v);
+                    const validation = f.validate();
+                    const violation = validation.get();
+                    if (!violation) {
+                        return true;
+                    }
+                    const [key, expected] = violation;
+                    const message = this.i18nManager.t(key, {
+                        vars: { expected },
+                    });
+                    printError(message);
+                    return false;
+                },
+            });
+        }
+    }
+};
+CommandExecutor = CommandExecutor_1 = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('I18nManager')),
+    __param(2, inject('PromptManager')),
+    __param(3, inject('UCManager')),
+    __param(4, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, WordingManager])
+], CommandExecutor);
+export { CommandExecutor };

package/dist/esm/target/lib/cli/renderer.d.ts

@@ -0,0 +1,2 @@
+export declare function print(line: string): void;
+export declare function printError(err: string | Error): void;

package/dist/esm/target/lib/cli/renderer.js

@@ -0,0 +1,17 @@
+import { CustomError } from '../../../error/index.js';
+export function print(line) {
+    console.info(line);
+}
+export function printError(err) {
+    let message = '';
+    if (err instanceof Error) {
+        message = err.message;
+        if (!(err instanceof CustomError)) {
+            console.error(err);
+        }
+    }
+    else if (typeof err === 'string') {
+        message = err;
+    }
+    console.error(message);
+}

package/dist/esm/target/lib/client/ServerClientManager.d.ts

@@ -0,0 +1,27 @@
+import type { ApiKey, JWT, URL } from '../../../dt/index.js';
+import type { HTTPAPICallerBasicAuth, Settings } from '../../../std/index.js';
+import type { UCAuth, UCAuthRole } from '../../../uc/index.js';
+import type { AuthCookieName, PublicApiKeyHeaderName } from '../shared.js';
+export interface ServerClientManagerSettings extends Settings {
+    server_cookies_name_auth?: AuthCookieName | undefined;
+    server_dangerously_set_api_key?: ApiKey | undefined;
+    server_dangerously_set_basic?: HTTPAPICallerBasicAuth | undefined;
+    server_dangerously_set_jwts?: Record<UCAuthRole, JWT> | undefined;
+    server_public_api_key: ApiKey | null;
+    server_public_api_key_header_name: PublicApiKeyHeaderName | null;
+    server_public_url: URL | null;
+}
+export interface ServerClientManagerPublicApiKeyHeader {
+    name: PublicApiKeyHeaderName;
+    value: ApiKey;
+}
+export interface ServerClientManagerOpts {
+    auth: UCAuth | null;
+}
+export interface ServerClientManager {
+    authApiKey(opts?: ServerClientManagerOpts): Promise<ApiKey | null>;
+    authBasic(opts?: ServerClientManagerOpts): Promise<HTTPAPICallerBasicAuth | null>;
+    authJWT(opts?: ServerClientManagerOpts): Promise<JWT | null>;
+    baseURL(opts?: ServerClientManagerOpts): Promise<URL>;
+    publicApiKey(opts?: ServerClientManagerOpts): Promise<ApiKey | null>;
+}

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

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

package/dist/esm/target/lib/client/consts.d.ts

@@ -0,0 +1,2 @@
+import type { ServerClientManagerSettings } from './ServerClientManager.js';
+export declare const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS: ServerClientManagerSettings;

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

@@ -0,0 +1,5 @@
+export const TARGET_DEFAULT_SERVER_CLIENT_MANAGER_SETTINGS = {
+    server_public_api_key: 'PublicApiKeyToBeChangedWhenDeploying',
+    server_public_api_key_header_name: 'X-API-Key',
+    server_public_url: 'http://localhost:7443',
+};

package/dist/esm/target/lib/mcp-server/MCPServerBooter.d.ts

@@ -0,0 +1,15 @@
+import type { AppUCsLoaderInput } from '../../../app/index.js';
+import { ProductUCsLoader } from '../../../product/index.js';
+import type { Logger, Worker } from '../../../std/index.js';
+import { type UCManager } from '../../../uc/index.js';
+import type { ServerManager } from '../server/ServerManager.js';
+type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'>;
+export declare class MCPServerBooter implements Worker<Input, Promise<void>> {
+    private logger;
+    private productUCsLoader;
+    private serverManager;
+    private ucManager;
+    constructor(logger: Logger, productUCsLoader: ProductUCsLoader, serverManager: ServerManager, ucManager: UCManager);
+    exec({ appsRootPath, srcImporter }: Input): Promise<void>;
+}
+export {};

package/dist/esm/target/lib/mcp-server/MCPServerBooter.js

@@ -0,0 +1,55 @@
+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 { ProductUCsLoader } from '../../../product/index.js';
+import { ucHTTPContract } from '../../../uc/index.js';
+let MCPServerBooter = class MCPServerBooter {
+    logger;
+    productUCsLoader;
+    serverManager;
+    ucManager;
+    constructor(logger, productUCsLoader, serverManager, ucManager) {
+        this.logger = logger;
+        this.productUCsLoader = productUCsLoader;
+        this.serverManager = serverManager;
+        this.ucManager = ucManager;
+    }
+    async exec({ appsRootPath, srcImporter }) {
+        try {
+            await this.serverManager.init();
+            const ucs = await this.productUCsLoader.exec({
+                appsRootPath,
+                srcImporter,
+            });
+            for await (const uc of ucs) {
+                const contract = ucHTTPContract(uc);
+                await this.ucManager.initServer(uc);
+                await this.serverManager.mount(uc.appManifest, uc.def, contract);
+            }
+            await this.serverManager.warmUp();
+            await this.serverManager.start();
+        }
+        catch (err) {
+            this.logger.error(err);
+        }
+    }
+};
+MCPServerBooter = __decorate([
+    injectable(),
+    __param(0, inject('Logger')),
+    __param(1, inject(ProductUCsLoader)),
+    __param(2, inject('ServerManager')),
+    __param(3, inject('UCManager')),
+    __metadata("design:paramtypes", [Object, ProductUCsLoader, Object, Object])
+], MCPServerBooter);
+export { MCPServerBooter };

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

@@ -0,0 +1,16 @@
+import type { Container } from 'inversify';
+import React, { type PropsWithChildren, type ReactElement } from 'react';
+import { WordingManager } from '../../../i18n/index.js';
+import type { I18nManager } from '../../../std/index.js';
+export interface DIContextT {
+    container: Container;
+    i18nManager: I18nManager;
+    wordingManager: WordingManager;
+}
+export declare const DIContext: React.Context<DIContextT | null>;
+export declare function useDIContext(): DIContextT;
+interface Props {
+    container: Container;
+}
+export declare function DIContextProvider({ children, container, }: PropsWithChildren<Props>): ReactElement;
+export {};

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

@@ -0,0 +1,19 @@
+import React, { createContext, useContext, useState, } from 'react';
+import { WordingManager } from '../../../i18n/index.js';
+export const DIContext = createContext(null);
+export function useDIContext() {
+    const c = useContext(DIContext);
+    if (!c) {
+        throw new Error('You must initialize DIContext');
+    }
+    return c;
+}
+export function DIContextProvider({ children, container, }) {
+    const [i18nManager] = useState(container.get('I18nManager'));
+    const [wordingManager] = useState(container.resolve(WordingManager));
+    return (React.createElement(DIContext.Provider, { value: {
+            container,
+            i18nManager,
+            wordingManager,
+        } }, children));
+}

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

@@ -0,0 +1,6 @@
+import { type PropsWithChildren, type ReactElement } from 'react';
+import { type UC, type UCInput, type UCOPIBase } from '../../../uc/index.js';
+export interface Props<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    uc: UC<I, OPI0, OPI1>;
+}
+export declare function UCContainer<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ children, uc, }: PropsWithChildren<Props<I, OPI0, OPI1>>): ReactElement | null;

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

@@ -0,0 +1,24 @@
+import React, { useEffect, useState, } from 'react';
+import { UCExecChecker, } from '../../../uc/index.js';
+import { useDIContext } from './DIContextProvider.js';
+export function UCContainer({ children, uc, }) {
+    const { container } = useDIContext();
+    const [isAllowed, setIsAllowed] = useState(undefined);
+    const [ucExecChecker] = useState(container.resolve(UCExecChecker));
+    useEffect(() => {
+        (async () => {
+            const { allowed } = await ucExecChecker.exec({
+                lifecycle: 'client',
+                uc,
+            });
+            setIsAllowed(allowed);
+        })();
+    }, [uc, ucExecChecker]);
+    if (isAllowed === undefined) {
+        return React.createElement(React.Fragment, null);
+    }
+    if (isAllowed === false) {
+        return null;
+    }
+    return React.createElement(React.Fragment, null, children);
+}

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

@@ -0,0 +1,9 @@
+import { type ReactElement } from 'react';
+import type { UCInput, UCOPIBase } from '../../../uc/index.js';
+import type { UCEntrypointCtx } from './entrypoint.js';
+import type { RenderUCEntrypointTouchable } from './touchable.js';
+type Props<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCEntrypointCtx<I, OPI0, OPI1> & {
+    renderTouchable: RenderUCEntrypointTouchable<I, OPI0, OPI1>;
+};
+export declare function UCEntrypoint<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ path, renderTouchable, uc }: Props<I, OPI0, OPI1>): ReactElement;
+export {};

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

@@ -0,0 +1,8 @@
+import React, {} from 'react';
+import { useDIContext } from './DIContextProvider.js';
+import { UCContainer } from './UCContainer.js';
+export function UCEntrypoint({ path, renderTouchable, uc }) {
+    const { wordingManager } = useDIContext();
+    const wording = wordingManager.uc(uc.def);
+    return (React.createElement(UCContainer, { uc: uc }, renderTouchable({ path, uc, wording })));
+}

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

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

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

@@ -0,0 +1,86 @@
+import React, { useEffect, useState } from 'react';
+import { ucIsDisabled, ucIsLoading, } from '../../../uc/index.js';
+import { sleep } from '../../../utils/index.js';
+import { useDIContext } from './DIContextProvider.js';
+import { UCContainer } from './UCContainer.js';
+export function UCPanel({ autoExec = false, clearAfterExec = true, onDone, onError, onInit, onStartSubmitting, renderAutoExecLoader, renderForm, renderExecTouchable, sleepInMs, uc, }) {
+    const { container } = useDIContext();
+    const [ucManager] = useState(container.get('UCManager'));
+    const [execState, setExecState] = useState(onInit ? 'initializing' : 'idle');
+    useEffect(() => {
+        if (!autoExec) {
+            return;
+        }
+        onSubmit();
+    }, [autoExec]);
+    useEffect(() => {
+        if (execState !== 'initializing') {
+            return;
+        }
+        (async () => {
+            await onInit?.(uc);
+            setExecState('idle');
+        })();
+    }, [execState, onInit, uc]);
+    const onChange = (f, op, v) => {
+        f.setValue(op, v);
+    };
+    const clear = () => {
+        if (!clearAfterExec) {
+            return;
+        }
+        uc.clear();
+    };
+    const onSubmit = async () => {
+        setExecState('submitting');
+        await sleep(100);
+        await onStartSubmitting?.();
+        const confirmed = await ucManager.confirmClient(uc);
+        if (!confirmed) {
+            setExecState('idle');
+            return false;
+        }
+        if (sleepInMs !== undefined) {
+            await sleep(sleepInMs);
+        }
+        try {
+            const ucor = await ucManager.execClient(uc);
+            await onDone?.(ucor);
+            clear();
+            return true;
+        }
+        catch (err) {
+            if (!onError) {
+                throw err;
+            }
+            onError(err);
+            return false;
+        }
+        finally {
+            setExecState('idle');
+        }
+    };
+    const disabled = ucIsDisabled(execState);
+    const loading = ucIsLoading(execState);
+    const ctx = {
+        clearAfterExec,
+        disabled,
+        execState,
+        uc,
+    };
+    const needsInputFilling = uc.needsInputFilling();
+    return (React.createElement(UCContainer, { uc: uc },
+        autoExec && loading && renderAutoExecLoader(),
+        !autoExec && (React.createElement(React.Fragment, null,
+            !needsInputFilling &&
+                renderExecTouchable({
+                    ...ctx,
+                    onSubmit,
+                }),
+            needsInputFilling &&
+                renderForm({
+                    ...ctx,
+                    onChange,
+                    onSubmit,
+                })))));
+}

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

@@ -0,0 +1,6 @@
+import type { URLPath } from '../../../dt/index.js';
+import type { UC, UCInput, UCOPIBase } from '../../../uc/index.js';
+export interface UCEntrypointCtx<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    path?: URLPath | undefined;
+    uc: UC<I, OPI0, OPI1>;
+}

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

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

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

@@ -0,0 +1,10 @@
+import type { ReactElement } from 'react';
+import type { DataType } from '../../../dt/index.js';
+import type { UCInput, UCInputField, UCInputFieldChangeOperator, UCInputFieldValue, UCOPIBase } from '../../../uc/index.js';
+import type { UCPanelCtx, UCPanelOnSubmit } from './panel.js';
+export type UCFormFieldControlOnChange<T extends DataType = DataType> = (f: UCInputField<T>, op: UCInputFieldChangeOperator, v: UCInputFieldValue<T>) => void;
+export type UCFormProps<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCPanelCtx<I, OPI0, OPI1> & {
+    onChange: UCFormFieldControlOnChange;
+    onSubmit: UCPanelOnSubmit;
+};
+export type RenderUCForm<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (props: UCFormProps<I, OPI0, OPI1>) => ReactElement;

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

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

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

@@ -0,0 +1,2 @@
+import type { ReactElement } from 'react';
+export type RenderUCAutoExecLoader = () => ReactElement;

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

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

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

@@ -0,0 +1,14 @@
+import type { UC, UCExecState, UCInput, UCOPIBase, UCOutputReader } from '../../../uc/index.js';
+export type UCPanelOnDone<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (ucor: UCOutputReader<I, OPI0, OPI1>) => Promise<void>;
+export type UCPanelOnError = (err: Error) => Promise<void>;
+export type UCPanelOnInit<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (uc: UC<I, OPI0, OPI1>) => Promise<void>;
+export type UCPanelOnStartSubmitting = () => Promise<void>;
+export type UCPanelOnSubmit = () => Promise<boolean>;
+export interface UCPanelState {
+    clearAfterExec?: boolean;
+    disabled: boolean;
+    execState: UCExecState;
+}
+export type UCPanelCtx<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCPanelState & {
+    uc: UC<I, OPI0, OPI1>;
+};

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

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

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

@@ -0,0 +1,12 @@
+import type { ReactElement } from 'react';
+import type { UCInput, UCOPIBase, UCWording } from '../../../uc/index.js';
+import type { UCEntrypointCtx } from './entrypoint.js';
+import type { UCPanelCtx, UCPanelOnSubmit } from './panel.js';
+export type UCEntrypointTouchableProps<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCEntrypointCtx<I, OPI0, OPI1> & {
+    wording: UCWording;
+};
+export type RenderUCEntrypointTouchable<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (props: UCEntrypointTouchableProps<I, OPI0, OPI1>) => ReactElement;
+export type UCExecTouchableProps<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UCPanelCtx<I, OPI0, OPI1> & {
+    onSubmit: UCPanelOnSubmit;
+};
+export type RenderUCExecTouchable<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (props: UCExecTouchableProps<I, OPI0, OPI1>) => ReactElement;

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

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

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

@@ -0,0 +1,15 @@
+import { type ArgsRecord, UC, type UCDef, type UCInput, type UCOPIBase } from '../../../uc/index.js';
+type CloneFunc<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (i: Partial<I>) => UC<I, OPI0, OPI1>;
+type DivertFunc<II extends UCInput | undefined = undefined, OOPI0 extends UCOPIBase | undefined = undefined, OOPI1 extends UCOPIBase | undefined = undefined> = (siblingUCD: UCDef) => UC<II, OOPI0, OOPI1>;
+type RefillFunc<I extends UCInput | undefined = undefined> = (i: Partial<I>) => void;
+export declare function useUC<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(appManifest: ArgsRecord<I, OPI0, OPI1>['appManifest'], def: ArgsRecord<I, OPI0, OPI1>['def'], auth: ArgsRecord<I, OPI0, OPI1>['auth'], opts?: {
+    fillWith: Partial<I>;
+}): [
+    UC<I, OPI0, OPI1>,
+    {
+        clone: CloneFunc<I, OPI0, OPI1>;
+        divert: DivertFunc;
+        refill: RefillFunc<I>;
+    }
+];
+export {};

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

@@ -0,0 +1,22 @@
+import { useState } from 'react';
+import { UC, } from '../../../uc/index.js';
+export function useUC(appManifest, def, auth, opts) {
+    const [uc, setUC] = useState(() => {
+        const { name: appName, ucReg } = appManifest;
+        const { name: ucName } = def.metadata;
+        if (!Object.keys(ucReg).includes(ucName)) {
+            throw new Error(`The use case ${ucName} does not exist in app ${appName}`);
+        }
+        const v = new UC(appManifest, def, auth);
+        if (opts?.fillWith) {
+            v.fill(opts?.fillWith);
+        }
+        return v;
+    });
+    const clone = (i) => new UC(uc.appManifest, uc.def, uc.auth).fill(i);
+    const divert = (siblingUCD) => new UC(uc.appManifest, siblingUCD, uc.auth);
+    const refill = (i) => {
+        setUC(new UC(uc.appManifest, uc.def, uc.auth).fill(i));
+    };
+    return [uc, { clone, divert, refill }];
+}

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

@@ -0,0 +1,17 @@
+import type { UCInput, UCOPIBase, UCOutputReader, UCOutputReaderPart } from '../../../uc/index.js';
+type AppendFunc<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (ucor: UCOutputReader<any, OPI0, OPI1>) => void;
+type RemoveFunc<OPI extends UCOPIBase> = (item: OPI) => void;
+type UpdateFunc<OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = (ucor: UCOutputReader<any, OPI0, OPI1>) => void;
+export declare function useUCOR<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>(ucor: UCOutputReader<I, OPI0, OPI1>): [
+    UCOutputReaderPart<NonNullable<OPI0>> | undefined,
+    UCOutputReaderPart<NonNullable<OPI1>> | undefined,
+    {
+        append0: AppendFunc<OPI0, OPI1>;
+        append1: AppendFunc<OPI0, OPI1>;
+        remove0: RemoveFunc<NonNullable<OPI0>>;
+        remove1: RemoveFunc<NonNullable<OPI1>>;
+        update0: UpdateFunc<OPI0, OPI1>;
+        update1: UpdateFunc<OPI0, OPI1>;
+    }
+];
+export {};