@uniweb/semantic-parser 1.1.4 → 1.1.6

package/src/mappers/extractors.js

@@ -1,416 +0,0 @@
-/**
- * Pre-built extractors for common component patterns
- *
- * All extractors work with the flat content structure:
- * - Root level: title, pretitle, subtitle, paragraphs, links, imgs, items, etc.
- * - Items array: each item has flat structure (title, paragraphs, etc.)
- */
-
-import { first, joinParagraphs } from "./helpers.js";
-
-/**
- * Extract hero component data
- * Common pattern: Large header with title, subtitle, image, and CTA
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @returns {Object} Hero component data
- */
-function hero(parsed) {
-    const links = parsed?.links || [];
-    const buttonLink = links.find(l => l.role?.startsWith('button'));
-    const plainLink = links.find(l => !l.role?.startsWith('button'));
-
-    return {
-        title: parsed?.title || null,
-        subtitle: parsed?.subtitle || null,
-        kicker: parsed?.pretitle || null,
-        description: parsed?.paragraphs || [],
-        image: first(parsed?.imgs)?.url || null,
-        imageAlt: first(parsed?.imgs)?.alt || null,
-        banner: null, // Banner detection would need to be added separately
-        cta: buttonLink || plainLink || null,
-    };
-}
-
-/**
- * Extract card component data
- * Common pattern: Title, description, image, and link
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @param {Object} options - Extraction options
- * @param {boolean} options.useItems - Extract from items instead of main
- * @param {number} options.itemIndex - Specific item index to extract from
- * @returns {Object|Array} Card data or array of cards if useItems=true
- */
-function card(parsed, options = {}) {
-    const { useItems = false, itemIndex } = options;
-
-    const extractCard = (content) => {
-        if (!content) return null;
-
-        const links = content.links || [];
-        const buttonLink = links.find(l => l.role?.startsWith('button'));
-        const plainLink = links.find(l => !l.role?.startsWith('button'));
-
-        return {
-            title: content.title || null,
-            subtitle: content.subtitle || null,
-            description: content.paragraphs || [],
-            image: first(content.imgs)?.url || null,
-            imageAlt: first(content.imgs)?.alt || null,
-            icon: first(content.icons) || null,
-            link: plainLink || null,
-            cta: buttonLink || plainLink || null,
-        };
-    };
-
-    if (useItems) {
-        const items = parsed?.items || [];
-        if (itemIndex !== undefined) {
-            return extractCard(items[itemIndex]);
-        }
-        return items.map(extractCard).filter(Boolean);
-    }
-
-    return extractCard(parsed);
-}
-
-/**
- * Extract article/blog content
- * Common pattern: Title, author info, content blocks, images
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @returns {Object} Article data
- */
-function article(parsed) {
-    return {
-        title: parsed?.title || null,
-        subtitle: parsed?.subtitle || null,
-        kicker: parsed?.pretitle || null,
-        author: null, // Would need metadata support
-        date: null,   // Would need metadata support
-        banner: null, // Banner detection would need to be added separately
-        content: parsed?.paragraphs || [],
-        images: parsed?.imgs || [],
-        videos: parsed?.videos || [],
-        links: parsed?.links || [],
-    };
-}
-
-/**
- * Extract statistics/metrics data
- * Common pattern: Numeric value with label
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @returns {Array} Array of stat objects
- */
-function stats(parsed) {
-    const items = parsed?.items || [];
-
-    return items
-        .map((item) => ({
-            value: item.title || null,
-            label: item.subtitle || first(item.paragraphs) || null,
-            description: item.paragraphs || [],
-        }))
-        .filter((stat) => stat.value);
-}
-
-/**
- * Extract navigation menu structure
- * Common pattern: Hierarchical menu with labels, links, and optional children
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @returns {Array} Navigation items
- */
-function navigation(parsed) {
-    const items = parsed?.items || [];
-
-    return items
-        .map((item) => {
-            const navItem = {
-                label: item.title || null,
-                href: first(item.links)?.href || null,
-            };
-
-            // Extract children from nested lists
-            const firstList = first(item.lists);
-            if (firstList && firstList.length > 0) {
-                navItem.children = firstList
-                    .map((listItem) => ({
-                        label: joinParagraphs(listItem.paragraphs) || null,
-                        href: first(listItem.links)?.href || null,
-                        icon: first(listItem.icons) || null,
-                    }))
-                    .filter((child) => child.label);
-            }
-
-            return navItem;
-        })
-        .filter((item) => item.label);
-}
-
-/**
- * Extract feature list
- * Common pattern: Icon/image, title, description
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @returns {Array} Feature items
- */
-function features(parsed) {
-    const items = parsed?.items || [];
-
-    return items
-        .map((item) => ({
-            title: item.title || null,
-            subtitle: item.subtitle || null,
-            description: item.paragraphs || [],
-            icon: first(item.icons) || null,
-            image: first(item.imgs)?.url || null,
-            link: first(item.links) || null,
-        }))
-        .filter((feature) => feature.title);
-}
-
-/**
- * Extract testimonial data
- * Common pattern: Quote, author name, role, image
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @param {Object} options - Extraction options
- * @param {boolean} options.useItems - Extract from items instead of main
- * @returns {Object|Array} Testimonial data
- */
-function testimonial(parsed, options = {}) {
-    const { useItems = false } = options;
-
-    const extractTestimonial = (content) => {
-        if (!content) return null;
-
-        return {
-            quote: content.paragraphs || [],
-            author: content.title || null,
-            role: content.subtitle || null,
-            company: content.pretitle || null,
-            image: first(content.imgs)?.url || null,
-            imageAlt: first(content.imgs)?.alt || null,
-        };
-    };
-
-    if (useItems) {
-        const items = parsed?.items || [];
-        return items.map(extractTestimonial).filter(Boolean);
-    }
-
-    return extractTestimonial(parsed);
-}
-
-/**
- * Extract FAQ (question and answer pairs)
- * Common pattern: Question as title, answer as content
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @returns {Array} FAQ items
- */
-function faq(parsed) {
-    const items = parsed?.items || [];
-
-    return items
-        .map((item) => ({
-            question: item.title || null,
-            answer: item.paragraphs || [],
-            links: item.links || [],
-        }))
-        .filter((item) => item.question);
-}
-
-/**
- * Extract pricing tier data
- * Common pattern: Plan name, price, features list, CTA
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @returns {Array} Pricing tiers
- */
-function pricing(parsed) {
-    const items = parsed?.items || [];
-
-    return items
-        .map((item) => {
-            const firstList = first(item.lists);
-            const links = item.links || [];
-            const buttonLink = links.find(l => l.role?.startsWith('button'));
-
-            return {
-                name: item.title || null,
-                price: item.subtitle || null,
-                description: first(item.paragraphs) || null,
-                features: firstList
-                    ? firstList
-                          .map((listItem) =>
-                              joinParagraphs(listItem.paragraphs)
-                          )
-                          .filter(Boolean)
-                    : [],
-                cta: buttonLink || first(links) || null,
-                highlighted:
-                    item.pretitle?.toLowerCase().includes("popular") || false,
-            };
-        })
-        .filter((tier) => tier.name);
-}
-
-/**
- * Extract team member data
- * Common pattern: Name, role, bio, image, social links
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @returns {Array} Team members
- */
-function team(parsed) {
-    const items = parsed?.items || [];
-
-    return items
-        .map((item) => ({
-            name: item.title || null,
-            role: item.subtitle || null,
-            department: item.pretitle || null,
-            bio: item.paragraphs || [],
-            image: first(item.imgs)?.url || null,
-            imageAlt: first(item.imgs)?.alt || null,
-            links: item.links || [],
-        }))
-        .filter((member) => member.name);
-}
-
-/**
- * Extract gallery images
- * Common pattern: Collection of images with captions
- *
- * @param {Object} parsed - Parsed content from parseContent()
- * @param {Object} options - Extraction options
- * @param {string} options.source - Source to extract from: 'main', 'items', 'all'
- * @returns {Array} Gallery images
- */
-function gallery(parsed, options = {}) {
-    const { source = "all" } = options;
-    const images = [];
-
-    if (source === "main" || source === "all") {
-        const mainImages = parsed?.imgs || [];
-        images.push(...mainImages);
-    }
-
-    if (source === "items" || source === "all") {
-        const items = parsed?.items || [];
-        items.forEach((item) => {
-            const itemImages = item.imgs || [];
-            images.push(...itemImages);
-        });
-    }
-
-    return images.map((img) => ({
-        url: img.url,
-        alt: img.alt || null,
-        caption: img.caption || null,
-    }));
-}
-
-/**
- * Extract content in legacy Article class format
- * Used for backward compatibility with existing components
- *
- * This extractor transforms the new flat parser output into the nested format
- * used by the legacy Article class, enabling drop-in replacement without
- * breaking existing components.
- *
- * NOTE: Reconstructs deprecated fields (buttons, cards, documents, forms, alignment)
- * from the new consolidated structure for backwards compatibility.
- *
- * @param {Object} parsed - Parsed content from parseContent() (flat structure)
- * @returns {Object} Legacy format { main, items } with nested header/body structure
- *
- * @example
- * const { parseContent, mappers } = require('@uniweb/semantic-parser');
- * const parsed = parseContent(doc);
- * const legacy = mappers.extractors.legacy(parsed);
- * // Returns: { main: { header: {...}, body: {...} }, items: [...] }
- */
-function legacy(parsed) {
-    const transformToNested = (content) => {
-        if (!content) return null;
-
-        let imgs = content.imgs || [];
-        let banner = imgs.filter((item) => {
-            return (item.role = "banner");
-        })?.[0];
-
-        if (!banner) banner = imgs[0];
-
-        // Reconstruct deprecated fields from new structure
-        const links = content.links || [];
-        const buttons = links
-            .filter(l => l.role?.startsWith('button'))
-            .map(l => ({ attrs: l, content: l.label }));
-        const documents = links
-            .filter(l => l.role === 'document')
-            .map(l => ({ title: l.label, href: l.href, coverImg: l.preview }));
-        const plainLinks = links.filter(l => !l.role?.startsWith('button') && l.role !== 'document');
-
-        const cards = content.data?.cards || [];
-        const form = content.data?.form || null;
-        const forms = form ? [form] : [];
-
-        return {
-            header: {
-                title: content.title || "",
-                subtitle: content.subtitle || "",
-                subtitle2: content.subtitle2 || "",
-                pretitle: content.pretitle || "",
-                // Auto-fill description (legacy behavior)
-                description:
-                    content.subtitle2 ||
-                    first(content.paragraphs) ||
-                    "",
-                alignment: "", // Deprecated: always empty
-            },
-            banner,
-            body: {
-                paragraphs: content.paragraphs || [],
-                headings: content.headings || [],
-                imgs,
-                videos: content.videos || [],
-                lists: content.lists || [],
-                links: plainLinks,
-                icons: content.icons || [],
-                buttons,
-                cards,
-                documents,
-                forms,
-                form,
-                quotes: content.quotes || [],
-                properties: content.data || {},
-                propertyBlocks: [],
-            },
-        };
-    };
-
-    return {
-        main: transformToNested(parsed),
-        items: (parsed?.items || []).map(transformToNested),
-    };
-}
-
-export {
-    hero,
-    card,
-    article,
-    stats,
-    navigation,
-    features,
-    testimonial,
-    faq,
-    pricing,
-    team,
-    gallery,
-    legacy,
-};

