libmodulor 0.1.0 → 0.2.0

package/dist/esm/std/impl/SimpleHTTPAPICaller.js

@@ -0,0 +1,196 @@
+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 { CustomError, IllegalArgumentError } from '../../error/index.js';
+import { HTTPRequestBuilder } from '../../utils/index.js';
+let SimpleHTTPAPICaller = class SimpleHTTPAPICaller {
+    bufferManager;
+    httpAPICallExecutor;
+    httpAPICallExecutorAgentBuilder;
+    httpRequestBuilder;
+    logger;
+    xmlManager;
+    constructor(bufferManager, httpAPICallExecutor, httpAPICallExecutorAgentBuilder, httpRequestBuilder, logger, xmlManager) {
+        this.bufferManager = bufferManager;
+        this.httpAPICallExecutor = httpAPICallExecutor;
+        this.httpAPICallExecutorAgentBuilder = httpAPICallExecutorAgentBuilder;
+        this.httpRequestBuilder = httpRequestBuilder;
+        this.logger = logger;
+        this.xmlManager = xmlManager;
+    }
+    async exec({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType = 'application/json', errBuilder, method, opts, outputBuilder, req, urlBuilder, unknownErrorMessage = CustomError.ERROR_UNKNOWN, }) {
+        const baseURL = await urlBuilder();
+        const data = (await req?.builder?.()) || {};
+        const { body, url } = await this.httpRequestBuilder.exec({
+            baseURL,
+            data,
+            envelope: req?.envelope || 'query-params',
+        });
+        const reqHeaders = await this.computeHeaders({
+            additionalHeadersBuilder,
+            authorizationHeader,
+            basicAuth,
+            contentType,
+            req,
+        });
+        const agent = this.httpAPICallExecutorAgentBuilder.exec({
+            url: new URL(url),
+        });
+        const response = await this.httpAPICallExecutor.fn()(url, {
+            agent,
+            body,
+            headers: reqHeaders,
+            method,
+        });
+        const { headers, status } = response;
+        this.logger.trace('HTTPAPICaller', {
+            body,
+            method,
+            reqHeaders,
+            resHeaders: Array.from(headers.entries()),
+            status,
+            url,
+        });
+        if (status === 202 || status === 204) {
+            return {};
+        }
+        const responseContentType = headers.get('Content-Type');
+        const isJSON = responseContentType?.startsWith('application/json');
+        const isFormURLEncoded = responseContentType?.startsWith('application/x-www-form-urlencoded');
+        const isXML = responseContentType?.startsWith('text/xml');
+        this.logger.trace('HTTPAPICaller', {
+            isFormURLEncoded,
+            isJSON,
+            isXML,
+        });
+        const { ok, redirected } = response;
+        if (ok || redirected) {
+            return this.processResGood({ opts, outputBuilder }, isFormURLEncoded, isJSON, isXML, response);
+        }
+        const errMsg = await this.processResBad({ errBuilder, opts }, isJSON, isXML, response);
+        const message = errMsg ?? unknownErrorMessage;
+        if (status < 500) {
+            throw new IllegalArgumentError(message);
+        }
+        throw new Error(message);
+    }
+    async computeHeaders({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType = 'application/json', req, }) {
+        const headers = {};
+        if (req?.envelope !== 'form-data') {
+            headers['Content-Type'] = contentType;
+        }
+        if (authorizationHeader) {
+            const { prefix, value } = authorizationHeader;
+            headers['Authorization'] = [prefix, value].join(' ').trim();
+        }
+        if (basicAuth) {
+            const { password, username } = basicAuth;
+            const prefix = 'Basic';
+            const value = this.bufferManager.encodeBase64([username, password].join(':'));
+            headers['Authorization'] = [prefix, value].join(' ').trim();
+        }
+        if (additionalHeadersBuilder) {
+            const additionalHeaders = await additionalHeadersBuilder();
+            if (additionalHeaders) {
+                for (const [k, v] of Object.entries(additionalHeaders)) {
+                    headers[k] = v;
+                }
+            }
+        }
+        return headers;
+    }
+    async processResBad({ errBuilder, opts, }, isJSON, isXML, response) {
+        let error;
+        try {
+            if (isJSON) {
+                error = await response.json();
+            }
+            else {
+                const asText = await response.text();
+                this.logger.trace('HTTPAPICaller', {
+                    asText,
+                });
+                if (isXML) {
+                    error = await this.xmlManager.parse(asText, opts?.xml);
+                }
+                else {
+                    error = asText;
+                }
+            }
+            this.logger.trace('HTTPAPICaller', { error });
+        }
+        catch (err) {
+            this.logger.error(err);
+            return null;
+        }
+        if (typeof error === 'string') {
+            return error.trim();
+        }
+        if (!error) {
+            return null;
+        }
+        try {
+            const message = await errBuilder(error);
+            if (typeof message === 'string') {
+                return message;
+            }
+            return JSON.stringify(message);
+        }
+        catch (err) {
+            this.logger.error(err);
+            return JSON.stringify(error);
+        }
+    }
+    async processResGood({ opts, outputBuilder, }, isFormURLEncoded, isJSON, isXML, response) {
+        let payload;
+        if (isJSON) {
+            payload = await response.json();
+        }
+        else {
+            const asText = await response.text();
+            this.logger.trace('HTTPAPICaller', {
+                asText,
+            });
+            if (isFormURLEncoded) {
+                payload = {};
+                new URL(`http://localhost?${asText}`).searchParams.forEach((v, k) => {
+                    payload[k] = v;
+                });
+            }
+            else if (isXML) {
+                payload = await this.xmlManager.parse(asText, opts?.xml);
+            }
+            else {
+                payload = asText;
+            }
+        }
+        this.logger.trace('HTTPAPICaller', {
+            payload,
+        });
+        if (payload && outputBuilder) {
+            return outputBuilder(payload);
+        }
+        return payload;
+    }
+};
+SimpleHTTPAPICaller = __decorate([
+    injectable(),
+    __param(0, inject('BufferManager')),
+    __param(1, inject('HTTPAPICallExecutor')),
+    __param(2, inject('HTTPAPICallExecutorAgentBuilder')),
+    __param(3, inject(HTTPRequestBuilder)),
+    __param(4, inject('Logger')),
+    __param(5, inject('XMLManager')),
+    __metadata("design:paramtypes", [Object, Object, Object, HTTPRequestBuilder, Object, Object])
+], SimpleHTTPAPICaller);
+export { SimpleHTTPAPICaller };

