libmodulor 0.1.0 → 0.3.0

package/dist/esm/uc/workers/SimpleAggregateOwnershipChecker.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;
+};
+import { injectable } from 'inversify';
+import { ForbiddenAsNotFoundError } from '../../error/index.js';
+let SimpleAggregateOwnershipChecker = class SimpleAggregateOwnershipChecker {
+    async exec({ record, scope = ['organization', 'user'], uc, }) {
+        const { auth } = uc;
+        if (this.checkOrg(scope)) {
+            const organizationId = auth?.organization.id;
+            if (!organizationId || record.organizationId !== organizationId) {
+                throw new ForbiddenAsNotFoundError();
+            }
+        }
+        if (this.checkUser(scope)) {
+            const userId = auth?.user.id;
+            if (!userId || record.userId !== userId) {
+                throw new ForbiddenAsNotFoundError();
+            }
+        }
+    }
+    checkOrg(scope) {
+        return scope === undefined || scope.includes('organization');
+    }
+    checkUser(scope) {
+        return scope === undefined || scope.includes('user');
+    }
+};
+SimpleAggregateOwnershipChecker = __decorate([
+    injectable()
+], SimpleAggregateOwnershipChecker);
+export { SimpleAggregateOwnershipChecker };

package/dist/esm/uc/workers/UCBuilder.d.ts

@@ -0,0 +1,10 @@
+import type { Worker } from '../../std/index.js';
+import { type ArgsRecord, UC } from '../UC.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+type Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = ArgsRecord<I, OPI0, OPI1>;
+type Output<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> = UC<I, OPI0, OPI1>;
+export declare class UCBuilder implements Worker<Input, Output> {
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ appManifest, auth, def }: Input<I, OPI0, OPI1>): Output<I, OPI0, OPI1>;
+}
+export {};

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

@@ -0,0 +1,17 @@
+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';
+import { UC } from '../UC.js';
+let UCBuilder = class UCBuilder {
+    exec({ appManifest, auth, def }) {
+        return new UC(appManifest, def, auth);
+    }
+};
+UCBuilder = __decorate([
+    injectable()
+], UCBuilder);
+export { UCBuilder };

package/dist/esm/uc/workers/UCExecChecker.d.ts

@@ -0,0 +1,24 @@
+import { type interfaces } from 'inversify';
+import type { ProductManifest } from '../../product/index.js';
+import type { Configurable, SettingsManager, Worker } from '../../std/index.js';
+import type { UC } from '../UC.js';
+import type { UCDefLifecycle } from '../def.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCPolicy, UCPolicyOutput } from '../policy.js';
+import type { UCSettings } from '../settings.js';
+interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    lifecycle: UCDefLifecycle;
+    uc: UC<I, OPI0, OPI1>;
+}
+type Output = UCPolicyOutput;
+type S = Pick<UCSettings, 'uc_disabled_use_cases'>;
+export declare class UCExecChecker implements Configurable<S>, Worker<Input, Promise<Output>> {
+    private productManifest;
+    private settingsManager;
+    private ucPolicyProvider;
+    constructor(productManifest: ProductManifest, settingsManager: SettingsManager<S>, ucPolicyProvider: interfaces.Provider<UCPolicy>);
+    s(): S;
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ lifecycle, uc }: Input<I, OPI0, OPI1>): Promise<Output>;
+}
+export {};

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

