meno-core 1.0.0

package/lib/shared/registry/nodeTypes/EmbedNodeType.ts

@@ -0,0 +1,61 @@
+/**
+ * Embed Node Type Definition
+ * Renders custom HTML/SVG content
+ */
+
+import { z } from 'zod';
+import { createElement as h } from 'react';
+import { StyleValueSchema } from '../../validation/schemas';
+import { createNodeType } from '../createNodeType';
+import { textareaField } from '../fieldPresets';
+
+// Schema is the SINGLE source of truth
+const EmbedNodeSchemaInternal = z.object({
+  type: z.literal('embed'),
+  html: z.string(),
+  style: StyleValueSchema.optional(),
+  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+}).passthrough();
+
+// TypeScript type inferred from schema
+export type EmbedNode = z.infer<typeof EmbedNodeSchemaInternal>;
+
+// Export schema for validation/schemas.ts
+export const EmbedNodeSchema = EmbedNodeSchemaInternal;
+
+export const EmbedNodeType = createNodeType({
+  type: 'embed',
+  displayName: 'Embed',
+  category: 'content',
+  schema: EmbedNodeSchemaInternal,
+
+  defaultValues: {
+    html: '',
+    style: { base: {} },
+  },
+
+  treeDisplay: {
+    icon: 'HTML_ELEMENT',
+    getLabel: () => 'Embed',
+  },
+
+  editableFields: [
+    textareaField({ name: 'html', label: 'HTML Content', required: true, placeholder: '<svg>...</svg>' }),
+  ],
+
+  clientRenderer: (node, context) => {
+    return h('div', {
+      key: context.key,
+      dangerouslySetInnerHTML: { __html: node.html },
+    });
+  },
+
+  ssrRenderer: (node, _context) => {
+    return `<div>${node.html}</div>`;
+  },
+
+  capabilities: {
+    canHaveChildren: false,
+    requiresProps: ['html'],
+  },
+});

package/lib/shared/registry/nodeTypes/HtmlNodeType.ts

@@ -0,0 +1,88 @@
+/**
+ * HTML Node Type Definition
+ * HTML element nodes (div, span, header, etc.)
+ */
+
+import { z } from 'zod';
+import { createElement as h } from 'react';
+import { StyleValueSchema } from '../../validation/schemas';
+import { createNodeType } from '../createNodeType';
+
+// Forward reference for ComponentNode schema (recursive)
+const ComponentNodeSchemaRef: z.ZodType<any> = z.lazy(() => z.any());
+
+// Schema is the SINGLE source of truth
+const HtmlNodeSchemaInternal = z.object({
+  type: z.literal('node'),
+  tag: z.string(),
+  style: StyleValueSchema.optional(),
+  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+  props: z.record(z.string(), z.any()).optional(), // Backward compatibility
+  children: z.union([
+    z.array(z.union([ComponentNodeSchemaRef, z.string()])),
+    z.string(),
+  ]).optional(),
+}).passthrough();
+
+// TypeScript type inferred from schema
+export type HtmlNode = z.infer<typeof HtmlNodeSchemaInternal>;
+
+// Export schema for validation/schemas.ts
+export const HtmlNodeSchema = HtmlNodeSchemaInternal;
+
+export const HtmlNodeType = createNodeType({
+  type: 'node',
+  displayName: 'HTML Element',
+  category: 'core',
+  schema: HtmlNodeSchemaInternal,
+
+  defaultValues: {
+    tag: 'div',
+    style: { base: {} },
+    children: [],
+  },
+
+  treeDisplay: {
+    icon: 'HTML_ELEMENT',
+    getLabel: (node) => node.tag,
+  },
+
+  clientRenderer: (node, context) => {
+    const props: Record<string, any> = { key: context.key };
+
+    // Prevent form submission in editor
+    if (node.tag === 'form') {
+      props.onSubmit = (e: React.FormEvent) => e.preventDefault();
+    }
+
+    // Void elements cannot have children
+    const voidElements = ['img', 'br', 'hr', 'input', 'meta', 'link', 'area', 'base', 'col', 'embed', 'param', 'source', 'track', 'wbr'];
+    if (voidElements.includes(node.tag.toLowerCase())) {
+      return h(node.tag, props);
+    }
+
+    const children = context.buildChildren(
+      node.children as any,
+      context.elementPath,
+      context.parentComponentName,
+      context.componentContext
+    );
+
+    return h(node.tag, props, children);
+  },
+
+  ssrRenderer: (node, context) => {
+    const childrenHTML = context.renderChildren(node.children as any, context);
+    // Void elements don't have closing tags
+    const voidElements = ['img', 'br', 'hr', 'input', 'meta', 'link', 'area', 'base', 'col', 'embed', 'param', 'source', 'track', 'wbr'];
+    if (voidElements.includes(node.tag.toLowerCase())) {
+      return `<${node.tag} />`;
+    }
+    return `<${node.tag}>${childrenHTML}</${node.tag}>`;
+  },
+
+  capabilities: {
+    canHaveChildren: true,
+    requiresProps: ['tag'],
+  },
+});

