libmodulor 0.25.0 → 0.27.0

package/dist/esm/apps/Helper/src/ucds/CreateAppUCD.js

@@ -0,0 +1,101 @@
+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_NAME_PLACEHOLDER } from '../../../../convention.js';
+import { TString } from '../../../../dt/index.js';
+import { IllegalArgumentError } from '../../../../error/index.js';
+import { EverybodyUCPolicy, } from '../../../../uc/index.js';
+import { GIT_KEEP_FILE_NAME } from '../lib/consts.js';
+import { successMessage } from '../lib/funcs.js';
+import { AppInputFieldsDef } from '../lib/io.js';
+import { files } from '../lib/layers/app.js';
+import { SrcFilesGenerator } from '../lib/SrcFilesGenerator.js';
+import { Manifest } from '../manifest.js';
+let CreateAppClientMain = class CreateAppClientMain {
+    fsManager;
+    i18nManager;
+    logger;
+    srcFilesGenerator;
+    rootPath;
+    constructor(fsManager, i18nManager, logger, srcFilesGenerator) {
+        this.fsManager = fsManager;
+        this.i18nManager = i18nManager;
+        this.logger = logger;
+        this.srcFilesGenerator = srcFilesGenerator;
+    }
+    async exec({ uc }) {
+        const appsPath = uc.reqVal0('appsPath');
+        const appName = uc.reqVal0('appName');
+        this.rootPath = this.fsManager.path(appsPath, appName);
+        // TODO : Rollback the whole thing in case of failure
+        await this.assertNotExisting();
+        await this.createRootDir();
+        await this.srcFilesGenerator.exec({
+            files: files(appName),
+            rootPath: this.rootPath,
+        });
+        await this.rmGitKeep();
+        this.logger.info(successMessage('App'));
+    }
+    async assertNotExisting() {
+        if (!(await this.fsManager.exists(this.rootPath))) {
+            return;
+        }
+        throw new IllegalArgumentError(this.i18nManager.t('err_existing_app', {
+            vars: { appPath: this.rootPath },
+        }));
+    }
+    async createRootDir() {
+        this.logger.info('Creating root dir : %s', this.rootPath);
+        await this.fsManager.mkdir(this.rootPath, { recursive: true });
+    }
+    async rmGitKeep() {
+        const filePath = this.fsManager.path(this.rootPath, '..', GIT_KEEP_FILE_NAME);
+        if (!(await this.fsManager.exists(filePath))) {
+            return;
+        }
+        await this.fsManager.rm(filePath);
+    }
+};
+CreateAppClientMain = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('I18nManager')),
+    __param(2, inject('Logger')),
+    __param(3, inject(SrcFilesGenerator)),
+    __metadata("design:paramtypes", [Object, Object, Object, SrcFilesGenerator])
+], CreateAppClientMain);
+export const CreateAppUCD = {
+    ext: {
+        cmd: {
+            mountAt: 'CreateApp',
+        },
+    },
+    io: {
+        i: {
+            fields: {
+                ...AppInputFieldsDef,
+                appName: {
+                    type: new TString().setExamples([APP_NAME_PLACEHOLDER]),
+                },
+            },
+        },
+    },
+    lifecycle: {
+        client: {
+            main: CreateAppClientMain,
+            policy: EverybodyUCPolicy,
+        },
+    },
+    metadata: Manifest.ucReg.CreateApp,
+};

package/dist/esm/apps/Helper/src/ucds/CreateProductUCD.d.ts

@@ -0,0 +1,7 @@
+import type { ProductName } from '../../../../product/index.js';
+import { type UCDef, type UCInputFieldValue } from '../../../../uc/index.js';
+import { type ProductInput } from '../lib/io.js';
+export interface CreateProductInput extends ProductInput {
+    productName: UCInputFieldValue<ProductName>;
+}
+export declare const CreateProductUCD: UCDef<CreateProductInput>;

package/dist/esm/apps/Helper/src/ucds/CreateProductUCD.js