@@ -0,0 +1,72 @@
+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 UCExecChecker = class UCExecChecker {
+    productManifest;
+    settingsManager;
+    ucPolicyProvider;
+    constructor(productManifest, settingsManager, ucPolicyProvider) {
+        this.productManifest = productManifest;
+        this.settingsManager = settingsManager;
+        this.ucPolicyProvider = ucPolicyProvider;
+    }
+    s() {
+        return {
+            uc_disabled_use_cases: this.settingsManager.get()('uc_disabled_use_cases'),
+        };
+    }
+    async exec({ lifecycle, uc }) {
+        const output = {
+            allowed: false,
+        };
+        const { lifecycle: { client, server }, metadata, } = uc.def;
+        const disabled = this.s().uc_disabled_use_cases.includes(metadata.name);
+        if (disabled) {
+            return output;
+        }
+        switch (lifecycle) {
+            case 'client': {
+                if (!client) {
+                    return output;
+                }
+                const { appManifest } = uc;
+                const app = this.productManifest.appReg.find((app) => appManifest.name === app.name);
+                if (!app) {
+                    throw new Error(`Could not find app named ${appManifest.name}`);
+                }
+                const ucds = app.ucds?.exclude ?? [];
+                output.allowed = !ucds.includes(metadata.name);
+                if (output.allowed) {
+                    const policy = (await this.ucPolicyProvider(client.policy));
+                    const { allowed } = await policy.exec({ uc });
+                    output.allowed = allowed;
+                }
+                break;
+            }
+            case 'server':
+                output.allowed = typeof server === 'object';
+                break;
+            default:
+                ((_) => { })(lifecycle);
+        }
+        return output;
+    }
+};
+UCExecChecker = __decorate([
+    injectable(),
+    __param(0, inject('ProductManifest')),
+    __param(1, inject('SettingsManager')),
+    __param(2, inject('Provider<UCPolicy>')),
+    __metadata("design:paramtypes", [Object, Object, Function])
+], UCExecChecker);
+export { UCExecChecker };

package/dist/esm/uc/workers/UCInputFilesProcessor.d.ts

@@ -0,0 +1,20 @@
+import type { ClockManager, Configurable, CryptoManager, FSManager, SettingsManager, Worker } from '../../std/index.js';
+import type { UC } from '../UC.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.js';
+import type { UCSettings } from '../settings.js';
+interface Input<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined> {
+    uc: UC<I, OPI0, OPI1>;
+}
+type S = Pick<UCSettings, 'uc_file_ref_prefix' | 'uc_files_directory_path'>;
+export declare class UCInputFilesProcessor implements Configurable<S>, Worker<Input, Promise<void>> {
+    private clockManager;
+    private cryptoManager;
+    private fsManager;
+    private settingsManager;
+    constructor(clockManager: ClockManager, cryptoManager: CryptoManager, fsManager: FSManager, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ uc }: Input<I, OPI0, OPI1>): Promise<void>;
+    private processFile;
+}
+export {};

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

@@ -0,0 +1,75 @@
+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 { TFile } from '../../dt/index.js';
+import { UCInputFieldChangeOperator, ucifRepeatability, } from '../input-field.js';
+import { rVal0, rValArr } from '../utils/rVal.js';
+let UCInputFilesProcessor = class UCInputFilesProcessor {
+    clockManager;
+    cryptoManager;
+    fsManager;
+    settingsManager;
+    constructor(clockManager, cryptoManager, fsManager, settingsManager) {
+        this.clockManager = clockManager;
+        this.cryptoManager = cryptoManager;
+        this.fsManager = fsManager;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            uc_file_ref_prefix: this.settingsManager.get()('uc_file_ref_prefix'),
+            uc_files_directory_path: this.settingsManager.get()('uc_files_directory_path'),
+        };
+    }
+    async exec({ uc }) {
+        const canHandleFiles = await this.fsManager.canHandleFiles();
+        if (!canHandleFiles) {
+            return;
+        }
+        const fileFields = uc.inputFields.filter((f) => f.def.type instanceof TFile);
+        for await (const field of fileFields) {
+            const [isRepeatable] = ucifRepeatability(field.def);
+            if (isRepeatable) {
+                const files = rValArr(field.getValue());
+                const fileNameRefs = await Promise.all(files.map(async (f) => this.processFile(f)));
+                field.setValue(UCInputFieldChangeOperator.SET, fileNameRefs);
+            }
+            else {
+                const file = rVal0(field.getValue());
+                if (file) {
+                    const fileNameRef = await this.processFile(file);
+                    field.setValue(UCInputFieldChangeOperator.SET, fileNameRef);
+                }
+            }
+        }
+    }
+    async processFile(file) {
+        const extension = this.fsManager.fileExtension(file.name);
+        const prefix = this.clockManager.nowToKey();
+        const fileName = `${prefix}-${this.cryptoManager.randomUUID()}.${extension}`;
+        const fileNameRef = `${this.s().uc_file_ref_prefix}${fileName}`;
+        const path = file instanceof File ? file.name : file.path;
+        await this.fsManager.cp(path, this.fsManager.path(this.s().uc_files_directory_path, fileName));
+        await this.fsManager.rm(path);
+        return fileNameRef;
+    }
+};
+UCInputFilesProcessor = __decorate([
+    injectable(),
+    __param(0, inject('ClockManager')),
+    __param(1, inject('CryptoManager')),
+    __param(2, inject('FSManager')),
+    __param(3, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object, Object, Object])
+], UCInputFilesProcessor);
+export { UCInputFilesProcessor };