package/lib/shared/registry/nodeTypes/LocaleListNodeType.ts

@@ -0,0 +1,66 @@
+/**
+ * Locale List Node Type Definition
+ * Renders locale switcher links
+ */
+
+import { z } from 'zod';
+import { createElement as h } from 'react';
+import { StyleValueSchema } from '../../validation/schemas';
+import { createNodeType } from '../createNodeType';
+
+// Schema is the SINGLE source of truth
+const LocaleListNodeSchemaInternal = z.object({
+  type: z.literal('locale-list'),
+  style: StyleValueSchema.optional(),
+  itemStyle: StyleValueSchema.optional(),
+  activeItemStyle: StyleValueSchema.optional(),
+  separatorStyle: StyleValueSchema.optional(),
+  showCurrent: z.boolean().optional(),
+  showSeparator: z.boolean().optional(),
+  showFlag: z.boolean().optional(),
+  flagStyle: StyleValueSchema.optional(),
+  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+}).passthrough();
+
+// TypeScript type inferred from schema
+export type LocaleListNode = z.infer<typeof LocaleListNodeSchemaInternal>;
+
+// Export schema for validation/schemas.ts
+export const LocaleListNodeSchema = LocaleListNodeSchemaInternal;
+
+export const LocaleListNodeType = createNodeType({
+  type: 'locale-list',
+  displayName: 'LocaleList',
+  category: 'special',
+  schema: LocaleListNodeSchemaInternal,
+
+  defaultValues: {
+    style: { base: {} },
+    showCurrent: true,
+    showSeparator: true,
+    showFlag: true,
+  },
+
+  treeDisplay: {
+    icon: 'HTML_ELEMENT',
+    getLabel: () => 'LocaleList',
+  },
+
+  clientRenderer: (_node, context) => {
+    // In editor, shows placeholder
+    return h('div', {
+      key: context.key,
+      'data-locale-list': 'true',
+    }, '[Locale List]');
+  },
+
+  ssrRenderer: (_node, _context) => {
+    // Placeholder - full implementation renders actual locale links
+    return '<div class="locale-list">[Locale List]</div>';
+  },
+
+  capabilities: {
+    canHaveChildren: false,
+    requiresProps: [],
+  },
+});

package/lib/shared/registry/nodeTypes/ObjectLinkNodeType.ts

