lib-pixelbuild 0.1.0

package/dist/elements/ElementColWrapper.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+import type { ElementType } from '../types/ElementType.js';
+export declare function ElementColWrapper({ element, children }: {
+    readonly element: ElementType;
+    readonly children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/elements/ElementColWrapper.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Col } from 'react-bootstrap';
+export function ElementColWrapper({ element, children }) {
+    return (_jsx(Col, { xs: element.width.xs, sm: element.width.sm, md: element.width.md, lg: element.width.lg, xl: element.width.xl, style: element.styles, children: children }, element.id));
+}

package/dist/elements/FileElement.d.ts

@@ -0,0 +1,4 @@
+import type { ElementType } from '../types/ElementType.js';
+export declare function FileElement({ element }: {
+    readonly element: ElementType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/elements/FileElement.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DOMPurify from 'dompurify';
+import { ElementColWrapper } from './ElementColWrapper.js';
+export function FileElement({ element }) {
+    return (_jsx(ElementColWrapper, { element: element, children: _jsx("div", { dangerouslySetInnerHTML: { __html: DOMPurify.sanitize(String(element.id)) } }) }));
+}

package/dist/elements/IconElement.d.ts

@@ -0,0 +1,4 @@
+import type { ElementType } from '../types/ElementType.js';
+export declare function IconElement({ element }: {
+    readonly element: ElementType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/elements/IconElement.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import React, { Suspense } from 'react';
+import { ElementColWrapper } from './ElementColWrapper.js';
+export function IconElement({ element }) {
+    const name = String(element.properties.name || '');
+    const LazyIcon = React.lazy(() => import('react-icons/fa').then((module) => {
+        const Icon = module[name];
+        if (!Icon)
+            throw new Error(`Icon '${name}' not found in pack`);
+        return { default: Icon };
+    }));
+    return (_jsx(ElementColWrapper, { element: element, children: _jsx(Suspense, { fallback: null, children: _jsx(LazyIcon, { size: 20, style: element.styles }) }) }));
+}

package/dist/elements/ImageElement.d.ts

@@ -0,0 +1,4 @@
+import type { ElementType } from '../types/ElementType.js';
+export declare function ImageElement({ element }: {
+    readonly element: ElementType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/elements/ImageElement.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ElementColWrapper } from './ElementColWrapper.js';
+export function ImageElement({ element }) {
+    const properties = element.properties;
+    return (_jsx(ElementColWrapper, { element: element, children: _jsx("img", { src: String(properties.src || properties.path || ''), alt: String(properties.alt || properties.title || ''), style: element.styles }) }));
+}

package/dist/elements/InputElement.d.ts

@@ -0,0 +1,4 @@
+import type { ElementType } from '../types/ElementType.js';
+export declare function InputElement({ element }: {
+    readonly element: ElementType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/elements/InputElement.js

@@ -0,0 +1,24 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect } from 'react';
+import { Form } from 'react-bootstrap';
+import InputMask from 'react-input-mask';
+import { ElementColWrapper } from './ElementColWrapper.js';
+import { UseFormStore } from '../stores/UseFormStore.js';
+export function InputElement({ element }) {
+    const properties = element.properties;
+    const hidden = UseFormStore((state) => { var _a; return (_a = state.elements[element.id]) === null || _a === void 0 ? void 0 : _a.hidden; });
+    const error = UseFormStore((state) => { var _a; return (_a = state.elements[element.id]) === null || _a === void 0 ? void 0 : _a.error; });
+    const errorMessage = UseFormStore((state) => { var _a; return (_a = state.elements[element.id]) === null || _a === void 0 ? void 0 : _a.errorMessage; });
+    const registerElement = UseFormStore((state) => state.registerElement);
+    const validateFormData = UseFormStore((state) => state.validateFormData);
+    useEffect(() => {
+        registerElement(element.id, properties.componentId, {
+            name: String(properties.name || ''),
+            type: 'input',
+            inputValidateId: properties.inputValidateId
+        });
+    }, [element.id, properties.name, properties.inputValidateId, registerElement]);
+    if (hidden)
+        return null;
+    return (_jsx(ElementColWrapper, { element: element, children: _jsxs(Form.Group, { className: "mb-3", controlId: String(properties.name || ''), children: [_jsx(Form.Label, { children: String(properties.title || '') }), _jsx(Form.Control, { as: InputMask, mask: String(properties.mask || ''), onChange: (e) => UseFormStore.getState().setElementState(element.id, { value: e.target.value }), onBlur: (e) => validateFormData(properties.inputValidateId, element.id, e.target.value), required: Boolean(properties.required), name: String(properties.name || ''), placeholder: String(properties.placeholder || ''), isInvalid: !!error, style: element.styles }), _jsx(Form.Control.Feedback, { type: "invalid", children: errorMessage })] }) }));
+}

package/dist/elements/LinkElement.d.ts

@@ -0,0 +1,4 @@
+import type { ElementType } from '../types/ElementType.js';
+export declare function LinkElement({ element }: {
+    readonly element: ElementType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/elements/LinkElement.js

@@ -0,0 +1,6 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ElementColWrapper } from './ElementColWrapper.js';
+export function LinkElement({ element }) {
+    const properties = element.properties;
+    return (_jsx(ElementColWrapper, { element: element, children: _jsx("a", { href: String(properties.href || properties.path || '#'), target: String(properties.target || '_self'), rel: "noopener noreferrer", style: element.styles, children: String(properties.text || properties.title || '') }) }));
+}

package/dist/elements/TextElement.d.ts

@@ -0,0 +1,4 @@
+import type { ElementType } from '../types/ElementType.js';
+export declare function TextElement({ element }: {
+    readonly element: ElementType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/elements/TextElement.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import DOMPurify from 'dompurify';
+import { ElementColWrapper } from './ElementColWrapper.js';
+export function TextElement({ element }) {
+    const properties = element.properties;
+    const text = String(properties.text || properties.title || properties.message || '');
+    if (element.elementType === 'title') {
+        const tag = String(properties.tag || 'h2');
+        const TitleTag = tag;
+        return (_jsx(ElementColWrapper, { element: element, children: _jsx(TitleTag, { style: element.styles, children: text }) }));
+    }
+    return (_jsx(ElementColWrapper, { element: element, children: _jsx("div", { dangerouslySetInnerHTML: { __html: DOMPurify.sanitize(text) }, style: element.styles }) }));
+}

package/dist/factories/ButtonActionFactory.d.ts

@@ -0,0 +1,5 @@
+import type { FormFieldsType } from '../types/FormFieldsType.js';
+import type { MailBodyType } from '../types/MailBodyType.js';
+export declare class ButtonActionFactory {
+    build(actionId: number, data: FormFieldsType[]): Promise<MailBodyType | boolean>;
+}

package/dist/factories/ButtonActionFactory.js

@@ -0,0 +1,13 @@
+import { EmailService } from '../services/EmailService.js';
+import { ButtonActionEnum } from '../constants/ButtonActionEnum.js';
+export class ButtonActionFactory {
+    async build(actionId, data) {
+        const emailService = new EmailService('https://api.example.com');
+        switch (actionId) {
+            case ButtonActionEnum.SendMail:
+                return emailService.sendMail(data);
+            default:
+                throw new Error('Invalid button action: ' + actionId);
+        }
+    }
+}

package/dist/factories/ComponentFactory.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { ComponentType } from '../types/ComponentType.js';
+export declare class ComponentFactory {
+    build(component: ComponentType): React.ReactElement | null;
+}

package/dist/factories/ComponentFactory.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ComponentTypeEnum } from '../constants/ComponentEnum.js';
+import { TextComponent } from '../components/TextComponent.js';
+import { ListComponent } from '../components/ListComponent.js';
+import { CarouselComponent } from '../components/CarouselComponent.js';
+import { FormComponent } from '../components/FormComponent.js';
+import { SliderComponent } from '../components/SliderComponent.js';
+import { CardComponent } from '../components/CardComponent.js';
+import { MapComponent } from '../components/MapComponent.js';
+export class ComponentFactory {
+    build(component) {
+        switch (component.componentType) {
+            case ComponentTypeEnum.Text:
+            case ComponentTypeEnum.TextWithImage:
+            case ComponentTypeEnum.HeroBanner:
+                return _jsx(TextComponent, { component: component }, component.id);
+            case ComponentTypeEnum.List:
+                return _jsx(ListComponent, { component: component }, component.id);
+            case ComponentTypeEnum.Slider:
+            case ComponentTypeEnum.Gallery:
+            case ComponentTypeEnum.Testimonials:
+                return _jsx(SliderComponent, { component: component }, component.id);
+            case ComponentTypeEnum.Form:
+                return _jsx(FormComponent, { component: component }, component.id);
+            case ComponentTypeEnum.Card:
+            case ComponentTypeEnum.Faq:
+                return _jsx(CardComponent, { component: component }, component.id);
+            case ComponentTypeEnum.Image:
+                return _jsx(CarouselComponent, { component: component }, component.id);
+            case ComponentTypeEnum.Map:
+                return _jsx(MapComponent, { component: component }, component.id);
+            default:
+                throw new Error('Invalid component type: ' + component.componentType);
+        }
+    }
+}

package/dist/factories/ElementFactory.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { ElementType } from '../types/ElementType.js';
+export declare class ElementFactory {
+    build(element: ElementType): React.ReactElement | null;
+}

package/dist/factories/ElementFactory.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ElementTypeEnum } from '../constants/ElementEnum.js';
+import { TextElement } from '../elements/TextElement.js';
+import { ImageElement } from '../elements/ImageElement.js';
+import { InputElement } from '../elements/InputElement.js';
+import { IconElement } from '../elements/IconElement.js';
+import { ButtonElement } from '../elements/ButtonElement.js';
+import { FileElement } from '../elements/FileElement.js';
+import { AlertElement } from '../elements/AlertElement.js';
+import { LinkElement } from '../elements/LinkElement.js';
+export class ElementFactory {
+    build(element) {
+        switch (element.elementType) {
+            case ElementTypeEnum.Text:
+            case ElementTypeEnum.Textarea:
+            case ElementTypeEnum.Title:
+                return _jsx(TextElement, { element: element }, element.id);
+            case ElementTypeEnum.Image:
+            case ElementTypeEnum.Video:
+                return _jsx(ImageElement, { element: element }, element.id);
+            case ElementTypeEnum.Input:
+            case ElementTypeEnum.Select:
+            case ElementTypeEnum.Checkbox:
+            case ElementTypeEnum.Radio:
+                return _jsx(InputElement, { element: element }, element.id);
+            case ElementTypeEnum.Icon:
+                return _jsx(IconElement, { element: element }, element.id);
+            case ElementTypeEnum.Button:
+                return _jsx(ButtonElement, { element: element }, element.id);
+            case ElementTypeEnum.File:
+                return _jsx(FileElement, { element: element }, element.id);
+            case ElementTypeEnum.Alert:
+                return _jsx(AlertElement, { element: element }, element.id);
+            case ElementTypeEnum.Link:
+                return _jsx(LinkElement, { element: element }, element.id);
+            case ElementTypeEnum.Divider:
+                return _jsx("hr", { style: element.styles }, element.id);
+            default:
+                throw new Error('Invalid element type: ' + element.elementType);
+        }
+    }
+}

package/dist/factories/InputValidateFactory.d.ts

@@ -0,0 +1,9 @@
+type ValidationResult = {
+    success: boolean;
+    message?: string;
+    [key: string]: string | boolean;
+};
+export declare class InputValidateFactory {
+    build(input_validate_type: number, value: string): ValidationResult;
+}
+export {};

package/dist/factories/InputValidateFactory.js

@@ -0,0 +1,21 @@
+import { InputValidateService } from '../services/InputValidateService.js';
+import { InputValidateEnum } from '../constants/InputValidateEnum.js';
+export class InputValidateFactory {
+    build(input_validate_type, value) {
+        const inputValidateService = new InputValidateService();
+        switch (input_validate_type) {
+            case InputValidateEnum.Name:
+                return inputValidateService.nameValidation(value);
+            case InputValidateEnum.Email:
+                return inputValidateService.emailValidation(value);
+            case InputValidateEnum.Cpf:
+                return inputValidateService.cpfValidation(value);
+            case InputValidateEnum.Phone:
+                return inputValidateService.phoneValidation(value);
+            case InputValidateEnum.BirthDate:
+                return inputValidateService.birthDateValidation(value);
+            default:
+                throw new Error('Input validate not found: ' + input_validate_type);
+        }
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,27 @@
+export type { RawWebsiteType } from './types/RawWebsiteType.js';
+export type { WebsiteType } from './types/WebsiteType.js';
+export type { PageType } from './types/PageType.js';
+export type { SectionType } from './types/SectionType.js';
+export type { SectionColumnType } from './types/SectionColumnType.js';
+export type { ColumnWidthType } from './types/ColumnWidthType.js';
+export type { ComponentType } from './types/ComponentType.js';
+export type { ElementType } from './types/ElementType.js';
+export type { PropertiesType } from './types/PropertiesType.js';
+export type { StylesType } from './types/StylesType.js';
+export type { UserType } from './types/UserType.js';
+export type { AuthenticateResponseType } from './types/AuthenticateResponseType.js';
+export { Header } from './layouts/Header.js';
+export { Footer } from './layouts/Footer.js';
+export { SiteLayout } from './layouts/SiteLayout.js';
+export { PageBuilder } from './builders/PageBuilder.js';
+export { SectionRenderer } from './renderers/SectionRenderer.js';
+export { LoadingComponent } from './components/LoadingComponent.js';
+export { ComponentFactory } from './factories/ComponentFactory.js';
+export { ElementFactory } from './factories/ElementFactory.js';
+export { ComponentTypeEnum } from './constants/ComponentEnum.js';
+export { ElementTypeEnum } from './constants/ElementEnum.js';
+export { ApiService } from './services/ApiService.js';
+export { analyticsService } from './services/AnalyticsService.js';
+export { CacheService } from './services/CacheService.js';
+export { ConstructorService } from './services/ConstructorService.js';
+export { EmailService } from './services/EmailService.js';

package/dist/index.js

@@ -0,0 +1,15 @@
+export { Header } from './layouts/Header.js';
+export { Footer } from './layouts/Footer.js';
+export { SiteLayout } from './layouts/SiteLayout.js';
+export { PageBuilder } from './builders/PageBuilder.js';
+export { SectionRenderer } from './renderers/SectionRenderer.js';
+export { LoadingComponent } from './components/LoadingComponent.js';
+export { ComponentFactory } from './factories/ComponentFactory.js';
+export { ElementFactory } from './factories/ElementFactory.js';
+export { ComponentTypeEnum } from './constants/ComponentEnum.js';
+export { ElementTypeEnum } from './constants/ElementEnum.js';
+export { ApiService } from './services/ApiService.js';
+export { analyticsService } from './services/AnalyticsService.js';
+export { CacheService } from './services/CacheService.js';
+export { ConstructorService } from './services/ConstructorService.js';
+export { EmailService } from './services/EmailService.js';

package/dist/layouts/Footer.d.ts

@@ -0,0 +1,4 @@
+import { WebsiteType } from '../types/WebsiteType.js';
+export declare function Footer({ website }: {
+    readonly website: WebsiteType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/layouts/Footer.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import DOMPurify from 'dompurify';
+import { Container, Row, Col } from 'react-bootstrap';
+import { SocialIconsComponent } from '../components/SocialIconsComponent.js';
+export function Footer({ website }) {
+    var _a;
+    const social = (_a = website.properties) === null || _a === void 0 ? void 0 : _a.social;
+    const footer = website.footer.properties;
+    const styles = website.footer.styles;
+    return (_jsx(Container, { fluid: styles.fluid || undefined, style: { backgroundColor: styles.backgroundColor }, children: _jsxs(Row, { id: 'footer', style: styles, children: [_jsx(Col, { xs: 12, sm: 12, md: 12, lg: 12, className: "d-flex justify-content-center", style: { marginBottom: '30px' }, children: social && (_jsx(SocialIconsComponent, { social: social })) }), _jsx(Col, { xs: 12, sm: 12, md: 12, lg: 12, className: "d-flex flex-column align-items-center", style: { padding: '20px' }, dangerouslySetInnerHTML: { __html: DOMPurify.sanitize(footer.text1) } }), _jsx(Col, { xs: 12, sm: 12, md: 12, lg: 12, className: "d-flex flex-column align-items-center", style: { padding: '20px' }, dangerouslySetInnerHTML: { __html: DOMPurify.sanitize(footer.text2) } }), _jsx(Col, { xs: 12, sm: 12, md: 12, lg: 12, className: "d-flex justify-content-center", dangerouslySetInnerHTML: { __html: DOMPurify.sanitize(footer.text3) } }), _jsxs(Col, { xs: 12, sm: 12, md: 12, lg: 12, children: [_jsx("hr", { className: "footer-divider" }), _jsxs("p", { className: "text-center mb-0", children: ["\u00A9 ", new Date().getFullYear(), " ", website.name] })] })] }) }));
+}

package/dist/layouts/Header.d.ts

@@ -0,0 +1,4 @@
+import type { WebsiteType } from '../types/WebsiteType.js';
+export declare function Header({ website }: {
+    readonly website: WebsiteType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/layouts/Header.js

@@ -0,0 +1,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Container, Row, Col } from 'react-bootstrap';
+export function Header({ website }) {
+    const headerProperties = website.header.properties;
+    const headerStyles = website.header.styles;
+    const domain = website.domain.replaceAll('.', '');
+    return (_jsx(Container, { fluid: headerStyles.fluid || undefined, style: { backgroundColor: headerStyles.backgroundColor }, children: _jsxs(Row, { id: "header", children: [_jsx(Col, { xs: 3, md: 3, lg: 3, style: Object.assign({ display: headerProperties.showLogo ? 'block' : 'none' }, headerStyles), children: _jsx("img", { src: `https://noisdev-website-images.s3.sa-east-1.amazonaws.com/${domain}/${website.logo}`, width: "200", className: "d-inline-block align-top", alt: "Logo", style: { textAlign: headerProperties.logoAlign } }) }), _jsx(Col, { lg: 2, children: "Social Icons" }), _jsx(Col, { lg: 3, children: "Email" }), _jsx(Col, { lg: 2, children: "Liga\u00E7\u00F5es" }), _jsx(Col, { lg: 2, children: "Localiza\u00E7\u00E3o" })] }) }));
+}

package/dist/layouts/Menu.d.ts

@@ -0,0 +1,5 @@
+import type { PageType } from '../types/PageType.js';
+export declare function Menu({ page, websitePages }: {
+    readonly page?: PageType;
+    readonly websitePages?: PageType[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/layouts/Menu.js

@@ -0,0 +1,34 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Navbar, Nav, Container } from 'react-bootstrap';
+export function Menu({ page, websitePages }) {
+    if (!websitePages || websitePages.length === 0) {
+        return null;
+    }
+    const menuPages = websitePages
+        .filter((p) => p.menu === true)
+        .sort((a, b) => a.menuOrder - b.menuOrder);
+    if (menuPages.length === 0) {
+        return null;
+    }
+    const currentPath = (page === null || page === void 0 ? void 0 : page.path) || '';
+    const isActive = (path) => {
+        if (!currentPath)
+            return false;
+        if (path === '/')
+            return currentPath === '/' || currentPath === '';
+        return currentPath === path || currentPath.startsWith(path + '/');
+    };
+    return (_jsx(Navbar, { expand: "lg", className: "py-3", children: _jsxs(Container, { children: [_jsx(Navbar.Toggle, { "aria-controls": "basic-navbar-nav", className: "menu" }), _jsx(Navbar.Collapse, { id: "basic-navbar-nav", children: _jsx(Nav, { className: "me-auto", children: menuPages.map((p) => {
+                            const active = isActive(p.path);
+                            return (_jsx(Nav.Link, { href: p.path, style: {
+                                    color: active ? '#c0ad5b' : '#a4a4a4',
+                                    fontSize: '0.9rem',
+                                    letterSpacing: '0.05em',
+                                    textTransform: 'uppercase',
+                                    margin: '0 12px',
+                                    paddingBottom: '4px',
+                                    borderBottom: active ? '2px solid #c0ad5b' : '2px solid transparent',
+                                    transition: 'color 0.3s, border-color 0.3s',
+                                }, children: p.title }, p.id));
+                        }) }) })] }) }));
+}

package/dist/layouts/SiteLayout.d.ts

@@ -0,0 +1,4 @@
+import type { WebsiteType } from '../types/WebsiteType.js';
+export declare function SiteLayout({ website }: {
+    readonly website: WebsiteType;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/layouts/SiteLayout.js

@@ -0,0 +1,7 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Outlet } from 'react-router-dom';
+import { Header } from './Header.js';
+import { Footer } from './Footer.js';
+export function SiteLayout({ website }) {
+    return (_jsxs("div", { id: "site-layout", style: { backgroundColor: website.styles.backgroundColor, color: website.styles.color }, children: [_jsx(Header, { website: website }), _jsx(Outlet, {}), _jsx(Footer, { website: website })] }));
+}

package/dist/renderers/SectionRenderer.d.ts

@@ -0,0 +1,4 @@
+import type { SectionType } from '../types/SectionType.js';
+export declare function SectionRenderer({ sections }: {
+    readonly sections: SectionType[];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/renderers/SectionRenderer.js

@@ -0,0 +1,39 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import React from 'react';
+import { Container, Row, Col } from 'react-bootstrap';
+import { ComponentFactory } from '../factories/ComponentFactory.js';
+function colWidthValue(width, offset) {
+    if (width === undefined && offset === undefined)
+        return undefined;
+    if (offset !== undefined) {
+        return { span: width !== null && width !== void 0 ? width : 12, offset };
+    }
+    return width;
+}
+function renderSection(section) {
+    const content = (_jsx(Row, { id: `section-${section.id}`, style: section.sectionType === 'row' ? section.styles : undefined, children: section.columns.map(renderColumn) }));
+    if (section.sectionType === 'container-fluid') {
+        return _jsx(Container, { fluid: true, style: section.styles, children: content });
+    }
+    if (section.sectionType === 'container') {
+        return _jsx(Container, { style: section.styles, children: content });
+    }
+    return content;
+}
+function renderColumn(column) {
+    const componentFactory = new ComponentFactory();
+    return (_jsxs(Col, { id: `column-${column.id}`, xs: colWidthValue(column.width.xs, column.offset.xs), sm: colWidthValue(column.width.sm, column.offset.sm), md: colWidthValue(column.width.md, column.offset.md), lg: colWidthValue(column.width.lg, column.offset.lg), xl: colWidthValue(column.width.xl, column.offset.xl), style: column.styles, children: [column.components
+                .filter((c) => c.enabled)
+                .sort((a, b) => a.sort - b.sort)
+                .map((component) => componentFactory.build(component)), column.childSections
+                .sort((a, b) => a.sort - b.sort)
+                .map((childSection) => renderSection(childSection))] }, column.id));
+}
+export function SectionRenderer({ sections }) {
+    if (!sections || sections.length === 0) {
+        return null;
+    }
+    return (_jsx(_Fragment, { children: sections
+            .sort((a, b) => a.sort - b.sort)
+            .map((section) => (_jsx(React.Fragment, { children: renderSection(section) }, section.id))) }));
+}

package/dist/services/AnalyticsService.d.ts

@@ -0,0 +1,8 @@
+declare class AnalyticsService {
+    private initialized;
+    initialize(trackingId: string): void;
+    pageView(page: string, title: string): void;
+    sendEvent(category: string, action: string, label?: string, value?: number): void;
+}
+export declare const analyticsService: AnalyticsService;
+export {};

package/dist/services/AnalyticsService.js

@@ -0,0 +1,28 @@
+var _a;
+import ReactGAImport from 'react-ga4';
+const ReactGA = (_a = ReactGAImport === null || ReactGAImport === void 0 ? void 0 : ReactGAImport.default) !== null && _a !== void 0 ? _a : ReactGAImport;
+class AnalyticsService {
+    constructor() {
+        this.initialized = false;
+    }
+    initialize(trackingId) {
+        if (!trackingId || this.initialized)
+            return;
+        ReactGA.initialize(trackingId);
+        this.initialized = true;
+    }
+    pageView(page, title) {
+        ReactGA.send({ hitType: "pageview", page: page, title: title });
+    }
+    sendEvent(category, action, label, value) {
+        ReactGA.event({
+            category: category,
+            action: action,
+            label: label,
+            value: value,
+            nonInteraction: true,
+            transport: "xhr",
+        });
+    }
+}
+export const analyticsService = new AnalyticsService();

package/dist/services/ApiService.d.ts

@@ -0,0 +1,5 @@
+import type { RawWebsiteType } from '../types/RawWebsiteType.js';
+declare class ApiService {
+    getStructure(websiteId: number, apiUrl: string): Promise<RawWebsiteType>;
+}
+export { ApiService };

package/dist/services/ApiService.js

@@ -0,0 +1,17 @@
+class ApiService {
+    async getStructure(websiteId, apiUrl) {
+        try {
+            const response = await fetch(`${apiUrl}/website/${websiteId}/structure`);
+            if (!response.ok) {
+                throw new Error(response.status.toString());
+            }
+            const json = await response.json();
+            return json.data;
+        }
+        catch (error) {
+            console.error('Erro ao buscar dados da API:', error);
+            throw new Error(error instanceof Error ? error.message : JSON.stringify(error));
+        }
+    }
+}
+export { ApiService };

package/dist/services/CacheService.d.ts

@@ -0,0 +1,5 @@
+import type { RawWebsiteType } from '../types/RawWebsiteType.js';
+declare class CacheService {
+    getStructure(): RawWebsiteType;
+}
+export { CacheService };

package/dist/services/CacheService.js

@@ -0,0 +1,16 @@
+class CacheService {
+    getStructure() {
+        try {
+            const cachedData = localStorage.getItem('websiteData');
+            if (!cachedData) {
+                throw new Error('Sem dados em cache');
+            }
+            return JSON.parse(cachedData);
+        }
+        catch (error) {
+            console.error('Erro ao buscar dados do cache:', error);
+            throw new Error(error instanceof Error ? error.message : JSON.stringify(error));
+        }
+    }
+}
+export { CacheService };

package/dist/services/ConstructorService.d.ts

@@ -0,0 +1,12 @@
+import type { RawWebsiteType } from '../types/RawWebsiteType.js';
+declare class ConstructorService {
+    fetchWebsiteFromApi(websiteId: number, apiUrl: string): Promise<RawWebsiteType>;
+    fetchWebsiteFromCache(): Promise<RawWebsiteType>;
+    fetchMenu(): Promise<{
+        id: number;
+        name: string;
+        path: string;
+        type: 'link';
+    }[]>;
+}
+export { ConstructorService };

package/dist/services/ConstructorService.js

@@ -0,0 +1,33 @@
+import { ApiService } from './ApiService.js';
+import { CacheService } from './CacheService.js';
+class ConstructorService {
+    async fetchWebsiteFromApi(websiteId, apiUrl) {
+        const apiService = new ApiService();
+        const website = await apiService.getStructure(websiteId, apiUrl);
+        if (!website) {
+            throw new Error('Site não encontrado');
+        }
+        localStorage.setItem('websiteData', JSON.stringify(website));
+        return website;
+    }
+    async fetchWebsiteFromCache() {
+        const cacheService = new CacheService();
+        const website = cacheService.getStructure();
+        if (!website) {
+            throw new Error('Site não encontrado');
+        }
+        return website;
+    }
+    async fetchMenu() {
+        const websiteStructure = await this.fetchWebsiteFromCache();
+        return websiteStructure.pages
+            .filter((page) => page.menu === 1)
+            .map((page) => ({
+            id: page.id,
+            name: page.name,
+            path: page.path,
+            type: 'link'
+        }));
+    }
+}
+export { ConstructorService };

package/dist/services/EmailService.d.ts

@@ -0,0 +1,9 @@
+import type { FormFieldsType } from '../types/FormFieldsType.js';
+import type { MailBodyType } from '../types/MailBodyType.js';
+declare class EmailService {
+    private readonly urlApi;
+    constructor(urlApi: string);
+    sendMail(params: FormFieldsType[]): Promise<boolean>;
+    createBody(params: FormFieldsType[]): MailBodyType;
+}
+export { EmailService };