package/dist/esm/uc/workers/UCInputValidator.d.ts

@@ -0,0 +1,15 @@
+import { WordingManager } from '../../i18n/index.js';
+import type { I18nManager, Worker } from '../../std/index.js';
+import type { UC } from '../UC.js';
+import type { UCInput } from '../input.js';
+import type { UCOPIBase } from '../opi.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 UCInputValidator implements Worker<Input, void> {
+    private i18nManager;
+    private wordingManager;
+    constructor(i18nManager: I18nManager, wordingManager: WordingManager);
+    exec<I extends UCInput | undefined = undefined, OPI0 extends UCOPIBase | undefined = undefined, OPI1 extends UCOPIBase | undefined = undefined>({ uc }: Input<I, OPI0, OPI1>): void;
+}
+export {};

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

@@ -0,0 +1,48 @@
+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 { IllegalArgumentError } from '../../error/index.js';
+import { WordingManager } from '../../i18n/index.js';
+let UCInputValidator = class UCInputValidator {
+    i18nManager;
+    wordingManager;
+    constructor(i18nManager, wordingManager) {
+        this.i18nManager = i18nManager;
+        this.wordingManager = wordingManager;
+    }
+    exec({ uc }) {
+        const res = uc.validate();
+        if (!res) {
+            return;
+        }
+        const [field, validation] = res;
+        const violation = validation.get();
+        if (!violation) {
+            return;
+        }
+        const [key, expected] = violation;
+        let message = this.i18nManager.t(key, { vars: { expected } });
+        if (field) {
+            const { label } = this.wordingManager.ucif(field);
+            message = `${label} ${message ? message.toLowerCase() : ''}`.trim();
+        }
+        throw new IllegalArgumentError(message);
+    }
+};
+UCInputValidator = __decorate([
+    injectable(),
+    __param(0, inject('I18nManager')),
+    __param(1, inject(WordingManager)),
+    __metadata("design:paramtypes", [Object, WordingManager])
+], UCInputValidator);
+export { UCInputValidator };

package/dist/esm/uc/workers/UCOutputFilesProcessor.d.ts

@@ -0,0 +1,20 @@
+import type { File, FilePath } from '../../dt/index.js';
+import type { Configurable, FSManager, SettingsManager, Worker } from '../../std/index.js';
+import type { UCInputFieldValue } from '../input-field.js';
+import type { UCSettings } from '../settings.js';
+interface Input {
+    files: UCInputFieldValue<File>;
+    keepOnlyFileName: boolean;
+}
+interface Output {
+    filePaths: FilePath[];
+}
+type S = Pick<UCSettings, 'uc_file_ref_prefix' | 'uc_files_directory_path'>;
+export declare class UCOutputFilesProcessor implements Configurable<S>, Worker<Input, Promise<Output>> {
+    private fsManager;
+    private settingsManager;
+    constructor(fsManager: FSManager, settingsManager: SettingsManager<S>);
+    s(): S;
+    exec({ files, keepOnlyFileName }: Input): Promise<Output>;
+}
+export {};

package/dist/esm/uc/workers/UCOutputFilesProcessor.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;
+};
+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 { rValArr } from '../utils/rVal.js';
+let UCOutputFilesProcessor = class UCOutputFilesProcessor {
+    fsManager;
+    settingsManager;
+    constructor(fsManager, settingsManager) {
+        this.fsManager = fsManager;
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            uc_file_ref_prefix: this.settingsManager.get()('uc_file_ref_prefix'),
+            uc_files_directory_path: this.settingsManager.get()('uc_files_directory_path'),
+        };
+    }
+    async exec({ files, keepOnlyFileName }) {
+        const output = {
+            filePaths: [],
+        };
+        if (!files) {
+            return output;
+        }
+        const fileNameRefs = rValArr(files);
+        output.filePaths = await Promise.all(fileNameRefs.map(async (fileNameRef) => {
+            let filePath;
+            if (typeof fileNameRef === 'string') {
+                const fileName = fileNameRef.replace(this.s().uc_file_ref_prefix, '');
+                filePath = this.fsManager.path(this.s().uc_files_directory_path, fileName);
+            }
+            else {
+                filePath = fileNameRef.path;
+            }
+            if (keepOnlyFileName) {
+                const { base } = await this.fsManager.info(filePath);
+                return `/${base}`;
+            }
+            return filePath;
+        }));
+        return output;
+    }
+};
+UCOutputFilesProcessor = __decorate([
+    injectable(),
+    __param(0, inject('FSManager')),
+    __param(1, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object, Object])
+], UCOutputFilesProcessor);
+export { UCOutputFilesProcessor };