@@ -0,0 +1,75 @@
+/**
+ * Object Link Node Type Definition
+ * Renders as div in editor, <a> tag in SSR
+ */
+
+import { z } from 'zod';
+import { createElement as h } from 'react';
+import { StyleValueSchema, LinkMappingSchema } from '../../validation/schemas';
+import { createNodeType } from '../createNodeType';
+import { urlField } from '../fieldPresets';
+
+// Forward reference for ComponentNode schema (recursive)
+// This will be resolved when schemas.ts imports this and builds the union
+const ComponentNodeSchemaRef: z.ZodType<any> = z.lazy(() => z.any());
+
+// Schema is the SINGLE source of truth
+const ObjectLinkNodeSchemaInternal = z.object({
+  type: z.literal('object-link'),
+  href: z.union([z.string(), LinkMappingSchema]),
+  style: StyleValueSchema.optional(),
+  attributes: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
+  children: z.union([
+    z.array(z.union([ComponentNodeSchemaRef, z.string()])),
+    z.string(),
+  ]).optional(),
+}).passthrough();
+
+// TypeScript type inferred from schema
+export type ObjectLinkNode = z.infer<typeof ObjectLinkNodeSchemaInternal>;
+
+// Export schema for validation/schemas.ts
+export const ObjectLinkNodeSchema = ObjectLinkNodeSchemaInternal;
+
+export const ObjectLinkNodeType = createNodeType({
+  type: 'object-link',
+  displayName: 'Link',
+  category: 'content',
+  schema: ObjectLinkNodeSchemaInternal,
+
+  defaultValues: {
+    href: '#',
+    style: { base: {} },
+    children: [],
+  },
+
+  treeDisplay: {
+    icon: 'HTML_ELEMENT',
+    getLabel: () => 'Link',
+  },
+
+  editableFields: [
+    urlField({ name: 'href', label: 'Link URL', required: true }),
+  ],
+
+  clientRenderer: (node, context) => {
+    const children = context.buildChildren(
+      node.children as any,
+      context.elementPath,
+      context.parentComponentName,
+      context.componentContext
+    );
+    return h('div', { key: context.key }, children);
+  },
+
+  ssrRenderer: (node, context) => {
+    const href = typeof node.href === 'string' ? node.href : '#';
+    const childrenHTML = context.renderChildren(node.children as any, context);
+    return `<a href="${context.escapeHtml(href)}" class="olink">${childrenHTML}</a>`;
+  },
+
+  capabilities: {
+    canHaveChildren: true,
+    requiresProps: ['href'],
+  },
+});

package/lib/shared/registry/nodeTypes/SlotMarkerType.ts

@@ -0,0 +1,49 @@
+/**
+ * Slot Marker Node Type Definition
+ * Indicates where instance children should be placed in a component
+ */
+
+import { z } from 'zod';
+import { createNodeType } from '../createNodeType';
+
+// Schema is the SINGLE source of truth
+const SlotMarkerSchemaInternal = z.object({
+  type: z.literal('slot'),
+}).passthrough();
+
+// TypeScript type inferred from schema
+export type SlotMarker = z.infer<typeof SlotMarkerSchemaInternal>;
+
+// Export schema for validation/schemas.ts
+export const SlotMarkerSchema = SlotMarkerSchemaInternal;
+
+export const SlotMarkerType = createNodeType({
+  type: 'slot',
+  displayName: 'Slot',
+  category: 'special',
+  schema: SlotMarkerSchemaInternal,
+
+  defaultValues: {},
+
+  treeDisplay: {
+    icon: 'SLOT_MARKER',
+    getLabel: () => 'slot',
+  },
+
+  clientRenderer: (_node, _context) => {
+    // Slot markers are replaced with instance children during component rendering
+    return null;
+  },
+
+  ssrRenderer: (_node, _context) => {
+    // Slot markers are replaced with instance children during component rendering
+    return '';
+  },
+
+  capabilities: {
+    canHaveChildren: false,
+    canHaveStyle: false,
+    canHaveAttributes: false,
+    requiresProps: [],
+  },
+});

package/lib/shared/registry/nodeTypes/TextNodeType.ts

@@ -0,0 +1,52 @@
+/**
+ * Text Node Type Definition
+ * Static text content in component structures
+ */
+
+import { z } from 'zod';
+import { createNodeType } from '../createNodeType';
+
+// Schema is the SINGLE source of truth
+const TextNodeSchemaInternal = z.object({
+  type: z.literal('text'),
+  value: z.string(),
+}).passthrough();
+
+// TypeScript type inferred from schema
+export type TextNode = z.infer<typeof TextNodeSchemaInternal>;
+
+// Export schema for validation/schemas.ts
+export const TextNodeSchema = TextNodeSchemaInternal;
+
+export const TextNodeType = createNodeType({
+  type: 'text',
+  displayName: 'Text',
+  category: 'content',
+  schema: TextNodeSchemaInternal,
+
+  defaultValues: {
+    value: '',
+  },
+
+  treeDisplay: {
+    icon: 'TEXT',
+    getLabel: (node) => `"${node.value.substring(0, 30)}${node.value.length > 30 ? '...' : ''}"`,
+  },
+
+  clientRenderer: (node, context) => {
+    // Text nodes render as simple text content
+    return context.processI18n(node.value) as any;
+  },
+
+  ssrRenderer: (node, context) => {
+    // Text nodes render as escaped text
+    return context.escapeHtml(context.processI18n(node.value));
+  },
+
+  capabilities: {
+    canHaveChildren: false,
+    canHaveStyle: false,
+    canHaveAttributes: false,
+    requiresProps: ['value'],
+  },
+});