@@ -0,0 +1,101 @@
+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 { PRODUCT_NAME_PLACEHOLDER } from '../../../../convention.js';
+import { TString } from '../../../../dt/index.js';
+import { IllegalArgumentError } from '../../../../error/index.js';
+import { EverybodyUCPolicy, } from '../../../../uc/index.js';
+import { GIT_KEEP_FILE_NAME } from '../lib/consts.js';
+import { successMessage } from '../lib/funcs.js';
+import { ProductInputFieldsDef } from '../lib/io.js';
+import { files } from '../lib/layers/product.js';
+import { SrcFilesGenerator } from '../lib/SrcFilesGenerator.js';
+import { Manifest } from '../manifest.js';
+let CreateProductClientMain = class CreateProductClientMain {
+    fsManager;
+    i18nManager;
+    logger;
+    srcFilesGenerator;
+    rootPath;
+    constructor(fsManager, i18nManager, logger, srcFilesGenerator) {
+        this.fsManager = fsManager;
+        this.i18nManager = i18nManager;
+        this.logger = logger;
+        this.srcFilesGenerator = srcFilesGenerator;
+    }
+    async exec({ uc }) {
+        const productsPath = uc.reqVal0('productsPath');
+        const productName = uc.reqVal0('productName');
+        this.rootPath = this.fsManager.path(productsPath, productName);
+        // TODO : Rollback the whole thing in case of failure
+        await this.assertNotExisting();
+        await this.createRootDir();
+        await this.srcFilesGenerator.exec({
+            files: files(productName),
+            rootPath: this.rootPath,
+        });
+        await this.rmGitKeep();
+        this.logger.info(successMessage('Product'));
+    }
+    async assertNotExisting() {
+        if (!(await this.fsManager.exists(this.rootPath))) {
+            return;
+        }
+        throw new IllegalArgumentError(this.i18nManager.t('err_existing_product', {
+            vars: { productPath: this.rootPath },
+        }));
+    }
+    async createRootDir() {
+        this.logger.info('Creating root dir : %s', this.rootPath);
+        await this.fsManager.mkdir(this.rootPath, { recursive: true });
+    }
+    async rmGitKeep() {
+        const filePath = this.fsManager.path(this.rootPath, '..', GIT_KEEP_FILE_NAME);
+        if (!(await this.fsManager.exists(filePath))) {
+            return;
+        }
+        await this.fsManager.rm(filePath);
+    }
+};
+CreateProductClientMain = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('I18nManager')),
+    __param(2, inject('Logger')),
+    __param(3, inject(SrcFilesGenerator)),
+    __metadata("design:paramtypes", [Object, Object, Object, SrcFilesGenerator])
+], CreateProductClientMain);
+export const CreateProductUCD = {
+    ext: {
+        cmd: {
+            mountAt: 'CreateProduct',
+        },
+    },
+    io: {
+        i: {
+            fields: {
+                ...ProductInputFieldsDef,
+                productName: {
+                    type: new TString().setExamples([PRODUCT_NAME_PLACEHOLDER]),
+                },
+            },
+        },
+    },
+    lifecycle: {
+        client: {
+            main: CreateProductClientMain,
+            policy: EverybodyUCPolicy,
+        },
+    },
+    metadata: Manifest.ucReg.CreateProduct,
+};

package/dist/esm/apps/Helper/src/ucds/CreateProjectUCD.d.ts

@@ -1,6 +1,5 @@
 import { type DirPath, type FileName, type FreeTextShort, type Slug } from '../../../../dt/index.js';
