libmodulor 0.1.0 → 0.3.0

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

@@ -0,0 +1,14 @@
+import type { FilePath } from '../dt/index.js';
+export type EnvironmentManagerEnvVarName = string;
+type Browser = 'chrome' | 'edge' | 'firefox' | 'opera' | 'safari';
+type MobileOS = 'android' | 'ios';
+type OS = 'darwin' | 'linux' | 'macos' | 'windows' | 'windows_nt';
+export type EnvironmentManagerType = Browser | MobileOS | OS | (string & {});
+export interface EnvironmentManager {
+    cwd(): FilePath;
+    env(name: EnvironmentManagerEnvVarName): string | undefined;
+    home(): FilePath;
+    isProd(): boolean;
+    type(): EnvironmentManagerType;
+}
+export {};

package/dist/esm/std/EnvironmentManager.js

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

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

@@ -0,0 +1,17 @@
+import type { ExternalResourceManager } from './ExternalResourceManager.js';
+import type { Worker } from './Worker.js';
+export interface ExternalResourceInstallerFeedback {
+    message: string;
+    mode: 'confirm' | 'done' | 'error' | 'prompt' | 'waiting';
+}
+export type ExternalResourceInstallerOnFeedback = (feedback: ExternalResourceInstallerFeedback) => Promise<void>;
+interface Input {
+    autoGenerate: boolean;
+    force: boolean;
+    manager: ExternalResourceManager;
+    onFeedback: ExternalResourceInstallerOnFeedback;
+}
+export declare class ExternalResourceInstaller implements Worker<Input, Promise<void>> {
+    exec({ autoGenerate, onFeedback, force, manager, }: Input): Promise<void>;
+}
+export {};

package/dist/esm/std/ExternalResourceInstaller.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 { injectable } from 'inversify';
+let ExternalResourceInstaller = class ExternalResourceInstaller {
+    async exec({ autoGenerate, onFeedback, force, manager, }) {
+        const name = manager.name();
+        await onFeedback({
+            message: `Checking ${name} presence`,
+            mode: 'waiting',
+        });
+        if (force && (await manager.exists())) {
+            await manager.delete();
+        }
+        if (await manager.exists()) {
+            await onFeedback({ message: name, mode: 'confirm' });
+        }
+        else {
+            await onFeedback({
+                message: `Creating ${name}`,
+                mode: 'waiting',
+            });
+            await manager.create(autoGenerate);
+            await onFeedback({
+                message: `Created ${name} successfully`,
+                mode: 'confirm',
+            });
+        }
+    }
+};
+ExternalResourceInstaller = __decorate([
+    injectable()
+], ExternalResourceInstaller);
+export { ExternalResourceInstaller };

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

@@ -0,0 +1,6 @@
+export interface ExternalResourceManager {
+    create(autoGenerate: boolean): Promise<void>;
+    delete(): Promise<void>;
+    exists(): Promise<boolean>;
+    name(): string;
+}

package/dist/esm/std/ExternalResourceManager.js

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

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

@@ -0,0 +1,55 @@
+import type { DateISO8601, DirPath, File, FileExtension, FileMimeType, FileName, FilePath, UIntQuantity } from '../dt/index.js';
+export type FSManagerChmodMode = number | string;
+export interface FSManagerCatOpts {
+    encoding?: FSManagerEncoding;
+}
+export type FSManagerEncoding = 'utf-8';
+export interface FSManagerFilePickerOpts {
+    max?: UIntQuantity;
+    path?: FilePath;
+}
+export type FSManagerFilePickerSource = 'camera' | 'library' | 'path';
+export declare enum FSManagerItemInfoType {
+    DIR = "DIR",
+    FILE = "FILE",
+    OTHER = "OTHER"
+}
+export interface FSManagerItemInfo {
+    base: string;
+    birthtime: DateISO8601;
+    dir: string;
+    ext: string;
+    mimeType: FileMimeType | null;
+    name: string;
+    root: string;
+    size: UIntQuantity;
+    type: FSManagerItemInfoType;
+}
+export interface FSManagerLsOpts {
+    recursive?: boolean;
+    withFullPath?: boolean;
+}
+export interface FSManagerLsItem {
+    path: FilePath;
+    type: FSManagerItemInfoType;
+}
+export interface FSManagerMkdirOpts {
+    recursive?: boolean;
+}
+export type Pathname = DirPath | FilePath;
+export interface 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/FSManager.js