package/lib/shared/registry/nodeTypes/index.ts

@@ -0,0 +1,75 @@
+/**
+ * Node Types Index
+ * Exports all built-in node type definitions, schemas, and types
+ *
+ * This is the single source of truth for node type definitions.
+ * Types are inferred from Zod schemas, eliminating duplication.
+ */
+
+import { globalNodeTypeManager } from '../NodeTypeManager';
+import type { NodeTypeDefinition } from '../NodeTypeDefinition';
+
+// Import all node type definitions (each file exports type, schema, and definition)
+import { HtmlNodeType, HtmlNodeSchema, type HtmlNode } from './HtmlNodeType';
+import { ComponentInstanceNodeType, ComponentInstanceNodeSchema, type ComponentInstanceNode } from './ComponentInstanceNodeType';
+import { SlotMarkerType, SlotMarkerSchema, type SlotMarker } from './SlotMarkerType';
+import { EmbedNodeType, EmbedNodeSchema, type EmbedNode } from './EmbedNodeType';
+import { ObjectLinkNodeType, ObjectLinkNodeSchema, type ObjectLinkNode } from './ObjectLinkNodeType';
+import { LocaleListNodeType, LocaleListNodeSchema, type LocaleListNode } from './LocaleListNodeType';
+import { TextNodeType, TextNodeSchema, type TextNode } from './TextNodeType';
+/**
+ * All built-in node type definitions
+ * Type assertion needed because TypeScript sees each as a specific generic type
+ */
+export const builtInNodeTypes: NodeTypeDefinition[] = [
+  HtmlNodeType as NodeTypeDefinition,
+  ComponentInstanceNodeType as NodeTypeDefinition,
+  SlotMarkerType as NodeTypeDefinition,
+  EmbedNodeType as NodeTypeDefinition,
+  ObjectLinkNodeType as NodeTypeDefinition,
+  LocaleListNodeType as NodeTypeDefinition,
+  TextNodeType as NodeTypeDefinition,
+];
+
+/**
+ * Export all schemas for use in validation/schemas.ts
+ */
+export const nodeSchemas = {
+  html: HtmlNodeSchema,
+  component: ComponentInstanceNodeSchema,
+  slot: SlotMarkerSchema,
+  embed: EmbedNodeSchema,
+  objectLink: ObjectLinkNodeSchema,
+  localeList: LocaleListNodeSchema,
+  text: TextNodeSchema,
+};
+
+/**
+ * Register all built-in node types with the global manager
+ * Call this early in app lifecycle (client and server entry points)
+ */
+export function registerBuiltInNodeTypes(): void {
+  globalNodeTypeManager.registerAll(builtInNodeTypes);
+}
+
+// Re-export individual node types for direct access
+export { HtmlNodeType, HtmlNodeSchema, type HtmlNode } from './HtmlNodeType';
+export { ComponentInstanceNodeType, ComponentInstanceNodeSchema, type ComponentInstanceNode } from './ComponentInstanceNodeType';
+export { SlotMarkerType, SlotMarkerSchema, type SlotMarker } from './SlotMarkerType';
+export { EmbedNodeType, EmbedNodeSchema, type EmbedNode } from './EmbedNodeType';
+export { ObjectLinkNodeType, ObjectLinkNodeSchema, type ObjectLinkNode } from './ObjectLinkNodeType';
+export { LocaleListNodeType, LocaleListNodeSchema, type LocaleListNode } from './LocaleListNodeType';
+export { TextNodeType, TextNodeSchema, type TextNode } from './TextNodeType';
+
+/**
+ * Discriminated union of all component node types
+ * This is the single source of truth for ComponentNode type
+ */
+export type ComponentNode =
+  | HtmlNode
+  | ComponentInstanceNode
+  | SlotMarker
+  | EmbedNode
+  | ObjectLinkNode
+  | LocaleListNode
+  | TextNode;