libmodulor 0.1.0 → 0.3.0

package/dist/esm/std/impl/NodeCryptoManager.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 crypto from 'node:crypto';
+import { promisify } from 'node:util';
+import { injectable } from 'inversify';
+const pbkdf2 = promisify(crypto.pbkdf2);
+const scrypt = promisify(crypto.scrypt);
+let NodeCryptoManager = class NodeCryptoManager {
+    async clear() {
+    }
+    hash(algorithm, base, binaryToTextEncoding) {
+        return crypto
+            .createHash(algorithm)
+            .update(base)
+            .digest(binaryToTextEncoding);
+    }
+    hmacToBase64(algorithm, base, key, keyEncoding) {
+        return crypto
+            .createHmac(algorithm, key, { encoding: keyEncoding })
+            .update(base)
+            .digest('base64');
+    }
+    hmacToHex(algorithm, base, key, keyEncoding) {
+        return crypto
+            .createHmac(algorithm, key, { encoding: keyEncoding })
+            .update(base)
+            .digest('hex');
+    }
+    async pbkdf2(password, salt, iterationsCount, keyLength, digest) {
+        const result = await pbkdf2(password, salt, iterationsCount, keyLength, digest);
+        return Uint8Array.from(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(password, salt, keyLength) {
+        const buffer = (await scrypt(password, salt, keyLength));
+        return buffer.toString('hex');
+    }
+};
+NodeCryptoManager = __decorate([
+    injectable()
+], NodeCryptoManager);
+export { NodeCryptoManager };

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

@@ -0,0 +1,10 @@
+import type { UIntQuantity, UUID } from '../../dt/index.js';
+import type { CryptoManagerRandomString } from '../CryptoManager.js';
+import { NodeCryptoManager } from './NodeCryptoManager.js';
+export declare class NodeDeterministicCryptoManager extends NodeCryptoManager {
+    private randomStringIdx;
+    private uuidIdx;
+    clear(): Promise<void>;
+    randomString(length: UIntQuantity): Promise<CryptoManagerRandomString>;
+    randomUUID(): UUID;
+}

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

@@ -0,0 +1,59 @@
+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 { createHash } from 'node:crypto';
+import { injectable } from 'inversify';
+import { NodeCryptoManager } from './NodeCryptoManager.js';
+let NodeDeterministicCryptoManager = class NodeDeterministicCryptoManager extends NodeCryptoManager {
+    randomStringIdx = 0;
+    uuidIdx = 0;
+    async clear() {
+        await super.clear();
+        this.randomStringIdx = 0;
+        this.uuidIdx = 0;
+    }
+    async randomString(length) {
+        this.randomStringIdx += 1;
+        let res = '';
+        while (res.length < length) {
+            const hash = this.hash('sha512', this.randomStringIdx.toString(), 'hex');
+            res = `${res}${hash}`;
+        }
+        if (res.length > length) {
+            res = res.substring(0, length + 1);
+        }
+        return res;
+    }
+    randomUUID() {
+        this.uuidIdx += 1;
+        const hash = createHash('sha1').update(this.uuidIdx.toString());
+        const hashBytes = hash.digest().subarray(0, 16);
+        const bytes = Array.from(hashBytes);
+        if (bytes[6] !== undefined) {
+            bytes[6] = (bytes[6] & 0x0f) | 0x40;
+        }
+        if (bytes[8] !== undefined) {
+            bytes[8] = (bytes[8] & 0x3f) | 0x80;
+        }
+        const raw = bytes
+            .map((byte) => {
+            return (byte + 0x1_00).toString(16).substring(1);
+        })
+            .join('');
+        const uuid = [
+            raw.substring(0, 8),
+            raw.substring(8, 12),
+            raw.substring(12, 16),
+            raw.substring(16, 20),
+            raw.substring(20, 32),
+        ].join('-');
+        return uuid;
+    }
+};
+NodeDeterministicCryptoManager = __decorate([
+    injectable()
+], NodeDeterministicCryptoManager);
+export { NodeDeterministicCryptoManager };

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

@@ -0,0 +1,9 @@
+import type { FilePath } from '../../dt/index.js';
+import type { EnvironmentManager, EnvironmentManagerEnvVarName, EnvironmentManagerType } from '../EnvironmentManager.js';
+export declare class NodeEnvironmentManager implements EnvironmentManager {
+    cwd(): FilePath;
+    env(name: EnvironmentManagerEnvVarName): string | undefined;
+    home(): FilePath;
+    isProd(): boolean;
+    type(): EnvironmentManagerType;
+}

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

@@ -0,0 +1,29 @@
+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 { homedir, type } from 'node:os';
+import { injectable } from 'inversify';
+let NodeEnvironmentManager = class NodeEnvironmentManager {
+    cwd() {
+        return process.cwd();
+    }
+    env(name) {
+        return process.env[name];
+    }
+    home() {
+        return homedir();
+    }
+    isProd() {
+        return process.env['NODE_ENV'] === 'production';
+    }
+    type() {
+        return type().toLowerCase();
+    }
+};
+NodeEnvironmentManager = __decorate([
+    injectable()
+], NodeEnvironmentManager);
+export { NodeEnvironmentManager };

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

@@ -0,0 +1,19 @@
+import type { DirPath, File, FileExtension, FileName, FilePath } from '../../dt/index.js';
+import { type FSManager, type FSManagerCatOpts, type FSManagerChmodMode, type FSManagerFilePickerOpts, type FSManagerFilePickerSource, type FSManagerItemInfo, type FSManagerLsItem, type FSManagerLsOpts, type FSManagerMkdirOpts, type Pathname } from '../FSManager.js';
+export declare class NodeFSManager 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>;
+    private determineType;
+}

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

@@ -0,0 +1,126 @@
+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 { appendFile, chmod, cp, mkdir, readFile, readdir, rm, stat, writeFile, } from 'node:fs/promises';
+import { extname, join, parse } from 'node:path';
+import { injectable } from 'inversify';
+import { FSManagerItemInfoType, } from '../FSManager.js';
+let NodeFSManager = class NodeFSManager {
+    async canHandleFiles() {
+        return true;
+    }
+    async cat(path, opts) {
+        return readFile(path, opts?.encoding ?? 'utf8');
+    }
+    async chmod(path, mode) {
+        return chmod(path, mode);
+    }
+    async cp(src, dest) {
+        await cp(src, dest, { recursive: true });
+    }
+    async echoIn(src, content) {
+        await appendFile(src, content);
+    }
+    async exists(path) {
+        try {
+            await stat(path);
+            return true;
+        }
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+            return false;
+        }
+    }
+    fileExtension(fileName) {
+        return extname(fileName)
+            .replace('.', '')
+            .toLowerCase();
+    }
+    async info(path) {
+        const parsedPath = parse(path);
+        const stats = await stat(path);
+        const { birthtime, size } = stats;
+        const mimeType = null;
+        const type = this.determineType(stats);
+        return {
+            ...parsedPath,
+            birthtime: birthtime.toISOString(),
+            mimeType,
+            size,
+            type,
+        };
+    }
+    async ls(path, opts) {
+        const items = await readdir(path, {
+            recursive: opts?.recursive,
+            withFileTypes: true,
+        });
+        return items.map((item) => ({
+            path: opts?.withFullPath
+                ? this.path(item.path, item.name)
+                : item.name,
+            type: this.determineType(item),
+        }));
+    }
+    async mkdir(path, opts) {
+        await mkdir(path, { recursive: opts?.recursive });
+    }
+    path(...parts) {
+        return join(...parts);
+    }
+    async pickFiles(source, opts) {
+        const validSources = ['path'];
+        if (!validSources.includes(source)) {
+            throw new Error(`You cannot pick a file via ${source}`);
+        }
+        const path = opts?.path;
+        if (!path) {
+            return [];
+        }
+        switch (source) {
+            case 'path': {
+                const { base: name, mimeType: type } = await this.info(path);
+                if (!type) {
+                    return [];
+                }
+                return [
+                    {
+                        name,
+                        path,
+                        type,
+                    },
+                ];
+            }
+            case 'camera':
+            case 'library':
+                return [];
+            default:
+                ((_) => { })(source);
+                return [];
+        }
+    }
+    async rm(path) {
+        await rm(path, { recursive: true });
+    }
+    async touch(path, content) {
+        await writeFile(path, content);
+    }
+    determineType(stats) {
+        if (stats.isDirectory()) {
+            return FSManagerItemInfoType.DIR;
+        }
+        if (stats.isFile()) {
+            return FSManagerItemInfoType.FILE;
+        }
+        return FSManagerItemInfoType.OTHER;
+    }
+};
+NodeFSManager = __decorate([
+    injectable()
+], NodeFSManager);
+export { NodeFSManager };

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