-import type { FSManager, Logger, ShellCommandExecutor } from '../../../../std/index.js';
-import { type UCDef, type UCInput, type UCInputFieldValue, type UCMain, type UCMainInput } from '../../../../uc/index.js';
+import { type UCDef, type UCInput, type UCInputFieldValue } from '../../../../uc/index.js';
 export interface CreateProjectInput extends UCInput {
     initialCommit: UCInputFieldValue<FreeTextShort>;
     outPath: UCInputFieldValue<DirPath>;
@@ -9,19 +8,4 @@ export interface CreateProjectInput extends UCInput {
     scmBin: UCInputFieldValue<FileName>;
     verbose: UCInputFieldValue<boolean>;
 }
-export declare class CreateProjectClientMain implements UCMain<CreateProjectInput> {
-    private fsManager;
-    private logger;
-    private shellCommandExecutor;
-    constructor(fsManager: FSManager, logger: Logger, shellCommandExecutor: ShellCommandExecutor);
-    exec({ uc }: UCMainInput<CreateProjectInput>): Promise<void>;
-    private assertBinPresence;
-    private commit;
-    private createConfigFiles;
-    private createDirs;
-    private createRootDir;
-    private initRepository;
-    private installDeps;
-    private runDevCmds;
-}
 export declare const CreateProjectUCD: UCDef<CreateProjectInput>;

package/dist/esm/apps/Helper/src/ucds/CreateProjectUCD.js

@@ -15,16 +15,22 @@ import { APPS_ROOT_PATH, PRODUCTS_ROOT_PATH } from '../../../../convention.js';
 import { TBoolean, TDirPath, TFileName, TFreeTextShort, TSlug, } from '../../../../dt/index.js';
 import { IllegalArgumentError } from '../../../../error/index.js';
 import { EverybodyUCPolicy, } from '../../../../uc/index.js';
-import { projectFiles } from '../lib/project.js';
+import { GIT_KEEP_FILE_NAME } from '../lib/consts.js';
+import { successMessage } from '../lib/funcs.js';
+import { files } from '../lib/layers/project.js';
+import { SrcFilesGenerator } from '../lib/SrcFilesGenerator.js';
 import { Manifest } from '../manifest.js';
 let CreateProjectClientMain = class CreateProjectClientMain {
     fsManager;
     logger;
     shellCommandExecutor;
-    constructor(fsManager, logger, shellCommandExecutor) {
+    srcFilesGenerator;
+    rootPath;
+    constructor(fsManager, logger, shellCommandExecutor, srcFilesGenerator) {
         this.fsManager = fsManager;
         this.logger = logger;
         this.shellCommandExecutor = shellCommandExecutor;
+        this.srcFilesGenerator = srcFilesGenerator;
     }
     async exec({ uc }) {
         const initialCommit = uc.reqVal0('initialCommit');
@@ -35,16 +41,19 @@ let CreateProjectClientMain = class CreateProjectClientMain {
         const verbose = uc.reqVal0('verbose');
         await this.assertBinPresence(pkgManagerBin);
         await this.assertBinPresence(scmBin);
-        const cwd = this.fsManager.path(outPath, projectName);
+        this.rootPath = this.fsManager.path(outPath, projectName);
         // TODO : Rollback the whole thing in case of failure
-        await this.createRootDir(cwd);
-        await this.initRepository(scmBin, cwd, verbose);
-        await this.createConfigFiles(projectName, cwd);
-        await this.createDirs(cwd);
-        await this.installDeps(pkgManagerBin, cwd, verbose);
-        await this.commit(scmBin, initialCommit, cwd, verbose);
-        await this.runDevCmds(pkgManagerBin, cwd, verbose);
-        this.logger.info('Done ! Project ready ! ✅ 🚀');
+        await this.createRootDir();
+        await this.initRepository(scmBin, verbose);
+        await this.srcFilesGenerator.exec({
+            files: files(projectName),
+            rootPath: this.rootPath,
+        });
+        await this.createDirs();
+        await this.installDeps(pkgManagerBin, verbose);
+        await this.commit(scmBin, initialCommit, verbose);
+        await this.runDevCmds(pkgManagerBin, verbose);
+        this.logger.info(successMessage('Project'));
     }
     async assertBinPresence(bin) {
         try {
@@ -57,7 +66,7 @@ let CreateProjectClientMain = class CreateProjectClientMain {
             throw new IllegalArgumentError(`'${bin}' seems missing. Is it installed on your machine ?`);
         }
     }
-    async commit(scmBin, initialCommit, cwd, verbose) {
+    async commit(scmBin, initialCommit, verbose) {
         this.logger.info('Committing');
         const cmdArgs = [
             ['branch', '-M', 'master'],
@@ -67,54 +76,51 @@ let CreateProjectClientMain = class CreateProjectClientMain {
         for await (const args of cmdArgs) {
             await this.shellCommandExecutor.exec({
                 bin: scmBin,
-                opts: { args, cwd, streamData: verbose },
+                opts: { args, cwd: this.rootPath, streamData: verbose },
             });
         }
     }
-    async createConfigFiles(projectName, cwd) {
-        const files = projectFiles(projectName);
-        for await (const [fileName, content] of files) {
-            const path = this.fsManager.path(cwd, fileName);
-            await this.fsManager.touch(path, content);
-        }
-    }
-    async createDirs(cwd) {
+    async createDirs() {
         this.logger.info('Creating apps and products directories');
         const dirs = [APPS_ROOT_PATH, PRODUCTS_ROOT_PATH];
         for await (const dirPath of dirs) {
-            const path = this.fsManager.path(cwd, ...dirPath);
+            const path = this.fsManager.path(this.rootPath, ...dirPath);
             await this.fsManager.mkdir(path, { recursive: true });
-            await this.fsManager.touch(this.fsManager.path(path, '.gitkeep'), '');
+            await this.fsManager.touch(this.fsManager.path(path, GIT_KEEP_FILE_NAME), '');
         }
     }
-    async createRootDir(cwd) {
-        this.logger.info('Creating root dir : %s', cwd);
-        await this.fsManager.mkdir(cwd, { recursive: true });
+    async createRootDir() {
+        this.logger.info('Creating root dir : %s', this.rootPath);
+        await this.fsManager.mkdir(this.rootPath, { recursive: true });
     }
-    async initRepository(scmBin, cwd, verbose) {
+    async initRepository(scmBin, verbose) {
         const cmd = 'init';
         this.logger.info('Initializing repository : %s %s', scmBin, cmd);
         await this.shellCommandExecutor.exec({
             bin: scmBin,
-            opts: { args: [cmd], cwd, streamData: verbose },
+            opts: { args: [cmd], cwd: this.rootPath, streamData: verbose },
         });
     }
-    async installDeps(pkgManagerBin, cwd, verbose) {
+    async installDeps(pkgManagerBin, verbose) {
         const cmd = 'install';
         this.logger.info('Installing dependencies : %s %s', pkgManagerBin, cmd);
         await this.shellCommandExecutor.exec({
             bin: pkgManagerBin,
-            opts: { args: [cmd], cwd, streamData: verbose },
+            opts: { args: [cmd], cwd: this.rootPath, streamData: verbose },
         });
     }
-    async runDevCmds(pkgManagerBin, cwd, verbose) {
+    async runDevCmds(pkgManagerBin, verbose) {
         const cmd = 'run';
         const scripts = ['lint', 'test'];
         for await (const script of scripts) {
             this.logger.info('Running dev command : %s %s %s', pkgManagerBin, cmd, script);
             await this.shellCommandExecutor.exec({
                 bin: pkgManagerBin,
-                opts: { args: [cmd, script], cwd, streamData: verbose },
+                opts: {
+                    args: [cmd, script],
+                    cwd: this.rootPath,
+                    streamData: verbose,
+                },
             });
         }
     }
@@ -124,9 +130,9 @@ CreateProjectClientMain = __decorate([
     __param(0, inject('FSManager')),
     __param(1, inject('Logger')),
     __param(2, inject('ShellCommandExecutor')),
-    __metadata("design:paramtypes", [Object, Object, Object])
+    __param(3, inject(SrcFilesGenerator)),
+    __metadata("design:paramtypes", [Object, Object, Object, SrcFilesGenerator])
 ], CreateProjectClientMain);
-export { CreateProjectClientMain };
 export const CreateProjectUCD = {
     ext: {
         cmd: {

package/dist/esm/apps/Helper/src/ucds/CreateTargetUCD.d.ts

@@ -0,0 +1,9 @@
+import type { ProductName } from '../../../../product/index.js';
+import { type TargetName } from '../../../../target/index.js';
+import { type UCDef, type UCInputFieldValue } from '../../../../uc/index.js';
+import { type ProductInput } from '../lib/io.js';
+export interface CreateTargetInput extends ProductInput {
+    productName: UCInputFieldValue<ProductName>;
+    targetName: UCInputFieldValue<TargetName>;
+}
+export declare const CreateTargetUCD: UCDef<CreateTargetInput>;

package/dist/esm/apps/Helper/src/ucds/CreateTargetUCD.js

@@ -0,0 +1,109 @@
+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 { PRODUCT_NAME_PLACEHOLDER, PRODUCT_TARGETS_DIR_NAME, TARGET_NAME_PLACEHOLDER, } from '../../../../convention.js';
+import { TString } from '../../../../dt/index.js';
+import { IllegalArgumentError } from '../../../../error/index.js';
+import { TARGETS } from '../../../../target/index.js';
+import { EverybodyUCPolicy, } from '../../../../uc/index.js';
+import { successMessage } from '../lib/funcs.js';
+import { ProductInputFieldsDef } from '../lib/io.js';
+import { files } from '../lib/layers/target.js';
+import { SrcFilesGenerator } from '../lib/SrcFilesGenerator.js';
+import { Manifest } from '../manifest.js';
+let CreateTargetClientMain = class CreateTargetClientMain {
+    fsManager;
+    i18nManager;
+    logger;
+    srcFilesGenerator;
+    rootPath;
+    constructor(fsManager, i18nManager, logger, srcFilesGenerator) {
+        this.fsManager = fsManager;
+        this.i18nManager = i18nManager;
+        this.logger = logger;
+        this.srcFilesGenerator = srcFilesGenerator;
+    }
+    async exec({ uc }) {
+        const productsPath = uc.reqVal0('productsPath');
+        const productName = uc.reqVal0('productName');
+        const targetName = uc.reqVal0('targetName');
+        this.rootPath = this.fsManager.path(productsPath, productName, PRODUCT_TARGETS_DIR_NAME, targetName);
+        // TODO : Rollback the whole thing in case of failure
+        const filesToGenerate = files(targetName);
+        if (filesToGenerate.size === 0) {
+            throw new IllegalArgumentError(this.i18nManager.t('err_target_generator_not_available'));
+        }
+        await this.assertNotExisting();
+        await this.createRootDir();
+        await this.srcFilesGenerator.exec({
+            files: files(targetName),
+            rootPath: this.rootPath,
+        });
+        this.logger.info(successMessage('Target'));
+    }
+    async assertNotExisting() {
+        if (!(await this.fsManager.exists(this.rootPath))) {
+            return;
+        }
+        throw new IllegalArgumentError(this.i18nManager.t('err_existing_target', {
+            vars: { targetPath: this.rootPath },
+        }));
+    }
+    async createRootDir() {
+        this.logger.info('Creating root dir : %s', this.rootPath);
+        if (await this.fsManager.exists(this.rootPath)) {
+            return;
+        }
+        await this.fsManager.mkdir(this.rootPath, { recursive: true });
+    }
+};
+CreateTargetClientMain = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('I18nManager')),
+    __param(2, inject('Logger')),
+    __param(3, inject(SrcFilesGenerator)),
+    __metadata("design:paramtypes", [Object, Object, Object, SrcFilesGenerator])
+], CreateTargetClientMain);
+export const CreateTargetUCD = {
+    ext: {
+        cmd: {
+            mountAt: 'CreateTarget',
+        },
+    },
+    io: {
+        i: {
+            fields: {
+                ...ProductInputFieldsDef,
+                productName: {
+                    type: new TString().setExamples([PRODUCT_NAME_PLACEHOLDER]),
+                },
+                targetName: {
+                    type: new TString()
+                        .setOptions(Object.keys(TARGETS).map((t) => ({
+                        label: t,
+                        value: t,
+                    })))
+                        .setExamples([TARGET_NAME_PLACEHOLDER]),
+                },
+            },
+        },
+    },
+    lifecycle: {
+        client: {
+            main: CreateTargetClientMain,
+            policy: EverybodyUCPolicy,
+        },
+    },
+    metadata: Manifest.ucReg.CreateTarget,
+};

package/dist/esm/apps/Helper/src/ucds/CreateUCUCD.d.ts

@@ -0,0 +1,8 @@
+import type { AppName } from '../../../../app/index.js';
+import { type UCDef, type UCInputFieldValue, type UCName } from '../../../../uc/index.js';
+import { type AppInput } from '../lib/io.js';
+export interface CreateUCInput extends AppInput {
+    appName: UCInputFieldValue<AppName>;
+    ucName: UCInputFieldValue<UCName>;
+}
+export declare const CreateUCUCD: UCDef<CreateUCInput>;

package/dist/esm/apps/Helper/src/ucds/CreateUCUCD.js

@@ -0,0 +1,87 @@
+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_NAME_PLACEHOLDER, APP_SRC_DIR_NAME, APP_SRC_UCDS_DIR_NAME, UC_NAME_PLACEHOLDER, } from '../../../../convention.js';
+import { TString } from '../../../../dt/index.js';
+import { EverybodyUCPolicy, } from '../../../../uc/index.js';
+import { successMessage } from '../lib/funcs.js';
+import { AppInputFieldsDef } from '../lib/io.js';
+import { files } from '../lib/layers/uc.js';
+import { SrcFilesGenerator } from '../lib/SrcFilesGenerator.js';
+import { Manifest } from '../manifest.js';
+let CreateUCClientMain = class CreateUCClientMain {
+    fsManager;
+    logger;
+    srcFilesGenerator;
+    rootPath;
+    constructor(fsManager, logger, srcFilesGenerator) {
+        this.fsManager = fsManager;
+        this.logger = logger;
+        this.srcFilesGenerator = srcFilesGenerator;
+    }
+    async exec({ uc }) {
+        const appsPath = uc.reqVal0('appsPath');
+        const appName = uc.reqVal0('appName');
+        const ucName = uc.reqVal0('ucName');
+        this.rootPath = this.fsManager.path(appsPath, appName, APP_SRC_DIR_NAME, APP_SRC_UCDS_DIR_NAME);
+        // TODO : Rollback the whole thing in case of failure
+        await this.createRootDir();
+        await this.srcFilesGenerator.exec({
+            files: files(ucName),
+            rootPath: this.rootPath,
+        });
+        this.logger.info(successMessage('Use case'));
+        this.logger.info('You can now register the use case in the App Manifest');
+    }
+    async createRootDir() {
+        this.logger.info('Creating root dir : %s', this.rootPath);
+        if (await this.fsManager.exists(this.rootPath)) {
+            return;
+        }
+        await this.fsManager.mkdir(this.rootPath, { recursive: true });
+    }
+};
+CreateUCClientMain = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('Logger')),
+    __param(2, inject(SrcFilesGenerator)),
+    __metadata("design:paramtypes", [Object, Object, SrcFilesGenerator])
+], CreateUCClientMain);
+export const CreateUCUCD = {
+    ext: {
+        cmd: {
+            mountAt: 'CreateUC',
+        },
+    },
+    io: {
+        i: {
+            fields: {
+                ...AppInputFieldsDef,
+                appName: {
+                    type: new TString().setExamples([APP_NAME_PLACEHOLDER]),
+                },
+                ucName: {
+                    type: new TString().setExamples([UC_NAME_PLACEHOLDER]),
+                },
+            },
+        },
+    },
+    lifecycle: {
+        client: {
+            main: CreateUCClientMain,
+            policy: EverybodyUCPolicy,
+        },
+    },
+    metadata: Manifest.ucReg.CreateUC,
+};

package/dist/esm/apps/Helper/src/ucds/DeleteGeneratedAppsTestsUCD.d.ts

@@ -1,5 +1,5 @@
 import { type UCDef } from '../../../../uc/index.js';
-import { type AppInput } from '../lib/app.js';
+import { type AppInput } from '../lib/io.js';
 export interface DeleteGeneratedAppsTestsInput extends AppInput {
 }
 export declare const DeleteGeneratedAppsTestsUCD: UCDef<DeleteGeneratedAppsTestsInput>;

package/dist/esm/apps/Helper/src/ucds/DeleteGeneratedAppsTestsUCD.js

@@ -14,7 +14,7 @@ import { inject, injectable } from 'inversify';
 import { AppSrcBrowser } from '../../../../app/index.js';
 import { APP_TEST_DIR_NAME, APP_TEST_MAIN_FILE_NAME, } from '../../../../convention.js';
 import { EverybodyUCPolicy, } from '../../../../uc/index.js';
-import { AppInputFieldsDef } from '../lib/app.js';
+import { AppInputFieldsDef } from '../lib/io.js';
 import { Manifest } from '../manifest.js';
 let DeleteGeneratedAppsTestsClientMain = class DeleteGeneratedAppsTestsClientMain {
     appSrcBrowser;

package/dist/esm/apps/Helper/src/ucds/GenerateAppsTestsUCD.d.ts

@@ -1,6 +1,6 @@
 import { type FilePath, type HostPort, type UIntDuration } from '../../../../dt/index.js';
 import { type UCDef, type UCInputFieldValue } from '../../../../uc/index.js';
-import { type AppInput } from '../lib/app.js';
+import { type AppInput } from '../lib/io.js';
 declare const DEP_MAPPING_SEP = "::";
 type DepMapping = `${FilePath}${typeof DEP_MAPPING_SEP}${FilePath}`;
 export interface GenerateAppsTestsInput extends AppInput {

package/dist/esm/apps/Helper/src/ucds/GenerateAppsTestsUCD.js

@@ -14,7 +14,7 @@ import { inject, injectable } from 'inversify';
 import { AppSrcBrowser } from '../../../../app/index.js';
 import { THostPort, TString, TUIntDuration, } from '../../../../dt/index.js';
 import { EverybodyUCPolicy, } from '../../../../uc/index.js';
-import { AppInputFieldsDef } from '../lib/app.js';
+import { AppInputFieldsDef } from '../lib/io.js';
 import { Manifest } from '../manifest.js';
 const DEP_MAPPING_SEP = '::';
 class TDepMapping extends TString {

package/dist/esm/apps/Helper/src/ucds/TestAppUCD.d.ts

@@ -1,6 +1,6 @@
 import type { AppName } from '../../../../app/index.js';
 import { type UCDef, type UCInputFieldValue, type UCName } from '../../../../uc/index.js';
-import { type AppInput } from '../lib/app.js';
+import { type AppInput } from '../lib/io.js';
 export interface TestAppInput extends AppInput {
     appName: UCInputFieldValue<AppName>;
     only: UCInputFieldValue<UCName>;

package/dist/esm/apps/Helper/src/ucds/TestAppUCD.js

@@ -16,7 +16,7 @@ import { TBoolean, TString } from '../../../../dt/index.js';
 import { IllegalArgumentError } from '../../../../error/index.js';
 import { SimpleHTMLAppTestReportEmitter } from '../../../../testing/impl/SimpleHTMLAppTestReportEmitter.js';
 import { EverybodyUCPolicy, } from '../../../../uc/index.js';
-import { AppInputFieldsDef } from '../lib/app.js';
+import { AppInputFieldsDef } from '../lib/io.js';
 import { Manifest } from '../manifest.js';
 let TestAppClientMain = class TestAppClientMain {
     appTestSuiteRunner;