@@ -0,0 +1,6 @@
+export var FSManagerItemInfoType;
+(function (FSManagerItemInfoType) {
+    FSManagerItemInfoType["DIR"] = "DIR";
+    FSManagerItemInfoType["FILE"] = "FILE";
+    FSManagerItemInfoType["OTHER"] = "OTHER";
+})(FSManagerItemInfoType || (FSManagerItemInfoType = {}));

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

@@ -0,0 +1,9 @@
+import type { FileMimeType, FilePath } from '../dt/index.js';
+export interface BlobLike {
+    type: FileMimeType;
+    uri: FilePath;
+}
+export type FormDataBuilderVal = BlobLike | string;
+export interface FormDataBuilder {
+    append(fd: FormData, key: string, val: FormDataBuilderVal): Promise<void>;
+}

package/dist/esm/std/FormDataBuilder.js

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

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

@@ -0,0 +1,40 @@
+import type { FreeTextLong, HTML, HTTPContentType, HTTPMethod, HTTPStatusNumber, JSONString, URL as URLString } from '../dt/index.js';
+import type { HTTPRequestBuilder } from '../utils/index.js';
+import type { BufferManagerBase64String } from './BufferManager.js';
+import type { Worker } from './Worker.js';
+export type HTTPAPICallExecutorAgent = {
+    destroy(): void;
+};
+export interface HTTPAPICallExecutorAgentBuilderInput {
+    url: URL;
+}
+export type HTTPAPICallExecutorAgentBuilderOutput = HTTPAPICallExecutorAgent | undefined;
+export interface HTTPAPICallExecutorAgentBuilder extends Worker<HTTPAPICallExecutorAgentBuilderInput, HTTPAPICallExecutorAgentBuilderOutput> {
+}
+export type HTTPAPICallExecutorFunc<Res> = (url: URL | URLString, info?: {
+    agent?: HTTPAPICallExecutorAgent | undefined;
+    body?: Awaited<ReturnType<HTTPRequestBuilder['exec']>>['body'];
+    headers?: {
+        Authorization?: BufferManagerBase64String;
+        'Content-Type'?: HTTPContentType;
+    };
+    method?: HTTPMethod;
+}) => Promise<HTTPAPICallExecutorResponse<Res>>;
+export interface HTTPAPICallExecutorResponse<Res> {
+    arrayBuffer(): Promise<Buffer>;
+    body: {
+        readable: boolean;
+    };
+    headers: {
+        entries(): IterableIterator<[string, string]>;
+        get: (name: 'Content-Type') => HTTPContentType;
+    };
+    json: () => Promise<Res>;
+    ok: boolean;
+    redirected: boolean;
+    status: HTTPStatusNumber;
+    text: () => Promise<FreeTextLong | HTML | JSONString>;
+}
+export interface HTTPAPICallExecutor {
+    fn<Res>(): HTTPAPICallExecutorFunc<Res>;
+}

package/dist/esm/std/HTTPAPICallExecutor.js

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

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

@@ -0,0 +1,39 @@
+import type { ApiKey, ErrorMessage, HTTPContentType, HTTPMethod, JWT, Password, URL, Username } from '../dt/index.js';
+import type { HTTPDataEnvelope } from '../utils/index.js';
+import type { XMLManagerParseOpts } from './XMLManager.js';
+type AdditionalHeadersBuilder<AH> = () => Promise<AH>;
+type ErrBuilder<ResBad> = (response: ResBad) => Promise<ErrorMessage>;
+type OutputBuilder<ResGood, O> = (response: ResGood) => Promise<O>;
+type ReqBuilder<Req extends object> = () => Promise<Req>;
+type URLBuilder = () => Promise<URL>;
+export interface HTTPAPICallerAuthorizationHeader {
+    prefix?: 'AWS4-HMAC-SHA256' | 'Basic' | 'Bearer' | 'JWT' | 'OAuth';
+    value: ApiKey | JWT | Password;
+}
+export interface HTTPAPICallerBasicAuth {
+    password: Password;
+    username: Username;
+}
+export interface HTTPAPICallerInputOpts {
+    xml?: XMLManagerParseOpts;
+}
+export interface HTTPAPICallerInput<AH extends object | undefined, Req extends object, ResBad, ResGood, O> {
+    additionalHeadersBuilder?: AdditionalHeadersBuilder<AH> | undefined;
+    authorizationHeader?: HTTPAPICallerAuthorizationHeader | undefined;
+    basicAuth?: HTTPAPICallerBasicAuth | undefined;
+    contentType?: HTTPContentType;
+    errBuilder: ErrBuilder<ResBad>;
+    method: HTTPMethod;
+    opts?: HTTPAPICallerInputOpts | undefined;
+    outputBuilder?: OutputBuilder<ResGood, O> | undefined;
+    req?: {
+        builder: ReqBuilder<Req>;
+        envelope: HTTPDataEnvelope;
+    } | undefined;
+    unknownErrorMessage?: ErrorMessage | undefined;
+    urlBuilder: URLBuilder;
+}
+export interface HTTPAPICaller {
+    exec<AH extends object | undefined, Req extends object, ResBad, ResGood, O>(input: HTTPAPICallerInput<AH, Req, ResBad, ResGood, O>): Promise<O>;
+}
+export {};