package/src/mappers/helpers.js

@@ -1,234 +0,0 @@
-/**
- * Helper utilities for content transformation
- */
-
-import { createExcerpt, stripMarkup } from './types.js';
-
-/**
- * Get the first item from an array or return default value
- * @param {Array} arr - Array to get first item from
- * @param {*} defaultValue - Value to return if array is empty or undefined
- * @returns {*} First item or default value
- */
-function first(arr, defaultValue = null) {
-    return arr?.[0] ?? defaultValue;
-}
-
-/**
- * Get the last item from an array or return default value
- * @param {Array} arr - Array to get last item from
- * @param {*} defaultValue - Value to return if array is empty or undefined
- * @returns {*} Last item or default value
- */
-function last(arr, defaultValue = null) {
-    if (!arr || arr.length === 0) return defaultValue;
-    return arr[arr.length - 1];
-}
-
-/**
- * Transform an array using a mapping function
- * @param {Array} arr - Array to transform
- * @param {Function} transform - Transformation function
- * @returns {Array} Transformed array
- */
-function transformArray(arr, transform) {
-    if (!Array.isArray(arr)) return [];
-    return arr.map(transform);
-}
-
-/**
- * Filter array and optionally transform
- * @param {Array} arr - Array to filter
- * @param {Function} predicate - Filter function
- * @param {Function} transform - Optional transformation function
- * @returns {Array} Filtered (and transformed) array
- */
-function filterArray(arr, predicate, transform = null) {
-    if (!Array.isArray(arr)) return [];
-    const filtered = arr.filter(predicate);
-    return transform ? filtered.map(transform) : filtered;
-}
-
-/**
- * Join array of strings with separator
- * @param {Array} arr - Array to join
- * @param {string} separator - Separator string
- * @returns {string} Joined string
- */
-function joinText(arr, separator = ' ') {
-    if (!Array.isArray(arr)) return '';
-    return arr.filter(Boolean).join(separator);
-}
-
-/**
- * Flatten nested array structure
- * @param {Array} arr - Array to flatten
- * @param {number} depth - Depth to flatten (default: 1)
- * @returns {Array} Flattened array
- */
-function flatten(arr, depth = 1) {
-    if (!Array.isArray(arr)) return [];
-    return arr.flat(depth);
-}
-
-/**
- * Check if value exists (not null, undefined, or empty string)
- * @param {*} value - Value to check
- * @returns {boolean} True if value exists
- */
-function exists(value) {
-    return value !== null && value !== undefined && value !== '';
-}
-
-/**
- * Get value with fallback
- * @param {*} value - Primary value
- * @param {*} fallback - Fallback value
- * @returns {*} Value or fallback
- */
-function withDefault(value, fallback) {
-    return exists(value) ? value : fallback;
-}
-
-/**
- * Validate that required fields are present
- * @param {Object} data - Data object to validate
- * @param {Array<string>} required - Array of required field names
- * @returns {Object} Validation result { valid: boolean, missing: Array<string> }
- */
-function validateRequired(data, required) {
-    const missing = required.filter(field => !exists(data[field]));
-    return {
-        valid: missing.length === 0,
-        missing
-    };
-}
-
-/**
- * Pick specific properties from object
- * @param {Object} obj - Source object
- * @param {Array<string>} keys - Keys to pick
- * @returns {Object} Object with only picked keys
- */
-function pick(obj, keys) {
-    if (!obj) return {};
-    return keys.reduce((result, key) => {
-        if (key in obj) {
-            result[key] = obj[key];
-        }
-        return result;
-    }, {});
-}
-
-/**
- * Omit specific properties from object
- * @param {Object} obj - Source object
- * @param {Array<string>} keys - Keys to omit
- * @returns {Object} Object without omitted keys
- */
-function omit(obj, keys) {
-    if (!obj) return {};
-    const result = { ...obj };
-    keys.forEach(key => delete result[key]);
-    return result;
-}
-
-/**
- * Safely access nested property
- * @param {Object} obj - Object to access
- * @param {string} path - Dot-notation path (e.g., 'a.b.c')
- * @param {*} defaultValue - Default value if path doesn't exist
- * @returns {*} Value at path or default
- */
-function get(obj, path, defaultValue = undefined) {
-    if (!obj || !path) return defaultValue;
-
-    const keys = path.split('.');
-    let result = obj;
-
-    for (const key of keys) {
-        if (result === null || result === undefined) {
-            return defaultValue;
-        }
-        result = result[key];
-    }
-
-    return result !== undefined ? result : defaultValue;
-}
-
-/**
- * Compact an array (remove null, undefined, empty string)
- * @param {Array} arr - Array to compact
- * @returns {Array} Compacted array
- */
-function compact(arr) {
-    if (!Array.isArray(arr)) return [];
-    return arr.filter(exists);
-}
-
-/**
- * Create a safe extractor that won't throw on missing data
- * @param {Function} extractFn - Extraction function that might throw
- * @param {*} defaultValue - Default value if extraction fails
- * @returns {Function} Safe extraction function
- */
-function safe(extractFn, defaultValue = null) {
-    return (...args) => {
-        try {
-            return extractFn(...args) ?? defaultValue;
-        } catch (error) {
-            return defaultValue;
-        }
-    };
-}
-
-/**
- * Join paragraphs into a single string
- * @param {Array|string} paragraphs - Array of paragraphs or single paragraph
- * @param {string} separator - Separator to use between paragraphs
- * @returns {string} Joined text
- */
-function joinParagraphs(paragraphs, separator = ' ') {
-    if (!Array.isArray(paragraphs)) return paragraphs || '';
-    return paragraphs.filter(Boolean).join(separator);
-}
-
-/**
- * Create an excerpt from paragraphs
- * @param {Array|string} paragraphs - Array of paragraphs or single paragraph
- * @param {Object} options - Excerpt options (maxLength, boundary, ellipsis)
- * @returns {string} Generated excerpt
- */
-function excerptFromParagraphs(paragraphs, options = {}) {
-    return createExcerpt(paragraphs, options);
-}
-
-/**
- * Count words in text or paragraphs
- * @param {Array|string} text - Text or array of paragraphs
- * @returns {number} Word count
- */
-function countWords(text) {
-    const plain = Array.isArray(text) ? text.join(' ') : text;
-    return stripMarkup(plain).split(/\s+/).filter(Boolean).length;
-}
-
-export {
-    first,
-    last,
-    transformArray,
-    filterArray,
-    joinText,
-    flatten,
-    exists,
-    withDefault,
-    validateRequired,
-    pick,
-    omit,
-    get,
-    compact,
-    safe,
-    joinParagraphs,
-    excerptFromParagraphs,
-    countWords
-};

package/src/mappers/index.js

@@ -1,28 +0,0 @@
-/**
- * Content mapping utilities for transforming parsed content
- * into component-specific formats
- */
-
-import * as helpers from './helpers.js';
-import * as accessor from './accessor.js';
-import * as extractors from './extractors.js';
-import * as types from './types.js';
-
-export {
-    // Helper utilities
-    helpers,
-
-    // Path-based accessor
-    accessor,
-
-    // Common extractors
-    extractors,
-
-    // Type system
-    types
-};
-
-// Re-export all functions for direct access
-export * from './helpers.js';
-export * from './accessor.js';
-export * from './extractors.js';