meno-core 1.0.21 → 1.0.23

package/lib/shared/richtext/htmlToTiptap.ts

@@ -102,6 +102,9 @@ function isBlockNode(type: string): boolean {
     'tableRow',
     'tableCell',
     'tableHeader',
+    'iframe',
+    'rawHtml',
+    'menoComponent',
   ].includes(type);
 }
 
@@ -169,6 +172,8 @@ function parseNode(node: Node): TiptapNode | TiptapNode[] | null {
       return { type: 'hardBreak' };
     case 'img':
       return parseImage(element);
+    case 'iframe':
+      return parseIframe(element);
     case 'table':
       return parseTable(element);
 
@@ -192,8 +197,19 @@ function parseNode(node: Node): TiptapNode | TiptapNode[] | null {
     case 'span':
       return parseSpan(element);
 
-    // Container elements - just parse children
-    case 'div':
+    // Container elements - check for special data attributes first
+    case 'div': {
+      // Raw HTML block
+      if (element.hasAttribute('data-raw-html')) {
+        return { type: 'rawHtml', attrs: { content: element.innerHTML } };
+      }
+      // Meno component embed
+      if (element.hasAttribute('data-meno-component')) {
+        return parseMenoComponent(element);
+      }
+      // Regular div - parse children
+      return parseChildren(element);
+    }
     case 'article':
     case 'section':
     case 'main':
@@ -343,6 +359,34 @@ function parseImage(element: HTMLElement): TiptapNode {
   return { type: 'image', attrs };
 }
 
+function parseIframe(element: HTMLElement): TiptapNode {
+  const src = element.getAttribute('src') || '';
+  const width = element.getAttribute('width') || '100%';
+  const height = element.getAttribute('height') || '315';
+
+  return {
+    type: 'iframe',
+    attrs: { src, width, height },
+  };
+}
+
+function parseMenoComponent(element: HTMLElement): TiptapNode {
+  const component = element.getAttribute('data-meno-component') || '';
+  let props: Record<string, unknown> = {};
+  const propsStr = element.getAttribute('data-meno-props');
+  if (propsStr) {
+    try {
+      props = JSON.parse(propsStr);
+    } catch {
+      // ignore parse errors
+    }
+  }
+  return {
+    type: 'menoComponent',
+    attrs: { component, props },
+  };
+}
+
 function parseTable(element: HTMLElement): TiptapNode {
   const rows: TiptapNode[] = [];
 

package/lib/shared/richtext/tiptapToHtml.ts

@@ -47,6 +47,9 @@ export const RICH_TEXT_ALLOWED_TAGS = [
   'hr',
   'figure',
   'figcaption',
+  // Embeds
+  'iframe',
+  'div',
 ];
 
 export const RICH_TEXT_ALLOWED_ATTRS = [
@@ -68,6 +71,14 @@ export const RICH_TEXT_ALLOWED_ATTRS = [
   'data-language',
   // Alignment (via style)
   'style',
+  // Iframe attributes
+  'frameborder',
+  'allowfullscreen',
+  'allow',
+  // Raw HTML / Component attributes
+  'data-raw-html',
+  'data-meno-component',
+  'data-meno-props',
 ];
 
 /**
@@ -184,6 +195,15 @@ function renderNode(node: TiptapNode): string {
     case 'tableHeader':
       return renderTableCell(node, 'th');
 
+    case 'iframe':
+      return renderIframe(node);
+
+    case 'rawHtml':
+      return renderRawHtml(node);
+
+    case 'menoComponent':
+      return renderMenoComponent(node);
+
     default:
       // Unknown node type - try to render content
       if (node.content) {
@@ -299,6 +319,51 @@ function renderTableCell(node: TiptapNode, tag: 'td' | 'th'): string {
   return `<${tag}${attrStr}>${content}</${tag}>`;
 }
 
+/**
+ * Render iframe embed
+ */
+function renderIframe(node: TiptapNode): string {
+  const src = node.attrs?.src as string | undefined;
+  if (!src) return '';
+
+  // Only allow https:// URLs for security
+  if (!src.startsWith('https://')) return '';
+
+  const width = (node.attrs?.width as string | undefined) || '100%';
+  const height = (node.attrs?.height as string | undefined) || '315';
+
+  return `<iframe src="${escapeAttr(src)}" width="${escapeAttr(String(width))}" height="${escapeAttr(String(height))}" frameborder="0" allowfullscreen></iframe>`;
+}
+
+/**
+ * Render raw HTML block
+ */
+function renderRawHtml(node: TiptapNode): string {
+  const content = node.attrs?.content as string | undefined;
+  if (!content) return '';
+
+  // Strip script tags and event handlers for safety
+  const sanitized = content
+    .replace(/<script\b[^<]*(?:(?!<\/script>)<[^<]*)*<\/script>/gi, '')
+    .replace(/\son\w+\s*=\s*(['"])[^'"]*\1/gi, '')
+    .replace(/\son\w+\s*=\s*[^\s>]*/gi, '');
+
+  return `<div data-raw-html="true">${sanitized}</div>`;
+}
+
+/**
+ * Render Meno component marker for SSR expansion
+ */
+function renderMenoComponent(node: TiptapNode): string {
+  const component = node.attrs?.component as string | undefined;
+  if (!component) return '';
+
+  const props = node.attrs?.props as Record<string, unknown> | undefined;
+  const propsJson = props ? escapeAttr(JSON.stringify(props)) : '{}';
+
+  return `<div data-meno-component="${escapeAttr(component)}" data-meno-props="${propsJson}"></div>`;
+}
+
 /**
  * Render text node with marks
  */

package/lib/shared/richtext/types.ts

@@ -68,7 +68,10 @@ export type TiptapNodeType =
   | 'table'
   | 'tableRow'
   | 'tableCell'
-  | 'tableHeader';
+  | 'tableHeader'
+  | 'iframe'
+  | 'rawHtml'
+  | 'menoComponent';
 
 /**
  * Known Tiptap mark types

package/lib/shared/types/cms.ts

@@ -11,6 +11,7 @@ export type CMSFieldType =
   | 'number'     // Numeric value
   | 'boolean'    // True/false
   | 'image'      // Image URL/path
+  | 'file'       // File URL/path (any file type)
   | 'date'       // ISO date string
   | 'select'     // Single selection from options
   | 'reference'  // Reference to another collection item
@@ -25,6 +26,7 @@ export interface CMSFieldDefinition {
   label?: string;           // Display label in editor
   description?: string;     // Help text
   options?: string[];       // For 'select' type
+  accept?: string;           // For 'file' type - MIME filter (e.g. "application/pdf", "*/*")
   collection?: string;      // For 'reference' type - target collection ID
   multiple?: boolean;       // For 'reference' type - allows array of IDs
 }

package/lib/shared/types/components.ts

@@ -10,13 +10,20 @@ import type { ComponentNode } from './nodes';
  */
 export type PropType = 'string' | 'select' | 'boolean' | 'number' | 'link' | 'file' | 'rich-text' | 'list';
 
+/**
+ * Project-level enum configuration
+ * Keys are enum names, values are arrays of options
+ */
+export type EnumsConfig = Record<string, readonly string[]>;
+
 /**
  * Internationalization (i18n) value object
  * Keys are locale codes (e.g., 'en', 'pl', 'de')
+ * Values can be strings (for string props) or arrays (for list props)
  */
 export interface I18nValue {
   _i18n: true;
-  [locale: string]: string | true;  // true is for the _i18n marker itself
+  [locale: string]: string | unknown[] | true;  // true is for the _i18n marker, arrays for list props
 }
 
 /**
@@ -58,7 +65,8 @@ export interface LinkPropValue {
 export interface BasePropDefinition {
   type: Exclude<PropType, 'list'>;
   default?: string | number | boolean | I18nValue | LinkPropValue;
-  options?: readonly string[];  // Required for "select" type
+  options?: readonly string[];  // Required for "select" type (inline options)
+  enumName?: string;  // For "select" type: reference to project-level enum
   accept?: string;  // For "file" type: MIME pattern like "image/*", "video/*"
 }
 
@@ -70,8 +78,9 @@ export type ListItemSchema = Record<string, BasePropDefinition>;
 
 /**
  * List item value type
+ * Supports i18n values for localized string fields
  */
-export type ListItemValue = Record<string, string | number | boolean | LinkPropValue | null>;
+export type ListItemValue = Record<string, string | number | boolean | LinkPropValue | I18nValue | null>;
 
 /**
  * List prop definition - for array/list data

package/lib/shared/types/experiments.ts

@@ -0,0 +1,55 @@
+/**
+ * A/B Testing Experiment Types
+ * Defines experiment configuration, variants, and conversion goals
+ */
+
+export interface ConversionGoal {
+  id: string
+  name: string
+  type: 'click' | 'navigation' | 'custom'
+  /** CSS selector for click goals */
+  selector?: string
+  /** URL pattern for navigation goals */
+  url?: string
+  /** Custom event name */
+  event?: string
+}
+
+export interface ExperimentVariant {
+  branch: string
+  /** Percentage of traffic (0-100) */
+  weight: number
+  /** Cloudflare Pages preview deploy URL, e.g. "https://variant-blue.project.pages.dev" */
+  deployUrl: string
+}
+
+export interface Experiment {
+  id: string
+  name: string
+  status: 'draft' | 'running' | 'paused' | 'completed'
+  controlBranch: string
+  variants: ExperimentVariant[]
+  /** Percentage of traffic for control (0-100) */
+  controlWeight: number
+  conversionGoals: ConversionGoal[]
+  createdAt: string
+  startedAt?: string
+  endedAt?: string
+}
+
+export interface ExperimentResults {
+  experimentId: string
+  variants: VariantResult[]
+}
+
+export interface VariantResult {
+  variant: string
+  visitors: number
+  conversions: number
+  conversionRate: number
+  /** Lift percentage compared to control */
+  lift?: number
+  /** p-value from z-test */
+  pValue?: number
+  isSignificant: boolean
+}

package/lib/shared/types/index.ts

@@ -34,6 +34,7 @@ export type {
   I18nConfig,
   LocaleConfig,
   LinkPropValue,
+  EnumsConfig,
 } from './components';
 
 export {
@@ -139,5 +140,14 @@ export { DEFAULT_PREFETCH_CONFIG } from './prefetch';
 // Export config types
 export type { CSPConfig } from './config';
 
+// Export experiment types
+export type {
+  ConversionGoal,
+  ExperimentVariant,
+  Experiment,
+  ExperimentResults,
+  VariantResult,
+} from './experiments';
+
 // Note: Path types are exported from ../paths/index.ts, not from here
 

package/lib/shared/utils.ts

@@ -7,16 +7,12 @@ import { stringToPath, pathToLegacyString, getParentPath, isRootPath as isRootPa
 import { ROOT_0_STRING } from './pathArrayUtils';
 
 /**
- * Deep clone an object using JSON serialization
+ * Deep clone an object using structuredClone
  * @param obj - The object to clone
  * @returns A deep clone of the object
  */
 export function deepClone<T>(obj: T): T {
-  try {
-    return JSON.parse(JSON.stringify(obj)) as T;
-  } catch (error) {
-    throw error;
-  }
+  return structuredClone(obj);
 }
 
 /**

package/lib/shared/validation/propValidator.test.ts

@@ -181,6 +181,56 @@ describe('Prop Validator', () => {
       expect(result.valid).toBe(true);
       expect(result.props.text).toBe('<b>Bold text</b>');
     });
+
+    test('list prop with I18nValue passes validation', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        items: {
+          type: 'list',
+          itemSchema: {
+            title: { type: 'string', default: '' },
+            text: { type: 'string', default: '' },
+          },
+          default: [],
+        },
+      };
+      const passedProps = {
+        items: {
+          _i18n: true,
+          en: [{ title: 'English', text: 'Text' }],
+          pl: [{ title: 'Polish', text: 'Tekst' }],
+        },
+      };
+
+      const result = validateComponentProps(propDefs, passedProps);
+
+      expect(result.valid).toBe(true);
+      // I18nValue should be preserved (resolved later by resolveI18nInProps)
+      expect(result.props.items).toEqual({
+        _i18n: true,
+        en: [{ title: 'English', text: 'Text' }],
+        pl: [{ title: 'Polish', text: 'Tekst' }],
+      });
+    });
+
+    test('list prop with plain array passes validation', () => {
+      const propDefs: Record<string, PropDefinition> = {
+        items: {
+          type: 'list',
+          itemSchema: {
+            title: { type: 'string', default: '' },
+          },
+          default: [],
+        },
+      };
+      const passedProps = {
+        items: [{ title: 'Item 1' }, { title: 'Item 2' }],
+      };
+
+      const result = validateComponentProps(propDefs, passedProps);
+
+      expect(result.valid).toBe(true);
+      expect(result.props.items).toEqual([{ title: 'Item 1' }, { title: 'Item 2' }]);
+    });
   });
 
   describe('Backward compatibility maintained', () => {

package/lib/shared/validation/propValidator.ts

@@ -167,9 +167,9 @@ function validateSingleProp(
       break;
 
     case 'list':
-      // List type accepts arrays
+      // List type accepts arrays and i18n values (i18n values will be resolved later)
       coercedValue = value;
-      typeValid = Array.isArray(value);
+      typeValid = Array.isArray(value) || isI18nValue(value);
       break;
 
     default:

package/lib/shared/validation/schemas.ts

@@ -29,9 +29,16 @@ export const BasePropDefinitionSchema = z.object({
   type: BasePropTypeSchema,
   default: z.union([z.string(), z.number(), z.boolean(), z.object({ href: z.string(), target: z.string().optional() })]).optional(),
   options: z.array(z.string()).readonly().optional(),
+  enumName: z.string().optional(), // For 'select' type: reference to project-level enum
   accept: z.string().optional(), // For 'file' type: MIME pattern like "image/*", "video/*"
 }).passthrough();
 
+/**
+ * Project-level enums configuration schema
+ * Keys are enum names, values are arrays of options
+ */
+export const EnumsConfigSchema = z.record(z.string(), z.array(z.string()));
+
 /**
  * List item schema - defines structure of each item in a list prop
  */
@@ -269,7 +276,7 @@ export const ListNodeSchemaBasic: z.ZodType<any> = z.lazy(() => z.object({
   sourceType: z.enum(['prop', 'collection']).optional(), // defaults to 'prop'
   source: z.string().optional(), // Source prop name or collection name
   collection: z.string().optional(), // Legacy field for cms-list migration
-  tag: z.string().optional(), // Wrapper element tag, defaults to 'div'
+  tag: z.union([z.string(), z.literal(false)]).optional(), // Wrapper element tag, defaults to 'div'. Set to false for no container.
   label: z.string().optional(),
   if: IfConditionSchema.optional(),
   style: StyleValueSchema.optional(),
@@ -476,7 +483,7 @@ export const PageDataSchema = z.union([
  * CMS field type schema
  */
 export const CMSFieldTypeSchema = z.enum([
-  'string', 'text', 'rich-text', 'number', 'boolean', 'image', 'date', 'select', 'reference', 'i18n', 'i18n-text'
+  'string', 'text', 'rich-text', 'number', 'boolean', 'image', 'file', 'date', 'select', 'reference', 'i18n', 'i18n-text'
 ]);
 
 /**
@@ -489,6 +496,7 @@ export const CMSFieldDefinitionSchema = z.object({
   label: z.string().optional(),
   description: z.string().optional(),
   options: z.array(z.string()).optional(),
+  accept: z.string().optional(),
   collection: z.string().optional(),
   multiple: z.boolean().optional(),
 }).passthrough();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "meno-core",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "type": "module",
   "bin": {
     "meno": "./bin/cli.ts"