package/dist/esm/std/impl/SimpleMapI18nManager.d.ts

@@ -0,0 +1,16 @@
+import { type I18n, type I18nLanguageCode, type I18nTranslationKey } from '../../i18n/index.js';
+import type { I18nManager, I18nManagerTOpts } from '../I18nManager.js';
+import type { Logger } from '../Logger.js';
+export declare class SimpleMapI18nManager implements I18nManager {
+    private i18n;
+    private logger;
+    private static PLACEHOLDERS_REGEX;
+    private entries;
+    constructor(i18n: I18n, logger: Logger);
+    add<K extends I18nTranslationKey>(key: K, value: string): Promise<void>;
+    init(): Promise<void>;
+    l(): I18nLanguageCode;
+    t<K extends I18nTranslationKey>(key: K, opts?: I18nManagerTOpts): string;
+    tOrNull<K extends I18nTranslationKey>(key: K, _opts?: I18nManagerTOpts): string | null;
+    private replacePlaceholders;
+}

package/dist/esm/std/impl/SimpleMapI18nManager.js

@@ -0,0 +1,74 @@
+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 SimpleMapI18nManager_1;
+import { inject, injectable } from 'inversify';
+import { I18N_DEFAULT_LANG, } from '../../i18n/index.js';
+let SimpleMapI18nManager = class SimpleMapI18nManager {
+    static { SimpleMapI18nManager_1 = this; }
+    i18n;
+    logger;
+    static PLACEHOLDERS_REGEX = /{{([A-Z-a-z0-9]+)}}/g;
+    entries;
+    constructor(i18n, logger) {
+        this.i18n = i18n;
+        this.logger = logger;
+        this.entries = new Map();
+    }
+    async add(key, value) {
+        this.entries.set(key, value);
+    }
+    async init() {
+        const translations = this.i18n[this.l()];
+        this.logger.trace('Initializing I18nManager', { translations });
+        if (!translations) {
+            return;
+        }
+        for (const [k, v] of Object.entries(translations)) {
+            this.entries.set(k, v);
+        }
+    }
+    l() {
+        return I18N_DEFAULT_LANG;
+    }
+    t(key, opts) {
+        const v = this.entries.get(key);
+        if (v) {
+            return this.replacePlaceholders(v, opts);
+        }
+        if (opts?.fallback) {
+            return opts.fallback;
+        }
+        return key;
+    }
+    tOrNull(key, _opts) {
+        return this.entries.get(key) || null;
+    }
+    replacePlaceholders(v, opts) {
+        let res = v;
+        const placeholders = res.matchAll(SimpleMapI18nManager_1.PLACEHOLDERS_REGEX);
+        for (const [placeholder, key] of placeholders) {
+            if (!key) {
+                continue;
+            }
+            res = res.replaceAll(placeholder, opts?.vars?.[key] ?? '');
+        }
+        return res;
+    }
+};
+SimpleMapI18nManager = SimpleMapI18nManager_1 = __decorate([
+    injectable(),
+    __param(0, inject('I18n')),
+    __param(1, inject('Logger')),
+    __metadata("design:paramtypes", [Object, Object])
+], SimpleMapI18nManager);
+export { SimpleMapI18nManager };

