libmodulor 0.22.0 → 0.24.0

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

@@ -11,7 +11,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { inject, injectable } from 'inversify';
-import typescript, { isClassDeclaration, isObjectLiteralExpression, isPropertyAssignment, } from 'typescript';
+import typescript, { isClassDeclaration, isObjectLiteralExpression, isPropertyAssignment, SyntaxKind, } from 'typescript';
+// https://ts-ast-viewer.com
 // To avoid the following error when used in a consumer :
 // SyntaxError: Named export 'ModuleKind' not found. The requested module 'typescript' is a CommonJS module, which may not support all module.exports as named exports.
 // CommonJS modules can always be imported via the default export
@@ -99,20 +100,46 @@ let TypeScriptLibUCDefASTParser = class TypeScriptLibUCDefASTParser {
     }
     getTypeFields(node) {
         const type = this.typeChecker.getTypeAtLocation(node);
-        const fields = type.getProperties().map((p) => {
+        const fields = type
+            .getProperties()
+            .map((p) => {
             const field = {
                 err: null,
-                value: p.getName(),
+                value: {
+                    dataType: null,
+                    name: null,
+                    raw: null,
+                    type: null,
+                },
             };
             const declarations = p.getDeclarations();
-            if (declarations) {
-                const [first] = declarations;
-                if (first && isPropertySignature(first)) {
-                    field.value = first
-                        .getText()
-                        .replaceAll('\n', '')
-                        .replaceAll(';', '');
-                }
+            if (!declarations) {
+                return field;
+            }
+            const [first] = declarations;
+            if (first && isPropertySignature(first)) {
+                field.value.raw = first
+                    .getText()
+                    .replaceAll('\n', '')
+                    .replaceAll(';', '')
+                    .replaceAll(/\s+/g, ' ');
+                first.forEachChild((node1) => {
+                    if (isIdentifier(node1)) {
+                        field.value.name = node1.getText();
+                    }
+                    else if (isTypeReferenceNode(node1)) {
+                        field.value.type = node1.getText();
+                        node1.forEachChild((node2) => {
+                            if (isIdentifier(node2) ||
+                                isTypeReferenceNode(node2) ||
+                                node2.kind === SyntaxKind.BooleanKeyword ||
+                                node2.kind === SyntaxKind.NumberKeyword ||
+                                node2.kind === SyntaxKind.StringKeyword) {
+                                field.value.dataType = node2.getText();
+                            }
+                        });
+                    }
+                });
             }
             return field;
         });

package/dist/esm/testing/impl/VitestAppTestSuiteRunner.d.ts

@@ -5,7 +5,7 @@ export declare class VitestAppTestSuiteRunner implements AppTestSuiteRunner {
     private fsManager;
     private shellCommandExecutor;
     constructor(fsManager: FSManager, shellCommandExecutor: ShellCommandExecutor);
-    exec({ appPath, skipCoverage, updateSnapshots, }: Input): Promise<void>;
+    exec({ appPath, only, skipCoverage, updateSnapshots, }: Input): Promise<void>;
     coverageReportEntrypointPath(appPath: FilePath): Promise<FilePath>;
     private coverageReportPath;
 }

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

@@ -19,18 +19,33 @@ let VitestAppTestSuiteRunner = class VitestAppTestSuiteRunner {
         this.fsManager = fsManager;
         this.shellCommandExecutor = shellCommandExecutor;
     }
-    async exec({ appPath, skipCoverage, updateSnapshots, }) {
+    async exec({ appPath, only, skipCoverage, updateSnapshots, }) {
         const testPath = this.fsManager.path(appPath, APP_TEST_DIR_NAME);
         const args = [
             'run',
             '--color',
+            // https://vitest.dev/guide/cli.html#dir
             '--dir',
             appPath,
         ];
+        if (only) {
+            args.push(
+            // https://vitest.dev/guide/cli.html#testnamepattern
+            '--testNamePattern', only);
+        }
         if (!skipCoverage) {
-            args.push('--coverage.enabled', '--coverage.exclude', testPath, '--coverage.include', appPath, '--coverage.reportsDirectory', this.coverageReportPath(appPath));
+            args.push(
+            // https://vitest.dev/guide/cli.html#coverage-enabled
+            '--coverage.enabled', 
+            // https://vitest.dev/guide/cli.html#coverage-exclude
+            '--coverage.exclude', testPath, 
+            // https://vitest.dev/guide/cli.html#coverage-include
+            '--coverage.include', appPath, 
+            // https://vitest.dev/guide/cli.html#coverage-reportsdirectory
+            '--coverage.reportsDirectory', this.coverageReportPath(appPath));
         }
         if (updateSnapshots) {
+            // https://vitest.dev/guide/cli.html#update
             args.push('--update');
         }
         await this.shellCommandExecutor.exec({

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

@@ -18,8 +18,8 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
     const settings = {
         ...STD_DEFAULT_JWT_MANAGER_SETTINGS,
         ...TARGET_DEFAULT_SERVER_MANAGER_SETTINGS,
-        jwt_manager_audience: 'fik',
-        jwt_manager_issuer: 'fik',
+        jwt_manager_audience: 'libmodulor-test',
+        jwt_manager_issuer: 'libmodulor-test',
         jwt_manager_secret: new TPassword().example(),
         logger_level,
         server_basic_auth_entries: {
@@ -28,6 +28,7 @@ export async function newNodeAppTester(serverPortRangeStart, idx, args) {
         server_binding_port: serverPortRangeStart + idx,
         server_private_api_key_entries: [new TApiKey().example()],
         server_public_api_key_entries: [new TApiKey().example()],
+        server_stop_mode: 'aggressive',
     };
     const container = new Container(CONTAINER_OPTS);
     bindCommon(container, () => settings);

package/dist/esm/testing/opts.js

@@ -4,7 +4,7 @@ export const DEFAULT_APP_TESTER_OPTS = {
         imports: {
             external: {
                 aliasPrefix: '@',
-                allowed: ['inversify', 'libmodulor'],
+                allowed: ['libmodulor', 'inversify'],
             },
             internal: {
                 maxDepth: '../../',

package/dist/esm/testing/workers/AppTestSuiteRunner.d.ts

@@ -1,7 +1,9 @@
 import type { FilePath } from '../../dt/index.js';
 import type { Worker } from '../../std/index.js';
+import type { UCName } from '../../uc/index.js';
 export interface Input {
     appPath: FilePath;
+    only: UCName | null;
     skipCoverage: boolean;
     updateSnapshots: boolean;
 }

package/dist/esm/testing/workers/UCExecutor.js

@@ -104,7 +104,7 @@ let UCExecutor = class UCExecutor {
                     break;
                 }
                 default:
-                    ((_) => { })(transportType);
+                    transportType;
             }
             if (!ucor) {
                 throw new Error(ERR_CLIENT_EXPECTED_UCOR(name));

package/dist/esm/testing/workers/checkers/AppI18nChecker.d.ts

@@ -1,10 +1,12 @@
 import type { AppManifest } from '../../../app/index.js';
 import type { ErrorMessage } from '../../../dt/index.js';
-import type { I18n } from '../../../i18n/index.js';
+import { type I18n } from '../../../i18n/index.js';
 import type { Worker } from '../../../std/index.js';
+import type { Output as UCDefSourcesCheckerOutput } from './UCDefSourcesChecker.js';
 export interface Input {
     appI18n: I18n;
     appManifest: Pick<AppManifest, 'languageCodes'>;
+    ucDefSourcesCheckerOutput: UCDefSourcesCheckerOutput;
 }
 export interface Output {
     errors: ErrorMessage[];
@@ -13,7 +15,11 @@ export declare class AppI18nChecker implements Worker<Input, Promise<Output>> {
     private static I18N_KEY_PATTERN;
     private output;
     constructor();
-    exec({ appI18n, appManifest }: Input): Promise<Output>;
+    exec({ appI18n, appManifest, ucDefSourcesCheckerOutput, }: Input): Promise<Output>;
     private makeSureLanguagesAreConsistent;
     private makeSureKeysAndLabelsAreValid;
+    private makeSureNonDefaultLanguagesAreFullyTranslated;
+    private checkUC;
+    private checkIOFields;
+    private checkKey;
 }

package/dist/esm/testing/workers/checkers/AppI18nChecker.js

@@ -9,9 +9,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 var AppI18nChecker_1;
 import { injectable } from 'inversify';
+import { I18N_DEFAULT_LANG, } from '../../../i18n/index.js';
 const ERR_I18N_MISMATCH = () => 'The languageCodes in app manifest must match with the keys in i18n';
 const ERR_I18N_KEY_INVALID = (key) => `The i18n key '${key}' must respect the i18n key pattern`;
-const ERR_I18N_LABEL_NO_DOT = (key) => `The i18n key '${key}' is a label, thus should not ends with a dot`;
+const ERR_I18N_LABEL_NO_DOT = (key) => `The i18n key '${key}' is a label, thus it should not end with a dot`;
+const ERR_I18N_MISSING_TRANS = (key, lang) => `The i18n key '${key}' is missing for lang '${lang}'`;
 let AppI18nChecker = class AppI18nChecker {
     static { AppI18nChecker_1 = this; }
     static I18N_KEY_PATTERN = /(dt_([A-Z][A-Za-z0-9]+)_([A-Za-z0-9]+)_(desc|label))|(err_([A-Za-z_]+))|(uc_([A-Z][A-Za-z0-9]+)_(client_confirm_(cancel|confirm|message|title)|desc|label|i_submit_(changing|idle|initializing|submitting)|op_(0|1)_(empty|label)))|(ucif_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(ucof_([a-z]([A-Za-z0-9]+)?)_(desc|label))|(validation_([a-z]+)_([A-Z][A-Za-z0-9]+))/;
@@ -19,9 +21,10 @@ let AppI18nChecker = class AppI18nChecker {
     constructor() {
         this.output = { errors: [] };
     }
-    async exec({ appI18n, appManifest }) {
+    async exec({ appI18n, appManifest, ucDefSourcesCheckerOutput, }) {
         this.makeSureLanguagesAreConsistent(appI18n, appManifest);
         this.makeSureKeysAndLabelsAreValid(appI18n);
+        this.makeSureNonDefaultLanguagesAreFullyTranslated(appI18n, ucDefSourcesCheckerOutput);
         return this.output;
     }
     makeSureLanguagesAreConsistent(appI18n, appManifest) {
@@ -44,6 +47,45 @@ let AppI18nChecker = class AppI18nChecker {
             }
         }
     }
+    makeSureNonDefaultLanguagesAreFullyTranslated(i18n, ucDefSourcesCheckerOutput) {
+        for (const [lang, translations] of Object.entries(i18n)) {
+            if (lang === I18N_DEFAULT_LANG) {
+                // We assume the code is in English so it's fine not to have all the translations in this language.
+                // For instance, a field named "name" will be humanized as "Name", which is totally ok.
+                continue;
+            }
+            for (const { metadataName, ioIFields, ioOPI0Fields, ioOPI1Fields, } of ucDefSourcesCheckerOutput.items) {
+                this.checkUC(lang, translations, 'label', metadataName);
+                for (const [prefix, fields] of [
+                    ['ucif', ioIFields],
+                    ['ucof', ioOPI0Fields],
+                    ['ucof', ioOPI1Fields],
+                ]) {
+                    this.checkIOFields(lang, translations, prefix, 'label', fields);
+                }
+            }
+        }
+    }
+    checkUC(lang, translations, suffix, metadataName) {
+        if (!metadataName) {
+            return;
+        }
+        this.checkKey(lang, translations, `uc_${metadataName.value}_${suffix}`);
+    }
+    checkIOFields(lang, translations, prefix, suffix, fields) {
+        if (!fields) {
+            return;
+        }
+        for (const f of fields) {
+            this.checkKey(lang, translations, `${prefix}_${f.value.name}_${suffix}`);
+        }
+    }
+    checkKey(lang, translations, key) {
+        if (key in translations) {
+            return;
+        }
+        this.output.errors.push(ERR_I18N_MISSING_TRANS(key, lang));
+    }
 };
 AppI18nChecker = AppI18nChecker_1 = __decorate([
     injectable(),

package/dist/esm/testing/workers/checkers/UCDefSourcesChecker.js

@@ -18,7 +18,7 @@ const ERR_UCD_CONST_NAME = (name) => `The UCD const name '${name}' must follow t
 const ERR_UCD_FILE_SUFFIX = (fileName) => `The file '${fileName}' must end with ${UC_DEF_FILE_NAME_SUFFIX}`;
 const ERR_UCD_IMPORTS_EXTERNAL_ALLOWED = (aliasPrefix, allowed, text) => `External imports must be an alias '${aliasPrefix}*' or be one of ${allowed} (Got ${text})`;
 const ERR_UCD_IMPORTS_INTERNAL_MAX_DEPTH = (maxDepth) => `Internal imports must not be deeper than ${maxDepth}`;
-const ERR_UCD_INPUT_FIELD_PATTERN = () => `The input field def must match ${UC_INPUT_FIELD_PATTERN}`;
+const ERR_UCD_INPUT_FIELD_DECLARATION = (raw) => `The input field def must match 'name: UCInputFieldValue<DataType>' (Got '${raw}')`;
 const ERR_UCD_INPUT_TYPE_NAME = (ucName) => `The input type must be named ${ucName}${UC_INPUT_SUFFIX}`;
 const ERR_UCD_OPI_TYPE_NAME = (ucName, idx) => `The OPI must be named ${ucName}${UC_OPI_SUFFIX}${idx}`;
 // TODO : Improve the check* methods that look a little bit hacky
@@ -93,16 +93,16 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
         };
         item.ioIFields = fields;
         for (const f of item.ioIFields) {
-            const parts = f.value.split(':');
-            if (parts.length !== 2) {
-                continue;
+            const { dataType, name, raw, type } = f.value;
+            if (dataType &&
+                name &&
+                raw &&
+                type &&
+                type.match(new RegExp(UC_INPUT_FIELD_PATTERN)) !== null) {
+            }
+            else {
+                f.err = ERR_UCD_INPUT_FIELD_DECLARATION(raw);
             }
-            const [_name, type] = parts;
-            // trim because we process `name: Type` if the code is linted correctly
-            f.err =
-                type?.trim().match(new RegExp(UC_INPUT_FIELD_PATTERN)) !== null
-                    ? null
-                    : ERR_UCD_INPUT_FIELD_PATTERN();
         }
     }
     checkMainStep(lifecycle, step, item) {
@@ -120,7 +120,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
                 item.lifecycleServerSteps.push({ err: null, value: step });
                 break;
             default:
-                ((_) => { })(lifecycle);
+                lifecycle;
         }
     }
     checkMetadata(metadata, item) {
@@ -177,7 +177,7 @@ let UCDefSourcesChecker = class UCDefSourcesChecker {
                 };
                 break;
             default:
-                ((_) => { })(lifecycle);
+                lifecycle;
         }
     }
     async processFiles(appPath, paths) {

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

@@ -51,7 +51,7 @@ let HTTPUCTransporter = class HTTPUCTransporter {
                 break;
             }
             default:
-                ((_) => { })(publicApiKeyCheckType);
+                publicApiKeyCheckType;
         }
         if (auth) {
             switch (authType) {
@@ -86,7 +86,7 @@ let HTTPUCTransporter = class HTTPUCTransporter {
                     break;
                 }
                 default:
-                    ((_) => { })(authType);
+                    authType;
             }
         }
         const res = await this.httpAPICaller.exec({

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

@@ -112,7 +112,7 @@ let KnexUCDataStore = class KnexUCDataStore {
             case 'sqlite3':
                 return [];
             default:
-                ((_) => { })(type);
+                (type);
                 return [];
         }
     }
@@ -156,7 +156,7 @@ let KnexUCDataStore = class KnexUCDataStore {
                 this.fillConfigForSQLite3();
                 break;
             default:
-                ((_) => { })(type);
+                (type);
         }
     }
     fillConfigForPG() {

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

@@ -48,7 +48,6 @@ 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 './value.js';

package/dist/esm/uc/index.js

@@ -48,7 +48,6 @@ 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 './value.js';

package/dist/esm/uc/workers/UCExecChecker.js

@@ -59,7 +59,7 @@ let UCExecChecker = class UCExecChecker {
                 output.allowed = typeof server === 'object';
                 break;
             default:
-                ((_) => { })(lifecycle);
+                lifecycle;
         }
         return output;
     }

package/dist/esm/utils/bundling/babel/plugin.d.ts

@@ -0,0 +1,2 @@
+import { type PluginObj } from '@babel/core';
+export declare const Plugin: PluginObj;

package/dist/esm/utils/bundling/babel/plugin.js

@@ -0,0 +1,38 @@
+import { types as t } from '@babel/core';
+import { UC_LIFECYCLE_PROP_NAME, UC_LIFECYCLE_SERVER_PROP_NAME, } from '../../../convention.js';
+import { isFileEligible } from '../funcs.js';
+// Using `PluginObj` instead of `satisfies PluginObj`.
+// Otherwise TypeScript is not happy and triggers a TS2209.
+export const Plugin = {
+    name: 'libmodulor-plugin',
+    visitor: {
+        ObjectExpression(path, state) {
+            if (!isFileEligible(state.filename, ['js', 'ts'])) {
+                return;
+            }
+            const lifecycle = findLifecycleProp(path);
+            if (!lifecycle) {
+                return;
+            }
+            const lifecycleObj = lifecycle.value;
+            const server = findServerProp(lifecycleObj);
+            if (!server) {
+                return;
+            }
+            server.value = t.booleanLiteral(true);
+        },
+    },
+};
+function findLifecycleProp(path) {
+    return path.node.properties.find((p) => t.isObjectProperty(p) &&
+        t.isIdentifier(p.key, {
+            name: UC_LIFECYCLE_PROP_NAME,
+        }) &&
+        t.isObjectExpression(p.value));
+}
+function findServerProp(lifecycleObj) {
+    return lifecycleObj.properties.find((p) => t.isObjectProperty(p) &&
+        t.isIdentifier(p.key, {
+            name: UC_LIFECYCLE_SERVER_PROP_NAME,
+        }));
+}

package/dist/esm/utils/bundling/funcs.d.ts

@@ -0,0 +1,6 @@
+import type { FileName } from '../../dt/index.js';
+export type InputCode = string;
+export type OutputCode = string;
+export type StrippableFileExtension = 'js' | 'ts';
+export declare function isFileEligible(fileName: FileName | undefined, exts: StrippableFileExtension[]): boolean;
+export declare function assertTransformedCorrectly(transformed: OutputCode, fileName: FileName | undefined): void;

package/dist/esm/utils/bundling/funcs.js

@@ -0,0 +1,20 @@
+import { UC_DEF_SUFFIX } from '../../convention.js';
+export function isFileEligible(fileName, exts) {
+    if (!fileName) {
+        return false;
+    }
+    for (const ext of exts) {
+        if (fileName.endsWith(`${UC_DEF_SUFFIX}.${ext}`)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function assertTransformedCorrectly(transformed, fileName) {
+    const match = transformed.match(/server: (.*)ServerMain/g);
+    if (match !== null) {
+        // biome-ignore lint/suspicious/noConsole: we want it
+        console.warn(transformed);
+        throw new Error(`[WARNING] The following file might not have been transformed correctly : ${fileName} (see transformed above)`);
+    }
+}

package/dist/esm/utils/bundling/typescript.d.ts

@@ -0,0 +1,3 @@
+import type { FileName } from '../../dt/index.js';
+import type { InputCode, OutputCode } from './funcs.js';
+export declare function transform(code: InputCode, fileName: FileName): OutputCode;

package/dist/esm/utils/bundling/typescript.js

@@ -0,0 +1,61 @@
+import ts from 'typescript';
+import { UC_DEF_SUFFIX, UC_LIFECYCLE_PROP_NAME, UC_LIFECYCLE_SERVER_PROP_NAME, } from '../../convention.js';
+export function transform(code, fileName) {
+    const sourceFile = ts.createSourceFile(fileName, code, ts.ScriptTarget.ESNext);
+    const result = ts.transform(sourceFile, [transformer()]);
+    const transformed = result.transformed[0];
+    if (!transformed) {
+        throw new Error(`Could not transform file : ${fileName}`);
+    }
+    const printer = ts.createPrinter();
+    return printer.printFile(transformed);
+}
+function transformer() {
+    return (context) => {
+        return (sourceFile) => {
+            const { factory } = context;
+            function visit(node) {
+                if (!isUCDDeclaration(sourceFile, node)) {
+                    return ts.visitEachChild(node, visit, context);
+                }
+                const rootObj = node.initializer;
+                const lifecycle = findLifecycleProp(sourceFile, rootObj);
+                if (!lifecycle) {
+                    return ts.visitEachChild(node, visit, context);
+                }
+                const lifecycleObj = lifecycle.initializer;
+                const server = findServerProp(sourceFile, lifecycleObj);
+                if (!server) {
+                    return ts.visitEachChild(node, visit, context);
+                }
+                // Nodes are immutable so we need to re-create the whole tree
+                const newServer = factory.updatePropertyAssignment(server, server.name, factory.createTrue());
+                const newLifecycleObj = factory.updateObjectLiteralExpression(lifecycleObj, lifecycleObj.properties.map((p) => p === server ? newServer : p));
+                const newLifecycle = factory.updatePropertyAssignment(lifecycle, lifecycle.name, newLifecycleObj);
+                const newRootObj = factory.updateObjectLiteralExpression(rootObj, rootObj.properties.map((p) => p === lifecycle ? newLifecycle : p));
+                return factory.updateVariableDeclaration(node, node.name, node.exclamationToken, node.type, newRootObj);
+            }
+            return ts.visitNode(sourceFile, visit);
+        };
+    };
+}
+function isUCDDeclaration(sourceFile, node) {
+    if (!ts.isVariableDeclaration(node)) {
+        return false;
+    }
+    const name = node.name.getText(sourceFile);
+    return (name.endsWith(UC_DEF_SUFFIX) &&
+        !!node.initializer &&
+        ts.isObjectLiteralExpression(node.initializer));
+}
+function findLifecycleProp(sourceFile, rootObj) {
+    return rootObj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.getText(sourceFile) === UC_LIFECYCLE_PROP_NAME &&
+        ts.isObjectLiteralExpression(p.initializer));
+}
+function findServerProp(sourceFile, lifecycleObj) {
+    return lifecycleObj.properties.find((p) => ts.isPropertyAssignment(p) &&
+        ts.isIdentifier(p.name) &&
+        p.name.getText(sourceFile) === UC_LIFECYCLE_SERVER_PROP_NAME);
+}

package/dist/esm/utils/bundling/vite/plugin.d.ts

@@ -0,0 +1,6 @@
+export declare const Plugin: {
+    name: string;
+    transform: (this: import("rollup").TransformPluginContext, code: string, id: string) => {
+        code: string;
+    };
+};

package/dist/esm/utils/bundling/vite/plugin.js

@@ -0,0 +1,17 @@
+import { assertTransformedCorrectly, isFileEligible } from '../funcs.js';
+import { transform } from '../typescript.js';
+export const Plugin = {
+    name: 'libmodulor-plugin',
+    transform: (code, id) => {
+        if (!isFileEligible(id, ['ts'])) {
+            return {
+                code,
+            };
+        }
+        const transformed = transform(code, id);
+        assertTransformedCorrectly(transformed, id);
+        return {
+            code: transformed,
+        };
+    },
+};

package/dist/esm/utils/bundling/webpack/loader.d.ts

@@ -0,0 +1,2 @@
+import { type InputCode, type OutputCode } from '../funcs.js';
+export default function loader(source: InputCode): OutputCode;

package/dist/esm/utils/bundling/webpack/loader.js

@@ -0,0 +1,12 @@
+import { assertTransformedCorrectly, isFileEligible, } from '../funcs.js';
+import { transform } from '../typescript.js';
+export default function loader(source) {
+    // @ts-expect-error -- magically made available by Webpack at execution
+    const fileName = this.resourcePath;
+    if (!isFileEligible(fileName, ['ts'])) {
+        return source;
+    }
+    const transformed = transform(source, fileName);
+    assertTransformedCorrectly(transformed, fileName);
+    return transformed;
+}

package/dist/esm/utils/http/HTTPRequestBuilder.js

@@ -41,7 +41,7 @@ let HTTPRequestBuilder = class HTTPRequestBuilder {
                 break;
             }
             default:
-                ((_) => { })(envelope);
+                envelope;
                 return output;
         }
         return output;

package/dist/esm/utils/http/NDJSONStreamManager.d.ts

@@ -1,12 +1,13 @@
 import type { HTTPAPICallExecutorResBody, Worker } from '../../std/index.js';
 type Encoding = 'utf-8';
 interface I<D extends object = object> {
+    abortController: AbortController;
     encoding?: Encoding | undefined;
     onData: (data: D) => Promise<void>;
     reader: ReturnType<HTTPAPICallExecutorResBody['getReader']>;
 }
 export declare class NDJSONStreamManager implements Worker<I, Promise<void>> {
     private static DEFAULT_ENCODING;
-    exec({ encoding, onData, reader, }: I): Promise<void>;
+    exec({ abortController, encoding, onData, reader, }: I): Promise<void>;
 }
 export {};

package/dist/esm/utils/http/NDJSONStreamManager.js

@@ -10,10 +10,13 @@ import { NDJSON_DATA_SEP } from './nd-json.js';
 let NDJSONStreamManager = class NDJSONStreamManager {
     static { NDJSONStreamManager_1 = this; }
     static DEFAULT_ENCODING = 'utf-8';
-    async exec({ encoding = NDJSONStreamManager_1.DEFAULT_ENCODING, onData, reader, }) {
+    async exec({ abortController, encoding = NDJSONStreamManager_1.DEFAULT_ENCODING, onData, reader, }) {
         const decoder = new TextDecoder(encoding);
         let buffer = '';
         while (true) {
+            if (abortController.signal.aborted) {
+                return;
+            }
             const { done, value } = await reader.read();
             if (done) {
                 return;

package/dist/esm/utils/http/SSEStreamManager.d.ts

@@ -1,12 +1,13 @@
 import type { HTTPAPICallExecutorResBody, Worker } from '../../std/index.js';
 type Encoding = 'utf-8';
 interface I<D extends object = object> {
+    abortController: AbortController;
     encoding?: Encoding | undefined;
     onData: (data: D) => Promise<void>;
     reader: ReturnType<HTTPAPICallExecutorResBody['getReader']>;
 }
 export declare class SSEStreamManager implements Worker<I, Promise<void>> {
     private static DEFAULT_ENCODING;
-    exec({ encoding, onData, reader, }: I): Promise<void>;
+    exec({ abortController, encoding, onData, reader, }: I): Promise<void>;
 }
 export {};

package/dist/esm/utils/http/SSEStreamManager.js

@@ -11,10 +11,13 @@ import { isSSEError, parseDataLine, SSE_DATA_SEP, SSE_MSG_SEP } from './sse.js';
 let SSEStreamManager = class SSEStreamManager {
     static { SSEStreamManager_1 = this; }
     static DEFAULT_ENCODING = 'utf-8';
-    async exec({ encoding = SSEStreamManager_1.DEFAULT_ENCODING, onData, reader, }) {
+    async exec({ abortController, encoding = SSEStreamManager_1.DEFAULT_ENCODING, onData, reader, }) {
         const decoder = new TextDecoder(encoding);
         let buffer = '';
         while (true) {
+            if (abortController.signal.aborted) {
+                return;
+            }
             const { done, value } = await reader.read();
             if (done) {
                 return;

package/dist/esm/utils/ioc/bindCommon.js

@@ -49,7 +49,7 @@ export function bindCommon(container, settingsFunc) {
         .bind('I18nManager')
         .to(SimpleMapI18nManager)
         .inSingletonScope();
-    container.bind('I18n').toConstantValue({});
+    container.bind('I18n').toConstantValue({ en: {} });
     container.bind('Logger').to(ConsoleLogger);
     container.bind('Settings').toConstantValue(settings);
     container