@arc-js/config-manager 0.0.1 → 0.0.2

package/index.js

@@ -8,7 +8,7 @@ function __awaiter(thisArg, _arguments, P, generator) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
         function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
         function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, [])).next());
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 }
 
@@ -2269,17 +2269,12 @@ var jsxRuntimeExports = requireJsxRuntime();
 var reactExports = requireReact();
 
 const mergeDeep = (target, source) => {
-    if (typeof target !== 'object' || typeof source !== 'object') {
+    if (typeof target !== 'object' || typeof source !== 'object')
         return source;
-    }
     const output = Object.assign({}, target);
     for (const key in source) {
         if (source.hasOwnProperty(key)) {
-            if (target.hasOwnProperty(key) &&
-                typeof target[key] === 'object' &&
-                typeof source[key] === 'object' &&
-                !Array.isArray(target[key]) &&
-                !Array.isArray(source[key])) {
+            if (target.hasOwnProperty(key)) {
                 output[key] = mergeDeep(target[key], source[key]);
             }
             else {
@@ -2290,1166 +2285,235 @@ const mergeDeep = (target, source) => {
     return output;
 };
 
-var cooks = {};
-
-var timez = {};
-
-var hasRequiredTimez;
-
-function requireTimez () {
-	if (hasRequiredTimez) return timez;
-	hasRequiredTimez = 1;
-
-	Object.defineProperty(timez, '__esModule', { value: true });
-
-	class Timez {
-	    constructor(input, enableException = false) {
-	        if (this.dateChecker(input) === false) {
-	            this._date = undefined;
-	        }
-	        else {
-	            if (input instanceof Timez && !!input && !!(input === null || input === void 0 ? void 0 : input._date)) {
-	                this._date = new Date(input === null || input === void 0 ? void 0 : input._date);
-	            }
-	            else if (input instanceof Date) {
-	                this._date = new Date(input);
-	            }
-	            else if (typeof input === 'string') {
-	                this._date = Timez.parseString(input, enableException);
-	            }
-	            else if (typeof input === 'number') {
-	                this._date = new Date(input);
-	            }
-	            else if (input === undefined ||
-	                input === null ||
-	                (typeof input === 'number' && isNaN(input))) {
-	                this._date = new Date();
-	            }
-	            else {
-	                this._date = undefined;
-	            }
-	        }
-	    }
-	    static now() {
-	        return new Timez();
-	    }
-	    static parse(dateString, format) {
-	        if (typeof format === 'string' &&
-	            format.length > 0 && ((dateString instanceof Timez &&
-	            !!dateString &&
-	            !!(dateString === null || dateString === void 0 ? void 0 : dateString._date)) ||
-	            dateString instanceof Date ||
-	            typeof dateString === 'string' ||
-	            typeof dateString === 'number' || (dateString === undefined ||
-	            dateString === null ||
-	            (typeof dateString === 'number' && isNaN(dateString))))) {
-	            return Timez.parseWithFormat(dateString, format) || new Timez(dateString);
-	        }
-	        return new Timez(dateString);
-	    }
-	    static unix(timestamp) {
-	        return new Timez(timestamp * 1000);
-	    }
-	    static utc() {
-	        const now = new Date();
-	        return new Timez(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate(), now.getUTCHours(), now.getUTCMinutes(), now.getUTCSeconds(), now.getUTCMilliseconds()));
-	    }
-	    year() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getFullYear();
-	    }
-	    month() {
-	        return !!this._date ? this._date.getMonth() + 1 : undefined;
-	    }
-	    date() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getDate();
-	    }
-	    hour() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getHours();
-	    }
-	    minute() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getMinutes();
-	    }
-	    second() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getSeconds();
-	    }
-	    millisecond() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getMilliseconds();
-	    }
-	    day() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getDay();
-	    }
-	    add(amount, unit) {
-	        if (!this._date) {
-	            return new Timez(undefined);
-	        }
-	        const newDate = new Date(this._date);
-	        switch (unit) {
-	            case 'years':
-	                newDate.setFullYear(newDate.getFullYear() + amount);
-	                break;
-	            case 'months':
-	                newDate.setMonth(newDate.getMonth() + amount);
-	                break;
-	            case 'days':
-	                newDate.setDate(newDate.getDate() + amount);
-	                break;
-	            case 'hours':
-	                newDate.setHours(newDate.getHours() + amount);
-	                break;
-	            case 'minutes':
-	                newDate.setMinutes(newDate.getMinutes() + amount);
-	                break;
-	            case 'seconds':
-	                newDate.setSeconds(newDate.getSeconds() + amount);
-	                break;
-	            case 'milliseconds':
-	                newDate.setMilliseconds(newDate.getMilliseconds() + amount);
-	                break;
-	        }
-	        return new Timez(newDate);
-	    }
-	    subtract(amount, unit) {
-	        return this.add(-amount, unit);
-	    }
-	    startOf(unit) {
-	        if (!this._date) {
-	            return new Timez(undefined);
-	        }
-	        const newDate = new Date(this._date);
-	        switch (unit) {
-	            case 'year':
-	                newDate.setMonth(0, 1);
-	                newDate.setHours(0, 0, 0, 0);
-	                break;
-	            case 'month':
-	                newDate.setDate(1);
-	                newDate.setHours(0, 0, 0, 0);
-	                break;
-	            case 'day':
-	                newDate.setHours(0, 0, 0, 0);
-	                break;
-	            case 'hour':
-	                newDate.setMinutes(0, 0, 0);
-	                break;
-	            case 'minute':
-	                newDate.setSeconds(0, 0);
-	                break;
-	            case 'second':
-	                newDate.setMilliseconds(0);
-	                break;
-	        }
-	        return new Timez(newDate);
-	    }
-	    endOf(unit) {
-	        const start = this.startOf(unit);
-	        switch (unit) {
-	            case 'year':
-	                return start.add(1, 'years').subtract(1, 'milliseconds');
-	            case 'month':
-	                return start.add(1, 'months').subtract(1, 'milliseconds');
-	            case 'day':
-	                return start.add(1, 'days').subtract(1, 'milliseconds');
-	            case 'hour':
-	                return start.add(1, 'hours').subtract(1, 'milliseconds');
-	            case 'minute':
-	                return start.add(1, 'minutes').subtract(1, 'milliseconds');
-	            case 'second':
-	                return start.add(1, 'seconds').subtract(1, 'milliseconds');
-	            default:
-	                return start;
-	        }
-	    }
-	    isBefore(other, inclusivity = '()') {
-	        const isIncluded = inclusivity[1] === ']';
-	        const otherTimez = other instanceof Timez ? other : new Timez(other);
-	        if (!this._date || !otherTimez._date) {
-	            return false;
-	        }
-	        return ((!isIncluded &&
-	            this._date < otherTimez._date) ||
-	            (!!isIncluded &&
-	                this._date <= otherTimez._date));
-	    }
-	    isAfter(other, inclusivity = '()') {
-	        const isIncluded = inclusivity[0] === '[';
-	        const otherTimez = other instanceof Timez ? other : new Timez(other);
-	        if (!this._date || !otherTimez._date) {
-	            return false;
-	        }
-	        return ((!isIncluded &&
-	            this._date > otherTimez._date) ||
-	            (!!isIncluded &&
-	                this._date >= otherTimez._date));
-	    }
-	    isSame(other, unit) {
-	        const otherTimez = other instanceof Timez ? other : new Timez(other);
-	        if (!unit && this._date && otherTimez._date) {
-	            return this._date.getTime() === otherTimez._date.getTime();
-	        }
-	        const thisStart = !!unit ? this.startOf(unit) : undefined;
-	        const otherStart = !!unit ? otherTimez.startOf(unit) : undefined;
-	        if (!thisStart || !(thisStart === null || thisStart === void 0 ? void 0 : thisStart._date) || !otherStart || !(otherStart === null || otherStart === void 0 ? void 0 : otherStart._date)) {
-	            return false;
-	        }
-	        return thisStart._date.getTime() === otherStart._date.getTime();
-	    }
-	    isBetween(start, end, inclusivity = '()') {
-	        const startTimez = start instanceof Timez ? start : new Timez(start);
-	        const endTimez = end instanceof Timez ? end : new Timez(end);
-	        const startIncluded = inclusivity[0] === '[';
-	        const endIncluded = inclusivity[1] === ']';
-	        const afterStart = startIncluded ?
-	            this.isSame(startTimez) || this.isAfter(startTimez) :
-	            this.isAfter(startTimez);
-	        const beforeEnd = endIncluded ?
-	            this.isSame(endTimez) || this.isBefore(endTimez) :
-	            this.isBefore(endTimez);
-	        return afterStart && beforeEnd;
-	    }
-	    format(formatString) {
-	        if (!formatString) {
-	            return this.toISOString();
-	        }
-	        const predefinedFormat = Timez.PREDEFINED_FORMATS[formatString];
-	        if (predefinedFormat) {
-	            return this.format(predefinedFormat);
-	        }
-	        let result = '';
-	        let i = 0;
-	        while (i < formatString.length) {
-	            if (formatString[i] === '[') {
-	                const endIndex = formatString.indexOf(']', i);
-	                if (endIndex === -1) {
-	                    result += formatString[i];
-	                    i++;
-	                    continue;
-	                }
-	                const literal = formatString.substring(i + 1, endIndex);
-	                result += literal;
-	                i = endIndex + 1;
-	            }
-	            else if (formatString[i] === '%' && i + 1 < formatString.length) {
-	                const token = `%${formatString[i + 1]}`;
-	                const formatter = Timez.FORMAT_TOKENS[token];
-	                if (formatter) {
-	                    result += formatter(this);
-	                }
-	                else {
-	                    result += token;
-	                }
-	                i += 2;
-	            }
-	            else {
-	                result += formatString[i];
-	                i++;
-	            }
-	        }
-	        return result;
-	    }
-	    setTimezone(timezone) {
-	        if (!this._date) {
-	            return new Timez(undefined);
-	        }
-	        const currentOffset = this._date.getTimezoneOffset();
-	        const targetOffset = this.parseTimezoneOffset(timezone);
-	        const adjustedDate = new Date(this._date.getTime() + (targetOffset - currentOffset) * 60000);
-	        return new Timez(adjustedDate);
-	    }
-	    utc() {
-	        if (!this._date) {
-	            return new Timez(undefined);
-	        }
-	        return new Timez(new Date(Date.UTC(this._date.getUTCFullYear(), this._date.getUTCMonth(), this._date.getUTCDate(), this._date.getUTCHours(), this._date.getUTCMinutes(), this._date.getUTCSeconds(), this._date.getUTCMilliseconds())));
-	    }
-	    local() {
-	        if (!this._date) {
-	            return new Timez(undefined);
-	        }
-	        return new Timez(new Date(this._date.getFullYear(), this._date.getMonth(), this._date.getDate(), this._date.getHours(), this._date.getMinutes(), this._date.getSeconds(), this._date.getMilliseconds()));
-	    }
-	    toString() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.toString();
-	    }
-	    toISOString() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.toISOString();
-	    }
-	    toDate() {
-	        return !!this._date ? new Date(this._date) : undefined;
-	    }
-	    valueOf() {
-	        var _a;
-	        return (_a = this._date) === null || _a === void 0 ? void 0 : _a.getTime();
-	    }
-	    unix() {
-	        return !!this._date ? Math.floor(this._date.getTime() / 1000) : undefined;
-	    }
-	    utcOffset() {
-	        return this._date ? -this._date.getTimezoneOffset() : undefined;
-	    }
-	    isCorrect() {
-	        return !!this._date && !isNaN(this._date.getTime());
-	    }
-	    timezone() {
-	        if (!this._date)
-	            return undefined;
-	        try {
-	            const formatter = new Intl.DateTimeFormat();
-	            const timezone = formatter.resolvedOptions().timeZone;
-	            return timezone || undefined;
-	        }
-	        catch (error) {
-	            return this.timezoneFromOffset();
-	        }
-	    }
-	    timezoneAbbr() {
-	        if (!this._date)
-	            return undefined;
-	        try {
-	            const formatter = new Intl.DateTimeFormat('en', {
-	                timeZoneName: 'short'
-	            });
-	            const parts = formatter.formatToParts(this._date);
-	            const timezonePart = parts.find(part => part.type === 'timeZoneName');
-	            return (timezonePart === null || timezonePart === void 0 ? void 0 : timezonePart.value) || undefined;
-	        }
-	        catch (error) {
-	            return this.timezoneAbbrFromOffset();
-	        }
-	    }
-	    timezoneName() {
-	        if (!this._date)
-	            return undefined;
-	        try {
-	            const formatter = new Intl.DateTimeFormat('en', {
-	                timeZoneName: 'long'
-	            });
-	            const parts = formatter.formatToParts(this._date);
-	            const timezonePart = parts.find(part => part.type === 'timeZoneName');
-	            return (timezonePart === null || timezonePart === void 0 ? void 0 : timezonePart.value) || undefined;
-	        }
-	        catch (error) {
-	            return this.timezoneNameFromOffset();
-	        }
-	    }
-	    timezoneOffsetString() {
-	        const offset = this.utcOffset();
-	        if (offset === undefined)
-	            return undefined;
-	        const sign = offset >= 0 ? '+' : '-';
-	        const hours = Math.floor(Math.abs(offset) / 60).toString().padStart(2, '0');
-	        const minutes = (Math.abs(offset) % 60).toString().padStart(2, '0');
-	        return `${sign}${hours}:${minutes}`;
-	    }
-	    dateChecker(input) {
-	        return ((input instanceof Timez &&
-	            !!input &&
-	            !!(input === null || input === void 0 ? void 0 : input._date)) ||
-	            input instanceof Date ||
-	            typeof input === 'string' ||
-	            typeof input === 'number' || (input === undefined ||
-	            input === null ||
-	            (typeof input === 'number' && isNaN(input))));
-	    }
-	    timezoneFromOffset() {
-	        const offset = this.utcOffset();
-	        if (offset === undefined)
-	            return undefined;
-	        const offsetToTimezone = {
-	            0: 'Etc/UTC',
-	            60: 'Europe/Paris',
-	            120: 'Europe/Athens',
-	            180: 'Europe/Moscow',
-	            240: 'Asia/Dubai',
-	            270: 'Asia/Tehran',
-	            300: 'Asia/Karachi',
-	            330: 'Asia/Kolkata',
-	            345: 'Asia/Rangoon',
-	            360: 'Asia/Dhaka',
-	            390: 'Asia/Yangon',
-	            420: 'Asia/Bangkok',
-	            480: 'Asia/Shanghai',
-	            525: 'Asia/Kathmandu',
-	            540: 'Asia/Tokyo',
-	            570: 'Australia/Adelaide',
-	            600: 'Australia/Sydney',
-	            630: 'Australia/Lord_Howe',
-	            660: 'Pacific/Noumea',
-	            675: 'Australia/Eucla',
-	            720: 'Pacific/Auckland',
-	            780: 'Pacific/Chatham',
-	            [-60]: 'Atlantic/Azores',
-	            [-120]: 'America/Noronha',
-	            [-180]: 'America/Argentina/Buenos_Aires',
-	            [-210]: 'America/St_Johns',
-	            [-240]: 'America/Halifax',
-	            [-270]: 'America/Caracas',
-	            [-300]: 'America/New_York',
-	            [-360]: 'America/Chicago',
-	            [-420]: 'America/Denver',
-	            [-480]: 'America/Los_Angeles',
-	            [-540]: 'America/Anchorage',
-	            [-600]: 'Pacific/Honolulu',
-	            [-660]: 'Pacific/Pago_Pago',
-	            [-720]: 'Pacific/Kiritimati',
-	        };
-	        return offsetToTimezone[offset] || `Etc/GMT${offset >= 0 ? '-' : '+'}${Math.abs(offset) / 60}`;
-	    }
-	    timezoneAbbrFromOffset() {
-	        const offset = this.utcOffset();
-	        if (offset === undefined)
-	            return undefined;
-	        const offsetToAbbr = {
-	            0: 'GMT',
-	            60: 'CET',
-	            [-300]: 'EST',
-	            [-360]: 'CST',
-	            [-420]: 'MST',
-	            [-480]: 'PST',
-	        };
-	        return offsetToAbbr[offset] || `GMT${offset >= 0 ? '+' : ''}${offset / 60}`;
-	    }
-	    timezoneNameFromOffset() {
-	        const offset = this.utcOffset();
-	        if (offset === undefined)
-	            return undefined;
-	        const offsetToName = {
-	            0: 'Greenwich Mean Time',
-	            60: 'Central European Time',
-	            [-300]: 'Eastern Standard Time',
-	            [-360]: 'Central Standard Time',
-	            [-420]: 'Mountain Standard Time',
-	            [-480]: 'Pacific Standard Time',
-	        };
-	        return offsetToName[offset] || `GMT${offset >= 0 ? '+' : ''}${offset / 60}`;
-	    }
-	    isDST() {
-	        if (!this._date)
-	            return undefined;
-	        try {
-	            const jan = new Date(this._date.getFullYear(), 0, 1);
-	            const jul = new Date(this._date.getFullYear(), 6, 1);
-	            const stdOffset = Math.max(jan.getTimezoneOffset(), jul.getTimezoneOffset());
-	            return this._date.getTimezoneOffset() < stdOffset;
-	        }
-	        catch (error) {
-	            return undefined;
-	        }
-	    }
-	    static parseString(dateString, enableException = false) {
-	        const isoDate = new Date(dateString);
-	        if (!isNaN(isoDate.getTime())) {
-	            return isoDate;
-	        }
-	        const formats = [
-	            /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})\.(\d{3})Z$/,
-	            /^(\d{4})-(\d{2})-(\d{2})$/,
-	            /^(\d{4})\/(\d{2})\/(\d{2}) (\d{2}):(\d{2}):(\d{2})$/,
-	            /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})$/
-	        ];
-	        for (const regex of formats) {
-	            const match = dateString.match(regex);
-	            if (match) {
-	                const components = match.slice(1).map(Number);
-	                if (regex === formats[0]) {
-	                    return new Date(Date.UTC(components[0], components[1] - 1, components[2], components[3], components[4], components[5], components[6]));
-	                }
-	                else if (regex === formats[1]) {
-	                    return new Date(components[0], components[1] - 1, components[2]);
-	                }
-	                else if (regex === formats[2]) {
-	                    return new Date(components[0], components[1] - 1, components[2], components[3], components[4], components[5]);
-	                }
-	                else if (regex === formats[3]) {
-	                    return new Date(components[0], components[1] - 1, components[2], components[3], components[4], components[5]);
-	                }
-	            }
-	        }
-	        const fallback = new Date(dateString);
-	        if (!isNaN(fallback.getTime())) {
-	            return fallback;
-	        }
-	        if (!!enableException) {
-	            throw new Error(`Unable to parse date string: ${dateString}`);
-	        }
-	    }
-	    static parseWithFormat(value, format) {
-	        if (!value || !format)
-	            return undefined;
-	        const valueStr = String(value).trim();
-	        if (!valueStr)
-	            return undefined;
-	        const tokenHandlers = {
-	            'Y': {
-	                regex: /\d{4}/,
-	                extract: (match) => parseInt(match, 10)
-	            },
-	            'y': {
-	                regex: /\d{2}/,
-	                extract: (match) => {
-	                    const year = parseInt(match, 10);
-	                    return year >= 70 ? 1900 + year : 2000 + year;
-	                }
-	            },
-	            'm': {
-	                regex: /\d{1,2}/,
-	                extract: (match) => parseInt(match, 10)
-	            },
-	            'd': {
-	                regex: /\d{1,2}/,
-	                extract: (match) => parseInt(match, 10)
-	            },
-	            'H': {
-	                regex: /\d{1,2}/,
-	                extract: (match) => parseInt(match, 10)
-	            },
-	            'M': {
-	                regex: /\d{1,2}/,
-	                extract: (match) => parseInt(match, 10)
-	            },
-	            'S': {
-	                regex: /\d{1,2}/,
-	                extract: (match) => parseInt(match, 10)
-	            },
-	            'f': {
-	                regex: /\d{1,3}/,
-	                extract: (match) => parseInt(match, 10)
-	            }
-	        };
-	        const result = {
-	            year: new Date().getFullYear(),
-	            month: 1,
-	            day: 1,
-	            hour: 0,
-	            minute: 0,
-	            second: 0,
-	            millisecond: 0
-	        };
-	        let valueIndex = 0;
-	        let formatIndex = 0;
-	        let inLiteral = false;
-	        let currentLiteral = '';
-	        while (formatIndex < format.length && valueIndex < valueStr.length) {
-	            const formatChar = format[formatIndex];
-	            if (formatChar === '[') {
-	                inLiteral = true;
-	                currentLiteral = '';
-	                formatIndex++;
-	            }
-	            else if (formatChar === ']' && inLiteral) {
-	                if (valueStr.substring(valueIndex, valueIndex + currentLiteral.length) === currentLiteral) {
-	                    valueIndex += currentLiteral.length;
-	                }
-	                else {
-	                    return undefined;
-	                }
-	                inLiteral = false;
-	                currentLiteral = '';
-	                formatIndex++;
-	            }
-	            else if (inLiteral) {
-	                currentLiteral += formatChar;
-	                formatIndex++;
-	            }
-	            else if (formatChar === '%' && formatIndex + 1 < format.length) {
-	                const token = format[formatIndex + 1];
-	                const handler = tokenHandlers[token];
-	                if (handler) {
-	                    const remainingValue = valueStr.substring(valueIndex);
-	                    const match = remainingValue.match(handler.regex);
-	                    if (match && match.index === 0) {
-	                        const matchedValue = match[0];
-	                        const numericValue = handler.extract(matchedValue);
-	                        switch (token) {
-	                            case 'Y':
-	                            case 'y':
-	                                result.year = numericValue;
-	                                break;
-	                            case 'm':
-	                                result.month = numericValue;
-	                                break;
-	                            case 'd':
-	                                result.day = numericValue;
-	                                break;
-	                            case 'H':
-	                                result.hour = numericValue;
-	                                break;
-	                            case 'M':
-	                                result.minute = numericValue;
-	                                break;
-	                            case 'S':
-	                                result.second = numericValue;
-	                                break;
-	                            case 'f':
-	                                result.millisecond = numericValue;
-	                                break;
-	                        }
-	                        valueIndex += matchedValue.length;
-	                    }
-	                    else {
-	                        return undefined;
-	                    }
-	                }
-	                else {
-	                    valueIndex++;
-	                }
-	                formatIndex += 2;
-	            }
-	            else {
-	                if (formatChar === valueStr[valueIndex]) {
-	                    valueIndex++;
-	                    formatIndex++;
-	                }
-	                else {
-	                    return undefined;
-	                }
-	            }
-	        }
-	        if (result.month < 1 || result.month > 12)
-	            return undefined;
-	        if (result.day < 1 || result.day > 31)
-	            return undefined;
-	        if (result.hour < 0 || result.hour > 23)
-	            return undefined;
-	        if (result.minute < 0 || result.minute > 59)
-	            return undefined;
-	        if (result.second < 0 || result.second > 59)
-	            return undefined;
-	        if (result.millisecond < 0 || result.millisecond > 999)
-	            return undefined;
-	        try {
-	            const date = new Date(result.year, result.month - 1, 
-	            result.day, result.hour, result.minute, result.second, result.millisecond);
-	            if (isNaN(date.getTime())) {
-	                return undefined;
-	            }
-	            return new Timez(date);
-	        }
-	        catch (error) {
-	            return undefined;
-	        }
-	    }
-	    static getTokenLength(token) {
-	        const tokenLengths = {
-	            'Y': 4, 
-	            'y': 2, 
-	            'm': 2, 
-	            'd': 2, 
-	            'H': 2, 
-	            'M': 2, 
-	            'S': 2, 
-	            'f': 3, 
-	            'z': 5 
-	        };
-	        return tokenLengths[token] || 1;
-	    }
-	    parseTimezoneOffset(timezone) {
-	        const offsets = {
-	            'UTC': 0,
-	            'EST': -300, 
-	            'EDT': -240, 
-	            'CST': -360, 
-	            'CDT': -300, 
-	            'PST': -480, 
-	            'PDT': -420, 
-	        };
-	        if (offsets[timezone.toUpperCase()] !== undefined) {
-	            return offsets[timezone.toUpperCase()];
-	        }
-	        const match = timezone.match(/^([+-])(\d{1,2}):?(\d{2})?$/);
-	        if (match) {
-	            const sign = match[1] === '+' ? 1 : -1;
-	            const hours = parseInt(match[2], 10);
-	            const minutes = match[3] ? parseInt(match[3], 10) : 0;
-	            return sign * (hours * 60 + minutes);
-	        }
-	        return this._date ? -this._date.getTimezoneOffset() : 0;
-	    }
-	    static get FORMATS() {
-	        return Object.assign({}, Timez.PREDEFINED_FORMATS);
-	    }
-	    static exposeToGlobal() {
-	        if (typeof window !== 'undefined') {
-	            window.Timez = Timez;
-	        }
-	    }
-	}
-	Timez.FORMAT_TOKENS = {
-	    '%Y': (t) => { var _a; return (_a = t.year()) === null || _a === void 0 ? void 0 : _a.toString().padStart(4, '0'); },
-	    '%y': (t) => { var _a; return (_a = t.year()) === null || _a === void 0 ? void 0 : _a.toString().slice(-2).padStart(2, '0'); },
-	    '%m': (t) => { var _a; return (_a = t.month()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
-	    '%d': (t) => { var _a; return (_a = t.date()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
-	    '%H': (t) => { var _a; return (_a = t.hour()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
-	    '%M': (t) => { var _a; return (_a = t.minute()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
-	    '%S': (t) => { var _a; return (_a = t.second()) === null || _a === void 0 ? void 0 : _a.toString().padStart(2, '0'); },
-	    '%f': (t) => { var _a; return (_a = t.millisecond()) === null || _a === void 0 ? void 0 : _a.toString().padStart(3, '0'); },
-	    '%z': (t) => {
-	        const offset = t.utcOffset();
-	        if (!offset) {
-	            return undefined;
-	        }
-	        const sign = offset >= 0 ? '+' : '-';
-	        const hours = Math.floor(Math.abs(offset) / 60).toString().padStart(2, '0');
-	        const minutes = (Math.abs(offset) % 60).toString().padStart(2, '0');
-	        return `${sign}${hours}${minutes}`;
-	    },
-	    '%s': (t) => {
-	        const val = t.valueOf();
-	        return !!val ? Math.floor(val / 1000).toString() : undefined;
-	    },
-	};
-	Timez.PREDEFINED_FORMATS = {
-	    ISO: '%Y-%m-%dT%H:%M:%S.%fZ',
-	    ISO_DATE: '%Y-%m-%d',
-	    ISO_TIME: '%H:%M:%S.%fZ',
-	    COMPACT: '%Y%m%d%H%M%S',
-	    SLASH_DATETIME: '%Y/%m/%d %H:%M:%S.%fZ',
-	    SLASH_DATETIME_SEC: '%Y/%m/%d %H:%M:%S',
-	    SLASH_DATETIME_MIN: '%Y/%m/%d %H:%M',
-	    EUROPEAN: '%d/%m/%Y %H:%M:%S GMT%z',
-	    SLASH_DATE: '%Y/%m/%d',
-	    TIME_MICRO: '%H:%M:%S.%fZ',
-	    TIME_SEC: '%H:%M:%S',
-	    CUSTOM_GREETING: '[Bonjour celestin, ][la date actuelle est:: le] %d/%m/%Y [à] %H:%M:%S.%f[Z]',
-	};
-	if (typeof window !== 'undefined') {
-	    window.Timez = Timez;
-	}
-
-	timez.Timez = Timez;
-	timez.default = Timez;
-	return timez;
-}
-
-var hasRequiredCooks;
-
-function requireCooks () {
-	if (hasRequiredCooks) return cooks;
-	hasRequiredCooks = 1;
-
-	Object.defineProperty(cooks, '__esModule', { value: true });
-
-	var timez = requireTimez();
-
-	const tabAlphabetique = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'];
-	[...tabAlphabetique, ...tabAlphabetique.map(x => x.toUpperCase())];
-
-	class Cooks {
-	    static set(key, value, options = {}) {
-	        if (!this.isBrowser())
-	            return;
-	        try {
-	            const serializedValue = this.serialize(value);
-	            const encodedValue = encodeURIComponent(serializedValue);
-	            const cookieString = this.buildCookieString(key, encodedValue, options);
-	            document.cookie = cookieString;
-	        }
-	        catch (error) {
-	            console.error(`Cooks: Error setting cookie "${key}":`, error);
-	        }
-	    }
-	    static get(key) {
-	        if (!this.isBrowser())
-	            return null;
-	        try {
-	            const cookies = this.getAllCookies();
-	            const encodedValue = cookies[key];
-	            if (!encodedValue)
-	                return null;
-	            const decodedValue = decodeURIComponent(encodedValue);
-	            return this.deserialize(decodedValue);
-	        }
-	        catch (error) {
-	            console.error(`Cooks: Error getting cookie "${key}":`, error);
-	            return null;
-	        }
-	    }
-	    static remove(key, path = '/', domain) {
-	        if (!this.isBrowser())
-	            return;
-	        const options = {
-	            expires: new Date(0),
-	            path,
-	            domain
-	        };
-	        this.set(key, '', options);
-	    }
-	    static has(key) {
-	        return this.get(key) !== null;
-	    }
-	    static keys() {
-	        if (!this.isBrowser())
-	            return [];
-	        const cookies = this.getAllCookies();
-	        return Object.keys(cookies);
-	    }
-	    static clear() {
-	        if (!this.isBrowser())
-	            return;
-	        const cookies = this.getAllCookies();
-	        Object.keys(cookies).forEach(key => {
-	            this.remove(key);
-	        });
-	    }
-	    static serialize(value) {
-	        if (value instanceof Date) {
-	            return JSON.stringify({
-	                __type: 'Date',
-	                __value: value.toISOString()
-	            });
-	        }
-	        return JSON.stringify(value);
-	    }
-	    static deserialize(value) {
-	        const parsed = JSON.parse(value);
-	        if (parsed && typeof parsed === 'object' && parsed.__type === 'Date') {
-	            return new Date(parsed.__value);
-	        }
-	        return parsed;
-	    }
-	    static buildCookieString(key, value, options) {
-	        const mergedOptions = Object.assign(Object.assign({}, this.DEFAULT_OPTIONS), options);
-	        let cookieString = `${key}=${value}`;
-	        if (mergedOptions.expires !== undefined) {
-	            let expirationDate;
-	            if (typeof mergedOptions.expires === 'number') {
-	                const expirationDateInitial = new timez.Timez().add(mergedOptions.expires, 'seconds').toDate();
-	                if (!!expirationDateInitial) {
-	                    expirationDate = expirationDateInitial;
-	                }
-	                else {
-	                    expirationDate = new Date();
-	                }
-	            }
-	            else {
-	                expirationDate = mergedOptions.expires;
-	            }
-	            cookieString += `; expires=${expirationDate.toUTCString()}`;
-	        }
-	        if (mergedOptions.path)
-	            cookieString += `; path=${mergedOptions.path}`;
-	        if (mergedOptions.domain)
-	            cookieString += `; domain=${mergedOptions.domain}`;
-	        if (mergedOptions.secure)
-	            cookieString += `; secure`;
-	        if (mergedOptions.sameSite)
-	            cookieString += `; samesite=${mergedOptions.sameSite}`;
-	        {
-	            console.log(`Cooks - buildCookieString | cookieString:: `, cookieString);
-	        }
-	        return cookieString;
-	    }
-	    static getAllCookies() {
-	        return document.cookie
-	            .split(';')
-	            .reduce((cookies, cookie) => {
-	            const [key, value] = cookie.split('=').map(part => part.trim());
-	            if (key) {
-	                cookies[key] = value || '';
-	            }
-	            return cookies;
-	        }, {});
-	    }
-	    static isBrowser() {
-	        return typeof window !== 'undefined' && typeof document !== 'undefined';
-	    }
-	    static exposeToGlobal() {
-	        if (typeof window !== "undefined") {
-	            window.Cooks = Cooks;
-	        }
-	    }
-	}
-	Cooks.DEFAULT_OPTIONS = {
-	    path: '/',
-	    secure: true,
-	    sameSite: 'lax'
-	};
-	if (typeof window !== "undefined") {
-	    window.Cooks = Cooks;
-	}
-
-	cooks.Cooks = Cooks;
-	cooks.default = Cooks;
-	return cooks;
-}
-
-requireCooks();
-
-var _a;
-const SRC_DIR = ((_a = process === null || process === void 0 ? void 0 : process.env) === null || _a === void 0 ? void 0 : _a.VITE_APP_SRC_DIR) || '/src';
+let configManagerConfig = null;
+const setConfigManagerConfig = (config) => {
+    configManagerConfig = config;
+};
 
-const globalConfigGlob = import.meta.glob('@/config.json', { eager: false });
-const moduleConfigsGlob = import.meta.glob('@/modules/*/config.json', { eager: false });
-const loadGlobalConfig = () => __awaiter(void 0, void 0, void 0, function* () {
+const loadBaseConfig = () => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        const path = `${SRC_DIR}/config.json`;
-        if (globalConfigGlob[path]) {
-            const module = yield globalConfigGlob[path]();
-            return module.default || module;
-        }
-        else {
-            const module = yield import(
-            path);
-            return module.default;
+        if (!(configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.base)) {
+            console.warn('No base config found');
+            return {};
         }
+        const baseConfigs = yield Promise.all(Object.entries(configManagerConfig.base).map((_a) => __awaiter(void 0, [_a], void 0, function* ([key, loader]) {
+            try {
+                const config = yield loader();
+                return { key, config };
+            }
+            catch (error) {
+                console.error(`Failed to load base config ${key}:`, error);
+                return { key, config: {} };
+            }
+        })));
+        return baseConfigs.reduce((acc, { key, config }) => {
+            return Object.assign(Object.assign({}, acc), config);
+        }, {});
     }
     catch (error) {
-        console.warn('Global config not found, using empty config');
+        console.error('Failed to load base config:', error);
         return {};
     }
 });
-const loadModuleConfig = (moduleName) => __awaiter(void 0, void 0, void 0, function* () {
-    try {
-        const path = `${SRC_DIR}/modules/${moduleName}/config.json`;
-        if (moduleConfigsGlob[path]) {
-            const module = yield moduleConfigsGlob[path]();
-            return module.default || module;
+const loadModulesConfigs = () => __awaiter(void 0, void 0, void 0, function* () {
+    const results = [];
+    if (!(configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.modules)) {
+        return results;
+    }
+    for (const [moduleName, loader] of Object.entries(configManagerConfig.modules)) {
+        try {
+            const config = yield loader();
+            results.push({
+                moduleName,
+                config
+            });
         }
-        else {
-            const module = yield import(
-            path);
-            return module.default;
+        catch (error) {
+            console.error(`Failed to load config for module "${moduleName}"`, error);
         }
     }
-    catch (error) {
-        console.warn(`Module config "${moduleName}" not found, using empty config`);
-        return {};
-    }
+    return results;
 });
-const loadEnvConfig = () => {
-    const envConfig = {};
-    if (import.meta.env) {
-        Object.keys(import.meta.env).forEach(key => {
-            if (key.startsWith('VITE_')) {
-                const configKey = key
-                    .replace(/^VITE_/, '')
-                    .toLowerCase()
-                    .split('_')
-                    .map((part, index) => index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1))
-                    .join('');
-                envConfig[configKey] = import.meta.env[key];
-            }
-        });
+const loadModuleConfig = (moduleName) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a;
+    if (!((_a = configManagerConfig === null || configManagerConfig === void 0 ? void 0 : configManagerConfig.modules) === null || _a === void 0 ? void 0 : _a[moduleName])) {
+        return undefined;
     }
-    if (typeof process !== 'undefined' && process.env) {
-        Object.keys(process.env).forEach(key => {
-            if (key.startsWith('VITE_') || key === 'NODE_ENV') {
-                const configKey = key
-                    .replace(/^VITE_/, '')
-                    .toLowerCase()
-                    .split('_')
-                    .map((part, index) => index === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1))
-                    .join('');
-                envConfig[configKey] = process.env[key];
-            }
-        });
+    try {
+        const loader = configManagerConfig.modules[moduleName];
+        const config = yield loader();
+        return {
+            moduleName,
+            config
+        };
     }
-    return envConfig;
-};
+    catch (error) {
+        console.error(`Failed to load config for module "${moduleName}"`, error);
+        return undefined;
+    }
+});
 
-class ConfigurationService {
+class ConfigService {
     constructor() {
-        Object.defineProperty(this, "configs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        Object.defineProperty(this, "envConfig", {
+        Object.defineProperty(this, "resources", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: {}
         });
-        Object.defineProperty(this, "globalConfig", {
+        Object.defineProperty(this, "loadedModules", {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: {}
-        });
-        Object.defineProperty(this, "initialized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
+            value: new Set()
         });
     }
     initialize() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.initialized)
-                return;
-            this.globalConfig = yield loadGlobalConfig();
-            this.envConfig = yield loadEnvConfig();
-            this.configs.set('global', this.globalConfig);
-            this.configs.set('ENV', this.envConfig);
-            this.initialized = true;
+            yield this.loadAllConfigs();
         });
     }
-    loadModuleConfig(moduleName) {
+    loadAllConfigs() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.configs.has(moduleName))
-                return;
-            const moduleConfig = yield loadModuleConfig(moduleName);
-            const mergedConfig = mergeDeep(Object.assign({}, this.globalConfig), moduleConfig);
-            this.configs.set(moduleName, mergedConfig);
+            const base = yield loadBaseConfig();
+            const modules = yield loadModulesConfigs();
+            this.resources = modules.reduce((acc, { moduleName, config }) => {
+                return mergeDeep(acc, { [moduleName]: config });
+            }, { base });
+            modules.forEach(({ moduleName }) => {
+                this.loadedModules.add(moduleName);
+            });
         });
     }
-    get(path, options = {}) {
-        const { moduleName = 'global', defaultValue, required = false } = options;
-        const config = this.configs.get(moduleName) || this.globalConfig;
-        if (!this.configs.has(moduleName) && moduleName !== 'ENV') {
-            console.warn(`Module ${moduleName} config not loaded. Loading synchronously...`);
-            this.loadModuleConfig(moduleName).catch(console.error);
-        }
-        const value = this.resolvePath(config, path);
-        if (value === undefined && required) {
-            throw new Error(`Configuration path "${path}" is required but not found in module "${moduleName}"`);
-        }
-        return value !== undefined ? value : defaultValue;
-    }
-    getOrThrow(path, moduleName) {
-        const value = this.get(path, { moduleName, required: true });
-        if (value === undefined) {
-            throw new Error(`Configuration path "${path}" not found in module "${moduleName || 'global'}"`);
-        }
-        return value;
-    }
-    getAll(moduleName) {
-        if (moduleName) {
-            return this.configs.get(moduleName) || {};
-        }
-        const allConfigs = Object.assign({}, this.globalConfig);
-        for (const [name, config] of this.configs.entries()) {
-            if (name !== 'global' && name !== 'ENV') {
-                allConfigs[name] = config;
+    loadModule(moduleName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.loadedModules.has(moduleName))
+                return;
+            const moduleData = yield loadModuleConfig(moduleName);
+            if (moduleData === null || moduleData === void 0 ? void 0 : moduleData.config) {
+                this.resources[moduleName] = mergeDeep(this.resources[moduleName] || {}, moduleData.config);
+                this.loadedModules.add(moduleName);
             }
-        }
-        return allConfigs;
-    }
-    has(path, moduleName) {
-        const config = moduleName ? this.configs.get(moduleName) : this.globalConfig;
-        if (!config)
-            return false;
-        return this.resolvePath(config, path) !== undefined;
-    }
-    set(path, value, moduleName) {
-        const targetConfig = moduleName
-            ? (this.configs.get(moduleName) || {})
-            : this.globalConfig;
-        this.setPath(targetConfig, path, value);
-        if (moduleName) {
-            this.configs.set(moduleName, targetConfig);
-        }
-        else {
-            this.globalConfig = targetConfig;
-            this.configs.set('global', targetConfig);
-        }
-    }
-    merge(config, moduleName) {
-        const targetConfig = moduleName
-            ? (this.configs.get(moduleName) || {})
-            : this.globalConfig;
-        const merged = mergeDeep(targetConfig, config);
-        if (moduleName) {
-            this.configs.set(moduleName, merged);
-        }
-        else {
-            this.globalConfig = merged;
-            this.configs.set('global', merged);
-        }
+        });
     }
-    resolvePath(obj, path) {
-        if (typeof path === 'string') {
-            return path.split('.').reduce((acc, key) => {
-                return acc && acc[key] !== undefined ? acc[key] : undefined;
-            }, obj);
+    get(key, options = {}) {
+        const { moduleName = 'base', defaultValue = undefined, pathSeparator = '.' } = options;
+        const resource = this.resources[moduleName];
+        if (!resource) {
+            return defaultValue;
         }
-        return path.reduce((acc, key) => {
-            return acc && acc[key] !== undefined ? acc[key] : undefined;
-        }, obj);
+        const result = key.split(pathSeparator).reduce((acc, part) => {
+            return acc && acc[part] !== undefined ? acc[part] : undefined;
+        }, resource);
+        return result !== undefined ? result : defaultValue;
     }
-    setPath(obj, path, value) {
-        const keys = typeof path === 'string' ? path.split('.') : path;
-        let current = obj;
-        for (let i = 0; i < keys.length - 1; i++) {
-            const key = keys[i];
-            if (!current[key] || typeof current[key] !== 'object') {
-                current[key] = {};
-            }
-            current = current[key];
-        }
-        current[keys[keys.length - 1]] = value;
+    getConfig(moduleName = 'base') {
+        return this.resources[moduleName] || {};
     }
-    getEnv(key, defaultValue) {
-        return this.envConfig[key] || defaultValue;
-    }
-    isProduction() {
-        return this.getEnv('NODE_ENV') === 'production';
-    }
-    isDevelopment() {
-        return this.getEnv('NODE_ENV') === 'development';
-    }
-    isTest() {
-        return this.getEnv('NODE_ENV') === 'test';
+    reload() {
+        return this.loadAllConfigs();
     }
 }
 
-const ConfigContext = reactExports.createContext(null);
-const useConfigValue = () => {
-    const [service] = reactExports.useState(() => new ConfigurationService());
+const ConfigManagerContext = reactExports.createContext(null);
+const useConfigManagerValue = (configManagerConfig) => {
+    const [service] = reactExports.useState(() => new ConfigService());
     const [isLoading, setIsLoading] = reactExports.useState(true);
+    reactExports.useEffect(() => {
+        setConfigManagerConfig(configManagerConfig);
+    }, [configManagerConfig]);
     reactExports.useEffect(() => {
         const initialize = () => __awaiter(void 0, void 0, void 0, function* () {
-            yield service.initialize();
-            setIsLoading(false);
+            setIsLoading(true);
+            try {
+                yield service.initialize();
+            }
+            catch (error) {
+                console.error('Failed to initialize config manager:', error);
+            }
+            finally {
+                setIsLoading(false);
+            }
         });
         initialize();
-    }, []);
-    const loadModuleConfig = (moduleName) => __awaiter(void 0, void 0, void 0, function* () {
+    }, [service]);
+    const reloadConfig = reactExports.useCallback(() => __awaiter(void 0, void 0, void 0, function* () {
         setIsLoading(true);
-        yield service.loadModuleConfig(moduleName);
-        setIsLoading(false);
-    });
-    const value = reactExports.useMemo(() => ({
-        get: service.get.bind(service),
-        getOrThrow: service.getOrThrow.bind(service),
-        getAll: service.getAll.bind(service),
-        has: service.has.bind(service),
-        set: service.set.bind(service),
-        merge: service.merge.bind(service),
-        getEnv: service.getEnv.bind(service),
-        isProduction: service.isProduction.bind(service),
-        isDevelopment: service.isDevelopment.bind(service),
-        isTest: service.isTest.bind(service),
-        loadModuleConfig,
+        try {
+            yield service.reload();
+        }
+        catch (error) {
+            console.error('Failed to reload config:', error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }), [service]);
+    const loadModuleConfig = reactExports.useCallback((moduleName) => __awaiter(void 0, void 0, void 0, function* () {
+        setIsLoading(true);
+        try {
+            yield service.loadModule(moduleName);
+        }
+        catch (error) {
+            console.error(`Failed to load module config ${moduleName}:`, error);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }), [service]);
+    const get = reactExports.useCallback((key, options) => {
+        return service.get(key, options);
+    }, [service]);
+    const getConfig = reactExports.useCallback((moduleName) => {
+        return service.getConfig(moduleName);
+    }, [service]);
+    return {
+        get,
+        getConfig,
+        reloadConfig,
         isLoading,
-    }), [service, isLoading]);
-    return value;
+        loadModuleConfig,
+    };
 };
-const ConfigProvider = ({ children, preloadModules = [] }) => {
-    const value = useConfigValue();
-    reactExports.useEffect(() => {
-        if (!value.isLoading) {
-            preloadModules.forEach(moduleName => {
-                value.loadModuleConfig(moduleName);
-            });
-        }
-    }, [value.isLoading]);
-    return jsxRuntimeExports.jsx(ConfigContext.Provider, { value: value, children: children });
+const ConfigManagerProvider = ({ configs, children, }) => {
+    const value = useConfigManagerValue(configs);
+    return jsxRuntimeExports.jsx(ConfigManagerContext.Provider, { value: value, children: children });
 };
-const useConfig = () => {
-    const context = reactExports.useContext(ConfigContext);
+const useConfigManager = () => {
+    const context = reactExports.useContext(ConfigManagerContext);
     if (!context)
-        throw new Error('useConfig must be used within a ConfigProvider');
+        throw new Error('useConfigManager must be used within a ConfigManagerProvider');
     return context;
 };
 
-export { ConfigProvider, useConfig };
+const useConfig = (moduleName) => {
+    const configManager = useConfigManager();
+    const [isModuleLoading, setIsModuleLoading] = reactExports.useState(false);
+    const [moduleLoaded, setModuleLoaded] = reactExports.useState(!moduleName);
+    const cf = reactExports.useCallback((key, options) => {
+        const finalOptions = Object.assign(Object.assign({}, options), { moduleName: (options === null || options === void 0 ? void 0 : options.moduleName) || moduleName || 'base' });
+        return configManager.get(key, finalOptions);
+    }, [configManager, moduleName]);
+    reactExports.useEffect(() => {
+        if (moduleName && !moduleLoaded) {
+            setIsModuleLoading(true);
+            configManager.loadModuleConfig(moduleName)
+                .then(() => {
+                setModuleLoaded(true);
+            })
+                .finally(() => {
+                setIsModuleLoading(false);
+            });
+        }
+    }, [moduleName, moduleLoaded, configManager]);
+    return {
+        cf,
+        getConfig: configManager.getConfig,
+        reloadConfig: configManager.reloadConfig,
+        isLoading: configManager.isLoading || isModuleLoading,
+        isModuleLoaded: moduleLoaded,
+        loadModuleConfig: configManager.loadModuleConfig,
+    };
+};
+
+export { ConfigManagerProvider, useConfig, useConfigManager };