@@ -0,0 +1,4 @@
+import type { FormDataBuilder, FormDataBuilderVal } from '../FormDataBuilder.js';
+export declare class NodeFormDataBuilder implements FormDataBuilder {
+    append(fd: FormData, key: string, val: FormDataBuilderVal): Promise<void>;
+}

package/dist/esm/std/impl/NodeFormDataBuilder.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;
+};
+import { Blob } from 'node:buffer';
+import { createReadStream } from 'node:fs';
+import { basename } from 'node:path';
+import { injectable } from 'inversify';
+let NodeFormDataBuilder = class NodeFormDataBuilder {
+    async append(fd, key, val) {
+        const isFile = typeof val === 'object' && val !== null && 'uri' in val;
+        if (isFile) {
+            const rs = createReadStream(val.uri);
+            const chunks = [];
+            await new Promise((resolve, reject) => {
+                rs.on('data', (chunk) => {
+                    chunks.push(chunk);
+                });
+                rs.on('end', () => {
+                    fd.append(key, new Blob(chunks, { type: val.type }), basename(val.uri));
+                    resolve(null);
+                });
+                rs.on('error', (err) => {
+                    reject(err);
+                });
+            });
+            return;
+        }
+        fd.append(key, val);
+    }
+};
+NodeFormDataBuilder = __decorate([
+    injectable()
+], NodeFormDataBuilder);
+export { NodeFormDataBuilder };

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

