@se-studio/core-ui 1.0.45 → 1.0.47

package/CMS_INFRASTRUCTURE.md

@@ -0,0 +1,335 @@
+# CMS Component Mapping Infrastructure
+
+This document describes the CMS component mapping infrastructure extracted from the Point.me marketing-site project into the core-ui package.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Architecture](#architecture)
+  - [Core Concepts](#core-concepts)
+  - [File Structure](#file-structure)
+- [Usage Guide](#usage-guide)
+  - [1. Create Your Renderer Configuration](#1-create-your-renderer-configuration)
+  - [2. Use CmsContent with Your Configuration](#2-use-cmscontent-with-your-configuration)
+  - [3. Use UnusedChecker for Development](#3-use-unusedchecker-for-development)
+- [Configuration Composition](#configuration-composition)
+  - [Preview Mode Configuration](#preview-mode-configuration)
+  - [Environment-Specific Configurations](#environment-specific-configurations)
+  - [Embedded Context Configuration](#embedded-context-configuration)
+- [Type System](#type-system)
+  - [BaseCmsConfig](#basecmsconfig)
+  - [CmsRendererConfig](#cmsrendererconfig)
+  - [Context Types](#context-types)
+- [Development Features](#development-features)
+  - [Unknown Type Warnings](#unknown-type-warnings)
+  - [Generic Fallbacks](#generic-fallbacks)
+  - [Type Safety](#type-safety)
+- [Benefits Over Ad-Hoc Rendering](#benefits-over-ad-hoc-rendering)
+- [Migration from Marketing-Site](#migration-from-marketing-site)
+- [Examples](#examples)
+- [API Reference](#api-reference)
+  - [CmsContent Props](#cmscontent-props)
+- [Future Enhancements](#future-enhancements)
+
+## Overview
+
+The infrastructure provides a type-safe, extensible system for mapping CMS content types to React components. It supports:
+
+- **Component/Collection Mapping**: Registry pattern for routing content types to renderers
+- **Embedding System**: Components can be rendered in embedded contexts (like rich text)
+- **Generic Fallbacks**: Automatic fallback rendering for unmapped types
+- **Development Utilities**: Warnings for unused props and rendering errors
+
+## Architecture
+
+### Core Concepts
+
+1. **Content Routing**: `CmsContent` receives an array of mixed content types and routes each to the appropriate renderer
+2. **Type Mapping**: `ComponentMap` and `CollectionMap` define which React components render which content types
+3. **Embedded Rendering**: Components can be rendered in embedded contexts (like rich text)
+
+### File Structure
+
+```
+packages/core-ui/src/
+├── components/
+│   ├── CmsComponent.tsx        # Component type router
+│   ├── CmsCollection.tsx       # Collection type router
+│   ├── CmsContent.tsx          # Main content renderer
+│   ├── GenericComponent.tsx    # Fallback component renderer
+│   └── GenericCollection.tsx   # Fallback collection renderer
+├── embeddable/
+│   ├── EmbeddableContext.ts    # Context types for embedded rendering
+│   ├── BuildEmbed.tsx          # Factory functions for embeddable components
+│   └── EmbeddableMaps.ts       # Type definitions for embeddable maps
+└── utils/
+    ├── componentUtils.ts       # Related content fetching
+    └── UnusedChecker.tsx       # Development warning utility
+```
+
+## Usage Guide
+
+### 1. Create Your Renderer Configuration
+
+The recommended approach is to create a single `CmsRendererConfig` object that bundles all your renderer maps and options:
+
+```tsx
+import { createCmsRendererConfig } from "@se-studio/core-ui";
+import type { MyProjectConfig } from "./types";
+
+// Import your component renderers
+import { HeroComponent } from "@/components/Hero";
+import { CTAComponent } from "@/components/CTA";
+import { ContentBlock } from "@/components/ContentBlock";
+
+// Import your collection renderers
+import { FAQCollection } from "@/components/FAQCollection";
+import { RelatedArticles } from "@/components/RelatedArticles";
+
+// Import special renderers (optional)
+import { VisualRenderer } from "@/components/VisualRenderer";
+import { InternalLinkRenderer } from "@/components/InternalLinkRenderer";
+
+/**
+ * Main CMS renderer configuration for the project.
+ * Create this once and reuse it throughout your app.
+ */
+export const rendererConfig = createCmsRendererConfig<MyProjectConfig>({
+  componentMap: {
+    "Hero": HeroComponent,
+    "CTA": CTAComponent,
+    "Content Block": ContentBlock,
+  },
+  collectionMap: {
+    "FAQs": FAQCollection,
+    "Related Articles": RelatedArticles,
+  },
+  // Optional: external components, visuals, links
+  externalComponentMap: {
+    "Contact Form": ContactFormRenderer,
+  },
+  visualComponentRenderer: VisualRenderer,
+  internalLinkRenderer: InternalLinkRenderer,
+  // Show errors in development mode
+  showUnknownTypeErrors: process.env.NODE_ENV === 'development',
+  showRenderErrors: process.env.NODE_ENV === 'development',
+});
+```
+
+### 2. Use CmsContent with Your Configuration
+
+```tsx
+import { CmsContent } from "@se-studio/core-ui";
+import { rendererConfig } from "@/cms/rendererConfig";
+
+export function PageRenderer({ page }) {
+  const pageContext = {
+    pageLink: { slug: page.slug, title: page.title },
+  };
+
+  return (
+    <CmsContent
+      rendererConfig={rendererConfig}
+      pageContext={pageContext}
+      contents={page.contents}
+    />
+  );
+}
+```
+
+**Benefits of this approach:**
+- **Clean API**: Only 3 props instead of 7+ individual props
+- **Single source of truth**: All renderer configuration in one place
+- **Easy to extend**: Add new renderer types without touching every CmsContent call
+- **Type-safe**: Full TypeScript support with generics
+- **Composable**: Create variants with `mergeCmsRendererConfig()`
+
+### 3. Use UnusedChecker for Development
+
+Catch unused CMS properties that aren't being rendered:
+
+```tsx
+import { UnusedChecker } from "@se-studio/core-ui";
+
+export const MyComponent = ({ information, contentContext }) => {
+  const { heading, body, links, ...unused } = information;
+
+  return (
+    <UnusedChecker
+      componentName="MyComponent"
+      unused={unused}
+      showWarnings={true}
+    >
+      <div>
+        <h2>{heading}</h2>
+        <p>{body}</p>
+      </div>
+    </UnusedChecker>
+  );
+};
+```
+
+## Configuration Composition
+
+The `mergeCmsRendererConfig()` utility allows you to create specialized configurations from a base config:
+
+### Preview Mode Configuration
+
+```tsx
+import { mergeCmsRendererConfig } from "@se-studio/core-ui";
+
+const baseConfig = createCmsRendererConfig({ ... });
+
+// Preview config with all errors displayed
+export const previewConfig = mergeCmsRendererConfig(baseConfig, {
+  showUnknownTypeErrors: true,
+  showRenderErrors: true,
+});
+
+// Use in preview routes
+<CmsContent rendererConfig={previewConfig} ... />
+```
+
+### Environment-Specific Configurations
+
+```tsx
+const productionConfig = createCmsRendererConfig({
+  componentMap: { ... },
+  collectionMap: { ... },
+  showUnknownTypeErrors: false,
+  showRenderErrors: false,
+});
+
+const developmentConfig = mergeCmsRendererConfig(productionConfig, {
+  showUnknownTypeErrors: true,
+  showRenderErrors: true,
+});
+
+export const rendererConfig =
+  process.env.NODE_ENV === 'production'
+    ? productionConfig
+    : developmentConfig;
+```
+
+### Embedded Context Configuration
+
+```tsx
+// Different component map for embedded contexts
+const embeddedConfig = mergeCmsRendererConfig(baseConfig, {
+  componentMap: {
+    ...baseConfig.componentMap,
+    "Hero": EmbeddedHeroComponent, // Use simplified version
+  },
+});
+```
+
+## Type System
+
+### BaseCmsConfig
+
+Projects must extend `BaseCmsConfig` to define their CMS-specific types:
+
+```tsx
+import type { BaseCmsConfig } from "@se-studio/core-data-types";
+
+export interface MyProjectConfig extends BaseCmsConfig {
+  ComponentType: "Hero" | "CTA" | "Content Block";
+  CollectionType: "FAQs" | "Related Articles";
+  ExternalComponentType: "ContactForm" | "Newsletter";
+  ColourName: "red" | "blue" | "green";
+  // ... other type overrides
+}
+```
+
+### CmsRendererConfig
+
+The main configuration type that bundles all renderer maps:
+
+```tsx
+interface CmsRendererConfig<TConfig extends BaseCmsConfig> {
+  componentMap: ComponentMap<TConfig>;
+  collectionMap: CollectionMap<TConfig>;
+  externalComponentMap?: ExternalComponentMap<TConfig>;
+  visualComponentRenderer?: VisualComponentRenderer<TConfig>;
+  internalLinkRenderer?: InternalLinkRenderer<TConfig>;
+  showUnknownTypeErrors?: boolean;
+  showRenderErrors?: boolean;
+}
+```
+
+### Context Types
+
+- `IPageContext<TConfig>`: Page-level context (article, page, tag links)
+- `IContentContext<TConfig>`: Content-level context (current, previous, next content)
+- `IEmbeddableComponentContext<TConfig>`: Context for embedded components
+- `IEmbeddableCollectionContext<TConfig>`: Context for embedded collections
+
+## Development Features
+
+### Unknown Type Warnings
+
+In development mode, the infrastructure displays visual warnings for:
+- Unmapped component/collection types
+- Rendering errors
+- Unused CMS properties
+
+### Generic Fallbacks
+
+When a component/collection type isn't mapped:
+1. A warning is logged to console
+2. In dev mode, an error panel is displayed
+3. A generic fallback renderer is used
+4. The page continues to render (no crashes)
+
+### Type Safety
+
+- Full TypeScript support with generic types
+- Development warnings catch unused properties
+
+## Benefits Over Ad-Hoc Rendering
+
+1. **Centralized Mapping**: All component mappings in one place
+2. **Reusability**: Components work in multiple contexts (full-page, embedded)
+3. **Maintainability**: Changes to component structure are caught at compile-time
+4. **Development UX**: Clear warnings for mistakes
+5. **Fallback Handling**: Pages never break from unmapped types
+
+## Migration from Marketing-Site
+
+To migrate an existing project:
+
+1. Install core-ui: `pnpm add @se-studio/core-ui`
+2. Create ComponentMap and CollectionMap
+3. Replace direct component rendering with CmsContent
+4. Test with `showUnknownTypeErrors={true}` to find missing mappings
+
+## Examples
+
+See the example apps in this monorepo for complete working implementations:
+- `apps/example-pointme`: Full Point.me-style implementation
+- `apps/example-hsd`: Alternative implementation pattern
+
+## API Reference
+
+### CmsContent Props
+
+- `pageContext`: Page-level context information
+- `contents`: Array of content to render
+- `componentMap`: Map of component types to renderers
+- `collectionMap`: Map of collection types to renderers
+- `externalComponentMap`: Map of external component types to renderers (optional)
+- `visualComponentRenderer`: Renderer for Visual content types (optional)
+- `internalLinkRenderer`: Renderer for Internal Link content types (optional)
+- `showUnknownTypeErrors`: Show error panels for unknown types (default: false)
+- `showRenderErrors`: Show error panels for rendering errors (default: false)
+
+## Future Enhancements
+
+Potential improvements for future iterations:
+
+- [ ] Async component loading for code splitting
+- [ ] Component preview mode for CMS editors
+- [ ] Performance monitoring hooks
+- [ ] Server-side rendering optimizations
+- [ ] Component analytics integration
+- [ ] Rich text node renderer registration system

package/CONSENT.md

@@ -0,0 +1,121 @@
+# Consent Management Guide
+
+Core UI integrates with [Orejime](https://github.com/empreinte-digitale/orejime), an open-source consent management manager, to provide GDPR and CCPA compliance.
+
+## Overview
+
+The consent system ensures that:
+1. Users are presented with a consent banner
+2. Cookies/Trackers are blocked until consent is given
+3. Analytics adapters only fire when allowed
+
+## Setup
+
+### 1. Configure Consent Provider
+
+Wrap your application with `ConsentProvider` and provide configuration.
+
+```tsx
+import { ConsentProvider } from '@se-studio/core-ui';
+
+const config = {
+  apps: [
+    {
+      name: 'google-tag-manager',
+      title: 'Analytics',
+      purposes: ['analytics'],
+      cookies: ['_ga', '_gid'],
+      required: false,
+      default: true,
+    },
+    {
+      name: 'marketing-cookies',
+      title: 'Marketing',
+      purposes: ['marketing'],
+      required: false,
+    }
+  ],
+  privacyPolicy: '/privacy-policy',
+};
+
+// Styling theme (optional)
+const theme = {
+  primaryColor: '#0070f3',
+  borderRadius: '8px',
+};
+
+export function AppProviders({ children }) {
+  return (
+    <ConsentProvider config={config} theme={theme}>
+      {children}
+    </ConsentProvider>
+  );
+}
+```
+
+### 2. Connect to Analytics
+
+Use `ConsentAwareAdapter` to gate analytics based on consent.
+
+```tsx
+import { ConsentAwareAdapter, GoogleTagManagerAdapter, useConsent } from '@se-studio/core-ui';
+
+function AnalyticsSetup() {
+  const { hasConsent } = useConsent();
+  
+  const adapter = useMemo(() => {
+    const base = new GoogleTagManagerAdapter({ containerId: '...' });
+    // 'google-tag-manager' matches the app name in config
+    return new ConsentAwareAdapter(base, 'google-tag-manager', hasConsent);
+  }, [hasConsent]);
+  
+  return <AnalyticsProvider adapter={adapter}>...</AnalyticsProvider>;
+}
+```
+
+## Styling
+
+Orejime styles can be customized via CSS variables or the `theme` prop.
+
+### Using Theme Prop
+
+```tsx
+<ConsentProvider 
+  theme={{
+    fontFamily: 'Inter, sans-serif',
+    primaryColor: '#ff0000',
+    backgroundColor: '#ffffff'
+  }}
+>
+```
+
+### Using CSS Variables
+
+In your global CSS:
+
+```css
+:root {
+  --orejime-color-primary: #ff0000;
+  --orejime-border-radius: 4px;
+  --orejime-z-index: 50;
+}
+```
+
+## Hook API
+
+The `useConsent` hook provides access to consent state.
+
+```tsx
+import { useConsent } from '@se-studio/core-ui';
+
+function MyComponent() {
+  const { hasConsent, showConsentModal, resetConsent } = useConsent();
+
+  return (
+    <div>
+      {hasConsent('analytics') && <AnalyticsDashboard />}
+      <button onClick={showConsentModal}>Cookie Settings</button>
+    </div>
+  );
+}
+```

package/README.md

@@ -10,6 +10,7 @@ Shared React UI component library with Tailwind CSS v4 and CMS infrastructure fo
 - **Tailwind CSS v4** - Modern utility-first CSS framework with custom breakpoints
 - **Visual Components** - Optimized image, video, and animation components
 - **Rich Text Rendering** - RTF (Rich Text Field) support with embedded content
+- **CMS Showcase** - Shared developer tools for testing and previewing CMS components
 - **Tree-shakeable** - Import only what you need
 - **Dual exports** - ESM and CJS support
 - **Fully tested** - Comprehensive test coverage with Vitest
@@ -237,6 +238,16 @@ import { UnusedChecker } from '@se-studio/core-ui';
 />
 ```
 
+#### CMS Showcase
+
+The library provides a set of components and utilities to build a CMS component showcase for your project.
+
+- **`ShowcasePage`** - The main interface for selecting components and adjusting mock data.
+- **`ShowcaseRenderPage`** - The renderer component for the preview iframe.
+- **`mockFactory`** - Utilities for generating mock data from CMS registrations.
+
+See the [CMS Showcase Infrastructure Guide](./src/showcase/README.md) for more details.
+
 ### Animation & Monitoring Components
 
 #### ClientMonitor
@@ -397,17 +408,12 @@ const previewConfig = mergeCmsRendererConfig(
 #### Utilities
 - **`buildPageMetadata`** - Generates Next.js metadata object from CMS page model
 - **`handleCmsError`** - Error handling utility for CMS operations
-- **`extractComponentInfo`** - Extract specific component information fields
-- **`extractCollectionInfo`** - Extract specific collection information fields
-- **`extractPageContext`** - Extract specific page context fields
+- **`getRelatedArticles`** - Utility to fetch related articles for collections
+- **`getRelatedPeople`** - Utility to fetch related people for collections
 - **`cn`** - Utility function for merging Tailwind CSS classes
 
 #### Types
 - **`CmsRendererConfig`** - Complete renderer configuration type
-- **`ComponentRenderer<T>`** - Type for component renderer functions
-- **`CollectionRenderer<T>`** - Type for collection renderer functions
-- **`ComponentConfig<T>`** - Type-safe component configuration
-- **`CollectionConfig<T>`** - Type-safe collection configuration
 
 For detailed JSDoc documentation on all exports, see the TypeScript declaration files (`.d.ts`) in the package.
 
@@ -417,7 +423,6 @@ For advanced CMS infrastructure usage, including:
 - Configuration composition patterns
 - Embeddable components
 - Context passing
-- Type-safe prop extraction
 - Preview mode setup
 
 See the [CMS Infrastructure Guide](./CMS_INFRASTRUCTURE.md).

package/dist/cmsRegistration.d.ts

@@ -0,0 +1,152 @@
+/**
+ * CMS Registration System
+ *
+ * This module provides a unified registration pattern for CMS components and collections.
+ * Instead of updating multiple places when adding a new component, you can define a single
+ * registration object that contains all related pieces (renderer, embedded renderer, used fields).
+ *
+ * @example
+ * ```tsx
+ * // In your component file
+ * export const HeroRegistration = defineComponent({
+ *   name: 'Hero',
+ *   renderer: Hero,
+ *   usedFields: USED_FIELDS,
+ * });
+ *
+ * // In cms.ts
+ * const componentRegistrations = [HeroRegistration, ...];
+ * const { componentMap, embeddedComponentMap, componentFieldsMap } =
+ *   buildComponentMaps(componentRegistrations);
+ * ```
+ */
+import type { ITyped } from '@se-studio/core-data-types';
+import type { CollectionRenderer, EmbeddedCollectionRenderer } from './components/CmsCollection';
+import type { ComponentRenderer, EmbeddedComponentRenderer } from './components/CmsComponent';
+import type { EmbeddedExternalComponentRenderer, ExternalComponentRenderer } from './components/CmsExternalComponent';
+export interface MockData {
+    visual?: {
+        width: number;
+        height: number;
+    };
+    [key: string]: string | number | boolean | {
+        width: number;
+        height: number;
+    } | undefined;
+}
+/**
+ * Registration for a CMS component.
+ * Components can optionally have an embedded variant for use in RTF/collections.
+ */
+export interface ComponentRegistration<TName extends string = string, TComponent extends ITyped = ITyped> {
+    /** CMS component type name (e.g., 'Hero', 'Callout') */
+    name: TName;
+    /** Main renderer for page-level display */
+    renderer: ComponentRenderer<TComponent>;
+    /** Fields used by this component (for cms-showcase and unused field checking) */
+    usedFields: Set<string>;
+    /** Optional embedded renderer for RTF/collection contexts */
+    embeddedRenderer?: EmbeddedComponentRenderer<TComponent>;
+    /** Optional mock data configuration for the showcase */
+    mock?: MockData;
+}
+/**
+ * Registration for a CMS collection.
+ * Collections render arrays of content items.
+ */
+export interface CollectionRegistration<TName extends string = string, TCollection extends ITyped = ITyped> {
+    /** CMS collection type name (e.g., 'Card grid', 'Icon cards') */
+    name: TName;
+    /** Main renderer for page-level display */
+    renderer: CollectionRenderer<TCollection>;
+    /** Fields used by this collection */
+    usedFields: Set<string>;
+    /** Optional embedded renderer for nested contexts */
+    embeddedRenderer?: EmbeddedCollectionRenderer<TCollection>;
+    /** Optional: fields used by card items within the collection */
+    cardUsedFields?: Set<string>;
+    /** Optional mock data configuration for the showcase (collection fields) */
+    mock?: MockData;
+    /** Optional mock data configuration for the showcase (card fields) */
+    cardMock?: MockData;
+}
+/**
+ * Registration for an external component (forms, iframes, third-party widgets).
+ */
+export interface ExternalComponentRegistration<TName extends string = string, TExternal extends ITyped = ITyped> {
+    /** External component type name (e.g., 'iframe', 'Pardot form') */
+    name: TName;
+    /** Renderer for the external component */
+    renderer: ExternalComponentRenderer<TExternal>;
+    /** Optional embedded renderer */
+    embeddedRenderer?: EmbeddedExternalComponentRenderer<TExternal>;
+}
+/**
+ * Builds component maps from an array of registrations.
+ * Returns componentMap, embeddedComponentMap, and componentFieldsMap.
+ */
+export declare function buildComponentMaps<TComponent extends ITyped>(registrations: ComponentRegistration<string, TComponent>[]): {
+    componentMap: Record<string, ComponentRenderer<TComponent>>;
+    embeddedComponentMap: Record<string, EmbeddedComponentRenderer<TComponent>>;
+    componentFieldsMap: Record<string, Set<string>>;
+    componentMockMap: Record<string, MockData>;
+};
+/**
+ * Builds collection maps from an array of registrations.
+ */
+export declare function buildCollectionMaps<TCollection extends ITyped>(registrations: CollectionRegistration<string, TCollection>[]): {
+    collectionMap: Record<string, CollectionRenderer<TCollection>>;
+    embeddedCollectionMap: Record<string, EmbeddedCollectionRenderer<TCollection>>;
+    collectionFieldsMap: Record<string, Set<string>>;
+    collectionCardFieldsMap: Record<string, Set<string>>;
+    collectionMockMap: Record<string, MockData>;
+    collectionCardMockMap: Record<string, MockData>;
+};
+/**
+ * Builds external component maps from an array of registrations.
+ */
+export declare function buildExternalComponentMaps<TExternal extends ITyped>(registrations: ExternalComponentRegistration<string, TExternal>[]): {
+    externalComponentMap: Record<string, ExternalComponentRenderer<TExternal>>;
+    embeddedExternalComponentMap: Record<string, EmbeddedExternalComponentRenderer<TExternal>>;
+};
+/**
+ * Helper to create a component registration with type inference.
+ * Use this in component files to get proper type checking.
+ *
+ * @example
+ * ```tsx
+ * export const HeroRegistration = defineComponent({
+ *   name: 'Hero',
+ *   renderer: Hero,
+ *   usedFields: USED_FIELDS,
+ * });
+ * ```
+ */
+export declare function defineComponent<TName extends string, TComponent extends ITyped>(registration: ComponentRegistration<TName, TComponent>): ComponentRegistration<TName, TComponent>;
+/**
+ * Helper to create a collection registration with type inference.
+ *
+ * @example
+ * ```tsx
+ * export const CardGridRegistration = defineCollection({
+ *   name: 'Card grid',
+ *   renderer: CardGrid,
+ *   usedFields: COLLECTION_USED_FIELDS,
+ *   embeddedRenderer: EmbeddedCardGrid,
+ * });
+ * ```
+ */
+export declare function defineCollection<TName extends string, TCollection extends ITyped>(registration: CollectionRegistration<TName, TCollection>): CollectionRegistration<TName, TCollection>;
+/**
+ * Helper to create an external component registration with type inference.
+ *
+ * @example
+ * ```tsx
+ * export const IFrameRegistration = defineExternalComponent({
+ *   name: 'iframe',
+ *   renderer: ExternalIFrame,
+ * });
+ * ```
+ */
+export declare function defineExternalComponent<TName extends string, TExternal extends ITyped>(registration: ExternalComponentRegistration<TName, TExternal>): ExternalComponentRegistration<TName, TExternal>;
+//# sourceMappingURL=cmsRegistration.d.ts.map

package/dist/cmsRegistration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cmsRegistration.d.ts","sourceRoot":"","sources":["../src/cmsRegistration.ts"],"names":[],"mappings":"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"}