package/dist/esm/std/HTTPAPICaller.js

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

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

@@ -0,0 +1,14 @@
+import type { UIntQuantity } from '../dt/index.js';
+import type { I18nLanguageCode, I18nTranslationKey } from '../i18n/types.js';
+import type { Initializable } from '../utils/index.js';
+export interface I18nManagerTOpts {
+    count?: UIntQuantity;
+    fallback?: string | undefined;
+    vars?: Record<string, string>;
+}
+export interface I18nManager extends Initializable {
+    add<K extends I18nTranslationKey>(key: K, value: string): Promise<void>;
+    l(): I18nLanguageCode;
+    t<T extends I18nTranslationKey>(key: T, opts?: I18nManagerTOpts): string;
+    tOrNull<T extends I18nTranslationKey>(key: T, opts?: I18nManagerTOpts): string | null;
+}

package/dist/esm/std/I18nManager.js

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

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

@@ -0,0 +1,34 @@
+import type { ApiKey, JWT, Password, SSHPublicKey, Timestamp } from '../dt/index.js';
+import type { Settings } from './SettingsManager.js';
+export type JWTSecret = Password;
+export type JWTManagerPayload = {
+    exp?: Timestamp;
+    iat?: Timestamp;
+};
+export interface JWTManagerSettings extends Settings {
+    jwt_manager_algorithm: 'HS256' | 'HS512' | 'RS256';
+    jwt_manager_audience: string;
+    jwt_manager_expires_in: string;
+    jwt_manager_invalidate_issued_before: Timestamp | null;
+    jwt_manager_issuer: string;
+    jwt_manager_key_id: ApiKey | null;
+    jwt_manager_secret: JWTSecret;
+    jwt_manager_subject: string | null;
+}
+export type JWTManagerDecodeOpts = Pick<JWTManagerEncodeOpts, 'secret'> & {
+    spki?: SSHPublicKey;
+};
+export interface JWTManagerEncodeOpts {
+    alg?: JWTManagerSettings['jwt_manager_algorithm'];
+    aud?: JWTManagerSettings['jwt_manager_audience'];
+    exp?: JWTManagerSettings['jwt_manager_expires_in'];
+    iss?: JWTManagerSettings['jwt_manager_issuer'];
+    kid?: JWTManagerSettings['jwt_manager_key_id'];
+    secret?: JWTManagerSettings['jwt_manager_secret'];
+    sub?: JWTManagerSettings['jwt_manager_subject'];
+}
+export interface JWTManager {
+    decode<T extends JWTManagerPayload>(value: JWT, opts?: JWTManagerDecodeOpts): Promise<T>;
+    encode<T extends object>(payload: T, opts?: JWTManagerEncodeOpts): Promise<JWT>;
+    isUsable(value: JWT): Promise<boolean>;
+}

package/dist/esm/std/JWTManager.js

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

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

@@ -0,0 +1,17 @@
+import type { Clearable, Initializable } from '../utils/index.js';
+import type { Settings } from './SettingsManager.js';
+import type { Worker } from './Worker.js';
+export type JobManagerJobName = string;
+export type JobManagerQueueName = string;
+export interface JobManagerSettings extends Settings {
+    job_manager_enabled: boolean;
+    job_manager_processors: {
+        queueName: JobManagerQueueName;
+        workerClass: {
+            new (...args: any[]): Worker<any, any>;
+        };
+    }[];
+}
+export interface JobManager extends Clearable, Initializable {
+    dispatch<I>(queueName: JobManagerQueueName, jobName: JobManagerJobName, input: I): Promise<void>;
+}

package/dist/esm/std/JobManager.js

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

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

@@ -0,0 +1,13 @@
+import type { Settings } from './SettingsManager.js';
+export type LoggerLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error';
+export type LoggerMessage = string;
+export interface LoggerSettings extends Settings {
+    logger_level: LoggerLevel;
+}
+export interface Logger {
+    debug(message: LoggerMessage, ...meta: unknown[]): void;
+    error(err: Error): void;
+    info(message: LoggerMessage, ...meta: unknown[]): void;
+    trace(message: LoggerMessage, ...meta: unknown[]): void;
+    warn(message: LoggerMessage, ...meta: unknown[]): void;
+}