@@ -0,0 +1,7 @@
+import type { EnvironmentManager } from '../EnvironmentManager.js';
+import type { HTTPAPICallExecutorAgentBuilder, HTTPAPICallExecutorAgentBuilderInput, HTTPAPICallExecutorAgentBuilderOutput } from '../HTTPAPICallExecutor.js';
+export declare class NodeHTTPAPICallExecutorAgentBuilder implements HTTPAPICallExecutorAgentBuilder {
+    private environmentManager;
+    constructor(environmentManager: EnvironmentManager);
+    exec({ url, }: HTTPAPICallExecutorAgentBuilderInput): HTTPAPICallExecutorAgentBuilderOutput;
+}

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

@@ -0,0 +1,35 @@
+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 http from 'node:http';
+import https from 'node:https';
+import { inject, injectable } from 'inversify';
+let NodeHTTPAPICallExecutorAgentBuilder = class NodeHTTPAPICallExecutorAgentBuilder {
+    environmentManager;
+    constructor(environmentManager) {
+        this.environmentManager = environmentManager;
+    }
+    exec({ url, }) {
+        if (url.protocol.startsWith('https')) {
+            return new https.Agent({
+                rejectUnauthorized: this.environmentManager.isProd(),
+            });
+        }
+        return new http.Agent();
+    }
+};
+NodeHTTPAPICallExecutorAgentBuilder = __decorate([
+    injectable(),
+    __param(0, inject('EnvironmentManager')),
+    __metadata("design:paramtypes", [Object])
+], NodeHTTPAPICallExecutorAgentBuilder);
+export { NodeHTTPAPICallExecutorAgentBuilder };

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

@@ -0,0 +1,4 @@
+import type { PromptManager, PromptManagerPromptOpts } from '../PromptManager.js';
+export declare class NodePromptManager implements PromptManager {
+    prompt<T extends string>(invite: string, opts?: PromptManagerPromptOpts<T>): Promise<T>;
+}

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

@@ -0,0 +1,34 @@
+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 { stdin, stdout } from 'node:process';
+import { createInterface } from 'node:readline/promises';
+import { injectable } from 'inversify';
+let NodePromptManager = class NodePromptManager {
+    async prompt(invite, opts) {
+        const readLine = createInterface({
+            input: stdin,
+            output: stdout,
+        });
+        readLine.on('SIGINT', () => {
+            readLine.close();
+            process.exit(0);
+        });
+        const message = `${invite} : `;
+        let res = '';
+        let isValid = false;
+        while (!isValid) {
+            res = await readLine.question(message);
+            isValid = opts?.validate ? await opts.validate(res) : true;
+        }
+        readLine.close();
+        return res;
+    }
+};
+NodePromptManager = __decorate([
+    injectable()
+], NodePromptManager);
+export { NodePromptManager };

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

@@ -0,0 +1,4 @@
+import type { HTTPAPICallExecutorAgentBuilder, HTTPAPICallExecutorAgentBuilderInput, HTTPAPICallExecutorAgentBuilderOutput } from '../HTTPAPICallExecutor.js';
+export declare class NoopHTTPAPICallExecutorAgentBuilder implements HTTPAPICallExecutorAgentBuilder {
+    exec(_input: HTTPAPICallExecutorAgentBuilderInput): HTTPAPICallExecutorAgentBuilderOutput;
+}

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

@@ -0,0 +1,16 @@
+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 NoopHTTPAPICallExecutorAgentBuilder = class NoopHTTPAPICallExecutorAgentBuilder {
+    exec(_input) {
+        return undefined;
+    }
+};
+NoopHTTPAPICallExecutorAgentBuilder = __decorate([
+    injectable()
+], NoopHTTPAPICallExecutorAgentBuilder);
+export { NoopHTTPAPICallExecutorAgentBuilder };

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

@@ -0,0 +1,4 @@
+import type { XMLManager, XMLManagerParseOpts, XMLManagerRawXML } from '../XMLManager.js';
+export declare class NoopXMLManager implements XMLManager {
+    parse<T>(_xml: XMLManagerRawXML, _opts?: XMLManagerParseOpts): Promise<T>;
+}

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

