umwd-components 0.1.836 → 0.1.838

package/dist/esm/src/components/common/module-config/ModuleGuard.js

@@ -0,0 +1,39 @@
+"use client";
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { jsx, Fragment } from 'react/jsx-runtime';
+import { isModuleEnabled, isModuleFeatureEnabled } from '../../../lib/module-config/config.js';
+
+/**
+ * Component that conditionally renders children based on module/feature enablement
+ */
+function ModuleGuard({ module, feature, fallback = null, children, }) {
+    const moduleEnabled = isModuleEnabled(module);
+    if (!moduleEnabled) {
+        return jsx(Fragment, { children: fallback });
+    }
+    if (feature) {
+        const featureEnabled = isModuleFeatureEnabled(module, feature);
+        if (!featureEnabled) {
+            return jsx(Fragment, { children: fallback });
+        }
+    }
+    return jsx(Fragment, { children: children });
+}
+/**
+ * Render prop component that provides module/feature status to children
+ */
+function ConditionalModule({ module, feature, children, }) {
+    const moduleEnabled = isModuleEnabled(module);
+    const featureEnabled = feature
+        ? isModuleFeatureEnabled(module, feature)
+        : true;
+    const isEnabled = moduleEnabled && featureEnabled;
+    return jsx(Fragment, { children: children(isEnabled) });
+}
+
+export { ConditionalModule, ModuleGuard };

package/dist/esm/src/index.js

@@ -223,3 +223,6 @@ export { MinioItemList } from './components/common/media/minio/MinioItemList.js'
 export { MinioDisplay } from './components/common/media/minio/MinioDisplay.js';
 export { contactFormAction } from './data/actions/e-commerce/lead/contactFormAction.js';
 export { ShippingStatusIndicator } from './components/e-commerce/opo/ShippingStatusIndicator.js';
+export { clearConfigCache, getConfigFilePath, getEnabledModules, getFullConfig, getModuleConfig, isModuleEnabled, isModuleFeatureEnabled, validateCurrentConfig } from './lib/module-config/config.js';
+export { filterNavigationByModules } from './lib/module-config/navigation-filter.js';
+export { ConditionalModule, ModuleGuard } from './components/common/module-config/ModuleGuard.js';

package/dist/esm/src/lib/module-config/config.js

