meno-core 1.0.44 → 1.0.46

package/dist/chunks/{chunk-5TJA272J.js → chunk-C6U5T5S5.js}

@@ -16,10 +16,10 @@ import {
   parseJSON,
   resolveSlugToPageId,
   variableService
-} from "./chunk-3XXLBUYA.js";
+} from "./chunk-77ZB6353.js";
 import {
   configService
-} from "./chunk-YEJVSNVF.js";
+} from "./chunk-ZTKHJQ2Z.js";
 import {
   bundleFile,
   createRuntimeServer,
@@ -29,7 +29,7 @@ import {
   projectPaths,
   resolvePackagePath,
   resolveProjectPath
-} from "./chunk-5Z5VQRTJ.js";
+} from "./chunk-I7YIGZXT.js";
 import {
   fileExists,
   hashContent,
@@ -39,16 +39,16 @@ import {
 } from "./chunk-WQFG7PAH.js";
 import {
   extractStringValue
-} from "./chunk-46AVQA4V.js";
+} from "./chunk-IF3RATBY.js";
 import {
   isPathWithinRoot
-} from "./chunk-S2HXJTAF.js";
+} from "./chunk-KITQJYZV.js";
 import {
   addItemUrls
-} from "./chunk-KPNSCQNA.js";
+} from "./chunk-FED5MME6.js";
 import {
   parseLocaleFromPath
-} from "./chunk-X5SH4HXS.js";
+} from "./chunk-XSWR3QLI.js";
 import {
   API_ROUTES,
   HMR_ROUTE,
@@ -56,7 +56,7 @@ import {
   SERVER_PORT,
   WEBSOCKET_STATES,
   init_constants
-} from "./chunk-BXB6AX76.js";
+} from "./chunk-2QK6U5UK.js";
 
 // lib/server/pageCache.ts
 var PageCache = class {
@@ -3221,4 +3221,4 @@ export {
   createServer,
   FileSystemPageProvider
 };
-//# sourceMappingURL=chunk-5TJA272J.js.map
+//# sourceMappingURL=chunk-C6U5T5S5.js.map

package/dist/chunks/{chunk-KPNSCQNA.js → chunk-FED5MME6.js}

@@ -5,12 +5,13 @@ import {
   convertPxToRem,
   getBreakpointName,
   getBreakpointValues,
+  getScaleMultiplier,
   isI18nValue,
   resolveI18nInProps,
   resolveI18nValue,
   scalePropertyValue,
   shouldConvertProperty
-} from "./chunk-X5SH4HXS.js";
+} from "./chunk-XSWR3QLI.js";
 import {
   isTiptapDocument,
   tiptapToHtml
@@ -18,7 +19,7 @@ import {
 import {
   NODE_TYPE,
   init_constants
-} from "./chunk-BXB6AX76.js";
+} from "./chunk-2QK6U5UK.js";
 import {
   __esm,
   __export,
@@ -32,8 +33,8 @@ var init_schemas = __esm({
   "lib/shared/validation/schemas.ts"() {
     "use strict";
     init_constants();
-    BasePropTypeSchema = z.enum(["string", "select", "boolean", "number", "link", "file", "rich-text"]);
-    PropTypeSchema = z.enum(["string", "select", "boolean", "number", "link", "file", "rich-text", "list"]);
+    BasePropTypeSchema = z.enum(["string", "select", "boolean", "number", "link", "file", "rich-text", "embed"]);
+    PropTypeSchema = z.enum(["string", "select", "boolean", "number", "link", "file", "rich-text", "embed", "list"]);
     BasePropDefinitionSchema = z.object({
       type: BasePropTypeSchema,
       default: z.union([z.string(), z.number(), z.boolean(), z.object({ href: z.string(), target: z.string().optional() })]).optional(),
@@ -2278,10 +2279,9 @@ function mergeResponsiveStyles(responsiveStyle, strategy = "all", viewportWidth,
       return merged;
     }
     const breakpointEntries = Object.entries(breakpointValues);
-    breakpointEntries.sort((a, b) => a[1] - b[1]);
-    const activeBreakpointValue = breakpointValues[activeBreakpoint];
+    breakpointEntries.sort((a, b) => b[1] - a[1]);
     for (const [name, value] of breakpointEntries) {
-      if (value <= activeBreakpointValue && responsiveStyle[name]) {
+      if (viewportWidth <= value && responsiveStyle[name]) {
         Object.assign(merged, responsiveStyle[name]);
       }
     }
@@ -2397,6 +2397,25 @@ function isLikelyComponentTag(tag) {
 function isSlotMarker(node) {
   return node?.type === NODE_TYPE.SLOT;
 }
+function componentHasSlot(def) {
+  const structure = def?.component?.structure;
+  if (!structure) return false;
+  return structureContainsSlot(structure);
+}
+function structureContainsSlot(node) {
+  if (node == null) return false;
+  if (Array.isArray(node)) {
+    for (const item of node) {
+      if (structureContainsSlot(item)) return true;
+    }
+    return false;
+  }
+  if (typeof node !== "object") return false;
+  const obj = node;
+  if (obj.type === NODE_TYPE.SLOT) return true;
+  if (obj.children !== void 0) return structureContainsSlot(obj.children);
+  return false;
+}
 function isEmbedNode(node) {
   return node?.type === NODE_TYPE.EMBED;
 }
@@ -2601,6 +2620,10 @@ function validateSingleProp(propName, propDef, value) {
       coercedValue = value;
       typeValid = typeof value === "string";
       break;
+    case "embed":
+      coercedValue = value;
+      typeValid = typeof value === "string";
+      break;
     case "list":
       coercedValue = value;
       typeValid = Array.isArray(value) || isI18nValue(value);
@@ -3242,7 +3265,16 @@ function propertyValueToClass(prop, value) {
     registerDynamicStyle(className2, cssProperty, value);
     return className2;
   }
-  const stringValue = String(value);
+  let stringValue = String(value);
+  if (prop === "fontFamily") {
+    stringValue = stringValue.split(",").map((font) => {
+      const trimmed = font.trim();
+      if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        return trimmed.slice(1, -1);
+      }
+      return trimmed;
+    }).join(", ");
+  }
   let className = null;
   if (specialValueMappings[prop]) {
     const mapping = specialValueMappings[prop];
@@ -3793,6 +3825,170 @@ function isCurrentLink(href, currentPagePath) {
   return normalizePath(href) === normalizePath(currentPagePath);
 }
 
+// lib/shared/cssNamedColors.ts
+var CSS_NAMED_COLORS = /* @__PURE__ */ new Set([
+  // CSS Level 4 named colors
+  "aliceblue",
+  "antiquewhite",
+  "aqua",
+  "aquamarine",
+  "azure",
+  "beige",
+  "bisque",
+  "black",
+  "blanchedalmond",
+  "blue",
+  "blueviolet",
+  "brown",
+  "burlywood",
+  "cadetblue",
+  "chartreuse",
+  "chocolate",
+  "coral",
+  "cornflowerblue",
+  "cornsilk",
+  "crimson",
+  "cyan",
+  "darkblue",
+  "darkcyan",
+  "darkgoldenrod",
+  "darkgray",
+  "darkgreen",
+  "darkgrey",
+  "darkkhaki",
+  "darkmagenta",
+  "darkolivegreen",
+  "darkorange",
+  "darkorchid",
+  "darkred",
+  "darksalmon",
+  "darkseagreen",
+  "darkslateblue",
+  "darkslategray",
+  "darkslategrey",
+  "darkturquoise",
+  "darkviolet",
+  "deeppink",
+  "deepskyblue",
+  "dimgray",
+  "dimgrey",
+  "dodgerblue",
+  "firebrick",
+  "floralwhite",
+  "forestgreen",
+  "fuchsia",
+  "gainsboro",
+  "ghostwhite",
+  "gold",
+  "goldenrod",
+  "gray",
+  "green",
+  "greenyellow",
+  "grey",
+  "honeydew",
+  "hotpink",
+  "indianred",
+  "indigo",
+  "ivory",
+  "khaki",
+  "lavender",
+  "lavenderblush",
+  "lawngreen",
+  "lemonchiffon",
+  "lightblue",
+  "lightcoral",
+  "lightcyan",
+  "lightgoldenrodyellow",
+  "lightgray",
+  "lightgreen",
+  "lightgrey",
+  "lightpink",
+  "lightsalmon",
+  "lightseagreen",
+  "lightskyblue",
+  "lightslategray",
+  "lightslategrey",
+  "lightsteelblue",
+  "lightyellow",
+  "lime",
+  "limegreen",
+  "linen",
+  "magenta",
+  "maroon",
+  "mediumaquamarine",
+  "mediumblue",
+  "mediumorchid",
+  "mediumpurple",
+  "mediumseagreen",
+  "mediumslateblue",
+  "mediumspringgreen",
+  "mediumturquoise",
+  "mediumvioletred",
+  "midnightblue",
+  "mintcream",
+  "mistyrose",
+  "moccasin",
+  "navajowhite",
+  "navy",
+  "oldlace",
+  "olive",
+  "olivedrab",
+  "orange",
+  "orangered",
+  "orchid",
+  "palegoldenrod",
+  "palegreen",
+  "paleturquoise",
+  "palevioletred",
+  "papayawhip",
+  "peachpuff",
+  "peru",
+  "pink",
+  "plum",
+  "powderblue",
+  "purple",
+  "rebeccapurple",
+  "red",
+  "rosybrown",
+  "royalblue",
+  "saddlebrown",
+  "salmon",
+  "sandybrown",
+  "seagreen",
+  "seashell",
+  "sienna",
+  "silver",
+  "skyblue",
+  "slateblue",
+  "slategray",
+  "slategrey",
+  "snow",
+  "springgreen",
+  "steelblue",
+  "tan",
+  "teal",
+  "thistle",
+  "tomato",
+  "turquoise",
+  "violet",
+  "wheat",
+  "white",
+  "whitesmoke",
+  "yellow",
+  "yellowgreen",
+  // CSS color keywords
+  "transparent",
+  "currentcolor",
+  // CSS-wide keywords (should never be wrapped in var())
+  "inherit",
+  "initial",
+  "unset",
+  "revert"
+]);
+function isCssNamedColor(value) {
+  return CSS_NAMED_COLORS.has(value.toLowerCase());
+}
+
 // lib/shared/cssGeneration.ts
 var SORTED_PREFIXES = Object.keys(prefixToCSSProperty).sort((a, b) => b.length - a.length);
 var cssPropertyOrderMap = (() => {
@@ -3837,7 +4033,18 @@ var AUTO_RESPONSIVE_TYPE_MAP = {
   "font-size": "fontSize",
   "gap": "gap",
   "row-gap": "gap",
-  "column-gap": "gap"
+  "column-gap": "gap",
+  "border-radius": "borderRadius",
+  "border-top-left-radius": "borderRadius",
+  "border-top-right-radius": "borderRadius",
+  "border-bottom-left-radius": "borderRadius",
+  "border-bottom-right-radius": "borderRadius",
+  "width": "size",
+  "height": "size",
+  "max-width": "size",
+  "max-height": "size",
+  "min-width": "size",
+  "min-height": "size"
 };
 function escapeCSSClassName(className) {
   return className.replace(/[.#[\](){};<>+~:,%\/\s]/g, "\\$&");
@@ -4038,6 +4245,9 @@ function generateRuleForClass(className) {
   }
   if (prefix === "bgc" || prefix === "bg" || prefix === "c" || prefix === "bc") {
     if (!value.startsWith("#") && !value.includes("rgb") && !value.includes("px")) {
+      if (isCssNamedColor(value)) {
+        return `${cssProp}: ${value};`;
+      }
       return `${cssProp}: var(--${value});`;
     }
   }
@@ -4322,12 +4532,16 @@ function styleObjectToCSS(style) {
   }
   return declarations.join("; ");
 }
-function generateInteractiveCSS(elementClass, interactiveStyles, breakpoints = DEFAULT_BREAKPOINTS, remConfig) {
+function generateInteractiveCSS(elementClass, interactiveStyles, breakpoints = DEFAULT_BREAKPOINTS, remConfig, responsiveScales) {
   const css = [];
   const breakpointValues = getBreakpointValues(breakpoints);
+  const scalingEnabled = responsiveScales?.enabled === true;
   for (const rule of interactiveStyles) {
     const { prefix, postfix, style } = rule;
     const fullSelector = `${prefix || ""}.${elementClass}${postfix || ""}`;
+    const sortedBreakpoints = Object.entries(breakpointValues).sort(
+      ([, a], [, b]) => b - a
+    );
     if (isResponsiveStyle2(style)) {
       const responsive = style;
       if (responsive.base && Object.keys(responsive.base).length > 0) {
@@ -4336,13 +4550,25 @@ function generateInteractiveCSS(elementClass, interactiveStyles, breakpoints = D
           css.push(`${fullSelector} { ${properties}; }`);
         }
       }
-      const sortedBreakpoints = Object.entries(breakpointValues).sort(
-        ([, a], [, b]) => b - a
-      );
       for (const [breakpointName, breakpointValue] of sortedBreakpoints) {
-        const breakpointStyles = responsive[breakpointName];
-        if (breakpointStyles && Object.keys(breakpointStyles).length > 0) {
-          const properties = applyRemConversion(styleObjectToCSS(breakpointStyles), remConfig);
+        const explicit = responsive[breakpointName];
+        let merged = null;
+        if (explicit && Object.keys(explicit).length > 0) {
+          merged = { ...explicit };
+        }
+        if (scalingEnabled && responsive.base) {
+          const scaled = scaleStyleForBreakpoint(
+            responsive.base,
+            responsiveScales,
+            breakpointName,
+            new Set(Object.keys(explicit ?? {}))
+          );
+          if (Object.keys(scaled).length > 0) {
+            merged = { ...merged ?? {}, ...scaled };
+          }
+        }
+        if (merged && Object.keys(merged).length > 0) {
+          const properties = applyRemConversion(styleObjectToCSS(merged), remConfig);
           if (properties) {
             css.push(
               `@media (max-width: ${breakpointValue}px) { ${fullSelector} { ${properties}; } }`
@@ -4357,15 +4583,52 @@ function generateInteractiveCSS(elementClass, interactiveStyles, breakpoints = D
         if (properties) {
           css.push(`${fullSelector} { ${properties}; }`);
         }
+        if (scalingEnabled) {
+          for (const [breakpointName, breakpointValue] of sortedBreakpoints) {
+            const scaled = scaleStyleForBreakpoint(
+              flatStyle,
+              responsiveScales,
+              breakpointName,
+              /* @__PURE__ */ new Set()
+            );
+            if (Object.keys(scaled).length === 0) continue;
+            const scaledProps = applyRemConversion(styleObjectToCSS(scaled), remConfig);
+            if (!scaledProps) continue;
+            css.push(
+              `@media (max-width: ${breakpointValue}px) { ${fullSelector} { ${scaledProps}; } }`
+            );
+          }
+        }
       }
     }
   }
   return css.join("\n");
 }
-function generateAllInteractiveCSS(interactiveStylesMap, breakpoints = DEFAULT_BREAKPOINTS, remConfig) {
+function scaleStyleForBreakpoint(baseStyle, responsiveScales, breakpointName, skipProperties) {
+  const result = {};
+  const baseRef = responsiveScales.baseReference ?? 16;
+  for (const [property, value] of Object.entries(baseStyle)) {
+    if (skipProperties.has(property)) continue;
+    if (typeof value === "object" && value !== null && "_mapping" in value) continue;
+    if (value == null) continue;
+    const strValue = String(value);
+    if (strValue === "") continue;
+    const scale = getScaleMultiplier(
+      responsiveScales,
+      property,
+      breakpointName
+    );
+    if (scale == null) continue;
+    const scaledValue = scalePropertyValue(strValue, baseRef, scale);
+    if (scaledValue == null || scaledValue === strValue) continue;
+    result[property] = scaledValue;
+  }
+  return result;
+}
+function generateAllInteractiveCSS(interactiveStylesMap, breakpoints = DEFAULT_BREAKPOINTS, remConfig, responsiveScales) {
   const cssBlocks = [];
   for (const [elementClass, styles] of interactiveStylesMap) {
-    const css = generateInteractiveCSS(elementClass, styles, breakpoints, remConfig);
+    const css = generateInteractiveCSS(elementClass, styles, breakpoints, remConfig, responsiveScales);
     if (css) {
       cssBlocks.push(css);
     }
@@ -4468,6 +4731,7 @@ export {
   extractNodeProperties,
   isLikelyComponentTag,
   isSlotMarker,
+  componentHasSlot,
   isEmbedNode,
   isLinkNode,
   isLocaleListNode,
@@ -4536,6 +4800,8 @@ export {
   createStyleMappingFromProps,
   normalizePath,
   isCurrentLink,
+  CSS_NAMED_COLORS,
+  isCssNamedColor,
   sortClassesByPropertyOrder,
   generateRuleForClass,
   generateUtilityCSS,
@@ -4544,4 +4810,4 @@ export {
   generateInteractiveCSS,
   generateAllInteractiveCSS
 };
-//# sourceMappingURL=chunk-KPNSCQNA.js.map
+//# sourceMappingURL=chunk-FED5MME6.js.map