package/dist/esm/utils/async/sleep.d.ts

@@ -0,0 +1,2 @@
+import type { UIntDuration } from '../../dt/index.js';
+export declare function sleep(durationInMs: UIntDuration): Promise<void>;

package/dist/esm/utils/async/sleep.js

@@ -0,0 +1,7 @@
+export function sleep(durationInMs) {
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, durationInMs);
+    });
+}

package/dist/esm/utils/concerns/Clearable.d.ts

@@ -0,0 +1,3 @@
+export interface Clearable {
+    clear(): Promise<void>;
+}

package/dist/esm/utils/concerns/Clearable.js

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

package/dist/esm/utils/concerns/Initializable.d.ts

@@ -0,0 +1,3 @@
+export interface Initializable {
+    init(): Promise<void>;
+}

package/dist/esm/utils/concerns/Initializable.js

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

package/dist/esm/utils/esm/srcImporter.d.ts

@@ -0,0 +1,2 @@
+import type { FilePath } from '../../dt/index.js';
+export type SrcImporter<T extends object = object> = (path: FilePath) => Promise<T>;

package/dist/esm/utils/esm/srcImporter.js

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

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

@@ -0,0 +1,17 @@
+import type { URL as URLString } from '../../dt/index.js';
+import type { FormDataBuilder, Worker } from '../../std/index.js';
+import type { HTTPDataEnvelope, HTTPReqData } from './types.js';
+export interface Input {
+    baseURL: URLString;
+    data: HTTPReqData;
+    envelope: HTTPDataEnvelope;
+}
+export interface Output {
+    body: BodyInit | null;
+    url: URLString;
+}
+export declare class HTTPRequestBuilder implements Worker<Input, Promise<Output>> {
+    private formDataBuilder;
+    constructor(formDataBuilder: FormDataBuilder);
+    exec({ baseURL, data, envelope }: Input): Promise<Output>;
+}

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

@@ -0,0 +1,55 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { inject, injectable } from 'inversify';
+import { toFormData } from './toFormData.js';
+import { toJSON } from './toJSON.js';
+import { toQueryParams } from './toQueryParams.js';
+let HTTPRequestBuilder = class HTTPRequestBuilder {
+    formDataBuilder;
+    constructor(formDataBuilder) {
+        this.formDataBuilder = formDataBuilder;
+    }
+    async exec({ baseURL, data, envelope }) {
+        const output = {
+            body: null,
+            url: baseURL,
+        };
+        switch (envelope) {
+            case 'form-data': {
+                const fd = new FormData();
+                await toFormData(data, fd, this.formDataBuilder);
+                output.body = fd;
+                break;
+            }
+            case 'json':
+                output.body = toJSON(data);
+                break;
+            case 'query-params': {
+                const url = new URL(baseURL);
+                await toQueryParams(data, url);
+                output.url = url.toString();
+                break;
+            }
+            default:
+                ((_) => { })(envelope);
+                return output;
+        }
+        return output;
+    }
+};
+HTTPRequestBuilder = __decorate([
+    injectable(),
+    __param(0, inject('FormDataBuilder')),
+    __metadata("design:paramtypes", [Object])
+], HTTPRequestBuilder);
+export { HTTPRequestBuilder };

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

@@ -0,0 +1,2 @@
+import type { HTTPReqData } from './types.js';
+export declare function appendData<T extends HTTPReqData>(data: T | undefined | null, func: (key: string, val: any) => Promise<void>): Promise<void>;

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

