@marvalt/dstyler 0.1.3

package/dist/index.esm.js

@@ -0,0 +1,931 @@
+import require$$0, { useEffect } from 'react';
+
+var jsxRuntime = {exports: {}};
+
+var reactJsxRuntime_production = {};
+
+/**
+ * @license React
+ * react-jsx-runtime.production.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactJsxRuntime_production;
+
+function requireReactJsxRuntime_production () {
+	if (hasRequiredReactJsxRuntime_production) return reactJsxRuntime_production;
+	hasRequiredReactJsxRuntime_production = 1;
+	var REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+	  REACT_FRAGMENT_TYPE = Symbol.for("react.fragment");
+	function jsxProd(type, config, maybeKey) {
+	  var key = null;
+	  void 0 !== maybeKey && (key = "" + maybeKey);
+	  void 0 !== config.key && (key = "" + config.key);
+	  if ("key" in config) {
+	    maybeKey = {};
+	    for (var propName in config)
+	      "key" !== propName && (maybeKey[propName] = config[propName]);
+	  } else maybeKey = config;
+	  config = maybeKey.ref;
+	  return {
+	    $$typeof: REACT_ELEMENT_TYPE,
+	    type: type,
+	    key: key,
+	    ref: void 0 !== config ? config : null,
+	    props: maybeKey
+	  };
+	}
+	reactJsxRuntime_production.Fragment = REACT_FRAGMENT_TYPE;
+	reactJsxRuntime_production.jsx = jsxProd;
+	reactJsxRuntime_production.jsxs = jsxProd;
+	return reactJsxRuntime_production;
+}
+
+var reactJsxRuntime_development = {};
+
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+var hasRequiredReactJsxRuntime_development;
+
+function requireReactJsxRuntime_development () {
+	if (hasRequiredReactJsxRuntime_development) return reactJsxRuntime_development;
+	hasRequiredReactJsxRuntime_development = 1;
+	"production" !== process.env.NODE_ENV &&
+	  (function () {
+	    function getComponentNameFromType(type) {
+	      if (null == type) return null;
+	      if ("function" === typeof type)
+	        return type.$$typeof === REACT_CLIENT_REFERENCE
+	          ? null
+	          : type.displayName || type.name || null;
+	      if ("string" === typeof type) return type;
+	      switch (type) {
+	        case REACT_FRAGMENT_TYPE:
+	          return "Fragment";
+	        case REACT_PROFILER_TYPE:
+	          return "Profiler";
+	        case REACT_STRICT_MODE_TYPE:
+	          return "StrictMode";
+	        case REACT_SUSPENSE_TYPE:
+	          return "Suspense";
+	        case REACT_SUSPENSE_LIST_TYPE:
+	          return "SuspenseList";
+	        case REACT_ACTIVITY_TYPE:
+	          return "Activity";
+	      }
+	      if ("object" === typeof type)
+	        switch (
+	          ("number" === typeof type.tag &&
+	            console.error(
+	              "Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."
+	            ),
+	          type.$$typeof)
+	        ) {
+	          case REACT_PORTAL_TYPE:
+	            return "Portal";
+	          case REACT_CONTEXT_TYPE:
+	            return type.displayName || "Context";
+	          case REACT_CONSUMER_TYPE:
+	            return (type._context.displayName || "Context") + ".Consumer";
+	          case REACT_FORWARD_REF_TYPE:
+	            var innerType = type.render;
+	            type = type.displayName;
+	            type ||
+	              ((type = innerType.displayName || innerType.name || ""),
+	              (type = "" !== type ? "ForwardRef(" + type + ")" : "ForwardRef"));
+	            return type;
+	          case REACT_MEMO_TYPE:
+	            return (
+	              (innerType = type.displayName || null),
+	              null !== innerType
+	                ? innerType
+	                : getComponentNameFromType(type.type) || "Memo"
+	            );
+	          case REACT_LAZY_TYPE:
+	            innerType = type._payload;
+	            type = type._init;
+	            try {
+	              return getComponentNameFromType(type(innerType));
+	            } catch (x) {}
+	        }
+	      return null;
+	    }
+	    function testStringCoercion(value) {
+	      return "" + value;
+	    }
+	    function checkKeyStringCoercion(value) {
+	      try {
+	        testStringCoercion(value);
+	        var JSCompiler_inline_result = !1;
+	      } catch (e) {
+	        JSCompiler_inline_result = true;
+	      }
+	      if (JSCompiler_inline_result) {
+	        JSCompiler_inline_result = console;
+	        var JSCompiler_temp_const = JSCompiler_inline_result.error;
+	        var JSCompiler_inline_result$jscomp$0 =
+	          ("function" === typeof Symbol &&
+	            Symbol.toStringTag &&
+	            value[Symbol.toStringTag]) ||
+	          value.constructor.name ||
+	          "Object";
+	        JSCompiler_temp_const.call(
+	          JSCompiler_inline_result,
+	          "The provided key is an unsupported type %s. This value must be coerced to a string before using it here.",
+	          JSCompiler_inline_result$jscomp$0
+	        );
+	        return testStringCoercion(value);
+	      }
+	    }
+	    function getTaskName(type) {
+	      if (type === REACT_FRAGMENT_TYPE) return "<>";
+	      if (
+	        "object" === typeof type &&
+	        null !== type &&
+	        type.$$typeof === REACT_LAZY_TYPE
+	      )
+	        return "<...>";
+	      try {
+	        var name = getComponentNameFromType(type);
+	        return name ? "<" + name + ">" : "<...>";
+	      } catch (x) {
+	        return "<...>";
+	      }
+	    }
+	    function getOwner() {
+	      var dispatcher = ReactSharedInternals.A;
+	      return null === dispatcher ? null : dispatcher.getOwner();
+	    }
+	    function UnknownOwner() {
+	      return Error("react-stack-top-frame");
+	    }
+	    function hasValidKey(config) {
+	      if (hasOwnProperty.call(config, "key")) {
+	        var getter = Object.getOwnPropertyDescriptor(config, "key").get;
+	        if (getter && getter.isReactWarning) return false;
+	      }
+	      return void 0 !== config.key;
+	    }
+	    function defineKeyPropWarningGetter(props, displayName) {
+	      function warnAboutAccessingKey() {
+	        specialPropKeyWarningShown ||
+	          ((specialPropKeyWarningShown = true),
+	          console.error(
+	            "%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://react.dev/link/special-props)",
+	            displayName
+	          ));
+	      }
+	      warnAboutAccessingKey.isReactWarning = true;
+	      Object.defineProperty(props, "key", {
+	        get: warnAboutAccessingKey,
+	        configurable: true
+	      });
+	    }
+	    function elementRefGetterWithDeprecationWarning() {
+	      var componentName = getComponentNameFromType(this.type);
+	      didWarnAboutElementRef[componentName] ||
+	        ((didWarnAboutElementRef[componentName] = true),
+	        console.error(
+	          "Accessing element.ref was removed in React 19. ref is now a regular prop. It will be removed from the JSX Element type in a future release."
+	        ));
+	      componentName = this.props.ref;
+	      return void 0 !== componentName ? componentName : null;
+	    }
+	    function ReactElement(type, key, props, owner, debugStack, debugTask) {
+	      var refProp = props.ref;
+	      type = {
+	        $$typeof: REACT_ELEMENT_TYPE,
+	        type: type,
+	        key: key,
+	        props: props,
+	        _owner: owner
+	      };
+	      null !== (void 0 !== refProp ? refProp : null)
+	        ? Object.defineProperty(type, "ref", {
+	            enumerable: false,
+	            get: elementRefGetterWithDeprecationWarning
+	          })
+	        : Object.defineProperty(type, "ref", { enumerable: false, value: null });
+	      type._store = {};
+	      Object.defineProperty(type._store, "validated", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: 0
+	      });
+	      Object.defineProperty(type, "_debugInfo", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: null
+	      });
+	      Object.defineProperty(type, "_debugStack", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: debugStack
+	      });
+	      Object.defineProperty(type, "_debugTask", {
+	        configurable: false,
+	        enumerable: false,
+	        writable: true,
+	        value: debugTask
+	      });
+	      Object.freeze && (Object.freeze(type.props), Object.freeze(type));
+	      return type;
+	    }
+	    function jsxDEVImpl(
+	      type,
+	      config,
+	      maybeKey,
+	      isStaticChildren,
+	      debugStack,
+	      debugTask
+	    ) {
+	      var children = config.children;
+	      if (void 0 !== children)
+	        if (isStaticChildren)
+	          if (isArrayImpl(children)) {
+	            for (
+	              isStaticChildren = 0;
+	              isStaticChildren < children.length;
+	              isStaticChildren++
+	            )
+	              validateChildKeys(children[isStaticChildren]);
+	            Object.freeze && Object.freeze(children);
+	          } else
+	            console.error(
+	              "React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead."
+	            );
+	        else validateChildKeys(children);
+	      if (hasOwnProperty.call(config, "key")) {
+	        children = getComponentNameFromType(type);
+	        var keys = Object.keys(config).filter(function (k) {
+	          return "key" !== k;
+	        });
+	        isStaticChildren =
+	          0 < keys.length
+	            ? "{key: someKey, " + keys.join(": ..., ") + ": ...}"
+	            : "{key: someKey}";
+	        didWarnAboutKeySpread[children + isStaticChildren] ||
+	          ((keys =
+	            0 < keys.length ? "{" + keys.join(": ..., ") + ": ...}" : "{}"),
+	          console.error(
+	            'A props object containing a "key" prop is being spread into JSX:\n  let props = %s;\n  <%s {...props} />\nReact keys must be passed directly to JSX without using spread:\n  let props = %s;\n  <%s key={someKey} {...props} />',
+	            isStaticChildren,
+	            children,
+	            keys,
+	            children
+	          ),
+	          (didWarnAboutKeySpread[children + isStaticChildren] = true));
+	      }
+	      children = null;
+	      void 0 !== maybeKey &&
+	        (checkKeyStringCoercion(maybeKey), (children = "" + maybeKey));
+	      hasValidKey(config) &&
+	        (checkKeyStringCoercion(config.key), (children = "" + config.key));
+	      if ("key" in config) {
+	        maybeKey = {};
+	        for (var propName in config)
+	          "key" !== propName && (maybeKey[propName] = config[propName]);
+	      } else maybeKey = config;
+	      children &&
+	        defineKeyPropWarningGetter(
+	          maybeKey,
+	          "function" === typeof type
+	            ? type.displayName || type.name || "Unknown"
+	            : type
+	        );
+	      return ReactElement(
+	        type,
+	        children,
+	        maybeKey,
+	        getOwner(),
+	        debugStack,
+	        debugTask
+	      );
+	    }
+	    function validateChildKeys(node) {
+	      isValidElement(node)
+	        ? node._store && (node._store.validated = 1)
+	        : "object" === typeof node &&
+	          null !== node &&
+	          node.$$typeof === REACT_LAZY_TYPE &&
+	          ("fulfilled" === node._payload.status
+	            ? isValidElement(node._payload.value) &&
+	              node._payload.value._store &&
+	              (node._payload.value._store.validated = 1)
+	            : node._store && (node._store.validated = 1));
+	    }
+	    function isValidElement(object) {
+	      return (
+	        "object" === typeof object &&
+	        null !== object &&
+	        object.$$typeof === REACT_ELEMENT_TYPE
+	      );
+	    }
+	    var React = require$$0,
+	      REACT_ELEMENT_TYPE = Symbol.for("react.transitional.element"),
+	      REACT_PORTAL_TYPE = Symbol.for("react.portal"),
+	      REACT_FRAGMENT_TYPE = Symbol.for("react.fragment"),
+	      REACT_STRICT_MODE_TYPE = Symbol.for("react.strict_mode"),
+	      REACT_PROFILER_TYPE = Symbol.for("react.profiler"),
+	      REACT_CONSUMER_TYPE = Symbol.for("react.consumer"),
+	      REACT_CONTEXT_TYPE = Symbol.for("react.context"),
+	      REACT_FORWARD_REF_TYPE = Symbol.for("react.forward_ref"),
+	      REACT_SUSPENSE_TYPE = Symbol.for("react.suspense"),
+	      REACT_SUSPENSE_LIST_TYPE = Symbol.for("react.suspense_list"),
+	      REACT_MEMO_TYPE = Symbol.for("react.memo"),
+	      REACT_LAZY_TYPE = Symbol.for("react.lazy"),
+	      REACT_ACTIVITY_TYPE = Symbol.for("react.activity"),
+	      REACT_CLIENT_REFERENCE = Symbol.for("react.client.reference"),
+	      ReactSharedInternals =
+	        React.__CLIENT_INTERNALS_DO_NOT_USE_OR_WARN_USERS_THEY_CANNOT_UPGRADE,
+	      hasOwnProperty = Object.prototype.hasOwnProperty,
+	      isArrayImpl = Array.isArray,
+	      createTask = console.createTask
+	        ? console.createTask
+	        : function () {
+	            return null;
+	          };
+	    React = {
+	      react_stack_bottom_frame: function (callStackForError) {
+	        return callStackForError();
+	      }
+	    };
+	    var specialPropKeyWarningShown;
+	    var didWarnAboutElementRef = {};
+	    var unknownOwnerDebugStack = React.react_stack_bottom_frame.bind(
+	      React,
+	      UnknownOwner
+	    )();
+	    var unknownOwnerDebugTask = createTask(getTaskName(UnknownOwner));
+	    var didWarnAboutKeySpread = {};
+	    reactJsxRuntime_development.Fragment = REACT_FRAGMENT_TYPE;
+	    reactJsxRuntime_development.jsx = function (type, config, maybeKey) {
+	      var trackActualOwner =
+	        1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+	      return jsxDEVImpl(
+	        type,
+	        config,
+	        maybeKey,
+	        false,
+	        trackActualOwner
+	          ? Error("react-stack-top-frame")
+	          : unknownOwnerDebugStack,
+	        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+	      );
+	    };
+	    reactJsxRuntime_development.jsxs = function (type, config, maybeKey) {
+	      var trackActualOwner =
+	        1e4 > ReactSharedInternals.recentlyCreatedOwnerStacks++;
+	      return jsxDEVImpl(
+	        type,
+	        config,
+	        maybeKey,
+	        true,
+	        trackActualOwner
+	          ? Error("react-stack-top-frame")
+	          : unknownOwnerDebugStack,
+	        trackActualOwner ? createTask(getTaskName(type)) : unknownOwnerDebugTask
+	      );
+	    };
+	  })();
+	return reactJsxRuntime_development;
+}
+
+if (process.env.NODE_ENV === 'production') {
+  jsxRuntime.exports = requireReactJsxRuntime_production();
+} else {
+  jsxRuntime.exports = requireReactJsxRuntime_development();
+}
+
+var jsxRuntimeExports = jsxRuntime.exports;
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ */
+const defaultTokens = {
+    colors: {
+        primary: '#1a73e8',
+        secondary: '#34a853',
+        background: '#ffffff',
+        text: '#222222',
+        default: '#ffffff',
+        alternate: '#f5f5f5',
+        highlight: '#e8f0fe',
+    },
+    spacing: {
+        sm: 8,
+        md: 16,
+        lg: 32,
+        xl: 64,
+    },
+    typography: {
+        body: 'Inter, sans-serif',
+        heading: 'Inter, sans-serif',
+        scale: 1.2,
+    },
+};
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ */
+/**
+ * Convert WordPress theme styles to design tokens
+ */
+function convertWordPressToTokens(wpStyles) {
+    if (!wpStyles) {
+        return defaultTokens;
+    }
+    const tokens = {
+        ...defaultTokens,
+        colors: {
+            ...defaultTokens.colors,
+            ...(wpStyles.colors?.primary && { primary: wpStyles.colors.primary }),
+            ...(wpStyles.colors?.secondary && { secondary: wpStyles.colors.secondary }),
+            ...(wpStyles.colors?.text && { text: wpStyles.colors.text }),
+            ...(wpStyles.colors?.background && {
+                background: wpStyles.colors.background,
+                default: wpStyles.colors.background,
+            }),
+        },
+        typography: {
+            ...defaultTokens.typography,
+            ...(wpStyles.typography?.heading_font_family && {
+                heading: wpStyles.typography.heading_font_family
+            }),
+            ...(wpStyles.typography?.body_font_family && {
+                body: wpStyles.typography.body_font_family
+            }),
+        },
+    };
+    // Generate alternate and highlight colors from primary/background
+    if (tokens.colors.primary && tokens.colors.background) {
+        // Alternate: slightly darker/lighter than background
+        tokens.colors.alternate = adjustBrightness(tokens.colors.background, -0.05);
+        // Highlight: tinted with primary color
+        tokens.colors.highlight = blendColors(tokens.colors.background, tokens.colors.primary, 0.1);
+    }
+    return tokens;
+}
+/**
+ * Adjust brightness of a hex color
+ */
+function adjustBrightness(hex, amount) {
+    const num = parseInt(hex.replace('#', ''), 16);
+    const r = Math.max(0, Math.min(255, ((num >> 16) & 0xff) + (amount * 255)));
+    const g = Math.max(0, Math.min(255, ((num >> 8) & 0xff) + (amount * 255)));
+    const b = Math.max(0, Math.min(255, (num & 0xff) + (amount * 255)));
+    return `#${((r << 16) | (g << 8) | b).toString(16).padStart(6, '0')}`;
+}
+/**
+ * Blend two colors
+ */
+function blendColors(color1, color2, ratio) {
+    const c1 = hexToRgb(color1);
+    const c2 = hexToRgb(color2);
+    if (!c1 || !c2)
+        return color1;
+    const r = Math.round(c1.r + (c2.r - c1.r) * ratio);
+    const g = Math.round(c1.g + (c2.g - c1.g) * ratio);
+    const b = Math.round(c1.b + (c2.b - c1.b) * ratio);
+    return `rgb(${r}, ${g}, ${b})`;
+}
+function hexToRgb(hex) {
+    const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+    return result
+        ? {
+            r: parseInt(result[1], 16),
+            g: parseInt(result[2], 16),
+            b: parseInt(result[3], 16),
+        }
+        : null;
+}
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ */
+/**
+ * Inject CSS variables from design tokens into the document
+ */
+function injectCSSVariables(tokens) {
+    if (typeof document === 'undefined')
+        return;
+    const root = document.documentElement;
+    // Colors
+    root.style.setProperty('--dstyler-color-primary', tokens.colors.primary);
+    root.style.setProperty('--dstyler-color-secondary', tokens.colors.secondary);
+    root.style.setProperty('--dstyler-color-background', tokens.colors.background);
+    root.style.setProperty('--dstyler-color-text', tokens.colors.text);
+    root.style.setProperty('--dstyler-color-default', tokens.colors.default);
+    root.style.setProperty('--dstyler-color-alternate', tokens.colors.alternate);
+    root.style.setProperty('--dstyler-color-highlight', tokens.colors.highlight);
+    // Spacing
+    root.style.setProperty('--dstyler-spacing-sm', `${tokens.spacing.sm}px`);
+    root.style.setProperty('--dstyler-spacing-md', `${tokens.spacing.md}px`);
+    root.style.setProperty('--dstyler-spacing-lg', `${tokens.spacing.lg}px`);
+    root.style.setProperty('--dstyler-spacing-xl', `${tokens.spacing.xl}px`);
+    // Typography
+    root.style.setProperty('--dstyler-font-body', tokens.typography.body);
+    root.style.setProperty('--dstyler-font-heading', tokens.typography.heading);
+    root.style.setProperty('--dstyler-font-scale', tokens.typography.scale.toString());
+}
+
+const ThemeProvider = ({ children, wpStyles }) => {
+    useEffect(() => {
+        const tokens = convertWordPressToTokens(wpStyles);
+        injectCSSVariables(tokens);
+    }, [wpStyles]);
+    return jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: children });
+};
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ */
+/**
+ * Select template component based on section properties
+ */
+function selectTemplate(section) {
+    const block = section.block;
+    const attrs = block.attributes || {};
+    const className = section.customClass?.toLowerCase() || '';
+    // Check for hero/cover blocks
+    if (block.name === 'core/cover') {
+        return 'HeroDefault';
+    }
+    // Check for footer (could be detected by block name or class)
+    if (className.includes('footer') || block.name === 'core/footer') {
+        return 'FooterMinimal';
+    }
+    // Check for wave style
+    if (className.includes('wave') || attrs.style === 'wave') {
+        return 'SectionWave';
+    }
+    // Default section template
+    return 'SectionBase';
+}
+
+const SectionBase = ({ section, children }) => {
+    const style = section.style || 'default';
+    const bgColor = `var(--dstyler-color-${style})`;
+    const className = [
+        'dstyler-section',
+        `dstyler-section-${style}`,
+        section.customClass,
+    ].filter(Boolean).join(' ');
+    return (jsxRuntimeExports.jsx("section", { className: className, id: section.customId, style: {
+            backgroundColor: bgColor,
+            padding: 'var(--dstyler-spacing-xl) var(--dstyler-spacing-md)',
+        }, children: jsxRuntimeExports.jsx("div", { style: {
+                maxWidth: 'var(--dstyler-container-max-width, 1200px)',
+                margin: '0 auto',
+            }, children: children }) }));
+};
+
+const SectionWave = ({ section, children, waveTop = true, waveBottom = true, }) => {
+    const style = section.style || 'default';
+    const bgColor = `var(--dstyler-color-${style})`;
+    const className = [
+        'dstyler-section',
+        'dstyler-section-wave',
+        `dstyler-section-${style}`,
+        section.customClass,
+    ].filter(Boolean).join(' ');
+    // Wave SVG
+    const waveSvg = (jsxRuntimeExports.jsx("svg", { viewBox: "0 0 1440 120", preserveAspectRatio: "none", style: {
+            width: '100%',
+            height: '60px',
+            display: 'block',
+            fill: bgColor,
+        }, children: jsxRuntimeExports.jsx("path", { d: "M0,60 C240,0 480,120 720,60 C960,0 1200,120 1440,60 L1440,120 L0,120 Z" }) }));
+    return (jsxRuntimeExports.jsxs("section", { className: className, id: section.customId, style: {
+            backgroundColor: bgColor,
+            position: 'relative',
+        }, children: [waveTop && (jsxRuntimeExports.jsx("div", { style: { marginTop: '-1px' }, children: waveSvg })), jsxRuntimeExports.jsx("div", { style: {
+                    padding: 'var(--dstyler-spacing-xl) var(--dstyler-spacing-md)',
+                }, children: jsxRuntimeExports.jsx("div", { style: {
+                        maxWidth: 'var(--dstyler-container-max-width, 1200px)',
+                        margin: '0 auto',
+                    }, children: children }) }), waveBottom && (jsxRuntimeExports.jsx("div", { style: { marginBottom: '-1px', transform: 'rotate(180deg)' }, children: waveSvg }))] }));
+};
+
+const HeroDefault = ({ section, children }) => {
+    const style = section.style || 'default';
+    const bgColor = `var(--dstyler-color-${style})`;
+    const className = [
+        'dstyler-hero',
+        'dstyler-hero-default',
+        `dstyler-hero-${style}`,
+        section.customClass,
+    ].filter(Boolean).join(' ');
+    return (jsxRuntimeExports.jsx("section", { className: className, id: section.customId, style: {
+            backgroundColor: bgColor,
+            padding: 'var(--dstyler-spacing-xl) var(--dstyler-spacing-md)',
+            minHeight: '50vh',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+        }, children: jsxRuntimeExports.jsx("div", { style: {
+                maxWidth: 'var(--dstyler-container-max-width, 1200px)',
+                margin: '0 auto',
+                textAlign: 'center',
+            }, children: children }) }));
+};
+
+const FooterMinimal = ({ section, children }) => {
+    const style = section.style || 'default';
+    const bgColor = `var(--dstyler-color-${style})`;
+    const className = [
+        'dstyler-footer',
+        'dstyler-footer-minimal',
+        `dstyler-footer-${style}`,
+        section.customClass,
+    ].filter(Boolean).join(' ');
+    return (jsxRuntimeExports.jsx("footer", { className: className, id: section.customId, style: {
+            backgroundColor: bgColor,
+            padding: 'var(--dstyler-spacing-lg) var(--dstyler-spacing-md)',
+            borderTop: '1px solid var(--dstyler-color-alternate)',
+        }, children: jsxRuntimeExports.jsx("div", { style: {
+                maxWidth: 'var(--dstyler-container-max-width, 1200px)',
+                margin: '0 auto',
+                textAlign: 'center',
+                fontSize: '0.875rem',
+                color: 'var(--dstyler-color-text)',
+            }, children: children }) }));
+};
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ */
+/**
+ * Select block renderer based on block type
+ */
+function selectBlockRenderer(block) {
+    const blockName = block.name;
+    // Map WordPress block types to renderers
+    switch (blockName) {
+        case 'core/paragraph':
+        case 'core/heading':
+            return 'BlockText';
+        case 'core/image':
+        case 'core/gallery':
+            return 'BlockImage';
+        case 'core/button':
+        case 'core/buttons':
+            return 'BlockButton';
+        case 'core/html':
+        case 'core/shortcode':
+            // Check if it's a form shortcode
+            const attrs = block.attributes || {};
+            const content = attrs.content || attrs.html || '';
+            if (content.includes('[gravityform') || content.includes('[mauticform')) {
+                return 'BlockForm';
+            }
+            return 'BlockText';
+        default:
+            return 'BlockText'; // Default fallback
+    }
+}
+
+const BlockText = ({ block, className }) => {
+    const attrs = block.attributes || {};
+    const content = attrs.content || attrs.text || '';
+    const tagName = block.name === 'core/heading'
+        ? `h${attrs.level || 2}`
+        : 'p';
+    const Tag = tagName;
+    const style = {
+        fontFamily: 'var(--dstyler-font-body)',
+        color: 'var(--dstyler-color-text)',
+        marginBottom: 'var(--dstyler-spacing-md)',
+    };
+    if (block.name === 'core/heading') {
+        style.fontFamily = 'var(--dstyler-font-heading)';
+        style.fontSize = `calc(1rem * var(--dstyler-font-scale) * ${attrs.level || 2})`;
+        style.fontWeight = 'bold';
+    }
+    return (jsxRuntimeExports.jsx(Tag, { className: className, style: style, dangerouslySetInnerHTML: { __html: content } }));
+};
+
+const BlockImage = ({ block, className }) => {
+    const attrs = block.attributes || {};
+    const url = attrs.url || attrs.sourceUrl || '';
+    const alt = attrs.alt || attrs.altText || '';
+    const width = attrs.width;
+    const height = attrs.height;
+    if (!url)
+        return null;
+    const style = {
+        maxWidth: '100%',
+        height: 'auto',
+        marginBottom: 'var(--dstyler-spacing-md)',
+        borderRadius: '8px',
+    };
+    return (jsxRuntimeExports.jsx("img", { src: url, alt: alt, width: width, height: height, className: className, style: style, loading: "lazy" }));
+};
+
+const BlockButton = ({ block, className }) => {
+    const attrs = block.attributes || {};
+    const text = attrs.text || attrs.label || 'Button';
+    const url = attrs.url || attrs.linkUrl || '#';
+    const isExternal = typeof window !== 'undefined'
+        ? url.startsWith('http') && !url.includes(window.location.hostname)
+        : url.startsWith('http');
+    const style = {
+        display: 'inline-block',
+        padding: 'var(--dstyler-spacing-md) var(--dstyler-spacing-lg)',
+        backgroundColor: 'var(--dstyler-color-primary)',
+        color: '#ffffff',
+        textDecoration: 'none',
+        borderRadius: '4px',
+        fontWeight: '500',
+        marginBottom: 'var(--dstyler-spacing-md)',
+        transition: 'opacity 0.2s',
+    };
+    return (jsxRuntimeExports.jsx("a", { href: url, target: isExternal ? '_blank' : undefined, rel: isExternal ? 'noopener noreferrer' : undefined, className: className, style: style, onMouseEnter: (e) => {
+            e.currentTarget.style.opacity = '0.9';
+        }, onMouseLeave: (e) => {
+            e.currentTarget.style.opacity = '1';
+        }, children: text }));
+};
+
+const BlockForm = ({ block, className }) => {
+    const attrs = block.attributes || {};
+    const content = attrs.content || attrs.html || '';
+    // For now, just render the HTML content
+    // In the future, this could parse and render using Gravity Forms or Mautic components
+    const style = {
+        marginBottom: 'var(--dstyler-spacing-lg)',
+    };
+    return (jsxRuntimeExports.jsx("div", { className: className, style: style, dangerouslySetInnerHTML: { __html: content } }));
+};
+
+const AutoBlock = ({ block, registry }) => {
+    // If registry is provided, use it for rendering (integrates with wparser)
+    if (registry && registry.renderers[block.name]) {
+        const Renderer = registry.renderers[block.name];
+        return jsxRuntimeExports.jsx(Renderer, { block: block, context: { registry } });
+    }
+    // Otherwise, use dstyler's block renderers
+    const rendererName = selectBlockRenderer(block);
+    switch (rendererName) {
+        case 'BlockText':
+            return jsxRuntimeExports.jsx(BlockText, { block: block });
+        case 'BlockImage':
+            return jsxRuntimeExports.jsx(BlockImage, { block: block });
+        case 'BlockButton':
+            return jsxRuntimeExports.jsx(BlockButton, { block: block });
+        case 'BlockForm':
+            return jsxRuntimeExports.jsx(BlockForm, { block: block });
+        default:
+            // Fallback: render block name or content
+            return (jsxRuntimeExports.jsx("div", { style: { marginBottom: 'var(--dstyler-spacing-md)' }, children: jsxRuntimeExports.jsxs("pre", { style: { fontSize: '0.875rem', color: '#666' }, children: [block.name, ": ", JSON.stringify(block.attributes, null, 2)] }) }));
+    }
+};
+
+const AutoSection = ({ section, registry }) => {
+    const templateName = selectTemplate(section);
+    // Render blocks using AutoBlock or registry
+    const renderBlocks = () => {
+        if (registry) {
+            // Use registry for block rendering (integrates with wparser)
+            return section.blocks.map((block, index) => (jsxRuntimeExports.jsx(AutoBlock, { block: block, registry: registry }, `${block.name}-${index}`)));
+        }
+        // Fallback to simple block rendering
+        return section.blocks.map((block, index) => (jsxRuntimeExports.jsx(AutoBlock, { block: block }, `${block.name}-${index}`)));
+    };
+    // Select template component
+    switch (templateName) {
+        case 'SectionWave': {
+            const className = section.customClass?.toLowerCase() || '';
+            const waveTop = className.includes('wave-top') || !className.includes('wave-bottom');
+            const waveBottom = className.includes('wave-bottom') || !className.includes('wave-top');
+            return (jsxRuntimeExports.jsx(SectionWave, { section: section, waveTop: waveTop, waveBottom: waveBottom, children: renderBlocks() }));
+        }
+        case 'HeroDefault':
+            return (jsxRuntimeExports.jsx(HeroDefault, { section: section, children: renderBlocks() }));
+        case 'FooterMinimal':
+            return (jsxRuntimeExports.jsx(FooterMinimal, { section: section, children: renderBlocks() }));
+        default:
+            return (jsxRuntimeExports.jsx(SectionBase, { section: section, children: renderBlocks() }));
+    }
+};
+
+/**
+ * @license GPL-3.0-or-later
+ *
+ * This file is part of the MarVAlt Open SDK.
+ * Copyright (c) 2025 Vibune Pty Ltd.
+ */
+/**
+ * Detect sections from WordPress blocks
+ * Sections are defined by core/group blocks (with or without alignment)
+ * Sub-sections are core/columns blocks inside groups
+ */
+function detectSections(blocks) {
+    const sections = [];
+    let sectionIndex = 0;
+    for (const block of blocks) {
+        // core/group blocks are sections
+        if (block.name === 'core/group') {
+            const attrs = block.attributes || {};
+            const className = attrs.className;
+            const customId = attrs.id;
+            // Extract blocks from innerBlocks
+            const innerBlocks = block.innerBlocks || [];
+            sections.push({
+                id: `section-${sectionIndex}`,
+                type: 'section',
+                block,
+                blocks: innerBlocks,
+                index: sectionIndex,
+                customClass: className,
+                customId,
+            });
+            sectionIndex++;
+        }
+    }
+    return sections;
+}
+/**
+ * Determine section style based on alternating logic and custom classes
+ * Rules:
+ * - default is always first
+ * - after default follows alternate
+ * - highlight resets - next section is default
+ */
+function determineSectionStyle(section, previousStyle) {
+    const className = section.customClass?.toLowerCase() || '';
+    // Check for custom class overrides first
+    if (className.includes('highlight') || className.includes('highlight-section')) {
+        return 'highlight';
+    }
+    if (className.includes('dark') || className.includes('dark-section')) {
+        return 'alternate';
+    }
+    if (className.includes('default') || className.includes('default-section')) {
+        return 'default';
+    }
+    // Alternating logic
+    if (section.index === 0) {
+        return 'default';
+    }
+    if (previousStyle === 'highlight') {
+        return 'default';
+    }
+    if (previousStyle === 'default') {
+        return 'alternate';
+    }
+    if (previousStyle === 'alternate') {
+        return 'default';
+    }
+    return 'default';
+}
+
+const StyledPage = ({ page, registry }) => {
+    const blocks = page.blocks || [];
+    // Detect sections from blocks
+    const sections = detectSections(blocks);
+    // Apply alternating style logic
+    let previousStyle;
+    const styledSections = sections.map((section) => {
+        const style = determineSectionStyle(section, previousStyle);
+        previousStyle = style;
+        return {
+            ...section,
+            style,
+        };
+    });
+    return (jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: styledSections.map((section) => (jsxRuntimeExports.jsx(AutoSection, { section: section, registry: registry }, section.id))) }));
+};
+
+export { AutoBlock, AutoSection, FooterMinimal, HeroDefault, SectionBase, SectionWave, StyledPage, ThemeProvider, convertWordPressToTokens, defaultTokens, detectSections, determineSectionStyle, injectCSSVariables, selectBlockRenderer, selectTemplate };
+//# sourceMappingURL=index.esm.js.map