package/dist/esm/std/impl/StaticSettingsManager.d.ts

@@ -0,0 +1,6 @@
+import type { Settings, SettingsGetter, SettingsManager } from '../SettingsManager.js';
+export declare class StaticSettingsManager<S extends Settings = Settings> implements SettingsManager<S> {
+    private settings;
+    constructor(settings: S);
+    get(): SettingsGetter<S>;
+}

package/dist/esm/std/impl/StaticSettingsManager.js

@@ -0,0 +1,28 @@
+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';
+let StaticSettingsManager = class StaticSettingsManager {
+    settings;
+    constructor(settings) {
+        this.settings = settings;
+    }
+    get() {
+        return (key) => this.settings[key];
+    }
+};
+StaticSettingsManager = __decorate([
+    injectable(),
+    __param(0, inject('Settings')),
+    __metadata("design:paramtypes", [Object])
+], StaticSettingsManager);
+export { StaticSettingsManager };

package/dist/esm/std/impl/StdDateClockManager.d.ts

@@ -0,0 +1,7 @@
+import type { Timestamp } from '../../dt/index.js';
+import type { ClockManager, ClockManagerDateKey } from '../ClockManager.js';
+export declare class StdDateClockManager implements ClockManager {
+    now(): Date;
+    nowToKey(): ClockManagerDateKey;
+    time(): Timestamp;
+}

package/dist/esm/std/impl/StdDateClockManager.js

@@ -0,0 +1,25 @@
+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;
+};
+import { injectable } from 'inversify';
+let StdDateClockManager = class StdDateClockManager {
+    now() {
+        return new Date();
+    }
+    nowToKey() {
+        return this.now()
+            .toISOString()
+            .replaceAll(/-|T|:/g, '')
+            .split('.')[0];
+    }
+    time() {
+        return Math.round(this.now().getTime() / 1000);
+    }
+};
+StdDateClockManager = __decorate([
+    injectable()
+], StdDateClockManager);
+export { StdDateClockManager };

