@lodashventure/medusa-product-content 1.1.0

package/dist/admin/utils/import-export.js

@@ -0,0 +1,384 @@
+"use strict";
+/**
+ * Import/Export utility for specifications
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exportSpecsToCSV = exportSpecsToCSV;
+exports.exportSpecsToJSON = exportSpecsToJSON;
+exports.importSpecsFromCSV = importSpecsFromCSV;
+exports.importSpecsFromJSON = importSpecsFromJSON;
+exports.mergeSpecs = mergeSpecs;
+const papaparse_1 = __importDefault(require("papaparse"));
+/**
+ * Export specifications to CSV
+ */
+function exportSpecsToCSV(specs) {
+    const rows = [];
+    const locales = new Set();
+    // Collect all locales
+    specs.groups.forEach(group => {
+        Object.keys(group.i18n).forEach(locale => locales.add(locale));
+        group.items.forEach(item => {
+            Object.keys(item.i18n).forEach(locale => locales.add(locale));
+        });
+    });
+    const localeArray = Array.from(locales).sort();
+    // Create headers
+    const headers = [
+        'group_key',
+        'group_position',
+        ...localeArray.map(locale => `group_label.${locale}`),
+        'item_position',
+        ...localeArray.flatMap(locale => [`key.${locale}`, `value.${locale}`]),
+        'visible'
+    ];
+    // Create data rows
+    specs.groups.forEach(group => {
+        group.items.forEach(item => {
+            const row = {
+                group_key: group.key,
+                group_position: group.position,
+                item_position: item.position,
+                visible: item.visible ? 'true' : 'false'
+            };
+            // Add group labels
+            localeArray.forEach(locale => {
+                row[`group_label.${locale}`] = group.i18n[locale]?.label || '';
+            });
+            // Add item keys and values
+            localeArray.forEach(locale => {
+                row[`key.${locale}`] = item.i18n[locale]?.key || '';
+                row[`value.${locale}`] = item.i18n[locale]?.value || '';
+            });
+            rows.push(row);
+        });
+    });
+    // Convert to CSV
+    const csv = papaparse_1.default.unparse({
+        fields: headers,
+        data: rows
+    });
+    return csv;
+}
+/**
+ * Export specifications to JSON
+ */
+function exportSpecsToJSON(specs) {
+    return JSON.stringify(specs, null, 2);
+}
+/**
+ * Import specifications from CSV
+ */
+async function importSpecsFromCSV(csvContent, defaultLocale = 'th-TH') {
+    const parseResult = papaparse_1.default.parse(csvContent, {
+        header: true,
+        skipEmptyLines: true
+    });
+    if (parseResult.errors.length > 0) {
+        return {
+            specs: null,
+            validation: {
+                isValid: false,
+                errors: parseResult.errors.map((error, index) => ({
+                    row: error.row || index,
+                    field: 'parse',
+                    message: error.message,
+                    value: error.code
+                }))
+            }
+        };
+    }
+    const rows = parseResult.data;
+    const validation = validateCSVData(rows);
+    if (!validation.isValid) {
+        return { specs: null, validation };
+    }
+    // Convert CSV rows to specs structure
+    const specs = convertCSVToSpecs(rows, defaultLocale);
+    return {
+        specs,
+        validation: {
+            isValid: true,
+            errors: [],
+            processedRows: rows.length
+        }
+    };
+}
+/**
+ * Import specifications from JSON
+ */
+async function importSpecsFromJSON(jsonContent) {
+    try {
+        const specs = JSON.parse(jsonContent);
+        // Validate structure
+        const validation = validateSpecsStructure(specs);
+        if (!validation.isValid) {
+            return { specs: null, validation };
+        }
+        return {
+            specs,
+            validation: {
+                isValid: true,
+                errors: [],
+                processedRows: specs.groups.reduce((acc, g) => acc + g.items.length, 0)
+            }
+        };
+    }
+    catch (error) {
+        return {
+            specs: null,
+            validation: {
+                isValid: false,
+                errors: [{
+                        row: 0,
+                        field: 'json',
+                        message: `Invalid JSON: ${error.message}`
+                    }]
+            }
+        };
+    }
+}
+/**
+ * Validate CSV data
+ */
+function validateCSVData(rows) {
+    const errors = [];
+    rows.forEach((row, index) => {
+        // Check required fields
+        if (!row.group_key) {
+            errors.push({
+                row: index + 1,
+                field: 'group_key',
+                message: 'Group key is required',
+                value: row.group_key
+            });
+        }
+        // Check at least one key/value pair exists
+        const hasContent = Object.keys(row).some(key => {
+            if (key.startsWith('key.') || key.startsWith('value.')) {
+                return row[key] && row[key].trim() !== '';
+            }
+            return false;
+        });
+        if (!hasContent) {
+            errors.push({
+                row: index + 1,
+                field: 'content',
+                message: 'At least one key/value pair is required'
+            });
+        }
+        // Validate visible field
+        if (row.visible && !['true', 'false', '1', '0', ''].includes(row.visible.toLowerCase())) {
+            errors.push({
+                row: index + 1,
+                field: 'visible',
+                message: 'Visible must be true or false',
+                value: row.visible
+            });
+        }
+    });
+    return {
+        isValid: errors.length === 0,
+        errors,
+        processedRows: rows.length
+    };
+}
+/**
+ * Validate specs structure
+ */
+function validateSpecsStructure(specs) {
+    const errors = [];
+    if (!specs || typeof specs !== 'object') {
+        errors.push({
+            row: 0,
+            field: 'root',
+            message: 'Invalid specs structure'
+        });
+        return { isValid: false, errors };
+    }
+    if (!specs.default_locale) {
+        errors.push({
+            row: 0,
+            field: 'default_locale',
+            message: 'Default locale is required'
+        });
+    }
+    if (!Array.isArray(specs.groups)) {
+        errors.push({
+            row: 0,
+            field: 'groups',
+            message: 'Groups must be an array'
+        });
+        return { isValid: false, errors };
+    }
+    specs.groups.forEach((group, groupIndex) => {
+        if (!group.key) {
+            errors.push({
+                row: groupIndex,
+                field: 'group.key',
+                message: 'Group key is required'
+            });
+        }
+        if (!group.i18n || typeof group.i18n !== 'object') {
+            errors.push({
+                row: groupIndex,
+                field: 'group.i18n',
+                message: 'Group i18n is required'
+            });
+        }
+        if (!Array.isArray(group.items)) {
+            errors.push({
+                row: groupIndex,
+                field: 'group.items',
+                message: 'Group items must be an array'
+            });
+        }
+        else {
+            group.items.forEach((item, itemIndex) => {
+                if (!item.i18n || typeof item.i18n !== 'object') {
+                    errors.push({
+                        row: groupIndex * 100 + itemIndex,
+                        field: 'item.i18n',
+                        message: 'Item i18n is required'
+                    });
+                }
+            });
+        }
+    });
+    return {
+        isValid: errors.length === 0,
+        errors
+    };
+}
+/**
+ * Convert CSV rows to specs structure
+ */
+function convertCSVToSpecs(rows, defaultLocale) {
+    const groupsMap = new Map();
+    const locales = new Set();
+    // Collect all locales from column names
+    Object.keys(rows[0] || {}).forEach(key => {
+        const match = key.match(/\.([\w-]+)$/);
+        if (match) {
+            locales.add(match[1]);
+        }
+    });
+    rows.forEach(row => {
+        const groupKey = row.group_key;
+        let group = groupsMap.get(groupKey);
+        if (!group) {
+            group = {
+                key: groupKey,
+                position: parseInt(row.group_position) || groupsMap.size + 1,
+                i18n: {},
+                items: []
+            };
+            // Add group labels
+            locales.forEach(locale => {
+                const label = row[`group_label.${locale}`];
+                if (label) {
+                    group.i18n[locale] = { label };
+                }
+            });
+            groupsMap.set(groupKey, group);
+        }
+        // Create item
+        const item = {
+            position: parseInt(row.item_position) || group.items.length + 1,
+            i18n: {},
+            visible: row.visible !== 'false' && row.visible !== '0'
+        };
+        // Add item translations
+        locales.forEach(locale => {
+            const key = row[`key.${locale}`];
+            const value = row[`value.${locale}`];
+            if (key || value) {
+                item.i18n[locale] = {
+                    key: key || '',
+                    value: value || ''
+                };
+            }
+        });
+        group.items.push(item);
+    });
+    // Sort groups and items by position
+    const groups = Array.from(groupsMap.values()).sort((a, b) => a.position - b.position);
+    groups.forEach(group => {
+        group.items.sort((a, b) => a.position - b.position);
+    });
+    return {
+        default_locale: defaultLocale,
+        groups
+    };
+}
+/**
+ * Merge imported specs with existing specs
+ */
+function mergeSpecs(existing, imported, strategy = 'merge') {
+    if (strategy === 'replace') {
+        return imported;
+    }
+    if (strategy === 'append') {
+        const maxPosition = Math.max(...existing.groups.map(g => g.position), 0);
+        imported.groups.forEach((group, index) => {
+            group.position = maxPosition + index + 1;
+        });
+        return {
+            default_locale: existing.default_locale,
+            groups: [...existing.groups, ...imported.groups]
+        };
+    }
+    // Merge strategy
+    const mergedGroups = new Map();
+    // Add existing groups
+    existing.groups.forEach(group => {
+        mergedGroups.set(group.key, { ...group });
+    });
+    // Merge imported groups
+    imported.groups.forEach(importedGroup => {
+        const existingGroup = mergedGroups.get(importedGroup.key);
+        if (existingGroup) {
+            // Merge i18n
+            existingGroup.i18n = {
+                ...existingGroup.i18n,
+                ...importedGroup.i18n
+            };
+            // Merge items
+            const itemsMap = new Map();
+            // Add existing items
+            existingGroup.items.forEach(item => {
+                const key = Object.values(item.i18n)[0]?.key || `item-${item.position}`;
+                itemsMap.set(key, item);
+            });
+            // Merge imported items
+            importedGroup.items.forEach(importedItem => {
+                const key = Object.values(importedItem.i18n)[0]?.key || `item-${importedItem.position}`;
+                const existingItem = itemsMap.get(key);
+                if (existingItem) {
+                    // Merge i18n
+                    existingItem.i18n = {
+                        ...existingItem.i18n,
+                        ...importedItem.i18n
+                    };
+                    existingItem.visible = importedItem.visible;
+                }
+                else {
+                    itemsMap.set(key, importedItem);
+                }
+            });
+            existingGroup.items = Array.from(itemsMap.values())
+                .sort((a, b) => a.position - b.position);
+        }
+        else {
+            mergedGroups.set(importedGroup.key, importedGroup);
+        }
+    });
+    return {
+        default_locale: existing.default_locale,
+        groups: Array.from(mergedGroups.values())
+            .sort((a, b) => a.position - b.position)
+    };
+}