@@ -0,0 +1,16 @@
+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 NoopXMLManager = class NoopXMLManager {
+    async parse(_xml, _opts) {
+        return {};
+    }
+};
+NoopXMLManager = __decorate([
+    injectable()
+], NoopXMLManager);
+export { NoopXMLManager };

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

@@ -0,0 +1,16 @@
+import type { ApiKey, JWT, URL } from '../../dt/index.js';
+import type { ServerClientManager, ServerClientManagerOpts, ServerClientManagerSettings } from '../../target/lib/client/ServerClientManager.js';
+import type { HTTPAPICallerBasicAuth } from '../HTTPAPICaller.js';
+import type { Configurable, SettingsManager } from '../SettingsManager.js';
+type S = ServerClientManagerSettings;
+export declare class SettingsServerClientManager implements Configurable<S>, ServerClientManager {
+    private settingsManager;
+    constructor(settingsManager: SettingsManager<S>);
+    s(): S;
+    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>;
+}
+export {};

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

@@ -0,0 +1,59 @@
+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 SettingsServerClientManager = class SettingsServerClientManager {
+    settingsManager;
+    constructor(settingsManager) {
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            server_dangerously_set_api_key: this.settingsManager.get()('server_dangerously_set_api_key'),
+            server_dangerously_set_basic: this.settingsManager.get()('server_dangerously_set_basic'),
+            server_dangerously_set_jwts: this.settingsManager.get()('server_dangerously_set_jwts'),
+            server_public_api_key: this.settingsManager.get()('server_public_api_key'),
+            server_public_api_key_header_name: this.settingsManager.get()('server_public_api_key_header_name'),
+            server_public_url: this.settingsManager.get()('server_public_url'),
+        };
+    }
+    async authApiKey(_opts) {
+        return this.s().server_dangerously_set_api_key ?? null;
+    }
+    async authBasic(_opts) {
+        return this.s().server_dangerously_set_basic ?? null;
+    }
+    async authJWT(opts) {
+        let jwt = null;
+        if (opts?.auth) {
+            jwt =
+                this.s().server_dangerously_set_jwts?.[opts.auth.role] ?? null;
+        }
+        return jwt;
+    }
+    async baseURL(_opts) {
+        const url = this.s().server_public_url;
+        if (!url) {
+            throw new Error('You need to set the server public url');
+        }
+        return url;
+    }
+    async publicApiKey(_opts) {
+        return this.s().server_public_api_key;
+    }
+};
+SettingsServerClientManager = __decorate([
+    injectable(),
+    __param(0, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object])
+], SettingsServerClientManager);
+export { SettingsServerClientManager };

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

@@ -0,0 +1,4 @@
+import type { FormDataBuilder, FormDataBuilderVal } from '../FormDataBuilder.js';
+export declare class SimpleFormDataBuilder implements FormDataBuilder {
+    append(fd: FormData, key: string, val: FormDataBuilderVal): Promise<void>;
+}

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

@@ -0,0 +1,16 @@
+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 SimpleFormDataBuilder = class SimpleFormDataBuilder {
+    async append(fd, key, val) {
+        fd.append(key, val);
+    }
+};
+SimpleFormDataBuilder = __decorate([
+    injectable()
+], SimpleFormDataBuilder);
+export { SimpleFormDataBuilder };

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

@@ -0,0 +1,19 @@
+import { HTTPRequestBuilder } from '../../utils/index.js';
+import type { BufferManager } from '../BufferManager.js';
+import type { HTTPAPICallExecutor, HTTPAPICallExecutorAgentBuilder } from '../HTTPAPICallExecutor.js';
+import type { HTTPAPICaller, HTTPAPICallerInput } from '../HTTPAPICaller.js';
+import type { Logger } from '../Logger.js';
+import type { XMLManager } from '../XMLManager.js';
+export declare class SimpleHTTPAPICaller implements HTTPAPICaller {
+    private bufferManager;
+    private httpAPICallExecutor;
+    private httpAPICallExecutorAgentBuilder;
+    private httpRequestBuilder;
+    private logger;
+    private xmlManager;
+    constructor(bufferManager: BufferManager, httpAPICallExecutor: HTTPAPICallExecutor, httpAPICallExecutorAgentBuilder: HTTPAPICallExecutorAgentBuilder, httpRequestBuilder: HTTPRequestBuilder, logger: Logger, xmlManager: XMLManager);
+    exec<AH extends object | undefined, Req extends object, ResBad, ResGood, O>({ additionalHeadersBuilder, authorizationHeader, basicAuth, contentType, errBuilder, method, opts, outputBuilder, req, urlBuilder, unknownErrorMessage, }: HTTPAPICallerInput<AH, Req, ResBad, ResGood, O>): Promise<O>;
+    private computeHeaders;
+    private processResBad;
+    private processResGood;
+}