package/dist/esm/std/impl/UCDataStoreExternalResourceManager.d.ts

@@ -0,0 +1,10 @@
+import type { UCDataStore } from '../../uc/index.js';
+import type { ExternalResourceManager } from '../ExternalResourceManager.js';
+export declare class UCDataStoreExternalResourceManager implements ExternalResourceManager {
+    private ucDataStore;
+    constructor(ucDataStore: UCDataStore);
+    create(): Promise<void>;
+    delete(): Promise<void>;
+    exists(): Promise<boolean>;
+    name(): string;
+}

package/dist/esm/std/impl/UCDataStoreExternalResourceManager.js

@@ -0,0 +1,37 @@
+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';
+let UCDataStoreExternalResourceManager = class UCDataStoreExternalResourceManager {
+    ucDataStore;
+    constructor(ucDataStore) {
+        this.ucDataStore = ucDataStore;
+    }
+    async create() {
+        return this.ucDataStore.install();
+    }
+    async delete() {
+        return this.ucDataStore.destroy();
+    }
+    async exists() {
+        return this.ucDataStore.exists();
+    }
+    name() {
+        return 'data store';
+    }
+};
+UCDataStoreExternalResourceManager = __decorate([
+    injectable(),
+    __param(0, inject('UCDataStore')),
+    __metadata("design:paramtypes", [Object])
+], UCDataStoreExternalResourceManager);
+export { UCDataStoreExternalResourceManager };

package/dist/esm/std/impl/WebCryptoManager.d.ts

@@ -0,0 +1,13 @@
+import type { Password, UIntQuantity, UUID } from '../../dt/index.js';
+import type { BufferManagerBase64String } from '../BufferManager.js';
+import type { CryptoManager, CryptoManagerHMACKey, CryptoManagerHMACKeyEncoding, CryptoManagerHash, CryptoManagerHashAlgorithm, CryptoManagerRandomString, CryptoManagerSalt, CryptoManagerSaltedScrypt } from '../CryptoManager.js';
+export declare class WebCryptoManager implements CryptoManager {
+    clear(): Promise<void>;
+    hash(_algorithm: CryptoManagerHashAlgorithm, _base: string): CryptoManagerHash;
+    hmacToBase64(_algorithm: CryptoManagerHashAlgorithm, _base: string, _key: CryptoManagerHMACKey, _keyEncoding: CryptoManagerHMACKeyEncoding): BufferManagerBase64String;
+    hmacToHex(_algorithm: CryptoManagerHashAlgorithm, _base: string, _key: CryptoManagerHMACKey, _keyEncoding: CryptoManagerHMACKeyEncoding): CryptoManagerHash;
+    pbkdf2(password: Password, salt: CryptoManagerSalt, iterationsCount: UIntQuantity, keyLength: UIntQuantity, digest: CryptoManagerHashAlgorithm): Promise<Uint8Array>;
+    randomString(length: UIntQuantity): Promise<CryptoManagerRandomString>;
+    randomUUID(): UUID;
+    scrypt(): Promise<CryptoManagerSaltedScrypt>;
+}

package/dist/esm/std/impl/WebCryptoManager.js