package/dist/admin/utils/locale.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Locale utility functions
+ */
+import { LocaleUtils, SpecGroup, SpecItem } from '../../types';
+export declare const localeUtils: LocaleUtils;
+/**
+ * Get localized spec value with fallback
+ */
+export declare function getLocalizedSpec(item: SpecItem, locale: string, fallbackLocale: string, field: 'key' | 'value'): string;
+/**
+ * Get localized group label with fallback
+ */
+export declare function getLocalizedGroupLabel(group: SpecGroup, locale: string, fallbackLocale: string): string;

package/dist/admin/utils/locale.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Locale utility functions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.localeUtils = void 0;
+exports.getLocalizedSpec = getLocalizedSpec;
+exports.getLocalizedGroupLabel = getLocalizedGroupLabel;
+exports.localeUtils = {
+    getLocaleLabel: (code) => {
+        const labels = {
+            'th-TH': 'ไทย',
+            'en-US': 'English (US)',
+            'en-GB': 'English (UK)',
+            'zh-CN': '中文 (简体)',
+            'ja-JP': '日本語',
+            'ko-KR': '한국어',
+            'vi-VN': 'Tiếng Việt',
+            'ms-MY': 'Bahasa Melayu',
+            'id-ID': 'Bahasa Indonesia',
+            'es-ES': 'Español',
+            'fr-FR': 'Français',
+            'de-DE': 'Deutsch',
+            'pt-BR': 'Português (BR)',
+            'ru-RU': 'Русский',
+            'ar-SA': 'العربية'
+        };
+        return labels[code] || code;
+    },
+    parseLocaleCode: (code) => {
+        const parts = code.split('-');
+        return {
+            language: parts[0],
+            region: parts[1]
+        };
+    },
+    getLanguageFromLocale: (code) => {
+        return code.split('-')[0];
+    },
+    getFallbackLocale: (locale, availableLocales, defaultLocale) => {
+        // Try exact match
+        if (availableLocales.includes(locale)) {
+            return locale;
+        }
+        // Try language-only match
+        const language = locale.split('-')[0];
+        const languageMatch = availableLocales.find(l => l.startsWith(language));
+        if (languageMatch) {
+            return languageMatch;
+        }
+        // Return default
+        return defaultLocale;
+    },
+    calculateLocaleCompleteness: (specs, locale) => {
+        if (!specs?.groups || specs.groups.length === 0) {
+            return 100; // No specs = complete
+        }
+        let total = 0;
+        let completed = 0;
+        specs.groups.forEach((group) => {
+            // Check group label
+            total++;
+            if (group.i18n?.[locale]?.label) {
+                completed++;
+            }
+            // Check items
+            group.items?.forEach((item) => {
+                total += 2; // key + value
+                if (item.i18n?.[locale]?.key) {
+                    completed++;
+                }
+                if (item.i18n?.[locale]?.value) {
+                    completed++;
+                }
+            });
+        });
+        return total === 0 ? 100 : Math.round((completed / total) * 100);
+    }
+};
+/**
+ * Get localized spec value with fallback
+ */
+function getLocalizedSpec(item, locale, fallbackLocale, field) {
+    return item.i18n?.[locale]?.[field] ||
+        item.i18n?.[fallbackLocale]?.[field] ||
+        '';
+}
+/**
+ * Get localized group label with fallback
+ */
+function getLocalizedGroupLabel(group, locale, fallbackLocale) {
+    return group.i18n?.[locale]?.label ||
+        group.i18n?.[fallbackLocale]?.label ||
+        group.key;
+}