@@ -0,0 +1,14 @@
+export async function appendData(data, func) {
+    if (data === undefined || data === null) {
+        return;
+    }
+    for await (const key of Object.keys(data)) {
+        const value = data[key];
+        const isArray = Array.isArray(value);
+        const keyToSend = isArray ? `${key}[]` : key;
+        const valueToSend = isArray ? value : [value];
+        for await (const v of valueToSend) {
+            await func(keyToSend, v);
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+import type { FormDataBuilder } from '../../std/index.js';
+import type { HTTPReqData } from './types.js';
+export declare function toFormData<T extends HTTPReqData>(data: T | undefined | null, fd: FormData, formDataBuilder: FormDataBuilder): Promise<void>;

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

@@ -0,0 +1,4 @@
+import { appendData } from './appendData.js';
+export async function toFormData(data, fd, formDataBuilder) {
+    await appendData(data, (k, v) => formDataBuilder.append(fd, k, v));
+}

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

@@ -0,0 +1,3 @@
+import type { JSONString } from '../../dt/index.js';
+import type { HTTPReqData } from './types.js';
+export declare function toJSON<T extends HTTPReqData>(data: T | undefined | null): JSONString;

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

@@ -0,0 +1,3 @@
+export function toJSON(data) {
+    return JSON.stringify(data);
+}

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

@@ -0,0 +1,2 @@
+import type { HTTPReqData } from './types.js';
+export declare function toQueryParams<T extends HTTPReqData>(data: T | undefined | null, url: URL): Promise<void>;

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

@@ -0,0 +1,4 @@
+import { appendData } from './appendData.js';
+export async function toQueryParams(data, url) {
+    await appendData(data, async (k, v) => url.searchParams.append(k, v));
+}

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

@@ -0,0 +1,2 @@
+export type HTTPDataEnvelope = 'form-data' | 'json' | 'query-params';
+export type HTTPReqData = Record<string, unknown>;

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

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

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

@@ -0,0 +1,18 @@
+export { sleep } from './async/sleep.js';
+export type { Clearable } from './concerns/Clearable.js';
+export type { Initializable } from './concerns/Initializable.js';
+export type { SrcImporter } from './esm/srcImporter.js';
+export { HTTPRequestBuilder } from './http/HTTPRequestBuilder.js';
+export type { HTTPDataEnvelope, HTTPReqData } from './http/types.js';
+export { bindProvider } from './ioc/bindProvider.js';
+export { CONTAINER_OPTS } from './ioc/container.js';
+export { ContainerPrinter } from './ioc/ContainerPrinter.js';
+export type { Class } from './ioc/types.js';
+export { fmt as fmtNumber } from './numbers/fmt.js';
+export { type CoreUnit, type SquareUnit, type SquareableUnit, type Unit, baseFromSquareUnit, isSquareUnit, } from './numbers/units.js';
+export { capitalize, isCapitalized } from './strings/capitalize.js';
+export { humanize } from './strings/humanize.js';
+export { truncate } from './strings/truncate.js';
+export { fmtBold, fmtCommand, fmtPadEndFor, fmtSection, } from './terminal/fmt.js';
+export { assertIsDefined, isBlank, range, sample, tupleOf, } from './types/funcs.js';
+export type { ExtractStrict, RecursiveNonNullable, StringKeys, } from './types/utility-types.js';

package/dist/esm/utils/index.js

@@ -0,0 +1,12 @@
+export { sleep } from './async/sleep.js';
+export { HTTPRequestBuilder } from './http/HTTPRequestBuilder.js';
+export { bindProvider } from './ioc/bindProvider.js';
+export { CONTAINER_OPTS } from './ioc/container.js';
+export { ContainerPrinter } from './ioc/ContainerPrinter.js';
+export { fmt as fmtNumber } from './numbers/fmt.js';
+export { baseFromSquareUnit, isSquareUnit, } from './numbers/units.js';
+export { capitalize, isCapitalized } from './strings/capitalize.js';
+export { humanize } from './strings/humanize.js';
+export { truncate } from './strings/truncate.js';
+export { fmtBold, fmtCommand, fmtPadEndFor, fmtSection, } from './terminal/fmt.js';
+export { assertIsDefined, isBlank, range, sample, tupleOf, } from './types/funcs.js';

package/dist/esm/utils/ioc/ContainerPrinter.d.ts

@@ -0,0 +1,12 @@
+import { type Container } from 'inversify';
+import type { Logger, Worker } from '../../std/index.js';
+interface Input {
+    container: Container;
+}
+export declare class ContainerPrinter implements Worker<Input, Promise<void>> {
+    private logger;
+    constructor(logger: Logger);
+    exec({ container }: Input): Promise<void>;
+    private symToString;
+}
+export {};