@@ -0,0 +1,60 @@
+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;
+};
+import { injectable } from 'inversify';
+const DIGEST_MAPPING = new Map([
+    ['sha512', 'SHA-512'],
+]);
+let WebCryptoManager = class WebCryptoManager {
+    async clear() {
+    }
+    hash(_algorithm, _base) {
+        throw new Error('Method not implemented.');
+    }
+    hmacToBase64(_algorithm, _base, _key, _keyEncoding) {
+        throw new Error('Method not implemented.');
+    }
+    hmacToHex(_algorithm, _base, _key, _keyEncoding) {
+        throw new Error('Method not implemented.');
+    }
+    async pbkdf2(password, salt, iterationsCount, keyLength, digest) {
+        const hash = DIGEST_MAPPING.get(digest);
+        if (!hash) {
+            throw new Error(`Digest ${digest} is not valid for WebCryptoManager`);
+        }
+        const textEncoder = new TextEncoder();
+        const passwordKey = await crypto.subtle.importKey('raw', textEncoder.encode(password), 'PBKDF2', false, ['deriveBits']);
+        const result = await crypto.subtle.deriveBits({
+            hash,
+            iterations: iterationsCount,
+            name: 'PBKDF2',
+            salt: textEncoder.encode(salt),
+        }, passwordKey, keyLength * 8);
+        return new Uint8Array(result);
+    }
+    async randomString(length) {
+        let res = '';
+        while (res.length < length) {
+            const next = Math.random().toString(36).slice(2, 3);
+            if (res.length === 0 &&
+                Number.isInteger(Number.parseInt(next, 10))) {
+                continue;
+            }
+            res += next;
+        }
+        return res;
+    }
+    randomUUID() {
+        return crypto.randomUUID();
+    }
+    async scrypt() {
+        throw new Error('Not available on this platform');
+    }
+};
+WebCryptoManager = __decorate([
+    injectable()
+], WebCryptoManager);
+export { WebCryptoManager };

package/dist/esm/std/impl/WebFSManager.d.ts

@@ -0,0 +1,18 @@
+import type { DirPath, File, FileExtension, FileName, FilePath } from '../../dt/index.js';
+import type { FSManager, FSManagerCatOpts, FSManagerChmodMode, FSManagerFilePickerOpts, FSManagerFilePickerSource, FSManagerItemInfo, FSManagerLsItem, FSManagerLsOpts, FSManagerMkdirOpts, Pathname } from '../FSManager.js';
+export declare class WebFSManager implements FSManager {
+    canHandleFiles(): Promise<boolean>;
+    cat<T extends string>(_path: FilePath, _opts?: FSManagerCatOpts): Promise<T>;
+    chmod(_path: Pathname, _mode: FSManagerChmodMode): Promise<void>;
+    cp(_src: Pathname, _dest: Pathname): Promise<void>;
+    echoIn<T extends string>(_src: FilePath, _content: T): Promise<void>;
+    exists(_path: Pathname): Promise<boolean>;
+    fileExtension(_fileName: FileName): FileExtension;
+    info(_path: Pathname): Promise<FSManagerItemInfo>;
+    ls(_path: DirPath, _opts?: FSManagerLsOpts): Promise<FSManagerLsItem[]>;
+    mkdir(_path: DirPath, _opts?: FSManagerMkdirOpts): Promise<void>;
+    path(..._parts: Pathname[]): Pathname;
+    pickFiles(_source: FSManagerFilePickerSource, _opts?: FSManagerFilePickerOpts): Promise<File[]>;
+    rm(_path: Pathname): Promise<void>;
+    touch<T extends string>(_path: FilePath, _content: T): Promise<void>;
+}

package/dist/esm/std/impl/WebFSManager.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;
+};
+import { injectable } from 'inversify';
+let WebFSManager = class WebFSManager {
+    async canHandleFiles() {
+        return true;
+    }
+    async cat(_path, _opts) {
+        throw new Error('Not available on this platform');
+    }
+    async chmod(_path, _mode) {
+        throw new Error('Not available on this platform');
+    }
+    async cp(_src, _dest) {
+        throw new Error('Not available on this platform');
+    }
+    async echoIn(_src, _content) {
+        throw new Error('Not available on this platform');
+    }
+    async exists(_path) {
+        throw new Error('Not available on this platform');
+    }
+    fileExtension(_fileName) {
+        throw new Error('Not available on this platform');
+    }
+    async info(_path) {
+        throw new Error('Not available on this platform');
+    }
+    async ls(_path, _opts) {
+        throw new Error('Not available on this platform');
+    }
+    async mkdir(_path, _opts) {
+        throw new Error('Not available on this platform');
+    }
+    path(..._parts) {
+        throw new Error('Not available on this platform');
+    }
+    async pickFiles(_source, _opts) {
+        throw new Error('Not available on this platform');
+    }
+    async rm(_path) {
+        throw new Error('Not available on this platform');
+    }
+    async touch(_path, _content) {
+        throw new Error('Not available on this platform');
+    }
+};
+WebFSManager = __decorate([
+    injectable()
+], WebFSManager);
+export { WebFSManager };

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