package/dist/esm/std/Logger.js

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

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

@@ -0,0 +1,6 @@
+export interface PromptManagerPromptOpts<T extends string> {
+    validate?: (value: T) => Promise<boolean>;
+}
+export interface PromptManager {
+    prompt<T extends string>(invite: string, opts?: PromptManagerPromptOpts<T>): Promise<T>;
+}

package/dist/esm/std/PromptManager.js

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

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

@@ -0,0 +1,14 @@
+export declare const SettingsManagerMandatoryPlaceholder = "!<>!";
+export declare const SettingsManagerMandatoryPlaceholderForArray: string[];
+export declare const SettingsManagerMandatoryPlaceholderForObject: {
+    '0': string;
+};
+export interface Settings {
+}
+export interface Configurable<S> {
+    s(): S;
+}
+export type SettingsGetter<S> = <K extends keyof S>(key: K) => S[K];
+export interface SettingsManager<S = Settings> {
+    get(): SettingsGetter<S>;
+}

package/dist/esm/std/SettingsManager.js

@@ -0,0 +1,7 @@
+export const SettingsManagerMandatoryPlaceholder = '!<>!';
+export const SettingsManagerMandatoryPlaceholderForArray = [
+    SettingsManagerMandatoryPlaceholder,
+];
+export const SettingsManagerMandatoryPlaceholderForObject = {
+    '0': SettingsManagerMandatoryPlaceholder,
+};

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

@@ -0,0 +1,3 @@
+export interface Worker<I, O> {
+    exec(input: I): O;
+}

package/dist/esm/std/Worker.js

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

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

@@ -0,0 +1,9 @@
+export type XMLManagerRawXML = string;
+export interface XMLManagerParseOpts {
+    attributeNamePrefix?: string;
+    isArray?: (tagName: string) => boolean;
+    isObject?: (tagName: string) => boolean;
+}
+export interface XMLManager {
+    parse<T>(xml: XMLManagerRawXML, opts?: XMLManagerParseOpts): Promise<T>;
+}

package/dist/esm/std/XMLManager.js

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

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

@@ -0,0 +1,8 @@
+import type { EmailManagerSettings } from './EmailManager.js';
+import type { JWTManagerSettings } from './JWTManager.js';
+import type { JobManagerSettings } from './JobManager.js';
+import type { LoggerSettings } from './Logger.js';
+export declare const STD_DEFAULT_EMAIL_MANAGER_SETTINGS: EmailManagerSettings;
+export declare const STD_DEFAULT_JOB_MANAGER_SETTINGS: JobManagerSettings;
+export declare const STD_DEFAULT_JWT_MANAGER_SETTINGS: JWTManagerSettings;
+export declare const STD_DEFAULT_LOGGER_SETTINGS: LoggerSettings;

package/dist/esm/std/consts.js

@@ -0,0 +1,22 @@
+import { SettingsManagerMandatoryPlaceholder } from './SettingsManager.js';
+export const STD_DEFAULT_EMAIL_MANAGER_SETTINGS = {
+    email_manager_enabled: false,
+    email_manager_from: 'me@example.com',
+};
+export const STD_DEFAULT_JOB_MANAGER_SETTINGS = {
+    job_manager_enabled: false,
+    job_manager_processors: [],
+};
+export const STD_DEFAULT_JWT_MANAGER_SETTINGS = {
+    jwt_manager_algorithm: 'HS256',
+    jwt_manager_audience: SettingsManagerMandatoryPlaceholder,
+    jwt_manager_expires_in: '1h',
+    jwt_manager_invalidate_issued_before: null,
+    jwt_manager_issuer: SettingsManagerMandatoryPlaceholder,
+    jwt_manager_key_id: null,
+    jwt_manager_secret: SettingsManagerMandatoryPlaceholder,
+    jwt_manager_subject: null,
+};
+export const STD_DEFAULT_LOGGER_SETTINGS = {
+    logger_level: 'debug',
+};

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

@@ -0,0 +1,10 @@
+import { Buffer } from 'buffer';
+import type { BufferManager, BufferManagerBase64String } from '../BufferManager.js';
+export declare class BufferLibBufferManager implements BufferManager {
+    decodeBase64<T extends string>(value: BufferManagerBase64String): T;
+    decodeUint8Array<T extends string>(value: Uint8Array): T;
+    encodeBase64<T extends string>(value: T): BufferManagerBase64String;
+    encodeUint8Array<T extends string>(value: T): Uint8Array;
+    from<T extends string>(value: T): Buffer;
+    fromHexToBase64<T extends string>(value: T): BufferManagerBase64String;
+}

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