@@ -0,0 +1,231 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { readFileSync } from 'fs';
+import { join } from 'path';
+
+let cachedConfig = null;
+/**
+ * Get the path to the umwdconfig.json file
+ * This function works across different environments (frontend, backend, CMS)
+ */
+function getConfigPath() {
+    // Start from the current working directory
+    let currentPath = process.cwd();
+    // For apps in subdirectories, traverse up to find the root config
+    const possiblePaths = [
+        join(currentPath, "umwdconfig.json"), // Root level
+        join(currentPath, "..", "umwdconfig.json"), // One level up (for frontend/backend/cms)
+        join(currentPath, "..", "..", "umwdconfig.json"), // Two levels up
+        join(currentPath, "..", "..", "..", "umwdconfig.json"), // Three levels up
+    ];
+    for (const path of possiblePaths) {
+        try {
+            // Check if file exists by trying to read it
+            readFileSync(path, "utf8");
+            return path;
+        }
+        catch {
+            // File doesn't exist, continue to next path
+            continue;
+        }
+    }
+    throw new Error("umwdconfig.json not found. Please ensure the configuration file exists in the project root.\n" +
+        `Searched paths:\n${possiblePaths.map((p) => `  - ${p}`).join("\n")}`);
+}
+/**
+ * Validate the UMWD configuration object
+ */
+function validateConfig(config) {
+    const errors = [];
+    if (!config || typeof config !== "object") {
+        return {
+            isValid: false,
+            errors: [
+                { field: "root", message: "Configuration must be a valid object" },
+            ],
+        };
+    }
+    if (!config.modules || typeof config.modules !== "object") {
+        errors.push({
+            field: "modules",
+            message: "modules field is required and must be an object",
+        });
+    }
+    else {
+        // Validate required modules
+        const requiredModules = ["pageBuilder", "ecommerce"];
+        for (const module of requiredModules) {
+            if (!config.modules[module]) {
+                errors.push({
+                    field: `modules.${module}`,
+                    message: `${module} module configuration is required`,
+                });
+            }
+            else if (typeof config.modules[module] !== "object") {
+                errors.push({
+                    field: `modules.${module}`,
+                    message: `${module} module must be an object`,
+                });
+            }
+            else if (typeof config.modules[module].enabled !== "boolean") {
+                errors.push({
+                    field: `modules.${module}.enabled`,
+                    message: `${module}.enabled must be a boolean`,
+                });
+            }
+        }
+        // Validate optional features within modules
+        Object.keys(config.modules).forEach((moduleName) => {
+            const module = config.modules[moduleName];
+            if (module && module.features && typeof module.features !== "object") {
+                errors.push({
+                    field: `modules.${moduleName}.features`,
+                    message: `${moduleName}.features must be an object`,
+                });
+            }
+            else if (module && module.features) {
+                Object.keys(module.features).forEach((featureName) => {
+                    if (typeof module.features[featureName] !== "boolean") {
+                        errors.push({
+                            field: `modules.${moduleName}.features.${featureName}`,
+                            message: `${moduleName}.features.${featureName} must be a boolean`,
+                        });
+                    }
+                });
+            }
+        });
+    }
+    return {
+        isValid: errors.length === 0,
+        errors,
+    };
+}
+/**
+ * Load and parse the UMWD configuration file
+ */
+function loadConfig(useCache = true) {
+    if (useCache && cachedConfig) {
+        return cachedConfig;
+    }
+    try {
+        const configPath = getConfigPath();
+        const configContent = readFileSync(configPath, "utf8");
+        const config = JSON.parse(configContent);
+        const validation = validateConfig(config);
+        if (!validation.isValid) {
+            const errorMessages = validation.errors
+                .map((error) => `${error.field}: ${error.message}`)
+                .join(", ");
+            throw new Error(`Invalid UMWD configuration: ${errorMessages}`);
+        }
+        cachedConfig = config;
+        return cachedConfig;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            throw new Error("Invalid JSON in umwdconfig.json file. Please check the file syntax.");
+        }
+        throw error;
+    }
+}
+/**
+ * Get the configuration for a specific module
+ */
+function getModuleConfig(moduleName) {
+    const config = loadConfig();
+    if (!config.modules[moduleName]) {
+        throw new Error(`Module '${moduleName}' not found in configuration`);
+    }
+    return config.modules[moduleName];
+}
+/**
+ * Check if a specific module is enabled
+ */
+function isModuleEnabled(moduleName) {
+    try {
+        const moduleConfig = getModuleConfig(moduleName);
+        return moduleConfig ? moduleConfig.enabled : false;
+    }
+    catch {
+        // If module doesn't exist or config is invalid, assume it's disabled
+        return false;
+    }
+}
+/**
+ * Check if a specific feature within a module is enabled
+ */
+function isModuleFeatureEnabled(moduleName, featureName) {
+    try {
+        const moduleConfig = getModuleConfig(moduleName);
+        // If module doesn't exist or is disabled, all features are disabled
+        if (!moduleConfig || !moduleConfig.enabled) {
+            return false;
+        }
+        // If no features are defined, assume the feature is enabled (if module is enabled)
+        if (!moduleConfig.features) {
+            return true;
+        }
+        // Check if the specific feature is enabled
+        return moduleConfig.features[featureName] === true;
+    }
+    catch {
+        // If module doesn't exist or config is invalid, assume feature is disabled
+        return false;
+    }
+}
+/**
+ * Get the full configuration object
+ */
+function getFullConfig() {
+    return loadConfig();
+}
+/**
+ * Get all enabled modules
+ */
+function getEnabledModules() {
+    const config = loadConfig();
+    return Object.keys(config.modules).filter((moduleName) => {
+        const moduleConfig = config.modules[moduleName];
+        return moduleConfig && moduleConfig.enabled;
+    });
+}
+/**
+ * Validate the current configuration without throwing
+ */
+function validateCurrentConfig() {
+    try {
+        const configPath = getConfigPath();
+        const configContent = readFileSync(configPath, "utf8");
+        const config = JSON.parse(configContent);
+        return validateConfig(config);
+    }
+    catch (error) {
+        return {
+            isValid: false,
+            errors: [
+                {
+                    field: "file",
+                    message: error instanceof Error ? error.message : "Unknown error",
+                },
+            ],
+        };
+    }
+}
+/**
+ * Clear the configuration cache (useful for testing or dynamic config reloading)
+ */
+function clearConfigCache() {
+    cachedConfig = null;
+}
+/**
+ * Get the path to the configuration file (useful for debugging)
+ */
+function getConfigFilePath() {
+    return getConfigPath();
+}
+
+export { clearConfigCache, getConfigFilePath, getEnabledModules, getFullConfig, getModuleConfig, isModuleEnabled, isModuleFeatureEnabled, validateCurrentConfig };

package/dist/esm/src/lib/module-config/navigation-filter.js

@@ -0,0 +1,58 @@
+/*
+ * UMWD-Components
+ * @copyright Jelle Paulus
+ * @license MIT
+ */
+  
+import { isModuleEnabled, isModuleFeatureEnabled } from './config.js';
+
+/**
+ * Filter navigation items based on enabled modules and features
+ */
+function filterNavigationByModules(navigation) {
+    return navigation
+        .filter((item) => {
+        // Check if this is an e-commerce related navigation item
+        if (item.href && isECommerceRoute(item.href)) {
+            if (!isModuleEnabled("ecommerce")) {
+                return false;
+            }
+            // Check for specific e-commerce features
+            if (item.href.includes("/user/orders") ||
+                item.href.includes("/user/returns")) {
+                return isModuleFeatureEnabled("ecommerce", "orders");
+            }
+            if (item.href.includes("/shop")) {
+                return isModuleFeatureEnabled("ecommerce", "shopping");
+            }
+        }
+        return true;
+    })
+        .map((item) => {
+        // Process children for items that passed the filter
+        if (item.children) {
+            return {
+                ...item,
+                children: filterNavigationByModules(item.children),
+            };
+        }
+        return item;
+    });
+}
+/**
+ * Check if a route is e-commerce related
+ */
+function isECommerceRoute(href) {
+    const ecommercePatterns = [
+        "/shop",
+        "/user/orders",
+        "/user/returns",
+        "/user/profile",
+        "/cart",
+        "/checkout",
+        "/check-out",
+    ];
+    return ecommercePatterns.some((pattern) => href.startsWith(pattern));
+}
+
+export { filterNavigationByModules };