@@ -0,0 +1,20 @@
+export * from './consts.js';
+export * from './BufferManager.js';
+export * from './ClockManager.js';
+export * from './CryptoManager.js';
+export * from './EmailManager.js';
+export * from './EnvironmentManager.js';
+export * from './ExternalResourceInstaller.js';
+export * from './ExternalResourceManager.js';
+export * from './FSManager.js';
+export * from './FormDataBuilder.js';
+export * from './HTTPAPICaller.js';
+export * from './HTTPAPICallExecutor.js';
+export * from './I18nManager.js';
+export * from './JobManager.js';
+export * from './JWTManager.js';
+export * from './Logger.js';
+export * from './PromptManager.js';
+export * from './SettingsManager.js';
+export * from './Worker.js';
+export * from './XMLManager.js';

package/dist/esm/std/index.js

@@ -0,0 +1,20 @@
+export * from './consts.js';
+export * from './BufferManager.js';
+export * from './ClockManager.js';
+export * from './CryptoManager.js';
+export * from './EmailManager.js';
+export * from './EnvironmentManager.js';
+export * from './ExternalResourceInstaller.js';
+export * from './ExternalResourceManager.js';
+export * from './FSManager.js';
+export * from './FormDataBuilder.js';
+export * from './HTTPAPICaller.js';
+export * from './HTTPAPICallExecutor.js';
+export * from './I18nManager.js';
+export * from './JobManager.js';
+export * from './JWTManager.js';
+export * from './Logger.js';
+export * from './PromptManager.js';
+export * from './SettingsManager.js';
+export * from './Worker.js';
+export * from './XMLManager.js';

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

@@ -0,0 +1,6 @@
+import type { AppUCsLoaderInput } from '../../../app/index.js';
+export type Input = Pick<AppUCsLoaderInput, 'appsRootPath' | 'srcImporter'>;
+export type Output = void;
+export interface CLIManager {
+    handleCommand(input: Input): Promise<void>;
+}

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

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

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

@@ -0,0 +1,24 @@
+import type { SemVerVersion } from '../../../dt/index.js';
+import { WordingManager } from '../../../i18n/index.js';
+import { type FSManager, type I18nManager, type PromptManager, type Worker } from '../../../std/index.js';
+import { type UC, type UCInput, type UCManager, type UCOPIBase } from '../../../uc/index.js';
+interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    uc: UC<I, OPI0, OPI1>;
+}
+export declare class CommandExecutor implements Worker<Input, Promise<void>> {
+    private fsManager;
+    private i18nManager;
+    private promptManager;
+    private ucManager;
+    private wordingManager;
+    private static DEFAULT_VERSION;
+    private static VERSION_FILE_NAME;
+    private static VERSION_FETCH_MAX_TRIES;
+    private static VERSION_FETCH_START_PATH;
+    constructor(fsManager: FSManager, i18nManager: I18nManager, promptManager: PromptManager, ucManager: UCManager, wordingManager: WordingManager);
+    exec({ uc }: Input): Promise<void>;
+    fieldsForFlags(uc: UC): ReturnType<UC['inputFieldsInsensitive']>;
+    version(): Promise<SemVerVersion>;
+    private promptForSensitiveFields;
+}
+export {};