@@ -0,0 +1,32 @@
+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 { Buffer } from 'buffer';
+import { injectable } from 'inversify';
+let BufferLibBufferManager = class BufferLibBufferManager {
+    decodeBase64(value) {
+        return Buffer.from(value, 'base64').toString('ascii');
+    }
+    decodeUint8Array(value) {
+        return Buffer.from(value).toString('hex');
+    }
+    encodeBase64(value) {
+        return Buffer.from(value).toString('base64');
+    }
+    encodeUint8Array(value) {
+        return Uint8Array.from(Buffer.from(value, 'hex'));
+    }
+    from(value) {
+        return Buffer.from(value);
+    }
+    fromHexToBase64(value) {
+        return Buffer.from(value, 'hex').toString('base64');
+    }
+};
+BufferLibBufferManager = __decorate([
+    injectable()
+], BufferLibBufferManager);
+export { BufferLibBufferManager };

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

@@ -0,0 +1,17 @@
+import type { Logger, LoggerMessage, LoggerSettings } from '../Logger.js';
+import type { Configurable, SettingsManager } from '../SettingsManager.js';
+type S = LoggerSettings;
+export declare class ConsoleLogger implements Configurable<S>, Logger {
+    private settingsManager;
+    private static LEVELS;
+    constructor(settingsManager: SettingsManager<S>);
+    s(): S;
+    debug(message: LoggerMessage, ...meta: unknown[]): void;
+    error(err: Error): void;
+    info(message: LoggerMessage, ...meta: unknown[]): void;
+    trace(message: LoggerMessage, ...meta: unknown[]): void;
+    warn(message: LoggerMessage, ...meta: unknown[]): void;
+    private shouldLog;
+    private t;
+}
+export {};

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

@@ -0,0 +1,77 @@
+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 ConsoleLogger_1;
+import { inject, injectable } from 'inversify';
+let ConsoleLogger = class ConsoleLogger {
+    static { ConsoleLogger_1 = this; }
+    settingsManager;
+    static LEVELS = [
+        'trace',
+        'debug',
+        'info',
+        'warn',
+        'error',
+    ];
+    constructor(settingsManager) {
+        this.settingsManager = settingsManager;
+    }
+    s() {
+        return {
+            logger_level: this.settingsManager.get()('logger_level'),
+        };
+    }
+    debug(message, ...meta) {
+        if (!this.shouldLog('debug')) {
+            return;
+        }
+        console.debug(`${this.t()} [debug] ${message}`, ...meta);
+    }
+    error(err) {
+        if (!this.shouldLog('error')) {
+            return;
+        }
+        console.error(err);
+    }
+    info(message, ...meta) {
+        if (!this.shouldLog('info')) {
+            return;
+        }
+        console.info(`${this.t()} [info] ${message}`, ...meta);
+    }
+    trace(message, ...meta) {
+        if (!this.shouldLog('trace')) {
+            return;
+        }
+        console.debug(`${this.t()} [trace] ${message}`, ...meta);
+    }
+    warn(message, ...meta) {
+        if (!this.shouldLog('warn')) {
+            return;
+        }
+        console.warn(`${this.t()} [warn] ${message}`, ...meta);
+    }
+    shouldLog(level) {
+        const configLevelIndex = ConsoleLogger_1.LEVELS.findIndex((l) => l === this.s().logger_level);
+        const levelIndex = ConsoleLogger_1.LEVELS.findIndex((l) => l === level);
+        return levelIndex >= configLevelIndex;
+    }
+    t() {
+        return new Date().toISOString();
+    }
+};
+ConsoleLogger = ConsoleLogger_1 = __decorate([
+    injectable(),
+    __param(0, inject('SettingsManager')),
+    __metadata("design:paramtypes", [Object])
+], ConsoleLogger);
+export { ConsoleLogger };

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

@@ -0,0 +1,10 @@
+import type { EnvironmentManager } from '../EnvironmentManager.js';
+import { type Settings, type SettingsGetter, type SettingsManager } from '../SettingsManager.js';
+export declare class EnvSettingsManager<S extends Settings = Settings> implements SettingsManager<S> {
+    private environmentManager;
+    private settings;
+    static ENV_VAR_PREFIX: string;
+    constructor(environmentManager: EnvironmentManager, settings: S);
+    get(): SettingsGetter<S>;
+    isMandatoryPlaceholder(value: unknown): value is string;
+}