package/dist/admin/utils/sanitize.d.ts

@@ -0,0 +1,29 @@
+/**
+ * HTML sanitization utility
+ */
+export interface SanitizeOptions {
+    allowedTags?: string[];
+    allowedAttributes?: Record<string, string[]>;
+    removeScripts?: boolean;
+    removeStyles?: boolean;
+}
+/**
+ * Sanitize HTML content
+ */
+export declare function sanitizeHTML(html: string, options?: SanitizeOptions): string;
+/**
+ * Extract plain text from HTML
+ */
+export declare function extractPlainText(html: string, maxLength?: number): string;
+/**
+ * Generate auto-excerpt from HTML
+ */
+export declare function generateExcerpt(html: string, maxLength?: number): string;
+/**
+ * Strip all HTML tags
+ */
+export declare function stripHtml(html: string): string;
+/**
+ * Estimate reading time
+ */
+export declare function estimateReadingTime(html: string): number;

package/dist/admin/utils/sanitize.js

@@ -0,0 +1,188 @@
+"use strict";
+/**
+ * HTML sanitization utility
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeHTML = sanitizeHTML;
+exports.extractPlainText = extractPlainText;
+exports.generateExcerpt = generateExcerpt;
+exports.stripHtml = stripHtml;
+exports.estimateReadingTime = estimateReadingTime;
+const isomorphic_dompurify_1 = __importDefault(require("isomorphic-dompurify"));
+const DEFAULT_ALLOWED_TAGS = [
+    "h1",
+    "h2",
+    "h3",
+    "h4",
+    "h5",
+    "h6",
+    "p",
+    "br",
+    "hr",
+    "strong",
+    "b",
+    "em",
+    "i",
+    "u",
+    "strike",
+    "s",
+    "del",
+    "ul",
+    "ol",
+    "li",
+    "blockquote",
+    "pre",
+    "code",
+    "a",
+    "img",
+    "table",
+    "thead",
+    "tbody",
+    "tfoot",
+    "tr",
+    "th",
+    "td",
+    "span",
+    "div",
+];
+const DEFAULT_ALLOWED_ATTRIBUTES = {
+    a: ["href", "target", "rel", "title"],
+    img: ["src", "alt", "title", "width", "height"],
+    blockquote: ["cite"],
+    code: ["class"],
+    pre: ["class"],
+    span: ["class", "style"],
+    div: ["class"],
+    table: ["class"],
+    th: ["colspan", "rowspan", "align"],
+    td: ["colspan", "rowspan", "align"],
+};
+/**
+ * Sanitize HTML content
+ */
+function sanitizeHTML(html, options = {}) {
+    const { allowedTags = DEFAULT_ALLOWED_TAGS, allowedAttributes = DEFAULT_ALLOWED_ATTRIBUTES, removeScripts = true, removeStyles = true, } = options;
+    // Configure DOMPurify
+    const config = {
+        ALLOWED_TAGS: allowedTags,
+        ALLOWED_ATTR: Object.keys(allowedAttributes).reduce((acc, tag) => {
+            allowedAttributes[tag].forEach((attr) => {
+                acc.push(attr);
+            });
+            return acc;
+        }, []),
+        KEEP_CONTENT: true,
+        ALLOW_DATA_ATTR: false,
+        FORBID_TAGS: removeScripts ? ["script", "style"] : [],
+        FORBID_ATTR: removeStyles ? ["style"] : [],
+    };
+    // Add custom hook to handle specific attributes per tag
+    isomorphic_dompurify_1.default.addHook("afterSanitizeAttributes", (node) => {
+        const tagName = node.tagName?.toLowerCase();
+        if (tagName && allowedAttributes[tagName]) {
+            const allowedAttrs = allowedAttributes[tagName];
+            const attrs = node.attributes;
+            if (attrs) {
+                for (let i = attrs.length - 1; i >= 0; i--) {
+                    const attr = attrs[i];
+                    if (!allowedAttrs.includes(attr.name)) {
+                        node.removeAttribute(attr.name);
+                    }
+                }
+            }
+        }
+        // Ensure links are safe
+        if (tagName === "a") {
+            const href = node.getAttribute("href");
+            if (href && !isValidUrl(href)) {
+                node.removeAttribute("href");
+            }
+            // Add rel="noopener noreferrer" for external links
+            const target = node.getAttribute("target");
+            if (target === "_blank") {
+                node.setAttribute("rel", "noopener noreferrer");
+            }
+        }
+        // Validate image sources
+        if (tagName === "img") {
+            const src = node.getAttribute("src");
+            if (src && !isValidImageUrl(src)) {
+                node.removeAttribute("src");
+            }
+        }
+    });
+    const cleaned = isomorphic_dompurify_1.default.sanitize(html, config);
+    // Remove hook after use
+    isomorphic_dompurify_1.default.removeHook("afterSanitizeAttributes");
+    return String(cleaned);
+}
+/**
+ * Extract plain text from HTML
+ */
+function extractPlainText(html, maxLength) {
+    const tempDiv = document.createElement("div");
+    tempDiv.innerHTML = sanitizeHTML(html);
+    let text = tempDiv.textContent || tempDiv.innerText || "";
+    text = text.replace(/\s+/g, " ").trim();
+    if (maxLength && text.length > maxLength) {
+        text = text.substring(0, maxLength) + "...";
+    }
+    return text;
+}
+/**
+ * Generate auto-excerpt from HTML
+ */
+function generateExcerpt(html, maxLength = 160) {
+    const plainText = extractPlainText(html, maxLength);
+    return plainText;
+}
+/**
+ * Validate URL
+ */
+function isValidUrl(url) {
+    try {
+        // Allow relative URLs
+        if (url.startsWith("/") || url.startsWith("#")) {
+            return true;
+        }
+        const urlObj = new URL(url);
+        // Only allow http(s) and mailto
+        return ["http:", "https:", "mailto:"].includes(urlObj.protocol);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate image URL
+ */
+function isValidImageUrl(url) {
+    // Allow data URLs for embedded images
+    if (url.startsWith("data:image/")) {
+        return true;
+    }
+    // Allow relative URLs
+    if (url.startsWith("/")) {
+        return true;
+    }
+    // Check if it's a valid absolute URL
+    return isValidUrl(url);
+}
+/**
+ * Strip all HTML tags
+ */
+function stripHtml(html) {
+    return html.replace(/<[^>]*>/g, "");
+}
+/**
+ * Estimate reading time
+ */
+function estimateReadingTime(html) {
+    const text = extractPlainText(html);
+    const wordsPerMinute = 200;
+    const words = text.split(/\s+/).length;
+    return Math.ceil(words / wordsPerMinute);
+}